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