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