linux/net/bridge/br_ioctl.c
<<
>>
Prefs
   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 compatability.
 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