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