net/core/dev_ioctl.c

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