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
43
44#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
45
46#include <linux/types.h>
47#include <linux/kernel.h>
48#include <linux/wait.h>
49#include <linux/time.h>
50#include <linux/ip.h>
51#include <linux/ipv6.h>
52#include <linux/init.h>
53#include <linux/slab.h>
54#include <net/inet_ecn.h>
55#include <net/ip.h>
56#include <net/icmp.h>
57#include <net/net_namespace.h>
58
59#include <linux/socket.h>
60#include <net/sock.h>
61
62#include <net/sctp/sctp.h>
63#include <net/sctp/sm.h>
64#include <net/sctp/checksum.h>
65
66
67static sctp_xmit_t sctp_packet_can_append_data(struct sctp_packet *packet,
68 struct sctp_chunk *chunk);
69static void sctp_packet_append_data(struct sctp_packet *packet,
70 struct sctp_chunk *chunk);
71static sctp_xmit_t sctp_packet_will_fit(struct sctp_packet *packet,
72 struct sctp_chunk *chunk,
73 u16 chunk_len);
74
75static void sctp_packet_reset(struct sctp_packet *packet)
76{
77 packet->size = packet->overhead;
78 packet->has_cookie_echo = 0;
79 packet->has_sack = 0;
80 packet->has_data = 0;
81 packet->has_auth = 0;
82 packet->ipfragok = 0;
83 packet->auth = NULL;
84}
85
86
87
88
89struct sctp_packet *sctp_packet_config(struct sctp_packet *packet,
90 __u32 vtag, int ecn_capable)
91{
92 struct sctp_chunk *chunk = NULL;
93
94 SCTP_DEBUG_PRINTK("%s: packet:%p vtag:0x%x\n", __func__,
95 packet, vtag);
96
97 packet->vtag = vtag;
98
99 if (ecn_capable && sctp_packet_empty(packet)) {
100 chunk = sctp_get_ecne_prepend(packet->transport->asoc);
101
102
103
104
105 if (chunk)
106 sctp_packet_append_chunk(packet, chunk);
107 }
108
109 return packet;
110}
111
112
113struct sctp_packet *sctp_packet_init(struct sctp_packet *packet,
114 struct sctp_transport *transport,
115 __u16 sport, __u16 dport)
116{
117 struct sctp_association *asoc = transport->asoc;
118 size_t overhead;
119
120 SCTP_DEBUG_PRINTK("%s: packet:%p transport:%p\n", __func__,
121 packet, transport);
122
123 packet->transport = transport;
124 packet->source_port = sport;
125 packet->destination_port = dport;
126 INIT_LIST_HEAD(&packet->chunk_list);
127 if (asoc) {
128 struct sctp_sock *sp = sctp_sk(asoc->base.sk);
129 overhead = sp->pf->af->net_header_len;
130 } else {
131 overhead = sizeof(struct ipv6hdr);
132 }
133 overhead += sizeof(struct sctphdr);
134 packet->overhead = overhead;
135 sctp_packet_reset(packet);
136 packet->vtag = 0;
137 packet->malloced = 0;
138 return packet;
139}
140
141
142void sctp_packet_free(struct sctp_packet *packet)
143{
144 struct sctp_chunk *chunk, *tmp;
145
146 SCTP_DEBUG_PRINTK("%s: packet:%p\n", __func__, packet);
147
148 list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {
149 list_del_init(&chunk->list);
150 sctp_chunk_free(chunk);
151 }
152
153 if (packet->malloced)
154 kfree(packet);
155}
156
157
158
159
160
161
162
163
164sctp_xmit_t sctp_packet_transmit_chunk(struct sctp_packet *packet,
165 struct sctp_chunk *chunk,
166 int one_packet)
167{
168 sctp_xmit_t retval;
169 int error = 0;
170
171 SCTP_DEBUG_PRINTK("%s: packet:%p chunk:%p\n", __func__,
172 packet, chunk);
173
174 switch ((retval = (sctp_packet_append_chunk(packet, chunk)))) {
175 case SCTP_XMIT_PMTU_FULL:
176 if (!packet->has_cookie_echo) {
177 error = sctp_packet_transmit(packet);
178 if (error < 0)
179 chunk->skb->sk->sk_err = -error;
180
181
182
183
184 if (!one_packet)
185 retval = sctp_packet_append_chunk(packet,
186 chunk);
187 }
188 break;
189
190 case SCTP_XMIT_RWND_FULL:
191 case SCTP_XMIT_OK:
192 case SCTP_XMIT_NAGLE_DELAY:
193 break;
194 }
195
196 return retval;
197}
198
199
200static sctp_xmit_t sctp_packet_bundle_auth(struct sctp_packet *pkt,
201 struct sctp_chunk *chunk)
202{
203 struct sctp_association *asoc = pkt->transport->asoc;
204 struct sctp_chunk *auth;
205 sctp_xmit_t retval = SCTP_XMIT_OK;
206
207
208 if (!asoc)
209 return retval;
210
211
212
213
214 if (chunk->chunk_hdr->type == SCTP_CID_AUTH || pkt->has_auth)
215 return retval;
216
217
218
219
220 if (!chunk->auth)
221 return retval;
222
223 auth = sctp_make_auth(asoc);
224 if (!auth)
225 return retval;
226
227 retval = sctp_packet_append_chunk(pkt, auth);
228
229 return retval;
230}
231
232
233static sctp_xmit_t sctp_packet_bundle_sack(struct sctp_packet *pkt,
234 struct sctp_chunk *chunk)
235{
236 sctp_xmit_t retval = SCTP_XMIT_OK;
237
238
239
240
241 if (sctp_chunk_is_data(chunk) && !pkt->has_sack &&
242 !pkt->has_cookie_echo) {
243 struct sctp_association *asoc;
244 struct timer_list *timer;
245 asoc = pkt->transport->asoc;
246 timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK];
247
248
249 if (timer_pending(timer)) {
250 struct sctp_chunk *sack;
251 asoc->a_rwnd = asoc->rwnd;
252 sack = sctp_make_sack(asoc);
253 if (sack) {
254 retval = sctp_packet_append_chunk(pkt, sack);
255 asoc->peer.sack_needed = 0;
256 if (del_timer(timer))
257 sctp_association_put(asoc);
258 }
259 }
260 }
261 return retval;
262}
263
264
265
266
267sctp_xmit_t sctp_packet_append_chunk(struct sctp_packet *packet,
268 struct sctp_chunk *chunk)
269{
270 sctp_xmit_t retval = SCTP_XMIT_OK;
271 __u16 chunk_len = WORD_ROUND(ntohs(chunk->chunk_hdr->length));
272
273 SCTP_DEBUG_PRINTK("%s: packet:%p chunk:%p\n", __func__, packet,
274 chunk);
275
276
277
278
279
280 if (sctp_chunk_is_data(chunk)) {
281 retval = sctp_packet_can_append_data(packet, chunk);
282 if (retval != SCTP_XMIT_OK)
283 goto finish;
284 }
285
286
287 retval = sctp_packet_bundle_auth(packet, chunk);
288 if (retval != SCTP_XMIT_OK)
289 goto finish;
290
291
292 retval = sctp_packet_bundle_sack(packet, chunk);
293 if (retval != SCTP_XMIT_OK)
294 goto finish;
295
296
297 retval = sctp_packet_will_fit(packet, chunk, chunk_len);
298 if (retval != SCTP_XMIT_OK)
299 goto finish;
300
301
302 switch (chunk->chunk_hdr->type) {
303 case SCTP_CID_DATA:
304
305 sctp_packet_append_data(packet, chunk);
306
307 packet->has_sack = 1;
308
309 packet->has_auth = 1;
310
311 packet->has_data = 1;
312
313 chunk->sent_at = jiffies;
314 break;
315 case SCTP_CID_COOKIE_ECHO:
316 packet->has_cookie_echo = 1;
317 break;
318
319 case SCTP_CID_SACK:
320 packet->has_sack = 1;
321 break;
322
323 case SCTP_CID_AUTH:
324 packet->has_auth = 1;
325 packet->auth = chunk;
326 break;
327 }
328
329
330 list_add_tail(&chunk->list, &packet->chunk_list);
331 packet->size += chunk_len;
332 chunk->transport = packet->transport;
333finish:
334 return retval;
335}
336
337
338
339
340
341
342int sctp_packet_transmit(struct sctp_packet *packet)
343{
344 struct sctp_transport *tp = packet->transport;
345 struct sctp_association *asoc = tp->asoc;
346 struct sctphdr *sh;
347 struct sk_buff *nskb;
348 struct sctp_chunk *chunk, *tmp;
349 struct sock *sk;
350 int err = 0;
351 int padding;
352 __u8 has_data = 0;
353 struct dst_entry *dst = tp->dst;
354 unsigned char *auth = NULL;
355 __u32 cksum_buf_len = sizeof(struct sctphdr);
356
357 SCTP_DEBUG_PRINTK("%s: packet:%p\n", __func__, packet);
358
359
360 if (list_empty(&packet->chunk_list))
361 return err;
362
363
364 chunk = list_entry(packet->chunk_list.next, struct sctp_chunk, list);
365 sk = chunk->skb->sk;
366
367
368 nskb = alloc_skb(packet->size + LL_MAX_HEADER, GFP_ATOMIC);
369 if (!nskb)
370 goto nomem;
371
372
373 skb_reserve(nskb, packet->overhead + LL_MAX_HEADER);
374
375
376
377
378 skb_set_owner_w(nskb, sk);
379
380
381 if (!dst || (dst->obsolete > 1)) {
382 dst_release(dst);
383 sctp_transport_route(tp, NULL, sctp_sk(sk));
384 if (asoc && (asoc->param_flags & SPP_PMTUD_ENABLE)) {
385 sctp_assoc_sync_pmtu(asoc);
386 }
387 }
388 dst = dst_clone(tp->dst);
389 skb_dst_set(nskb, dst);
390 if (!dst)
391 goto no_route;
392
393
394 sh = (struct sctphdr *)skb_push(nskb, sizeof(struct sctphdr));
395 skb_reset_transport_header(nskb);
396 sh->source = htons(packet->source_port);
397 sh->dest = htons(packet->destination_port);
398
399
400
401
402
403
404
405
406
407 sh->vtag = htonl(packet->vtag);
408 sh->checksum = 0;
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429 SCTP_DEBUG_PRINTK("***sctp_transmit_packet***\n");
430 list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {
431 list_del_init(&chunk->list);
432 if (sctp_chunk_is_data(chunk)) {
433
434
435
436
437
438
439
440 if (!tp->rto_pending) {
441 chunk->rtt_in_progress = 1;
442 tp->rto_pending = 1;
443 }
444 has_data = 1;
445 }
446
447 padding = WORD_ROUND(chunk->skb->len) - chunk->skb->len;
448 if (padding)
449 memset(skb_put(chunk->skb, padding), 0, padding);
450
451
452
453
454
455 if (chunk == packet->auth)
456 auth = skb_tail_pointer(nskb);
457
458 cksum_buf_len += chunk->skb->len;
459 memcpy(skb_put(nskb, chunk->skb->len),
460 chunk->skb->data, chunk->skb->len);
461
462 SCTP_DEBUG_PRINTK("%s %p[%s] %s 0x%x, %s %d, %s %d, %s %d\n",
463 "*** Chunk", chunk,
464 sctp_cname(SCTP_ST_CHUNK(
465 chunk->chunk_hdr->type)),
466 chunk->has_tsn ? "TSN" : "No TSN",
467 chunk->has_tsn ?
468 ntohl(chunk->subh.data_hdr->tsn) : 0,
469 "length", ntohs(chunk->chunk_hdr->length),
470 "chunk->skb->len", chunk->skb->len,
471 "rtt_in_progress", chunk->rtt_in_progress);
472
473
474
475
476
477
478 if (!sctp_chunk_is_data(chunk))
479 sctp_chunk_free(chunk);
480 }
481
482
483
484
485
486
487
488
489
490
491 if (auth)
492 sctp_auth_calculate_hmac(asoc, nskb,
493 (struct sctp_auth_chunk *)auth,
494 GFP_ATOMIC);
495
496
497
498
499
500
501
502
503 if (!sctp_checksum_disable &&
504 !(dst->dev->features & (NETIF_F_NO_CSUM | NETIF_F_SCTP_CSUM))) {
505 __u32 crc32 = sctp_start_cksum((__u8 *)sh, cksum_buf_len);
506
507
508
509
510 sh->checksum = sctp_end_cksum(crc32);
511 } else {
512 if (dst->dev->features & NETIF_F_SCTP_CSUM) {
513
514 nskb->ip_summed = CHECKSUM_PARTIAL;
515 nskb->csum_start = (skb_transport_header(nskb) -
516 nskb->head);
517 nskb->csum_offset = offsetof(struct sctphdr, checksum);
518 } else {
519 nskb->ip_summed = CHECKSUM_UNNECESSARY;
520 }
521 }
522
523
524
525
526
527
528
529
530
531
532
533
534
535 (*tp->af_specific->ecn_capable)(nskb->sk);
536
537
538
539
540
541
542
543 if (asoc && asoc->peer.last_sent_to != tp) {
544
545
546
547 asoc->peer.last_sent_to = tp;
548 }
549
550 if (has_data) {
551 struct timer_list *timer;
552 unsigned long timeout;
553
554
555 if (sctp_state(asoc, ESTABLISHED) && asoc->autoclose) {
556 timer = &asoc->timers[SCTP_EVENT_TIMEOUT_AUTOCLOSE];
557 timeout = asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE];
558
559 if (!mod_timer(timer, jiffies + timeout))
560 sctp_association_hold(asoc);
561 }
562 }
563
564 SCTP_DEBUG_PRINTK("***sctp_transmit_packet*** skb len %d\n",
565 nskb->len);
566
567 nskb->local_df = packet->ipfragok;
568 (*tp->af_specific->sctp_xmit)(nskb, tp);
569
570out:
571 sctp_packet_reset(packet);
572 return err;
573no_route:
574 kfree_skb(nskb);
575 IP_INC_STATS_BH(&init_net, IPSTATS_MIB_OUTNOROUTES);
576
577
578
579
580
581
582
583
584
585err:
586
587
588
589
590 list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {
591 list_del_init(&chunk->list);
592 if (!sctp_chunk_is_data(chunk))
593 sctp_chunk_free(chunk);
594 }
595 goto out;
596nomem:
597 err = -ENOMEM;
598 goto err;
599}
600
601
602
603
604
605
606static sctp_xmit_t sctp_packet_can_append_data(struct sctp_packet *packet,
607 struct sctp_chunk *chunk)
608{
609 sctp_xmit_t retval = SCTP_XMIT_OK;
610 size_t datasize, rwnd, inflight, flight_size;
611 struct sctp_transport *transport = packet->transport;
612 struct sctp_association *asoc = transport->asoc;
613 struct sctp_outq *q = &asoc->outqueue;
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628 rwnd = asoc->peer.rwnd;
629 inflight = q->outstanding_bytes;
630 flight_size = transport->flight_size;
631
632 datasize = sctp_data_size(chunk);
633
634 if (datasize > rwnd) {
635 if (inflight > 0) {
636
637
638
639 retval = SCTP_XMIT_RWND_FULL;
640 goto finish;
641 }
642 }
643
644
645
646
647
648
649
650
651
652
653
654
655
656 if (chunk->fast_retransmit != SCTP_NEED_FRTX)
657 if (flight_size >= transport->cwnd) {
658 retval = SCTP_XMIT_RWND_FULL;
659 goto finish;
660 }
661
662
663
664
665
666
667 if (!sctp_sk(asoc->base.sk)->nodelay && sctp_packet_empty(packet) &&
668 inflight && sctp_state(asoc, ESTABLISHED)) {
669 unsigned max = transport->pathmtu - packet->overhead;
670 unsigned len = chunk->skb->len + q->out_qlen;
671
672
673
674
675
676
677
678 if ((len < max) && chunk->msg->can_delay) {
679 retval = SCTP_XMIT_NAGLE_DELAY;
680 goto finish;
681 }
682 }
683
684finish:
685 return retval;
686}
687
688
689static void sctp_packet_append_data(struct sctp_packet *packet,
690 struct sctp_chunk *chunk)
691{
692 struct sctp_transport *transport = packet->transport;
693 size_t datasize = sctp_data_size(chunk);
694 struct sctp_association *asoc = transport->asoc;
695 u32 rwnd = asoc->peer.rwnd;
696
697
698 transport->flight_size += datasize;
699
700
701 asoc->outqueue.outstanding_bytes += datasize;
702
703
704
705
706
707
708
709 datasize += sizeof(struct sk_buff);
710 if (datasize < rwnd)
711 rwnd -= datasize;
712 else
713 rwnd = 0;
714
715 asoc->peer.rwnd = rwnd;
716
717 if (!asoc->peer.prsctp_capable)
718 chunk->msg->can_abandon = 0;
719 sctp_chunk_assign_tsn(chunk);
720 sctp_chunk_assign_ssn(chunk);
721}
722
723static sctp_xmit_t sctp_packet_will_fit(struct sctp_packet *packet,
724 struct sctp_chunk *chunk,
725 u16 chunk_len)
726{
727 size_t psize;
728 size_t pmtu;
729 int too_big;
730 sctp_xmit_t retval = SCTP_XMIT_OK;
731
732 psize = packet->size;
733 pmtu = ((packet->transport->asoc) ?
734 (packet->transport->asoc->pathmtu) :
735 (packet->transport->pathmtu));
736
737 too_big = (psize + chunk_len > pmtu);
738
739
740 if (too_big) {
741
742
743
744
745
746
747
748
749 if (sctp_packet_empty(packet) || !sctp_chunk_is_data(chunk) ||
750 (!packet->has_data && chunk->auth)) {
751
752
753
754
755 packet->ipfragok = 1;
756 } else {
757 retval = SCTP_XMIT_PMTU_FULL;
758 }
759 }
760
761 return retval;
762}
763