1 /* SCTP kernel implementation
2 * (C) Copyright IBM Corp. 2002, 2004
3 * Copyright (c) 2002 Intel Corp.
5 * This file is part of the SCTP kernel implementation
7 * Sysctl related interfaces for SCTP.
9 * This SCTP implementation is free software;
10 * 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)
15 * This SCTP implementation is distributed in the hope that it
16 * 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.
21 * You should have received a copy of the GNU General Public License
22 * along with GNU CC; see the file COPYING. If not, write to
23 * the Free Software Foundation, 59 Temple Place - Suite 330,
24 * Boston, MA 02111-1307, USA.
26 * Please send any bug reports or fixes you make to the
28 * lksctp developers <linux-sctp@vger.kernel.org>
30 * Written or modified by:
31 * Mingqin Liu <liuming@us.ibm.com>
32 * Jon Grimm <jgrimm@us.ibm.com>
33 * Ardelle Fan <ardelle.fan@intel.com>
34 * Ryan Layer <rmlayer@us.ibm.com>
35 * Sridhar Samudrala <sri@us.ibm.com>
38 #include <net/sctp/structs.h>
39 #include <net/sctp/sctp.h>
40 #include <linux/sysctl.h>
44 static int timer_max = 86400000; /* ms in one day */
45 static int int_max = INT_MAX;
46 static int sack_timer_min = 1;
47 static int sack_timer_max = 500;
48 static int addr_scope_max = 3; /* check sctp_scope_policy_t in include/net/sctp/constants.h for max entries */
49 static int rwnd_scale_max = 16;
50 static unsigned long max_autoclose_min = 0;
51 static unsigned long max_autoclose_max =
52 (MAX_SCHEDULE_TIMEOUT / HZ > UINT_MAX)
53 ? UINT_MAX : MAX_SCHEDULE_TIMEOUT / HZ;
55 extern long sysctl_sctp_mem[3];
56 extern int sysctl_sctp_rmem[3];
57 extern int sysctl_sctp_wmem[3];
59 static int proc_sctp_do_hmac_alg(struct ctl_table *ctl,
61 void __user *buffer, size_t *lenp,
64 static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write,
65 void __user *buffer, size_t *lenp,
67 static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write,
68 void __user *buffer, size_t *lenp,
71 static struct ctl_table sctp_table[] = {
73 .procname = "sctp_mem",
74 .data = &sysctl_sctp_mem,
75 .maxlen = sizeof(sysctl_sctp_mem),
77 .proc_handler = proc_doulongvec_minmax
80 .procname = "sctp_rmem",
81 .data = &sysctl_sctp_rmem,
82 .maxlen = sizeof(sysctl_sctp_rmem),
84 .proc_handler = proc_dointvec,
87 .procname = "sctp_wmem",
88 .data = &sysctl_sctp_wmem,
89 .maxlen = sizeof(sysctl_sctp_wmem),
91 .proc_handler = proc_dointvec,
97 static struct ctl_table sctp_net_table[] = {
99 .procname = "rto_initial",
100 .data = &init_net.sctp.rto_initial,
101 .maxlen = sizeof(unsigned int),
103 .proc_handler = proc_dointvec_minmax,
108 .procname = "rto_min",
109 .data = &init_net.sctp.rto_min,
110 .maxlen = sizeof(unsigned int),
112 .proc_handler = proc_sctp_do_rto_min,
114 .extra2 = &init_net.sctp.rto_max
117 .procname = "rto_max",
118 .data = &init_net.sctp.rto_max,
119 .maxlen = sizeof(unsigned int),
121 .proc_handler = proc_sctp_do_rto_max,
122 .extra1 = &init_net.sctp.rto_min,
126 .procname = "rto_alpha_exp_divisor",
127 .data = &init_net.sctp.rto_alpha,
128 .maxlen = sizeof(int),
130 .proc_handler = proc_dointvec,
133 .procname = "rto_beta_exp_divisor",
134 .data = &init_net.sctp.rto_beta,
135 .maxlen = sizeof(int),
137 .proc_handler = proc_dointvec,
140 .procname = "max_burst",
141 .data = &init_net.sctp.max_burst,
142 .maxlen = sizeof(int),
144 .proc_handler = proc_dointvec_minmax,
149 .procname = "cookie_preserve_enable",
150 .data = &init_net.sctp.cookie_preserve_enable,
151 .maxlen = sizeof(int),
153 .proc_handler = proc_dointvec,
156 .procname = "cookie_hmac_alg",
159 .proc_handler = proc_sctp_do_hmac_alg,
162 .procname = "valid_cookie_life",
163 .data = &init_net.sctp.valid_cookie_life,
164 .maxlen = sizeof(unsigned int),
166 .proc_handler = proc_dointvec_minmax,
171 .procname = "sack_timeout",
172 .data = &init_net.sctp.sack_timeout,
173 .maxlen = sizeof(int),
175 .proc_handler = proc_dointvec_minmax,
176 .extra1 = &sack_timer_min,
177 .extra2 = &sack_timer_max,
180 .procname = "hb_interval",
181 .data = &init_net.sctp.hb_interval,
182 .maxlen = sizeof(unsigned int),
184 .proc_handler = proc_dointvec_minmax,
189 .procname = "association_max_retrans",
190 .data = &init_net.sctp.max_retrans_association,
191 .maxlen = sizeof(int),
193 .proc_handler = proc_dointvec_minmax,
198 .procname = "path_max_retrans",
199 .data = &init_net.sctp.max_retrans_path,
200 .maxlen = sizeof(int),
202 .proc_handler = proc_dointvec_minmax,
207 .procname = "max_init_retransmits",
208 .data = &init_net.sctp.max_retrans_init,
209 .maxlen = sizeof(int),
211 .proc_handler = proc_dointvec_minmax,
216 .procname = "pf_retrans",
217 .data = &init_net.sctp.pf_retrans,
218 .maxlen = sizeof(int),
220 .proc_handler = proc_dointvec_minmax,
225 .procname = "sndbuf_policy",
226 .data = &init_net.sctp.sndbuf_policy,
227 .maxlen = sizeof(int),
229 .proc_handler = proc_dointvec,
232 .procname = "rcvbuf_policy",
233 .data = &init_net.sctp.rcvbuf_policy,
234 .maxlen = sizeof(int),
236 .proc_handler = proc_dointvec,
239 .procname = "default_auto_asconf",
240 .data = &init_net.sctp.default_auto_asconf,
241 .maxlen = sizeof(int),
243 .proc_handler = proc_dointvec,
246 .procname = "addip_enable",
247 .data = &init_net.sctp.addip_enable,
248 .maxlen = sizeof(int),
250 .proc_handler = proc_dointvec,
253 .procname = "addip_noauth_enable",
254 .data = &init_net.sctp.addip_noauth,
255 .maxlen = sizeof(int),
257 .proc_handler = proc_dointvec,
260 .procname = "prsctp_enable",
261 .data = &init_net.sctp.prsctp_enable,
262 .maxlen = sizeof(int),
264 .proc_handler = proc_dointvec,
267 .procname = "auth_enable",
268 .data = &init_net.sctp.auth_enable,
269 .maxlen = sizeof(int),
271 .proc_handler = proc_dointvec,
274 .procname = "addr_scope_policy",
275 .data = &init_net.sctp.scope_policy,
276 .maxlen = sizeof(int),
278 .proc_handler = proc_dointvec_minmax,
280 .extra2 = &addr_scope_max,
283 .procname = "rwnd_update_shift",
284 .data = &init_net.sctp.rwnd_upd_shift,
285 .maxlen = sizeof(int),
287 .proc_handler = &proc_dointvec_minmax,
289 .extra2 = &rwnd_scale_max,
292 .procname = "max_autoclose",
293 .data = &init_net.sctp.max_autoclose,
294 .maxlen = sizeof(unsigned long),
296 .proc_handler = &proc_doulongvec_minmax,
297 .extra1 = &max_autoclose_min,
298 .extra2 = &max_autoclose_max,
304 static int proc_sctp_do_hmac_alg(struct ctl_table *ctl,
306 void __user *buffer, size_t *lenp,
309 struct net *net = current->nsproxy->net_ns;
311 struct ctl_table tbl;
316 memset(&tbl, 0, sizeof(struct ctl_table));
322 tbl.data = net->sctp.sctp_hmac_alg ? : none;
323 tbl.maxlen = strlen(tbl.data);
325 ret = proc_dostring(&tbl, write, buffer, lenp, ppos);
328 #ifdef CONFIG_CRYPTO_MD5
329 if (!strncmp(tmp, "md5", 3)) {
330 net->sctp.sctp_hmac_alg = "md5";
334 #ifdef CONFIG_CRYPTO_SHA1
335 if (!strncmp(tmp, "sha1", 4)) {
336 net->sctp.sctp_hmac_alg = "sha1";
340 if (!strncmp(tmp, "none", 4)) {
341 net->sctp.sctp_hmac_alg = NULL;
352 static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write,
353 void __user *buffer, size_t *lenp,
356 struct net *net = current->nsproxy->net_ns;
358 struct ctl_table tbl;
359 unsigned int min = *(unsigned int *) ctl->extra1;
360 unsigned int max = *(unsigned int *) ctl->extra2;
363 memset(&tbl, 0, sizeof(struct ctl_table));
364 tbl.maxlen = sizeof(unsigned int);
367 tbl.data = &new_value;
369 tbl.data = &net->sctp.rto_min;
370 ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
372 if (ret || new_value > max || new_value < min)
374 net->sctp.rto_min = new_value;
379 static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write,
380 void __user *buffer, size_t *lenp,
383 struct net *net = current->nsproxy->net_ns;
385 struct ctl_table tbl;
386 unsigned int min = *(unsigned int *) ctl->extra1;
387 unsigned int max = *(unsigned int *) ctl->extra2;
390 memset(&tbl, 0, sizeof(struct ctl_table));
391 tbl.maxlen = sizeof(unsigned int);
394 tbl.data = &new_value;
396 tbl.data = &net->sctp.rto_max;
397 ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
399 if (ret || new_value > max || new_value < min)
401 net->sctp.rto_max = new_value;
406 int sctp_sysctl_net_register(struct net *net)
408 struct ctl_table *table;
411 table = kmemdup(sctp_net_table, sizeof(sctp_net_table), GFP_KERNEL);
415 for (i = 0; table[i].data; i++)
416 table[i].data += (char *)(&net->sctp) - (char *)&init_net.sctp;
418 net->sctp.sysctl_header = register_net_sysctl(net, "net/sctp", table);
422 void sctp_sysctl_net_unregister(struct net *net)
424 struct ctl_table *table;
426 table = net->sctp.sysctl_header->ctl_table_arg;
427 unregister_net_sysctl_table(net->sctp.sysctl_header);
431 static struct ctl_table_header * sctp_sysctl_header;
433 /* Sysctl registration. */
434 void sctp_sysctl_register(void)
436 sctp_sysctl_header = register_net_sysctl(&init_net, "net/sctp", sctp_table);
439 /* Sysctl deregistration. */
440 void sctp_sysctl_unregister(void)
442 unregister_net_sysctl_table(sctp_sysctl_header);