blob: 2e9ada10fd846c10bc6281c30f29cf1fed02ca3c [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. 2002, 2004
3 * Copyright (c) 2002 Intel Corp.
4 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -05005 * This file is part of the SCTP kernel implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
7 * Sysctl related interfaces for SCTP.
8 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -05009 * This SCTP implementation is free software;
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 * you can redistribute it and/or modify it under the terms of
11 * the GNU General Public License as published by
12 * the Free Software Foundation; either version 2, or (at your option)
13 * any later version.
14 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -050015 * This SCTP implementation is distributed in the hope that it
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
17 * ************************
18 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
19 * See the GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
Jeff Kirsher4b2f13a2013-12-06 06:28:48 -080022 * along with GNU CC; see the file COPYING. If not, see
23 * <http://www.gnu.org/licenses/>.
Linus Torvalds1da177e2005-04-16 15:20:36 -070024 *
25 * Please send any bug reports or fixes you make to the
26 * email address(es):
Daniel Borkmann91705c62013-07-23 14:51:47 +020027 * lksctp developers <linux-sctp@vger.kernel.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070029 * Written or modified by:
30 * Mingqin Liu <liuming@us.ibm.com>
31 * Jon Grimm <jgrimm@us.ibm.com>
32 * Ardelle Fan <ardelle.fan@intel.com>
33 * Ryan Layer <rmlayer@us.ibm.com>
34 * Sridhar Samudrala <sri@us.ibm.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 */
36
Daniel Borkmannb58537a2014-06-15 00:59:14 +020037#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
38
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <net/sctp/structs.h>
Adrian Bunk8c5955d2005-09-05 18:07:42 -070040#include <net/sctp/sctp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/sysctl.h>
42
Vladislav Yasevich3fd091e2006-08-22 13:29:17 -070043static int zero = 0;
44static int one = 1;
45static int timer_max = 86400000; /* ms in one day */
46static int int_max = INT_MAX;
Jean-Mickael Guerind48e0742009-05-13 00:03:20 +020047static int sack_timer_min = 1;
48static int sack_timer_max = 500;
Bhaskar Dutta72388432009-09-03 17:25:47 +053049static int addr_scope_max = 3; /* check sctp_scope_policy_t in include/net/sctp/constants.h for max entries */
Vlad Yasevich90f2f532009-11-23 15:53:57 -050050static int rwnd_scale_max = 16;
Daniel Borkmannb58537a2014-06-15 00:59:14 +020051static int rto_alpha_min = 0;
52static int rto_beta_min = 0;
53static int rto_alpha_max = 1000;
54static int rto_beta_max = 1000;
55
Xi Wang2692ba62011-12-16 12:44:15 +000056static unsigned long max_autoclose_min = 0;
57static unsigned long max_autoclose_max =
58 (MAX_SCHEDULE_TIMEOUT / HZ > UINT_MAX)
59 ? UINT_MAX : MAX_SCHEDULE_TIMEOUT / HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Eric Dumazet8d987e52010-11-09 23:24:26 +000061extern long sysctl_sctp_mem[3];
Vlad Yasevich007e3932007-09-16 16:04:37 -070062extern int sysctl_sctp_rmem[3];
63extern int sysctl_sctp_wmem[3];
Neil Horman4d93df02007-08-15 16:07:44 -070064
wangweidongb486b222013-12-11 09:50:40 +080065static int proc_sctp_do_hmac_alg(struct ctl_table *ctl, int write,
Neil Horman3c681982012-10-24 09:20:03 +000066 void __user *buffer, size_t *lenp,
Neil Horman3c681982012-10-24 09:20:03 +000067 loff_t *ppos);
wangweidong4f3fdf32013-12-11 09:50:39 +080068static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write,
69 void __user *buffer, size_t *lenp,
70 loff_t *ppos);
71static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write,
72 void __user *buffer, size_t *lenp,
73 loff_t *ppos);
Daniel Borkmannb58537a2014-06-15 00:59:14 +020074static int proc_sctp_do_alpha_beta(struct ctl_table *ctl, int write,
75 void __user *buffer, size_t *lenp,
76 loff_t *ppos);
Vlad Yasevichb14878c2014-04-17 17:26:50 +020077static int proc_sctp_do_auth(struct ctl_table *ctl, int write,
78 void __user *buffer, size_t *lenp,
79 loff_t *ppos);
wangweidong4f3fdf32013-12-11 09:50:39 +080080
Joe Perchesfe2c6332013-06-11 23:04:25 -070081static struct ctl_table sctp_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 {
Neil Horman4d93df02007-08-15 16:07:44 -070083 .procname = "sctp_mem",
84 .data = &sysctl_sctp_mem,
85 .maxlen = sizeof(sysctl_sctp_mem),
86 .mode = 0644,
Eric Dumazet8d987e52010-11-09 23:24:26 +000087 .proc_handler = proc_doulongvec_minmax
Neil Horman4d93df02007-08-15 16:07:44 -070088 },
89 {
Neil Horman4d93df02007-08-15 16:07:44 -070090 .procname = "sctp_rmem",
91 .data = &sysctl_sctp_rmem,
92 .maxlen = sizeof(sysctl_sctp_rmem),
93 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -080094 .proc_handler = proc_dointvec,
Neil Horman4d93df02007-08-15 16:07:44 -070095 },
96 {
Neil Horman4d93df02007-08-15 16:07:44 -070097 .procname = "sctp_wmem",
98 .data = &sysctl_sctp_wmem,
99 .maxlen = sizeof(sysctl_sctp_wmem),
100 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -0800101 .proc_handler = proc_dointvec,
Neil Horman4d93df02007-08-15 16:07:44 -0700102 },
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000103
104 { /* sentinel */ }
105};
106
Joe Perchesfe2c6332013-06-11 23:04:25 -0700107static struct ctl_table sctp_net_table[] = {
Vlad Yasevicha29a5bd2007-09-16 19:31:35 -0700108 {
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000109 .procname = "rto_initial",
110 .data = &init_net.sctp.rto_initial,
111 .maxlen = sizeof(unsigned int),
112 .mode = 0644,
113 .proc_handler = proc_dointvec_minmax,
114 .extra1 = &one,
115 .extra2 = &timer_max
116 },
117 {
118 .procname = "rto_min",
119 .data = &init_net.sctp.rto_min,
120 .maxlen = sizeof(unsigned int),
121 .mode = 0644,
wangweidong4f3fdf32013-12-11 09:50:39 +0800122 .proc_handler = proc_sctp_do_rto_min,
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000123 .extra1 = &one,
wangweidong4f3fdf32013-12-11 09:50:39 +0800124 .extra2 = &init_net.sctp.rto_max
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000125 },
126 {
127 .procname = "rto_max",
128 .data = &init_net.sctp.rto_max,
129 .maxlen = sizeof(unsigned int),
130 .mode = 0644,
wangweidong4f3fdf32013-12-11 09:50:39 +0800131 .proc_handler = proc_sctp_do_rto_max,
132 .extra1 = &init_net.sctp.rto_min,
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000133 .extra2 = &timer_max
134 },
135 {
136 .procname = "rto_alpha_exp_divisor",
137 .data = &init_net.sctp.rto_alpha,
138 .maxlen = sizeof(int),
Daniel Borkmannb58537a2014-06-15 00:59:14 +0200139 .mode = 0644,
140 .proc_handler = proc_sctp_do_alpha_beta,
141 .extra1 = &rto_alpha_min,
142 .extra2 = &rto_alpha_max,
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000143 },
144 {
145 .procname = "rto_beta_exp_divisor",
146 .data = &init_net.sctp.rto_beta,
147 .maxlen = sizeof(int),
Daniel Borkmannb58537a2014-06-15 00:59:14 +0200148 .mode = 0644,
149 .proc_handler = proc_sctp_do_alpha_beta,
150 .extra1 = &rto_beta_min,
151 .extra2 = &rto_beta_max,
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000152 },
153 {
154 .procname = "max_burst",
155 .data = &init_net.sctp.max_burst,
156 .maxlen = sizeof(int),
157 .mode = 0644,
158 .proc_handler = proc_dointvec_minmax,
159 .extra1 = &zero,
160 .extra2 = &int_max
161 },
162 {
163 .procname = "cookie_preserve_enable",
164 .data = &init_net.sctp.cookie_preserve_enable,
165 .maxlen = sizeof(int),
166 .mode = 0644,
167 .proc_handler = proc_dointvec,
168 },
169 {
Neil Horman3c681982012-10-24 09:20:03 +0000170 .procname = "cookie_hmac_alg",
wangweidong22a1f5142014-02-12 09:44:43 +0800171 .data = &init_net.sctp.sctp_hmac_alg,
Neil Horman3c681982012-10-24 09:20:03 +0000172 .maxlen = 8,
173 .mode = 0644,
174 .proc_handler = proc_sctp_do_hmac_alg,
175 },
176 {
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000177 .procname = "valid_cookie_life",
178 .data = &init_net.sctp.valid_cookie_life,
179 .maxlen = sizeof(unsigned int),
180 .mode = 0644,
181 .proc_handler = proc_dointvec_minmax,
182 .extra1 = &one,
183 .extra2 = &timer_max
184 },
185 {
186 .procname = "sack_timeout",
187 .data = &init_net.sctp.sack_timeout,
188 .maxlen = sizeof(int),
189 .mode = 0644,
190 .proc_handler = proc_dointvec_minmax,
191 .extra1 = &sack_timer_min,
192 .extra2 = &sack_timer_max,
193 },
194 {
195 .procname = "hb_interval",
196 .data = &init_net.sctp.hb_interval,
197 .maxlen = sizeof(unsigned int),
198 .mode = 0644,
199 .proc_handler = proc_dointvec_minmax,
200 .extra1 = &one,
201 .extra2 = &timer_max
202 },
203 {
204 .procname = "association_max_retrans",
205 .data = &init_net.sctp.max_retrans_association,
206 .maxlen = sizeof(int),
207 .mode = 0644,
208 .proc_handler = proc_dointvec_minmax,
209 .extra1 = &one,
210 .extra2 = &int_max
211 },
212 {
213 .procname = "path_max_retrans",
214 .data = &init_net.sctp.max_retrans_path,
215 .maxlen = sizeof(int),
216 .mode = 0644,
217 .proc_handler = proc_dointvec_minmax,
218 .extra1 = &one,
219 .extra2 = &int_max
220 },
221 {
222 .procname = "max_init_retransmits",
223 .data = &init_net.sctp.max_retrans_init,
224 .maxlen = sizeof(int),
225 .mode = 0644,
226 .proc_handler = proc_dointvec_minmax,
227 .extra1 = &one,
228 .extra2 = &int_max
229 },
230 {
231 .procname = "pf_retrans",
232 .data = &init_net.sctp.pf_retrans,
233 .maxlen = sizeof(int),
234 .mode = 0644,
235 .proc_handler = proc_dointvec_minmax,
236 .extra1 = &zero,
237 .extra2 = &int_max
238 },
239 {
240 .procname = "sndbuf_policy",
241 .data = &init_net.sctp.sndbuf_policy,
242 .maxlen = sizeof(int),
243 .mode = 0644,
244 .proc_handler = proc_dointvec,
245 },
246 {
247 .procname = "rcvbuf_policy",
248 .data = &init_net.sctp.rcvbuf_policy,
249 .maxlen = sizeof(int),
250 .mode = 0644,
251 .proc_handler = proc_dointvec,
252 },
253 {
254 .procname = "default_auto_asconf",
255 .data = &init_net.sctp.default_auto_asconf,
256 .maxlen = sizeof(int),
257 .mode = 0644,
258 .proc_handler = proc_dointvec,
259 },
260 {
261 .procname = "addip_enable",
262 .data = &init_net.sctp.addip_enable,
Vlad Yasevicha29a5bd2007-09-16 19:31:35 -0700263 .maxlen = sizeof(int),
264 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -0800265 .proc_handler = proc_dointvec,
Vlad Yasevicha29a5bd2007-09-16 19:31:35 -0700266 },
Vlad Yasevich73d9c4f2007-10-24 17:24:26 -0400267 {
Vlad Yasevich73d9c4f2007-10-24 17:24:26 -0400268 .procname = "addip_noauth_enable",
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000269 .data = &init_net.sctp.addip_noauth,
270 .maxlen = sizeof(int),
271 .mode = 0644,
272 .proc_handler = proc_dointvec,
273 },
274 {
275 .procname = "prsctp_enable",
276 .data = &init_net.sctp.prsctp_enable,
277 .maxlen = sizeof(int),
278 .mode = 0644,
279 .proc_handler = proc_dointvec,
280 },
281 {
282 .procname = "auth_enable",
283 .data = &init_net.sctp.auth_enable,
Vlad Yasevich73d9c4f2007-10-24 17:24:26 -0400284 .maxlen = sizeof(int),
285 .mode = 0644,
Vlad Yasevichb14878c2014-04-17 17:26:50 +0200286 .proc_handler = proc_sctp_do_auth,
Vlad Yasevich73d9c4f2007-10-24 17:24:26 -0400287 },
Bhaskar Dutta72388432009-09-03 17:25:47 +0530288 {
Bhaskar Dutta72388432009-09-03 17:25:47 +0530289 .procname = "addr_scope_policy",
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000290 .data = &init_net.sctp.scope_policy,
Bhaskar Dutta72388432009-09-03 17:25:47 +0530291 .maxlen = sizeof(int),
292 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800293 .proc_handler = proc_dointvec_minmax,
Bhaskar Dutta72388432009-09-03 17:25:47 +0530294 .extra1 = &zero,
295 .extra2 = &addr_scope_max,
296 },
Vlad Yasevich90f2f532009-11-23 15:53:57 -0500297 {
Vlad Yasevich90f2f532009-11-23 15:53:57 -0500298 .procname = "rwnd_update_shift",
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000299 .data = &init_net.sctp.rwnd_upd_shift,
Vlad Yasevich90f2f532009-11-23 15:53:57 -0500300 .maxlen = sizeof(int),
301 .mode = 0644,
302 .proc_handler = &proc_dointvec_minmax,
Vlad Yasevich90f2f532009-11-23 15:53:57 -0500303 .extra1 = &one,
304 .extra2 = &rwnd_scale_max,
305 },
Xi Wang2692ba62011-12-16 12:44:15 +0000306 {
307 .procname = "max_autoclose",
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000308 .data = &init_net.sctp.max_autoclose,
Xi Wang2692ba62011-12-16 12:44:15 +0000309 .maxlen = sizeof(unsigned long),
310 .mode = 0644,
311 .proc_handler = &proc_doulongvec_minmax,
312 .extra1 = &max_autoclose_min,
313 .extra2 = &max_autoclose_max,
314 },
David S. Miller71acc0d2013-08-09 13:09:41 -0700315
Linus Torvaldsd7fc02c2009-12-08 07:55:01 -0800316 { /* sentinel */ }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317};
318
wangweidongb486b222013-12-11 09:50:40 +0800319static int proc_sctp_do_hmac_alg(struct ctl_table *ctl, int write,
Neil Horman3c681982012-10-24 09:20:03 +0000320 void __user *buffer, size_t *lenp,
321 loff_t *ppos)
322{
323 struct net *net = current->nsproxy->net_ns;
Joe Perchesfe2c6332013-06-11 23:04:25 -0700324 struct ctl_table tbl;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200325 bool changed = false;
Neil Horman3c681982012-10-24 09:20:03 +0000326 char *none = "none";
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200327 char tmp[8];
328 int ret;
Neil Horman3c681982012-10-24 09:20:03 +0000329
330 memset(&tbl, 0, sizeof(struct ctl_table));
331
332 if (write) {
333 tbl.data = tmp;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200334 tbl.maxlen = sizeof(tmp);
Neil Horman3c681982012-10-24 09:20:03 +0000335 } else {
336 tbl.data = net->sctp.sctp_hmac_alg ? : none;
337 tbl.maxlen = strlen(tbl.data);
338 }
Neil Horman3c681982012-10-24 09:20:03 +0000339
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200340 ret = proc_dostring(&tbl, write, buffer, lenp, ppos);
341 if (write && ret == 0) {
Neil Horman3c681982012-10-24 09:20:03 +0000342#ifdef CONFIG_CRYPTO_MD5
343 if (!strncmp(tmp, "md5", 3)) {
344 net->sctp.sctp_hmac_alg = "md5";
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200345 changed = true;
Neil Horman3c681982012-10-24 09:20:03 +0000346 }
347#endif
348#ifdef CONFIG_CRYPTO_SHA1
349 if (!strncmp(tmp, "sha1", 4)) {
350 net->sctp.sctp_hmac_alg = "sha1";
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200351 changed = true;
Neil Horman3c681982012-10-24 09:20:03 +0000352 }
353#endif
354 if (!strncmp(tmp, "none", 4)) {
355 net->sctp.sctp_hmac_alg = NULL;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200356 changed = true;
Neil Horman3c681982012-10-24 09:20:03 +0000357 }
Neil Horman3c681982012-10-24 09:20:03 +0000358 if (!changed)
359 ret = -EINVAL;
360 }
361
362 return ret;
363}
364
wangweidong4f3fdf32013-12-11 09:50:39 +0800365static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write,
366 void __user *buffer, size_t *lenp,
367 loff_t *ppos)
368{
369 struct net *net = current->nsproxy->net_ns;
wangweidong4f3fdf32013-12-11 09:50:39 +0800370 unsigned int min = *(unsigned int *) ctl->extra1;
371 unsigned int max = *(unsigned int *) ctl->extra2;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200372 struct ctl_table tbl;
373 int ret, new_value;
wangweidong4f3fdf32013-12-11 09:50:39 +0800374
375 memset(&tbl, 0, sizeof(struct ctl_table));
376 tbl.maxlen = sizeof(unsigned int);
377
378 if (write)
379 tbl.data = &new_value;
380 else
381 tbl.data = &net->sctp.rto_min;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200382
wangweidong4f3fdf32013-12-11 09:50:39 +0800383 ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200384 if (write && ret == 0) {
385 if (new_value > max || new_value < min)
wangweidong4f3fdf32013-12-11 09:50:39 +0800386 return -EINVAL;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200387
wangweidong4f3fdf32013-12-11 09:50:39 +0800388 net->sctp.rto_min = new_value;
389 }
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200390
wangweidong4f3fdf32013-12-11 09:50:39 +0800391 return ret;
392}
393
394static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write,
395 void __user *buffer, size_t *lenp,
396 loff_t *ppos)
397{
398 struct net *net = current->nsproxy->net_ns;
wangweidong4f3fdf32013-12-11 09:50:39 +0800399 unsigned int min = *(unsigned int *) ctl->extra1;
400 unsigned int max = *(unsigned int *) ctl->extra2;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200401 struct ctl_table tbl;
402 int ret, new_value;
wangweidong4f3fdf32013-12-11 09:50:39 +0800403
404 memset(&tbl, 0, sizeof(struct ctl_table));
405 tbl.maxlen = sizeof(unsigned int);
406
407 if (write)
408 tbl.data = &new_value;
409 else
410 tbl.data = &net->sctp.rto_max;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200411
wangweidong4f3fdf32013-12-11 09:50:39 +0800412 ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200413 if (write && ret == 0) {
414 if (new_value > max || new_value < min)
wangweidong4f3fdf32013-12-11 09:50:39 +0800415 return -EINVAL;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200416
wangweidong4f3fdf32013-12-11 09:50:39 +0800417 net->sctp.rto_max = new_value;
418 }
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200419
wangweidong4f3fdf32013-12-11 09:50:39 +0800420 return ret;
421}
422
Daniel Borkmannb58537a2014-06-15 00:59:14 +0200423static int proc_sctp_do_alpha_beta(struct ctl_table *ctl, int write,
424 void __user *buffer, size_t *lenp,
425 loff_t *ppos)
426{
Daniel Borkmanneaea2da2014-06-30 13:52:09 +0200427 if (write)
428 pr_warn_once("Changing rto_alpha or rto_beta may lead to "
429 "suboptimal rtt/srtt estimations!\n");
Daniel Borkmannb58537a2014-06-15 00:59:14 +0200430
431 return proc_dointvec_minmax(ctl, write, buffer, lenp, ppos);
432}
433
Vlad Yasevichb14878c2014-04-17 17:26:50 +0200434static int proc_sctp_do_auth(struct ctl_table *ctl, int write,
435 void __user *buffer, size_t *lenp,
436 loff_t *ppos)
437{
438 struct net *net = current->nsproxy->net_ns;
439 struct ctl_table tbl;
440 int new_value, ret;
441
442 memset(&tbl, 0, sizeof(struct ctl_table));
443 tbl.maxlen = sizeof(unsigned int);
444
445 if (write)
446 tbl.data = &new_value;
447 else
448 tbl.data = &net->sctp.auth_enable;
449
450 ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
Daniel Borkmann24599e62014-06-18 23:46:31 +0200451 if (write && ret == 0) {
Vlad Yasevichb14878c2014-04-17 17:26:50 +0200452 struct sock *sk = net->sctp.ctl_sock;
453
454 net->sctp.auth_enable = new_value;
455 /* Update the value in the control socket */
456 lock_sock(sk);
457 sctp_sk(sk)->ep->auth_enable = new_value;
458 release_sock(sk);
459 }
460
461 return ret;
462}
463
Eric W. Biedermanebb7e952012-08-07 07:23:59 +0000464int sctp_sysctl_net_register(struct net *net)
465{
wangweidongeb9f3702014-05-08 20:55:01 +0800466 struct ctl_table *table;
467 int i;
Eric W. Biedermanebb7e952012-08-07 07:23:59 +0000468
wangweidongeb9f3702014-05-08 20:55:01 +0800469 table = kmemdup(sctp_net_table, sizeof(sctp_net_table), GFP_KERNEL);
470 if (!table)
471 return -ENOMEM;
Eric W. Biedermanebb7e952012-08-07 07:23:59 +0000472
wangweidongeb9f3702014-05-08 20:55:01 +0800473 for (i = 0; table[i].data; i++)
474 table[i].data += (char *)(&net->sctp) - (char *)&init_net.sctp;
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000475
Eric W. Biedermanebb7e952012-08-07 07:23:59 +0000476 net->sctp.sysctl_header = register_net_sysctl(net, "net/sctp", table);
wangweidongf66138c2014-05-08 20:55:02 +0800477 if (net->sctp.sysctl_header == NULL) {
478 kfree(table);
479 return -ENOMEM;
480 }
Eric W. Biedermanebb7e952012-08-07 07:23:59 +0000481 return 0;
482}
483
484void sctp_sysctl_net_unregister(struct net *net)
485{
Vlad Yasevich5f19d122013-01-24 11:02:47 -0500486 struct ctl_table *table;
487
488 table = net->sctp.sysctl_header->ctl_table_arg;
Eric W. Biedermanebb7e952012-08-07 07:23:59 +0000489 unregister_net_sysctl_table(net->sctp.sysctl_header);
Vlad Yasevich5f19d122013-01-24 11:02:47 -0500490 kfree(table);
Eric W. Biedermanebb7e952012-08-07 07:23:59 +0000491}
492
wangweidong26ac8e52013-12-23 12:16:51 +0800493static struct ctl_table_header *sctp_sysctl_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
495/* Sysctl registration. */
496void sctp_sysctl_register(void)
497{
Eric W. Biedermanec8f23c2012-04-19 13:44:49 +0000498 sctp_sysctl_header = register_net_sysctl(&init_net, "net/sctp", sctp_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499}
500
501/* Sysctl deregistration. */
502void sctp_sysctl_unregister(void)
503{
Eric W. Biederman5dd3df12012-04-19 13:24:33 +0000504 unregister_net_sysctl_table(sctp_sysctl_header);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505}