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