projects/linux·blob master · refs

1725 lines · 45.6 KiB

1// SPDX-License-Identifier: GPL-2.0-or-later
2/* SCTP kernel implementation
3 * (C) Copyright IBM Corp. 2001, 2004
4 * Copyright (c) 1999-2000 Cisco, Inc.
5 * Copyright (c) 1999-2001 Motorola, Inc.
6 * Copyright (c) 2001 Intel Corp.
7 * Copyright (c) 2001 Nokia, Inc.
8 * Copyright (c) 2001 La Monte H.P. Yarroll
9 *
10 * This file is part of the SCTP kernel implementation
11 *
12 * Initialization/cleanup for SCTP protocol support.
13 *
14 * Please send any bug reports or fixes you make to the
15 * email address(es):
16 * lksctp developers <[email protected]>
17 *
18 * Written or modified by:
19 * La Monte H.P. Yarroll <[email protected]>
20 * Karl Knutson <[email protected]>
21 * Jon Grimm <[email protected]>
22 * Sridhar Samudrala <[email protected]>
23 * Daisy Chang <[email protected]>
24 * Ardelle Fan <[email protected]>
25 */
26
27#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
28
29#include <linux/module.h>
30#include <linux/init.h>
31#include <linux/netdevice.h>
32#include <linux/inetdevice.h>
33#include <linux/seq_file.h>
34#include <linux/memblock.h>
35#include <linux/highmem.h>
36#include <linux/slab.h>
37#include <net/flow.h>
38#include <net/net_namespace.h>
39#include <net/protocol.h>
40#include <net/ip.h>
41#include <net/ipv6.h>
42#include <net/route.h>
43#include <net/sctp/sctp.h>
44#include <net/addrconf.h>
45#include <net/inet_common.h>
46#include <net/inet_ecn.h>
47#include <net/inet_sock.h>
48#include <net/udp_tunnel.h>
49#include <net/inet_dscp.h>
50
51#define MAX_SCTP_PORT_HASH_ENTRIES (64 * 1024)
52
53/* Global data structures. */
54struct sctp_globals sctp_globals __read_mostly;
55
56struct idr sctp_assocs_id;
57DEFINE_SPINLOCK(sctp_assocs_id_lock);
58
59static struct sctp_pf *sctp_pf_inet6_specific;
60static struct sctp_pf *sctp_pf_inet_specific;
61static struct sctp_af *sctp_af_v4_specific;
62static struct sctp_af *sctp_af_v6_specific;
63
64struct kmem_cache *sctp_chunk_cachep __read_mostly;
65struct kmem_cache *sctp_bucket_cachep __read_mostly;
66
67long sysctl_sctp_mem[3];
68int sysctl_sctp_rmem[3];
69int sysctl_sctp_wmem[3];
70
71/* Private helper to extract ipv4 address and stash them in
72 * the protocol structure.
73 */
74static void sctp_v4_copy_addrlist(struct list_head *addrlist,
75 struct net_device *dev)
76{
77 struct in_device *in_dev;
78 struct in_ifaddr *ifa;
79 struct sctp_sockaddr_entry *addr;
80
81 rcu_read_lock();
82 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
83 rcu_read_unlock();
84 return;
85 }
86
87 in_dev_for_each_ifa_rcu(ifa, in_dev) {
88 /* Add the address to the local list. */
89 addr = kzalloc_obj(*addr, GFP_ATOMIC);
90 if (addr) {
91 addr->a.v4.sin_family = AF_INET;
92 addr->a.v4.sin_addr.s_addr = ifa->ifa_local;
93 addr->valid = 1;
94 INIT_LIST_HEAD(&addr->list);
95 list_add_tail(&addr->list, addrlist);
96 }
97 }
98
99 rcu_read_unlock();
100}
101
102/* Extract our IP addresses from the system and stash them in the
103 * protocol structure.
104 */
105static void sctp_get_local_addr_list(struct net *net)
106{
107 struct net_device *dev;
108 struct list_head *pos;
109 struct sctp_af *af;
110
111 rcu_read_lock();
112 for_each_netdev_rcu(net, dev) {
113 list_for_each(pos, &sctp_address_families) {
114 af = list_entry(pos, struct sctp_af, list);
115 af->copy_addrlist(&net->sctp.local_addr_list, dev);
116 }
117 }
118 rcu_read_unlock();
119}
120
121/* Free the existing local addresses. */
122static void sctp_free_local_addr_list(struct net *net)
123{
124 struct sctp_sockaddr_entry *addr;
125 struct list_head *pos, *temp;
126
127 list_for_each_safe(pos, temp, &net->sctp.local_addr_list) {
128 addr = list_entry(pos, struct sctp_sockaddr_entry, list);
129 list_del(pos);
130 kfree(addr);
131 }
132}
133
134/* Copy the local addresses which are valid for 'scope' into 'bp'. */
135int sctp_copy_local_addr_list(struct net *net, struct sctp_bind_addr *bp,
136 enum sctp_scope scope, gfp_t gfp, int copy_flags)
137{
138 struct sctp_sockaddr_entry *addr;
139 union sctp_addr laddr;
140 int error = 0;
141
142 rcu_read_lock();
143 list_for_each_entry_rcu(addr, &net->sctp.local_addr_list, list) {
144 if (!addr->valid)
145 continue;
146 if (!sctp_in_scope(net, &addr->a, scope))
147 continue;
148
149 /* Now that the address is in scope, check to see if
150 * the address type is really supported by the local
151 * sock as well as the remote peer.
152 */
153 if (addr->a.sa.sa_family == AF_INET &&
154 (!(copy_flags & SCTP_ADDR4_ALLOWED) ||
155 !(copy_flags & SCTP_ADDR4_PEERSUPP)))
156 continue;
157 if (addr->a.sa.sa_family == AF_INET6 &&
158 (!(copy_flags & SCTP_ADDR6_ALLOWED) ||
159 !(copy_flags & SCTP_ADDR6_PEERSUPP)))
160 continue;
161
162 laddr = addr->a;
163 /* also works for setting ipv6 address port */
164 laddr.v4.sin_port = htons(bp->port);
165 if (sctp_bind_addr_state(bp, &laddr) != -1)
166 continue;
167
168 error = sctp_add_bind_addr(bp, &addr->a, sizeof(addr->a),
169 SCTP_ADDR_SRC, GFP_ATOMIC);
170 if (error)
171 break;
172 }
173
174 rcu_read_unlock();
175 return error;
176}
177
178/* Copy over any ip options */
179static void sctp_v4_copy_ip_options(struct sock *sk, struct sock *newsk)
180{
181 struct inet_sock *newinet, *inet = inet_sk(sk);
182 struct ip_options_rcu *inet_opt, *newopt = NULL;
183
184 newinet = inet_sk(newsk);
185
186 rcu_read_lock();
187 inet_opt = rcu_dereference(inet->inet_opt);
188 if (inet_opt) {
189 newopt = sock_kmemdup(newsk, inet_opt, sizeof(*inet_opt) +
190 inet_opt->opt.optlen, GFP_ATOMIC);
191 if (!newopt)
192 pr_err("%s: Failed to copy ip options\n", __func__);
193 }
194 RCU_INIT_POINTER(newinet->inet_opt, newopt);
195 rcu_read_unlock();
196}
197
198/* Account for the IP options */
199static int sctp_v4_ip_options_len(struct sock *sk)
200{
201 struct inet_sock *inet = inet_sk(sk);
202 struct ip_options_rcu *inet_opt;
203 int len = 0;
204
205 rcu_read_lock();
206 inet_opt = rcu_dereference(inet->inet_opt);
207 if (inet_opt)
208 len = inet_opt->opt.optlen;
209
210 rcu_read_unlock();
211 return len;
212}
213
214/* Initialize a sctp_addr from in incoming skb. */
215static void sctp_v4_from_skb(union sctp_addr *addr, struct sk_buff *skb,
216 int is_saddr)
217{
218 /* Always called on head skb, so this is safe */
219 struct sctphdr *sh = sctp_hdr(skb);
220 struct sockaddr_in *sa = &addr->v4;
221
222 addr->v4.sin_family = AF_INET;
223
224 if (is_saddr) {
225 sa->sin_port = sh->source;
226 sa->sin_addr.s_addr = ip_hdr(skb)->saddr;
227 } else {
228 sa->sin_port = sh->dest;
229 sa->sin_addr.s_addr = ip_hdr(skb)->daddr;
230 }
231 memset(sa->sin_zero, 0, sizeof(sa->sin_zero));
232}
233
234/* Initialize an sctp_addr from a socket. */
235static void sctp_v4_from_sk(union sctp_addr *addr, struct sock *sk)
236{
237 addr->v4.sin_family = AF_INET;
238 addr->v4.sin_port = 0;
239 addr->v4.sin_addr.s_addr = inet_sk(sk)->inet_rcv_saddr;
240 memset(addr->v4.sin_zero, 0, sizeof(addr->v4.sin_zero));
241}
242
243/* Initialize sk->sk_rcv_saddr from sctp_addr. */
244static void sctp_v4_to_sk_saddr(union sctp_addr *addr, struct sock *sk)
245{
246 inet_sk(sk)->inet_rcv_saddr = addr->v4.sin_addr.s_addr;
247}
248
249/* Initialize sk->sk_daddr from sctp_addr. */
250static void sctp_v4_to_sk_daddr(union sctp_addr *addr, struct sock *sk)
251{
252 inet_sk(sk)->inet_daddr = addr->v4.sin_addr.s_addr;
253}
254
255/* Initialize a sctp_addr from an address parameter. */
256static bool sctp_v4_from_addr_param(union sctp_addr *addr,
257 union sctp_addr_param *param,
258 __be16 port, int iif)
259{
260 if (ntohs(param->v4.param_hdr.length) < sizeof(struct sctp_ipv4addr_param))
261 return false;
262
263 addr->v4.sin_family = AF_INET;
264 addr->v4.sin_port = port;
265 addr->v4.sin_addr.s_addr = param->v4.addr.s_addr;
266 memset(addr->v4.sin_zero, 0, sizeof(addr->v4.sin_zero));
267
268 return true;
269}
270
271/* Initialize an address parameter from a sctp_addr and return the length
272 * of the address parameter.
273 */
274static int sctp_v4_to_addr_param(const union sctp_addr *addr,
275 union sctp_addr_param *param)
276{
277 int length = sizeof(struct sctp_ipv4addr_param);
278
279 param->v4.param_hdr.type = SCTP_PARAM_IPV4_ADDRESS;
280 param->v4.param_hdr.length = htons(length);
281 param->v4.addr.s_addr = addr->v4.sin_addr.s_addr;
282
283 return length;
284}
285
286/* Initialize a sctp_addr from a dst_entry. */
287static void sctp_v4_dst_saddr(union sctp_addr *saddr, struct flowi4 *fl4,
288 __be16 port)
289{
290 saddr->v4.sin_family = AF_INET;
291 saddr->v4.sin_port = port;
292 saddr->v4.sin_addr.s_addr = fl4->saddr;
293 memset(saddr->v4.sin_zero, 0, sizeof(saddr->v4.sin_zero));
294}
295
296/* Compare two addresses exactly. */
297static int sctp_v4_cmp_addr(const union sctp_addr *addr1,
298 const union sctp_addr *addr2)
299{
300 if (addr1->sa.sa_family != addr2->sa.sa_family)
301 return 0;
302 if (addr1->v4.sin_port != addr2->v4.sin_port)
303 return 0;
304 if (addr1->v4.sin_addr.s_addr != addr2->v4.sin_addr.s_addr)
305 return 0;
306
307 return 1;
308}
309
310/* Initialize addr struct to INADDR_ANY. */
311static void sctp_v4_inaddr_any(union sctp_addr *addr, __be16 port)
312{
313 addr->v4.sin_family = AF_INET;
314 addr->v4.sin_addr.s_addr = htonl(INADDR_ANY);
315 addr->v4.sin_port = port;
316 memset(addr->v4.sin_zero, 0, sizeof(addr->v4.sin_zero));
317}
318
319/* Is this a wildcard address? */
320static int sctp_v4_is_any(const union sctp_addr *addr)
321{
322 return htonl(INADDR_ANY) == addr->v4.sin_addr.s_addr;
323}
324
325/* This function checks if the address is a valid address to be used for
326 * SCTP binding.
327 *
328 * Output:
329 * Return 0 - If the address is a non-unicast or an illegal address.
330 * Return 1 - If the address is a unicast.
331 */
332static int sctp_v4_addr_valid(union sctp_addr *addr,
333 struct sctp_sock *sp,
334 const struct sk_buff *skb)
335{
336 /* IPv4 addresses not allowed */
337 if (sp && ipv6_only_sock(sctp_opt2sk(sp)))
338 return 0;
339
340 /* Is this a non-unicast address or a unusable SCTP address? */
341 if (IS_IPV4_UNUSABLE_ADDRESS(addr->v4.sin_addr.s_addr))
342 return 0;
343
344 /* Is this a broadcast address? */
345 if (skb && skb_rtable(skb)->rt_flags & RTCF_BROADCAST)
346 return 0;
347
348 return 1;
349}
350
351/* Should this be available for binding? */
352static int sctp_v4_available(union sctp_addr *addr, struct sctp_sock *sp)
353{
354 struct sock *sk = &sp->inet.sk;
355 struct net *net = sock_net(sk);
356 int tb_id = RT_TABLE_LOCAL;
357 int ret;
358
359 tb_id = l3mdev_fib_table_by_index(net, sk->sk_bound_dev_if) ?: tb_id;
360 ret = inet_addr_type_table(net, addr->v4.sin_addr.s_addr, tb_id);
361 if (addr->v4.sin_addr.s_addr != htonl(INADDR_ANY) &&
362 ret != RTN_LOCAL &&
363 !inet_test_bit(FREEBIND, sk) &&
364 !READ_ONCE(net->ipv4.sysctl_ip_nonlocal_bind))
365 return 0;
366
367 if (ipv6_only_sock(sctp_opt2sk(sp)))
368 return 0;
369
370 return 1;
371}
372
373/* Checking the loopback, private and other address scopes as defined in
374 * RFC 1918. The IPv4 scoping is based on the draft for SCTP IPv4
375 * scoping <draft-stewart-tsvwg-sctp-ipv4-00.txt>.
376 *
377 * Level 0 - unusable SCTP addresses
378 * Level 1 - loopback address
379 * Level 2 - link-local addresses
380 * Level 3 - private addresses.
381 * Level 4 - global addresses
382 * For INIT and INIT-ACK address list, let L be the level of
383 * requested destination address, sender and receiver
384 * SHOULD include all of its addresses with level greater
385 * than or equal to L.
386 *
387 * IPv4 scoping can be controlled through sysctl option
388 * net.sctp.addr_scope_policy
389 */
390static enum sctp_scope sctp_v4_scope(union sctp_addr *addr)
391{
392 enum sctp_scope retval;
393
394 /* Check for unusable SCTP addresses. */
395 if (IS_IPV4_UNUSABLE_ADDRESS(addr->v4.sin_addr.s_addr)) {
396 retval = SCTP_SCOPE_UNUSABLE;
397 } else if (ipv4_is_loopback(addr->v4.sin_addr.s_addr)) {
398 retval = SCTP_SCOPE_LOOPBACK;
399 } else if (ipv4_is_linklocal_169(addr->v4.sin_addr.s_addr)) {
400 retval = SCTP_SCOPE_LINK;
401 } else if (ipv4_is_private_10(addr->v4.sin_addr.s_addr) ||
402 ipv4_is_private_172(addr->v4.sin_addr.s_addr) ||
403 ipv4_is_private_192(addr->v4.sin_addr.s_addr) ||
404 ipv4_is_test_198(addr->v4.sin_addr.s_addr)) {
405 retval = SCTP_SCOPE_PRIVATE;
406 } else {
407 retval = SCTP_SCOPE_GLOBAL;
408 }
409
410 return retval;
411}
412
413/* Returns a valid dst cache entry for the given source and destination ip
414 * addresses. If an association is passed, trys to get a dst entry with a
415 * source address that matches an address in the bind address list.
416 */
417static void sctp_v4_get_dst(struct sctp_transport *t, union sctp_addr *saddr,
418 struct flowi *fl, struct sock *sk)
419{
420 struct sctp_association *asoc = t->asoc;
421 struct rtable *rt;
422 struct flowi _fl;
423 struct flowi4 *fl4 = &_fl.u.ip4;
424 struct sctp_bind_addr *bp;
425 struct sctp_sockaddr_entry *laddr;
426 struct dst_entry *dst = NULL;
427 union sctp_addr *daddr = &t->ipaddr;
428 union sctp_addr dst_saddr;
429 dscp_t dscp;
430
431 if (t->dscp & SCTP_DSCP_SET_MASK)
432 dscp = inet_dsfield_to_dscp(t->dscp);
433 else
434 dscp = inet_sk_dscp(inet_sk(sk));
435
436 memset(&_fl, 0x0, sizeof(_fl));
437 fl4->daddr = daddr->v4.sin_addr.s_addr;
438 fl4->fl4_dport = daddr->v4.sin_port;
439 fl4->flowi4_proto = IPPROTO_SCTP;
440 if (asoc) {
441 fl4->flowi4_dscp = dscp;
442 fl4->flowi4_scope = ip_sock_rt_scope(asoc->base.sk);
443 fl4->flowi4_oif = asoc->base.sk->sk_bound_dev_if;
444 fl4->fl4_sport = htons(asoc->base.bind_addr.port);
445 }
446 if (saddr) {
447 fl4->saddr = saddr->v4.sin_addr.s_addr;
448 if (!fl4->fl4_sport)
449 fl4->fl4_sport = saddr->v4.sin_port;
450 }
451
452 pr_debug("%s: dst:%pI4, src:%pI4 - ", __func__, &fl4->daddr,
453 &fl4->saddr);
454
455 rt = ip_route_output_key(sock_net(sk), fl4);
456 if (!IS_ERR(rt)) {
457 dst = &rt->dst;
458 t->dst = dst;
459 memcpy(fl, &_fl, sizeof(_fl));
460 }
461
462 /* If there is no association or if a source address is passed, no
463 * more validation is required.
464 */
465 if (!asoc || saddr)
466 goto out;
467
468 bp = &asoc->base.bind_addr;
469
470 if (dst) {
471 /* Walk through the bind address list and look for a bind
472 * address that matches the source address of the returned dst.
473 */
474 sctp_v4_dst_saddr(&dst_saddr, fl4, htons(bp->port));
475 rcu_read_lock();
476 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
477 if (!laddr->valid || (laddr->state == SCTP_ADDR_DEL) ||
478 (laddr->state != SCTP_ADDR_SRC &&
479 !asoc->src_out_of_asoc_ok))
480 continue;
481 if (sctp_v4_cmp_addr(&dst_saddr, &laddr->a))
482 goto out_unlock;
483 }
484 rcu_read_unlock();
485
486 /* None of the bound addresses match the source address of the
487 * dst. So release it.
488 */
489 dst_release(dst);
490 dst = NULL;
491 }
492
493 /* Walk through the bind address list and try to get a dst that
494 * matches a bind address as the source address.
495 */
496 rcu_read_lock();
497 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
498 struct net_device *odev;
499
500 if (!laddr->valid)
501 continue;
502 if (laddr->state != SCTP_ADDR_SRC ||
503 AF_INET != laddr->a.sa.sa_family)
504 continue;
505
506 fl4->fl4_sport = laddr->a.v4.sin_port;
507 flowi4_update_output(fl4, asoc->base.sk->sk_bound_dev_if,
508 daddr->v4.sin_addr.s_addr,
509 laddr->a.v4.sin_addr.s_addr);
510
511 rt = ip_route_output_key(sock_net(sk), fl4);
512 if (IS_ERR(rt))
513 continue;
514
515 /* Ensure the src address belongs to the output
516 * interface.
517 */
518 odev = __ip_dev_find(sock_net(sk), laddr->a.v4.sin_addr.s_addr,
519 false);
520 if (!odev || odev->ifindex != fl4->flowi4_oif) {
521 if (!dst) {
522 dst = &rt->dst;
523 t->dst = dst;
524 memcpy(fl, &_fl, sizeof(_fl));
525 } else {
526 dst_release(&rt->dst);
527 }
528 continue;
529 }
530
531 dst_release(dst);
532 dst = &rt->dst;
533 t->dst = dst;
534 memcpy(fl, &_fl, sizeof(_fl));
535 break;
536 }
537
538out_unlock:
539 rcu_read_unlock();
540out:
541 if (dst) {
542 pr_debug("rt_dst:%pI4, rt_src:%pI4\n",
543 &fl->u.ip4.daddr, &fl->u.ip4.saddr);
544 } else {
545 t->dst = NULL;
546 pr_debug("no route\n");
547 }
548}
549
550/* For v4, the source address is cached in the route entry(dst). So no need
551 * to cache it separately and hence this is an empty routine.
552 */
553static void sctp_v4_get_saddr(struct sctp_sock *sk,
554 struct sctp_transport *t,
555 struct flowi *fl)
556{
557 union sctp_addr *saddr = &t->saddr;
558 struct rtable *rt = dst_rtable(t->dst);
559
560 if (rt) {
561 saddr->v4.sin_family = AF_INET;
562 saddr->v4.sin_addr.s_addr = fl->u.ip4.saddr;
563 }
564}
565
566/* What interface did this skb arrive on? */
567static int sctp_v4_skb_iif(const struct sk_buff *skb)
568{
569 return inet_iif(skb);
570}
571
572static int sctp_v4_skb_sdif(const struct sk_buff *skb)
573{
574 return inet_sdif(skb);
575}
576
577/* Was this packet marked by Explicit Congestion Notification? */
578static int sctp_v4_is_ce(const struct sk_buff *skb)
579{
580 return INET_ECN_is_ce(ip_hdr(skb)->tos);
581}
582
583static int sctp_v4_addr_to_user(struct sctp_sock *sp, union sctp_addr *addr)
584{
585 /* No address mapping for V4 sockets */
586 memset(addr->v4.sin_zero, 0, sizeof(addr->v4.sin_zero));
587 return sizeof(struct sockaddr_in);
588}
589
590/* Dump the v4 addr to the seq file. */
591static void sctp_v4_seq_dump_addr(struct seq_file *seq, union sctp_addr *addr)
592{
593 seq_printf(seq, "%pI4 ", &addr->v4.sin_addr);
594}
595
596static void sctp_v4_ecn_capable(struct sock *sk)
597{
598 INET_ECN_xmit(sk);
599}
600
601static void sctp_addr_wq_timeout_handler(struct timer_list *t)
602{
603 struct net *net = timer_container_of(net, t, sctp.addr_wq_timer);
604 struct sctp_sockaddr_entry *addrw, *temp;
605 struct sctp_sock *sp;
606
607 spin_lock_bh(&net->sctp.addr_wq_lock);
608
609 list_for_each_entry_safe(addrw, temp, &net->sctp.addr_waitq, list) {
610 pr_debug("%s: the first ent in wq:%p is addr:%pISc for cmd:%d at "
611 "entry:%p\n", __func__, &net->sctp.addr_waitq, &addrw->a.sa,
612 addrw->state, addrw);
613
614#if IS_ENABLED(CONFIG_IPV6)
615 /* Now we send an ASCONF for each association */
616 /* Note. we currently don't handle link local IPv6 addressees */
617 if (addrw->a.sa.sa_family == AF_INET6) {
618 struct in6_addr *in6;
619
620 if (ipv6_addr_type(&addrw->a.v6.sin6_addr) &
621 IPV6_ADDR_LINKLOCAL)
622 goto free_next;
623
624 in6 = (struct in6_addr *)&addrw->a.v6.sin6_addr;
625 if (ipv6_chk_addr(net, in6, NULL, 0) == 0 &&
626 addrw->state == SCTP_ADDR_NEW) {
627 unsigned long timeo_val;
628
629 pr_debug("%s: this is on DAD, trying %d sec "
630 "later\n", __func__,
631 SCTP_ADDRESS_TICK_DELAY);
632
633 timeo_val = jiffies;
634 timeo_val += msecs_to_jiffies(SCTP_ADDRESS_TICK_DELAY);
635 mod_timer(&net->sctp.addr_wq_timer, timeo_val);
636 break;
637 }
638 }
639#endif
640 list_for_each_entry(sp, &net->sctp.auto_asconf_splist, auto_asconf_list) {
641 struct sock *sk;
642
643 sk = sctp_opt2sk(sp);
644 /* ignore bound-specific endpoints */
645 if (!sctp_is_ep_boundall(sk))
646 continue;
647 bh_lock_sock(sk);
648 if (sctp_asconf_mgmt(sp, addrw) < 0)
649 pr_debug("%s: sctp_asconf_mgmt failed\n", __func__);
650 bh_unlock_sock(sk);
651 }
652#if IS_ENABLED(CONFIG_IPV6)
653free_next:
654#endif
655 list_del(&addrw->list);
656 kfree(addrw);
657 }
658 spin_unlock_bh(&net->sctp.addr_wq_lock);
659}
660
661static void sctp_free_addr_wq(struct net *net)
662{
663 struct sctp_sockaddr_entry *addrw;
664 struct sctp_sockaddr_entry *temp;
665
666 timer_shutdown_sync(&net->sctp.addr_wq_timer);
667
668 spin_lock_bh(&net->sctp.addr_wq_lock);
669 list_for_each_entry_safe(addrw, temp, &net->sctp.addr_waitq, list) {
670 list_del(&addrw->list);
671 kfree(addrw);
672 }
673 spin_unlock_bh(&net->sctp.addr_wq_lock);
674}
675
676/* lookup the entry for the same address in the addr_waitq
677 * sctp_addr_wq MUST be locked
678 */
679static struct sctp_sockaddr_entry *sctp_addr_wq_lookup(struct net *net,
680 struct sctp_sockaddr_entry *addr)
681{
682 struct sctp_sockaddr_entry *addrw;
683
684 list_for_each_entry(addrw, &net->sctp.addr_waitq, list) {
685 if (addrw->a.sa.sa_family != addr->a.sa.sa_family)
686 continue;
687 if (addrw->a.sa.sa_family == AF_INET) {
688 if (addrw->a.v4.sin_addr.s_addr ==
689 addr->a.v4.sin_addr.s_addr)
690 return addrw;
691 } else if (addrw->a.sa.sa_family == AF_INET6) {
692 if (ipv6_addr_equal(&addrw->a.v6.sin6_addr,
693 &addr->a.v6.sin6_addr))
694 return addrw;
695 }
696 }
697 return NULL;
698}
699
700void sctp_addr_wq_mgmt(struct net *net, struct sctp_sockaddr_entry *addr, int cmd)
701{
702 struct sctp_sockaddr_entry *addrw;
703 unsigned long timeo_val;
704
705 /* first, we check if an opposite message already exist in the queue.
706 * If we found such message, it is removed.
707 * This operation is a bit stupid, but the DHCP client attaches the
708 * new address after a couple of addition and deletion of that address
709 */
710
711 spin_lock_bh(&net->sctp.addr_wq_lock);
712
713 /* Avoid searching the queue or modifying it if there are no consumers,
714 * as it can lead to performance degradation if addresses are modified
715 * en-masse.
716 *
717 * If the queue already contains some events, update it anyway to avoid
718 * ugly races between new sessions and new address events.
719 */
720 if (list_empty(&net->sctp.auto_asconf_splist) &&
721 list_empty(&net->sctp.addr_waitq)) {
722 spin_unlock_bh(&net->sctp.addr_wq_lock);
723 return;
724 }
725
726 /* Offsets existing events in addr_wq */
727 addrw = sctp_addr_wq_lookup(net, addr);
728 if (addrw) {
729 if (addrw->state != cmd) {
730 pr_debug("%s: offsets existing entry for %d, addr:%pISc "
731 "in wq:%p\n", __func__, addrw->state, &addrw->a.sa,
732 &net->sctp.addr_waitq);
733
734 list_del(&addrw->list);
735 kfree(addrw);
736 }
737 spin_unlock_bh(&net->sctp.addr_wq_lock);
738 return;
739 }
740
741 /* OK, we have to add the new address to the wait queue */
742 addrw = kmemdup(addr, sizeof(struct sctp_sockaddr_entry), GFP_ATOMIC);
743 if (addrw == NULL) {
744 spin_unlock_bh(&net->sctp.addr_wq_lock);
745 return;
746 }
747 addrw->state = cmd;
748 list_add_tail(&addrw->list, &net->sctp.addr_waitq);
749
750 pr_debug("%s: add new entry for cmd:%d, addr:%pISc in wq:%p\n",
751 __func__, addrw->state, &addrw->a.sa, &net->sctp.addr_waitq);
752
753 if (!timer_pending(&net->sctp.addr_wq_timer)) {
754 timeo_val = jiffies;
755 timeo_val += msecs_to_jiffies(SCTP_ADDRESS_TICK_DELAY);
756 mod_timer(&net->sctp.addr_wq_timer, timeo_val);
757 }
758 spin_unlock_bh(&net->sctp.addr_wq_lock);
759}
760
761/* Event handler for inet address addition/deletion events.
762 * The sctp_local_addr_list needs to be protocted by a spin lock since
763 * multiple notifiers (say IPv4 and IPv6) may be running at the same
764 * time and thus corrupt the list.
765 * The reader side is protected with RCU.
766 */
767static int sctp_inetaddr_event(struct notifier_block *this, unsigned long ev,
768 void *ptr)
769{
770 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
771 struct sctp_sockaddr_entry *addr = NULL;
772 struct sctp_sockaddr_entry *temp;
773 struct net *net = dev_net(ifa->ifa_dev->dev);
774 int found = 0;
775
776 switch (ev) {
777 case NETDEV_UP:
778 addr = kzalloc_obj(*addr, GFP_ATOMIC);
779 if (addr) {
780 addr->a.v4.sin_family = AF_INET;
781 addr->a.v4.sin_addr.s_addr = ifa->ifa_local;
782 addr->valid = 1;
783 spin_lock_bh(&net->sctp.local_addr_lock);
784 list_add_tail_rcu(&addr->list, &net->sctp.local_addr_list);
785 sctp_addr_wq_mgmt(net, addr, SCTP_ADDR_NEW);
786 spin_unlock_bh(&net->sctp.local_addr_lock);
787 }
788 break;
789 case NETDEV_DOWN:
790 spin_lock_bh(&net->sctp.local_addr_lock);
791 list_for_each_entry_safe(addr, temp,
792 &net->sctp.local_addr_list, list) {
793 if (addr->a.sa.sa_family == AF_INET &&
794 addr->a.v4.sin_addr.s_addr ==
795 ifa->ifa_local) {
796 found = 1;
797 addr->valid = 0;
798 list_del_rcu(&addr->list);
799 sctp_addr_wq_mgmt(net, addr, SCTP_ADDR_DEL);
800 break;
801 }
802 }
803 spin_unlock_bh(&net->sctp.local_addr_lock);
804 if (found)
805 kfree_rcu(addr, rcu);
806 break;
807 }
808
809 return NOTIFY_DONE;
810}
811
812/*
813 * Initialize the control inode/socket with a control endpoint data
814 * structure. This endpoint is reserved exclusively for the OOTB processing.
815 */
816static int sctp_ctl_sock_init(struct net *net)
817{
818 int err;
819 sa_family_t family = PF_INET;
820
821 if (sctp_get_pf_specific(PF_INET6))
822 family = PF_INET6;
823
824 err = inet_ctl_sock_create(&net->sctp.ctl_sock, family,
825 SOCK_SEQPACKET, IPPROTO_SCTP, net);
826
827 /* If IPv6 socket could not be created, try the IPv4 socket */
828 if (err < 0 && family == PF_INET6)
829 err = inet_ctl_sock_create(&net->sctp.ctl_sock, AF_INET,
830 SOCK_SEQPACKET, IPPROTO_SCTP,
831 net);
832
833 if (err < 0) {
834 pr_err("Failed to create the SCTP control socket\n");
835 return err;
836 }
837 return 0;
838}
839
840static int sctp_udp_rcv(struct sock *sk, struct sk_buff *skb)
841{
842 SCTP_INPUT_CB(skb)->encap_port = udp_hdr(skb)->source;
843
844 skb_set_transport_header(skb, sizeof(struct udphdr));
845 sctp_rcv(skb);
846 return 0;
847}
848
849int sctp_udp_sock_start(struct net *net)
850{
851 struct udp_tunnel_sock_cfg tuncfg = {NULL};
852 struct udp_port_cfg udp_conf = {0};
853 struct socket *sock;
854 int err;
855
856 udp_conf.family = AF_INET;
857 udp_conf.local_ip.s_addr = htonl(INADDR_ANY);
858 udp_conf.local_udp_port = htons(net->sctp.udp_port);
859 err = udp_sock_create(net, &udp_conf, &sock);
860 if (err) {
861 pr_err("Failed to create the SCTP UDP tunneling v4 sock\n");
862 return err;
863 }
864
865 tuncfg.encap_type = 1;
866 tuncfg.encap_rcv = sctp_udp_rcv;
867 tuncfg.encap_err_lookup = sctp_udp_v4_err;
868 setup_udp_tunnel_sock(net, sock->sk, &tuncfg);
869 net->sctp.udp4_sock = sock->sk;
870
871#if IS_ENABLED(CONFIG_IPV6)
872 memset(&udp_conf, 0, sizeof(udp_conf));
873
874 udp_conf.family = AF_INET6;
875 udp_conf.local_ip6 = in6addr_any;
876 udp_conf.local_udp_port = htons(net->sctp.udp_port);
877 udp_conf.use_udp6_rx_checksums = true;
878 udp_conf.ipv6_v6only = true;
879 err = udp_sock_create(net, &udp_conf, &sock);
880 if (err) {
881 pr_err("Failed to create the SCTP UDP tunneling v6 sock\n");
882 udp_tunnel_sock_release(net->sctp.udp4_sock);
883 net->sctp.udp4_sock = NULL;
884 return err;
885 }
886
887 tuncfg.encap_type = 1;
888 tuncfg.encap_rcv = sctp_udp_rcv;
889 tuncfg.encap_err_lookup = sctp_udp_v6_err;
890 setup_udp_tunnel_sock(net, sock->sk, &tuncfg);
891 net->sctp.udp6_sock = sock->sk;
892#endif
893
894 return 0;
895}
896
897void sctp_udp_sock_stop(struct net *net)
898{
899 if (net->sctp.udp4_sock) {
900 udp_tunnel_sock_release(net->sctp.udp4_sock);
901 net->sctp.udp4_sock = NULL;
902 }
903 if (net->sctp.udp6_sock) {
904 udp_tunnel_sock_release(net->sctp.udp6_sock);
905 net->sctp.udp6_sock = NULL;
906 }
907}
908
909/* Register address family specific functions. */
910int sctp_register_af(struct sctp_af *af)
911{
912 switch (af->sa_family) {
913 case AF_INET:
914 if (sctp_af_v4_specific)
915 return 0;
916 sctp_af_v4_specific = af;
917 break;
918 case AF_INET6:
919 if (sctp_af_v6_specific)
920 return 0;
921 sctp_af_v6_specific = af;
922 break;
923 default:
924 return 0;
925 }
926
927 INIT_LIST_HEAD(&af->list);
928 list_add_tail(&af->list, &sctp_address_families);
929 return 1;
930}
931
932/* Get the table of functions for manipulating a particular address
933 * family.
934 */
935struct sctp_af *sctp_get_af_specific(sa_family_t family)
936{
937 switch (family) {
938 case AF_INET:
939 return sctp_af_v4_specific;
940 case AF_INET6:
941 return sctp_af_v6_specific;
942 default:
943 return NULL;
944 }
945}
946
947/* Common code to initialize a AF_INET msg_name. */
948static void sctp_inet_msgname(char *msgname, int *addr_len)
949{
950 struct sockaddr_in *sin;
951
952 sin = (struct sockaddr_in *)msgname;
953 *addr_len = sizeof(struct sockaddr_in);
954 sin->sin_family = AF_INET;
955 memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
956}
957
958/* Copy the primary address of the peer primary address as the msg_name. */
959static void sctp_inet_event_msgname(struct sctp_ulpevent *event, char *msgname,
960 int *addr_len)
961{
962 struct sockaddr_in *sin, *sinfrom;
963
964 if (msgname) {
965 struct sctp_association *asoc;
966
967 asoc = event->asoc;
968 sctp_inet_msgname(msgname, addr_len);
969 sin = (struct sockaddr_in *)msgname;
970 sinfrom = &asoc->peer.primary_addr.v4;
971 sin->sin_port = htons(asoc->peer.port);
972 sin->sin_addr.s_addr = sinfrom->sin_addr.s_addr;
973 }
974}
975
976/* Initialize and copy out a msgname from an inbound skb. */
977static void sctp_inet_skb_msgname(struct sk_buff *skb, char *msgname, int *len)
978{
979 if (msgname) {
980 struct sctphdr *sh = sctp_hdr(skb);
981 struct sockaddr_in *sin = (struct sockaddr_in *)msgname;
982
983 sctp_inet_msgname(msgname, len);
984 sin->sin_port = sh->source;
985 sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
986 }
987}
988
989/* Do we support this AF? */
990static int sctp_inet_af_supported(sa_family_t family, struct sctp_sock *sp)
991{
992 /* PF_INET only supports AF_INET addresses. */
993 return AF_INET == family;
994}
995
996/* Address matching with wildcards allowed. */
997static int sctp_inet_cmp_addr(const union sctp_addr *addr1,
998 const union sctp_addr *addr2,
999 struct sctp_sock *opt)
1000{
1001 /* PF_INET only supports AF_INET addresses. */
1002 if (addr1->sa.sa_family != addr2->sa.sa_family)
1003 return 0;
1004 if (htonl(INADDR_ANY) == addr1->v4.sin_addr.s_addr ||
1005 htonl(INADDR_ANY) == addr2->v4.sin_addr.s_addr)
1006 return 1;
1007 if (addr1->v4.sin_addr.s_addr == addr2->v4.sin_addr.s_addr)
1008 return 1;
1009
1010 return 0;
1011}
1012
1013/* Verify that provided sockaddr looks bindable. Common verification has
1014 * already been taken care of.
1015 */
1016static int sctp_inet_bind_verify(struct sctp_sock *opt, union sctp_addr *addr)
1017{
1018 return sctp_v4_available(addr, opt);
1019}
1020
1021/* Verify that sockaddr looks sendable. Common verification has already
1022 * been taken care of.
1023 */
1024static int sctp_inet_send_verify(struct sctp_sock *opt, union sctp_addr *addr)
1025{
1026 return 1;
1027}
1028
1029/* Fill in Supported Address Type information for INIT and INIT-ACK
1030 * chunks. Returns number of addresses supported.
1031 */
1032static int sctp_inet_supported_addrs(const struct sctp_sock *opt,
1033 __be16 *types)
1034{
1035 types[0] = SCTP_PARAM_IPV4_ADDRESS;
1036 return 1;
1037}
1038
1039/* Wrapper routine that calls the ip transmit routine. */
1040static inline int sctp_v4_xmit(struct sk_buff *skb, struct sctp_transport *t)
1041{
1042 struct dst_entry *dst = dst_clone(t->dst);
1043 struct flowi4 *fl4 = &t->fl.u.ip4;
1044 struct sock *sk = skb->sk;
1045 struct inet_sock *inet = inet_sk(sk);
1046 __u8 dscp = READ_ONCE(inet->tos);
1047 __be16 df = 0;
1048
1049 pr_debug("%s: skb:%p, len:%d, src:%pI4, dst:%pI4\n", __func__, skb,
1050 skb->len, &fl4->saddr, &fl4->daddr);
1051
1052 if (t->dscp & SCTP_DSCP_SET_MASK)
1053 dscp = t->dscp & SCTP_DSCP_VAL_MASK;
1054
1055 inet->pmtudisc = t->param_flags & SPP_PMTUD_ENABLE ? IP_PMTUDISC_DO
1056 : IP_PMTUDISC_DONT;
1057 SCTP_INC_STATS(sock_net(sk), SCTP_MIB_OUTSCTPPACKS);
1058
1059 if (!t->encap_port || !sctp_sk(sk)->udp_port) {
1060 skb_dst_set(skb, dst);
1061 return __ip_queue_xmit(sk, skb, &t->fl, dscp);
1062 }
1063
1064 if (skb_is_gso(skb))
1065 skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL_CSUM;
1066
1067 if (ip_dont_fragment(sk, dst) && !skb->ignore_df)
1068 df = htons(IP_DF);
1069
1070 skb->encapsulation = 1;
1071 skb_reset_inner_mac_header(skb);
1072 skb_reset_inner_transport_header(skb);
1073 skb_set_inner_ipproto(skb, IPPROTO_SCTP);
1074 local_bh_disable();
1075 udp_tunnel_xmit_skb(dst_rtable(dst), sk, skb, fl4->saddr,
1076 fl4->daddr, dscp, ip4_dst_hoplimit(dst), df,
1077 sctp_sk(sk)->udp_port, t->encap_port, false, false,
1078 0);
1079 local_bh_enable();
1080 return 0;
1081}
1082
1083static struct sctp_af sctp_af_inet;
1084
1085static struct sctp_pf sctp_pf_inet = {
1086 .event_msgname = sctp_inet_event_msgname,
1087 .skb_msgname = sctp_inet_skb_msgname,
1088 .af_supported = sctp_inet_af_supported,
1089 .cmp_addr = sctp_inet_cmp_addr,
1090 .bind_verify = sctp_inet_bind_verify,
1091 .send_verify = sctp_inet_send_verify,
1092 .supported_addrs = sctp_inet_supported_addrs,
1093 .addr_to_user = sctp_v4_addr_to_user,
1094 .to_sk_saddr = sctp_v4_to_sk_saddr,
1095 .to_sk_daddr = sctp_v4_to_sk_daddr,
1096 .copy_ip_options = sctp_v4_copy_ip_options,
1097 .af = &sctp_af_inet
1098};
1099
1100/* Notifier for inetaddr addition/deletion events. */
1101static struct notifier_block sctp_inetaddr_notifier = {
1102 .notifier_call = sctp_inetaddr_event,
1103};
1104
1105/* Socket operations. */
1106static const struct proto_ops inet_seqpacket_ops = {
1107 .family = PF_INET,
1108 .owner = THIS_MODULE,
1109 .release = inet_release, /* Needs to be wrapped... */
1110 .bind = inet_bind,
1111 .connect = sctp_inet_connect,
1112 .socketpair = sock_no_socketpair,
1113 .accept = inet_accept,
1114 .getname = inet_getname, /* Semantics are different. */
1115 .poll = sctp_poll,
1116 .ioctl = inet_ioctl,
1117 .gettstamp = sock_gettstamp,
1118 .listen = sctp_inet_listen,
1119 .shutdown = inet_shutdown, /* Looks harmless. */
1120 .setsockopt = sock_common_setsockopt, /* IP_SOL IP_OPTION is a problem */
1121 .getsockopt = sock_common_getsockopt,
1122 .sendmsg = inet_sendmsg,
1123 .recvmsg = inet_recvmsg,
1124 .mmap = sock_no_mmap,
1125};
1126
1127/* Registration with AF_INET family. */
1128static struct inet_protosw sctp_seqpacket_protosw = {
1129 .type = SOCK_SEQPACKET,
1130 .protocol = IPPROTO_SCTP,
1131 .prot = &sctp_prot,
1132 .ops = &inet_seqpacket_ops,
1133 .flags = SCTP_PROTOSW_FLAG
1134};
1135static struct inet_protosw sctp_stream_protosw = {
1136 .type = SOCK_STREAM,
1137 .protocol = IPPROTO_SCTP,
1138 .prot = &sctp_prot,
1139 .ops = &inet_seqpacket_ops,
1140 .flags = SCTP_PROTOSW_FLAG
1141};
1142
1143static int sctp4_rcv(struct sk_buff *skb)
1144{
1145 SCTP_INPUT_CB(skb)->encap_port = 0;
1146 return sctp_rcv(skb);
1147}
1148
1149/* Register with IP layer. */
1150static const struct net_protocol sctp_protocol = {
1151 .handler = sctp4_rcv,
1152 .err_handler = sctp_v4_err,
1153 .no_policy = 1,
1154 .icmp_strict_tag_validation = 1,
1155};
1156
1157/* IPv4 address related functions. */
1158static struct sctp_af sctp_af_inet = {
1159 .sa_family = AF_INET,
1160 .sctp_xmit = sctp_v4_xmit,
1161 .setsockopt = ip_setsockopt,
1162 .getsockopt = ip_getsockopt,
1163 .get_dst = sctp_v4_get_dst,
1164 .get_saddr = sctp_v4_get_saddr,
1165 .copy_addrlist = sctp_v4_copy_addrlist,
1166 .from_skb = sctp_v4_from_skb,
1167 .from_sk = sctp_v4_from_sk,
1168 .from_addr_param = sctp_v4_from_addr_param,
1169 .to_addr_param = sctp_v4_to_addr_param,
1170 .cmp_addr = sctp_v4_cmp_addr,
1171 .addr_valid = sctp_v4_addr_valid,
1172 .inaddr_any = sctp_v4_inaddr_any,
1173 .is_any = sctp_v4_is_any,
1174 .available = sctp_v4_available,
1175 .scope = sctp_v4_scope,
1176 .skb_iif = sctp_v4_skb_iif,
1177 .skb_sdif = sctp_v4_skb_sdif,
1178 .is_ce = sctp_v4_is_ce,
1179 .seq_dump_addr = sctp_v4_seq_dump_addr,
1180 .ecn_capable = sctp_v4_ecn_capable,
1181 .net_header_len = sizeof(struct iphdr),
1182 .sockaddr_len = sizeof(struct sockaddr_in),
1183 .ip_options_len = sctp_v4_ip_options_len,
1184};
1185
1186struct sctp_pf *sctp_get_pf_specific(sa_family_t family)
1187{
1188 switch (family) {
1189 case PF_INET:
1190 return sctp_pf_inet_specific;
1191 case PF_INET6:
1192 return sctp_pf_inet6_specific;
1193 default:
1194 return NULL;
1195 }
1196}
1197
1198/* Register the PF specific function table. */
1199int sctp_register_pf(struct sctp_pf *pf, sa_family_t family)
1200{
1201 switch (family) {
1202 case PF_INET:
1203 if (sctp_pf_inet_specific)
1204 return 0;
1205 sctp_pf_inet_specific = pf;
1206 break;
1207 case PF_INET6:
1208 if (sctp_pf_inet6_specific)
1209 return 0;
1210 sctp_pf_inet6_specific = pf;
1211 break;
1212 default:
1213 return 0;
1214 }
1215 return 1;
1216}
1217
1218static inline int init_sctp_mibs(struct net *net)
1219{
1220 net->sctp.sctp_statistics = alloc_percpu(struct sctp_mib);
1221 if (!net->sctp.sctp_statistics)
1222 return -ENOMEM;
1223 return 0;
1224}
1225
1226static inline void cleanup_sctp_mibs(struct net *net)
1227{
1228 free_percpu(net->sctp.sctp_statistics);
1229}
1230
1231static void sctp_v4_pf_init(void)
1232{
1233 /* Initialize the SCTP specific PF functions. */
1234 sctp_register_pf(&sctp_pf_inet, PF_INET);
1235 sctp_register_af(&sctp_af_inet);
1236}
1237
1238static void sctp_v4_pf_exit(void)
1239{
1240 list_del(&sctp_af_inet.list);
1241}
1242
1243static int sctp_v4_protosw_init(void)
1244{
1245 int rc;
1246
1247 rc = proto_register(&sctp_prot, 1);
1248 if (rc)
1249 return rc;
1250
1251 /* Register SCTP(UDP and TCP style) with socket layer. */
1252 inet_register_protosw(&sctp_seqpacket_protosw);
1253 inet_register_protosw(&sctp_stream_protosw);
1254
1255 return 0;
1256}
1257
1258static void sctp_v4_protosw_exit(void)
1259{
1260 inet_unregister_protosw(&sctp_stream_protosw);
1261 inet_unregister_protosw(&sctp_seqpacket_protosw);
1262 proto_unregister(&sctp_prot);
1263}
1264
1265static int sctp_v4_add_protocol(void)
1266{
1267 int ret;
1268
1269 /* Register notifier for inet address additions/deletions. */
1270 ret = register_inetaddr_notifier(&sctp_inetaddr_notifier);
1271 if (ret)
1272 return ret;
1273
1274 /* Register SCTP with inet layer. */
1275 if (inet_add_protocol(&sctp_protocol, IPPROTO_SCTP) < 0) {
1276 unregister_inetaddr_notifier(&sctp_inetaddr_notifier);
1277 return -EAGAIN;
1278 }
1279
1280 return 0;
1281}
1282
1283static void sctp_v4_del_protocol(void)
1284{
1285 inet_del_protocol(&sctp_protocol, IPPROTO_SCTP);
1286 unregister_inetaddr_notifier(&sctp_inetaddr_notifier);
1287}
1288
1289static int __net_init sctp_defaults_init(struct net *net)
1290{
1291 int status;
1292
1293 /*
1294 * 14. Suggested SCTP Protocol Parameter Values
1295 */
1296 /* The following protocol parameters are RECOMMENDED: */
1297 /* RTO.Initial - 3 seconds */
1298 net->sctp.rto_initial = SCTP_RTO_INITIAL;
1299 /* RTO.Min - 1 second */
1300 net->sctp.rto_min = SCTP_RTO_MIN;
1301 /* RTO.Max - 60 seconds */
1302 net->sctp.rto_max = SCTP_RTO_MAX;
1303 /* RTO.Alpha - 1/8 */
1304 net->sctp.rto_alpha = SCTP_RTO_ALPHA;
1305 /* RTO.Beta - 1/4 */
1306 net->sctp.rto_beta = SCTP_RTO_BETA;
1307
1308 /* Valid.Cookie.Life - 60 seconds */
1309 net->sctp.valid_cookie_life = SCTP_DEFAULT_COOKIE_LIFE;
1310
1311 /* Whether Cookie Preservative is enabled(1) or not(0) */
1312 net->sctp.cookie_preserve_enable = 1;
1313
1314 /* Whether cookie authentication is enabled(1) or not(0) */
1315 net->sctp.cookie_auth_enable =
1316 !IS_ENABLED(CONFIG_SCTP_DEFAULT_COOKIE_HMAC_NONE);
1317
1318 /* Max.Burst - 4 */
1319 net->sctp.max_burst = SCTP_DEFAULT_MAX_BURST;
1320
1321 /* Disable of Primary Path Switchover by default */
1322 net->sctp.ps_retrans = SCTP_PS_RETRANS_MAX;
1323
1324 /* Enable pf state by default */
1325 net->sctp.pf_enable = 1;
1326
1327 /* Ignore pf exposure feature by default */
1328 net->sctp.pf_expose = SCTP_PF_EXPOSE_UNSET;
1329
1330 /* Association.Max.Retrans - 10 attempts
1331 * Path.Max.Retrans - 5 attempts (per destination address)
1332 * Max.Init.Retransmits - 8 attempts
1333 */
1334 net->sctp.max_retrans_association = 10;
1335 net->sctp.max_retrans_path = 5;
1336 net->sctp.max_retrans_init = 8;
1337
1338 /* Sendbuffer growth - do per-socket accounting */
1339 net->sctp.sndbuf_policy = 0;
1340
1341 /* Rcvbuffer growth - do per-socket accounting */
1342 net->sctp.rcvbuf_policy = 0;
1343
1344 /* HB.interval - 30 seconds */
1345 net->sctp.hb_interval = SCTP_DEFAULT_TIMEOUT_HEARTBEAT;
1346
1347 /* delayed SACK timeout */
1348 net->sctp.sack_timeout = SCTP_DEFAULT_TIMEOUT_SACK;
1349
1350 /* Disable ADDIP by default. */
1351 net->sctp.addip_enable = 0;
1352 net->sctp.addip_noauth = 0;
1353 net->sctp.default_auto_asconf = 0;
1354
1355 /* Enable PR-SCTP by default. */
1356 net->sctp.prsctp_enable = 1;
1357
1358 /* Disable RECONF by default. */
1359 net->sctp.reconf_enable = 0;
1360
1361 /* Disable AUTH by default. */
1362 net->sctp.auth_enable = 0;
1363
1364 /* Enable ECN by default. */
1365 net->sctp.ecn_enable = 1;
1366
1367 /* Set UDP tunneling listening port to 0 by default */
1368 net->sctp.udp_port = 0;
1369
1370 /* Set remote encap port to 0 by default */
1371 net->sctp.encap_port = 0;
1372
1373 /* Set SCOPE policy to enabled */
1374 net->sctp.scope_policy = SCTP_SCOPE_POLICY_ENABLE;
1375
1376 /* Set the default rwnd update threshold */
1377 net->sctp.rwnd_upd_shift = SCTP_DEFAULT_RWND_SHIFT;
1378
1379 /* Initialize maximum autoclose timeout. */
1380 net->sctp.max_autoclose = INT_MAX / HZ;
1381
1382#ifdef CONFIG_NET_L3_MASTER_DEV
1383 net->sctp.l3mdev_accept = 1;
1384#endif
1385
1386 /* Allocate and initialise sctp mibs. */
1387 status = init_sctp_mibs(net);
1388 if (status)
1389 goto err_init_mibs;
1390
1391#ifdef CONFIG_PROC_FS
1392 /* Initialize proc fs directory. */
1393 status = sctp_proc_init(net);
1394 if (status)
1395 goto err_init_proc;
1396#endif
1397
1398 sctp_dbg_objcnt_init(net);
1399
1400 /* Initialize the local address list. */
1401 INIT_LIST_HEAD(&net->sctp.local_addr_list);
1402 spin_lock_init(&net->sctp.local_addr_lock);
1403 sctp_get_local_addr_list(net);
1404
1405 /* Initialize the address event list */
1406 INIT_LIST_HEAD(&net->sctp.addr_waitq);
1407 INIT_LIST_HEAD(&net->sctp.auto_asconf_splist);
1408 spin_lock_init(&net->sctp.addr_wq_lock);
1409 net->sctp.addr_wq_timer.expires = 0;
1410 timer_setup(&net->sctp.addr_wq_timer, sctp_addr_wq_timeout_handler, 0);
1411
1412 return 0;
1413
1414#ifdef CONFIG_PROC_FS
1415err_init_proc:
1416 cleanup_sctp_mibs(net);
1417#endif
1418err_init_mibs:
1419 return status;
1420}
1421
1422static void __net_exit sctp_defaults_exit(struct net *net)
1423{
1424 /* Free the local address list */
1425 sctp_free_addr_wq(net);
1426 sctp_free_local_addr_list(net);
1427
1428#ifdef CONFIG_PROC_FS
1429 remove_proc_subtree("sctp", net->proc_net);
1430 net->sctp.proc_net_sctp = NULL;
1431#endif
1432 cleanup_sctp_mibs(net);
1433}
1434
1435static struct pernet_operations sctp_defaults_ops = {
1436 .init = sctp_defaults_init,
1437 .exit = sctp_defaults_exit,
1438};
1439
1440static int __net_init sctp_ctrlsock_init(struct net *net)
1441{
1442 int status;
1443
1444 /* Initialize the control inode/socket for handling OOTB packets. */
1445 status = sctp_ctl_sock_init(net);
1446 if (status) {
1447 pr_err("Failed to initialize the SCTP control sock\n");
1448 return status;
1449 }
1450
1451 status = sctp_sysctl_net_register(net);
1452 if (status) {
1453 inet_ctl_sock_destroy(net->sctp.ctl_sock);
1454 net->sctp.ctl_sock = NULL;
1455 }
1456
1457 return status;
1458}
1459
1460static void __net_exit sctp_ctrlsock_exit(struct net *net)
1461{
1462 sctp_sysctl_net_unregister(net);
1463 sctp_udp_sock_stop(net);
1464
1465 /* Free the control endpoint. */
1466 inet_ctl_sock_destroy(net->sctp.ctl_sock);
1467 net->sctp.ctl_sock = NULL;
1468}
1469
1470static struct pernet_operations sctp_ctrlsock_ops = {
1471 .init = sctp_ctrlsock_init,
1472 .exit = sctp_ctrlsock_exit,
1473};
1474
1475/* Initialize the universe into something sensible. */
1476static __init int sctp_init(void)
1477{
1478 unsigned long nr_pages = totalram_pages();
1479 unsigned long limit;
1480 unsigned long goal;
1481 int max_entry_order;
1482 int num_entries;
1483 int max_share;
1484 int status;
1485 int order;
1486 int i;
1487
1488 sock_skb_cb_check_size(sizeof(struct sctp_ulpevent));
1489
1490 /* Allocate bind_bucket and chunk caches. */
1491 status = -ENOBUFS;
1492 sctp_bucket_cachep = KMEM_CACHE(sctp_bind_bucket, SLAB_HWCACHE_ALIGN);
1493 if (!sctp_bucket_cachep)
1494 goto out;
1495
1496 sctp_chunk_cachep = KMEM_CACHE(sctp_chunk, SLAB_HWCACHE_ALIGN);
1497 if (!sctp_chunk_cachep)
1498 goto err_chunk_cachep;
1499
1500 status = percpu_counter_init(&sctp_sockets_allocated, 0, GFP_KERNEL);
1501 if (status)
1502 goto err_percpu_counter_init;
1503
1504 /* Implementation specific variables. */
1505
1506 /* Initialize default stream count setup information. */
1507 sctp_max_instreams = SCTP_DEFAULT_INSTREAMS;
1508 sctp_max_outstreams = SCTP_DEFAULT_OUTSTREAMS;
1509
1510 /* Initialize handle used for association ids. */
1511 idr_init(&sctp_assocs_id);
1512
1513 limit = nr_free_buffer_pages() / 8;
1514 limit = max(limit, 128UL);
1515 sysctl_sctp_mem[0] = limit / 4 * 3;
1516 sysctl_sctp_mem[1] = limit;
1517 sysctl_sctp_mem[2] = sysctl_sctp_mem[0] * 2;
1518
1519 /* Set per-socket limits to no more than 1/128 the pressure threshold*/
1520 limit = (sysctl_sctp_mem[1]) << (PAGE_SHIFT - 7);
1521 max_share = min(4UL*1024*1024, limit);
1522
1523 sysctl_sctp_rmem[0] = PAGE_SIZE; /* give each asoc 1 page min */
1524 sysctl_sctp_rmem[1] = 1500 * SKB_TRUESIZE(1);
1525 sysctl_sctp_rmem[2] = max(sysctl_sctp_rmem[1], max_share);
1526
1527 sysctl_sctp_wmem[0] = PAGE_SIZE;
1528 sysctl_sctp_wmem[1] = 16*1024;
1529 sysctl_sctp_wmem[2] = max(64*1024, max_share);
1530
1531 /* Size and allocate the association hash table.
1532 * The methodology is similar to that of the tcp hash tables.
1533 * Though not identical. Start by getting a goal size
1534 */
1535 if (nr_pages >= (128 * 1024))
1536 goal = nr_pages >> (22 - PAGE_SHIFT);
1537 else
1538 goal = nr_pages >> (24 - PAGE_SHIFT);
1539
1540 /* Then compute the page order for said goal */
1541 order = get_order(goal);
1542
1543 /* Now compute the required page order for the maximum sized table we
1544 * want to create
1545 */
1546 max_entry_order = get_order(MAX_SCTP_PORT_HASH_ENTRIES *
1547 sizeof(struct sctp_bind_hashbucket));
1548
1549 /* Limit the page order by that maximum hash table size */
1550 order = min(order, max_entry_order);
1551
1552 /* Allocate and initialize the endpoint hash table. */
1553 sctp_ep_hashsize = 64;
1554 sctp_ep_hashtable =
1555 kmalloc_objs(struct sctp_hashbucket, 64);
1556 if (!sctp_ep_hashtable) {
1557 pr_err("Failed endpoint_hash alloc\n");
1558 status = -ENOMEM;
1559 goto err_ehash_alloc;
1560 }
1561 for (i = 0; i < sctp_ep_hashsize; i++) {
1562 rwlock_init(&sctp_ep_hashtable[i].lock);
1563 INIT_HLIST_HEAD(&sctp_ep_hashtable[i].chain);
1564 }
1565
1566 /* Allocate and initialize the SCTP port hash table.
1567 * Note that order is initalized to start at the max sized
1568 * table we want to support. If we can't get that many pages
1569 * reduce the order and try again
1570 */
1571 do {
1572 sctp_port_hashtable = (struct sctp_bind_hashbucket *)
1573 __get_free_pages(GFP_KERNEL | __GFP_NOWARN, order);
1574 } while (!sctp_port_hashtable && --order > 0);
1575
1576 if (!sctp_port_hashtable) {
1577 pr_err("Failed bind hash alloc\n");
1578 status = -ENOMEM;
1579 goto err_bhash_alloc;
1580 }
1581
1582 /* Now compute the number of entries that will fit in the
1583 * port hash space we allocated
1584 */
1585 num_entries = (1UL << order) * PAGE_SIZE /
1586 sizeof(struct sctp_bind_hashbucket);
1587
1588 /* And finish by rounding it down to the nearest power of two.
1589 * This wastes some memory of course, but it's needed because
1590 * the hash function operates based on the assumption that
1591 * the number of entries is a power of two.
1592 */
1593 sctp_port_hashsize = rounddown_pow_of_two(num_entries);
1594
1595 for (i = 0; i < sctp_port_hashsize; i++) {
1596 spin_lock_init(&sctp_port_hashtable[i].lock);
1597 INIT_HLIST_HEAD(&sctp_port_hashtable[i].chain);
1598 }
1599
1600 status = sctp_transport_hashtable_init();
1601 if (status)
1602 goto err_thash_alloc;
1603
1604 pr_info("Hash tables configured (bind %d/%d)\n", sctp_port_hashsize,
1605 num_entries);
1606
1607 sctp_sysctl_register();
1608
1609 INIT_LIST_HEAD(&sctp_address_families);
1610 sctp_v4_pf_init();
1611 sctp_v6_pf_init();
1612 sctp_sched_ops_init();
1613
1614 status = register_pernet_subsys(&sctp_defaults_ops);
1615 if (status)
1616 goto err_register_defaults;
1617
1618 status = sctp_v4_protosw_init();
1619 if (status)
1620 goto err_protosw_init;
1621
1622 status = sctp_v6_protosw_init();
1623 if (status)
1624 goto err_v6_protosw_init;
1625
1626 status = register_pernet_subsys(&sctp_ctrlsock_ops);
1627 if (status)
1628 goto err_register_ctrlsock;
1629
1630 status = sctp_v4_add_protocol();
1631 if (status)
1632 goto err_add_protocol;
1633
1634 /* Register SCTP with inet6 layer. */
1635 status = sctp_v6_add_protocol();
1636 if (status)
1637 goto err_v6_add_protocol;
1638
1639 if (sctp_offload_init() < 0)
1640 pr_crit("%s: Cannot add SCTP protocol offload\n", __func__);
1641
1642out:
1643 return status;
1644err_v6_add_protocol:
1645 sctp_v4_del_protocol();
1646err_add_protocol:
1647 unregister_pernet_subsys(&sctp_ctrlsock_ops);
1648err_register_ctrlsock:
1649 sctp_v6_protosw_exit();
1650err_v6_protosw_init:
1651 sctp_v4_protosw_exit();
1652err_protosw_init:
1653 unregister_pernet_subsys(&sctp_defaults_ops);
1654err_register_defaults:
1655 sctp_v4_pf_exit();
1656 sctp_v6_pf_exit();
1657 sctp_sysctl_unregister();
1658 free_pages((unsigned long)sctp_port_hashtable,
1659 get_order(sctp_port_hashsize *
1660 sizeof(struct sctp_bind_hashbucket)));
1661err_bhash_alloc:
1662 sctp_transport_hashtable_destroy();
1663err_thash_alloc:
1664 kfree(sctp_ep_hashtable);
1665err_ehash_alloc:
1666 percpu_counter_destroy(&sctp_sockets_allocated);
1667err_percpu_counter_init:
1668 kmem_cache_destroy(sctp_chunk_cachep);
1669err_chunk_cachep:
1670 kmem_cache_destroy(sctp_bucket_cachep);
1671 goto out;
1672}
1673
1674/* Exit handler for the SCTP protocol. */
1675static __exit void sctp_exit(void)
1676{
1677 /* BUG. This should probably do something useful like clean
1678 * up all the remaining associations and all that memory.
1679 */
1680
1681 /* Unregister with inet6/inet layers. */
1682 sctp_v6_del_protocol();
1683 sctp_v4_del_protocol();
1684
1685 unregister_pernet_subsys(&sctp_ctrlsock_ops);
1686
1687 /* Free protosw registrations */
1688 sctp_v6_protosw_exit();
1689 sctp_v4_protosw_exit();
1690
1691 unregister_pernet_subsys(&sctp_defaults_ops);
1692
1693 /* Unregister with socket layer. */
1694 sctp_v6_pf_exit();
1695 sctp_v4_pf_exit();
1696
1697 sctp_sysctl_unregister();
1698
1699 free_pages((unsigned long)sctp_port_hashtable,
1700 get_order(sctp_port_hashsize *
1701 sizeof(struct sctp_bind_hashbucket)));
1702 kfree(sctp_ep_hashtable);
1703 sctp_transport_hashtable_destroy();
1704
1705 percpu_counter_destroy(&sctp_sockets_allocated);
1706
1707 rcu_barrier(); /* Wait for completion of call_rcu()'s */
1708
1709 kmem_cache_destroy(sctp_chunk_cachep);
1710 kmem_cache_destroy(sctp_bucket_cachep);
1711}
1712
1713module_init(sctp_init);
1714module_exit(sctp_exit);
1715
1716/*
1717 * __stringify doesn't likes enums, so use IPPROTO_SCTP value (132) directly.
1718 */
1719MODULE_ALIAS("net-pf-" __stringify(PF_INET) "-proto-132");
1720MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-132");
1721MODULE_AUTHOR("Linux Kernel SCTP developers <[email protected]>");
1722MODULE_DESCRIPTION("Support for the SCTP protocol (RFC2960)");
1723module_param_named(no_checksums, sctp_checksum_disable, bool, 0644);
1724MODULE_PARM_DESC(no_checksums, "Disable checksums computing and verification");
1725MODULE_LICENSE("GPL");