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