blob: 7b523e3f551f1761d891b606f293b2b721a87ca8 [file] [log] [blame]
Vlad Yasevich60c778b2008-01-11 09:57:09 -05001/* SCTP kernel implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * (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 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -05009 * This file is part of the SCTP kernel implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 *
11 * Initialization/cleanup for SCTP protocol support.
12 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -050013 * This SCTP implementation is free software;
Linus Torvalds1da177e2005-04-16 15:20:36 -070014 * 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 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -050019 * This SCTP implementation is distributed in the hope that it
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 * 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
Jeff Kirsher4b2f13a2013-12-06 06:28:48 -080026 * along with GNU CC; see the file COPYING. If not, see
27 * <http://www.gnu.org/licenses/>.
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 *
29 * Please send any bug reports or fixes you make to the
30 * email address(es):
Daniel Borkmann91705c62013-07-23 14:51:47 +020031 * lksctp developers <linux-sctp@vger.kernel.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 * 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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 */
41
Joe Perches145ce502010-08-24 13:21:08 +000042#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
43
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#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>
Neil Horman4d93df02007-08-15 16:07:44 -070049#include <linux/bootmem.h>
Vlad Yasevich845525a2008-07-18 23:08:21 -070050#include <linux/highmem.h>
51#include <linux/swap.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090052#include <linux/slab.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020053#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#include <net/protocol.h>
55#include <net/ip.h>
56#include <net/ipv6.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020057#include <net/route.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#include <net/sctp/sctp.h>
59#include <net/addrconf.h>
60#include <net/inet_common.h>
61#include <net/inet_ecn.h>
62
Neil Hormand9749fb2016-02-18 16:10:57 -050063#define MAX_SCTP_PORT_HASH_ENTRIES (64 * 1024)
64
Linus Torvalds1da177e2005-04-16 15:20:36 -070065/* Global data structures. */
Brian Haley4cbf1ca2006-09-18 00:04:22 -070066struct sctp_globals sctp_globals __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
68struct idr sctp_assocs_id;
69DEFINE_SPINLOCK(sctp_assocs_id_lock);
70
Linus Torvalds1da177e2005-04-16 15:20:36 -070071static 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
Christoph Lametere18b8902006-12-06 20:33:20 -080076struct kmem_cache *sctp_chunk_cachep __read_mostly;
77struct kmem_cache *sctp_bucket_cachep __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
Eric Dumazet8d987e52010-11-09 23:24:26 +000079long sysctl_sctp_mem[3];
Vlad Yasevich007e3932007-09-16 16:04:37 -070080int sysctl_sctp_rmem[3];
81int sysctl_sctp_wmem[3];
Neil Horman4d93df02007-08-15 16:07:44 -070082
Linus Torvalds1da177e2005-04-16 15:20:36 -070083/* Set up the proc fs entry for the SCTP protocol. */
Christoph Paaschf5f417c2012-12-06 03:03:12 +000084static int __net_init sctp_proc_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -070085{
Florian Westphalc4e85f82008-07-18 23:03:44 -070086#ifdef CONFIG_PROC_FS
Eric W. Biederman13d782f2012-08-06 08:45:15 +000087 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))
Wei Yongjun80896a32008-06-16 16:59:55 -070091 goto out_snmp_proc_init;
Eric W. Biederman13d782f2012-08-06 08:45:15 +000092 if (sctp_eps_proc_init(net))
Wei Yongjun80896a32008-06-16 16:59:55 -070093 goto out_eps_proc_init;
Eric W. Biederman13d782f2012-08-06 08:45:15 +000094 if (sctp_assocs_proc_init(net))
Wei Yongjun80896a32008-06-16 16:59:55 -070095 goto out_assocs_proc_init;
Eric W. Biederman13d782f2012-08-06 08:45:15 +000096 if (sctp_remaddr_proc_init(net))
David S. Millercaea9022008-06-16 18:25:48 -070097 goto out_remaddr_proc_init;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
99 return 0;
100
David S. Millercaea9022008-06-16 18:25:48 -0700101out_remaddr_proc_init:
Eric W. Biederman13d782f2012-08-06 08:45:15 +0000102 sctp_assocs_proc_exit(net);
Wei Yongjun80896a32008-06-16 16:59:55 -0700103out_assocs_proc_init:
Eric W. Biederman13d782f2012-08-06 08:45:15 +0000104 sctp_eps_proc_exit(net);
Wei Yongjun80896a32008-06-16 16:59:55 -0700105out_eps_proc_init:
Eric W. Biederman13d782f2012-08-06 08:45:15 +0000106 sctp_snmp_proc_exit(net);
Wei Yongjun80896a32008-06-16 16:59:55 -0700107out_snmp_proc_init:
Eric W. Biederman13d782f2012-08-06 08:45:15 +0000108 remove_proc_entry("sctp", net->proc_net);
109 net->sctp.proc_net_sctp = NULL;
110out_proc_net_sctp:
Randy Dunlap157653c2008-11-27 15:30:53 -0800111 return -ENOMEM;
Eric W. Biederman13d782f2012-08-06 08:45:15 +0000112#endif /* CONFIG_PROC_FS */
113 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114}
115
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900116/* Clean up the proc fs entry for the SCTP protocol.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 * Note: Do not make this __exit as it is used in the init error
118 * path.
119 */
Eric W. Biederman13d782f2012-08-06 08:45:15 +0000120static void sctp_proc_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121{
Florian Westphalc4e85f82008-07-18 23:03:44 -0700122#ifdef CONFIG_PROC_FS
Eric W. Biederman13d782f2012-08-06 08:45:15 +0000123 sctp_snmp_proc_exit(net);
124 sctp_eps_proc_exit(net);
125 sctp_assocs_proc_exit(net);
126 sctp_remaddr_proc_exit(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
Eric W. Biederman13d782f2012-08-06 08:45:15 +0000128 remove_proc_entry("sctp", net->proc_net);
129 net->sctp.proc_net_sctp = NULL;
Florian Westphalc4e85f82008-07-18 23:03:44 -0700130#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131}
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();
Herbert Xue5ed6392005-10-03 14:35:55 -0700144 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 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. */
Daniel Borkmann939cfa72013-06-17 11:40:04 +0200151 addr = kzalloc(sizeof(*addr), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 if (addr) {
Al Viro2a6fd782006-11-20 17:04:42 -0800153 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;
Vlad Yasevich29303542007-09-16 16:02:12 -0700156 addr->valid = 1;
157 INIT_LIST_HEAD(&addr->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 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 */
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000168static void sctp_get_local_addr_list(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169{
170 struct net_device *dev;
171 struct list_head *pos;
172 struct sctp_af *af;
173
Eric Dumazetc6d14c82009-11-04 05:43:23 -0800174 rcu_read_lock();
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000175 for_each_netdev_rcu(net, dev) {
Dave Jones2c0740e2013-06-17 22:26:52 -0400176 list_for_each(pos, &sctp_address_families) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 af = list_entry(pos, struct sctp_af, list);
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000178 af->copy_addrlist(&net->sctp.local_addr_list, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 }
180 }
Eric Dumazetc6d14c82009-11-04 05:43:23 -0800181 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182}
183
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184/* Free the existing local addresses. */
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000185static void sctp_free_local_addr_list(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186{
187 struct sctp_sockaddr_entry *addr;
188 struct list_head *pos, *temp;
189
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000190 list_for_each_safe(pos, temp, &net->sctp.local_addr_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 addr = list_entry(pos, struct sctp_sockaddr_entry, list);
192 list_del(pos);
193 kfree(addr);
194 }
195}
196
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197/* Copy the local addresses which are valid for 'scope' into 'bp'. */
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000198int sctp_copy_local_addr_list(struct net *net, struct sctp_bind_addr *bp,
199 sctp_scope_t scope, gfp_t gfp, int copy_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200{
201 struct sctp_sockaddr_entry *addr;
202 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
Vlad Yasevich29303542007-09-16 16:02:12 -0700204 rcu_read_lock();
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000205 list_for_each_entry_rcu(addr, &net->sctp.local_addr_list, list) {
Vlad Yasevich29303542007-09-16 16:02:12 -0700206 if (!addr->valid)
207 continue;
Eric W. Biedermane7ff4a72012-08-07 07:27:02 +0000208 if (sctp_in_scope(net, &addr->a, scope)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 /* 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 */
Al Viro6244be42006-11-20 17:21:44 -0800213 if ((((AF_INET == addr->a.sa.sa_family) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 (copy_flags & SCTP_ADDR4_PEERSUPP))) ||
Al Viro6244be42006-11-20 17:21:44 -0800215 (((AF_INET6 == addr->a.sa.sa_family) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 (copy_flags & SCTP_ADDR6_ALLOWED) &&
217 (copy_flags & SCTP_ADDR6_PEERSUPP)))) {
Vlad Yasevichf57d96b2007-12-20 14:12:24 -0800218 error = sctp_add_bind_addr(bp, &addr->a,
Marcelo Ricardo Leitner133800d2016-03-08 10:34:28 -0300219 sizeof(addr->a),
Vlad Yasevichf57d96b2007-12-20 14:12:24 -0800220 SCTP_ADDR_SRC, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 if (error)
222 goto end_copy;
223 }
224 }
225 }
226
227end_copy:
Vlad Yasevich29303542007-09-16 16:02:12 -0700228 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 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;
Al Virod55c41b2006-11-20 17:09:40 -0800237 __be16 *port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 struct sctphdr *sh;
239
240 port = &addr->v4.sin_port;
241 addr->v4.sin_family = AF_INET;
242
Marcelo Ricardo Leitner1f45f782016-07-13 15:08:57 -0300243 /* Always called on head skb, so this is safe */
Arnaldo Carvalho de Melo2c0fd382007-03-13 13:59:32 -0300244 sh = sctp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 if (is_saddr) {
Al Virod55c41b2006-11-20 17:09:40 -0800246 *port = sh->source;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700247 from = &ip_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 } else {
Al Virod55c41b2006-11-20 17:09:40 -0800249 *port = sh->dest;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700250 from = &ip_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 }
252 memcpy(&addr->v4.sin_addr.s_addr, from, sizeof(struct in_addr));
253}
254
255/* Initialize an sctp_addr from a socket. */
256static void sctp_v4_from_sk(union sctp_addr *addr, struct sock *sk)
257{
258 addr->v4.sin_family = AF_INET;
Al Viro7dcdbd92006-11-20 17:24:21 -0800259 addr->v4.sin_port = 0;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000260 addr->v4.sin_addr.s_addr = inet_sk(sk)->inet_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261}
262
263/* Initialize sk->sk_rcv_saddr from sctp_addr. */
264static void sctp_v4_to_sk_saddr(union sctp_addr *addr, struct sock *sk)
265{
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000266 inet_sk(sk)->inet_rcv_saddr = addr->v4.sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267}
268
269/* Initialize sk->sk_daddr from sctp_addr. */
270static void sctp_v4_to_sk_daddr(union sctp_addr *addr, struct sock *sk)
271{
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000272 inet_sk(sk)->inet_daddr = addr->v4.sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273}
274
275/* Initialize a sctp_addr from an address parameter. */
276static void sctp_v4_from_addr_param(union sctp_addr *addr,
277 union sctp_addr_param *param,
Al Virodd86d132006-11-20 17:11:13 -0800278 __be16 port, int iif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
280 addr->v4.sin_family = AF_INET;
281 addr->v4.sin_port = port;
282 addr->v4.sin_addr.s_addr = param->v4.addr.s_addr;
283}
284
285/* Initialize an address parameter from a sctp_addr and return the length
286 * of the address parameter.
287 */
288static int sctp_v4_to_addr_param(const union sctp_addr *addr,
289 union sctp_addr_param *param)
290{
291 int length = sizeof(sctp_ipv4addr_param_t);
292
293 param->v4.param_hdr.type = SCTP_PARAM_IPV4_ADDRESS;
Al Virodbc16db2006-11-20 17:01:42 -0800294 param->v4.param_hdr.length = htons(length);
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900295 param->v4.addr.s_addr = addr->v4.sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296
297 return length;
298}
299
300/* Initialize a sctp_addr from a dst_entry. */
David S. Miller18a353f42011-05-03 20:55:05 -0700301static void sctp_v4_dst_saddr(union sctp_addr *saddr, struct flowi4 *fl4,
Al Viro854d43a2006-11-20 17:06:24 -0800302 __be16 port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 saddr->v4.sin_family = AF_INET;
305 saddr->v4.sin_port = port;
David S. Miller18a353f42011-05-03 20:55:05 -0700306 saddr->v4.sin_addr.s_addr = fl4->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307}
308
309/* Compare two addresses exactly. */
310static int sctp_v4_cmp_addr(const union sctp_addr *addr1,
311 const union sctp_addr *addr2)
312{
313 if (addr1->sa.sa_family != addr2->sa.sa_family)
314 return 0;
315 if (addr1->v4.sin_port != addr2->v4.sin_port)
316 return 0;
317 if (addr1->v4.sin_addr.s_addr != addr2->v4.sin_addr.s_addr)
318 return 0;
319
320 return 1;
321}
322
323/* Initialize addr struct to INADDR_ANY. */
Al Viro6fbfa9f2006-11-20 17:24:53 -0800324static void sctp_v4_inaddr_any(union sctp_addr *addr, __be16 port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325{
326 addr->v4.sin_family = AF_INET;
Al Viroe6f1ceb2008-03-17 22:44:53 -0700327 addr->v4.sin_addr.s_addr = htonl(INADDR_ANY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 addr->v4.sin_port = port;
329}
330
331/* Is this a wildcard address? */
332static int sctp_v4_is_any(const union sctp_addr *addr)
333{
Al Viroe6f1ceb2008-03-17 22:44:53 -0700334 return htonl(INADDR_ANY) == addr->v4.sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335}
336
337/* This function checks if the address is a valid address to be used for
338 * SCTP binding.
339 *
340 * Output:
341 * Return 0 - If the address is a non-unicast or an illegal address.
342 * Return 1 - If the address is a unicast.
343 */
Vlad Yasevich5636bef2006-06-17 22:55:35 -0700344static int sctp_v4_addr_valid(union sctp_addr *addr,
345 struct sctp_sock *sp,
346 const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347{
Vlad Yasevich7dab83d2008-07-18 23:05:40 -0700348 /* IPv4 addresses not allowed */
349 if (sp && ipv6_only_sock(sctp_opt2sk(sp)))
350 return 0;
351
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 /* Is this a non-unicast address or a unusable SCTP address? */
Joe Perchesb5cb2bb2007-12-16 13:46:59 -0800353 if (IS_IPV4_UNUSABLE_ADDRESS(addr->v4.sin_addr.s_addr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 return 0;
355
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900356 /* Is this a broadcast address? */
Eric Dumazet511c3f92009-06-02 05:14:27 +0000357 if (skb && skb_rtable(skb)->rt_flags & RTCF_BROADCAST)
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900358 return 0;
Vlad Yasevich5636bef2006-06-17 22:55:35 -0700359
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 return 1;
361}
362
363/* Should this be available for binding? */
364static int sctp_v4_available(union sctp_addr *addr, struct sctp_sock *sp)
365{
Eric W. Biedermanbb2db452012-08-06 08:46:26 +0000366 struct net *net = sock_net(&sp->inet.sk);
367 int ret = inet_addr_type(net, addr->v4.sin_addr.s_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
Al Viroe6f1ceb2008-03-17 22:44:53 -0700370 if (addr->v4.sin_addr.s_addr != htonl(INADDR_ANY) &&
Neil Hormancdac4e02005-06-13 15:12:33 -0700371 ret != RTN_LOCAL &&
372 !sp->inet.freebind &&
Vincent Bernat49a60152014-09-05 15:09:03 +0200373 !net->ipv4.sysctl_ip_nonlocal_bind)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 return 0;
Neil Hormancdac4e02005-06-13 15:12:33 -0700375
Vlad Yasevich7dab83d2008-07-18 23:05:40 -0700376 if (ipv6_only_sock(sctp_opt2sk(sp)))
377 return 0;
378
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 return 1;
380}
381
382/* Checking the loopback, private and other address scopes as defined in
383 * RFC 1918. The IPv4 scoping is based on the draft for SCTP IPv4
384 * scoping <draft-stewart-tsvwg-sctp-ipv4-00.txt>.
385 *
386 * Level 0 - unusable SCTP addresses
387 * Level 1 - loopback address
388 * Level 2 - link-local addresses
389 * Level 3 - private addresses.
390 * Level 4 - global addresses
391 * For INIT and INIT-ACK address list, let L be the level of
392 * of requested destination address, sender and receiver
393 * SHOULD include all of its addresses with level greater
394 * than or equal to L.
Bhaskar Dutta72388432009-09-03 17:25:47 +0530395 *
396 * IPv4 scoping can be controlled through sysctl option
397 * net.sctp.addr_scope_policy
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 */
399static sctp_scope_t sctp_v4_scope(union sctp_addr *addr)
400{
401 sctp_scope_t retval;
402
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 /* Check for unusable SCTP addresses. */
Joe Perchesb5cb2bb2007-12-16 13:46:59 -0800404 if (IS_IPV4_UNUSABLE_ADDRESS(addr->v4.sin_addr.s_addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 retval = SCTP_SCOPE_UNUSABLE;
Joe Perchesb5cb2bb2007-12-16 13:46:59 -0800406 } else if (ipv4_is_loopback(addr->v4.sin_addr.s_addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 retval = SCTP_SCOPE_LOOPBACK;
Joe Perchesb5cb2bb2007-12-16 13:46:59 -0800408 } else if (ipv4_is_linklocal_169(addr->v4.sin_addr.s_addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 retval = SCTP_SCOPE_LINK;
Joe Perchesb5cb2bb2007-12-16 13:46:59 -0800410 } else if (ipv4_is_private_10(addr->v4.sin_addr.s_addr) ||
411 ipv4_is_private_172(addr->v4.sin_addr.s_addr) ||
412 ipv4_is_private_192(addr->v4.sin_addr.s_addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 retval = SCTP_SCOPE_PRIVATE;
414 } else {
415 retval = SCTP_SCOPE_GLOBAL;
416 }
417
418 return retval;
419}
420
421/* Returns a valid dst cache entry for the given source and destination ip
422 * addresses. If an association is passed, trys to get a dst entry with a
423 * source address that matches an address in the bind address list.
424 */
Vlad Yasevichda0420b2011-04-26 21:54:17 +0000425static void sctp_v4_get_dst(struct sctp_transport *t, union sctp_addr *saddr,
426 struct flowi *fl, struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427{
Vlad Yasevichda0420b2011-04-26 21:54:17 +0000428 struct sctp_association *asoc = t->asoc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 struct rtable *rt;
Vlad Yasevich9914ae32011-04-26 21:51:31 +0000430 struct flowi4 *fl4 = &fl->u.ip4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 struct sctp_bind_addr *bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 struct sctp_sockaddr_entry *laddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 struct dst_entry *dst = NULL;
Vlad Yasevichda0420b2011-04-26 21:54:17 +0000434 union sctp_addr *daddr = &t->ipaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 union sctp_addr dst_saddr;
436
Vlad Yasevich9914ae32011-04-26 21:51:31 +0000437 memset(fl4, 0x0, sizeof(struct flowi4));
438 fl4->daddr = daddr->v4.sin_addr.s_addr;
439 fl4->fl4_dport = daddr->v4.sin_port;
440 fl4->flowi4_proto = IPPROTO_SCTP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 if (asoc) {
Vlad Yasevich9914ae32011-04-26 21:51:31 +0000442 fl4->flowi4_tos = RT_CONN_FLAGS(asoc->base.sk);
443 fl4->flowi4_oif = asoc->base.sk->sk_bound_dev_if;
444 fl4->fl4_sport = htons(asoc->base.bind_addr.port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 }
Wei Yongjun6429d3d2010-04-30 21:42:44 -0400446 if (saddr) {
Vlad Yasevich9914ae32011-04-26 21:51:31 +0000447 fl4->saddr = saddr->v4.sin_addr.s_addr;
448 fl4->fl4_sport = saddr->v4.sin_port;
Wei Yongjun6429d3d2010-04-30 21:42:44 -0400449 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450
Daniel Borkmannbb333812013-06-28 19:49:40 +0200451 pr_debug("%s: dst:%pI4, src:%pI4 - ", __func__, &fl4->daddr,
452 &fl4->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
Eric W. Biedermanbb2db452012-08-06 08:46:26 +0000454 rt = ip_route_output_key(sock_net(sk), fl4);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800455 if (!IS_ERR(rt))
Changli Gaod8d1f302010-06-10 23:31:35 -0700456 dst = &rt->dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457
458 /* If there is no association or if a source address is passed, no
459 * more validation is required.
460 */
461 if (!asoc || saddr)
462 goto out;
463
464 bp = &asoc->base.bind_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
466 if (dst) {
467 /* Walk through the bind address list and look for a bind
468 * address that matches the source address of the returned dst.
469 */
David S. Miller18a353f42011-05-03 20:55:05 -0700470 sctp_v4_dst_saddr(&dst_saddr, fl4, htons(bp->port));
Vlad Yasevich559cf712007-09-16 16:03:28 -0700471 rcu_read_lock();
472 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
Michio Honda8a07eb02011-04-26 20:19:36 +0900473 if (!laddr->valid || (laddr->state == SCTP_ADDR_DEL) ||
474 (laddr->state != SCTP_ADDR_SRC &&
475 !asoc->src_out_of_asoc_ok))
Sridhar Samudraladc022a92006-07-21 14:49:25 -0700476 continue;
Al Viro854d43a2006-11-20 17:06:24 -0800477 if (sctp_v4_cmp_addr(&dst_saddr, &laddr->a))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 goto out_unlock;
479 }
Vlad Yasevich559cf712007-09-16 16:03:28 -0700480 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
482 /* None of the bound addresses match the source address of the
483 * dst. So release it.
484 */
485 dst_release(dst);
486 dst = NULL;
487 }
488
489 /* Walk through the bind address list and try to get a dst that
490 * matches a bind address as the source address.
491 */
Vlad Yasevich559cf712007-09-16 16:03:28 -0700492 rcu_read_lock();
493 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
Marcelo Ricardo Leitner0ca50d12015-07-17 12:34:18 -0300494 struct net_device *odev;
495
Vlad Yasevich559cf712007-09-16 16:03:28 -0700496 if (!laddr->valid)
497 continue;
Marcelo Ricardo Leitner07868282015-07-17 12:34:17 -0300498 if (laddr->state != SCTP_ADDR_SRC ||
499 AF_INET != laddr->a.sa.sa_family)
500 continue;
Xufeng Zhang85350872014-04-25 16:55:41 +0800501
Marcelo Ricardo Leitner07868282015-07-17 12:34:17 -0300502 fl4->fl4_sport = laddr->a.v4.sin_port;
503 flowi4_update_output(fl4,
504 asoc->base.sk->sk_bound_dev_if,
505 RT_CONN_FLAGS(asoc->base.sk),
506 daddr->v4.sin_addr.s_addr,
507 laddr->a.v4.sin_addr.s_addr);
508
509 rt = ip_route_output_key(sock_net(sk), fl4);
510 if (IS_ERR(rt))
511 continue;
512
Marcelo Ricardo Leitner410f0382015-09-02 16:20:22 -0300513 if (!dst)
514 dst = &rt->dst;
515
Marcelo Ricardo Leitner0ca50d12015-07-17 12:34:18 -0300516 /* Ensure the src address belongs to the output
517 * interface.
518 */
519 odev = __ip_dev_find(sock_net(sk), laddr->a.v4.sin_addr.s_addr,
520 false);
Marcelo Ricardo Leitnerd82f0f1f2015-09-02 16:20:21 -0300521 if (!odev || odev->ifindex != fl4->flowi4_oif) {
Marcelo Ricardo Leitner410f0382015-09-02 16:20:22 -0300522 if (&rt->dst != dst)
523 dst_release(&rt->dst);
Marcelo Ricardo Leitner0ca50d12015-07-17 12:34:18 -0300524 continue;
Marcelo Ricardo Leitnerd82f0f1f2015-09-02 16:20:21 -0300525 }
Marcelo Ricardo Leitner0ca50d12015-07-17 12:34:18 -0300526
Marcelo Ricardo Leitner410f0382015-09-02 16:20:22 -0300527 if (dst != &rt->dst)
528 dst_release(dst);
Marcelo Ricardo Leitner07868282015-07-17 12:34:17 -0300529 dst = &rt->dst;
530 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 }
532
533out_unlock:
Vlad Yasevich559cf712007-09-16 16:03:28 -0700534 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535out:
Vlad Yasevichda0420b2011-04-26 21:54:17 +0000536 t->dst = dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 if (dst)
Daniel Borkmannbb333812013-06-28 19:49:40 +0200538 pr_debug("rt_dst:%pI4, rt_src:%pI4\n",
539 &fl4->daddr, &fl4->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 else
Daniel Borkmannbb333812013-06-28 19:49:40 +0200541 pr_debug("no route\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542}
543
544/* For v4, the source address is cached in the route entry(dst). So no need
545 * to cache it separately and hence this is an empty routine.
546 */
YOSHIFUJI Hideakie5117102008-05-29 19:55:05 +0900547static void sctp_v4_get_saddr(struct sctp_sock *sk,
Vlad Yasevich9914ae32011-04-26 21:51:31 +0000548 struct sctp_transport *t,
Vlad Yasevich9914ae32011-04-26 21:51:31 +0000549 struct flowi *fl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550{
Vlad Yasevich9914ae32011-04-26 21:51:31 +0000551 union sctp_addr *saddr = &t->saddr;
552 struct rtable *rt = (struct rtable *)t->dst;
Vladislav Yasevich23ec47a2005-11-11 16:05:55 -0800553
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 if (rt) {
555 saddr->v4.sin_family = AF_INET;
David S. Miller902ebd32011-05-09 14:49:13 -0700556 saddr->v4.sin_addr.s_addr = fl->u.ip4.saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 }
558}
559
560/* What interface did this skb arrive on? */
561static int sctp_v4_skb_iif(const struct sk_buff *skb)
562{
David S. Miller92101b32012-07-23 16:29:00 -0700563 return inet_iif(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564}
565
566/* Was this packet marked by Explicit Congestion Notification? */
567static int sctp_v4_is_ce(const struct sk_buff *skb)
568{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700569 return INET_ECN_is_ce(ip_hdr(skb)->tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570}
571
572/* Create and initialize a new sk for the socket returned by accept(). */
573static struct sock *sctp_v4_create_accept_sk(struct sock *sk,
574 struct sctp_association *asoc)
575{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900576 struct sock *newsk = sk_alloc(sock_net(sk), PF_INET, GFP_KERNEL,
Eric W. Biederman11aa9c22015-05-08 21:09:13 -0500577 sk->sk_prot, 0);
Vlad Yasevich914e1c82009-02-13 08:33:44 +0000578 struct inet_sock *newinet;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
580 if (!newsk)
581 goto out;
582
583 sock_init_data(NULL, newsk);
584
Vlad Yasevich914e1c82009-02-13 08:33:44 +0000585 sctp_copy_sock(newsk, sk, asoc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 sock_reset_flag(newsk, SOCK_ZAPPED);
587
588 newinet = inet_sk(newsk);
589
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000590 newinet->inet_daddr = asoc->peer.primary_addr.v4.sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -0700592 sk_refcnt_debug_inc(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593
594 if (newsk->sk_prot->init(newsk)) {
595 sk_common_release(newsk);
596 newsk = NULL;
597 }
598
599out:
600 return newsk;
601}
602
Jason Gunthorpe299ee122014-07-30 12:40:53 -0600603static int sctp_v4_addr_to_user(struct sctp_sock *sp, union sctp_addr *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604{
Jason Gunthorpe299ee122014-07-30 12:40:53 -0600605 /* No address mapping for V4 sockets */
606 return sizeof(struct sockaddr_in);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607}
608
609/* Dump the v4 addr to the seq file. */
610static void sctp_v4_seq_dump_addr(struct seq_file *seq, union sctp_addr *addr)
611{
Harvey Harrison21454aa2008-10-31 00:54:56 -0700612 seq_printf(seq, "%pI4 ", &addr->v4.sin_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613}
614
Vlad Yasevichb9031d92008-06-04 12:40:15 -0700615static void sctp_v4_ecn_capable(struct sock *sk)
616{
617 INET_ECN_xmit(sk);
618}
619
stephen hemmingerbd2a13e2012-12-28 18:18:55 +0000620static void sctp_addr_wq_timeout_handler(unsigned long arg)
Michio Honda9f7d6532011-04-26 19:32:51 +0900621{
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000622 struct net *net = (struct net *)arg;
Michio Honda9f7d6532011-04-26 19:32:51 +0900623 struct sctp_sockaddr_entry *addrw, *temp;
624 struct sctp_sock *sp;
625
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000626 spin_lock_bh(&net->sctp.addr_wq_lock);
Michio Honda9f7d6532011-04-26 19:32:51 +0900627
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000628 list_for_each_entry_safe(addrw, temp, &net->sctp.addr_waitq, list) {
Daniel Borkmannbb333812013-06-28 19:49:40 +0200629 pr_debug("%s: the first ent in wq:%p is addr:%pISc for cmd:%d at "
630 "entry:%p\n", __func__, &net->sctp.addr_waitq, &addrw->a.sa,
631 addrw->state, addrw);
Michio Honda9f7d6532011-04-26 19:32:51 +0900632
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000633#if IS_ENABLED(CONFIG_IPV6)
Michio Honda9f7d6532011-04-26 19:32:51 +0900634 /* Now we send an ASCONF for each association */
635 /* Note. we currently don't handle link local IPv6 addressees */
636 if (addrw->a.sa.sa_family == AF_INET6) {
637 struct in6_addr *in6;
638
639 if (ipv6_addr_type(&addrw->a.v6.sin6_addr) &
640 IPV6_ADDR_LINKLOCAL)
641 goto free_next;
642
643 in6 = (struct in6_addr *)&addrw->a.v6.sin6_addr;
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000644 if (ipv6_chk_addr(net, in6, NULL, 0) == 0 &&
Michio Honda9f7d6532011-04-26 19:32:51 +0900645 addrw->state == SCTP_ADDR_NEW) {
646 unsigned long timeo_val;
647
Daniel Borkmannbb333812013-06-28 19:49:40 +0200648 pr_debug("%s: this is on DAD, trying %d sec "
649 "later\n", __func__,
650 SCTP_ADDRESS_TICK_DELAY);
651
Michio Honda9f7d6532011-04-26 19:32:51 +0900652 timeo_val = jiffies;
653 timeo_val += msecs_to_jiffies(SCTP_ADDRESS_TICK_DELAY);
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000654 mod_timer(&net->sctp.addr_wq_timer, timeo_val);
Michio Honda9f7d6532011-04-26 19:32:51 +0900655 break;
656 }
657 }
David S. Miller5d0c90c2011-06-06 13:05:55 -0700658#endif
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000659 list_for_each_entry(sp, &net->sctp.auto_asconf_splist, auto_asconf_list) {
Michio Honda9f7d6532011-04-26 19:32:51 +0900660 struct sock *sk;
661
662 sk = sctp_opt2sk(sp);
663 /* ignore bound-specific endpoints */
664 if (!sctp_is_ep_boundall(sk))
665 continue;
wangweidong5bc1d1b2014-01-21 15:44:12 +0800666 bh_lock_sock(sk);
Michio Honda9f7d6532011-04-26 19:32:51 +0900667 if (sctp_asconf_mgmt(sp, addrw) < 0)
Daniel Borkmannbb333812013-06-28 19:49:40 +0200668 pr_debug("%s: sctp_asconf_mgmt failed\n", __func__);
wangweidong5bc1d1b2014-01-21 15:44:12 +0800669 bh_unlock_sock(sk);
Michio Honda9f7d6532011-04-26 19:32:51 +0900670 }
Daniel Halperin39d84a52012-06-18 11:04:55 +0000671#if IS_ENABLED(CONFIG_IPV6)
Michio Honda9f7d6532011-04-26 19:32:51 +0900672free_next:
Daniel Halperin39d84a52012-06-18 11:04:55 +0000673#endif
Michio Honda9f7d6532011-04-26 19:32:51 +0900674 list_del(&addrw->list);
675 kfree(addrw);
676 }
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000677 spin_unlock_bh(&net->sctp.addr_wq_lock);
Michio Honda9f7d6532011-04-26 19:32:51 +0900678}
679
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000680static void sctp_free_addr_wq(struct net *net)
Michio Honda9f7d6532011-04-26 19:32:51 +0900681{
682 struct sctp_sockaddr_entry *addrw;
683 struct sctp_sockaddr_entry *temp;
684
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000685 spin_lock_bh(&net->sctp.addr_wq_lock);
686 del_timer(&net->sctp.addr_wq_timer);
687 list_for_each_entry_safe(addrw, temp, &net->sctp.addr_waitq, list) {
Michio Honda9f7d6532011-04-26 19:32:51 +0900688 list_del(&addrw->list);
689 kfree(addrw);
690 }
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000691 spin_unlock_bh(&net->sctp.addr_wq_lock);
Michio Honda9f7d6532011-04-26 19:32:51 +0900692}
693
694/* lookup the entry for the same address in the addr_waitq
695 * sctp_addr_wq MUST be locked
696 */
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000697static struct sctp_sockaddr_entry *sctp_addr_wq_lookup(struct net *net,
698 struct sctp_sockaddr_entry *addr)
Michio Honda9f7d6532011-04-26 19:32:51 +0900699{
700 struct sctp_sockaddr_entry *addrw;
701
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000702 list_for_each_entry(addrw, &net->sctp.addr_waitq, list) {
Michio Honda9f7d6532011-04-26 19:32:51 +0900703 if (addrw->a.sa.sa_family != addr->a.sa.sa_family)
704 continue;
705 if (addrw->a.sa.sa_family == AF_INET) {
706 if (addrw->a.v4.sin_addr.s_addr ==
707 addr->a.v4.sin_addr.s_addr)
708 return addrw;
709 } else if (addrw->a.sa.sa_family == AF_INET6) {
710 if (ipv6_addr_equal(&addrw->a.v6.sin6_addr,
711 &addr->a.v6.sin6_addr))
712 return addrw;
713 }
714 }
715 return NULL;
716}
717
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000718void sctp_addr_wq_mgmt(struct net *net, struct sctp_sockaddr_entry *addr, int cmd)
Michio Honda9f7d6532011-04-26 19:32:51 +0900719{
720 struct sctp_sockaddr_entry *addrw;
721 unsigned long timeo_val;
722
723 /* first, we check if an opposite message already exist in the queue.
724 * If we found such message, it is removed.
725 * This operation is a bit stupid, but the DHCP client attaches the
726 * new address after a couple of addition and deletion of that address
727 */
728
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000729 spin_lock_bh(&net->sctp.addr_wq_lock);
Michio Honda9f7d6532011-04-26 19:32:51 +0900730 /* Offsets existing events in addr_wq */
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000731 addrw = sctp_addr_wq_lookup(net, addr);
Michio Honda9f7d6532011-04-26 19:32:51 +0900732 if (addrw) {
733 if (addrw->state != cmd) {
Daniel Borkmannbb333812013-06-28 19:49:40 +0200734 pr_debug("%s: offsets existing entry for %d, addr:%pISc "
735 "in wq:%p\n", __func__, addrw->state, &addrw->a.sa,
736 &net->sctp.addr_waitq);
737
Michio Honda9f7d6532011-04-26 19:32:51 +0900738 list_del(&addrw->list);
739 kfree(addrw);
740 }
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000741 spin_unlock_bh(&net->sctp.addr_wq_lock);
Michio Honda9f7d6532011-04-26 19:32:51 +0900742 return;
743 }
744
745 /* OK, we have to add the new address to the wait queue */
746 addrw = kmemdup(addr, sizeof(struct sctp_sockaddr_entry), GFP_ATOMIC);
747 if (addrw == NULL) {
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000748 spin_unlock_bh(&net->sctp.addr_wq_lock);
Michio Honda9f7d6532011-04-26 19:32:51 +0900749 return;
750 }
751 addrw->state = cmd;
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000752 list_add_tail(&addrw->list, &net->sctp.addr_waitq);
Daniel Borkmannbb333812013-06-28 19:49:40 +0200753
754 pr_debug("%s: add new entry for cmd:%d, addr:%pISc in wq:%p\n",
755 __func__, addrw->state, &addrw->a.sa, &net->sctp.addr_waitq);
Michio Honda9f7d6532011-04-26 19:32:51 +0900756
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000757 if (!timer_pending(&net->sctp.addr_wq_timer)) {
Michio Honda9f7d6532011-04-26 19:32:51 +0900758 timeo_val = jiffies;
759 timeo_val += msecs_to_jiffies(SCTP_ADDRESS_TICK_DELAY);
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000760 mod_timer(&net->sctp.addr_wq_timer, timeo_val);
Michio Honda9f7d6532011-04-26 19:32:51 +0900761 }
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000762 spin_unlock_bh(&net->sctp.addr_wq_lock);
Michio Honda9f7d6532011-04-26 19:32:51 +0900763}
764
Vlad Yasevich29303542007-09-16 16:02:12 -0700765/* Event handler for inet address addition/deletion events.
766 * The sctp_local_addr_list needs to be protocted by a spin lock since
767 * multiple notifiers (say IPv4 and IPv6) may be running at the same
768 * time and thus corrupt the list.
769 * The reader side is protected with RCU.
770 */
Adrian Bunk24123182006-12-20 16:08:22 -0800771static int sctp_inetaddr_event(struct notifier_block *this, unsigned long ev,
772 void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773{
Sridhar Samudrala29c7cf92006-12-13 16:26:26 -0800774 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
Vlad Yasevich29303542007-09-16 16:02:12 -0700775 struct sctp_sockaddr_entry *addr = NULL;
776 struct sctp_sockaddr_entry *temp;
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000777 struct net *net = dev_net(ifa->ifa_dev->dev);
Chidambar 'ilLogict' Zinnoury22626212008-03-11 18:05:02 -0700778 int found = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
Sridhar Samudrala29c7cf92006-12-13 16:26:26 -0800780 switch (ev) {
781 case NETDEV_UP:
782 addr = kmalloc(sizeof(struct sctp_sockaddr_entry), GFP_ATOMIC);
783 if (addr) {
784 addr->a.v4.sin_family = AF_INET;
785 addr->a.v4.sin_port = 0;
786 addr->a.v4.sin_addr.s_addr = ifa->ifa_local;
Vlad Yasevich29303542007-09-16 16:02:12 -0700787 addr->valid = 1;
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000788 spin_lock_bh(&net->sctp.local_addr_lock);
789 list_add_tail_rcu(&addr->list, &net->sctp.local_addr_list);
790 sctp_addr_wq_mgmt(net, addr, SCTP_ADDR_NEW);
791 spin_unlock_bh(&net->sctp.local_addr_lock);
Sridhar Samudrala29c7cf92006-12-13 16:26:26 -0800792 }
793 break;
794 case NETDEV_DOWN:
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000795 spin_lock_bh(&net->sctp.local_addr_lock);
Vlad Yasevich29303542007-09-16 16:02:12 -0700796 list_for_each_entry_safe(addr, temp,
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000797 &net->sctp.local_addr_list, list) {
Pavel Emelyanova40a7d12008-04-12 18:40:38 -0700798 if (addr->a.sa.sa_family == AF_INET &&
799 addr->a.v4.sin_addr.s_addr ==
800 ifa->ifa_local) {
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000801 sctp_addr_wq_mgmt(net, addr, SCTP_ADDR_DEL);
Chidambar 'ilLogict' Zinnoury22626212008-03-11 18:05:02 -0700802 found = 1;
Vlad Yasevich29303542007-09-16 16:02:12 -0700803 addr->valid = 0;
804 list_del_rcu(&addr->list);
Sridhar Samudrala29c7cf92006-12-13 16:26:26 -0800805 break;
806 }
807 }
Eric W. Biederman4db67e82012-08-06 08:42:04 +0000808 spin_unlock_bh(&net->sctp.local_addr_lock);
Chidambar 'ilLogict' Zinnoury22626212008-03-11 18:05:02 -0700809 if (found)
Lai Jiangshan1231f0b2011-03-15 18:05:02 +0800810 kfree_rcu(addr, rcu);
Sridhar Samudrala29c7cf92006-12-13 16:26:26 -0800811 break;
812 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
814 return NOTIFY_DONE;
815}
816
817/*
818 * Initialize the control inode/socket with a control endpoint data
819 * structure. This endpoint is reserved exclusively for the OOTB processing.
820 */
Eric W. Biederman2ce95502012-08-06 08:43:06 +0000821static int sctp_ctl_sock_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822{
823 int err;
Brian Haleyfb13d9f2009-03-04 03:20:26 -0800824 sa_family_t family = PF_INET;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
826 if (sctp_get_pf_specific(PF_INET6))
827 family = PF_INET6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828
Eric W. Biederman2ce95502012-08-06 08:43:06 +0000829 err = inet_ctl_sock_create(&net->sctp.ctl_sock, family,
830 SOCK_SEQPACKET, IPPROTO_SCTP, net);
Brian Haleyfb13d9f2009-03-04 03:20:26 -0800831
832 /* If IPv6 socket could not be created, try the IPv4 socket */
833 if (err < 0 && family == PF_INET6)
Eric W. Biederman2ce95502012-08-06 08:43:06 +0000834 err = inet_ctl_sock_create(&net->sctp.ctl_sock, AF_INET,
Brian Haleyfb13d9f2009-03-04 03:20:26 -0800835 SOCK_SEQPACKET, IPPROTO_SCTP,
Eric W. Biederman2ce95502012-08-06 08:43:06 +0000836 net);
Brian Haleyfb13d9f2009-03-04 03:20:26 -0800837
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 if (err < 0) {
Joe Perches145ce502010-08-24 13:21:08 +0000839 pr_err("Failed to create the SCTP control socket\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 return err;
841 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 return 0;
843}
844
845/* Register address family specific functions. */
846int sctp_register_af(struct sctp_af *af)
847{
848 switch (af->sa_family) {
849 case AF_INET:
850 if (sctp_af_v4_specific)
851 return 0;
852 sctp_af_v4_specific = af;
853 break;
854 case AF_INET6:
855 if (sctp_af_v6_specific)
856 return 0;
857 sctp_af_v6_specific = af;
858 break;
859 default:
860 return 0;
861 }
862
863 INIT_LIST_HEAD(&af->list);
864 list_add_tail(&af->list, &sctp_address_families);
865 return 1;
866}
867
868/* Get the table of functions for manipulating a particular address
869 * family.
870 */
871struct sctp_af *sctp_get_af_specific(sa_family_t family)
872{
873 switch (family) {
874 case AF_INET:
875 return sctp_af_v4_specific;
876 case AF_INET6:
877 return sctp_af_v6_specific;
878 default:
879 return NULL;
880 }
881}
882
883/* Common code to initialize a AF_INET msg_name. */
884static void sctp_inet_msgname(char *msgname, int *addr_len)
885{
886 struct sockaddr_in *sin;
887
888 sin = (struct sockaddr_in *)msgname;
889 *addr_len = sizeof(struct sockaddr_in);
890 sin->sin_family = AF_INET;
891 memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
892}
893
894/* Copy the primary address of the peer primary address as the msg_name. */
895static void sctp_inet_event_msgname(struct sctp_ulpevent *event, char *msgname,
896 int *addr_len)
897{
898 struct sockaddr_in *sin, *sinfrom;
899
900 if (msgname) {
901 struct sctp_association *asoc;
902
903 asoc = event->asoc;
904 sctp_inet_msgname(msgname, addr_len);
905 sin = (struct sockaddr_in *)msgname;
906 sinfrom = &asoc->peer.primary_addr.v4;
907 sin->sin_port = htons(asoc->peer.port);
908 sin->sin_addr.s_addr = sinfrom->sin_addr.s_addr;
909 }
910}
911
912/* Initialize and copy out a msgname from an inbound skb. */
913static void sctp_inet_skb_msgname(struct sk_buff *skb, char *msgname, int *len)
914{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 if (msgname) {
Arnaldo Carvalho de Melo2c0fd382007-03-13 13:59:32 -0300916 struct sctphdr *sh = sctp_hdr(skb);
917 struct sockaddr_in *sin = (struct sockaddr_in *)msgname;
918
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 sctp_inet_msgname(msgname, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 sin->sin_port = sh->source;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700921 sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 }
923}
924
925/* Do we support this AF? */
926static int sctp_inet_af_supported(sa_family_t family, struct sctp_sock *sp)
927{
928 /* PF_INET only supports AF_INET addresses. */
Eric Dumazeta02cec22010-09-22 20:43:57 +0000929 return AF_INET == family;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930}
931
932/* Address matching with wildcards allowed. */
933static int sctp_inet_cmp_addr(const union sctp_addr *addr1,
934 const union sctp_addr *addr2,
935 struct sctp_sock *opt)
936{
937 /* PF_INET only supports AF_INET addresses. */
938 if (addr1->sa.sa_family != addr2->sa.sa_family)
939 return 0;
Al Viroe6f1ceb2008-03-17 22:44:53 -0700940 if (htonl(INADDR_ANY) == addr1->v4.sin_addr.s_addr ||
941 htonl(INADDR_ANY) == addr2->v4.sin_addr.s_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 return 1;
943 if (addr1->v4.sin_addr.s_addr == addr2->v4.sin_addr.s_addr)
944 return 1;
945
946 return 0;
947}
948
949/* Verify that provided sockaddr looks bindable. Common verification has
950 * already been taken care of.
951 */
952static int sctp_inet_bind_verify(struct sctp_sock *opt, union sctp_addr *addr)
953{
954 return sctp_v4_available(addr, opt);
955}
956
957/* Verify that sockaddr looks sendable. Common verification has already
958 * been taken care of.
959 */
960static int sctp_inet_send_verify(struct sctp_sock *opt, union sctp_addr *addr)
961{
962 return 1;
963}
964
965/* Fill in Supported Address Type information for INIT and INIT-ACK
966 * chunks. Returns number of addresses supported.
967 */
968static int sctp_inet_supported_addrs(const struct sctp_sock *opt,
Al Viro3dbe8652006-11-20 17:25:49 -0800969 __be16 *types)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970{
971 types[0] = SCTP_PARAM_IPV4_ADDRESS;
972 return 1;
973}
974
975/* Wrapper routine that calls the ip transmit routine. */
976static inline int sctp_v4_xmit(struct sk_buff *skb,
Herbert Xuf8803742008-08-03 21:15:08 -0700977 struct sctp_transport *transport)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978{
Herbert Xuf8803742008-08-03 21:15:08 -0700979 struct inet_sock *inet = inet_sk(skb->sk);
980
Daniel Borkmannbb333812013-06-28 19:49:40 +0200981 pr_debug("%s: skb:%p, len:%d, src:%pI4, dst:%pI4\n", __func__, skb,
982 skb->len, &transport->fl.u.ip4.saddr, &transport->fl.u.ip4.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
Herbert Xuf8803742008-08-03 21:15:08 -0700984 inet->pmtudisc = transport->param_flags & SPP_PMTUD_ENABLE ?
985 IP_PMTUDISC_DO : IP_PMTUDISC_DONT;
986
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000987 SCTP_INC_STATS(sock_net(&inet->sk), SCTP_MIB_OUTSCTPPACKS);
Daniel Borkmannbb333812013-06-28 19:49:40 +0200988
Eric Dumazetb0270e92014-04-15 12:58:34 -0400989 return ip_queue_xmit(&inet->sk, skb, &transport->fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990}
991
Neil Horman15efbe72008-02-15 09:53:59 -0500992static struct sctp_af sctp_af_inet;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993
994static struct sctp_pf sctp_pf_inet = {
995 .event_msgname = sctp_inet_event_msgname,
996 .skb_msgname = sctp_inet_skb_msgname,
997 .af_supported = sctp_inet_af_supported,
998 .cmp_addr = sctp_inet_cmp_addr,
999 .bind_verify = sctp_inet_bind_verify,
1000 .send_verify = sctp_inet_send_verify,
1001 .supported_addrs = sctp_inet_supported_addrs,
1002 .create_accept_sk = sctp_v4_create_accept_sk,
Jason Gunthorpe299ee122014-07-30 12:40:53 -06001003 .addr_to_user = sctp_v4_addr_to_user,
1004 .to_sk_saddr = sctp_v4_to_sk_saddr,
1005 .to_sk_daddr = sctp_v4_to_sk_daddr,
Neil Horman15efbe72008-02-15 09:53:59 -05001006 .af = &sctp_af_inet
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007};
1008
1009/* Notifier for inetaddr addition/deletion events. */
1010static struct notifier_block sctp_inetaddr_notifier = {
1011 .notifier_call = sctp_inetaddr_event,
1012};
1013
1014/* Socket operations. */
Eric Dumazet90ddc4f2005-12-22 12:49:22 -08001015static const struct proto_ops inet_seqpacket_ops = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001016 .family = PF_INET,
1017 .owner = THIS_MODULE,
1018 .release = inet_release, /* Needs to be wrapped... */
1019 .bind = inet_bind,
1020 .connect = inet_dgram_connect,
1021 .socketpair = sock_no_socketpair,
1022 .accept = inet_accept,
1023 .getname = inet_getname, /* Semantics are different. */
1024 .poll = sctp_poll,
1025 .ioctl = inet_ioctl,
1026 .listen = sctp_inet_listen,
1027 .shutdown = inet_shutdown, /* Looks harmless. */
1028 .setsockopt = sock_common_setsockopt, /* IP_SOL IP_OPTION is a problem */
1029 .getsockopt = sock_common_getsockopt,
1030 .sendmsg = inet_sendmsg,
Xin Longfd2d1802016-07-22 21:25:42 +08001031 .recvmsg = inet_recvmsg,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001032 .mmap = sock_no_mmap,
1033 .sendpage = sock_no_sendpage,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001034#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001035 .compat_setsockopt = compat_sock_common_setsockopt,
1036 .compat_getsockopt = compat_sock_common_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001037#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038};
1039
1040/* Registration with AF_INET family. */
1041static struct inet_protosw sctp_seqpacket_protosw = {
1042 .type = SOCK_SEQPACKET,
1043 .protocol = IPPROTO_SCTP,
1044 .prot = &sctp_prot,
1045 .ops = &inet_seqpacket_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 .flags = SCTP_PROTOSW_FLAG
1047};
1048static struct inet_protosw sctp_stream_protosw = {
1049 .type = SOCK_STREAM,
1050 .protocol = IPPROTO_SCTP,
1051 .prot = &sctp_prot,
1052 .ops = &inet_seqpacket_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 .flags = SCTP_PROTOSW_FLAG
1054};
1055
1056/* Register with IP layer. */
Alexey Dobriyan32613092009-09-14 12:21:47 +00001057static const struct net_protocol sctp_protocol = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 .handler = sctp_rcv,
1059 .err_handler = sctp_v4_err,
1060 .no_policy = 1,
Eric W. Biedermanbb2db452012-08-06 08:46:26 +00001061 .netns_ok = 1,
Hannes Frederic Sowa8ed1dc42014-01-09 10:01:17 +01001062 .icmp_strict_tag_validation = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063};
1064
1065/* IPv4 address related functions. */
Neil Horman15efbe72008-02-15 09:53:59 -05001066static struct sctp_af sctp_af_inet = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001067 .sa_family = AF_INET,
1068 .sctp_xmit = sctp_v4_xmit,
1069 .setsockopt = ip_setsockopt,
1070 .getsockopt = ip_getsockopt,
1071 .get_dst = sctp_v4_get_dst,
1072 .get_saddr = sctp_v4_get_saddr,
1073 .copy_addrlist = sctp_v4_copy_addrlist,
1074 .from_skb = sctp_v4_from_skb,
1075 .from_sk = sctp_v4_from_sk,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001076 .from_addr_param = sctp_v4_from_addr_param,
1077 .to_addr_param = sctp_v4_to_addr_param,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001078 .cmp_addr = sctp_v4_cmp_addr,
1079 .addr_valid = sctp_v4_addr_valid,
1080 .inaddr_any = sctp_v4_inaddr_any,
1081 .is_any = sctp_v4_is_any,
1082 .available = sctp_v4_available,
1083 .scope = sctp_v4_scope,
1084 .skb_iif = sctp_v4_skb_iif,
1085 .is_ce = sctp_v4_is_ce,
1086 .seq_dump_addr = sctp_v4_seq_dump_addr,
Vlad Yasevichb9031d92008-06-04 12:40:15 -07001087 .ecn_capable = sctp_v4_ecn_capable,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001088 .net_header_len = sizeof(struct iphdr),
1089 .sockaddr_len = sizeof(struct sockaddr_in),
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001090#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001091 .compat_setsockopt = compat_ip_setsockopt,
1092 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001093#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094};
1095
wangweidong8d726512013-12-23 12:16:53 +08001096struct sctp_pf *sctp_get_pf_specific(sa_family_t family)
1097{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 switch (family) {
1099 case PF_INET:
1100 return sctp_pf_inet_specific;
1101 case PF_INET6:
1102 return sctp_pf_inet6_specific;
1103 default:
1104 return NULL;
1105 }
1106}
1107
1108/* Register the PF specific function table. */
1109int sctp_register_pf(struct sctp_pf *pf, sa_family_t family)
1110{
1111 switch (family) {
1112 case PF_INET:
1113 if (sctp_pf_inet_specific)
1114 return 0;
1115 sctp_pf_inet_specific = pf;
1116 break;
1117 case PF_INET6:
1118 if (sctp_pf_inet6_specific)
1119 return 0;
1120 sctp_pf_inet6_specific = pf;
1121 break;
1122 default:
1123 return 0;
1124 }
1125 return 1;
1126}
1127
Eric W. Biedermanb01a2402012-08-06 08:47:55 +00001128static inline int init_sctp_mibs(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129{
WANG Cong698365f2014-05-05 15:55:55 -07001130 net->sctp.sctp_statistics = alloc_percpu(struct sctp_mib);
1131 if (!net->sctp.sctp_statistics)
1132 return -ENOMEM;
1133 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134}
1135
Eric W. Biedermanb01a2402012-08-06 08:47:55 +00001136static inline void cleanup_sctp_mibs(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137{
WANG Cong698365f2014-05-05 15:55:55 -07001138 free_percpu(net->sctp.sctp_statistics);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139}
1140
Vlad Yasevich270637a2008-03-20 15:17:14 -07001141static void sctp_v4_pf_init(void)
1142{
1143 /* Initialize the SCTP specific PF functions. */
1144 sctp_register_pf(&sctp_pf_inet, PF_INET);
1145 sctp_register_af(&sctp_af_inet);
1146}
1147
1148static void sctp_v4_pf_exit(void)
1149{
1150 list_del(&sctp_af_inet.list);
1151}
1152
1153static int sctp_v4_protosw_init(void)
1154{
1155 int rc;
1156
1157 rc = proto_register(&sctp_prot, 1);
1158 if (rc)
1159 return rc;
1160
1161 /* Register SCTP(UDP and TCP style) with socket layer. */
1162 inet_register_protosw(&sctp_seqpacket_protosw);
1163 inet_register_protosw(&sctp_stream_protosw);
1164
1165 return 0;
1166}
1167
1168static void sctp_v4_protosw_exit(void)
1169{
1170 inet_unregister_protosw(&sctp_stream_protosw);
1171 inet_unregister_protosw(&sctp_seqpacket_protosw);
1172 proto_unregister(&sctp_prot);
1173}
1174
1175static int sctp_v4_add_protocol(void)
1176{
1177 /* Register notifier for inet address additions/deletions. */
1178 register_inetaddr_notifier(&sctp_inetaddr_notifier);
1179
1180 /* Register SCTP with inet layer. */
1181 if (inet_add_protocol(&sctp_protocol, IPPROTO_SCTP) < 0)
1182 return -EAGAIN;
1183
1184 return 0;
1185}
1186
1187static void sctp_v4_del_protocol(void)
1188{
1189 inet_del_protocol(&sctp_protocol, IPPROTO_SCTP);
1190 unregister_inetaddr_notifier(&sctp_inetaddr_notifier);
1191}
1192
Marcelo Ricardo Leitner8e2d61e2015-09-10 17:31:15 -03001193static int __net_init sctp_defaults_init(struct net *net)
Eric W. Biederman4db67e82012-08-06 08:42:04 +00001194{
Eric W. Biederman2ce95502012-08-06 08:43:06 +00001195 int status;
1196
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00001197 /*
1198 * 14. Suggested SCTP Protocol Parameter Values
1199 */
1200 /* The following protocol parameters are RECOMMENDED: */
1201 /* RTO.Initial - 3 seconds */
1202 net->sctp.rto_initial = SCTP_RTO_INITIAL;
1203 /* RTO.Min - 1 second */
1204 net->sctp.rto_min = SCTP_RTO_MIN;
1205 /* RTO.Max - 60 seconds */
1206 net->sctp.rto_max = SCTP_RTO_MAX;
1207 /* RTO.Alpha - 1/8 */
1208 net->sctp.rto_alpha = SCTP_RTO_ALPHA;
1209 /* RTO.Beta - 1/4 */
1210 net->sctp.rto_beta = SCTP_RTO_BETA;
1211
1212 /* Valid.Cookie.Life - 60 seconds */
1213 net->sctp.valid_cookie_life = SCTP_DEFAULT_COOKIE_LIFE;
1214
1215 /* Whether Cookie Preservative is enabled(1) or not(0) */
1216 net->sctp.cookie_preserve_enable = 1;
1217
Neil Horman3c681982012-10-24 09:20:03 +00001218 /* Default sctp sockets to use md5 as their hmac alg */
Neil Horman0d0863b2012-12-14 15:22:01 +00001219#if defined (CONFIG_SCTP_DEFAULT_COOKIE_HMAC_MD5)
Neil Horman3c681982012-10-24 09:20:03 +00001220 net->sctp.sctp_hmac_alg = "md5";
Neil Horman0d0863b2012-12-14 15:22:01 +00001221#elif defined (CONFIG_SCTP_DEFAULT_COOKIE_HMAC_SHA1)
Neil Horman3c681982012-10-24 09:20:03 +00001222 net->sctp.sctp_hmac_alg = "sha1";
1223#else
1224 net->sctp.sctp_hmac_alg = NULL;
1225#endif
1226
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00001227 /* Max.Burst - 4 */
1228 net->sctp.max_burst = SCTP_DEFAULT_MAX_BURST;
1229
Zhu Yanjun566178f2015-12-16 13:55:04 +08001230 /* Enable pf state by default */
1231 net->sctp.pf_enable = 1;
1232
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +00001233 /* Association.Max.Retrans - 10 attempts
1234 * Path.Max.Retrans - 5 attempts (per destination address)
1235 * Max.Init.Retransmits - 8 attempts
1236 */
1237 net->sctp.max_retrans_association = 10;
1238 net->sctp.max_retrans_path = 5;
1239 net->sctp.max_retrans_init = 8;
1240
1241 /* Sendbuffer growth - do per-socket accounting */
1242 net->sctp.sndbuf_policy = 0;
1243
1244 /* Rcvbuffer growth - do per-socket accounting */
1245 net->sctp.rcvbuf_policy = 0;
1246
1247 /* HB.interval - 30 seconds */
1248 net->sctp.hb_interval = SCTP_DEFAULT_TIMEOUT_HEARTBEAT;
1249
1250 /* delayed SACK timeout */
1251 net->sctp.sack_timeout = SCTP_DEFAULT_TIMEOUT_SACK;
1252
1253 /* Disable ADDIP by default. */
1254 net->sctp.addip_enable = 0;
1255 net->sctp.addip_noauth = 0;
1256 net->sctp.default_auto_asconf = 0;
1257
1258 /* Enable PR-SCTP by default. */
1259 net->sctp.prsctp_enable = 1;
1260
1261 /* Disable AUTH by default. */
1262 net->sctp.auth_enable = 0;
1263
1264 /* Set SCOPE policy to enabled */
1265 net->sctp.scope_policy = SCTP_SCOPE_POLICY_ENABLE;
1266
1267 /* Set the default rwnd update threshold */
1268 net->sctp.rwnd_upd_shift = SCTP_DEFAULT_RWND_SHIFT;
1269
1270 /* Initialize maximum autoclose timeout. */
1271 net->sctp.max_autoclose = INT_MAX / HZ;
1272
Eric W. Biedermanebb7e952012-08-07 07:23:59 +00001273 status = sctp_sysctl_net_register(net);
1274 if (status)
1275 goto err_sysctl_register;
1276
Eric W. Biedermanb01a2402012-08-06 08:47:55 +00001277 /* Allocate and initialise sctp mibs. */
1278 status = init_sctp_mibs(net);
1279 if (status)
1280 goto err_init_mibs;
1281
Eric W. Biederman13d782f2012-08-06 08:45:15 +00001282 /* Initialize proc fs directory. */
1283 status = sctp_proc_init(net);
1284 if (status)
1285 goto err_init_proc;
1286
1287 sctp_dbg_objcnt_init(net);
1288
Eric W. Biederman4db67e82012-08-06 08:42:04 +00001289 /* Initialize the local address list. */
1290 INIT_LIST_HEAD(&net->sctp.local_addr_list);
1291 spin_lock_init(&net->sctp.local_addr_lock);
1292 sctp_get_local_addr_list(net);
1293
1294 /* Initialize the address event list */
1295 INIT_LIST_HEAD(&net->sctp.addr_waitq);
1296 INIT_LIST_HEAD(&net->sctp.auto_asconf_splist);
1297 spin_lock_init(&net->sctp.addr_wq_lock);
1298 net->sctp.addr_wq_timer.expires = 0;
1299 setup_timer(&net->sctp.addr_wq_timer, sctp_addr_wq_timeout_handler,
1300 (unsigned long)net);
1301
1302 return 0;
Eric W. Biederman2ce95502012-08-06 08:43:06 +00001303
Eric W. Biederman13d782f2012-08-06 08:45:15 +00001304err_init_proc:
Eric W. Biedermanb01a2402012-08-06 08:47:55 +00001305 cleanup_sctp_mibs(net);
1306err_init_mibs:
Eric W. Biedermanebb7e952012-08-07 07:23:59 +00001307 sctp_sysctl_net_unregister(net);
1308err_sysctl_register:
Eric W. Biederman2ce95502012-08-06 08:43:06 +00001309 return status;
Eric W. Biederman4db67e82012-08-06 08:42:04 +00001310}
1311
Marcelo Ricardo Leitner8e2d61e2015-09-10 17:31:15 -03001312static void __net_exit sctp_defaults_exit(struct net *net)
Eric W. Biederman4db67e82012-08-06 08:42:04 +00001313{
1314 /* Free the local address list */
1315 sctp_free_addr_wq(net);
1316 sctp_free_local_addr_list(net);
Eric W. Biederman2ce95502012-08-06 08:43:06 +00001317
Eric W. Biederman13d782f2012-08-06 08:45:15 +00001318 sctp_dbg_objcnt_exit(net);
1319
1320 sctp_proc_exit(net);
Eric W. Biedermanb01a2402012-08-06 08:47:55 +00001321 cleanup_sctp_mibs(net);
Eric W. Biedermanebb7e952012-08-07 07:23:59 +00001322 sctp_sysctl_net_unregister(net);
Eric W. Biederman4db67e82012-08-06 08:42:04 +00001323}
1324
Marcelo Ricardo Leitner8e2d61e2015-09-10 17:31:15 -03001325static struct pernet_operations sctp_defaults_ops = {
1326 .init = sctp_defaults_init,
1327 .exit = sctp_defaults_exit,
1328};
1329
1330static int __net_init sctp_ctrlsock_init(struct net *net)
1331{
1332 int status;
1333
1334 /* Initialize the control inode/socket for handling OOTB packets. */
1335 status = sctp_ctl_sock_init(net);
1336 if (status)
1337 pr_err("Failed to initialize the SCTP control sock\n");
1338
1339 return status;
1340}
1341
1342static void __net_init sctp_ctrlsock_exit(struct net *net)
1343{
1344 /* Free the control endpoint. */
1345 inet_ctl_sock_destroy(net->sctp.ctl_sock);
1346}
1347
1348static struct pernet_operations sctp_ctrlsock_ops = {
1349 .init = sctp_ctrlsock_init,
1350 .exit = sctp_ctrlsock_exit,
Eric W. Biederman4db67e82012-08-06 08:42:04 +00001351};
1352
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353/* Initialize the universe into something sensible. */
Daniel Borkmanndda91922013-06-17 11:40:05 +02001354static __init int sctp_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355{
1356 int i;
1357 int status = -EINVAL;
1358 unsigned long goal;
Neil Horman4d93df02007-08-15 16:07:44 -07001359 unsigned long limit;
1360 int max_share;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 int order;
Neil Hormand9749fb2016-02-18 16:10:57 -05001362 int num_entries;
1363 int max_entry_order;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364
Eyal Birgerb4772ef2015-03-01 14:58:29 +02001365 sock_skb_cb_check_size(sizeof(struct sctp_ulpevent));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366
Sridhar Samudrala827bf122007-05-04 13:36:30 -07001367 /* Allocate bind_bucket and chunk caches. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 status = -ENOBUFS;
1369 sctp_bucket_cachep = kmem_cache_create("sctp_bind_bucket",
1370 sizeof(struct sctp_bind_bucket),
1371 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +09001372 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 if (!sctp_bucket_cachep)
Sridhar Samudrala827bf122007-05-04 13:36:30 -07001374 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
1376 sctp_chunk_cachep = kmem_cache_create("sctp_chunk",
1377 sizeof(struct sctp_chunk),
1378 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +09001379 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 if (!sctp_chunk_cachep)
1381 goto err_chunk_cachep;
1382
Tejun Heo908c7f12014-09-08 09:51:29 +09001383 status = percpu_counter_init(&sctp_sockets_allocated, 0, GFP_KERNEL);
Eric W. Biederman632c9282012-08-06 08:44:24 +00001384 if (status)
1385 goto err_percpu_counter_init;
1386
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 /* Implementation specific variables. */
1388
1389 /* Initialize default stream count setup information. */
1390 sctp_max_instreams = SCTP_DEFAULT_INSTREAMS;
1391 sctp_max_outstreams = SCTP_DEFAULT_OUTSTREAMS;
1392
1393 /* Initialize handle used for association ids. */
1394 idr_init(&sctp_assocs_id);
1395
Eric Dumazetf03d78d2011-07-07 00:27:05 -07001396 limit = nr_free_buffer_pages() / 8;
Neil Horman4d93df02007-08-15 16:07:44 -07001397 limit = max(limit, 128UL);
1398 sysctl_sctp_mem[0] = limit / 4 * 3;
1399 sysctl_sctp_mem[1] = limit;
1400 sysctl_sctp_mem[2] = sysctl_sctp_mem[0] * 2;
1401
1402 /* Set per-socket limits to no more than 1/128 the pressure threshold*/
1403 limit = (sysctl_sctp_mem[1]) << (PAGE_SHIFT - 7);
1404 max_share = min(4UL*1024*1024, limit);
1405
Vlad Yasevich845525a2008-07-18 23:08:21 -07001406 sysctl_sctp_rmem[0] = SK_MEM_QUANTUM; /* give each asoc 1 page min */
Eric Dumazet87fb4b72011-10-13 07:28:54 +00001407 sysctl_sctp_rmem[1] = 1500 * SKB_TRUESIZE(1);
Neil Horman4d93df02007-08-15 16:07:44 -07001408 sysctl_sctp_rmem[2] = max(sysctl_sctp_rmem[1], max_share);
1409
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001410 sysctl_sctp_wmem[0] = SK_MEM_QUANTUM;
Neil Horman4d93df02007-08-15 16:07:44 -07001411 sysctl_sctp_wmem[1] = 16*1024;
1412 sysctl_sctp_wmem[2] = max(64*1024, max_share);
1413
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 /* Size and allocate the association hash table.
1415 * The methodology is similar to that of the tcp hash tables.
Neil Hormand9749fb2016-02-18 16:10:57 -05001416 * Though not identical. Start by getting a goal size
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 */
Jan Beulich44813742009-09-21 17:03:05 -07001418 if (totalram_pages >= (128 * 1024))
1419 goal = totalram_pages >> (22 - PAGE_SHIFT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 else
Jan Beulich44813742009-09-21 17:03:05 -07001421 goal = totalram_pages >> (24 - PAGE_SHIFT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422
Neil Hormand9749fb2016-02-18 16:10:57 -05001423 /* Then compute the page order for said goal */
1424 order = get_order(goal);
1425
1426 /* Now compute the required page order for the maximum sized table we
1427 * want to create
1428 */
1429 max_entry_order = get_order(MAX_SCTP_PORT_HASH_ENTRIES *
1430 sizeof(struct sctp_bind_hashbucket));
1431
1432 /* Limit the page order by that maximum hash table size */
1433 order = min(order, max_entry_order);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 /* Allocate and initialize the endpoint hash table. */
1436 sctp_ep_hashsize = 64;
Zhang Yanfei3b77d662013-03-12 13:39:47 +08001437 sctp_ep_hashtable =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 kmalloc(64 * sizeof(struct sctp_hashbucket), GFP_KERNEL);
1439 if (!sctp_ep_hashtable) {
Joe Perches145ce502010-08-24 13:21:08 +00001440 pr_err("Failed endpoint_hash alloc\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 status = -ENOMEM;
1442 goto err_ehash_alloc;
1443 }
1444 for (i = 0; i < sctp_ep_hashsize; i++) {
1445 rwlock_init(&sctp_ep_hashtable[i].lock);
Vlad Yasevichd970dbf2007-11-09 11:43:40 -05001446 INIT_HLIST_HEAD(&sctp_ep_hashtable[i].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 }
1448
Neil Hormand9749fb2016-02-18 16:10:57 -05001449 /* Allocate and initialize the SCTP port hash table.
1450 * Note that order is initalized to start at the max sized
1451 * table we want to support. If we can't get that many pages
1452 * reduce the order and try again
1453 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 sctp_port_hashtable = (struct sctp_bind_hashbucket *)
Eric Dumazet6857a022015-12-15 15:33:39 -08001456 __get_free_pages(GFP_KERNEL | __GFP_NOWARN, order);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 } while (!sctp_port_hashtable && --order > 0);
Neil Hormand9749fb2016-02-18 16:10:57 -05001458
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 if (!sctp_port_hashtable) {
Joe Perches145ce502010-08-24 13:21:08 +00001460 pr_err("Failed bind hash alloc\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 status = -ENOMEM;
1462 goto err_bhash_alloc;
1463 }
Neil Hormand9749fb2016-02-18 16:10:57 -05001464
1465 /* Now compute the number of entries that will fit in the
1466 * port hash space we allocated
1467 */
1468 num_entries = (1UL << order) * PAGE_SIZE /
1469 sizeof(struct sctp_bind_hashbucket);
1470
1471 /* And finish by rounding it down to the nearest power of two
1472 * this wastes some memory of course, but its needed because
1473 * the hash function operates based on the assumption that
1474 * that the number of entries is a power of two
1475 */
1476 sctp_port_hashsize = rounddown_pow_of_two(num_entries);
1477
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 for (i = 0; i < sctp_port_hashsize; i++) {
1479 spin_lock_init(&sctp_port_hashtable[i].lock);
Vlad Yasevichd970dbf2007-11-09 11:43:40 -05001480 INIT_HLIST_HEAD(&sctp_port_hashtable[i].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 }
1482
Wei Yongjuna5e27d12016-06-13 23:08:26 +08001483 status = sctp_transport_hashtable_init();
1484 if (status)
Xin Long4f008782015-12-30 23:50:47 +08001485 goto err_thash_alloc;
1486
Neil Hormand9749fb2016-02-18 16:10:57 -05001487 pr_info("Hash tables configured (bind %d/%d)\n", sctp_port_hashsize,
1488 num_entries);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 sctp_sysctl_register();
1491
1492 INIT_LIST_HEAD(&sctp_address_families);
Vlad Yasevich270637a2008-03-20 15:17:14 -07001493 sctp_v4_pf_init();
1494 sctp_v6_pf_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495
Marcelo Ricardo Leitner8e2d61e2015-09-10 17:31:15 -03001496 status = register_pernet_subsys(&sctp_defaults_ops);
1497 if (status)
1498 goto err_register_defaults;
Vlad Yasevich270637a2008-03-20 15:17:14 -07001499
Marcelo Ricardo Leitner8e2d61e2015-09-10 17:31:15 -03001500 status = sctp_v4_protosw_init();
Sridhar Samudrala827bf122007-05-04 13:36:30 -07001501 if (status)
Vlad Yasevich270637a2008-03-20 15:17:14 -07001502 goto err_protosw_init;
Sridhar Samudrala827bf122007-05-04 13:36:30 -07001503
Vlad Yasevich270637a2008-03-20 15:17:14 -07001504 status = sctp_v6_protosw_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 if (status)
Vlad Yasevich270637a2008-03-20 15:17:14 -07001506 goto err_v6_protosw_init;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507
Marcelo Ricardo Leitner8e2d61e2015-09-10 17:31:15 -03001508 status = register_pernet_subsys(&sctp_ctrlsock_ops);
Eric W. Biederman4db67e82012-08-06 08:42:04 +00001509 if (status)
Marcelo Ricardo Leitner8e2d61e2015-09-10 17:31:15 -03001510 goto err_register_ctrlsock;
Eric W. Biederman4db67e82012-08-06 08:42:04 +00001511
Vlad Yasevich270637a2008-03-20 15:17:14 -07001512 status = sctp_v4_add_protocol();
1513 if (status)
Sridhar Samudrala827bf122007-05-04 13:36:30 -07001514 goto err_add_protocol;
Sridhar Samudrala827bf122007-05-04 13:36:30 -07001515
1516 /* Register SCTP with inet6 layer. */
1517 status = sctp_v6_add_protocol();
1518 if (status)
1519 goto err_v6_add_protocol;
1520
Marcelo Ricardo Leitner90017ac2016-06-02 15:05:43 -03001521 if (sctp_offload_init() < 0)
1522 pr_crit("%s: Cannot add SCTP protocol offload\n", __func__);
1523
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524out:
1525 return status;
Sridhar Samudrala827bf122007-05-04 13:36:30 -07001526err_v6_add_protocol:
Vlad Yasevich270637a2008-03-20 15:17:14 -07001527 sctp_v4_del_protocol();
Vlad Yasevichd1dd5242009-03-02 06:46:50 +00001528err_add_protocol:
Marcelo Ricardo Leitner8e2d61e2015-09-10 17:31:15 -03001529 unregister_pernet_subsys(&sctp_ctrlsock_ops);
1530err_register_ctrlsock:
Vlad Yasevich270637a2008-03-20 15:17:14 -07001531 sctp_v6_protosw_exit();
1532err_v6_protosw_init:
1533 sctp_v4_protosw_exit();
1534err_protosw_init:
Marcelo Ricardo Leitner8e2d61e2015-09-10 17:31:15 -03001535 unregister_pernet_subsys(&sctp_defaults_ops);
1536err_register_defaults:
Vlad Yasevich270637a2008-03-20 15:17:14 -07001537 sctp_v4_pf_exit();
1538 sctp_v6_pf_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 sctp_sysctl_unregister();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 free_pages((unsigned long)sctp_port_hashtable,
1541 get_order(sctp_port_hashsize *
1542 sizeof(struct sctp_bind_hashbucket)));
1543err_bhash_alloc:
Xin Long4f008782015-12-30 23:50:47 +08001544 sctp_transport_hashtable_destroy();
1545err_thash_alloc:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 kfree(sctp_ep_hashtable);
1547err_ehash_alloc:
Eric W. Biederman632c9282012-08-06 08:44:24 +00001548 percpu_counter_destroy(&sctp_sockets_allocated);
1549err_percpu_counter_init:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 kmem_cache_destroy(sctp_chunk_cachep);
1551err_chunk_cachep:
1552 kmem_cache_destroy(sctp_bucket_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553 goto out;
1554}
1555
1556/* Exit handler for the SCTP protocol. */
Daniel Borkmanndda91922013-06-17 11:40:05 +02001557static __exit void sctp_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558{
1559 /* BUG. This should probably do something useful like clean
1560 * up all the remaining associations and all that memory.
1561 */
1562
Sridhar Samudrala827bf122007-05-04 13:36:30 -07001563 /* Unregister with inet6/inet layers. */
1564 sctp_v6_del_protocol();
Vlad Yasevich270637a2008-03-20 15:17:14 -07001565 sctp_v4_del_protocol();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566
Marcelo Ricardo Leitner8e2d61e2015-09-10 17:31:15 -03001567 unregister_pernet_subsys(&sctp_ctrlsock_ops);
Eric W. Biederman4db67e82012-08-06 08:42:04 +00001568
Vlad Yasevich270637a2008-03-20 15:17:14 -07001569 /* Free protosw registrations */
1570 sctp_v6_protosw_exit();
1571 sctp_v4_protosw_exit();
1572
Marcelo Ricardo Leitner8e2d61e2015-09-10 17:31:15 -03001573 unregister_pernet_subsys(&sctp_defaults_ops);
1574
Sridhar Samudrala827bf122007-05-04 13:36:30 -07001575 /* Unregister with socket layer. */
Vlad Yasevich270637a2008-03-20 15:17:14 -07001576 sctp_v6_pf_exit();
1577 sctp_v4_pf_exit();
Sridhar Samudrala827bf122007-05-04 13:36:30 -07001578
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 sctp_sysctl_unregister();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 free_pages((unsigned long)sctp_port_hashtable,
1582 get_order(sctp_port_hashsize *
1583 sizeof(struct sctp_bind_hashbucket)));
Xin Longb5eff712015-12-30 23:50:49 +08001584 kfree(sctp_ep_hashtable);
Xin Long4f008782015-12-30 23:50:47 +08001585 sctp_transport_hashtable_destroy();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586
Eric W. Biederman632c9282012-08-06 08:44:24 +00001587 percpu_counter_destroy(&sctp_sockets_allocated);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588
Jesper Dangaard Brouereaa184a2009-06-08 03:11:43 +00001589 rcu_barrier(); /* Wait for completion of call_rcu()'s */
1590
Sridhar Samudrala827bf122007-05-04 13:36:30 -07001591 kmem_cache_destroy(sctp_chunk_cachep);
1592 kmem_cache_destroy(sctp_bucket_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593}
1594
1595module_init(sctp_init);
1596module_exit(sctp_exit);
1597
Arnaldo Carvalho de Melobb97d312005-08-09 20:19:14 -07001598/*
1599 * __stringify doesn't likes enums, so use IPPROTO_SCTP value (132) directly.
1600 */
1601MODULE_ALIAS("net-pf-" __stringify(PF_INET) "-proto-132");
Sridhar Samudrala882a3822006-12-13 16:33:35 -08001602MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-132");
Daniel Borkmann91705c62013-07-23 14:51:47 +02001603MODULE_AUTHOR("Linux Kernel SCTP developers <linux-sctp@vger.kernel.org>");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604MODULE_DESCRIPTION("Support for the SCTP protocol (RFC2960)");
David S. Miller71acc0d2013-08-09 13:09:41 -07001605module_param_named(no_checksums, sctp_checksum_disable, bool, 0644);
1606MODULE_PARM_DESC(no_checksums, "Disable checksums computing and verification");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607MODULE_LICENSE("GPL");