1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
43
44#include <linux/types.h>
45#include <linux/list.h>
46#include <linux/socket.h>
47#include <linux/ip.h>
48#include <linux/slab.h>
49#include <net/sock.h>
50
51#include <net/sctp/sctp.h>
52#include <net/sctp/sm.h>
53
54
55static int sctp_acked(struct sctp_sackhdr *sack, __u32 tsn);
56static void sctp_check_transmitted(struct sctp_outq *q,
57 struct list_head *transmitted_queue,
58 struct sctp_transport *transport,
59 union sctp_addr *saddr,
60 struct sctp_sackhdr *sack,
61 __u32 *highest_new_tsn);
62
63static void sctp_mark_missing(struct sctp_outq *q,
64 struct list_head *transmitted_queue,
65 struct sctp_transport *transport,
66 __u32 highest_new_tsn,
67 int count_of_newacks);
68
69static void sctp_generate_fwdtsn(struct sctp_outq *q, __u32 sack_ctsn);
70
71static void sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp);
72
73
74static inline void sctp_outq_head_data(struct sctp_outq *q,
75 struct sctp_chunk *ch)
76{
77 list_add(&ch->list, &q->out_chunk_list);
78 q->out_qlen += ch->skb->len;
79}
80
81
82static inline struct sctp_chunk *sctp_outq_dequeue_data(struct sctp_outq *q)
83{
84 struct sctp_chunk *ch = NULL;
85
86 if (!list_empty(&q->out_chunk_list)) {
87 struct list_head *entry = q->out_chunk_list.next;
88
89 ch = list_entry(entry, struct sctp_chunk, list);
90 list_del_init(entry);
91 q->out_qlen -= ch->skb->len;
92 }
93 return ch;
94}
95
96static inline void sctp_outq_tail_data(struct sctp_outq *q,
97 struct sctp_chunk *ch)
98{
99 list_add_tail(&ch->list, &q->out_chunk_list);
100 q->out_qlen += ch->skb->len;
101}
102
103
104
105
106
107
108
109static inline int sctp_cacc_skip_3_1_d(struct sctp_transport *primary,
110 struct sctp_transport *transport,
111 int count_of_newacks)
112{
113 if (count_of_newacks >= 2 && transport != primary)
114 return 1;
115 return 0;
116}
117
118
119
120
121
122
123
124
125static inline int sctp_cacc_skip_3_1_f(struct sctp_transport *transport,
126 int count_of_newacks)
127{
128 if (count_of_newacks < 2 &&
129 (transport && !transport->cacc.cacc_saw_newack))
130 return 1;
131 return 0;
132}
133
134
135
136
137
138
139
140
141static inline int sctp_cacc_skip_3_1(struct sctp_transport *primary,
142 struct sctp_transport *transport,
143 int count_of_newacks)
144{
145 if (!primary->cacc.cycling_changeover) {
146 if (sctp_cacc_skip_3_1_d(primary, transport, count_of_newacks))
147 return 1;
148 if (sctp_cacc_skip_3_1_f(transport, count_of_newacks))
149 return 1;
150 return 0;
151 }
152 return 0;
153}
154
155
156
157
158
159
160
161
162static inline int sctp_cacc_skip_3_2(struct sctp_transport *primary, __u32 tsn)
163{
164 if (primary->cacc.cycling_changeover &&
165 TSN_lt(tsn, primary->cacc.next_tsn_at_change))
166 return 1;
167 return 0;
168}
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184static inline int sctp_cacc_skip(struct sctp_transport *primary,
185 struct sctp_transport *transport,
186 int count_of_newacks,
187 __u32 tsn)
188{
189 if (primary->cacc.changeover_active &&
190 (sctp_cacc_skip_3_1(primary, transport, count_of_newacks) ||
191 sctp_cacc_skip_3_2(primary, tsn)))
192 return 1;
193 return 0;
194}
195
196
197
198
199
200void sctp_outq_init(struct sctp_association *asoc, struct sctp_outq *q)
201{
202 memset(q, 0, sizeof(struct sctp_outq));
203
204 q->asoc = asoc;
205 INIT_LIST_HEAD(&q->out_chunk_list);
206 INIT_LIST_HEAD(&q->control_chunk_list);
207 INIT_LIST_HEAD(&q->retransmit);
208 INIT_LIST_HEAD(&q->sacked);
209 INIT_LIST_HEAD(&q->abandoned);
210}
211
212
213
214static void __sctp_outq_teardown(struct sctp_outq *q)
215{
216 struct sctp_transport *transport;
217 struct list_head *lchunk, *temp;
218 struct sctp_chunk *chunk, *tmp;
219
220
221 list_for_each_entry(transport, &q->asoc->peer.transport_addr_list,
222 transports) {
223 while ((lchunk = sctp_list_dequeue(&transport->transmitted)) != NULL) {
224 chunk = list_entry(lchunk, struct sctp_chunk,
225 transmitted_list);
226
227 sctp_chunk_fail(chunk, q->error);
228 sctp_chunk_free(chunk);
229 }
230 }
231
232
233 list_for_each_safe(lchunk, temp, &q->sacked) {
234 list_del_init(lchunk);
235 chunk = list_entry(lchunk, struct sctp_chunk,
236 transmitted_list);
237 sctp_chunk_fail(chunk, q->error);
238 sctp_chunk_free(chunk);
239 }
240
241
242 list_for_each_safe(lchunk, temp, &q->retransmit) {
243 list_del_init(lchunk);
244 chunk = list_entry(lchunk, struct sctp_chunk,
245 transmitted_list);
246 sctp_chunk_fail(chunk, q->error);
247 sctp_chunk_free(chunk);
248 }
249
250
251 list_for_each_safe(lchunk, temp, &q->abandoned) {
252 list_del_init(lchunk);
253 chunk = list_entry(lchunk, struct sctp_chunk,
254 transmitted_list);
255 sctp_chunk_fail(chunk, q->error);
256 sctp_chunk_free(chunk);
257 }
258
259
260 while ((chunk = sctp_outq_dequeue_data(q)) != NULL) {
261
262
263 sctp_chunk_fail(chunk, q->error);
264 sctp_chunk_free(chunk);
265 }
266
267
268 list_for_each_entry_safe(chunk, tmp, &q->control_chunk_list, list) {
269 list_del_init(&chunk->list);
270 sctp_chunk_free(chunk);
271 }
272}
273
274void sctp_outq_teardown(struct sctp_outq *q)
275{
276 __sctp_outq_teardown(q);
277 sctp_outq_init(q->asoc, q);
278}
279
280
281void sctp_outq_free(struct sctp_outq *q)
282{
283
284 __sctp_outq_teardown(q);
285}
286
287
288void sctp_outq_tail(struct sctp_outq *q, struct sctp_chunk *chunk, gfp_t gfp)
289{
290 struct net *net = sock_net(q->asoc->base.sk);
291
292 pr_debug("%s: outq:%p, chunk:%p[%s]\n", __func__, q, chunk,
293 chunk && chunk->chunk_hdr ?
294 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :
295 "illegal chunk");
296
297
298
299
300 if (sctp_chunk_is_data(chunk)) {
301 pr_debug("%s: outqueueing: outq:%p, chunk:%p[%s])\n",
302 __func__, q, chunk, chunk && chunk->chunk_hdr ?
303 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :
304 "illegal chunk");
305
306 sctp_outq_tail_data(q, chunk);
307 if (chunk->asoc->peer.prsctp_capable &&
308 SCTP_PR_PRIO_ENABLED(chunk->sinfo.sinfo_flags))
309 chunk->asoc->sent_cnt_removable++;
310 if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)
311 SCTP_INC_STATS(net, SCTP_MIB_OUTUNORDERCHUNKS);
312 else
313 SCTP_INC_STATS(net, SCTP_MIB_OUTORDERCHUNKS);
314 } else {
315 list_add_tail(&chunk->list, &q->control_chunk_list);
316 SCTP_INC_STATS(net, SCTP_MIB_OUTCTRLCHUNKS);
317 }
318
319 if (!q->cork)
320 sctp_outq_flush(q, 0, gfp);
321}
322
323
324
325
326static void sctp_insert_list(struct list_head *head, struct list_head *new)
327{
328 struct list_head *pos;
329 struct sctp_chunk *nchunk, *lchunk;
330 __u32 ntsn, ltsn;
331 int done = 0;
332
333 nchunk = list_entry(new, struct sctp_chunk, transmitted_list);
334 ntsn = ntohl(nchunk->subh.data_hdr->tsn);
335
336 list_for_each(pos, head) {
337 lchunk = list_entry(pos, struct sctp_chunk, transmitted_list);
338 ltsn = ntohl(lchunk->subh.data_hdr->tsn);
339 if (TSN_lt(ntsn, ltsn)) {
340 list_add(new, pos->prev);
341 done = 1;
342 break;
343 }
344 }
345 if (!done)
346 list_add_tail(new, head);
347}
348
349static int sctp_prsctp_prune_sent(struct sctp_association *asoc,
350 struct sctp_sndrcvinfo *sinfo,
351 struct list_head *queue, int msg_len)
352{
353 struct sctp_chunk *chk, *temp;
354
355 list_for_each_entry_safe(chk, temp, queue, transmitted_list) {
356 struct sctp_stream_out *streamout;
357
358 if (!SCTP_PR_PRIO_ENABLED(chk->sinfo.sinfo_flags) ||
359 chk->sinfo.sinfo_timetolive <= sinfo->sinfo_timetolive)
360 continue;
361
362 list_del_init(&chk->transmitted_list);
363 sctp_insert_list(&asoc->outqueue.abandoned,
364 &chk->transmitted_list);
365
366 streamout = &asoc->stream.out[chk->sinfo.sinfo_stream];
367 asoc->sent_cnt_removable--;
368 asoc->abandoned_sent[SCTP_PR_INDEX(PRIO)]++;
369 streamout->abandoned_sent[SCTP_PR_INDEX(PRIO)]++;
370
371 if (!chk->tsn_gap_acked) {
372 if (chk->transport)
373 chk->transport->flight_size -=
374 sctp_data_size(chk);
375 asoc->outqueue.outstanding_bytes -= sctp_data_size(chk);
376 }
377
378 msg_len -= SCTP_DATA_SNDSIZE(chk) +
379 sizeof(struct sk_buff) +
380 sizeof(struct sctp_chunk);
381 if (msg_len <= 0)
382 break;
383 }
384
385 return msg_len;
386}
387
388static int sctp_prsctp_prune_unsent(struct sctp_association *asoc,
389 struct sctp_sndrcvinfo *sinfo, int msg_len)
390{
391 struct sctp_outq *q = &asoc->outqueue;
392 struct sctp_chunk *chk, *temp;
393
394 list_for_each_entry_safe(chk, temp, &q->out_chunk_list, list) {
395 if (!SCTP_PR_PRIO_ENABLED(chk->sinfo.sinfo_flags) ||
396 chk->sinfo.sinfo_timetolive <= sinfo->sinfo_timetolive)
397 continue;
398
399 list_del_init(&chk->list);
400 q->out_qlen -= chk->skb->len;
401 asoc->sent_cnt_removable--;
402 asoc->abandoned_unsent[SCTP_PR_INDEX(PRIO)]++;
403 if (chk->sinfo.sinfo_stream < asoc->stream.outcnt) {
404 struct sctp_stream_out *streamout =
405 &asoc->stream.out[chk->sinfo.sinfo_stream];
406
407 streamout->abandoned_unsent[SCTP_PR_INDEX(PRIO)]++;
408 }
409
410 msg_len -= SCTP_DATA_SNDSIZE(chk) +
411 sizeof(struct sk_buff) +
412 sizeof(struct sctp_chunk);
413 sctp_chunk_free(chk);
414 if (msg_len <= 0)
415 break;
416 }
417
418 return msg_len;
419}
420
421
422void sctp_prsctp_prune(struct sctp_association *asoc,
423 struct sctp_sndrcvinfo *sinfo, int msg_len)
424{
425 struct sctp_transport *transport;
426
427 if (!asoc->peer.prsctp_capable || !asoc->sent_cnt_removable)
428 return;
429
430 msg_len = sctp_prsctp_prune_sent(asoc, sinfo,
431 &asoc->outqueue.retransmit,
432 msg_len);
433 if (msg_len <= 0)
434 return;
435
436 list_for_each_entry(transport, &asoc->peer.transport_addr_list,
437 transports) {
438 msg_len = sctp_prsctp_prune_sent(asoc, sinfo,
439 &transport->transmitted,
440 msg_len);
441 if (msg_len <= 0)
442 return;
443 }
444
445 sctp_prsctp_prune_unsent(asoc, sinfo, msg_len);
446}
447
448
449void sctp_retransmit_mark(struct sctp_outq *q,
450 struct sctp_transport *transport,
451 __u8 reason)
452{
453 struct list_head *lchunk, *ltemp;
454 struct sctp_chunk *chunk;
455
456
457 list_for_each_safe(lchunk, ltemp, &transport->transmitted) {
458 chunk = list_entry(lchunk, struct sctp_chunk,
459 transmitted_list);
460
461
462 if (sctp_chunk_abandoned(chunk)) {
463 list_del_init(lchunk);
464 sctp_insert_list(&q->abandoned, lchunk);
465
466
467
468
469
470
471 if (!chunk->tsn_gap_acked) {
472 if (chunk->transport)
473 chunk->transport->flight_size -=
474 sctp_data_size(chunk);
475 q->outstanding_bytes -= sctp_data_size(chunk);
476 q->asoc->peer.rwnd += sctp_data_size(chunk);
477 }
478 continue;
479 }
480
481
482
483
484
485 if ((reason == SCTP_RTXR_FAST_RTX &&
486 (chunk->fast_retransmit == SCTP_NEED_FRTX)) ||
487 (reason != SCTP_RTXR_FAST_RTX && !chunk->tsn_gap_acked)) {
488
489
490
491
492
493
494
495
496 q->asoc->peer.rwnd += sctp_data_size(chunk);
497 q->outstanding_bytes -= sctp_data_size(chunk);
498 if (chunk->transport)
499 transport->flight_size -= sctp_data_size(chunk);
500
501
502
503
504
505
506 chunk->tsn_missing_report = 0;
507
508
509
510
511
512
513
514 if (chunk->rtt_in_progress) {
515 chunk->rtt_in_progress = 0;
516 transport->rto_pending = 0;
517 }
518
519
520
521
522 list_del_init(lchunk);
523 sctp_insert_list(&q->retransmit, lchunk);
524 }
525 }
526
527 pr_debug("%s: transport:%p, reason:%d, cwnd:%d, ssthresh:%d, "
528 "flight_size:%d, pba:%d\n", __func__, transport, reason,
529 transport->cwnd, transport->ssthresh, transport->flight_size,
530 transport->partial_bytes_acked);
531}
532
533
534
535
536void sctp_retransmit(struct sctp_outq *q, struct sctp_transport *transport,
537 sctp_retransmit_reason_t reason)
538{
539 struct net *net = sock_net(q->asoc->base.sk);
540
541 switch (reason) {
542 case SCTP_RTXR_T3_RTX:
543 SCTP_INC_STATS(net, SCTP_MIB_T3_RETRANSMITS);
544 sctp_transport_lower_cwnd(transport, SCTP_LOWER_CWND_T3_RTX);
545
546
547
548 if (transport == transport->asoc->peer.retran_path)
549 sctp_assoc_update_retran_path(transport->asoc);
550 transport->asoc->rtx_data_chunks +=
551 transport->asoc->unack_data;
552 break;
553 case SCTP_RTXR_FAST_RTX:
554 SCTP_INC_STATS(net, SCTP_MIB_FAST_RETRANSMITS);
555 sctp_transport_lower_cwnd(transport, SCTP_LOWER_CWND_FAST_RTX);
556 q->fast_rtx = 1;
557 break;
558 case SCTP_RTXR_PMTUD:
559 SCTP_INC_STATS(net, SCTP_MIB_PMTUD_RETRANSMITS);
560 break;
561 case SCTP_RTXR_T1_RTX:
562 SCTP_INC_STATS(net, SCTP_MIB_T1_RETRANSMITS);
563 transport->asoc->init_retries++;
564 break;
565 default:
566 BUG();
567 }
568
569 sctp_retransmit_mark(q, transport, reason);
570
571
572
573
574
575 if (reason == SCTP_RTXR_T3_RTX)
576 sctp_generate_fwdtsn(q, q->asoc->ctsn_ack_point);
577
578
579
580
581
582 if (reason != SCTP_RTXR_FAST_RTX)
583 sctp_outq_flush(q, 1, GFP_ATOMIC);
584}
585
586
587
588
589
590
591
592
593
594static int sctp_outq_flush_rtx(struct sctp_outq *q, struct sctp_packet *pkt,
595 int rtx_timeout, int *start_timer)
596{
597 struct list_head *lqueue;
598 struct sctp_transport *transport = pkt->transport;
599 sctp_xmit_t status;
600 struct sctp_chunk *chunk, *chunk1;
601 int fast_rtx;
602 int error = 0;
603 int timer = 0;
604 int done = 0;
605
606 lqueue = &q->retransmit;
607 fast_rtx = q->fast_rtx;
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632 list_for_each_entry_safe(chunk, chunk1, lqueue, transmitted_list) {
633
634 if (sctp_chunk_abandoned(chunk)) {
635 list_del_init(&chunk->transmitted_list);
636 sctp_insert_list(&q->abandoned,
637 &chunk->transmitted_list);
638 continue;
639 }
640
641
642
643
644
645
646 if (chunk->tsn_gap_acked) {
647 list_move_tail(&chunk->transmitted_list,
648 &transport->transmitted);
649 continue;
650 }
651
652
653
654
655 if (fast_rtx && !chunk->fast_retransmit)
656 continue;
657
658redo:
659
660 status = sctp_packet_append_chunk(pkt, chunk);
661
662 switch (status) {
663 case SCTP_XMIT_PMTU_FULL:
664 if (!pkt->has_data && !pkt->has_cookie_echo) {
665
666
667
668
669
670
671 sctp_packet_transmit(pkt, GFP_ATOMIC);
672 goto redo;
673 }
674
675
676 error = sctp_packet_transmit(pkt, GFP_ATOMIC);
677
678
679
680
681
682 if (rtx_timeout || fast_rtx)
683 done = 1;
684 else
685 goto redo;
686
687
688 break;
689
690 case SCTP_XMIT_RWND_FULL:
691
692 error = sctp_packet_transmit(pkt, GFP_ATOMIC);
693
694
695
696
697 done = 1;
698 break;
699
700 case SCTP_XMIT_DELAY:
701
702 error = sctp_packet_transmit(pkt, GFP_ATOMIC);
703
704
705 done = 1;
706 break;
707
708 default:
709
710
711
712 list_move_tail(&chunk->transmitted_list,
713 &transport->transmitted);
714
715
716
717
718 if (chunk->fast_retransmit == SCTP_NEED_FRTX)
719 chunk->fast_retransmit = SCTP_DONT_FRTX;
720
721 q->asoc->stats.rtxchunks++;
722 break;
723 }
724
725
726 if (!error && !timer)
727 timer = 1;
728
729 if (done)
730 break;
731 }
732
733
734
735
736
737
738 if (rtx_timeout || fast_rtx) {
739 list_for_each_entry(chunk1, lqueue, transmitted_list) {
740 if (chunk1->fast_retransmit == SCTP_NEED_FRTX)
741 chunk1->fast_retransmit = SCTP_DONT_FRTX;
742 }
743 }
744
745 *start_timer = timer;
746
747
748 if (fast_rtx)
749 q->fast_rtx = 0;
750
751 return error;
752}
753
754
755void sctp_outq_uncork(struct sctp_outq *q, gfp_t gfp)
756{
757 if (q->cork)
758 q->cork = 0;
759
760 sctp_outq_flush(q, 0, gfp);
761}
762
763
764
765
766
767
768
769
770
771
772
773static void sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp)
774{
775 struct sctp_packet *packet;
776 struct sctp_packet singleton;
777 struct sctp_association *asoc = q->asoc;
778 __u16 sport = asoc->base.bind_addr.port;
779 __u16 dport = asoc->peer.port;
780 __u32 vtag = asoc->peer.i.init_tag;
781 struct sctp_transport *transport = NULL;
782 struct sctp_transport *new_transport;
783 struct sctp_chunk *chunk, *tmp;
784 sctp_xmit_t status;
785 int error = 0;
786 int start_timer = 0;
787 int one_packet = 0;
788
789
790 struct list_head transport_list;
791 struct list_head *ltransport;
792
793 INIT_LIST_HEAD(&transport_list);
794 packet = NULL;
795
796
797
798
799
800
801
802
803
804
805
806 list_for_each_entry_safe(chunk, tmp, &q->control_chunk_list, list) {
807
808
809
810
811
812
813 if (asoc->src_out_of_asoc_ok &&
814 chunk->chunk_hdr->type != SCTP_CID_ASCONF)
815 continue;
816
817 list_del_init(&chunk->list);
818
819
820 new_transport = chunk->transport;
821
822 if (!new_transport) {
823
824
825
826
827
828
829
830
831
832
833 if (transport &&
834 sctp_cmp_addr_exact(&chunk->dest,
835 &transport->ipaddr))
836 new_transport = transport;
837 else
838 new_transport = sctp_assoc_lookup_paddr(asoc,
839 &chunk->dest);
840
841
842
843
844 if (!new_transport)
845 new_transport = asoc->peer.active_path;
846 } else if ((new_transport->state == SCTP_INACTIVE) ||
847 (new_transport->state == SCTP_UNCONFIRMED) ||
848 (new_transport->state == SCTP_PF)) {
849
850
851
852
853
854
855
856
857
858
859
860
861
862 if (chunk->chunk_hdr->type != SCTP_CID_HEARTBEAT &&
863 chunk->chunk_hdr->type != SCTP_CID_HEARTBEAT_ACK &&
864 chunk->chunk_hdr->type != SCTP_CID_ASCONF_ACK)
865 new_transport = asoc->peer.active_path;
866 }
867
868
869
870
871 if (new_transport != transport) {
872 transport = new_transport;
873 if (list_empty(&transport->send_ready)) {
874 list_add_tail(&transport->send_ready,
875 &transport_list);
876 }
877 packet = &transport->packet;
878 sctp_packet_config(packet, vtag,
879 asoc->peer.ecn_capable);
880 }
881
882 switch (chunk->chunk_hdr->type) {
883
884
885
886
887
888
889 case SCTP_CID_INIT:
890 case SCTP_CID_INIT_ACK:
891 case SCTP_CID_SHUTDOWN_COMPLETE:
892 sctp_packet_init(&singleton, transport, sport, dport);
893 sctp_packet_config(&singleton, vtag, 0);
894 sctp_packet_append_chunk(&singleton, chunk);
895 error = sctp_packet_transmit(&singleton, gfp);
896 if (error < 0) {
897 asoc->base.sk->sk_err = -error;
898 return;
899 }
900 break;
901
902 case SCTP_CID_ABORT:
903 if (sctp_test_T_bit(chunk)) {
904 packet->vtag = asoc->c.my_vtag;
905 }
906
907
908
909
910
911 case SCTP_CID_HEARTBEAT_ACK:
912 case SCTP_CID_SHUTDOWN_ACK:
913 case SCTP_CID_COOKIE_ACK:
914 case SCTP_CID_COOKIE_ECHO:
915 case SCTP_CID_ERROR:
916 case SCTP_CID_ECN_CWR:
917 case SCTP_CID_ASCONF_ACK:
918 one_packet = 1;
919
920
921 case SCTP_CID_SACK:
922 case SCTP_CID_HEARTBEAT:
923 case SCTP_CID_SHUTDOWN:
924 case SCTP_CID_ECN_ECNE:
925 case SCTP_CID_ASCONF:
926 case SCTP_CID_FWD_TSN:
927 case SCTP_CID_RECONF:
928 status = sctp_packet_transmit_chunk(packet, chunk,
929 one_packet, gfp);
930 if (status != SCTP_XMIT_OK) {
931
932 list_add(&chunk->list, &q->control_chunk_list);
933 break;
934 }
935
936 asoc->stats.octrlchunks++;
937
938
939
940
941 if (chunk->chunk_hdr->type == SCTP_CID_FWD_TSN) {
942 sctp_transport_reset_t3_rtx(transport);
943 transport->last_time_sent = jiffies;
944 }
945
946 if (chunk == asoc->strreset_chunk)
947 sctp_transport_reset_reconf_timer(transport);
948
949 break;
950
951 default:
952
953 BUG();
954 }
955 }
956
957 if (q->asoc->src_out_of_asoc_ok)
958 goto sctp_flush_out;
959
960
961 switch (asoc->state) {
962 case SCTP_STATE_COOKIE_ECHOED:
963
964
965
966 if (!packet || !packet->has_cookie_echo)
967 break;
968
969
970 case SCTP_STATE_ESTABLISHED:
971 case SCTP_STATE_SHUTDOWN_PENDING:
972 case SCTP_STATE_SHUTDOWN_RECEIVED:
973
974
975
976
977
978
979
980
981
982 if (!list_empty(&q->retransmit)) {
983 if (asoc->peer.retran_path->state == SCTP_UNCONFIRMED)
984 goto sctp_flush_out;
985 if (transport == asoc->peer.retran_path)
986 goto retran;
987
988
989
990 transport = asoc->peer.retran_path;
991
992 if (list_empty(&transport->send_ready)) {
993 list_add_tail(&transport->send_ready,
994 &transport_list);
995 }
996
997 packet = &transport->packet;
998 sctp_packet_config(packet, vtag,
999 asoc->peer.ecn_capable);
1000 retran:
1001 error = sctp_outq_flush_rtx(q, packet,
1002 rtx_timeout, &start_timer);
1003 if (error < 0)
1004 asoc->base.sk->sk_err = -error;
1005
1006 if (start_timer) {
1007 sctp_transport_reset_t3_rtx(transport);
1008 transport->last_time_sent = jiffies;
1009 }
1010
1011
1012
1013
1014 if (packet->has_cookie_echo)
1015 goto sctp_flush_out;
1016
1017
1018
1019
1020 if (!list_empty(&q->retransmit))
1021 goto sctp_flush_out;
1022 }
1023
1024
1025
1026
1027
1028
1029 if (transport)
1030 sctp_transport_burst_limited(transport);
1031
1032
1033 while ((chunk = sctp_outq_dequeue_data(q)) != NULL) {
1034 __u32 sid = ntohs(chunk->subh.data_hdr->stream);
1035
1036
1037
1038
1039 if (chunk->sinfo.sinfo_stream >= asoc->stream.outcnt) {
1040
1041
1042 sctp_chunk_fail(chunk, SCTP_ERROR_INV_STRM);
1043 if (asoc->peer.prsctp_capable &&
1044 SCTP_PR_PRIO_ENABLED(chunk->sinfo.sinfo_flags))
1045 asoc->sent_cnt_removable--;
1046 sctp_chunk_free(chunk);
1047 continue;
1048 }
1049
1050
1051 if (sctp_chunk_abandoned(chunk)) {
1052 sctp_chunk_fail(chunk, 0);
1053 sctp_chunk_free(chunk);
1054 continue;
1055 }
1056
1057 if (asoc->stream.out[sid].state == SCTP_STREAM_CLOSED) {
1058 sctp_outq_head_data(q, chunk);
1059 goto sctp_flush_out;
1060 }
1061
1062
1063
1064
1065 new_transport = chunk->transport;
1066 if (!new_transport ||
1067 ((new_transport->state == SCTP_INACTIVE) ||
1068 (new_transport->state == SCTP_UNCONFIRMED) ||
1069 (new_transport->state == SCTP_PF)))
1070 new_transport = asoc->peer.active_path;
1071 if (new_transport->state == SCTP_UNCONFIRMED) {
1072 WARN_ONCE(1, "Attempt to send packet on unconfirmed path.");
1073 sctp_chunk_fail(chunk, 0);
1074 sctp_chunk_free(chunk);
1075 continue;
1076 }
1077
1078
1079 if (new_transport != transport) {
1080 transport = new_transport;
1081
1082
1083
1084
1085 if (list_empty(&transport->send_ready)) {
1086 list_add_tail(&transport->send_ready,
1087 &transport_list);
1088 }
1089
1090 packet = &transport->packet;
1091 sctp_packet_config(packet, vtag,
1092 asoc->peer.ecn_capable);
1093
1094
1095
1096 sctp_transport_burst_limited(transport);
1097 }
1098
1099 pr_debug("%s: outq:%p, chunk:%p[%s], tx-tsn:0x%x skb->head:%p "
1100 "skb->users:%d\n",
1101 __func__, q, chunk, chunk && chunk->chunk_hdr ?
1102 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :
1103 "illegal chunk", ntohl(chunk->subh.data_hdr->tsn),
1104 chunk->skb ? chunk->skb->head : NULL, chunk->skb ?
1105 refcount_read(&chunk->skb->users) : -1);
1106
1107
1108 status = sctp_packet_transmit_chunk(packet, chunk, 0, gfp);
1109
1110 switch (status) {
1111 case SCTP_XMIT_PMTU_FULL:
1112 case SCTP_XMIT_RWND_FULL:
1113 case SCTP_XMIT_DELAY:
1114
1115
1116
1117 pr_debug("%s: could not transmit tsn:0x%x, status:%d\n",
1118 __func__, ntohl(chunk->subh.data_hdr->tsn),
1119 status);
1120
1121 sctp_outq_head_data(q, chunk);
1122 goto sctp_flush_out;
1123
1124 case SCTP_XMIT_OK:
1125
1126
1127
1128
1129 if (asoc->state == SCTP_STATE_SHUTDOWN_PENDING)
1130 chunk->chunk_hdr->flags |= SCTP_DATA_SACK_IMM;
1131 if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)
1132 asoc->stats.ouodchunks++;
1133 else
1134 asoc->stats.oodchunks++;
1135
1136 break;
1137
1138 default:
1139 BUG();
1140 }
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152 list_add_tail(&chunk->transmitted_list,
1153 &transport->transmitted);
1154
1155 sctp_transport_reset_t3_rtx(transport);
1156 transport->last_time_sent = jiffies;
1157
1158
1159
1160
1161 if (packet->has_cookie_echo)
1162 goto sctp_flush_out;
1163 }
1164 break;
1165
1166 default:
1167
1168 break;
1169 }
1170
1171sctp_flush_out:
1172
1173
1174
1175
1176
1177
1178
1179
1180 while ((ltransport = sctp_list_dequeue(&transport_list)) != NULL) {
1181 struct sctp_transport *t = list_entry(ltransport,
1182 struct sctp_transport,
1183 send_ready);
1184 packet = &t->packet;
1185 if (!sctp_packet_empty(packet)) {
1186 error = sctp_packet_transmit(packet, gfp);
1187 if (error < 0)
1188 asoc->base.sk->sk_err = -error;
1189 }
1190
1191
1192 sctp_transport_burst_reset(t);
1193 }
1194}
1195
1196
1197static void sctp_sack_update_unack_data(struct sctp_association *assoc,
1198 struct sctp_sackhdr *sack)
1199{
1200 sctp_sack_variable_t *frags;
1201 __u16 unack_data;
1202 int i;
1203
1204 unack_data = assoc->next_tsn - assoc->ctsn_ack_point - 1;
1205
1206 frags = sack->variable;
1207 for (i = 0; i < ntohs(sack->num_gap_ack_blocks); i++) {
1208 unack_data -= ((ntohs(frags[i].gab.end) -
1209 ntohs(frags[i].gab.start) + 1));
1210 }
1211
1212 assoc->unack_data = unack_data;
1213}
1214
1215
1216
1217
1218
1219
1220int sctp_outq_sack(struct sctp_outq *q, struct sctp_chunk *chunk)
1221{
1222 struct sctp_association *asoc = q->asoc;
1223 struct sctp_sackhdr *sack = chunk->subh.sack_hdr;
1224 struct sctp_transport *transport;
1225 struct sctp_chunk *tchunk = NULL;
1226 struct list_head *lchunk, *transport_list, *temp;
1227 sctp_sack_variable_t *frags = sack->variable;
1228 __u32 sack_ctsn, ctsn, tsn;
1229 __u32 highest_tsn, highest_new_tsn;
1230 __u32 sack_a_rwnd;
1231 unsigned int outstanding;
1232 struct sctp_transport *primary = asoc->peer.primary_path;
1233 int count_of_newacks = 0;
1234 int gap_ack_blocks;
1235 u8 accum_moved = 0;
1236
1237
1238 transport_list = &asoc->peer.transport_addr_list;
1239
1240 sack_ctsn = ntohl(sack->cum_tsn_ack);
1241 gap_ack_blocks = ntohs(sack->num_gap_ack_blocks);
1242 asoc->stats.gapcnt += gap_ack_blocks;
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261 if (primary->cacc.changeover_active) {
1262 u8 clear_cycling = 0;
1263
1264 if (TSN_lte(primary->cacc.next_tsn_at_change, sack_ctsn)) {
1265 primary->cacc.changeover_active = 0;
1266 clear_cycling = 1;
1267 }
1268
1269 if (clear_cycling || gap_ack_blocks) {
1270 list_for_each_entry(transport, transport_list,
1271 transports) {
1272 if (clear_cycling)
1273 transport->cacc.cycling_changeover = 0;
1274 if (gap_ack_blocks)
1275 transport->cacc.cacc_saw_newack = 0;
1276 }
1277 }
1278 }
1279
1280
1281 highest_tsn = sack_ctsn;
1282 if (gap_ack_blocks)
1283 highest_tsn += ntohs(frags[gap_ack_blocks - 1].gab.end);
1284
1285 if (TSN_lt(asoc->highest_sacked, highest_tsn))
1286 asoc->highest_sacked = highest_tsn;
1287
1288 highest_new_tsn = sack_ctsn;
1289
1290
1291
1292
1293 sctp_check_transmitted(q, &q->retransmit, NULL, NULL, sack, &highest_new_tsn);
1294
1295
1296
1297
1298
1299
1300 list_for_each_entry(transport, transport_list, transports) {
1301 sctp_check_transmitted(q, &transport->transmitted,
1302 transport, &chunk->source, sack,
1303 &highest_new_tsn);
1304
1305
1306
1307
1308
1309 if (transport->cacc.cacc_saw_newack)
1310 count_of_newacks++;
1311 }
1312
1313
1314 if (TSN_lt(asoc->ctsn_ack_point, sack_ctsn)) {
1315 asoc->ctsn_ack_point = sack_ctsn;
1316 accum_moved = 1;
1317 }
1318
1319 if (gap_ack_blocks) {
1320
1321 if (asoc->fast_recovery && accum_moved)
1322 highest_new_tsn = highest_tsn;
1323
1324 list_for_each_entry(transport, transport_list, transports)
1325 sctp_mark_missing(q, &transport->transmitted, transport,
1326 highest_new_tsn, count_of_newacks);
1327 }
1328
1329
1330 sctp_sack_update_unack_data(asoc, sack);
1331
1332 ctsn = asoc->ctsn_ack_point;
1333
1334
1335 list_for_each_safe(lchunk, temp, &q->sacked) {
1336 tchunk = list_entry(lchunk, struct sctp_chunk,
1337 transmitted_list);
1338 tsn = ntohl(tchunk->subh.data_hdr->tsn);
1339 if (TSN_lte(tsn, ctsn)) {
1340 list_del_init(&tchunk->transmitted_list);
1341 if (asoc->peer.prsctp_capable &&
1342 SCTP_PR_PRIO_ENABLED(chunk->sinfo.sinfo_flags))
1343 asoc->sent_cnt_removable--;
1344 sctp_chunk_free(tchunk);
1345 }
1346 }
1347
1348
1349
1350
1351
1352
1353 sack_a_rwnd = ntohl(sack->a_rwnd);
1354 asoc->peer.zero_window_announced = !sack_a_rwnd;
1355 outstanding = q->outstanding_bytes;
1356
1357 if (outstanding < sack_a_rwnd)
1358 sack_a_rwnd -= outstanding;
1359 else
1360 sack_a_rwnd = 0;
1361
1362 asoc->peer.rwnd = sack_a_rwnd;
1363
1364 sctp_generate_fwdtsn(q, sack_ctsn);
1365
1366 pr_debug("%s: sack cumulative tsn ack:0x%x\n", __func__, sack_ctsn);
1367 pr_debug("%s: cumulative tsn ack of assoc:%p is 0x%x, "
1368 "advertised peer ack point:0x%x\n", __func__, asoc, ctsn,
1369 asoc->adv_peer_ack_point);
1370
1371 return sctp_outq_is_empty(q);
1372}
1373
1374
1375
1376
1377
1378int sctp_outq_is_empty(const struct sctp_outq *q)
1379{
1380 return q->out_qlen == 0 && q->outstanding_bytes == 0 &&
1381 list_empty(&q->retransmit);
1382}
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398static void sctp_check_transmitted(struct sctp_outq *q,
1399 struct list_head *transmitted_queue,
1400 struct sctp_transport *transport,
1401 union sctp_addr *saddr,
1402 struct sctp_sackhdr *sack,
1403 __u32 *highest_new_tsn_in_sack)
1404{
1405 struct list_head *lchunk;
1406 struct sctp_chunk *tchunk;
1407 struct list_head tlist;
1408 __u32 tsn;
1409 __u32 sack_ctsn;
1410 __u32 rtt;
1411 __u8 restart_timer = 0;
1412 int bytes_acked = 0;
1413 int migrate_bytes = 0;
1414 bool forward_progress = false;
1415
1416 sack_ctsn = ntohl(sack->cum_tsn_ack);
1417
1418 INIT_LIST_HEAD(&tlist);
1419
1420
1421 while (NULL != (lchunk = sctp_list_dequeue(transmitted_queue))) {
1422 tchunk = list_entry(lchunk, struct sctp_chunk,
1423 transmitted_list);
1424
1425 if (sctp_chunk_abandoned(tchunk)) {
1426
1427 sctp_insert_list(&q->abandoned, lchunk);
1428
1429
1430
1431
1432 if (!tchunk->tsn_gap_acked) {
1433 if (tchunk->transport)
1434 tchunk->transport->flight_size -=
1435 sctp_data_size(tchunk);
1436 q->outstanding_bytes -= sctp_data_size(tchunk);
1437 }
1438 continue;
1439 }
1440
1441 tsn = ntohl(tchunk->subh.data_hdr->tsn);
1442 if (sctp_acked(sack, tsn)) {
1443
1444
1445
1446
1447
1448 if (transport) {
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460 if (!tchunk->tsn_gap_acked &&
1461 !sctp_chunk_retransmitted(tchunk) &&
1462 tchunk->rtt_in_progress) {
1463 tchunk->rtt_in_progress = 0;
1464 rtt = jiffies - tchunk->sent_at;
1465 sctp_transport_update_rto(transport,
1466 rtt);
1467 }
1468 }
1469
1470
1471
1472
1473
1474
1475
1476 if (!tchunk->tsn_gap_acked) {
1477 tchunk->tsn_gap_acked = 1;
1478 if (TSN_lt(*highest_new_tsn_in_sack, tsn))
1479 *highest_new_tsn_in_sack = tsn;
1480 bytes_acked += sctp_data_size(tchunk);
1481 if (!tchunk->transport)
1482 migrate_bytes += sctp_data_size(tchunk);
1483 forward_progress = true;
1484 }
1485
1486 if (TSN_lte(tsn, sack_ctsn)) {
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496 restart_timer = 1;
1497 forward_progress = true;
1498
1499 if (!tchunk->tsn_gap_acked) {
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513 if (transport &&
1514 sack->num_gap_ack_blocks &&
1515 q->asoc->peer.primary_path->cacc.
1516 changeover_active)
1517 transport->cacc.cacc_saw_newack
1518 = 1;
1519 }
1520
1521 list_add_tail(&tchunk->transmitted_list,
1522 &q->sacked);
1523 } else {
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539 list_add_tail(lchunk, &tlist);
1540 }
1541 } else {
1542 if (tchunk->tsn_gap_acked) {
1543 pr_debug("%s: receiver reneged on data TSN:0x%x\n",
1544 __func__, tsn);
1545
1546 tchunk->tsn_gap_acked = 0;
1547
1548 if (tchunk->transport)
1549 bytes_acked -= sctp_data_size(tchunk);
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560 restart_timer = 1;
1561 }
1562
1563 list_add_tail(lchunk, &tlist);
1564 }
1565 }
1566
1567 if (transport) {
1568 if (bytes_acked) {
1569 struct sctp_association *asoc = transport->asoc;
1570
1571
1572
1573
1574
1575
1576
1577 bytes_acked -= migrate_bytes;
1578
1579
1580
1581
1582
1583
1584
1585
1586 transport->error_count = 0;
1587 transport->asoc->overall_error_count = 0;
1588 forward_progress = true;
1589
1590
1591
1592
1593
1594
1595
1596 if (asoc->state == SCTP_STATE_SHUTDOWN_PENDING &&
1597 del_timer(&asoc->timers
1598 [SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]))
1599 sctp_association_put(asoc);
1600
1601
1602
1603
1604 if ((transport->state == SCTP_INACTIVE ||
1605 transport->state == SCTP_UNCONFIRMED) &&
1606 sctp_cmp_addr_exact(&transport->ipaddr, saddr)) {
1607 sctp_assoc_control_transport(
1608 transport->asoc,
1609 transport,
1610 SCTP_TRANSPORT_UP,
1611 SCTP_RECEIVED_SACK);
1612 }
1613
1614 sctp_transport_raise_cwnd(transport, sack_ctsn,
1615 bytes_acked);
1616
1617 transport->flight_size -= bytes_acked;
1618 if (transport->flight_size == 0)
1619 transport->partial_bytes_acked = 0;
1620 q->outstanding_bytes -= bytes_acked + migrate_bytes;
1621 } else {
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636 if (!q->asoc->peer.rwnd &&
1637 !list_empty(&tlist) &&
1638 (sack_ctsn+2 == q->asoc->next_tsn) &&
1639 q->asoc->state < SCTP_STATE_SHUTDOWN_PENDING) {
1640 pr_debug("%s: sack received for zero window "
1641 "probe:%u\n", __func__, sack_ctsn);
1642
1643 q->asoc->overall_error_count = 0;
1644 transport->error_count = 0;
1645 }
1646 }
1647
1648
1649
1650
1651
1652
1653
1654 if (!transport->flight_size) {
1655 if (del_timer(&transport->T3_rtx_timer))
1656 sctp_transport_put(transport);
1657 } else if (restart_timer) {
1658 if (!mod_timer(&transport->T3_rtx_timer,
1659 jiffies + transport->rto))
1660 sctp_transport_hold(transport);
1661 }
1662
1663 if (forward_progress) {
1664 if (transport->dst)
1665 sctp_transport_dst_confirm(transport);
1666 }
1667 }
1668
1669 list_splice(&tlist, transmitted_queue);
1670}
1671
1672
1673static void sctp_mark_missing(struct sctp_outq *q,
1674 struct list_head *transmitted_queue,
1675 struct sctp_transport *transport,
1676 __u32 highest_new_tsn_in_sack,
1677 int count_of_newacks)
1678{
1679 struct sctp_chunk *chunk;
1680 __u32 tsn;
1681 char do_fast_retransmit = 0;
1682 struct sctp_association *asoc = q->asoc;
1683 struct sctp_transport *primary = asoc->peer.primary_path;
1684
1685 list_for_each_entry(chunk, transmitted_queue, transmitted_list) {
1686
1687 tsn = ntohl(chunk->subh.data_hdr->tsn);
1688
1689
1690
1691
1692
1693
1694
1695
1696 if (chunk->fast_retransmit == SCTP_CAN_FRTX &&
1697 !chunk->tsn_gap_acked &&
1698 TSN_lt(tsn, highest_new_tsn_in_sack)) {
1699
1700
1701
1702
1703 if (!transport || !sctp_cacc_skip(primary,
1704 chunk->transport,
1705 count_of_newacks, tsn)) {
1706 chunk->tsn_missing_report++;
1707
1708 pr_debug("%s: tsn:0x%x missing counter:%d\n",
1709 __func__, tsn, chunk->tsn_missing_report);
1710 }
1711 }
1712
1713
1714
1715
1716
1717
1718
1719 if (chunk->tsn_missing_report >= 3) {
1720 chunk->fast_retransmit = SCTP_NEED_FRTX;
1721 do_fast_retransmit = 1;
1722 }
1723 }
1724
1725 if (transport) {
1726 if (do_fast_retransmit)
1727 sctp_retransmit(q, transport, SCTP_RTXR_FAST_RTX);
1728
1729 pr_debug("%s: transport:%p, cwnd:%d, ssthresh:%d, "
1730 "flight_size:%d, pba:%d\n", __func__, transport,
1731 transport->cwnd, transport->ssthresh,
1732 transport->flight_size, transport->partial_bytes_acked);
1733 }
1734}
1735
1736
1737static int sctp_acked(struct sctp_sackhdr *sack, __u32 tsn)
1738{
1739 int i;
1740 sctp_sack_variable_t *frags;
1741 __u16 tsn_offset, blocks;
1742 __u32 ctsn = ntohl(sack->cum_tsn_ack);
1743
1744 if (TSN_lte(tsn, ctsn))
1745 goto pass;
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759 frags = sack->variable;
1760 blocks = ntohs(sack->num_gap_ack_blocks);
1761 tsn_offset = tsn - ctsn;
1762 for (i = 0; i < blocks; ++i) {
1763 if (tsn_offset >= ntohs(frags[i].gab.start) &&
1764 tsn_offset <= ntohs(frags[i].gab.end))
1765 goto pass;
1766 }
1767
1768 return 0;
1769pass:
1770 return 1;
1771}
1772
1773static inline int sctp_get_skip_pos(struct sctp_fwdtsn_skip *skiplist,
1774 int nskips, __be16 stream)
1775{
1776 int i;
1777
1778 for (i = 0; i < nskips; i++) {
1779 if (skiplist[i].stream == stream)
1780 return i;
1781 }
1782 return i;
1783}
1784
1785
1786static void sctp_generate_fwdtsn(struct sctp_outq *q, __u32 ctsn)
1787{
1788 struct sctp_association *asoc = q->asoc;
1789 struct sctp_chunk *ftsn_chunk = NULL;
1790 struct sctp_fwdtsn_skip ftsn_skip_arr[10];
1791 int nskips = 0;
1792 int skip_pos = 0;
1793 __u32 tsn;
1794 struct sctp_chunk *chunk;
1795 struct list_head *lchunk, *temp;
1796
1797 if (!asoc->peer.prsctp_capable)
1798 return;
1799
1800
1801
1802
1803
1804
1805
1806 if (TSN_lt(asoc->adv_peer_ack_point, ctsn))
1807 asoc->adv_peer_ack_point = ctsn;
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830 list_for_each_safe(lchunk, temp, &q->abandoned) {
1831 chunk = list_entry(lchunk, struct sctp_chunk,
1832 transmitted_list);
1833 tsn = ntohl(chunk->subh.data_hdr->tsn);
1834
1835
1836
1837
1838 if (TSN_lte(tsn, ctsn)) {
1839 list_del_init(lchunk);
1840 sctp_chunk_free(chunk);
1841 } else {
1842 if (TSN_lte(tsn, asoc->adv_peer_ack_point+1)) {
1843 asoc->adv_peer_ack_point = tsn;
1844 if (chunk->chunk_hdr->flags &
1845 SCTP_DATA_UNORDERED)
1846 continue;
1847 skip_pos = sctp_get_skip_pos(&ftsn_skip_arr[0],
1848 nskips,
1849 chunk->subh.data_hdr->stream);
1850 ftsn_skip_arr[skip_pos].stream =
1851 chunk->subh.data_hdr->stream;
1852 ftsn_skip_arr[skip_pos].ssn =
1853 chunk->subh.data_hdr->ssn;
1854 if (skip_pos == nskips)
1855 nskips++;
1856 if (nskips == 10)
1857 break;
1858 } else
1859 break;
1860 }
1861 }
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881 if (asoc->adv_peer_ack_point > ctsn)
1882 ftsn_chunk = sctp_make_fwdtsn(asoc, asoc->adv_peer_ack_point,
1883 nskips, &ftsn_skip_arr[0]);
1884
1885 if (ftsn_chunk) {
1886 list_add_tail(&ftsn_chunk->list, &q->control_chunk_list);
1887 SCTP_INC_STATS(sock_net(asoc->base.sk), SCTP_MIB_OUTCTRLCHUNKS);
1888 }
1889}
1890