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