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
45
46
47
48
49
50
51#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
52
53#include <linux/types.h>
54#include <linux/fcntl.h>
55#include <linux/poll.h>
56#include <linux/init.h>
57
58#include <linux/slab.h>
59#include <linux/in.h>
60#include <net/ipv6.h>
61#include <net/sctp/sctp.h>
62#include <net/sctp/sm.h>
63
64
65static void sctp_assoc_bh_rcv(struct work_struct *work);
66static void sctp_assoc_free_asconf_acks(struct sctp_association *asoc);
67
68
69
70
71
72static u32 idr_low = 1;
73
74
75
76
77
78static struct sctp_association *sctp_association_init(struct sctp_association *asoc,
79 const struct sctp_endpoint *ep,
80 const struct sock *sk,
81 sctp_scope_t scope,
82 gfp_t gfp)
83{
84 struct sctp_sock *sp;
85 int i;
86 sctp_paramhdr_t *p;
87 int err;
88
89
90 sp = sctp_sk((struct sock *)sk);
91
92
93 asoc->ep = (struct sctp_endpoint *)ep;
94 sctp_endpoint_hold(asoc->ep);
95
96
97 asoc->base.sk = (struct sock *)sk;
98 sock_hold(asoc->base.sk);
99
100
101 asoc->base.type = SCTP_EP_TYPE_ASSOCIATION;
102
103
104 atomic_set(&asoc->base.refcnt, 1);
105 asoc->base.dead = 0;
106 asoc->base.malloced = 0;
107
108
109 sctp_bind_addr_init(&asoc->base.bind_addr, ep->base.bind_addr.port);
110
111 asoc->state = SCTP_STATE_CLOSED;
112
113
114
115
116 asoc->cookie_life.tv_sec = sp->assocparams.sasoc_cookie_life / 1000;
117 asoc->cookie_life.tv_usec = (sp->assocparams.sasoc_cookie_life % 1000)
118 * 1000;
119 asoc->frag_point = 0;
120 asoc->user_frag = sp->user_frag;
121
122
123
124
125 asoc->max_retrans = sp->assocparams.sasoc_asocmaxrxt;
126 asoc->rto_initial = msecs_to_jiffies(sp->rtoinfo.srto_initial);
127 asoc->rto_max = msecs_to_jiffies(sp->rtoinfo.srto_max);
128 asoc->rto_min = msecs_to_jiffies(sp->rtoinfo.srto_min);
129
130 asoc->overall_error_count = 0;
131
132
133
134
135 asoc->hbinterval = msecs_to_jiffies(sp->hbinterval);
136
137
138 asoc->pathmaxrxt = sp->pathmaxrxt;
139
140
141 asoc->pathmtu = sp->pathmtu;
142
143
144 asoc->sackdelay = msecs_to_jiffies(sp->sackdelay);
145 asoc->sackfreq = sp->sackfreq;
146
147
148
149
150 asoc->param_flags = sp->param_flags;
151
152
153
154
155 asoc->max_burst = sp->max_burst;
156
157
158 asoc->timeouts[SCTP_EVENT_TIMEOUT_NONE] = 0;
159 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] = asoc->rto_initial;
160 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] = asoc->rto_initial;
161 asoc->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = asoc->rto_initial;
162 asoc->timeouts[SCTP_EVENT_TIMEOUT_T3_RTX] = 0;
163 asoc->timeouts[SCTP_EVENT_TIMEOUT_T4_RTO] = 0;
164
165
166
167
168
169 asoc->timeouts[SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]
170 = 5 * asoc->rto_max;
171
172 asoc->timeouts[SCTP_EVENT_TIMEOUT_HEARTBEAT] = 0;
173 asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] = asoc->sackdelay;
174 asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE] =
175 (unsigned long)sp->autoclose * HZ;
176
177
178 for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i)
179 setup_timer(&asoc->timers[i], sctp_timer_events[i],
180 (unsigned long)asoc);
181
182
183
184
185
186 asoc->c.sinit_max_instreams = sp->initmsg.sinit_max_instreams;
187 asoc->c.sinit_num_ostreams = sp->initmsg.sinit_num_ostreams;
188 asoc->max_init_attempts = sp->initmsg.sinit_max_attempts;
189
190 asoc->max_init_timeo =
191 msecs_to_jiffies(sp->initmsg.sinit_max_init_timeo);
192
193
194
195
196 asoc->ssnmap = NULL;
197
198
199
200
201
202
203 if ((sk->sk_rcvbuf/2) < SCTP_DEFAULT_MINWINDOW)
204 asoc->rwnd = SCTP_DEFAULT_MINWINDOW;
205 else
206 asoc->rwnd = sk->sk_rcvbuf/2;
207
208 asoc->a_rwnd = asoc->rwnd;
209
210 asoc->rwnd_over = 0;
211 asoc->rwnd_press = 0;
212
213
214 asoc->peer.rwnd = SCTP_DEFAULT_MAXWINDOW;
215
216
217 asoc->sndbuf_used = 0;
218
219
220 atomic_set(&asoc->rmem_alloc, 0);
221
222 init_waitqueue_head(&asoc->wait);
223
224 asoc->c.my_vtag = sctp_generate_tag(ep);
225 asoc->peer.i.init_tag = 0;
226 asoc->c.peer_vtag = 0;
227 asoc->c.my_ttag = 0;
228 asoc->c.peer_ttag = 0;
229 asoc->c.my_port = ep->base.bind_addr.port;
230
231 asoc->c.initial_tsn = sctp_generate_tsn(ep);
232
233 asoc->next_tsn = asoc->c.initial_tsn;
234
235 asoc->ctsn_ack_point = asoc->next_tsn - 1;
236 asoc->adv_peer_ack_point = asoc->ctsn_ack_point;
237 asoc->highest_sacked = asoc->ctsn_ack_point;
238 asoc->last_cwr_tsn = asoc->ctsn_ack_point;
239 asoc->unack_data = 0;
240
241
242
243
244
245
246
247
248
249
250
251 asoc->addip_serial = asoc->c.initial_tsn;
252
253 INIT_LIST_HEAD(&asoc->addip_chunk_list);
254 INIT_LIST_HEAD(&asoc->asconf_ack_list);
255
256
257 INIT_LIST_HEAD(&asoc->peer.transport_addr_list);
258 asoc->peer.transport_count = 0;
259
260
261
262
263
264
265
266
267
268
269
270
271 asoc->peer.sack_needed = 1;
272 asoc->peer.sack_cnt = 0;
273
274
275
276
277
278
279 asoc->peer.asconf_capable = 0;
280 if (sctp_addip_noauth)
281 asoc->peer.asconf_capable = 1;
282
283
284 sctp_inq_init(&asoc->base.inqueue);
285 sctp_inq_set_th_handler(&asoc->base.inqueue, sctp_assoc_bh_rcv);
286
287
288 sctp_outq_init(asoc, &asoc->outqueue);
289
290 if (!sctp_ulpq_init(&asoc->ulpq, asoc))
291 goto fail_init;
292
293 memset(&asoc->peer.tsn_map, 0, sizeof(struct sctp_tsnmap));
294
295 asoc->need_ecne = 0;
296
297 asoc->assoc_id = 0;
298
299
300
301
302 asoc->peer.ipv4_address = 1;
303 if (asoc->base.sk->sk_family == PF_INET6)
304 asoc->peer.ipv6_address = 1;
305 INIT_LIST_HEAD(&asoc->asocs);
306
307 asoc->autoclose = sp->autoclose;
308
309 asoc->default_stream = sp->default_stream;
310 asoc->default_ppid = sp->default_ppid;
311 asoc->default_flags = sp->default_flags;
312 asoc->default_context = sp->default_context;
313 asoc->default_timetolive = sp->default_timetolive;
314 asoc->default_rcv_context = sp->default_rcv_context;
315
316
317 INIT_LIST_HEAD(&asoc->endpoint_shared_keys);
318 err = sctp_auth_asoc_copy_shkeys(ep, asoc, gfp);
319 if (err)
320 goto fail_init;
321
322 asoc->active_key_id = ep->active_key_id;
323 asoc->asoc_shared_key = NULL;
324
325 asoc->default_hmac_id = 0;
326
327 if (ep->auth_hmacs_list)
328 memcpy(asoc->c.auth_hmacs, ep->auth_hmacs_list,
329 ntohs(ep->auth_hmacs_list->param_hdr.length));
330 if (ep->auth_chunk_list)
331 memcpy(asoc->c.auth_chunks, ep->auth_chunk_list,
332 ntohs(ep->auth_chunk_list->param_hdr.length));
333
334
335 p = (sctp_paramhdr_t *)asoc->c.auth_random;
336 p->type = SCTP_PARAM_RANDOM;
337 p->length = htons(sizeof(sctp_paramhdr_t) + SCTP_AUTH_RANDOM_LENGTH);
338 get_random_bytes(p+1, SCTP_AUTH_RANDOM_LENGTH);
339
340 return asoc;
341
342fail_init:
343 sctp_endpoint_put(asoc->ep);
344 sock_put(asoc->base.sk);
345 return NULL;
346}
347
348
349struct sctp_association *sctp_association_new(const struct sctp_endpoint *ep,
350 const struct sock *sk,
351 sctp_scope_t scope,
352 gfp_t gfp)
353{
354 struct sctp_association *asoc;
355
356 asoc = t_new(struct sctp_association, gfp);
357 if (!asoc)
358 goto fail;
359
360 if (!sctp_association_init(asoc, ep, sk, scope, gfp))
361 goto fail_init;
362
363 asoc->base.malloced = 1;
364 SCTP_DBG_OBJCNT_INC(assoc);
365 SCTP_DEBUG_PRINTK("Created asoc %p\n", asoc);
366
367 return asoc;
368
369fail_init:
370 kfree(asoc);
371fail:
372 return NULL;
373}
374
375
376
377
378void sctp_association_free(struct sctp_association *asoc)
379{
380 struct sock *sk = asoc->base.sk;
381 struct sctp_transport *transport;
382 struct list_head *pos, *temp;
383 int i;
384
385
386
387
388 if (!asoc->temp) {
389 list_del(&asoc->asocs);
390
391
392
393
394 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
395 sk->sk_ack_backlog--;
396 }
397
398
399
400
401 asoc->base.dead = 1;
402
403
404 sctp_outq_free(&asoc->outqueue);
405
406
407 sctp_ulpq_free(&asoc->ulpq);
408
409
410 sctp_inq_free(&asoc->base.inqueue);
411
412 sctp_tsnmap_free(&asoc->peer.tsn_map);
413
414
415 sctp_ssnmap_free(asoc->ssnmap);
416
417
418 sctp_bind_addr_free(&asoc->base.bind_addr);
419
420
421
422
423
424
425 for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i) {
426 if (timer_pending(&asoc->timers[i]) &&
427 del_timer(&asoc->timers[i]))
428 sctp_association_put(asoc);
429 }
430
431
432 kfree(asoc->peer.cookie);
433 kfree(asoc->peer.peer_random);
434 kfree(asoc->peer.peer_chunks);
435 kfree(asoc->peer.peer_hmacs);
436
437
438 list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
439 transport = list_entry(pos, struct sctp_transport, transports);
440 list_del(pos);
441 sctp_transport_free(transport);
442 }
443
444 asoc->peer.transport_count = 0;
445
446
447 sctp_assoc_free_asconf_acks(asoc);
448
449
450 if (asoc->addip_last_asconf)
451 sctp_chunk_free(asoc->addip_last_asconf);
452
453
454 sctp_auth_destroy_keys(&asoc->endpoint_shared_keys);
455
456
457 sctp_auth_key_put(asoc->asoc_shared_key);
458
459 sctp_association_put(asoc);
460}
461
462
463static void sctp_association_destroy(struct sctp_association *asoc)
464{
465 SCTP_ASSERT(asoc->base.dead, "Assoc is not dead", return);
466
467 sctp_endpoint_put(asoc->ep);
468 sock_put(asoc->base.sk);
469
470 if (asoc->assoc_id != 0) {
471 spin_lock_bh(&sctp_assocs_id_lock);
472 idr_remove(&sctp_assocs_id, asoc->assoc_id);
473 spin_unlock_bh(&sctp_assocs_id_lock);
474 }
475
476 WARN_ON(atomic_read(&asoc->rmem_alloc));
477
478 if (asoc->base.malloced) {
479 kfree(asoc);
480 SCTP_DBG_OBJCNT_DEC(assoc);
481 }
482}
483
484
485void sctp_assoc_set_primary(struct sctp_association *asoc,
486 struct sctp_transport *transport)
487{
488 int changeover = 0;
489
490
491
492
493 if (asoc->peer.primary_path != NULL &&
494 asoc->peer.primary_path != transport)
495 changeover = 1 ;
496
497 asoc->peer.primary_path = transport;
498
499
500 memcpy(&asoc->peer.primary_addr, &transport->ipaddr,
501 sizeof(union sctp_addr));
502
503
504
505
506 if ((transport->state == SCTP_ACTIVE) ||
507 (transport->state == SCTP_UNKNOWN))
508 asoc->peer.active_path = transport;
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524 if (!asoc->outqueue.outstanding_bytes && !asoc->outqueue.out_qlen)
525 return;
526
527 if (transport->cacc.changeover_active)
528 transport->cacc.cycling_changeover = changeover;
529
530
531
532
533 transport->cacc.changeover_active = changeover;
534
535
536
537
538 transport->cacc.next_tsn_at_change = asoc->next_tsn;
539}
540
541
542void sctp_assoc_rm_peer(struct sctp_association *asoc,
543 struct sctp_transport *peer)
544{
545 struct list_head *pos;
546 struct sctp_transport *transport;
547
548 SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_rm_peer:association %p addr: ",
549 " port: %d\n",
550 asoc,
551 (&peer->ipaddr),
552 ntohs(peer->ipaddr.v4.sin_port));
553
554
555
556
557 if (asoc->peer.retran_path == peer)
558 sctp_assoc_update_retran_path(asoc);
559
560
561 list_del(&peer->transports);
562
563
564 pos = asoc->peer.transport_addr_list.next;
565 transport = list_entry(pos, struct sctp_transport, transports);
566
567
568 if (asoc->peer.primary_path == peer)
569 sctp_assoc_set_primary(asoc, transport);
570 if (asoc->peer.active_path == peer)
571 asoc->peer.active_path = transport;
572 if (asoc->peer.last_data_from == peer)
573 asoc->peer.last_data_from = transport;
574
575
576
577
578
579
580 if (asoc->init_last_sent_to == peer)
581 asoc->init_last_sent_to = NULL;
582
583
584
585
586
587
588 if (asoc->shutdown_last_sent_to == peer)
589 asoc->shutdown_last_sent_to = NULL;
590
591
592
593
594 if (asoc->addip_last_asconf &&
595 asoc->addip_last_asconf->transport == peer)
596 asoc->addip_last_asconf->transport = NULL;
597
598
599
600
601 if (!list_empty(&peer->transmitted)) {
602 struct sctp_transport *active = asoc->peer.active_path;
603 struct sctp_chunk *ch;
604
605
606 list_for_each_entry(ch, &peer->transmitted,
607 transmitted_list) {
608 ch->transport = NULL;
609 ch->rtt_in_progress = 0;
610 }
611
612 list_splice_tail_init(&peer->transmitted,
613 &active->transmitted);
614
615
616
617
618
619 if (!timer_pending(&active->T3_rtx_timer))
620 if (!mod_timer(&active->T3_rtx_timer,
621 jiffies + active->rto))
622 sctp_transport_hold(active);
623 }
624
625 asoc->peer.transport_count--;
626
627 sctp_transport_free(peer);
628}
629
630
631struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *asoc,
632 const union sctp_addr *addr,
633 const gfp_t gfp,
634 const int peer_state)
635{
636 struct sctp_transport *peer;
637 struct sctp_sock *sp;
638 unsigned short port;
639
640 sp = sctp_sk(asoc->base.sk);
641
642
643 port = ntohs(addr->v4.sin_port);
644
645 SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_add_peer:association %p addr: ",
646 " port: %d state:%d\n",
647 asoc,
648 addr,
649 port,
650 peer_state);
651
652
653 if (0 == asoc->peer.port)
654 asoc->peer.port = port;
655
656
657 peer = sctp_assoc_lookup_paddr(asoc, addr);
658 if (peer) {
659
660
661
662
663 if (peer->state == SCTP_UNKNOWN) {
664 peer->state = SCTP_ACTIVE;
665 }
666 return peer;
667 }
668
669 peer = sctp_transport_new(addr, gfp);
670 if (!peer)
671 return NULL;
672
673 sctp_transport_set_owner(peer, asoc);
674
675
676
677
678 peer->hbinterval = asoc->hbinterval;
679
680
681 peer->pathmaxrxt = asoc->pathmaxrxt;
682
683
684
685
686 peer->sackdelay = asoc->sackdelay;
687 peer->sackfreq = asoc->sackfreq;
688
689
690
691
692 peer->param_flags = asoc->param_flags;
693
694 sctp_transport_route(peer, NULL, sp);
695
696
697 if (peer->param_flags & SPP_PMTUD_DISABLE) {
698 if (asoc->pathmtu)
699 peer->pathmtu = asoc->pathmtu;
700 else
701 peer->pathmtu = SCTP_DEFAULT_MAXSEGMENT;
702 }
703
704
705
706
707
708
709 if (asoc->pathmtu)
710 asoc->pathmtu = min_t(int, peer->pathmtu, asoc->pathmtu);
711 else
712 asoc->pathmtu = peer->pathmtu;
713
714 SCTP_DEBUG_PRINTK("sctp_assoc_add_peer:association %p PMTU set to "
715 "%d\n", asoc, asoc->pathmtu);
716 peer->pmtu_pending = 0;
717
718 asoc->frag_point = sctp_frag_point(asoc, asoc->pathmtu);
719
720
721
722
723 sctp_packet_init(&peer->packet, peer, asoc->base.bind_addr.port,
724 asoc->peer.port);
725
726
727
728
729
730
731
732
733
734
735
736 peer->cwnd = min(4*asoc->pathmtu, max_t(__u32, 2*asoc->pathmtu, 4380));
737
738
739
740
741
742 peer->ssthresh = SCTP_DEFAULT_MAXWINDOW;
743
744 peer->partial_bytes_acked = 0;
745 peer->flight_size = 0;
746 peer->burst_limited = 0;
747
748
749 peer->rto = asoc->rto_initial;
750
751
752 peer->state = peer_state;
753
754
755 list_add_tail(&peer->transports, &asoc->peer.transport_addr_list);
756 asoc->peer.transport_count++;
757
758
759 if (!asoc->peer.primary_path) {
760 sctp_assoc_set_primary(asoc, peer);
761 asoc->peer.retran_path = peer;
762 }
763
764 if (asoc->peer.active_path == asoc->peer.retran_path &&
765 peer->state != SCTP_UNCONFIRMED) {
766 asoc->peer.retran_path = peer;
767 }
768
769 return peer;
770}
771
772
773void sctp_assoc_del_peer(struct sctp_association *asoc,
774 const union sctp_addr *addr)
775{
776 struct list_head *pos;
777 struct list_head *temp;
778 struct sctp_transport *transport;
779
780 list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
781 transport = list_entry(pos, struct sctp_transport, transports);
782 if (sctp_cmp_addr_exact(addr, &transport->ipaddr)) {
783
784 sctp_assoc_rm_peer(asoc, transport);
785 break;
786 }
787 }
788}
789
790
791struct sctp_transport *sctp_assoc_lookup_paddr(
792 const struct sctp_association *asoc,
793 const union sctp_addr *address)
794{
795 struct sctp_transport *t;
796
797
798
799 list_for_each_entry(t, &asoc->peer.transport_addr_list,
800 transports) {
801 if (sctp_cmp_addr_exact(address, &t->ipaddr))
802 return t;
803 }
804
805 return NULL;
806}
807
808
809void sctp_assoc_del_nonprimary_peers(struct sctp_association *asoc,
810 struct sctp_transport *primary)
811{
812 struct sctp_transport *temp;
813 struct sctp_transport *t;
814
815 list_for_each_entry_safe(t, temp, &asoc->peer.transport_addr_list,
816 transports) {
817
818 if (t != primary)
819 sctp_assoc_rm_peer(asoc, t);
820 }
821}
822
823
824
825
826
827void sctp_assoc_control_transport(struct sctp_association *asoc,
828 struct sctp_transport *transport,
829 sctp_transport_cmd_t command,
830 sctp_sn_error_t error)
831{
832 struct sctp_transport *t = NULL;
833 struct sctp_transport *first;
834 struct sctp_transport *second;
835 struct sctp_ulpevent *event;
836 struct sockaddr_storage addr;
837 int spc_state = 0;
838
839
840 switch (command) {
841 case SCTP_TRANSPORT_UP:
842
843
844
845
846 if (SCTP_UNCONFIRMED == transport->state &&
847 SCTP_HEARTBEAT_SUCCESS == error)
848 spc_state = SCTP_ADDR_CONFIRMED;
849 else
850 spc_state = SCTP_ADDR_AVAILABLE;
851 transport->state = SCTP_ACTIVE;
852 break;
853
854 case SCTP_TRANSPORT_DOWN:
855
856
857
858
859 if (transport->state != SCTP_UNCONFIRMED)
860 transport->state = SCTP_INACTIVE;
861 else {
862 dst_release(transport->dst);
863 transport->dst = NULL;
864 }
865
866 spc_state = SCTP_ADDR_UNREACHABLE;
867 break;
868
869 default:
870 return;
871 }
872
873
874
875
876 memset(&addr, 0, sizeof(struct sockaddr_storage));
877 memcpy(&addr, &transport->ipaddr, transport->af_specific->sockaddr_len);
878 event = sctp_ulpevent_make_peer_addr_change(asoc, &addr,
879 0, spc_state, error, GFP_ATOMIC);
880 if (event)
881 sctp_ulpq_tail_event(&asoc->ulpq, event);
882
883
884
885
886
887
888
889
890
891 first = NULL; second = NULL;
892
893 list_for_each_entry(t, &asoc->peer.transport_addr_list,
894 transports) {
895
896 if ((t->state == SCTP_INACTIVE) ||
897 (t->state == SCTP_UNCONFIRMED))
898 continue;
899 if (!first || t->last_time_heard > first->last_time_heard) {
900 second = first;
901 first = t;
902 }
903 if (!second || t->last_time_heard > second->last_time_heard)
904 second = t;
905 }
906
907
908
909
910
911
912
913
914
915
916
917 if (((asoc->peer.primary_path->state == SCTP_ACTIVE) ||
918 (asoc->peer.primary_path->state == SCTP_UNKNOWN)) &&
919 first != asoc->peer.primary_path) {
920 second = first;
921 first = asoc->peer.primary_path;
922 }
923
924
925
926
927 if (!first) {
928 first = asoc->peer.primary_path;
929 second = asoc->peer.primary_path;
930 }
931
932
933 asoc->peer.active_path = first;
934 asoc->peer.retran_path = second;
935}
936
937
938void sctp_association_hold(struct sctp_association *asoc)
939{
940 atomic_inc(&asoc->base.refcnt);
941}
942
943
944
945
946void sctp_association_put(struct sctp_association *asoc)
947{
948 if (atomic_dec_and_test(&asoc->base.refcnt))
949 sctp_association_destroy(asoc);
950}
951
952
953
954
955__u32 sctp_association_get_next_tsn(struct sctp_association *asoc)
956{
957
958
959
960
961
962 __u32 retval = asoc->next_tsn;
963 asoc->next_tsn++;
964 asoc->unack_data++;
965
966 return retval;
967}
968
969
970
971
972int sctp_cmp_addr_exact(const union sctp_addr *ss1,
973 const union sctp_addr *ss2)
974{
975 struct sctp_af *af;
976
977 af = sctp_get_af_specific(ss1->sa.sa_family);
978 if (unlikely(!af))
979 return 0;
980
981 return af->cmp_addr(ss1, ss2);
982}
983
984
985
986
987
988struct sctp_chunk *sctp_get_ecne_prepend(struct sctp_association *asoc)
989{
990 struct sctp_chunk *chunk;
991
992
993
994
995 if (asoc->need_ecne)
996 chunk = sctp_make_ecne(asoc, asoc->last_ecne_tsn);
997 else
998 chunk = NULL;
999
1000 return chunk;
1001}
1002
1003
1004
1005
1006struct sctp_transport *sctp_assoc_lookup_tsn(struct sctp_association *asoc,
1007 __u32 tsn)
1008{
1009 struct sctp_transport *active;
1010 struct sctp_transport *match;
1011 struct sctp_transport *transport;
1012 struct sctp_chunk *chunk;
1013 __be32 key = htonl(tsn);
1014
1015 match = NULL;
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032 active = asoc->peer.active_path;
1033
1034 list_for_each_entry(chunk, &active->transmitted,
1035 transmitted_list) {
1036
1037 if (key == chunk->subh.data_hdr->tsn) {
1038 match = active;
1039 goto out;
1040 }
1041 }
1042
1043
1044 list_for_each_entry(transport, &asoc->peer.transport_addr_list,
1045 transports) {
1046
1047 if (transport == active)
1048 break;
1049 list_for_each_entry(chunk, &transport->transmitted,
1050 transmitted_list) {
1051 if (key == chunk->subh.data_hdr->tsn) {
1052 match = transport;
1053 goto out;
1054 }
1055 }
1056 }
1057out:
1058 return match;
1059}
1060
1061
1062struct sctp_transport *sctp_assoc_is_match(struct sctp_association *asoc,
1063 const union sctp_addr *laddr,
1064 const union sctp_addr *paddr)
1065{
1066 struct sctp_transport *transport;
1067
1068 if ((htons(asoc->base.bind_addr.port) == laddr->v4.sin_port) &&
1069 (htons(asoc->peer.port) == paddr->v4.sin_port)) {
1070 transport = sctp_assoc_lookup_paddr(asoc, paddr);
1071 if (!transport)
1072 goto out;
1073
1074 if (sctp_bind_addr_match(&asoc->base.bind_addr, laddr,
1075 sctp_sk(asoc->base.sk)))
1076 goto out;
1077 }
1078 transport = NULL;
1079
1080out:
1081 return transport;
1082}
1083
1084
1085static void sctp_assoc_bh_rcv(struct work_struct *work)
1086{
1087 struct sctp_association *asoc =
1088 container_of(work, struct sctp_association,
1089 base.inqueue.immediate);
1090 struct sctp_endpoint *ep;
1091 struct sctp_chunk *chunk;
1092 struct sock *sk;
1093 struct sctp_inq *inqueue;
1094 int state;
1095 sctp_subtype_t subtype;
1096 int error = 0;
1097
1098
1099 ep = asoc->ep;
1100 sk = asoc->base.sk;
1101
1102 inqueue = &asoc->base.inqueue;
1103 sctp_association_hold(asoc);
1104 while (NULL != (chunk = sctp_inq_pop(inqueue))) {
1105 state = asoc->state;
1106 subtype = SCTP_ST_CHUNK(chunk->chunk_hdr->type);
1107
1108
1109
1110
1111
1112
1113
1114
1115 if (sctp_auth_recv_cid(subtype.chunk, asoc) && !chunk->auth)
1116 continue;
1117
1118
1119
1120
1121 if (sctp_chunk_is_data(chunk))
1122 asoc->peer.last_data_from = chunk->transport;
1123 else
1124 SCTP_INC_STATS(SCTP_MIB_INCTRLCHUNKS);
1125
1126 if (chunk->transport)
1127 chunk->transport->last_time_heard = jiffies;
1128
1129
1130 error = sctp_do_sm(SCTP_EVENT_T_CHUNK, subtype,
1131 state, ep, asoc, chunk, GFP_ATOMIC);
1132
1133
1134
1135
1136 if (asoc->base.dead)
1137 break;
1138
1139
1140 if (error && chunk)
1141 chunk->pdiscard = 1;
1142 }
1143 sctp_association_put(asoc);
1144}
1145
1146
1147void sctp_assoc_migrate(struct sctp_association *assoc, struct sock *newsk)
1148{
1149 struct sctp_sock *newsp = sctp_sk(newsk);
1150 struct sock *oldsk = assoc->base.sk;
1151
1152
1153
1154
1155 list_del_init(&assoc->asocs);
1156
1157
1158 if (sctp_style(oldsk, TCP))
1159 oldsk->sk_ack_backlog--;
1160
1161
1162 sctp_endpoint_put(assoc->ep);
1163 sock_put(assoc->base.sk);
1164
1165
1166 assoc->ep = newsp->ep;
1167 sctp_endpoint_hold(assoc->ep);
1168
1169
1170 assoc->base.sk = newsk;
1171 sock_hold(assoc->base.sk);
1172
1173
1174 sctp_endpoint_add_asoc(newsp->ep, assoc);
1175}
1176
1177
1178void sctp_assoc_update(struct sctp_association *asoc,
1179 struct sctp_association *new)
1180{
1181 struct sctp_transport *trans;
1182 struct list_head *pos, *temp;
1183
1184
1185 asoc->c = new->c;
1186 asoc->peer.rwnd = new->peer.rwnd;
1187 asoc->peer.sack_needed = new->peer.sack_needed;
1188 asoc->peer.i = new->peer.i;
1189 sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_INITIAL,
1190 asoc->peer.i.initial_tsn, GFP_ATOMIC);
1191
1192
1193 list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
1194 trans = list_entry(pos, struct sctp_transport, transports);
1195 if (!sctp_assoc_lookup_paddr(new, &trans->ipaddr)) {
1196 sctp_assoc_rm_peer(asoc, trans);
1197 continue;
1198 }
1199
1200 if (asoc->state >= SCTP_STATE_ESTABLISHED)
1201 sctp_transport_reset(trans);
1202 }
1203
1204
1205
1206
1207
1208
1209 if (asoc->state >= SCTP_STATE_ESTABLISHED) {
1210 asoc->next_tsn = new->next_tsn;
1211 asoc->ctsn_ack_point = new->ctsn_ack_point;
1212 asoc->adv_peer_ack_point = new->adv_peer_ack_point;
1213
1214
1215
1216
1217 sctp_ssnmap_clear(asoc->ssnmap);
1218
1219
1220
1221
1222
1223 sctp_ulpq_flush(&asoc->ulpq);
1224
1225
1226
1227
1228
1229 asoc->overall_error_count = 0;
1230
1231 } else {
1232
1233 list_for_each_entry(trans, &new->peer.transport_addr_list,
1234 transports) {
1235 if (!sctp_assoc_lookup_paddr(asoc, &trans->ipaddr))
1236 sctp_assoc_add_peer(asoc, &trans->ipaddr,
1237 GFP_ATOMIC, trans->state);
1238 }
1239
1240 asoc->ctsn_ack_point = asoc->next_tsn - 1;
1241 asoc->adv_peer_ack_point = asoc->ctsn_ack_point;
1242 if (!asoc->ssnmap) {
1243
1244 asoc->ssnmap = new->ssnmap;
1245 new->ssnmap = NULL;
1246 }
1247
1248 if (!asoc->assoc_id) {
1249
1250
1251
1252 sctp_assoc_set_id(asoc, GFP_ATOMIC);
1253 }
1254 }
1255
1256
1257
1258
1259 kfree(asoc->peer.peer_random);
1260 asoc->peer.peer_random = new->peer.peer_random;
1261 new->peer.peer_random = NULL;
1262
1263 kfree(asoc->peer.peer_chunks);
1264 asoc->peer.peer_chunks = new->peer.peer_chunks;
1265 new->peer.peer_chunks = NULL;
1266
1267 kfree(asoc->peer.peer_hmacs);
1268 asoc->peer.peer_hmacs = new->peer.peer_hmacs;
1269 new->peer.peer_hmacs = NULL;
1270
1271 sctp_auth_key_put(asoc->asoc_shared_key);
1272 sctp_auth_asoc_init_active_key(asoc, GFP_ATOMIC);
1273}
1274
1275
1276
1277
1278
1279
1280void sctp_assoc_update_retran_path(struct sctp_association *asoc)
1281{
1282 struct sctp_transport *t, *next;
1283 struct list_head *head = &asoc->peer.transport_addr_list;
1284 struct list_head *pos;
1285
1286 if (asoc->peer.transport_count == 1)
1287 return;
1288
1289
1290 t = asoc->peer.retran_path;
1291 pos = &t->transports;
1292 next = NULL;
1293
1294 while (1) {
1295
1296 if (pos->next == head)
1297 pos = head->next;
1298 else
1299 pos = pos->next;
1300
1301 t = list_entry(pos, struct sctp_transport, transports);
1302
1303
1304
1305
1306
1307 if (t == asoc->peer.retran_path) {
1308 t = next;
1309 break;
1310 }
1311
1312
1313
1314 if ((t->state == SCTP_ACTIVE) ||
1315 (t->state == SCTP_UNKNOWN)) {
1316 break;
1317 } else {
1318
1319
1320
1321 if (t->state != SCTP_UNCONFIRMED && !next)
1322 next = t;
1323 }
1324 }
1325
1326 if (t)
1327 asoc->peer.retran_path = t;
1328
1329 SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_update_retran_path:association"
1330 " %p addr: ",
1331 " port: %d\n",
1332 asoc,
1333 (&t->ipaddr),
1334 ntohs(t->ipaddr.v4.sin_port));
1335}
1336
1337
1338struct sctp_transport *sctp_assoc_choose_alter_transport(
1339 struct sctp_association *asoc, struct sctp_transport *last_sent_to)
1340{
1341
1342
1343
1344
1345 if (!last_sent_to)
1346 return asoc->peer.active_path;
1347 else {
1348 if (last_sent_to == asoc->peer.retran_path)
1349 sctp_assoc_update_retran_path(asoc);
1350 return asoc->peer.retran_path;
1351 }
1352}
1353
1354
1355
1356
1357void sctp_assoc_sync_pmtu(struct sctp_association *asoc)
1358{
1359 struct sctp_transport *t;
1360 __u32 pmtu = 0;
1361
1362 if (!asoc)
1363 return;
1364
1365
1366 list_for_each_entry(t, &asoc->peer.transport_addr_list,
1367 transports) {
1368 if (t->pmtu_pending && t->dst) {
1369 sctp_transport_update_pmtu(t, dst_mtu(t->dst));
1370 t->pmtu_pending = 0;
1371 }
1372 if (!pmtu || (t->pathmtu < pmtu))
1373 pmtu = t->pathmtu;
1374 }
1375
1376 if (pmtu) {
1377 asoc->pathmtu = pmtu;
1378 asoc->frag_point = sctp_frag_point(asoc, pmtu);
1379 }
1380
1381 SCTP_DEBUG_PRINTK("%s: asoc:%p, pmtu:%d, frag_point:%d\n",
1382 __func__, asoc, asoc->pathmtu, asoc->frag_point);
1383}
1384
1385
1386static inline int sctp_peer_needs_update(struct sctp_association *asoc)
1387{
1388 switch (asoc->state) {
1389 case SCTP_STATE_ESTABLISHED:
1390 case SCTP_STATE_SHUTDOWN_PENDING:
1391 case SCTP_STATE_SHUTDOWN_RECEIVED:
1392 case SCTP_STATE_SHUTDOWN_SENT:
1393 if ((asoc->rwnd > asoc->a_rwnd) &&
1394 ((asoc->rwnd - asoc->a_rwnd) >= max_t(__u32,
1395 (asoc->base.sk->sk_rcvbuf >> sctp_rwnd_upd_shift),
1396 asoc->pathmtu)))
1397 return 1;
1398 break;
1399 default:
1400 break;
1401 }
1402 return 0;
1403}
1404
1405
1406void sctp_assoc_rwnd_increase(struct sctp_association *asoc, unsigned len)
1407{
1408 struct sctp_chunk *sack;
1409 struct timer_list *timer;
1410
1411 if (asoc->rwnd_over) {
1412 if (asoc->rwnd_over >= len) {
1413 asoc->rwnd_over -= len;
1414 } else {
1415 asoc->rwnd += (len - asoc->rwnd_over);
1416 asoc->rwnd_over = 0;
1417 }
1418 } else {
1419 asoc->rwnd += len;
1420 }
1421
1422
1423
1424
1425
1426
1427 if (asoc->rwnd_press && asoc->rwnd >= asoc->rwnd_press) {
1428 int change = min(asoc->pathmtu, asoc->rwnd_press);
1429 asoc->rwnd += change;
1430 asoc->rwnd_press -= change;
1431 }
1432
1433 SCTP_DEBUG_PRINTK("%s: asoc %p rwnd increased by %d to (%u, %u) "
1434 "- %u\n", __func__, asoc, len, asoc->rwnd,
1435 asoc->rwnd_over, asoc->a_rwnd);
1436
1437
1438
1439
1440
1441
1442 if (sctp_peer_needs_update(asoc)) {
1443 asoc->a_rwnd = asoc->rwnd;
1444 SCTP_DEBUG_PRINTK("%s: Sending window update SACK- asoc: %p "
1445 "rwnd: %u a_rwnd: %u\n", __func__,
1446 asoc, asoc->rwnd, asoc->a_rwnd);
1447 sack = sctp_make_sack(asoc);
1448 if (!sack)
1449 return;
1450
1451 asoc->peer.sack_needed = 0;
1452
1453 sctp_outq_tail(&asoc->outqueue, sack);
1454
1455
1456 timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK];
1457 if (timer_pending(timer) && del_timer(timer))
1458 sctp_association_put(asoc);
1459 }
1460}
1461
1462
1463void sctp_assoc_rwnd_decrease(struct sctp_association *asoc, unsigned len)
1464{
1465 int rx_count;
1466 int over = 0;
1467
1468 SCTP_ASSERT(asoc->rwnd, "rwnd zero", return);
1469 SCTP_ASSERT(!asoc->rwnd_over, "rwnd_over not zero", return);
1470
1471 if (asoc->ep->rcvbuf_policy)
1472 rx_count = atomic_read(&asoc->rmem_alloc);
1473 else
1474 rx_count = atomic_read(&asoc->base.sk->sk_rmem_alloc);
1475
1476
1477
1478
1479
1480
1481 if (rx_count >= asoc->base.sk->sk_rcvbuf)
1482 over = 1;
1483
1484 if (asoc->rwnd >= len) {
1485 asoc->rwnd -= len;
1486 if (over) {
1487 asoc->rwnd_press += asoc->rwnd;
1488 asoc->rwnd = 0;
1489 }
1490 } else {
1491 asoc->rwnd_over = len - asoc->rwnd;
1492 asoc->rwnd = 0;
1493 }
1494 SCTP_DEBUG_PRINTK("%s: asoc %p rwnd decreased by %d to (%u, %u, %u)\n",
1495 __func__, asoc, len, asoc->rwnd,
1496 asoc->rwnd_over, asoc->rwnd_press);
1497}
1498
1499
1500
1501
1502int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *asoc,
1503 sctp_scope_t scope, gfp_t gfp)
1504{
1505 int flags;
1506
1507
1508
1509
1510 flags = (PF_INET6 == asoc->base.sk->sk_family) ? SCTP_ADDR6_ALLOWED : 0;
1511 if (asoc->peer.ipv4_address)
1512 flags |= SCTP_ADDR4_PEERSUPP;
1513 if (asoc->peer.ipv6_address)
1514 flags |= SCTP_ADDR6_PEERSUPP;
1515
1516 return sctp_bind_addr_copy(&asoc->base.bind_addr,
1517 &asoc->ep->base.bind_addr,
1518 scope, gfp, flags);
1519}
1520
1521
1522int sctp_assoc_set_bind_addr_from_cookie(struct sctp_association *asoc,
1523 struct sctp_cookie *cookie,
1524 gfp_t gfp)
1525{
1526 int var_size2 = ntohs(cookie->peer_init->chunk_hdr.length);
1527 int var_size3 = cookie->raw_addr_list_len;
1528 __u8 *raw = (__u8 *)cookie->peer_init + var_size2;
1529
1530 return sctp_raw_to_bind_addrs(&asoc->base.bind_addr, raw, var_size3,
1531 asoc->ep->base.bind_addr.port, gfp);
1532}
1533
1534
1535int sctp_assoc_lookup_laddr(struct sctp_association *asoc,
1536 const union sctp_addr *laddr)
1537{
1538 int found = 0;
1539
1540 if ((asoc->base.bind_addr.port == ntohs(laddr->v4.sin_port)) &&
1541 sctp_bind_addr_match(&asoc->base.bind_addr, laddr,
1542 sctp_sk(asoc->base.sk)))
1543 found = 1;
1544
1545 return found;
1546}
1547
1548
1549int sctp_assoc_set_id(struct sctp_association *asoc, gfp_t gfp)
1550{
1551 int assoc_id;
1552 int error = 0;
1553
1554
1555 if (asoc->assoc_id)
1556 return error;
1557retry:
1558 if (unlikely(!idr_pre_get(&sctp_assocs_id, gfp)))
1559 return -ENOMEM;
1560
1561 spin_lock_bh(&sctp_assocs_id_lock);
1562 error = idr_get_new_above(&sctp_assocs_id, (void *)asoc,
1563 idr_low, &assoc_id);
1564 if (!error) {
1565 idr_low = assoc_id + 1;
1566 if (idr_low == INT_MAX)
1567 idr_low = 1;
1568 }
1569 spin_unlock_bh(&sctp_assocs_id_lock);
1570 if (error == -EAGAIN)
1571 goto retry;
1572 else if (error)
1573 return error;
1574
1575 asoc->assoc_id = (sctp_assoc_t) assoc_id;
1576 return error;
1577}
1578
1579
1580static void sctp_assoc_free_asconf_acks(struct sctp_association *asoc)
1581{
1582 struct sctp_chunk *ack;
1583 struct sctp_chunk *tmp;
1584
1585 list_for_each_entry_safe(ack, tmp, &asoc->asconf_ack_list,
1586 transmitted_list) {
1587 list_del_init(&ack->transmitted_list);
1588 sctp_chunk_free(ack);
1589 }
1590}
1591
1592
1593void sctp_assoc_clean_asconf_ack_cache(const struct sctp_association *asoc)
1594{
1595 struct sctp_chunk *ack;
1596 struct sctp_chunk *tmp;
1597
1598
1599
1600
1601 list_for_each_entry_safe(ack, tmp, &asoc->asconf_ack_list,
1602 transmitted_list) {
1603 if (ack->subh.addip_hdr->serial ==
1604 htonl(asoc->peer.addip_serial))
1605 break;
1606
1607 list_del_init(&ack->transmitted_list);
1608 sctp_chunk_free(ack);
1609 }
1610}
1611
1612
1613struct sctp_chunk *sctp_assoc_lookup_asconf_ack(
1614 const struct sctp_association *asoc,
1615 __be32 serial)
1616{
1617 struct sctp_chunk *ack;
1618
1619
1620
1621
1622 list_for_each_entry(ack, &asoc->asconf_ack_list, transmitted_list) {
1623 if (ack->subh.addip_hdr->serial == serial) {
1624 sctp_chunk_hold(ack);
1625 return ack;
1626 }
1627 }
1628
1629 return NULL;
1630}
1631