blob: 1250751bca1bc2283307aaf668a788013d7149b4 [file] [log] [blame]
Thomas Gleixner47505b82019-05-23 11:14:41 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Vlad Yasevich60c778b2008-01-11 09:57:09 -05002/* SCTP kernel implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * (C) Copyright IBM Corp. 2002, 2004
4 * Copyright (c) 2002 Intel Corp.
5 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -05006 * This file is part of the SCTP kernel implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
8 * Sysctl related interfaces for SCTP.
9 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 * Please send any bug reports or fixes you make to the
11 * email address(es):
Daniel Borkmann91705c62013-07-23 14:51:47 +020012 * lksctp developers <linux-sctp@vger.kernel.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070014 * Written or modified by:
15 * Mingqin Liu <liuming@us.ibm.com>
16 * Jon Grimm <jgrimm@us.ibm.com>
17 * Ardelle Fan <ardelle.fan@intel.com>
18 * Ryan Layer <rmlayer@us.ibm.com>
19 * Sridhar Samudrala <sri@us.ibm.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 */
21
Daniel Borkmannb58537a2014-06-15 00:59:14 +020022#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
23
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <net/sctp/structs.h>
Adrian Bunk8c5955d2005-09-05 18:07:42 -070025#include <net/sctp/sctp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/sysctl.h>
27
Vladislav Yasevich3fd091e2006-08-22 13:29:17 -070028static int timer_max = 86400000; /* ms in one day */
Jean-Mickael Guerind48e0742009-05-13 00:03:20 +020029static int sack_timer_min = 1;
30static int sack_timer_max = 500;
Xin Long701ef3e2017-08-05 19:59:53 +080031static int addr_scope_max = SCTP_SCOPE_POLICY_MAX;
Vlad Yasevich90f2f532009-11-23 15:53:57 -050032static int rwnd_scale_max = 16;
Daniel Borkmannb58537a2014-06-15 00:59:14 +020033static int rto_alpha_min = 0;
34static int rto_beta_min = 0;
35static int rto_alpha_max = 1000;
36static int rto_beta_max = 1000;
37
Xi Wang2692ba62011-12-16 12:44:15 +000038static unsigned long max_autoclose_min = 0;
39static unsigned long max_autoclose_max =
40 (MAX_SCHEDULE_TIMEOUT / HZ > UINT_MAX)
41 ? UINT_MAX : MAX_SCHEDULE_TIMEOUT / HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
wangweidongb486b222013-12-11 09:50:40 +080043static int proc_sctp_do_hmac_alg(struct ctl_table *ctl, int write,
Neil Horman3c681982012-10-24 09:20:03 +000044 void __user *buffer, size_t *lenp,
Neil Horman3c681982012-10-24 09:20:03 +000045 loff_t *ppos);
wangweidong4f3fdf32013-12-11 09:50:39 +080046static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write,
47 void __user *buffer, size_t *lenp,
48 loff_t *ppos);
49static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write,
50 void __user *buffer, size_t *lenp,
51 loff_t *ppos);
Daniel Borkmannb58537a2014-06-15 00:59:14 +020052static int proc_sctp_do_alpha_beta(struct ctl_table *ctl, int write,
53 void __user *buffer, size_t *lenp,
54 loff_t *ppos);
Vlad Yasevichb14878c2014-04-17 17:26:50 +020055static int proc_sctp_do_auth(struct ctl_table *ctl, int write,
56 void __user *buffer, size_t *lenp,
57 loff_t *ppos);
wangweidong4f3fdf32013-12-11 09:50:39 +080058
Joe Perchesfe2c6332013-06-11 23:04:25 -070059static struct ctl_table sctp_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 {
Neil Horman4d93df02007-08-15 16:07:44 -070061 .procname = "sctp_mem",
62 .data = &sysctl_sctp_mem,
63 .maxlen = sizeof(sysctl_sctp_mem),
64 .mode = 0644,
Eric Dumazet8d987e52010-11-09 23:24:26 +000065 .proc_handler = proc_doulongvec_minmax
Neil Horman4d93df02007-08-15 16:07:44 -070066 },
67 {
Neil Horman4d93df02007-08-15 16:07:44 -070068 .procname = "sctp_rmem",
69 .data = &sysctl_sctp_rmem,
70 .maxlen = sizeof(sysctl_sctp_rmem),
71 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -080072 .proc_handler = proc_dointvec,
Neil Horman4d93df02007-08-15 16:07:44 -070073 },
74 {
Neil Horman4d93df02007-08-15 16:07:44 -070075 .procname = "sctp_wmem",
76 .data = &sysctl_sctp_wmem,
77 .maxlen = sizeof(sysctl_sctp_wmem),
78 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -080079 .proc_handler = proc_dointvec,
Neil Horman4d93df02007-08-15 16:07:44 -070080 },
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +000081
82 { /* sentinel */ }
83};
84
Joe Perchesfe2c6332013-06-11 23:04:25 -070085static struct ctl_table sctp_net_table[] = {
Vlad Yasevicha29a5bd2007-09-16 19:31:35 -070086 {
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +000087 .procname = "rto_initial",
88 .data = &init_net.sctp.rto_initial,
89 .maxlen = sizeof(unsigned int),
90 .mode = 0644,
91 .proc_handler = proc_dointvec_minmax,
Matteo Croceeec48442019-07-18 15:58:50 -070092 .extra1 = SYSCTL_ONE,
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +000093 .extra2 = &timer_max
94 },
95 {
96 .procname = "rto_min",
97 .data = &init_net.sctp.rto_min,
98 .maxlen = sizeof(unsigned int),
99 .mode = 0644,
wangweidong4f3fdf32013-12-11 09:50:39 +0800100 .proc_handler = proc_sctp_do_rto_min,
Matteo Croceeec48442019-07-18 15:58:50 -0700101 .extra1 = SYSCTL_ONE,
wangweidong4f3fdf32013-12-11 09:50:39 +0800102 .extra2 = &init_net.sctp.rto_max
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000103 },
104 {
105 .procname = "rto_max",
106 .data = &init_net.sctp.rto_max,
107 .maxlen = sizeof(unsigned int),
108 .mode = 0644,
wangweidong4f3fdf32013-12-11 09:50:39 +0800109 .proc_handler = proc_sctp_do_rto_max,
110 .extra1 = &init_net.sctp.rto_min,
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000111 .extra2 = &timer_max
112 },
113 {
114 .procname = "rto_alpha_exp_divisor",
115 .data = &init_net.sctp.rto_alpha,
116 .maxlen = sizeof(int),
Daniel Borkmannb58537a2014-06-15 00:59:14 +0200117 .mode = 0644,
118 .proc_handler = proc_sctp_do_alpha_beta,
119 .extra1 = &rto_alpha_min,
120 .extra2 = &rto_alpha_max,
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000121 },
122 {
123 .procname = "rto_beta_exp_divisor",
124 .data = &init_net.sctp.rto_beta,
125 .maxlen = sizeof(int),
Daniel Borkmannb58537a2014-06-15 00:59:14 +0200126 .mode = 0644,
127 .proc_handler = proc_sctp_do_alpha_beta,
128 .extra1 = &rto_beta_min,
129 .extra2 = &rto_beta_max,
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000130 },
131 {
132 .procname = "max_burst",
133 .data = &init_net.sctp.max_burst,
134 .maxlen = sizeof(int),
135 .mode = 0644,
136 .proc_handler = proc_dointvec_minmax,
Matteo Croceeec48442019-07-18 15:58:50 -0700137 .extra1 = SYSCTL_ZERO,
138 .extra2 = SYSCTL_INT_MAX,
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000139 },
140 {
141 .procname = "cookie_preserve_enable",
142 .data = &init_net.sctp.cookie_preserve_enable,
143 .maxlen = sizeof(int),
144 .mode = 0644,
145 .proc_handler = proc_dointvec,
146 },
147 {
Neil Horman3c681982012-10-24 09:20:03 +0000148 .procname = "cookie_hmac_alg",
wangweidong22a1f5142014-02-12 09:44:43 +0800149 .data = &init_net.sctp.sctp_hmac_alg,
Neil Horman3c681982012-10-24 09:20:03 +0000150 .maxlen = 8,
151 .mode = 0644,
152 .proc_handler = proc_sctp_do_hmac_alg,
153 },
154 {
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000155 .procname = "valid_cookie_life",
156 .data = &init_net.sctp.valid_cookie_life,
157 .maxlen = sizeof(unsigned int),
158 .mode = 0644,
159 .proc_handler = proc_dointvec_minmax,
Matteo Croceeec48442019-07-18 15:58:50 -0700160 .extra1 = SYSCTL_ONE,
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000161 .extra2 = &timer_max
162 },
163 {
164 .procname = "sack_timeout",
165 .data = &init_net.sctp.sack_timeout,
166 .maxlen = sizeof(int),
167 .mode = 0644,
168 .proc_handler = proc_dointvec_minmax,
169 .extra1 = &sack_timer_min,
170 .extra2 = &sack_timer_max,
171 },
172 {
173 .procname = "hb_interval",
174 .data = &init_net.sctp.hb_interval,
175 .maxlen = sizeof(unsigned int),
176 .mode = 0644,
177 .proc_handler = proc_dointvec_minmax,
Matteo Croceeec48442019-07-18 15:58:50 -0700178 .extra1 = SYSCTL_ONE,
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000179 .extra2 = &timer_max
180 },
181 {
182 .procname = "association_max_retrans",
183 .data = &init_net.sctp.max_retrans_association,
184 .maxlen = sizeof(int),
185 .mode = 0644,
186 .proc_handler = proc_dointvec_minmax,
Matteo Croceeec48442019-07-18 15:58:50 -0700187 .extra1 = SYSCTL_ONE,
188 .extra2 = SYSCTL_INT_MAX,
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000189 },
190 {
191 .procname = "path_max_retrans",
192 .data = &init_net.sctp.max_retrans_path,
193 .maxlen = sizeof(int),
194 .mode = 0644,
195 .proc_handler = proc_dointvec_minmax,
Matteo Croceeec48442019-07-18 15:58:50 -0700196 .extra1 = SYSCTL_ONE,
197 .extra2 = SYSCTL_INT_MAX,
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000198 },
199 {
200 .procname = "max_init_retransmits",
201 .data = &init_net.sctp.max_retrans_init,
202 .maxlen = sizeof(int),
203 .mode = 0644,
204 .proc_handler = proc_dointvec_minmax,
Matteo Croceeec48442019-07-18 15:58:50 -0700205 .extra1 = SYSCTL_ONE,
206 .extra2 = SYSCTL_INT_MAX,
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000207 },
208 {
209 .procname = "pf_retrans",
210 .data = &init_net.sctp.pf_retrans,
211 .maxlen = sizeof(int),
212 .mode = 0644,
213 .proc_handler = proc_dointvec_minmax,
Matteo Croceeec48442019-07-18 15:58:50 -0700214 .extra1 = SYSCTL_ZERO,
215 .extra2 = SYSCTL_INT_MAX,
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000216 },
217 {
218 .procname = "sndbuf_policy",
219 .data = &init_net.sctp.sndbuf_policy,
220 .maxlen = sizeof(int),
221 .mode = 0644,
222 .proc_handler = proc_dointvec,
223 },
224 {
225 .procname = "rcvbuf_policy",
226 .data = &init_net.sctp.rcvbuf_policy,
227 .maxlen = sizeof(int),
228 .mode = 0644,
229 .proc_handler = proc_dointvec,
230 },
231 {
232 .procname = "default_auto_asconf",
233 .data = &init_net.sctp.default_auto_asconf,
234 .maxlen = sizeof(int),
235 .mode = 0644,
236 .proc_handler = proc_dointvec,
237 },
238 {
239 .procname = "addip_enable",
240 .data = &init_net.sctp.addip_enable,
Vlad Yasevicha29a5bd2007-09-16 19:31:35 -0700241 .maxlen = sizeof(int),
242 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -0800243 .proc_handler = proc_dointvec,
Vlad Yasevicha29a5bd2007-09-16 19:31:35 -0700244 },
Vlad Yasevich73d9c4f2007-10-24 17:24:26 -0400245 {
Vlad Yasevich73d9c4f2007-10-24 17:24:26 -0400246 .procname = "addip_noauth_enable",
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000247 .data = &init_net.sctp.addip_noauth,
248 .maxlen = sizeof(int),
249 .mode = 0644,
250 .proc_handler = proc_dointvec,
251 },
252 {
253 .procname = "prsctp_enable",
254 .data = &init_net.sctp.prsctp_enable,
255 .maxlen = sizeof(int),
256 .mode = 0644,
257 .proc_handler = proc_dointvec,
258 },
259 {
Xin Longc0d8bab2017-03-10 12:11:12 +0800260 .procname = "reconf_enable",
261 .data = &init_net.sctp.reconf_enable,
262 .maxlen = sizeof(int),
263 .mode = 0644,
264 .proc_handler = proc_dointvec,
265 },
266 {
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000267 .procname = "auth_enable",
268 .data = &init_net.sctp.auth_enable,
Vlad Yasevich73d9c4f2007-10-24 17:24:26 -0400269 .maxlen = sizeof(int),
270 .mode = 0644,
Vlad Yasevichb14878c2014-04-17 17:26:50 +0200271 .proc_handler = proc_sctp_do_auth,
Vlad Yasevich73d9c4f2007-10-24 17:24:26 -0400272 },
Bhaskar Dutta72388432009-09-03 17:25:47 +0530273 {
Xin Long463118c2017-12-15 00:41:32 +0800274 .procname = "intl_enable",
275 .data = &init_net.sctp.intl_enable,
276 .maxlen = sizeof(int),
277 .mode = 0644,
278 .proc_handler = proc_dointvec,
279 },
280 {
Bhaskar Dutta72388432009-09-03 17:25:47 +0530281 .procname = "addr_scope_policy",
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000282 .data = &init_net.sctp.scope_policy,
Bhaskar Dutta72388432009-09-03 17:25:47 +0530283 .maxlen = sizeof(int),
284 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800285 .proc_handler = proc_dointvec_minmax,
Matteo Croceeec48442019-07-18 15:58:50 -0700286 .extra1 = SYSCTL_ZERO,
Bhaskar Dutta72388432009-09-03 17:25:47 +0530287 .extra2 = &addr_scope_max,
288 },
Vlad Yasevich90f2f532009-11-23 15:53:57 -0500289 {
Vlad Yasevich90f2f532009-11-23 15:53:57 -0500290 .procname = "rwnd_update_shift",
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000291 .data = &init_net.sctp.rwnd_upd_shift,
Vlad Yasevich90f2f532009-11-23 15:53:57 -0500292 .maxlen = sizeof(int),
293 .mode = 0644,
294 .proc_handler = &proc_dointvec_minmax,
Matteo Croceeec48442019-07-18 15:58:50 -0700295 .extra1 = SYSCTL_ONE,
Vlad Yasevich90f2f532009-11-23 15:53:57 -0500296 .extra2 = &rwnd_scale_max,
297 },
Xi Wang2692ba62011-12-16 12:44:15 +0000298 {
299 .procname = "max_autoclose",
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000300 .data = &init_net.sctp.max_autoclose,
Xi Wang2692ba62011-12-16 12:44:15 +0000301 .maxlen = sizeof(unsigned long),
302 .mode = 0644,
303 .proc_handler = &proc_doulongvec_minmax,
304 .extra1 = &max_autoclose_min,
305 .extra2 = &max_autoclose_max,
306 },
Zhu Yanjun566178f2015-12-16 13:55:04 +0800307 {
308 .procname = "pf_enable",
309 .data = &init_net.sctp.pf_enable,
310 .maxlen = sizeof(int),
311 .mode = 0644,
312 .proc_handler = proc_dointvec,
313 },
David S. Miller71acc0d2013-08-09 13:09:41 -0700314
Linus Torvaldsd7fc02c2009-12-08 07:55:01 -0800315 { /* sentinel */ }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316};
317
wangweidongb486b222013-12-11 09:50:40 +0800318static int proc_sctp_do_hmac_alg(struct ctl_table *ctl, int write,
Neil Horman3c681982012-10-24 09:20:03 +0000319 void __user *buffer, size_t *lenp,
320 loff_t *ppos)
321{
322 struct net *net = current->nsproxy->net_ns;
Joe Perchesfe2c6332013-06-11 23:04:25 -0700323 struct ctl_table tbl;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200324 bool changed = false;
Neil Horman3c681982012-10-24 09:20:03 +0000325 char *none = "none";
Sasha Levin320f1a42016-01-07 14:52:43 -0500326 char tmp[8] = {0};
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200327 int ret;
Neil Horman3c681982012-10-24 09:20:03 +0000328
329 memset(&tbl, 0, sizeof(struct ctl_table));
330
331 if (write) {
332 tbl.data = tmp;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200333 tbl.maxlen = sizeof(tmp);
Neil Horman3c681982012-10-24 09:20:03 +0000334 } else {
335 tbl.data = net->sctp.sctp_hmac_alg ? : none;
336 tbl.maxlen = strlen(tbl.data);
337 }
Neil Horman3c681982012-10-24 09:20:03 +0000338
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200339 ret = proc_dostring(&tbl, write, buffer, lenp, ppos);
340 if (write && ret == 0) {
Neil Horman3c681982012-10-24 09:20:03 +0000341#ifdef CONFIG_CRYPTO_MD5
342 if (!strncmp(tmp, "md5", 3)) {
343 net->sctp.sctp_hmac_alg = "md5";
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200344 changed = true;
Neil Horman3c681982012-10-24 09:20:03 +0000345 }
346#endif
347#ifdef CONFIG_CRYPTO_SHA1
348 if (!strncmp(tmp, "sha1", 4)) {
349 net->sctp.sctp_hmac_alg = "sha1";
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200350 changed = true;
Neil Horman3c681982012-10-24 09:20:03 +0000351 }
352#endif
353 if (!strncmp(tmp, "none", 4)) {
354 net->sctp.sctp_hmac_alg = NULL;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200355 changed = true;
Neil Horman3c681982012-10-24 09:20:03 +0000356 }
Neil Horman3c681982012-10-24 09:20:03 +0000357 if (!changed)
358 ret = -EINVAL;
359 }
360
361 return ret;
362}
363
wangweidong4f3fdf32013-12-11 09:50:39 +0800364static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write,
365 void __user *buffer, size_t *lenp,
366 loff_t *ppos)
367{
368 struct net *net = current->nsproxy->net_ns;
wangweidong4f3fdf32013-12-11 09:50:39 +0800369 unsigned int min = *(unsigned int *) ctl->extra1;
370 unsigned int max = *(unsigned int *) ctl->extra2;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200371 struct ctl_table tbl;
372 int ret, new_value;
wangweidong4f3fdf32013-12-11 09:50:39 +0800373
374 memset(&tbl, 0, sizeof(struct ctl_table));
375 tbl.maxlen = sizeof(unsigned int);
376
377 if (write)
378 tbl.data = &new_value;
379 else
380 tbl.data = &net->sctp.rto_min;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200381
wangweidong4f3fdf32013-12-11 09:50:39 +0800382 ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200383 if (write && ret == 0) {
384 if (new_value > max || new_value < min)
wangweidong4f3fdf32013-12-11 09:50:39 +0800385 return -EINVAL;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200386
wangweidong4f3fdf32013-12-11 09:50:39 +0800387 net->sctp.rto_min = new_value;
388 }
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200389
wangweidong4f3fdf32013-12-11 09:50:39 +0800390 return ret;
391}
392
393static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write,
394 void __user *buffer, size_t *lenp,
395 loff_t *ppos)
396{
397 struct net *net = current->nsproxy->net_ns;
wangweidong4f3fdf32013-12-11 09:50:39 +0800398 unsigned int min = *(unsigned int *) ctl->extra1;
399 unsigned int max = *(unsigned int *) ctl->extra2;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200400 struct ctl_table tbl;
401 int ret, new_value;
wangweidong4f3fdf32013-12-11 09:50:39 +0800402
403 memset(&tbl, 0, sizeof(struct ctl_table));
404 tbl.maxlen = sizeof(unsigned int);
405
406 if (write)
407 tbl.data = &new_value;
408 else
409 tbl.data = &net->sctp.rto_max;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200410
wangweidong4f3fdf32013-12-11 09:50:39 +0800411 ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200412 if (write && ret == 0) {
413 if (new_value > max || new_value < min)
wangweidong4f3fdf32013-12-11 09:50:39 +0800414 return -EINVAL;
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200415
wangweidong4f3fdf32013-12-11 09:50:39 +0800416 net->sctp.rto_max = new_value;
417 }
Daniel Borkmannff5e92c2014-06-19 01:31:30 +0200418
wangweidong4f3fdf32013-12-11 09:50:39 +0800419 return ret;
420}
421
Daniel Borkmannb58537a2014-06-15 00:59:14 +0200422static int proc_sctp_do_alpha_beta(struct ctl_table *ctl, int write,
423 void __user *buffer, size_t *lenp,
424 loff_t *ppos)
425{
Daniel Borkmanneaea2da2014-06-30 13:52:09 +0200426 if (write)
427 pr_warn_once("Changing rto_alpha or rto_beta may lead to "
428 "suboptimal rtt/srtt estimations!\n");
Daniel Borkmannb58537a2014-06-15 00:59:14 +0200429
430 return proc_dointvec_minmax(ctl, write, buffer, lenp, ppos);
431}
432
Vlad Yasevichb14878c2014-04-17 17:26:50 +0200433static int proc_sctp_do_auth(struct ctl_table *ctl, int write,
434 void __user *buffer, size_t *lenp,
435 loff_t *ppos)
436{
437 struct net *net = current->nsproxy->net_ns;
438 struct ctl_table tbl;
439 int new_value, ret;
440
441 memset(&tbl, 0, sizeof(struct ctl_table));
442 tbl.maxlen = sizeof(unsigned int);
443
444 if (write)
445 tbl.data = &new_value;
446 else
447 tbl.data = &net->sctp.auth_enable;
448
449 ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
Daniel Borkmann24599e62014-06-18 23:46:31 +0200450 if (write && ret == 0) {
Vlad Yasevichb14878c2014-04-17 17:26:50 +0200451 struct sock *sk = net->sctp.ctl_sock;
452
453 net->sctp.auth_enable = new_value;
454 /* Update the value in the control socket */
455 lock_sock(sk);
456 sctp_sk(sk)->ep->auth_enable = new_value;
457 release_sock(sk);
458 }
459
460 return ret;
461}
462
Eric W. Biedermanebb7e952012-08-07 07:23:59 +0000463int sctp_sysctl_net_register(struct net *net)
464{
wangweidongeb9f3702014-05-08 20:55:01 +0800465 struct ctl_table *table;
466 int i;
Eric W. Biedermanebb7e952012-08-07 07:23:59 +0000467
wangweidongeb9f3702014-05-08 20:55:01 +0800468 table = kmemdup(sctp_net_table, sizeof(sctp_net_table), GFP_KERNEL);
469 if (!table)
470 return -ENOMEM;
Eric W. Biedermanebb7e952012-08-07 07:23:59 +0000471
wangweidongeb9f3702014-05-08 20:55:01 +0800472 for (i = 0; table[i].data; i++)
473 table[i].data += (char *)(&net->sctp) - (char *)&init_net.sctp;
Eric W. Biedermane1fc3b12012-08-07 07:29:57 +0000474
Eric W. Biedermanebb7e952012-08-07 07:23:59 +0000475 net->sctp.sysctl_header = register_net_sysctl(net, "net/sctp", table);
wangweidongf66138c2014-05-08 20:55:02 +0800476 if (net->sctp.sysctl_header == NULL) {
477 kfree(table);
478 return -ENOMEM;
479 }
Eric W. Biedermanebb7e952012-08-07 07:23:59 +0000480 return 0;
481}
482
483void sctp_sysctl_net_unregister(struct net *net)
484{
Vlad Yasevich5f19d122013-01-24 11:02:47 -0500485 struct ctl_table *table;
486
487 table = net->sctp.sysctl_header->ctl_table_arg;
Eric W. Biedermanebb7e952012-08-07 07:23:59 +0000488 unregister_net_sysctl_table(net->sctp.sysctl_header);
Vlad Yasevich5f19d122013-01-24 11:02:47 -0500489 kfree(table);
Eric W. Biedermanebb7e952012-08-07 07:23:59 +0000490}
491
wangweidong26ac8e52013-12-23 12:16:51 +0800492static struct ctl_table_header *sctp_sysctl_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
494/* Sysctl registration. */
495void sctp_sysctl_register(void)
496{
Eric W. Biedermanec8f23c2012-04-19 13:44:49 +0000497 sctp_sysctl_header = register_net_sysctl(&init_net, "net/sctp", sctp_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498}
499
500/* Sysctl deregistration. */
501void sctp_sysctl_unregister(void)
502{
Eric W. Biederman5dd3df12012-04-19 13:24:33 +0000503 unregister_net_sysctl_table(sctp_sysctl_header);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504}