net/core/dev_ioctl.c

   1 #include <linux/kmod.h>
   2 #include <linux/netdevice.h>
   3 #include <linux/etherdevice.h>
   4 #include <linux/rtnetlink.h>
   5 #include <linux/net_tstamp.h>
   6 #include <linux/wireless.h>
   7 #include <net/wext.h>
   8
   9 /*
  10  *      Map an interface index to its name (SIOCGIFNAME)
  11  */
  12
  13 /*
  14  *      We need this ioctl for efficient implementation of the
  15  *      if_indextoname() function required by the IPv6 API.  Without
  16  *      it, we would have to search all the interfaces to find a
  17  *      match.  --pb
  18  */
  19
  20 static int dev_ifname(struct net *net, struct ifreq __user *arg)
  21 {
  22         struct net_device *dev;
  23         struct ifreq ifr;
  24         unsigned seq;
  25
  26         /*
  27          *      Fetch the caller's info block.
  28          */
  29
  30         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
  31                 return -EFAULT;
  32
  33 retry:
  34         seq = read_seqcount_begin(&devnet_rename_seq);
  35         rcu_read_lock();
  36         dev = dev_get_by_index_rcu(net, ifr.ifr_ifindex);
  37         if (!dev) {
  38                 rcu_read_unlock();
  39                 return -ENODEV;
  40         }
  41
  42         strcpy(ifr.ifr_name, dev->name);
  43         rcu_read_unlock();
  44         if (read_seqcount_retry(&devnet_rename_seq, seq))
  45                 goto retry;
  46
  47         if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
  48                 return -EFAULT;
  49         return 0;
  50 }
  51
  52 static gifconf_func_t *gifconf_list[NPROTO];
  53
  54 /**
  55  *      register_gifconf        -       register a SIOCGIF handler
  56  *      @family: Address family
  57  *      @gifconf: Function handler
  58  *
  59  *      Register protocol dependent address dumping routines. The handler
  60  *      that is passed must not be freed or reused until it has been replaced
  61  *      by another handler.
  62  */
  63 int register_gifconf(unsigned int family, gifconf_func_t *gifconf)
  64 {
  65         if (family >= NPROTO)
  66                 return -EINVAL;
  67         gifconf_list[family] = gifconf;
  68         return 0;
  69 }
  70 EXPORT_SYMBOL(register_gifconf);
  71
  72 /*
  73  *      Perform a SIOCGIFCONF call. This structure will change
  74  *      size eventually, and there is nothing I can do about it.
  75  *      Thus we will need a 'compatibility mode'.
  76  */
  77
  78 static int dev_ifconf(struct net *net, char __user *arg)
  79 {
  80         struct ifconf ifc;
  81         struct net_device *dev;
  82         char __user *pos;
  83         int len;
  84         int total;
  85         int i;
  86
  87         /*
  88          *      Fetch the caller's info block.
  89          */
  90
  91         if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
  92                 return -EFAULT;
  93
  94         pos = ifc.ifc_buf;
  95         len = ifc.ifc_len;
  96
  97         /*
  98          *      Loop over the interfaces, and write an info block for each.
  99          */
 100
 101         total = 0;
 102         for_each_netdev(net, dev) {
 103                 for (i = 0; i < NPROTO; i++) {
 104                         if (gifconf_list[i]) {
 105                                 int done;
 106                                 if (!pos)
 107                                         done = gifconf_list[i](dev, NULL, 0);
 108                                 else
 109                                         done = gifconf_list[i](dev, pos + total,
 110                                                                len - total);
 111                                 if (done < 0)
 112                                         return -EFAULT;
 113                                 total += done;
 114                         }
 115                 }
 116         }
 117
 118         /*
 119          *      All done.  Write the updated control block back to the caller.
 120          */
 121         ifc.ifc_len = total;
 122
 123         /*
 124          *      Both BSD and Solaris return 0 here, so we do too.
 125          */
 126         return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
 127 }
 128
 129 /*
 130  *      Perform the SIOCxIFxxx calls, inside rcu_read_lock()
 131  */
 132 static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
 133 {
 134         int err;
 135         struct net_device *dev = dev_get_by_name_rcu(net, ifr->ifr_name);
 136
 137         if (!dev)
 138                 return -ENODEV;
 139
 140         switch (cmd) {
 141         case SIOCGIFFLAGS:      /* Get interface flags */
 142                 ifr->ifr_flags = (short) dev_get_flags(dev);
 143                 return 0;
 144
 145         case SIOCGIFMETRIC:     /* Get the metric on the interface
 146                                    (currently unused) */
 147                 ifr->ifr_metric = 0;
 148                 return 0;
 149
 150         case SIOCGIFMTU:        /* Get the MTU of a device */
 151                 ifr->ifr_mtu = dev->mtu;
 152                 return 0;
 153
 154         case SIOCGIFHWADDR:
 155                 if (!dev->addr_len)
 156                         memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
 157                 else
 158                         memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
 159                                min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
 160                 ifr->ifr_hwaddr.sa_family = dev->type;
 161                 return 0;
 162
 163         case SIOCGIFSLAVE:
 164                 err = -EINVAL;
 165                 break;
 166
 167         case SIOCGIFMAP:
 168                 ifr->ifr_map.mem_start = dev->mem_start;
 169                 ifr->ifr_map.mem_end   = dev->mem_end;
 170                 ifr->ifr_map.base_addr = dev->base_addr;
 171                 ifr->ifr_map.irq       = dev->irq;
 172                 ifr->ifr_map.dma       = dev->dma;
 173                 ifr->ifr_map.port      = dev->if_port;
 174                 return 0;
 175
 176         case SIOCGIFINDEX:
 177                 ifr->ifr_ifindex = dev->ifindex;
 178                 return 0;
 179
 180         case SIOCGIFTXQLEN:
 181                 ifr->ifr_qlen = dev->tx_queue_len;
 182                 return 0;
 183
 184         default:
 185                 /* dev_ioctl() should ensure this case
 186                  * is never reached
 187                  */
 188                 WARN_ON(1);
 189                 err = -ENOTTY;
 190                 break;
 191
 192         }
 193         return err;
 194 }
 195
 196 static int net_hwtstamp_validate(struct ifreq *ifr)
 197 {
 198         struct hwtstamp_config cfg;
 199         enum hwtstamp_tx_types tx_type;
 200         enum hwtstamp_rx_filters rx_filter;
 201         int tx_type_valid = 0;
 202         int rx_filter_valid = 0;
 203
 204         if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg)))
 205                 return -EFAULT;
 206
 207         if (cfg.flags) /* reserved for future extensions */
 208                 return -EINVAL;
 209
 210         tx_type = cfg.tx_type;
 211         rx_filter = cfg.rx_filter;
 212
 213         switch (tx_type) {
 214         case HWTSTAMP_TX_OFF:
 215         case HWTSTAMP_TX_ON:
 216         case HWTSTAMP_TX_ONESTEP_SYNC:
 217                 tx_type_valid = 1;
 218                 break;
 219         }
 220
 221         switch (rx_filter) {
 222         case HWTSTAMP_FILTER_NONE:
 223         case HWTSTAMP_FILTER_ALL:
 224         case HWTSTAMP_FILTER_SOME:
 225         case HWTSTAMP_FILTER_PTP_V1_L4_EVENT:
 226         case HWTSTAMP_FILTER_PTP_V1_L4_SYNC:
 227         case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ:
 228         case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
 229         case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
 230         case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
 231         case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
 232         case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
 233         case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
 234         case HWTSTAMP_FILTER_PTP_V2_EVENT:
 235         case HWTSTAMP_FILTER_PTP_V2_SYNC:
 236         case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
 237                 rx_filter_valid = 1;
 238                 break;
 239         }
 240
 241         if (!tx_type_valid || !rx_filter_valid)
 242                 return -ERANGE;
 243
 244         return 0;
 245 }
 246
 247 /*
 248  *      Perform the SIOCxIFxxx calls, inside rtnl_lock()
 249  */
 250 static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
 251 {
 252         int err;
 253         struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
 254         const struct net_device_ops *ops;
 255
 256         if (!dev)
 257                 return -ENODEV;
 258
 259         ops = dev->netdev_ops;
 260
 261         switch (cmd) {
 262         case SIOCSIFFLAGS:      /* Set interface flags */
 263                 return dev_change_flags(dev, ifr->ifr_flags);
 264
 265         case SIOCSIFMETRIC:     /* Set the metric on the interface
 266                                    (currently unused) */
 267                 return -EOPNOTSUPP;
 268
 269         case SIOCSIFMTU:        /* Set the MTU of a device */
 270                 return dev_set_mtu(dev, ifr->ifr_mtu);
 271
 272         case SIOCSIFHWADDR:
 273                 return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
 274
 275         case SIOCSIFHWBROADCAST:
 276                 if (ifr->ifr_hwaddr.sa_family != dev->type)
 277                         return -EINVAL;
 278                 memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
 279                        min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
 280                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
 281                 return 0;
 282
 283         case SIOCSIFMAP:
 284                 if (ops->ndo_set_config) {
 285                         if (!netif_device_present(dev))
 286                                 return -ENODEV;
 287                         return ops->ndo_set_config(dev, &ifr->ifr_map);
 288                 }
 289                 return -EOPNOTSUPP;
 290
 291         case SIOCADDMULTI:
 292                 if (!ops->ndo_set_rx_mode ||
 293                     ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
 294                         return -EINVAL;
 295                 if (!netif_device_present(dev))
 296                         return -ENODEV;
 297                 return dev_mc_add_global(dev, ifr->ifr_hwaddr.sa_data);
 298
 299         case SIOCDELMULTI:
 300                 if (!ops->ndo_set_rx_mode ||
 301                     ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
 302                         return -EINVAL;
 303                 if (!netif_device_present(dev))
 304                         return -ENODEV;
 305                 return dev_mc_del_global(dev, ifr->ifr_hwaddr.sa_data);
 306
 307         case SIOCSIFTXQLEN:
 308                 if (ifr->ifr_qlen < 0)
 309                         return -EINVAL;
 310                 dev->tx_queue_len = ifr->ifr_qlen;
 311                 return 0;
 312
 313         case SIOCSIFNAME:
 314                 ifr->ifr_newname[IFNAMSIZ-1] = '\0';
 315                 return dev_change_name(dev, ifr->ifr_newname);
 316
 317         case SIOCSHWTSTAMP:
 318                 err = net_hwtstamp_validate(ifr);
 319                 if (err)
 320                         return err;
 321                 /* fall through */
 322
 323         /*
 324          *      Unknown or private ioctl
 325          */
 326         default:
 327                 if ((cmd >= SIOCDEVPRIVATE &&
 328                     cmd <= SIOCDEVPRIVATE + 15) ||
 329                     cmd == SIOCBONDENSLAVE ||
 330                     cmd == SIOCBONDRELEASE ||
 331                     cmd == SIOCBONDSETHWADDR ||
 332                     cmd == SIOCBONDSLAVEINFOQUERY ||
 333                     cmd == SIOCBONDINFOQUERY ||
 334                     cmd == SIOCBONDCHANGEACTIVE ||
 335                     cmd == SIOCGMIIPHY ||
 336                     cmd == SIOCGMIIREG ||
 337                     cmd == SIOCSMIIREG ||
 338                     cmd == SIOCBRADDIF ||
 339                     cmd == SIOCBRDELIF ||
 340                     cmd == SIOCSHWTSTAMP ||
 341                     cmd == SIOCWANDEV) {
 342                         err = -EOPNOTSUPP;
 343                         if (ops->ndo_do_ioctl) {
 344                                 if (netif_device_present(dev))
 345                                         err = ops->ndo_do_ioctl(dev, ifr, cmd);
 346                                 else
 347                                         err = -ENODEV;
 348                         }
 349                 } else
 350                         err = -EINVAL;
 351
 352         }
 353         return err;
 354 }
 355
 356 /**
 357  *      dev_load        - load a network module
 358  *      @net: the applicable net namespace
 359  *      @name: name of interface
 360  *
 361  *      If a network interface is not present and the process has suitable
 362  *      privileges this function loads the module. If module loading is not
 363  *      available in this kernel then it becomes a nop.
 364  */
 365
 366 void dev_load(struct net *net, const char *name)
 367 {
 368         struct net_device *dev;
 369         int no_module;
 370
 371         rcu_read_lock();
 372         dev = dev_get_by_name_rcu(net, name);
 373         rcu_read_unlock();
 374
 375         no_module = !dev;
 376         if (no_module && capable(CAP_NET_ADMIN))
 377                 no_module = request_module("netdev-%s", name);
 378         if (no_module && capable(CAP_SYS_MODULE)) {
 379                 if (!request_module("%s", name))
 380                         pr_warn("Loading kernel module for a network device with CAP_SYS_MODULE (deprecated).  Use CAP_NET_ADMIN and alias netdev-%s instead.\n",
 381                                 name);
 382         }
 383 }
 384 EXPORT_SYMBOL(dev_load);
 385
 386 /*
 387  *      This function handles all "interface"-type I/O control requests. The actual
 388  *      'doing' part of this is dev_ifsioc above.
 389  */
 390
 391 /**
 392  *      dev_ioctl       -       network device ioctl
 393  *      @net: the applicable net namespace
 394  *      @cmd: command to issue
 395  *      @arg: pointer to a struct ifreq in user space
 396  *
 397  *      Issue ioctl functions to devices. This is normally called by the
 398  *      user space syscall interfaces but can sometimes be useful for
 399  *      other purposes. The return value is the return from the syscall if
 400  *      positive or a negative errno code on error.
 401  */
 402
 403 int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
 404 {
 405         struct ifreq ifr;
 406         int ret;
 407         char *colon;
 408
 409         /* One special case: SIOCGIFCONF takes ifconf argument
 410            and requires shared lock, because it sleeps writing
 411            to user space.
 412          */
 413
 414         if (cmd == SIOCGIFCONF) {
 415                 rtnl_lock();
 416                 ret = dev_ifconf(net, (char __user *) arg);
 417                 rtnl_unlock();
 418                 return ret;
 419         }
 420         if (cmd == SIOCGIFNAME)
 421                 return dev_ifname(net, (struct ifreq __user *)arg);
 422
 423         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
 424                 return -EFAULT;
 425
 426         ifr.ifr_name[IFNAMSIZ-1] = 0;
 427
 428         colon = strchr(ifr.ifr_name, ':');
 429         if (colon)
 430                 *colon = 0;
 431
 432         /*
 433          *      See which interface the caller is talking about.
 434          */
 435
 436         switch (cmd) {
 437         /*
 438          *      These ioctl calls:
 439          *      - can be done by all.
 440          *      - atomic and do not require locking.
 441          *      - return a value
 442          */
 443         case SIOCGIFFLAGS:
 444         case SIOCGIFMETRIC:
 445         case SIOCGIFMTU:
 446         case SIOCGIFHWADDR:
 447         case SIOCGIFSLAVE:
 448         case SIOCGIFMAP:
 449         case SIOCGIFINDEX:
 450         case SIOCGIFTXQLEN:
 451                 dev_load(net, ifr.ifr_name);
 452                 rcu_read_lock();
 453                 ret = dev_ifsioc_locked(net, &ifr, cmd);
 454                 rcu_read_unlock();
 455                 if (!ret) {
 456                         if (colon)
 457                                 *colon = ':';
 458                         if (copy_to_user(arg, &ifr,
 459                                          sizeof(struct ifreq)))
 460                                 ret = -EFAULT;
 461                 }
 462                 return ret;
 463
 464         case SIOCETHTOOL:
 465                 dev_load(net, ifr.ifr_name);
 466                 rtnl_lock();
 467                 ret = dev_ethtool(net, &ifr);
 468                 rtnl_unlock();
 469                 if (!ret) {
 470                         if (colon)
 471                                 *colon = ':';
 472                         if (copy_to_user(arg, &ifr,
 473                                          sizeof(struct ifreq)))
 474                                 ret = -EFAULT;
 475                 }
 476                 return ret;
 477
 478         /*
 479          *      These ioctl calls:
 480          *      - require superuser power.
 481          *      - require strict serialization.
 482          *      - return a value
 483          */
 484         case SIOCGMIIPHY:
 485         case SIOCGMIIREG:
 486         case SIOCSIFNAME:
 487                 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
 488                         return -EPERM;
 489                 dev_load(net, ifr.ifr_name);
 490                 rtnl_lock();
 491                 ret = dev_ifsioc(net, &ifr, cmd);
 492                 rtnl_unlock();
 493                 if (!ret) {
 494                         if (colon)
 495                                 *colon = ':';
 496                         if (copy_to_user(arg, &ifr,
 497                                          sizeof(struct ifreq)))
 498                                 ret = -EFAULT;
 499                 }
 500                 return ret;
 501
 502         /*
 503          *      These ioctl calls:
 504          *      - require superuser power.
 505          *      - require strict serialization.
 506          *      - do not return a value
 507          */
 508         case SIOCSIFMAP:
 509         case SIOCSIFTXQLEN:
 510                 if (!capable(CAP_NET_ADMIN))
 511                         return -EPERM;
 512                 /* fall through */
 513         /*
 514          *      These ioctl calls:
 515          *      - require local superuser power.
 516          *      - require strict serialization.
 517          *      - do not return a value
 518          */
 519         case SIOCSIFFLAGS:
 520         case SIOCSIFMETRIC:
 521         case SIOCSIFMTU:
 522         case SIOCSIFHWADDR:
 523         case SIOCSIFSLAVE:
 524         case SIOCADDMULTI:
 525         case SIOCDELMULTI:
 526         case SIOCSIFHWBROADCAST:
 527         case SIOCSMIIREG:
 528         case SIOCBONDENSLAVE:
 529         case SIOCBONDRELEASE:
 530         case SIOCBONDSETHWADDR:
 531         case SIOCBONDCHANGEACTIVE:
 532         case SIOCBRADDIF:
 533         case SIOCBRDELIF:
 534         case SIOCSHWTSTAMP:
 535                 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
 536                         return -EPERM;
 537                 /* fall through */
 538         case SIOCBONDSLAVEINFOQUERY:
 539         case SIOCBONDINFOQUERY:
 540                 dev_load(net, ifr.ifr_name);
 541                 rtnl_lock();
 542                 ret = dev_ifsioc(net, &ifr, cmd);
 543                 rtnl_unlock();
 544                 return ret;
 545
 546         case SIOCGIFMEM:
 547                 /* Get the per device memory space. We can add this but
 548                  * currently do not support it */
 549         case SIOCSIFMEM:
 550                 /* Set the per device memory buffer space.
 551                  * Not applicable in our case */
 552         case SIOCSIFLINK:
 553                 return -ENOTTY;
 554
 555         /*
 556          *      Unknown or private ioctl.
 557          */
 558         default:
 559                 if (cmd == SIOCWANDEV ||
 560                     (cmd >= SIOCDEVPRIVATE &&
 561                      cmd <= SIOCDEVPRIVATE + 15)) {
 562                         dev_load(net, ifr.ifr_name);
 563                         rtnl_lock();
 564                         ret = dev_ifsioc(net, &ifr, cmd);
 565                         rtnl_unlock();
 566                         if (!ret && copy_to_user(arg, &ifr,
 567                                                  sizeof(struct ifreq)))
 568                                 ret = -EFAULT;
 569                         return ret;
 570                 }
 571                 /* Take care of Wireless Extensions */
 572                 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
 573                         return wext_handle_ioctl(net, &ifr, cmd, arg);
 574                 return -ENOTTY;
 575         }
 576 }