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