Root/net/bridge/br_ioctl.c

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

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive