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