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#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
50
51#include <linux/module.h>
52#include <linux/init.h>
53#include <linux/netdevice.h>
54#include <linux/inetdevice.h>
55#include <linux/seq_file.h>
56#include <linux/bootmem.h>
57#include <linux/highmem.h>
58#include <linux/swap.h>
59#include <linux/slab.h>
60#include <net/net_namespace.h>
61#include <net/protocol.h>
62#include <net/ip.h>
63#include <net/ipv6.h>
64#include <net/route.h>
65#include <net/sctp/sctp.h>
66#include <net/addrconf.h>
67#include <net/inet_common.h>
68#include <net/inet_ecn.h>
69
70
71struct sctp_globals sctp_globals __read_mostly;
72
73struct idr sctp_assocs_id;
74DEFINE_SPINLOCK(sctp_assocs_id_lock);
75
76static struct sctp_pf *sctp_pf_inet6_specific;
77static struct sctp_pf *sctp_pf_inet_specific;
78static struct sctp_af *sctp_af_v4_specific;
79static struct sctp_af *sctp_af_v6_specific;
80
81struct kmem_cache *sctp_chunk_cachep __read_mostly;
82struct kmem_cache *sctp_bucket_cachep __read_mostly;
83
84long sysctl_sctp_mem[3];
85int sysctl_sctp_rmem[3];
86int sysctl_sctp_wmem[3];
87
88
89static int __net_init sctp_proc_init(struct net *net)
90{
91#ifdef CONFIG_PROC_FS
92 net->sctp.proc_net_sctp = proc_net_mkdir(net, "sctp", net->proc_net);
93 if (!net->sctp.proc_net_sctp)
94 goto out_proc_net_sctp;
95 if (sctp_snmp_proc_init(net))
96 goto out_snmp_proc_init;
97 if (sctp_eps_proc_init(net))
98 goto out_eps_proc_init;
99 if (sctp_assocs_proc_init(net))
100 goto out_assocs_proc_init;
101 if (sctp_remaddr_proc_init(net))
102 goto out_remaddr_proc_init;
103
104 return 0;
105
106out_remaddr_proc_init:
107 sctp_assocs_proc_exit(net);
108out_assocs_proc_init:
109 sctp_eps_proc_exit(net);
110out_eps_proc_init:
111 sctp_snmp_proc_exit(net);
112out_snmp_proc_init:
113 remove_proc_entry("sctp", net->proc_net);
114 net->sctp.proc_net_sctp = NULL;
115out_proc_net_sctp:
116 return -ENOMEM;
117#endif
118 return 0;
119}
120
121
122
123
124
125static void sctp_proc_exit(struct net *net)
126{
127#ifdef CONFIG_PROC_FS
128 sctp_snmp_proc_exit(net);
129 sctp_eps_proc_exit(net);
130 sctp_assocs_proc_exit(net);
131 sctp_remaddr_proc_exit(net);
132
133 remove_proc_entry("sctp", net->proc_net);
134 net->sctp.proc_net_sctp = NULL;
135#endif
136}
137
138
139
140
141static void sctp_v4_copy_addrlist(struct list_head *addrlist,
142 struct net_device *dev)
143{
144 struct in_device *in_dev;
145 struct in_ifaddr *ifa;
146 struct sctp_sockaddr_entry *addr;
147
148 rcu_read_lock();
149 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
150 rcu_read_unlock();
151 return;
152 }
153
154 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
155
156 addr = kzalloc(sizeof(*addr), GFP_ATOMIC);
157 if (addr) {
158 addr->a.v4.sin_family = AF_INET;
159 addr->a.v4.sin_port = 0;
160 addr->a.v4.sin_addr.s_addr = ifa->ifa_local;
161 addr->valid = 1;
162 INIT_LIST_HEAD(&addr->list);
163 list_add_tail(&addr->list, addrlist);
164 }
165 }
166
167 rcu_read_unlock();
168}
169
170
171
172
173static void sctp_get_local_addr_list(struct net *net)
174{
175 struct net_device *dev;
176 struct list_head *pos;
177 struct sctp_af *af;
178
179 rcu_read_lock();
180 for_each_netdev_rcu(net, dev) {
181 list_for_each(pos, &sctp_address_families) {
182 af = list_entry(pos, struct sctp_af, list);
183 af->copy_addrlist(&net->sctp.local_addr_list, dev);
184 }
185 }
186 rcu_read_unlock();
187}
188
189
190static void sctp_free_local_addr_list(struct net *net)
191{
192 struct sctp_sockaddr_entry *addr;
193 struct list_head *pos, *temp;
194
195 list_for_each_safe(pos, temp, &net->sctp.local_addr_list) {
196 addr = list_entry(pos, struct sctp_sockaddr_entry, list);
197 list_del(pos);
198 kfree(addr);
199 }
200}
201
202
203int sctp_copy_local_addr_list(struct net *net, struct sctp_bind_addr *bp,
204 sctp_scope_t scope, gfp_t gfp, int copy_flags)
205{
206 struct sctp_sockaddr_entry *addr;
207 int error = 0;
208
209 rcu_read_lock();
210 list_for_each_entry_rcu(addr, &net->sctp.local_addr_list, list) {
211 if (!addr->valid)
212 continue;
213 if (sctp_in_scope(net, &addr->a, scope)) {
214
215
216
217
218 if ((((AF_INET == addr->a.sa.sa_family) &&
219 (copy_flags & SCTP_ADDR4_PEERSUPP))) ||
220 (((AF_INET6 == addr->a.sa.sa_family) &&
221 (copy_flags & SCTP_ADDR6_ALLOWED) &&
222 (copy_flags & SCTP_ADDR6_PEERSUPP)))) {
223 error = sctp_add_bind_addr(bp, &addr->a,
224 SCTP_ADDR_SRC, GFP_ATOMIC);
225 if (error)
226 goto end_copy;
227 }
228 }
229 }
230
231end_copy:
232 rcu_read_unlock();
233 return error;
234}
235
236
237static void sctp_v4_from_skb(union sctp_addr *addr, struct sk_buff *skb,
238 int is_saddr)
239{
240 void *from;
241 __be16 *port;
242 struct sctphdr *sh;
243
244 port = &addr->v4.sin_port;
245 addr->v4.sin_family = AF_INET;
246
247 sh = sctp_hdr(skb);
248 if (is_saddr) {
249 *port = sh->source;
250 from = &ip_hdr(skb)->saddr;
251 } else {
252 *port = sh->dest;
253 from = &ip_hdr(skb)->daddr;
254 }
255 memcpy(&addr->v4.sin_addr.s_addr, from, sizeof(struct in_addr));
256}
257
258
259static void sctp_v4_from_sk(union sctp_addr *addr, struct sock *sk)
260{
261 addr->v4.sin_family = AF_INET;
262 addr->v4.sin_port = 0;
263 addr->v4.sin_addr.s_addr = inet_sk(sk)->inet_rcv_saddr;
264}
265
266
267static void sctp_v4_to_sk_saddr(union sctp_addr *addr, struct sock *sk)
268{
269 inet_sk(sk)->inet_rcv_saddr = addr->v4.sin_addr.s_addr;
270}
271
272
273static void sctp_v4_to_sk_daddr(union sctp_addr *addr, struct sock *sk)
274{
275 inet_sk(sk)->inet_daddr = addr->v4.sin_addr.s_addr;
276}
277
278
279static void sctp_v4_from_addr_param(union sctp_addr *addr,
280 union sctp_addr_param *param,
281 __be16 port, int iif)
282{
283 addr->v4.sin_family = AF_INET;
284 addr->v4.sin_port = port;
285 addr->v4.sin_addr.s_addr = param->v4.addr.s_addr;
286}
287
288
289
290
291static int sctp_v4_to_addr_param(const union sctp_addr *addr,
292 union sctp_addr_param *param)
293{
294 int length = sizeof(sctp_ipv4addr_param_t);
295
296 param->v4.param_hdr.type = SCTP_PARAM_IPV4_ADDRESS;
297 param->v4.param_hdr.length = htons(length);
298 param->v4.addr.s_addr = addr->v4.sin_addr.s_addr;
299
300 return length;
301}
302
303
304static void sctp_v4_dst_saddr(union sctp_addr *saddr, struct flowi4 *fl4,
305 __be16 port)
306{
307 saddr->v4.sin_family = AF_INET;
308 saddr->v4.sin_port = port;
309 saddr->v4.sin_addr.s_addr = fl4->saddr;
310}
311
312
313static int sctp_v4_cmp_addr(const union sctp_addr *addr1,
314 const union sctp_addr *addr2)
315{
316 if (addr1->sa.sa_family != addr2->sa.sa_family)
317 return 0;
318 if (addr1->v4.sin_port != addr2->v4.sin_port)
319 return 0;
320 if (addr1->v4.sin_addr.s_addr != addr2->v4.sin_addr.s_addr)
321 return 0;
322
323 return 1;
324}
325
326
327static void sctp_v4_inaddr_any(union sctp_addr *addr, __be16 port)
328{
329 addr->v4.sin_family = AF_INET;
330 addr->v4.sin_addr.s_addr = htonl(INADDR_ANY);
331 addr->v4.sin_port = port;
332}
333
334
335static int sctp_v4_is_any(const union sctp_addr *addr)
336{
337 return htonl(INADDR_ANY) == addr->v4.sin_addr.s_addr;
338}
339
340
341
342
343
344
345
346
347static int sctp_v4_addr_valid(union sctp_addr *addr,
348 struct sctp_sock *sp,
349 const struct sk_buff *skb)
350{
351
352 if (sp && ipv6_only_sock(sctp_opt2sk(sp)))
353 return 0;
354
355
356 if (IS_IPV4_UNUSABLE_ADDRESS(addr->v4.sin_addr.s_addr))
357 return 0;
358
359
360 if (skb && skb_rtable(skb)->rt_flags & RTCF_BROADCAST)
361 return 0;
362
363 return 1;
364}
365
366
367static int sctp_v4_available(union sctp_addr *addr, struct sctp_sock *sp)
368{
369 struct net *net = sock_net(&sp->inet.sk);
370 int ret = inet_addr_type(net, addr->v4.sin_addr.s_addr);
371
372
373 if (addr->v4.sin_addr.s_addr != htonl(INADDR_ANY) &&
374 ret != RTN_LOCAL &&
375 !sp->inet.freebind &&
376 !sysctl_ip_nonlocal_bind)
377 return 0;
378
379 if (ipv6_only_sock(sctp_opt2sk(sp)))
380 return 0;
381
382 return 1;
383}
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402static sctp_scope_t sctp_v4_scope(union sctp_addr *addr)
403{
404 sctp_scope_t retval;
405
406
407 if (IS_IPV4_UNUSABLE_ADDRESS(addr->v4.sin_addr.s_addr)) {
408 retval = SCTP_SCOPE_UNUSABLE;
409 } else if (ipv4_is_loopback(addr->v4.sin_addr.s_addr)) {
410 retval = SCTP_SCOPE_LOOPBACK;
411 } else if (ipv4_is_linklocal_169(addr->v4.sin_addr.s_addr)) {
412 retval = SCTP_SCOPE_LINK;
413 } else if (ipv4_is_private_10(addr->v4.sin_addr.s_addr) ||
414 ipv4_is_private_172(addr->v4.sin_addr.s_addr) ||
415 ipv4_is_private_192(addr->v4.sin_addr.s_addr)) {
416 retval = SCTP_SCOPE_PRIVATE;
417 } else {
418 retval = SCTP_SCOPE_GLOBAL;
419 }
420
421 return retval;
422}
423
424
425
426
427
428static void sctp_v4_get_dst(struct sctp_transport *t, union sctp_addr *saddr,
429 struct flowi *fl, struct sock *sk)
430{
431 struct sctp_association *asoc = t->asoc;
432 struct rtable *rt;
433 struct flowi4 *fl4 = &fl->u.ip4;
434 struct sctp_bind_addr *bp;
435 struct sctp_sockaddr_entry *laddr;
436 struct dst_entry *dst = NULL;
437 union sctp_addr *daddr = &t->ipaddr;
438 union sctp_addr dst_saddr;
439
440 memset(fl4, 0x0, sizeof(struct flowi4));
441 fl4->daddr = daddr->v4.sin_addr.s_addr;
442 fl4->fl4_dport = daddr->v4.sin_port;
443 fl4->flowi4_proto = IPPROTO_SCTP;
444 if (asoc) {
445 fl4->flowi4_tos = RT_CONN_FLAGS(asoc->base.sk);
446 fl4->flowi4_oif = asoc->base.sk->sk_bound_dev_if;
447 fl4->fl4_sport = htons(asoc->base.bind_addr.port);
448 }
449 if (saddr) {
450 fl4->saddr = saddr->v4.sin_addr.s_addr;
451 fl4->fl4_sport = saddr->v4.sin_port;
452 }
453
454 pr_debug("%s: dst:%pI4, src:%pI4 - ", __func__, &fl4->daddr,
455 &fl4->saddr);
456
457 rt = ip_route_output_key(sock_net(sk), fl4);
458 if (!IS_ERR(rt))
459 dst = &rt->dst;
460
461
462
463
464 if (!asoc || saddr)
465 goto out;
466
467 bp = &asoc->base.bind_addr;
468
469 if (dst) {
470
471
472
473 sctp_v4_dst_saddr(&dst_saddr, fl4, htons(bp->port));
474 rcu_read_lock();
475 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
476 if (!laddr->valid || (laddr->state == SCTP_ADDR_DEL) ||
477 (laddr->state != SCTP_ADDR_SRC &&
478 !asoc->src_out_of_asoc_ok))
479 continue;
480 if (sctp_v4_cmp_addr(&dst_saddr, &laddr->a))
481 goto out_unlock;
482 }
483 rcu_read_unlock();
484
485
486
487
488 dst_release(dst);
489 dst = NULL;
490 }
491
492
493
494
495 rcu_read_lock();
496 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
497 if (!laddr->valid)
498 continue;
499 if ((laddr->state == SCTP_ADDR_SRC) &&
500 (AF_INET == laddr->a.sa.sa_family)) {
501 fl4->saddr = laddr->a.v4.sin_addr.s_addr;
502 fl4->fl4_sport = laddr->a.v4.sin_port;
503 rt = ip_route_output_key(sock_net(sk), fl4);
504 if (!IS_ERR(rt)) {
505 dst = &rt->dst;
506 goto out_unlock;
507 }
508 }
509 }
510
511out_unlock:
512 rcu_read_unlock();
513out:
514 t->dst = dst;
515 if (dst)
516 pr_debug("rt_dst:%pI4, rt_src:%pI4\n",
517 &fl4->daddr, &fl4->saddr);
518 else
519 pr_debug("no route\n");
520}
521
522
523
524
525static void sctp_v4_get_saddr(struct sctp_sock *sk,
526 struct sctp_transport *t,
527 struct flowi *fl)
528{
529 union sctp_addr *saddr = &t->saddr;
530 struct rtable *rt = (struct rtable *)t->dst;
531
532 if (rt) {
533 saddr->v4.sin_family = AF_INET;
534 saddr->v4.sin_addr.s_addr = fl->u.ip4.saddr;
535 }
536}
537
538
539static int sctp_v4_skb_iif(const struct sk_buff *skb)
540{
541 return inet_iif(skb);
542}
543
544
545static int sctp_v4_is_ce(const struct sk_buff *skb)
546{
547 return INET_ECN_is_ce(ip_hdr(skb)->tos);
548}
549
550
551static struct sock *sctp_v4_create_accept_sk(struct sock *sk,
552 struct sctp_association *asoc)
553{
554 struct sock *newsk = sk_alloc(sock_net(sk), PF_INET, GFP_KERNEL,
555 sk->sk_prot);
556 struct inet_sock *newinet;
557
558 if (!newsk)
559 goto out;
560
561 sock_init_data(NULL, newsk);
562
563 sctp_copy_sock(newsk, sk, asoc);
564 sock_reset_flag(newsk, SOCK_ZAPPED);
565
566 newinet = inet_sk(newsk);
567
568 newinet->inet_daddr = asoc->peer.primary_addr.v4.sin_addr.s_addr;
569
570 sk_refcnt_debug_inc(newsk);
571
572 if (newsk->sk_prot->init(newsk)) {
573 sk_common_release(newsk);
574 newsk = NULL;
575 }
576
577out:
578 return newsk;
579}
580
581
582static void sctp_v4_addr_v4map(struct sctp_sock *sp, union sctp_addr *addr)
583{
584
585}
586
587
588static void sctp_v4_seq_dump_addr(struct seq_file *seq, union sctp_addr *addr)
589{
590 seq_printf(seq, "%pI4 ", &addr->v4.sin_addr);
591}
592
593static void sctp_v4_ecn_capable(struct sock *sk)
594{
595 INET_ECN_xmit(sk);
596}
597
598static void sctp_addr_wq_timeout_handler(unsigned long arg)
599{
600 struct net *net = (struct net *)arg;
601 struct sctp_sockaddr_entry *addrw, *temp;
602 struct sctp_sock *sp;
603
604 spin_lock_bh(&net->sctp.addr_wq_lock);
605
606 list_for_each_entry_safe(addrw, temp, &net->sctp.addr_waitq, list) {
607 pr_debug("%s: the first ent in wq:%p is addr:%pISc for cmd:%d at "
608 "entry:%p\n", __func__, &net->sctp.addr_waitq, &addrw->a.sa,
609 addrw->state, addrw);
610
611#if IS_ENABLED(CONFIG_IPV6)
612
613
614 if (addrw->a.sa.sa_family == AF_INET6) {
615 struct in6_addr *in6;
616
617 if (ipv6_addr_type(&addrw->a.v6.sin6_addr) &
618 IPV6_ADDR_LINKLOCAL)
619 goto free_next;
620
621 in6 = (struct in6_addr *)&addrw->a.v6.sin6_addr;
622 if (ipv6_chk_addr(net, in6, NULL, 0) == 0 &&
623 addrw->state == SCTP_ADDR_NEW) {
624 unsigned long timeo_val;
625
626 pr_debug("%s: this is on DAD, trying %d sec "
627 "later\n", __func__,
628 SCTP_ADDRESS_TICK_DELAY);
629
630 timeo_val = jiffies;
631 timeo_val += msecs_to_jiffies(SCTP_ADDRESS_TICK_DELAY);
632 mod_timer(&net->sctp.addr_wq_timer, timeo_val);
633 break;
634 }
635 }
636#endif
637 list_for_each_entry(sp, &net->sctp.auto_asconf_splist, auto_asconf_list) {
638 struct sock *sk;
639
640 sk = sctp_opt2sk(sp);
641
642 if (!sctp_is_ep_boundall(sk))
643 continue;
644 sctp_bh_lock_sock(sk);
645 if (sctp_asconf_mgmt(sp, addrw) < 0)
646 pr_debug("%s: sctp_asconf_mgmt failed\n", __func__);
647 sctp_bh_unlock_sock(sk);
648 }
649#if IS_ENABLED(CONFIG_IPV6)
650free_next:
651#endif
652 list_del(&addrw->list);
653 kfree(addrw);
654 }
655 spin_unlock_bh(&net->sctp.addr_wq_lock);
656}
657
658static void sctp_free_addr_wq(struct net *net)
659{
660 struct sctp_sockaddr_entry *addrw;
661 struct sctp_sockaddr_entry *temp;
662
663 spin_lock_bh(&net->sctp.addr_wq_lock);
664 del_timer(&net->sctp.addr_wq_timer);
665 list_for_each_entry_safe(addrw, temp, &net->sctp.addr_waitq, list) {
666 list_del(&addrw->list);
667 kfree(addrw);
668 }
669 spin_unlock_bh(&net->sctp.addr_wq_lock);
670}
671
672
673
674
675static struct sctp_sockaddr_entry *sctp_addr_wq_lookup(struct net *net,
676 struct sctp_sockaddr_entry *addr)
677{
678 struct sctp_sockaddr_entry *addrw;
679
680 list_for_each_entry(addrw, &net->sctp.addr_waitq, list) {
681 if (addrw->a.sa.sa_family != addr->a.sa.sa_family)
682 continue;
683 if (addrw->a.sa.sa_family == AF_INET) {
684 if (addrw->a.v4.sin_addr.s_addr ==
685 addr->a.v4.sin_addr.s_addr)
686 return addrw;
687 } else if (addrw->a.sa.sa_family == AF_INET6) {
688 if (ipv6_addr_equal(&addrw->a.v6.sin6_addr,
689 &addr->a.v6.sin6_addr))
690 return addrw;
691 }
692 }
693 return NULL;
694}
695
696void sctp_addr_wq_mgmt(struct net *net, struct sctp_sockaddr_entry *addr, int cmd)
697{
698 struct sctp_sockaddr_entry *addrw;
699 unsigned long timeo_val;
700
701
702
703
704
705
706
707 spin_lock_bh(&net->sctp.addr_wq_lock);
708
709 addrw = sctp_addr_wq_lookup(net, addr);
710 if (addrw) {
711 if (addrw->state != cmd) {
712 pr_debug("%s: offsets existing entry for %d, addr:%pISc "
713 "in wq:%p\n", __func__, addrw->state, &addrw->a.sa,
714 &net->sctp.addr_waitq);
715
716 list_del(&addrw->list);
717 kfree(addrw);
718 }
719 spin_unlock_bh(&net->sctp.addr_wq_lock);
720 return;
721 }
722
723
724 addrw = kmemdup(addr, sizeof(struct sctp_sockaddr_entry), GFP_ATOMIC);
725 if (addrw == NULL) {
726 spin_unlock_bh(&net->sctp.addr_wq_lock);
727 return;
728 }
729 addrw->state = cmd;
730 list_add_tail(&addrw->list, &net->sctp.addr_waitq);
731
732 pr_debug("%s: add new entry for cmd:%d, addr:%pISc in wq:%p\n",
733 __func__, addrw->state, &addrw->a.sa, &net->sctp.addr_waitq);
734
735 if (!timer_pending(&net->sctp.addr_wq_timer)) {
736 timeo_val = jiffies;
737 timeo_val += msecs_to_jiffies(SCTP_ADDRESS_TICK_DELAY);
738 mod_timer(&net->sctp.addr_wq_timer, timeo_val);
739 }
740 spin_unlock_bh(&net->sctp.addr_wq_lock);
741}
742
743
744
745
746
747
748
749static int sctp_inetaddr_event(struct notifier_block *this, unsigned long ev,
750 void *ptr)
751{
752 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
753 struct sctp_sockaddr_entry *addr = NULL;
754 struct sctp_sockaddr_entry *temp;
755 struct net *net = dev_net(ifa->ifa_dev->dev);
756 int found = 0;
757
758 switch (ev) {
759 case NETDEV_UP:
760 addr = kmalloc(sizeof(struct sctp_sockaddr_entry), GFP_ATOMIC);
761 if (addr) {
762 addr->a.v4.sin_family = AF_INET;
763 addr->a.v4.sin_port = 0;
764 addr->a.v4.sin_addr.s_addr = ifa->ifa_local;
765 addr->valid = 1;
766 spin_lock_bh(&net->sctp.local_addr_lock);
767 list_add_tail_rcu(&addr->list, &net->sctp.local_addr_list);
768 sctp_addr_wq_mgmt(net, addr, SCTP_ADDR_NEW);
769 spin_unlock_bh(&net->sctp.local_addr_lock);
770 }
771 break;
772 case NETDEV_DOWN:
773 spin_lock_bh(&net->sctp.local_addr_lock);
774 list_for_each_entry_safe(addr, temp,
775 &net->sctp.local_addr_list, list) {
776 if (addr->a.sa.sa_family == AF_INET &&
777 addr->a.v4.sin_addr.s_addr ==
778 ifa->ifa_local) {
779 sctp_addr_wq_mgmt(net, addr, SCTP_ADDR_DEL);
780 found = 1;
781 addr->valid = 0;
782 list_del_rcu(&addr->list);
783 break;
784 }
785 }
786 spin_unlock_bh(&net->sctp.local_addr_lock);
787 if (found)
788 kfree_rcu(addr, rcu);
789 break;
790 }
791
792 return NOTIFY_DONE;
793}
794
795
796
797
798
799static int sctp_ctl_sock_init(struct net *net)
800{
801 int err;
802 sa_family_t family = PF_INET;
803
804 if (sctp_get_pf_specific(PF_INET6))
805 family = PF_INET6;
806
807 err = inet_ctl_sock_create(&net->sctp.ctl_sock, family,
808 SOCK_SEQPACKET, IPPROTO_SCTP, net);
809
810
811 if (err < 0 && family == PF_INET6)
812 err = inet_ctl_sock_create(&net->sctp.ctl_sock, AF_INET,
813 SOCK_SEQPACKET, IPPROTO_SCTP,
814 net);
815
816 if (err < 0) {
817 pr_err("Failed to create the SCTP control socket\n");
818 return err;
819 }
820 return 0;
821}
822
823
824int sctp_register_af(struct sctp_af *af)
825{
826 switch (af->sa_family) {
827 case AF_INET:
828 if (sctp_af_v4_specific)
829 return 0;
830 sctp_af_v4_specific = af;
831 break;
832 case AF_INET6:
833 if (sctp_af_v6_specific)
834 return 0;
835 sctp_af_v6_specific = af;
836 break;
837 default:
838 return 0;
839 }
840
841 INIT_LIST_HEAD(&af->list);
842 list_add_tail(&af->list, &sctp_address_families);
843 return 1;
844}
845
846
847
848
849struct sctp_af *sctp_get_af_specific(sa_family_t family)
850{
851 switch (family) {
852 case AF_INET:
853 return sctp_af_v4_specific;
854 case AF_INET6:
855 return sctp_af_v6_specific;
856 default:
857 return NULL;
858 }
859}
860
861
862static void sctp_inet_msgname(char *msgname, int *addr_len)
863{
864 struct sockaddr_in *sin;
865
866 sin = (struct sockaddr_in *)msgname;
867 *addr_len = sizeof(struct sockaddr_in);
868 sin->sin_family = AF_INET;
869 memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
870}
871
872
873static void sctp_inet_event_msgname(struct sctp_ulpevent *event, char *msgname,
874 int *addr_len)
875{
876 struct sockaddr_in *sin, *sinfrom;
877
878 if (msgname) {
879 struct sctp_association *asoc;
880
881 asoc = event->asoc;
882 sctp_inet_msgname(msgname, addr_len);
883 sin = (struct sockaddr_in *)msgname;
884 sinfrom = &asoc->peer.primary_addr.v4;
885 sin->sin_port = htons(asoc->peer.port);
886 sin->sin_addr.s_addr = sinfrom->sin_addr.s_addr;
887 }
888}
889
890
891static void sctp_inet_skb_msgname(struct sk_buff *skb, char *msgname, int *len)
892{
893 if (msgname) {
894 struct sctphdr *sh = sctp_hdr(skb);
895 struct sockaddr_in *sin = (struct sockaddr_in *)msgname;
896
897 sctp_inet_msgname(msgname, len);
898 sin->sin_port = sh->source;
899 sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
900 }
901}
902
903
904static int sctp_inet_af_supported(sa_family_t family, struct sctp_sock *sp)
905{
906
907 return AF_INET == family;
908}
909
910
911static int sctp_inet_cmp_addr(const union sctp_addr *addr1,
912 const union sctp_addr *addr2,
913 struct sctp_sock *opt)
914{
915
916 if (addr1->sa.sa_family != addr2->sa.sa_family)
917 return 0;
918 if (htonl(INADDR_ANY) == addr1->v4.sin_addr.s_addr ||
919 htonl(INADDR_ANY) == addr2->v4.sin_addr.s_addr)
920 return 1;
921 if (addr1->v4.sin_addr.s_addr == addr2->v4.sin_addr.s_addr)
922 return 1;
923
924 return 0;
925}
926
927
928
929
930static int sctp_inet_bind_verify(struct sctp_sock *opt, union sctp_addr *addr)
931{
932 return sctp_v4_available(addr, opt);
933}
934
935
936
937
938static int sctp_inet_send_verify(struct sctp_sock *opt, union sctp_addr *addr)
939{
940 return 1;
941}
942
943
944
945
946static int sctp_inet_supported_addrs(const struct sctp_sock *opt,
947 __be16 *types)
948{
949 types[0] = SCTP_PARAM_IPV4_ADDRESS;
950 return 1;
951}
952
953
954static inline int sctp_v4_xmit(struct sk_buff *skb,
955 struct sctp_transport *transport)
956{
957 struct inet_sock *inet = inet_sk(skb->sk);
958
959 pr_debug("%s: skb:%p, len:%d, src:%pI4, dst:%pI4\n", __func__, skb,
960 skb->len, &transport->fl.u.ip4.saddr, &transport->fl.u.ip4.daddr);
961
962 inet->pmtudisc = transport->param_flags & SPP_PMTUD_ENABLE ?
963 IP_PMTUDISC_DO : IP_PMTUDISC_DONT;
964
965 SCTP_INC_STATS(sock_net(&inet->sk), SCTP_MIB_OUTSCTPPACKS);
966
967 return ip_queue_xmit(skb, &transport->fl);
968}
969
970static struct sctp_af sctp_af_inet;
971
972static struct sctp_pf sctp_pf_inet = {
973 .event_msgname = sctp_inet_event_msgname,
974 .skb_msgname = sctp_inet_skb_msgname,
975 .af_supported = sctp_inet_af_supported,
976 .cmp_addr = sctp_inet_cmp_addr,
977 .bind_verify = sctp_inet_bind_verify,
978 .send_verify = sctp_inet_send_verify,
979 .supported_addrs = sctp_inet_supported_addrs,
980 .create_accept_sk = sctp_v4_create_accept_sk,
981 .addr_v4map = sctp_v4_addr_v4map,
982 .af = &sctp_af_inet
983};
984
985
986static struct notifier_block sctp_inetaddr_notifier = {
987 .notifier_call = sctp_inetaddr_event,
988};
989
990
991static const struct proto_ops inet_seqpacket_ops = {
992 .family = PF_INET,
993 .owner = THIS_MODULE,
994 .release = inet_release,
995 .bind = inet_bind,
996 .connect = inet_dgram_connect,
997 .socketpair = sock_no_socketpair,
998 .accept = inet_accept,
999 .getname = inet_getname,
1000 .poll = sctp_poll,
1001 .ioctl = inet_ioctl,
1002 .listen = sctp_inet_listen,
1003 .shutdown = inet_shutdown,
1004 .setsockopt = sock_common_setsockopt,
1005 .getsockopt = sock_common_getsockopt,
1006 .sendmsg = inet_sendmsg,
1007 .recvmsg = sock_common_recvmsg,
1008 .mmap = sock_no_mmap,
1009 .sendpage = sock_no_sendpage,
1010#ifdef CONFIG_COMPAT
1011 .compat_setsockopt = compat_sock_common_setsockopt,
1012 .compat_getsockopt = compat_sock_common_getsockopt,
1013#endif
1014};
1015
1016
1017static struct inet_protosw sctp_seqpacket_protosw = {
1018 .type = SOCK_SEQPACKET,
1019 .protocol = IPPROTO_SCTP,
1020 .prot = &sctp_prot,
1021 .ops = &inet_seqpacket_ops,
1022 .no_check = 0,
1023 .flags = SCTP_PROTOSW_FLAG
1024};
1025static struct inet_protosw sctp_stream_protosw = {
1026 .type = SOCK_STREAM,
1027 .protocol = IPPROTO_SCTP,
1028 .prot = &sctp_prot,
1029 .ops = &inet_seqpacket_ops,
1030 .no_check = 0,
1031 .flags = SCTP_PROTOSW_FLAG
1032};
1033
1034
1035static const struct net_protocol sctp_protocol = {
1036 .handler = sctp_rcv,
1037 .err_handler = sctp_v4_err,
1038 .no_policy = 1,
1039 .netns_ok = 1,
1040};
1041
1042
1043static struct sctp_af sctp_af_inet = {
1044 .sa_family = AF_INET,
1045 .sctp_xmit = sctp_v4_xmit,
1046 .setsockopt = ip_setsockopt,
1047 .getsockopt = ip_getsockopt,
1048 .get_dst = sctp_v4_get_dst,
1049 .get_saddr = sctp_v4_get_saddr,
1050 .copy_addrlist = sctp_v4_copy_addrlist,
1051 .from_skb = sctp_v4_from_skb,
1052 .from_sk = sctp_v4_from_sk,
1053 .to_sk_saddr = sctp_v4_to_sk_saddr,
1054 .to_sk_daddr = sctp_v4_to_sk_daddr,
1055 .from_addr_param = sctp_v4_from_addr_param,
1056 .to_addr_param = sctp_v4_to_addr_param,
1057 .cmp_addr = sctp_v4_cmp_addr,
1058 .addr_valid = sctp_v4_addr_valid,
1059 .inaddr_any = sctp_v4_inaddr_any,
1060 .is_any = sctp_v4_is_any,
1061 .available = sctp_v4_available,
1062 .scope = sctp_v4_scope,
1063 .skb_iif = sctp_v4_skb_iif,
1064 .is_ce = sctp_v4_is_ce,
1065 .seq_dump_addr = sctp_v4_seq_dump_addr,
1066 .ecn_capable = sctp_v4_ecn_capable,
1067 .net_header_len = sizeof(struct iphdr),
1068 .sockaddr_len = sizeof(struct sockaddr_in),
1069#ifdef CONFIG_COMPAT
1070 .compat_setsockopt = compat_ip_setsockopt,
1071 .compat_getsockopt = compat_ip_getsockopt,
1072#endif
1073};
1074
1075struct sctp_pf *sctp_get_pf_specific(sa_family_t family) {
1076
1077 switch (family) {
1078 case PF_INET:
1079 return sctp_pf_inet_specific;
1080 case PF_INET6:
1081 return sctp_pf_inet6_specific;
1082 default:
1083 return NULL;
1084 }
1085}
1086
1087
1088int sctp_register_pf(struct sctp_pf *pf, sa_family_t family)
1089{
1090 switch (family) {
1091 case PF_INET:
1092 if (sctp_pf_inet_specific)
1093 return 0;
1094 sctp_pf_inet_specific = pf;
1095 break;
1096 case PF_INET6:
1097 if (sctp_pf_inet6_specific)
1098 return 0;
1099 sctp_pf_inet6_specific = pf;
1100 break;
1101 default:
1102 return 0;
1103 }
1104 return 1;
1105}
1106
1107static inline int init_sctp_mibs(struct net *net)
1108{
1109 return snmp_mib_init((void __percpu **)net->sctp.sctp_statistics,
1110 sizeof(struct sctp_mib),
1111 __alignof__(struct sctp_mib));
1112}
1113
1114static inline void cleanup_sctp_mibs(struct net *net)
1115{
1116 snmp_mib_free((void __percpu **)net->sctp.sctp_statistics);
1117}
1118
1119static void sctp_v4_pf_init(void)
1120{
1121
1122 sctp_register_pf(&sctp_pf_inet, PF_INET);
1123 sctp_register_af(&sctp_af_inet);
1124}
1125
1126static void sctp_v4_pf_exit(void)
1127{
1128 list_del(&sctp_af_inet.list);
1129}
1130
1131static int sctp_v4_protosw_init(void)
1132{
1133 int rc;
1134
1135 rc = proto_register(&sctp_prot, 1);
1136 if (rc)
1137 return rc;
1138
1139
1140 inet_register_protosw(&sctp_seqpacket_protosw);
1141 inet_register_protosw(&sctp_stream_protosw);
1142
1143 return 0;
1144}
1145
1146static void sctp_v4_protosw_exit(void)
1147{
1148 inet_unregister_protosw(&sctp_stream_protosw);
1149 inet_unregister_protosw(&sctp_seqpacket_protosw);
1150 proto_unregister(&sctp_prot);
1151}
1152
1153static int sctp_v4_add_protocol(void)
1154{
1155
1156 register_inetaddr_notifier(&sctp_inetaddr_notifier);
1157
1158
1159 if (inet_add_protocol(&sctp_protocol, IPPROTO_SCTP) < 0)
1160 return -EAGAIN;
1161
1162 return 0;
1163}
1164
1165static void sctp_v4_del_protocol(void)
1166{
1167 inet_del_protocol(&sctp_protocol, IPPROTO_SCTP);
1168 unregister_inetaddr_notifier(&sctp_inetaddr_notifier);
1169}
1170
1171static int __net_init sctp_net_init(struct net *net)
1172{
1173 int status;
1174
1175
1176
1177
1178
1179
1180 net->sctp.rto_initial = SCTP_RTO_INITIAL;
1181
1182 net->sctp.rto_min = SCTP_RTO_MIN;
1183
1184 net->sctp.rto_max = SCTP_RTO_MAX;
1185
1186 net->sctp.rto_alpha = SCTP_RTO_ALPHA;
1187
1188 net->sctp.rto_beta = SCTP_RTO_BETA;
1189
1190
1191 net->sctp.valid_cookie_life = SCTP_DEFAULT_COOKIE_LIFE;
1192
1193
1194 net->sctp.cookie_preserve_enable = 1;
1195
1196
1197#if defined (CONFIG_SCTP_DEFAULT_COOKIE_HMAC_MD5)
1198 net->sctp.sctp_hmac_alg = "md5";
1199#elif defined (CONFIG_SCTP_DEFAULT_COOKIE_HMAC_SHA1)
1200 net->sctp.sctp_hmac_alg = "sha1";
1201#else
1202 net->sctp.sctp_hmac_alg = NULL;
1203#endif
1204
1205
1206 net->sctp.max_burst = SCTP_DEFAULT_MAX_BURST;
1207
1208
1209
1210
1211
1212 net->sctp.max_retrans_association = 10;
1213 net->sctp.max_retrans_path = 5;
1214 net->sctp.max_retrans_init = 8;
1215
1216
1217 net->sctp.sndbuf_policy = 0;
1218
1219
1220 net->sctp.rcvbuf_policy = 0;
1221
1222
1223 net->sctp.hb_interval = SCTP_DEFAULT_TIMEOUT_HEARTBEAT;
1224
1225
1226 net->sctp.sack_timeout = SCTP_DEFAULT_TIMEOUT_SACK;
1227
1228
1229 net->sctp.addip_enable = 0;
1230 net->sctp.addip_noauth = 0;
1231 net->sctp.default_auto_asconf = 0;
1232
1233
1234 net->sctp.prsctp_enable = 1;
1235
1236
1237 net->sctp.auth_enable = 0;
1238
1239
1240 net->sctp.scope_policy = SCTP_SCOPE_POLICY_ENABLE;
1241
1242
1243 net->sctp.rwnd_upd_shift = SCTP_DEFAULT_RWND_SHIFT;
1244
1245
1246 net->sctp.max_autoclose = INT_MAX / HZ;
1247
1248 status = sctp_sysctl_net_register(net);
1249 if (status)
1250 goto err_sysctl_register;
1251
1252
1253 status = init_sctp_mibs(net);
1254 if (status)
1255 goto err_init_mibs;
1256
1257
1258 status = sctp_proc_init(net);
1259 if (status)
1260 goto err_init_proc;
1261
1262 sctp_dbg_objcnt_init(net);
1263
1264
1265 if ((status = sctp_ctl_sock_init(net))) {
1266 pr_err("Failed to initialize the SCTP control sock\n");
1267 goto err_ctl_sock_init;
1268 }
1269
1270
1271 INIT_LIST_HEAD(&net->sctp.local_addr_list);
1272 spin_lock_init(&net->sctp.local_addr_lock);
1273 sctp_get_local_addr_list(net);
1274
1275
1276 INIT_LIST_HEAD(&net->sctp.addr_waitq);
1277 INIT_LIST_HEAD(&net->sctp.auto_asconf_splist);
1278 spin_lock_init(&net->sctp.addr_wq_lock);
1279 net->sctp.addr_wq_timer.expires = 0;
1280 setup_timer(&net->sctp.addr_wq_timer, sctp_addr_wq_timeout_handler,
1281 (unsigned long)net);
1282
1283 return 0;
1284
1285err_ctl_sock_init:
1286 sctp_dbg_objcnt_exit(net);
1287 sctp_proc_exit(net);
1288err_init_proc:
1289 cleanup_sctp_mibs(net);
1290err_init_mibs:
1291 sctp_sysctl_net_unregister(net);
1292err_sysctl_register:
1293 return status;
1294}
1295
1296static void __net_exit sctp_net_exit(struct net *net)
1297{
1298
1299 sctp_free_addr_wq(net);
1300 sctp_free_local_addr_list(net);
1301
1302
1303 inet_ctl_sock_destroy(net->sctp.ctl_sock);
1304
1305 sctp_dbg_objcnt_exit(net);
1306
1307 sctp_proc_exit(net);
1308 cleanup_sctp_mibs(net);
1309 sctp_sysctl_net_unregister(net);
1310}
1311
1312static struct pernet_operations sctp_net_ops = {
1313 .init = sctp_net_init,
1314 .exit = sctp_net_exit,
1315};
1316
1317
1318static __init int sctp_init(void)
1319{
1320 int i;
1321 int status = -EINVAL;
1322 unsigned long goal;
1323 unsigned long limit;
1324 int max_share;
1325 int order;
1326
1327 BUILD_BUG_ON(sizeof(struct sctp_ulpevent) >
1328 sizeof(((struct sk_buff *) 0)->cb));
1329
1330
1331 status = -ENOBUFS;
1332 sctp_bucket_cachep = kmem_cache_create("sctp_bind_bucket",
1333 sizeof(struct sctp_bind_bucket),
1334 0, SLAB_HWCACHE_ALIGN,
1335 NULL);
1336 if (!sctp_bucket_cachep)
1337 goto out;
1338
1339 sctp_chunk_cachep = kmem_cache_create("sctp_chunk",
1340 sizeof(struct sctp_chunk),
1341 0, SLAB_HWCACHE_ALIGN,
1342 NULL);
1343 if (!sctp_chunk_cachep)
1344 goto err_chunk_cachep;
1345
1346 status = percpu_counter_init(&sctp_sockets_allocated, 0);
1347 if (status)
1348 goto err_percpu_counter_init;
1349
1350
1351
1352
1353 sctp_max_instreams = SCTP_DEFAULT_INSTREAMS;
1354 sctp_max_outstreams = SCTP_DEFAULT_OUTSTREAMS;
1355
1356
1357 idr_init(&sctp_assocs_id);
1358
1359 limit = nr_free_buffer_pages() / 8;
1360 limit = max(limit, 128UL);
1361 sysctl_sctp_mem[0] = limit / 4 * 3;
1362 sysctl_sctp_mem[1] = limit;
1363 sysctl_sctp_mem[2] = sysctl_sctp_mem[0] * 2;
1364
1365
1366 limit = (sysctl_sctp_mem[1]) << (PAGE_SHIFT - 7);
1367 max_share = min(4UL*1024*1024, limit);
1368
1369 sysctl_sctp_rmem[0] = SK_MEM_QUANTUM;
1370 sysctl_sctp_rmem[1] = 1500 * SKB_TRUESIZE(1);
1371 sysctl_sctp_rmem[2] = max(sysctl_sctp_rmem[1], max_share);
1372
1373 sysctl_sctp_wmem[0] = SK_MEM_QUANTUM;
1374 sysctl_sctp_wmem[1] = 16*1024;
1375 sysctl_sctp_wmem[2] = max(64*1024, max_share);
1376
1377
1378
1379
1380 if (totalram_pages >= (128 * 1024))
1381 goal = totalram_pages >> (22 - PAGE_SHIFT);
1382 else
1383 goal = totalram_pages >> (24 - PAGE_SHIFT);
1384
1385 for (order = 0; (1UL << order) < goal; order++)
1386 ;
1387
1388 do {
1389 sctp_assoc_hashsize = (1UL << order) * PAGE_SIZE /
1390 sizeof(struct sctp_hashbucket);
1391 if ((sctp_assoc_hashsize > (64 * 1024)) && order > 0)
1392 continue;
1393 sctp_assoc_hashtable = (struct sctp_hashbucket *)
1394 __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, order);
1395 } while (!sctp_assoc_hashtable && --order > 0);
1396 if (!sctp_assoc_hashtable) {
1397 pr_err("Failed association hash alloc\n");
1398 status = -ENOMEM;
1399 goto err_ahash_alloc;
1400 }
1401 for (i = 0; i < sctp_assoc_hashsize; i++) {
1402 rwlock_init(&sctp_assoc_hashtable[i].lock);
1403 INIT_HLIST_HEAD(&sctp_assoc_hashtable[i].chain);
1404 }
1405
1406
1407 sctp_ep_hashsize = 64;
1408 sctp_ep_hashtable =
1409 kmalloc(64 * sizeof(struct sctp_hashbucket), GFP_KERNEL);
1410 if (!sctp_ep_hashtable) {
1411 pr_err("Failed endpoint_hash alloc\n");
1412 status = -ENOMEM;
1413 goto err_ehash_alloc;
1414 }
1415 for (i = 0; i < sctp_ep_hashsize; i++) {
1416 rwlock_init(&sctp_ep_hashtable[i].lock);
1417 INIT_HLIST_HEAD(&sctp_ep_hashtable[i].chain);
1418 }
1419
1420
1421 do {
1422 sctp_port_hashsize = (1UL << order) * PAGE_SIZE /
1423 sizeof(struct sctp_bind_hashbucket);
1424 if ((sctp_port_hashsize > (64 * 1024)) && order > 0)
1425 continue;
1426 sctp_port_hashtable = (struct sctp_bind_hashbucket *)
1427 __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, order);
1428 } while (!sctp_port_hashtable && --order > 0);
1429 if (!sctp_port_hashtable) {
1430 pr_err("Failed bind hash alloc\n");
1431 status = -ENOMEM;
1432 goto err_bhash_alloc;
1433 }
1434 for (i = 0; i < sctp_port_hashsize; i++) {
1435 spin_lock_init(&sctp_port_hashtable[i].lock);
1436 INIT_HLIST_HEAD(&sctp_port_hashtable[i].chain);
1437 }
1438
1439 pr_info("Hash tables configured (established %d bind %d)\n",
1440 sctp_assoc_hashsize, sctp_port_hashsize);
1441
1442 sctp_sysctl_register();
1443
1444 INIT_LIST_HEAD(&sctp_address_families);
1445 sctp_v4_pf_init();
1446 sctp_v6_pf_init();
1447
1448 status = sctp_v4_protosw_init();
1449
1450 if (status)
1451 goto err_protosw_init;
1452
1453 status = sctp_v6_protosw_init();
1454 if (status)
1455 goto err_v6_protosw_init;
1456
1457 status = register_pernet_subsys(&sctp_net_ops);
1458 if (status)
1459 goto err_register_pernet_subsys;
1460
1461 status = sctp_v4_add_protocol();
1462 if (status)
1463 goto err_add_protocol;
1464
1465
1466 status = sctp_v6_add_protocol();
1467 if (status)
1468 goto err_v6_add_protocol;
1469
1470 status = 0;
1471out:
1472 return status;
1473err_v6_add_protocol:
1474 sctp_v4_del_protocol();
1475err_add_protocol:
1476 unregister_pernet_subsys(&sctp_net_ops);
1477err_register_pernet_subsys:
1478 sctp_v6_protosw_exit();
1479err_v6_protosw_init:
1480 sctp_v4_protosw_exit();
1481err_protosw_init:
1482 sctp_v4_pf_exit();
1483 sctp_v6_pf_exit();
1484 sctp_sysctl_unregister();
1485 free_pages((unsigned long)sctp_port_hashtable,
1486 get_order(sctp_port_hashsize *
1487 sizeof(struct sctp_bind_hashbucket)));
1488err_bhash_alloc:
1489 kfree(sctp_ep_hashtable);
1490err_ehash_alloc:
1491 free_pages((unsigned long)sctp_assoc_hashtable,
1492 get_order(sctp_assoc_hashsize *
1493 sizeof(struct sctp_hashbucket)));
1494err_ahash_alloc:
1495 percpu_counter_destroy(&sctp_sockets_allocated);
1496err_percpu_counter_init:
1497 kmem_cache_destroy(sctp_chunk_cachep);
1498err_chunk_cachep:
1499 kmem_cache_destroy(sctp_bucket_cachep);
1500 goto out;
1501}
1502
1503
1504static __exit void sctp_exit(void)
1505{
1506
1507
1508
1509
1510
1511 sctp_v6_del_protocol();
1512 sctp_v4_del_protocol();
1513
1514 unregister_pernet_subsys(&sctp_net_ops);
1515
1516
1517 sctp_v6_protosw_exit();
1518 sctp_v4_protosw_exit();
1519
1520
1521 sctp_v6_pf_exit();
1522 sctp_v4_pf_exit();
1523
1524 sctp_sysctl_unregister();
1525
1526 free_pages((unsigned long)sctp_assoc_hashtable,
1527 get_order(sctp_assoc_hashsize *
1528 sizeof(struct sctp_hashbucket)));
1529 kfree(sctp_ep_hashtable);
1530 free_pages((unsigned long)sctp_port_hashtable,
1531 get_order(sctp_port_hashsize *
1532 sizeof(struct sctp_bind_hashbucket)));
1533
1534 percpu_counter_destroy(&sctp_sockets_allocated);
1535
1536 rcu_barrier();
1537
1538 kmem_cache_destroy(sctp_chunk_cachep);
1539 kmem_cache_destroy(sctp_bucket_cachep);
1540}
1541
1542module_init(sctp_init);
1543module_exit(sctp_exit);
1544
1545
1546
1547
1548MODULE_ALIAS("net-pf-" __stringify(PF_INET) "-proto-132");
1549MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-132");
1550MODULE_AUTHOR("Linux Kernel SCTP developers <lksctp-developers@lists.sourceforge.net>");
1551MODULE_DESCRIPTION("Support for the SCTP protocol (RFC2960)");
1552module_param_named(no_checksums, sctp_checksum_disable, bool, 0644);
1553MODULE_PARM_DESC(no_checksums, "Disable checksums computing and verification");
1554MODULE_LICENSE("GPL");
1555