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