Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/drzeus/mmc
[linux-2.6] / net / bridge / br_ioctl.c
1 /*
2  *      Ioctl handler
3  *      Linux ethernet bridge
4  *
5  *      Authors:
6  *      Lennert Buytenhek               <buytenh@gnu.org>
7  *
8  *      $Id: br_ioctl.c,v 1.4 2000/11/08 05:16:40 davem Exp $
9  *
10  *      This program is free software; you can redistribute it and/or
11  *      modify it under the terms of the GNU General Public License
12  *      as published by the Free Software Foundation; either version
13  *      2 of the License, or (at your option) any later version.
14  */
15
16 #include <linux/capability.h>
17 #include <linux/kernel.h>
18 #include <linux/if_bridge.h>
19 #include <linux/netdevice.h>
20 #include <linux/times.h>
21 #include <net/net_namespace.h>
22 #include <asm/uaccess.h>
23 #include "br_private.h"
24
25 /* called with RTNL */
26 static int get_bridge_ifindices(int *indices, int num)
27 {
28         struct net_device *dev;
29         int i = 0;
30
31         for_each_netdev(&init_net, dev) {
32                 if (i >= num)
33                         break;
34                 if (dev->priv_flags & IFF_EBRIDGE)
35                         indices[i++] = dev->ifindex;
36         }
37
38         return i;
39 }
40
41 /* called with RTNL */
42 static void get_port_ifindices(struct net_bridge *br, int *ifindices, int num)
43 {
44         struct net_bridge_port *p;
45
46         list_for_each_entry(p, &br->port_list, list) {
47                 if (p->port_no < num)
48                         ifindices[p->port_no] = p->dev->ifindex;
49         }
50 }
51
52 /*
53  * Format up to a page worth of forwarding table entries
54  * userbuf -- where to copy result
55  * maxnum  -- maximum number of entries desired
56  *            (limited to a page for sanity)
57  * offset  -- number of records to skip
58  */
59 static int get_fdb_entries(struct net_bridge *br, void __user *userbuf,
60                            unsigned long maxnum, unsigned long offset)
61 {
62         int num;
63         void *buf;
64         size_t size;
65
66         /* Clamp size to PAGE_SIZE, test maxnum to avoid overflow */
67         if (maxnum > PAGE_SIZE/sizeof(struct __fdb_entry))
68                 maxnum = PAGE_SIZE/sizeof(struct __fdb_entry);
69
70         size = maxnum * sizeof(struct __fdb_entry);
71
72         buf = kmalloc(size, GFP_USER);
73         if (!buf)
74                 return -ENOMEM;
75
76         num = br_fdb_fillbuf(br, buf, maxnum, offset);
77         if (num > 0) {
78                 if (copy_to_user(userbuf, buf, num*sizeof(struct __fdb_entry)))
79                         num = -EFAULT;
80         }
81         kfree(buf);
82
83         return num;
84 }
85
86 static int add_del_if(struct net_bridge *br, int ifindex, int isadd)
87 {
88         struct net_device *dev;
89         int ret;
90
91         if (!capable(CAP_NET_ADMIN))
92                 return -EPERM;
93
94         dev = dev_get_by_index(&init_net, ifindex);
95         if (dev == NULL)
96                 return -EINVAL;
97
98         if (isadd)
99                 ret = br_add_if(br, dev);
100         else
101                 ret = br_del_if(br, dev);
102
103         dev_put(dev);
104         return ret;
105 }
106
107 /*
108  * Legacy ioctl's through SIOCDEVPRIVATE
109  * This interface is deprecated because it was too difficult to
110  * to do the translation for 32/64bit ioctl compatability.
111  */
112 static int old_dev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
113 {
114         struct net_bridge *br = netdev_priv(dev);
115         unsigned long args[4];
116
117         if (copy_from_user(args, rq->ifr_data, sizeof(args)))
118                 return -EFAULT;
119
120         switch (args[0]) {
121         case BRCTL_ADD_IF:
122         case BRCTL_DEL_IF:
123                 return add_del_if(br, args[1], args[0] == BRCTL_ADD_IF);
124
125         case BRCTL_GET_BRIDGE_INFO:
126         {
127                 struct __bridge_info b;
128
129                 memset(&b, 0, sizeof(struct __bridge_info));
130                 rcu_read_lock();
131                 memcpy(&b.designated_root, &br->designated_root, 8);
132                 memcpy(&b.bridge_id, &br->bridge_id, 8);
133                 b.root_path_cost = br->root_path_cost;
134                 b.max_age = jiffies_to_clock_t(br->max_age);
135                 b.hello_time = jiffies_to_clock_t(br->hello_time);
136                 b.forward_delay = br->forward_delay;
137                 b.bridge_max_age = br->bridge_max_age;
138                 b.bridge_hello_time = br->bridge_hello_time;
139                 b.bridge_forward_delay = jiffies_to_clock_t(br->bridge_forward_delay);
140                 b.topology_change = br->topology_change;
141                 b.topology_change_detected = br->topology_change_detected;
142                 b.root_port = br->root_port;
143
144                 b.stp_enabled = (br->stp_enabled != BR_NO_STP);
145                 b.ageing_time = jiffies_to_clock_t(br->ageing_time);
146                 b.hello_timer_value = br_timer_value(&br->hello_timer);
147                 b.tcn_timer_value = br_timer_value(&br->tcn_timer);
148                 b.topology_change_timer_value = br_timer_value(&br->topology_change_timer);
149                 b.gc_timer_value = br_timer_value(&br->gc_timer);
150                 rcu_read_unlock();
151
152                 if (copy_to_user((void __user *)args[1], &b, sizeof(b)))
153                         return -EFAULT;
154
155                 return 0;
156         }
157
158         case BRCTL_GET_PORT_LIST:
159         {
160                 int num, *indices;
161
162                 num = args[2];
163                 if (num < 0)
164                         return -EINVAL;
165                 if (num == 0)
166                         num = 256;
167                 if (num > BR_MAX_PORTS)
168                         num = BR_MAX_PORTS;
169
170                 indices = kcalloc(num, sizeof(int), GFP_KERNEL);
171                 if (indices == NULL)
172                         return -ENOMEM;
173
174                 get_port_ifindices(br, indices, num);
175                 if (copy_to_user((void __user *)args[1], indices, num*sizeof(int)))
176                         num =  -EFAULT;
177                 kfree(indices);
178                 return num;
179         }
180
181         case BRCTL_SET_BRIDGE_FORWARD_DELAY:
182                 if (!capable(CAP_NET_ADMIN))
183                         return -EPERM;
184
185                 spin_lock_bh(&br->lock);
186                 br->bridge_forward_delay = clock_t_to_jiffies(args[1]);
187                 if (br_is_root_bridge(br))
188                         br->forward_delay = br->bridge_forward_delay;
189                 spin_unlock_bh(&br->lock);
190                 return 0;
191
192         case BRCTL_SET_BRIDGE_HELLO_TIME:
193                 if (!capable(CAP_NET_ADMIN))
194                         return -EPERM;
195
196                 spin_lock_bh(&br->lock);
197                 br->bridge_hello_time = clock_t_to_jiffies(args[1]);
198                 if (br_is_root_bridge(br))
199                         br->hello_time = br->bridge_hello_time;
200                 spin_unlock_bh(&br->lock);
201                 return 0;
202
203         case BRCTL_SET_BRIDGE_MAX_AGE:
204                 if (!capable(CAP_NET_ADMIN))
205                         return -EPERM;
206
207                 spin_lock_bh(&br->lock);
208                 br->bridge_max_age = clock_t_to_jiffies(args[1]);
209                 if (br_is_root_bridge(br))
210                         br->max_age = br->bridge_max_age;
211                 spin_unlock_bh(&br->lock);
212                 return 0;
213
214         case BRCTL_SET_AGEING_TIME:
215                 if (!capable(CAP_NET_ADMIN))
216                         return -EPERM;
217
218                 br->ageing_time = clock_t_to_jiffies(args[1]);
219                 return 0;
220
221         case BRCTL_GET_PORT_INFO:
222         {
223                 struct __port_info p;
224                 struct net_bridge_port *pt;
225
226                 rcu_read_lock();
227                 if ((pt = br_get_port(br, args[2])) == NULL) {
228                         rcu_read_unlock();
229                         return -EINVAL;
230                 }
231
232                 memset(&p, 0, sizeof(struct __port_info));
233                 memcpy(&p.designated_root, &pt->designated_root, 8);
234                 memcpy(&p.designated_bridge, &pt->designated_bridge, 8);
235                 p.port_id = pt->port_id;
236                 p.designated_port = pt->designated_port;
237                 p.path_cost = pt->path_cost;
238                 p.designated_cost = pt->designated_cost;
239                 p.state = pt->state;
240                 p.top_change_ack = pt->topology_change_ack;
241                 p.config_pending = pt->config_pending;
242                 p.message_age_timer_value = br_timer_value(&pt->message_age_timer);
243                 p.forward_delay_timer_value = br_timer_value(&pt->forward_delay_timer);
244                 p.hold_timer_value = br_timer_value(&pt->hold_timer);
245
246                 rcu_read_unlock();
247
248                 if (copy_to_user((void __user *)args[1], &p, sizeof(p)))
249                         return -EFAULT;
250
251                 return 0;
252         }
253
254         case BRCTL_SET_BRIDGE_STP_STATE:
255                 if (!capable(CAP_NET_ADMIN))
256                         return -EPERM;
257
258                 br_stp_set_enabled(br, args[1]);
259                 return 0;
260
261         case BRCTL_SET_BRIDGE_PRIORITY:
262                 if (!capable(CAP_NET_ADMIN))
263                         return -EPERM;
264
265                 spin_lock_bh(&br->lock);
266                 br_stp_set_bridge_priority(br, args[1]);
267                 spin_unlock_bh(&br->lock);
268                 return 0;
269
270         case BRCTL_SET_PORT_PRIORITY:
271         {
272                 struct net_bridge_port *p;
273                 int ret = 0;
274
275                 if (!capable(CAP_NET_ADMIN))
276                         return -EPERM;
277
278                 if (args[2] >= (1<<(16-BR_PORT_BITS)))
279                         return -ERANGE;
280
281                 spin_lock_bh(&br->lock);
282                 if ((p = br_get_port(br, args[1])) == NULL)
283                         ret = -EINVAL;
284                 else
285                         br_stp_set_port_priority(p, args[2]);
286                 spin_unlock_bh(&br->lock);
287                 return ret;
288         }
289
290         case BRCTL_SET_PATH_COST:
291         {
292                 struct net_bridge_port *p;
293                 int ret = 0;
294
295                 if (!capable(CAP_NET_ADMIN))
296                         return -EPERM;
297
298                 if ((p = br_get_port(br, args[1])) == NULL)
299                         ret = -EINVAL;
300                 else
301                         br_stp_set_path_cost(p, args[2]);
302
303                 return ret;
304         }
305
306         case BRCTL_GET_FDB_ENTRIES:
307                 return get_fdb_entries(br, (void __user *)args[1],
308                                        args[2], args[3]);
309         }
310
311         return -EOPNOTSUPP;
312 }
313
314 static int old_deviceless(void __user *uarg)
315 {
316         unsigned long args[3];
317
318         if (copy_from_user(args, uarg, sizeof(args)))
319                 return -EFAULT;
320
321         switch (args[0]) {
322         case BRCTL_GET_VERSION:
323                 return BRCTL_VERSION;
324
325         case BRCTL_GET_BRIDGES:
326         {
327                 int *indices;
328                 int ret = 0;
329
330                 if (args[2] >= 2048)
331                         return -ENOMEM;
332                 indices = kcalloc(args[2], sizeof(int), GFP_KERNEL);
333                 if (indices == NULL)
334                         return -ENOMEM;
335
336                 args[2] = get_bridge_ifindices(indices, args[2]);
337
338                 ret = copy_to_user((void __user *)args[1], indices, args[2]*sizeof(int))
339                         ? -EFAULT : args[2];
340
341                 kfree(indices);
342                 return ret;
343         }
344
345         case BRCTL_ADD_BRIDGE:
346         case BRCTL_DEL_BRIDGE:
347         {
348                 char buf[IFNAMSIZ];
349
350                 if (!capable(CAP_NET_ADMIN))
351                         return -EPERM;
352
353                 if (copy_from_user(buf, (void __user *)args[1], IFNAMSIZ))
354                         return -EFAULT;
355
356                 buf[IFNAMSIZ-1] = 0;
357
358                 if (args[0] == BRCTL_ADD_BRIDGE)
359                         return br_add_bridge(buf);
360
361                 return br_del_bridge(buf);
362         }
363         }
364
365         return -EOPNOTSUPP;
366 }
367
368 int br_ioctl_deviceless_stub(struct net *net, unsigned int cmd, void __user *uarg)
369 {
370         switch (cmd) {
371         case SIOCGIFBR:
372         case SIOCSIFBR:
373                 return old_deviceless(uarg);
374
375         case SIOCBRADDBR:
376         case SIOCBRDELBR:
377         {
378                 char buf[IFNAMSIZ];
379
380                 if (!capable(CAP_NET_ADMIN))
381                         return -EPERM;
382
383                 if (copy_from_user(buf, uarg, IFNAMSIZ))
384                         return -EFAULT;
385
386                 buf[IFNAMSIZ-1] = 0;
387                 if (cmd == SIOCBRADDBR)
388                         return br_add_bridge(buf);
389
390                 return br_del_bridge(buf);
391         }
392         }
393         return -EOPNOTSUPP;
394 }
395
396 int br_dev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
397 {
398         struct net_bridge *br = netdev_priv(dev);
399
400         switch(cmd) {
401         case SIOCDEVPRIVATE:
402                 return old_dev_ioctl(dev, rq, cmd);
403
404         case SIOCBRADDIF:
405         case SIOCBRDELIF:
406                 return add_del_if(br, rq->ifr_ifindex, cmd == SIOCBRADDIF);
407
408         }
409
410         pr_debug("Bridge does not support ioctl 0x%x\n", cmd);
411         return -EOPNOTSUPP;
412 }