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