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. */
  66struct sctp_globals sctp_globals __read_mostly;
  67
  68struct idr sctp_assocs_id;
  69DEFINE_SPINLOCK(sctp_assocs_id_lock);
  70
  71static struct sctp_pf *sctp_pf_inet6_specific;
  72static struct sctp_pf *sctp_pf_inet_specific;
  73static struct sctp_af *sctp_af_v4_specific;
  74static struct sctp_af *sctp_af_v6_specific;
  75
  76struct kmem_cache *sctp_chunk_cachep __read_mostly;
  77struct kmem_cache *sctp_bucket_cachep __read_mostly;
  78
  79long sysctl_sctp_mem[3];
  80int sysctl_sctp_rmem[3];
  81int sysctl_sctp_wmem[3];
  82
  83/* Set up the proc fs entry for the SCTP protocol. */
  84static 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
 101out_remaddr_proc_init:
 102	sctp_assocs_proc_exit(net);
 103out_assocs_proc_init:
 104	sctp_eps_proc_exit(net);
 105out_eps_proc_init:
 106	sctp_snmp_proc_exit(net);
 107out_snmp_proc_init:
 108	remove_proc_entry("sctp", net->proc_net);
 109	net->sctp.proc_net_sctp = NULL;
 110out_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 */
 120static 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 */
 136static 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 */
 168static 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.  */
 185static 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'.  */
 198int 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
 227end_copy:
 228	rcu_read_unlock();
 229	return error;
 230}
 231
 232/* Initialize a sctp_addr from in incoming skb.  */
 233static 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. */
 255static 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. */
 263static 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. */
 269static 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. */
 275static 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 */
 287static 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. */
 300static 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. */
 309static 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. */
 323static 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? */
 331static 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 */
 343static 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?   */
 363static 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 */
 398static 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 */
 424static 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
 532out_unlock:
 533	rcu_read_unlock();
 534out:
 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 */
 546static 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? */
 560static 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? */
 566static 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(). */
 572static 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
 598out:
 599	return newsk;
 600}
 601
 602static 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. */
 609static 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
 614static void sctp_v4_ecn_capable(struct sock *sk)
 615{
 616	INET_ECN_xmit(sk);
 617}
 618
 619static 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)
 671free_next:
 672#endif
 673		list_del(&addrw->list);
 674		kfree(addrw);
 675	}
 676	spin_unlock_bh(&net->sctp.addr_wq_lock);
 677}
 678
 679static 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 */
 696static 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
 717void 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 */
 770static 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 */
 820static 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. */
 845int 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 */
 870struct 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. */
 883static 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. */
 894static 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. */
 912static 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? */
 925static 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. */
 932static 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 */
 951static 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 */
 959static 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 */
 967static 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. */
 975static 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
 991static struct sctp_af sctp_af_inet;
 992
 993static 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.  */
1009static struct notifier_block sctp_inetaddr_notifier = {
1010	.notifier_call = sctp_inetaddr_event,
1011};
1012
1013/* Socket operations.  */
1014static 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.  */
1040static 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};
1047static 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.  */
1056static 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.  */
1065static 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
1095struct 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.  */
1108int 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
1127static 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
1135static inline void cleanup_sctp_mibs(struct net *net)
1136{
1137	free_percpu(net->sctp.sctp_statistics);
1138}
1139
1140static 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
1147static void sctp_v4_pf_exit(void)
1148{
1149	list_del(&sctp_af_inet.list);
1150}
1151
1152static 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
1167static 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
1174static 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
1186static void sctp_v4_del_protocol(void)
1187{
1188	inet_del_protocol(&sctp_protocol, IPPROTO_SCTP);
1189	unregister_inetaddr_notifier(&sctp_inetaddr_notifier);
1190}
1191
1192static 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
1303err_init_proc:
1304	cleanup_sctp_mibs(net);
1305err_init_mibs:
1306	sctp_sysctl_net_unregister(net);
1307err_sysctl_register:
1308	return status;
1309}
1310
1311static 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
1324static struct pernet_operations sctp_defaults_ops = {
1325	.init = sctp_defaults_init,
1326	.exit = sctp_defaults_exit,
1327};
1328
1329static 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
1341static 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
1347static 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.  */
1353static __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
1519out:
1520	return status;
1521err_v6_add_protocol:
1522	sctp_v4_del_protocol();
1523err_add_protocol:
1524	unregister_pernet_subsys(&sctp_ctrlsock_ops);
1525err_register_ctrlsock:
1526	sctp_v6_protosw_exit();
1527err_v6_protosw_init:
1528	sctp_v4_protosw_exit();
1529err_protosw_init:
1530	unregister_pernet_subsys(&sctp_defaults_ops);
1531err_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)));
1538err_bhash_alloc:
1539	sctp_transport_hashtable_destroy();
1540err_thash_alloc:
1541	kfree(sctp_ep_hashtable);
1542err_ehash_alloc:
1543	percpu_counter_destroy(&sctp_sockets_allocated);
1544err_percpu_counter_init:
1545	kmem_cache_destroy(sctp_chunk_cachep);
1546err_chunk_cachep:
1547	kmem_cache_destroy(sctp_bucket_cachep);
1548	goto out;
1549}
1550
1551/* Exit handler for the SCTP protocol.  */
1552static __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
1590module_init(sctp_init);
1591module_exit(sctp_exit);
1592
1593/*
1594 * __stringify doesn't likes enums, so use IPPROTO_SCTP value (132) directly.
1595 */
1596MODULE_ALIAS("net-pf-" __stringify(PF_INET) "-proto-132");
1597MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-132");
1598MODULE_AUTHOR("Linux Kernel SCTP developers <linux-sctp@vger.kernel.org>");
1599MODULE_DESCRIPTION("Support for the SCTP protocol (RFC2960)");
1600module_param_named(no_checksums, sctp_checksum_disable, bool, 0644);
1601MODULE_PARM_DESC(no_checksums, "Disable checksums computing and verification");
1602MODULE_LICENSE("GPL");