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#include <linux/types.h>
45#include <linux/list.h>
46#include <linux/socket.h>
47#include <linux/ip.h>
48#include <linux/time.h>
49#include <linux/slab.h>
50#include <net/ip.h>
51#include <net/icmp.h>
52#include <net/snmp.h>
53#include <net/sock.h>
54#include <net/xfrm.h>
55#include <net/sctp/sctp.h>
56#include <net/sctp/sm.h>
57#include <net/sctp/checksum.h>
58#include <net/net_namespace.h>
59
60
61static int sctp_rcv_ootb(struct sk_buff *);
62static struct sctp_association *__sctp_rcv_lookup(struct net *net,
63 struct sk_buff *skb,
64 const union sctp_addr *paddr,
65 const union sctp_addr *laddr,
66 struct sctp_transport **transportp);
67static struct sctp_endpoint *__sctp_rcv_lookup_endpoint(struct net *net,
68 const union sctp_addr *laddr);
69static struct sctp_association *__sctp_lookup_association(
70 struct net *net,
71 const union sctp_addr *local,
72 const union sctp_addr *peer,
73 struct sctp_transport **pt);
74
75static int sctp_add_backlog(struct sock *sk, struct sk_buff *skb);
76
77
78
79static inline int sctp_rcv_checksum(struct net *net, struct sk_buff *skb)
80{
81 struct sctphdr *sh = sctp_hdr(skb);
82 __le32 cmp = sh->checksum;
83 __le32 val = sctp_compute_cksum(skb, 0);
84
85 if (val != cmp) {
86
87 SCTP_INC_STATS_BH(net, SCTP_MIB_CHECKSUMERRORS);
88 return -1;
89 }
90 return 0;
91}
92
93struct sctp_input_cb {
94 union {
95 struct inet_skb_parm h4;
96#if IS_ENABLED(CONFIG_IPV6)
97 struct inet6_skb_parm h6;
98#endif
99 } header;
100 struct sctp_chunk *chunk;
101};
102#define SCTP_INPUT_CB(__skb) ((struct sctp_input_cb *)&((__skb)->cb[0]))
103
104
105
106
107int sctp_rcv(struct sk_buff *skb)
108{
109 struct sock *sk;
110 struct sctp_association *asoc;
111 struct sctp_endpoint *ep = NULL;
112 struct sctp_ep_common *rcvr;
113 struct sctp_transport *transport = NULL;
114 struct sctp_chunk *chunk;
115 struct sctphdr *sh;
116 union sctp_addr src;
117 union sctp_addr dest;
118 int family;
119 struct sctp_af *af;
120 struct net *net = dev_net(skb->dev);
121
122 if (skb->pkt_type != PACKET_HOST)
123 goto discard_it;
124
125 SCTP_INC_STATS_BH(net, SCTP_MIB_INSCTPPACKS);
126
127 if (skb_linearize(skb))
128 goto discard_it;
129
130 sh = sctp_hdr(skb);
131
132
133 __skb_pull(skb, skb_transport_offset(skb));
134 if (skb->len < sizeof(struct sctphdr))
135 goto discard_it;
136
137 skb->csum_valid = 0;
138 if (skb_csum_unnecessary(skb))
139 __skb_decr_checksum_unnecessary(skb);
140 else if (!sctp_checksum_disable && sctp_rcv_checksum(net, skb) < 0)
141 goto discard_it;
142 skb->csum_valid = 1;
143
144 skb_pull(skb, sizeof(struct sctphdr));
145
146
147 if (skb->len < sizeof(struct sctp_chunkhdr))
148 goto discard_it;
149
150 family = ipver2af(ip_hdr(skb)->version);
151 af = sctp_get_af_specific(family);
152 if (unlikely(!af))
153 goto discard_it;
154
155
156 af->from_skb(&src, skb, 1);
157 af->from_skb(&dest, skb, 0);
158
159
160
161
162
163
164
165
166
167
168
169
170 if (!af->addr_valid(&src, NULL, skb) ||
171 !af->addr_valid(&dest, NULL, skb))
172 goto discard_it;
173
174 asoc = __sctp_rcv_lookup(net, skb, &src, &dest, &transport);
175
176 if (!asoc)
177 ep = __sctp_rcv_lookup_endpoint(net, &dest);
178
179
180 rcvr = asoc ? &asoc->base : &ep->base;
181 sk = rcvr->sk;
182
183
184
185
186
187 if (sk->sk_bound_dev_if && (sk->sk_bound_dev_if != af->skb_iif(skb))) {
188 if (asoc) {
189 sctp_association_put(asoc);
190 asoc = NULL;
191 } else {
192 sctp_endpoint_put(ep);
193 ep = NULL;
194 }
195 sk = net->sctp.ctl_sock;
196 ep = sctp_sk(sk)->ep;
197 sctp_endpoint_hold(ep);
198 rcvr = &ep->base;
199 }
200
201
202
203
204
205
206
207
208
209 if (!asoc) {
210 if (sctp_rcv_ootb(skb)) {
211 SCTP_INC_STATS_BH(net, SCTP_MIB_OUTOFBLUES);
212 goto discard_release;
213 }
214 }
215
216 if (!xfrm_policy_check(sk, XFRM_POLICY_IN, skb, family))
217 goto discard_release;
218 nf_reset(skb);
219
220 if (sk_filter(sk, skb))
221 goto discard_release;
222
223
224 chunk = sctp_chunkify(skb, asoc, sk);
225 if (!chunk)
226 goto discard_release;
227 SCTP_INPUT_CB(skb)->chunk = chunk;
228
229
230 chunk->rcvr = rcvr;
231
232
233 chunk->sctp_hdr = sh;
234
235
236 sctp_init_addrs(chunk, &src, &dest);
237
238
239 chunk->transport = transport;
240
241
242
243
244
245 bh_lock_sock(sk);
246
247 if (sk != rcvr->sk) {
248
249
250
251
252
253
254
255 bh_unlock_sock(sk);
256 sk = rcvr->sk;
257 bh_lock_sock(sk);
258 }
259
260 if (sock_owned_by_user(sk)) {
261 if (sctp_add_backlog(sk, skb)) {
262 bh_unlock_sock(sk);
263 sctp_chunk_free(chunk);
264 skb = NULL;
265 goto discard_release;
266 }
267 SCTP_INC_STATS_BH(net, SCTP_MIB_IN_PKT_BACKLOG);
268 } else {
269 SCTP_INC_STATS_BH(net, SCTP_MIB_IN_PKT_SOFTIRQ);
270 sctp_inq_push(&chunk->rcvr->inqueue, chunk);
271 }
272
273 bh_unlock_sock(sk);
274
275
276 if (asoc)
277 sctp_association_put(asoc);
278 else
279 sctp_endpoint_put(ep);
280
281 return 0;
282
283discard_it:
284 SCTP_INC_STATS_BH(net, SCTP_MIB_IN_PKT_DISCARDS);
285 kfree_skb(skb);
286 return 0;
287
288discard_release:
289
290 if (asoc)
291 sctp_association_put(asoc);
292 else
293 sctp_endpoint_put(ep);
294
295 goto discard_it;
296}
297
298
299
300
301
302
303int sctp_backlog_rcv(struct sock *sk, struct sk_buff *skb)
304{
305 struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;
306 struct sctp_inq *inqueue = &chunk->rcvr->inqueue;
307 struct sctp_ep_common *rcvr = NULL;
308 int backloged = 0;
309
310 rcvr = chunk->rcvr;
311
312
313
314
315
316 if (rcvr->dead) {
317 sctp_chunk_free(chunk);
318 goto done;
319 }
320
321 if (unlikely(rcvr->sk != sk)) {
322
323
324
325
326
327
328
329
330
331
332
333 sk = rcvr->sk;
334 bh_lock_sock(sk);
335
336 if (sock_owned_by_user(sk)) {
337 if (sk_add_backlog(sk, skb, sk->sk_rcvbuf))
338 sctp_chunk_free(chunk);
339 else
340 backloged = 1;
341 } else
342 sctp_inq_push(inqueue, chunk);
343
344 bh_unlock_sock(sk);
345
346
347 if (backloged)
348 return 0;
349 } else {
350 sctp_inq_push(inqueue, chunk);
351 }
352
353done:
354
355 if (SCTP_EP_TYPE_ASSOCIATION == rcvr->type)
356 sctp_association_put(sctp_assoc(rcvr));
357 else if (SCTP_EP_TYPE_SOCKET == rcvr->type)
358 sctp_endpoint_put(sctp_ep(rcvr));
359 else
360 BUG();
361
362 return 0;
363}
364
365static int sctp_add_backlog(struct sock *sk, struct sk_buff *skb)
366{
367 struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;
368 struct sctp_ep_common *rcvr = chunk->rcvr;
369 int ret;
370
371 ret = sk_add_backlog(sk, skb, sk->sk_rcvbuf);
372 if (!ret) {
373
374
375
376
377 if (SCTP_EP_TYPE_ASSOCIATION == rcvr->type)
378 sctp_association_hold(sctp_assoc(rcvr));
379 else if (SCTP_EP_TYPE_SOCKET == rcvr->type)
380 sctp_endpoint_hold(sctp_ep(rcvr));
381 else
382 BUG();
383 }
384 return ret;
385
386}
387
388
389void sctp_icmp_frag_needed(struct sock *sk, struct sctp_association *asoc,
390 struct sctp_transport *t, __u32 pmtu)
391{
392 if (!t || (t->pathmtu <= pmtu))
393 return;
394
395 if (sock_owned_by_user(sk)) {
396 asoc->pmtu_pending = 1;
397 t->pmtu_pending = 1;
398 return;
399 }
400
401 if (t->param_flags & SPP_PMTUD_ENABLE) {
402
403 sctp_transport_update_pmtu(sk, t, pmtu);
404
405
406 sctp_assoc_sync_pmtu(sk, asoc);
407 }
408
409
410
411
412
413
414
415 sctp_retransmit(&asoc->outqueue, t, SCTP_RTXR_PMTUD);
416}
417
418void sctp_icmp_redirect(struct sock *sk, struct sctp_transport *t,
419 struct sk_buff *skb)
420{
421 struct dst_entry *dst;
422
423 if (!t)
424 return;
425 dst = sctp_transport_dst_check(t);
426 if (dst)
427 dst->ops->redirect(dst, sk, skb);
428}
429
430
431
432
433
434
435
436
437
438
439
440
441void sctp_icmp_proto_unreachable(struct sock *sk,
442 struct sctp_association *asoc,
443 struct sctp_transport *t)
444{
445 if (sock_owned_by_user(sk)) {
446 if (timer_pending(&t->proto_unreach_timer))
447 return;
448 else {
449 if (!mod_timer(&t->proto_unreach_timer,
450 jiffies + (HZ/20)))
451 sctp_association_hold(asoc);
452 }
453 } else {
454 struct net *net = sock_net(sk);
455
456 pr_debug("%s: unrecognized next header type "
457 "encountered!\n", __func__);
458
459 if (del_timer(&t->proto_unreach_timer))
460 sctp_association_put(asoc);
461
462 sctp_do_sm(net, SCTP_EVENT_T_OTHER,
463 SCTP_ST_OTHER(SCTP_EVENT_ICMP_PROTO_UNREACH),
464 asoc->state, asoc->ep, asoc, t,
465 GFP_ATOMIC);
466 }
467}
468
469
470struct sock *sctp_err_lookup(struct net *net, int family, struct sk_buff *skb,
471 struct sctphdr *sctphdr,
472 struct sctp_association **app,
473 struct sctp_transport **tpp)
474{
475 union sctp_addr saddr;
476 union sctp_addr daddr;
477 struct sctp_af *af;
478 struct sock *sk = NULL;
479 struct sctp_association *asoc;
480 struct sctp_transport *transport = NULL;
481 struct sctp_init_chunk *chunkhdr;
482 __u32 vtag = ntohl(sctphdr->vtag);
483 int len = skb->len - ((void *)sctphdr - (void *)skb->data);
484
485 *app = NULL; *tpp = NULL;
486
487 af = sctp_get_af_specific(family);
488 if (unlikely(!af)) {
489 return NULL;
490 }
491
492
493 af->from_skb(&saddr, skb, 1);
494 af->from_skb(&daddr, skb, 0);
495
496
497
498
499 asoc = __sctp_lookup_association(net, &saddr, &daddr, &transport);
500 if (!asoc)
501 return NULL;
502
503 sk = asoc->base.sk;
504
505
506
507
508
509
510
511
512
513
514
515
516
517 if (vtag == 0) {
518 chunkhdr = (void *)sctphdr + sizeof(struct sctphdr);
519 if (len < sizeof(struct sctphdr) + sizeof(sctp_chunkhdr_t)
520 + sizeof(__be32) ||
521 chunkhdr->chunk_hdr.type != SCTP_CID_INIT ||
522 ntohl(chunkhdr->init_hdr.init_tag) != asoc->c.my_vtag) {
523 goto out;
524 }
525 } else if (vtag != asoc->c.peer_vtag) {
526 goto out;
527 }
528
529 bh_lock_sock(sk);
530
531
532
533
534 if (sock_owned_by_user(sk))
535 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
536
537 *app = asoc;
538 *tpp = transport;
539 return sk;
540
541out:
542 sctp_association_put(asoc);
543 return NULL;
544}
545
546
547void sctp_err_finish(struct sock *sk, struct sctp_association *asoc)
548{
549 bh_unlock_sock(sk);
550 sctp_association_put(asoc);
551}
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568void sctp_v4_err(struct sk_buff *skb, __u32 info)
569{
570 const struct iphdr *iph = (const struct iphdr *)skb->data;
571 const int ihlen = iph->ihl * 4;
572 const int type = icmp_hdr(skb)->type;
573 const int code = icmp_hdr(skb)->code;
574 struct sock *sk;
575 struct sctp_association *asoc = NULL;
576 struct sctp_transport *transport;
577 struct inet_sock *inet;
578 __u16 saveip, savesctp;
579 int err;
580 struct net *net = dev_net(skb->dev);
581
582
583 saveip = skb->network_header;
584 savesctp = skb->transport_header;
585 skb_reset_network_header(skb);
586 skb_set_transport_header(skb, ihlen);
587 sk = sctp_err_lookup(net, AF_INET, skb, sctp_hdr(skb), &asoc, &transport);
588
589 skb->network_header = saveip;
590 skb->transport_header = savesctp;
591 if (!sk) {
592 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
593 return;
594 }
595
596
597
598
599 switch (type) {
600 case ICMP_PARAMETERPROB:
601 err = EPROTO;
602 break;
603 case ICMP_DEST_UNREACH:
604 if (code > NR_ICMP_UNREACH)
605 goto out_unlock;
606
607
608 if (ICMP_FRAG_NEEDED == code) {
609 sctp_icmp_frag_needed(sk, asoc, transport, info);
610 goto out_unlock;
611 } else {
612 if (ICMP_PROT_UNREACH == code) {
613 sctp_icmp_proto_unreachable(sk, asoc,
614 transport);
615 goto out_unlock;
616 }
617 }
618 err = icmp_err_convert[code].errno;
619 break;
620 case ICMP_TIME_EXCEEDED:
621
622
623
624 if (ICMP_EXC_FRAGTIME == code)
625 goto out_unlock;
626
627 err = EHOSTUNREACH;
628 break;
629 case ICMP_REDIRECT:
630 sctp_icmp_redirect(sk, transport, skb);
631
632 default:
633 goto out_unlock;
634 }
635
636 inet = inet_sk(sk);
637 if (!sock_owned_by_user(sk) && inet->recverr) {
638 sk->sk_err = err;
639 sk->sk_error_report(sk);
640 } else {
641 sk->sk_err_soft = err;
642 }
643
644out_unlock:
645 sctp_err_finish(sk, asoc);
646}
647
648
649
650
651
652
653
654
655
656
657
658
659
660static int sctp_rcv_ootb(struct sk_buff *skb)
661{
662 sctp_chunkhdr_t *ch;
663 __u8 *ch_end;
664
665 ch = (sctp_chunkhdr_t *) skb->data;
666
667
668 do {
669
670 if (ntohs(ch->length) < sizeof(sctp_chunkhdr_t))
671 break;
672
673 ch_end = ((__u8 *)ch) + WORD_ROUND(ntohs(ch->length));
674 if (ch_end > skb_tail_pointer(skb))
675 break;
676
677
678
679
680
681 if (SCTP_CID_ABORT == ch->type)
682 goto discard;
683
684
685
686
687
688 if (SCTP_CID_SHUTDOWN_COMPLETE == ch->type)
689 goto discard;
690
691
692
693
694
695
696 if (SCTP_CID_INIT == ch->type && (void *)ch != skb->data)
697 goto discard;
698
699 ch = (sctp_chunkhdr_t *) ch_end;
700 } while (ch_end < skb_tail_pointer(skb));
701
702 return 0;
703
704discard:
705 return 1;
706}
707
708
709static void __sctp_hash_endpoint(struct sctp_endpoint *ep)
710{
711 struct net *net = sock_net(ep->base.sk);
712 struct sctp_ep_common *epb;
713 struct sctp_hashbucket *head;
714
715 epb = &ep->base;
716
717 epb->hashent = sctp_ep_hashfn(net, epb->bind_addr.port);
718 head = &sctp_ep_hashtable[epb->hashent];
719
720 write_lock(&head->lock);
721 hlist_add_head(&epb->node, &head->chain);
722 write_unlock(&head->lock);
723}
724
725
726void sctp_hash_endpoint(struct sctp_endpoint *ep)
727{
728 local_bh_disable();
729 __sctp_hash_endpoint(ep);
730 local_bh_enable();
731}
732
733
734static void __sctp_unhash_endpoint(struct sctp_endpoint *ep)
735{
736 struct net *net = sock_net(ep->base.sk);
737 struct sctp_hashbucket *head;
738 struct sctp_ep_common *epb;
739
740 epb = &ep->base;
741
742 epb->hashent = sctp_ep_hashfn(net, epb->bind_addr.port);
743
744 head = &sctp_ep_hashtable[epb->hashent];
745
746 write_lock(&head->lock);
747 hlist_del_init(&epb->node);
748 write_unlock(&head->lock);
749}
750
751
752void sctp_unhash_endpoint(struct sctp_endpoint *ep)
753{
754 local_bh_disable();
755 __sctp_unhash_endpoint(ep);
756 local_bh_enable();
757}
758
759
760static struct sctp_endpoint *__sctp_rcv_lookup_endpoint(struct net *net,
761 const union sctp_addr *laddr)
762{
763 struct sctp_hashbucket *head;
764 struct sctp_ep_common *epb;
765 struct sctp_endpoint *ep;
766 int hash;
767
768 hash = sctp_ep_hashfn(net, ntohs(laddr->v4.sin_port));
769 head = &sctp_ep_hashtable[hash];
770 read_lock(&head->lock);
771 sctp_for_each_hentry(epb, &head->chain) {
772 ep = sctp_ep(epb);
773 if (sctp_endpoint_is_match(ep, net, laddr))
774 goto hit;
775 }
776
777 ep = sctp_sk(net->sctp.ctl_sock)->ep;
778
779hit:
780 sctp_endpoint_hold(ep);
781 read_unlock(&head->lock);
782 return ep;
783}
784
785
786struct sctp_hash_cmp_arg {
787 const struct sctp_endpoint *ep;
788 const union sctp_addr *laddr;
789 const union sctp_addr *paddr;
790 const struct net *net;
791};
792
793static inline int sctp_hash_cmp(struct rhashtable_compare_arg *arg,
794 const void *ptr)
795{
796 const struct sctp_hash_cmp_arg *x = arg->key;
797 const struct sctp_transport *t = ptr;
798 struct sctp_association *asoc = t->asoc;
799 const struct net *net = x->net;
800
801 if (!sctp_cmp_addr_exact(&t->ipaddr, x->paddr))
802 return 1;
803 if (!net_eq(sock_net(asoc->base.sk), net))
804 return 1;
805 if (x->ep) {
806 if (x->ep != asoc->ep)
807 return 1;
808 } else {
809 if (x->laddr->v4.sin_port != htons(asoc->base.bind_addr.port))
810 return 1;
811 if (!sctp_bind_addr_match(&asoc->base.bind_addr,
812 x->laddr, sctp_sk(asoc->base.sk)))
813 return 1;
814 }
815
816 return 0;
817}
818
819static inline u32 sctp_hash_obj(const void *data, u32 len, u32 seed)
820{
821 const struct sctp_transport *t = data;
822 const union sctp_addr *paddr = &t->ipaddr;
823 const struct net *net = sock_net(t->asoc->base.sk);
824 u16 lport = htons(t->asoc->base.bind_addr.port);
825 u32 addr;
826
827 if (paddr->sa.sa_family == AF_INET6)
828 addr = jhash(&paddr->v6.sin6_addr, 16, seed);
829 else
830 addr = paddr->v4.sin_addr.s_addr;
831
832 return jhash_3words(addr, ((__u32)paddr->v4.sin_port) << 16 |
833 (__force __u32)lport, net_hash_mix(net), seed);
834}
835
836static inline u32 sctp_hash_key(const void *data, u32 len, u32 seed)
837{
838 const struct sctp_hash_cmp_arg *x = data;
839 const union sctp_addr *paddr = x->paddr;
840 const struct net *net = x->net;
841 u16 lport;
842 u32 addr;
843
844 lport = x->ep ? htons(x->ep->base.bind_addr.port) :
845 x->laddr->v4.sin_port;
846 if (paddr->sa.sa_family == AF_INET6)
847 addr = jhash(&paddr->v6.sin6_addr, 16, seed);
848 else
849 addr = paddr->v4.sin_addr.s_addr;
850
851 return jhash_3words(addr, ((__u32)paddr->v4.sin_port) << 16 |
852 (__force __u32)lport, net_hash_mix(net), seed);
853}
854
855static const struct rhashtable_params sctp_hash_params = {
856 .head_offset = offsetof(struct sctp_transport, node),
857 .hashfn = sctp_hash_key,
858 .obj_hashfn = sctp_hash_obj,
859 .obj_cmpfn = sctp_hash_cmp,
860 .automatic_shrinking = true,
861};
862
863int sctp_transport_hashtable_init(void)
864{
865 return rhashtable_init(&sctp_transport_hashtable, &sctp_hash_params);
866}
867
868void sctp_transport_hashtable_destroy(void)
869{
870 rhashtable_destroy(&sctp_transport_hashtable);
871}
872
873void sctp_hash_transport(struct sctp_transport *t)
874{
875 struct sctp_hash_cmp_arg arg;
876
877 if (t->asoc->temp)
878 return;
879
880 arg.ep = t->asoc->ep;
881 arg.paddr = &t->ipaddr;
882 arg.net = sock_net(t->asoc->base.sk);
883
884reinsert:
885 if (rhashtable_lookup_insert_key(&sctp_transport_hashtable, &arg,
886 &t->node, sctp_hash_params) == -EBUSY)
887 goto reinsert;
888}
889
890void sctp_unhash_transport(struct sctp_transport *t)
891{
892 if (t->asoc->temp)
893 return;
894
895 rhashtable_remove_fast(&sctp_transport_hashtable, &t->node,
896 sctp_hash_params);
897}
898
899struct sctp_transport *sctp_addrs_lookup_transport(
900 struct net *net,
901 const union sctp_addr *laddr,
902 const union sctp_addr *paddr)
903{
904 struct sctp_hash_cmp_arg arg = {
905 .ep = NULL,
906 .laddr = laddr,
907 .paddr = paddr,
908 .net = net,
909 };
910
911 return rhashtable_lookup_fast(&sctp_transport_hashtable, &arg,
912 sctp_hash_params);
913}
914
915struct sctp_transport *sctp_epaddr_lookup_transport(
916 const struct sctp_endpoint *ep,
917 const union sctp_addr *paddr)
918{
919 struct net *net = sock_net(ep->base.sk);
920 struct sctp_hash_cmp_arg arg = {
921 .ep = ep,
922 .paddr = paddr,
923 .net = net,
924 };
925
926 return rhashtable_lookup_fast(&sctp_transport_hashtable, &arg,
927 sctp_hash_params);
928}
929
930
931static struct sctp_association *__sctp_lookup_association(
932 struct net *net,
933 const union sctp_addr *local,
934 const union sctp_addr *peer,
935 struct sctp_transport **pt)
936{
937 struct sctp_transport *t;
938 struct sctp_association *asoc = NULL;
939
940 rcu_read_lock();
941 t = sctp_addrs_lookup_transport(net, local, peer);
942 if (!t || !sctp_transport_hold(t))
943 goto out;
944
945 asoc = t->asoc;
946 sctp_association_hold(asoc);
947 *pt = t;
948
949 sctp_transport_put(t);
950
951out:
952 rcu_read_unlock();
953 return asoc;
954}
955
956
957static
958struct sctp_association *sctp_lookup_association(struct net *net,
959 const union sctp_addr *laddr,
960 const union sctp_addr *paddr,
961 struct sctp_transport **transportp)
962{
963 struct sctp_association *asoc;
964
965 asoc = __sctp_lookup_association(net, laddr, paddr, transportp);
966
967 return asoc;
968}
969
970
971int sctp_has_association(struct net *net,
972 const union sctp_addr *laddr,
973 const union sctp_addr *paddr)
974{
975 struct sctp_association *asoc;
976 struct sctp_transport *transport;
977
978 if ((asoc = sctp_lookup_association(net, laddr, paddr, &transport))) {
979 sctp_association_put(asoc);
980 return 1;
981 }
982
983 return 0;
984}
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004static struct sctp_association *__sctp_rcv_init_lookup(struct net *net,
1005 struct sk_buff *skb,
1006 const union sctp_addr *laddr, struct sctp_transport **transportp)
1007{
1008 struct sctp_association *asoc;
1009 union sctp_addr addr;
1010 union sctp_addr *paddr = &addr;
1011 struct sctphdr *sh = sctp_hdr(skb);
1012 union sctp_params params;
1013 sctp_init_chunk_t *init;
1014 struct sctp_transport *transport;
1015 struct sctp_af *af;
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033 init = (sctp_init_chunk_t *)skb->data;
1034
1035
1036 sctp_walk_params(params, init, init_hdr.params) {
1037
1038
1039 af = sctp_get_af_specific(param_type2af(params.p->type));
1040 if (!af)
1041 continue;
1042
1043 af->from_addr_param(paddr, params.addr, sh->source, 0);
1044
1045 asoc = __sctp_lookup_association(net, laddr, paddr, &transport);
1046 if (asoc)
1047 return asoc;
1048 }
1049
1050 return NULL;
1051}
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067static struct sctp_association *__sctp_rcv_asconf_lookup(
1068 struct net *net,
1069 sctp_chunkhdr_t *ch,
1070 const union sctp_addr *laddr,
1071 __be16 peer_port,
1072 struct sctp_transport **transportp)
1073{
1074 sctp_addip_chunk_t *asconf = (struct sctp_addip_chunk *)ch;
1075 struct sctp_af *af;
1076 union sctp_addr_param *param;
1077 union sctp_addr paddr;
1078
1079
1080 param = (union sctp_addr_param *)(asconf + 1);
1081
1082 af = sctp_get_af_specific(param_type2af(param->p.type));
1083 if (unlikely(!af))
1084 return NULL;
1085
1086 af->from_addr_param(&paddr, param, peer_port, 0);
1087
1088 return __sctp_lookup_association(net, laddr, &paddr, transportp);
1089}
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101static struct sctp_association *__sctp_rcv_walk_lookup(struct net *net,
1102 struct sk_buff *skb,
1103 const union sctp_addr *laddr,
1104 struct sctp_transport **transportp)
1105{
1106 struct sctp_association *asoc = NULL;
1107 sctp_chunkhdr_t *ch;
1108 int have_auth = 0;
1109 unsigned int chunk_num = 1;
1110 __u8 *ch_end;
1111
1112
1113
1114
1115 ch = (sctp_chunkhdr_t *) skb->data;
1116 do {
1117
1118 if (ntohs(ch->length) < sizeof(sctp_chunkhdr_t))
1119 break;
1120
1121 ch_end = ((__u8 *)ch) + WORD_ROUND(ntohs(ch->length));
1122 if (ch_end > skb_tail_pointer(skb))
1123 break;
1124
1125 switch (ch->type) {
1126 case SCTP_CID_AUTH:
1127 have_auth = chunk_num;
1128 break;
1129
1130 case SCTP_CID_COOKIE_ECHO:
1131
1132
1133
1134
1135
1136
1137
1138 if (have_auth == 1 && chunk_num == 2)
1139 return NULL;
1140 break;
1141
1142 case SCTP_CID_ASCONF:
1143 if (have_auth || net->sctp.addip_noauth)
1144 asoc = __sctp_rcv_asconf_lookup(
1145 net, ch, laddr,
1146 sctp_hdr(skb)->source,
1147 transportp);
1148 default:
1149 break;
1150 }
1151
1152 if (asoc)
1153 break;
1154
1155 ch = (sctp_chunkhdr_t *) ch_end;
1156 chunk_num++;
1157 } while (ch_end < skb_tail_pointer(skb));
1158
1159 return asoc;
1160}
1161
1162
1163
1164
1165
1166
1167
1168static struct sctp_association *__sctp_rcv_lookup_harder(struct net *net,
1169 struct sk_buff *skb,
1170 const union sctp_addr *laddr,
1171 struct sctp_transport **transportp)
1172{
1173 sctp_chunkhdr_t *ch;
1174
1175 ch = (sctp_chunkhdr_t *) skb->data;
1176
1177
1178
1179
1180
1181
1182 if (WORD_ROUND(ntohs(ch->length)) > skb->len)
1183 return NULL;
1184
1185
1186 if (ch->type == SCTP_CID_INIT || ch->type == SCTP_CID_INIT_ACK)
1187 return __sctp_rcv_init_lookup(net, skb, laddr, transportp);
1188
1189 return __sctp_rcv_walk_lookup(net, skb, laddr, transportp);
1190}
1191
1192
1193static struct sctp_association *__sctp_rcv_lookup(struct net *net,
1194 struct sk_buff *skb,
1195 const union sctp_addr *paddr,
1196 const union sctp_addr *laddr,
1197 struct sctp_transport **transportp)
1198{
1199 struct sctp_association *asoc;
1200
1201 asoc = __sctp_lookup_association(net, laddr, paddr, transportp);
1202
1203
1204
1205
1206
1207 if (!asoc)
1208 asoc = __sctp_rcv_lookup_harder(net, skb, laddr, transportp);
1209
1210 return asoc;
1211}
1212