1 /* 2 * NET3 IP device support routines. 3 * 4 * Version: $Id: devinet.c,v 1.44 2001/10/31 21:55:54 davem Exp $ 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 * 11 * Derived from the IP parts of dev.c 1.0.19 12 * Authors: Ross Biro 13 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 14 * Mark Evans, <evansmp@uhura.aston.ac.uk> 15 * 16 * Additional Authors: 17 * Alan Cox, <gw4pts@gw4pts.ampr.org> 18 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 19 * 20 * Changes: 21 * Alexey Kuznetsov: pa_* fields are replaced with ifaddr 22 * lists. 23 * Cyrus Durgin: updated for kmod 24 * Matthias Andree: in devinet_ioctl, compare label and 25 * address (4.4BSD alias style support), 26 * fall back to comparing just the label 27 * if no match found. 28 */ 29 30 #include <linux/config.h> 31 32 #include <asm/uaccess.h> 33 #include <asm/system.h> 34 #include <linux/bitops.h> 35 #include <linux/capability.h> 36 #include <linux/module.h> 37 #include <linux/types.h> 38 #include <linux/kernel.h> 39 #include <linux/sched.h> 40 #include <linux/string.h> 41 #include <linux/mm.h> 42 #include <linux/socket.h> 43 #include <linux/sockios.h> 44 #include <linux/in.h> 45 #include <linux/errno.h> 46 #include <linux/interrupt.h> 47 #include <linux/if_ether.h> 48 #include <linux/inet.h> 49 #include <linux/netdevice.h> 50 #include <linux/etherdevice.h> 51 #include <linux/skbuff.h> 52 #include <linux/rtnetlink.h> 53 #include <linux/init.h> 54 #include <linux/notifier.h> 55 #include <linux/inetdevice.h> 56 #include <linux/igmp.h> 57 #ifdef CONFIG_SYSCTL 58 #include <linux/sysctl.h> 59 #endif 60 #include <linux/kmod.h> 61 62 #include <net/arp.h> 63 #include <net/ip.h> 64 #include <net/route.h> 65 #include <net/ip_fib.h> 66 67 struct ipv4_devconf ipv4_devconf = { 68 .accept_redirects = 1, 69 .send_redirects = 1, 70 .secure_redirects = 1, 71 .shared_media = 1, 72 }; 73 74 static struct ipv4_devconf ipv4_devconf_dflt = { 75 .accept_redirects = 1, 76 .send_redirects = 1, 77 .secure_redirects = 1, 78 .shared_media = 1, 79 .accept_source_route = 1, 80 }; 81 82 static void rtmsg_ifa(int event, struct in_ifaddr *); 83 84 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain); 85 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 86 int destroy); 87 #ifdef CONFIG_SYSCTL 88 static void devinet_sysctl_register(struct in_device *in_dev, 89 struct ipv4_devconf *p); 90 static void devinet_sysctl_unregister(struct ipv4_devconf *p); 91 #endif 92 93 /* Locks all the inet devices. */ 94 95 static struct in_ifaddr *inet_alloc_ifa(void) 96 { 97 struct in_ifaddr *ifa = kmalloc(sizeof(*ifa), GFP_KERNEL); 98 99 if (ifa) { 100 memset(ifa, 0, sizeof(*ifa)); 101 INIT_RCU_HEAD(&ifa->rcu_head); 102 } 103 104 return ifa; 105 } 106 107 static void inet_rcu_free_ifa(struct rcu_head *head) 108 { 109 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head); 110 if (ifa->ifa_dev) 111 in_dev_put(ifa->ifa_dev); 112 kfree(ifa); 113 } 114 115 static inline void inet_free_ifa(struct in_ifaddr *ifa) 116 { 117 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa); 118 } 119 120 void in_dev_finish_destroy(struct in_device *idev) 121 { 122 struct net_device *dev = idev->dev; 123 124 BUG_TRAP(!idev->ifa_list); 125 BUG_TRAP(!idev->mc_list); 126 #ifdef NET_REFCNT_DEBUG 127 printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n", 128 idev, dev ? dev->name : "NIL"); 129 #endif 130 dev_put(dev); 131 if (!idev->dead) 132 printk("Freeing alive in_device %p\n", idev); 133 else { 134 kfree(idev); 135 } 136 } 137 138 struct in_device *inetdev_init(struct net_device *dev) 139 { 140 struct in_device *in_dev; 141 142 ASSERT_RTNL(); 143 144 in_dev = kmalloc(sizeof(*in_dev), GFP_KERNEL); 145 if (!in_dev) 146 goto out; 147 memset(in_dev, 0, sizeof(*in_dev)); 148 INIT_RCU_HEAD(&in_dev->rcu_head); 149 memcpy(&in_dev->cnf, &ipv4_devconf_dflt, sizeof(in_dev->cnf)); 150 in_dev->cnf.sysctl = NULL; 151 in_dev->dev = dev; 152 if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL) 153 goto out_kfree; 154 /* Reference in_dev->dev */ 155 dev_hold(dev); 156 #ifdef CONFIG_SYSCTL 157 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4, 158 NET_IPV4_NEIGH, "ipv4", NULL, NULL); 159 #endif 160 161 /* Account for reference dev->ip_ptr */ 162 in_dev_hold(in_dev); 163 rcu_assign_pointer(dev->ip_ptr, in_dev); 164 165 #ifdef CONFIG_SYSCTL 166 devinet_sysctl_register(in_dev, &in_dev->cnf); 167 #endif 168 ip_mc_init_dev(in_dev); 169 if (dev->flags & IFF_UP) 170 ip_mc_up(in_dev); 171 out: 172 return in_dev; 173 out_kfree: 174 kfree(in_dev); 175 in_dev = NULL; 176 goto out; 177 } 178 179 static void in_dev_rcu_put(struct rcu_head *head) 180 { 181 struct in_device *idev = container_of(head, struct in_device, rcu_head); 182 in_dev_put(idev); 183 } 184 185 static void inetdev_destroy(struct in_device *in_dev) 186 { 187 struct in_ifaddr *ifa; 188 struct net_device *dev; 189 190 ASSERT_RTNL(); 191 192 dev = in_dev->dev; 193 if (dev == &loopback_dev) 194 return; 195 196 in_dev->dead = 1; 197 198 ip_mc_destroy_dev(in_dev); 199 200 while ((ifa = in_dev->ifa_list) != NULL) { 201 inet_del_ifa(in_dev, &in_dev->ifa_list, 0); 202 inet_free_ifa(ifa); 203 } 204 205 #ifdef CONFIG_SYSCTL 206 devinet_sysctl_unregister(&in_dev->cnf); 207 #endif 208 209 dev->ip_ptr = NULL; 210 211 #ifdef CONFIG_SYSCTL 212 neigh_sysctl_unregister(in_dev->arp_parms); 213 #endif 214 neigh_parms_release(&arp_tbl, in_dev->arp_parms); 215 arp_ifdown(dev); 216 217 call_rcu(&in_dev->rcu_head, in_dev_rcu_put); 218 } 219 220 int inet_addr_onlink(struct in_device *in_dev, u32 a, u32 b) 221 { 222 rcu_read_lock(); 223 for_primary_ifa(in_dev) { 224 if (inet_ifa_match(a, ifa)) { 225 if (!b || inet_ifa_match(b, ifa)) { 226 rcu_read_unlock(); 227 return 1; 228 } 229 } 230 } endfor_ifa(in_dev); 231 rcu_read_unlock(); 232 return 0; 233 } 234 235 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 236 int destroy) 237 { 238 struct in_ifaddr *promote = NULL; 239 struct in_ifaddr *ifa, *ifa1 = *ifap; 240 struct in_ifaddr *last_prim = in_dev->ifa_list; 241 struct in_ifaddr *prev_prom = NULL; 242 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev); 243 244 ASSERT_RTNL(); 245 246 /* 1. Deleting primary ifaddr forces deletion all secondaries 247 * unless alias promotion is set 248 **/ 249 250 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) { 251 struct in_ifaddr **ifap1 = &ifa1->ifa_next; 252 253 while ((ifa = *ifap1) != NULL) { 254 if (!(ifa->ifa_flags & IFA_F_SECONDARY) && 255 ifa1->ifa_scope <= ifa->ifa_scope) 256 last_prim = ifa; 257 258 if (!(ifa->ifa_flags & IFA_F_SECONDARY) || 259 ifa1->ifa_mask != ifa->ifa_mask || 260 !inet_ifa_match(ifa1->ifa_address, ifa)) { 261 ifap1 = &ifa->ifa_next; 262 prev_prom = ifa; 263 continue; 264 } 265 266 if (!do_promote) { 267 *ifap1 = ifa->ifa_next; 268 269 rtmsg_ifa(RTM_DELADDR, ifa); 270 blocking_notifier_call_chain(&inetaddr_chain, 271 NETDEV_DOWN, ifa); 272 inet_free_ifa(ifa); 273 } else { 274 promote = ifa; 275 break; 276 } 277 } 278 } 279 280 /* 2. Unlink it */ 281 282 *ifap = ifa1->ifa_next; 283 284 /* 3. Announce address deletion */ 285 286 /* Send message first, then call notifier. 287 At first sight, FIB update triggered by notifier 288 will refer to already deleted ifaddr, that could confuse 289 netlink listeners. It is not true: look, gated sees 290 that route deleted and if it still thinks that ifaddr 291 is valid, it will try to restore deleted routes... Grr. 292 So that, this order is correct. 293 */ 294 rtmsg_ifa(RTM_DELADDR, ifa1); 295 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1); 296 297 if (promote) { 298 299 if (prev_prom) { 300 prev_prom->ifa_next = promote->ifa_next; 301 promote->ifa_next = last_prim->ifa_next; 302 last_prim->ifa_next = promote; 303 } 304 305 promote->ifa_flags &= ~IFA_F_SECONDARY; 306 rtmsg_ifa(RTM_NEWADDR, promote); 307 blocking_notifier_call_chain(&inetaddr_chain, 308 NETDEV_UP, promote); 309 for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) { 310 if (ifa1->ifa_mask != ifa->ifa_mask || 311 !inet_ifa_match(ifa1->ifa_address, ifa)) 312 continue; 313 fib_add_ifaddr(ifa); 314 } 315 316 } 317 if (destroy) { 318 inet_free_ifa(ifa1); 319 320 if (!in_dev->ifa_list) 321 inetdev_destroy(in_dev); 322 } 323 } 324 325 static int inet_insert_ifa(struct in_ifaddr *ifa) 326 { 327 struct in_device *in_dev = ifa->ifa_dev; 328 struct in_ifaddr *ifa1, **ifap, **last_primary; 329 330 ASSERT_RTNL(); 331 332 if (!ifa->ifa_local) { 333 inet_free_ifa(ifa); 334 return 0; 335 } 336 337 ifa->ifa_flags &= ~IFA_F_SECONDARY; 338 last_primary = &in_dev->ifa_list; 339 340 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL; 341 ifap = &ifa1->ifa_next) { 342 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) && 343 ifa->ifa_scope <= ifa1->ifa_scope) 344 last_primary = &ifa1->ifa_next; 345 if (ifa1->ifa_mask == ifa->ifa_mask && 346 inet_ifa_match(ifa1->ifa_address, ifa)) { 347 if (ifa1->ifa_local == ifa->ifa_local) { 348 inet_free_ifa(ifa); 349 return -EEXIST; 350 } 351 if (ifa1->ifa_scope != ifa->ifa_scope) { 352 inet_free_ifa(ifa); 353 return -EINVAL; 354 } 355 ifa->ifa_flags |= IFA_F_SECONDARY; 356 } 357 } 358 359 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) { 360 net_srandom(ifa->ifa_local); 361 ifap = last_primary; 362 } 363 364 ifa->ifa_next = *ifap; 365 *ifap = ifa; 366 367 /* Send message first, then call notifier. 368 Notifier will trigger FIB update, so that 369 listeners of netlink will know about new ifaddr */ 370 rtmsg_ifa(RTM_NEWADDR, ifa); 371 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa); 372 373 return 0; 374 } 375 376 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa) 377 { 378 struct in_device *in_dev = __in_dev_get_rtnl(dev); 379 380 ASSERT_RTNL(); 381 382 if (!in_dev) { 383 in_dev = inetdev_init(dev); 384 if (!in_dev) { 385 inet_free_ifa(ifa); 386 return -ENOBUFS; 387 } 388 } 389 if (ifa->ifa_dev != in_dev) { 390 BUG_TRAP(!ifa->ifa_dev); 391 in_dev_hold(in_dev); 392 ifa->ifa_dev = in_dev; 393 } 394 if (LOOPBACK(ifa->ifa_local)) 395 ifa->ifa_scope = RT_SCOPE_HOST; 396 return inet_insert_ifa(ifa); 397 } 398 399 struct in_device *inetdev_by_index(int ifindex) 400 { 401 struct net_device *dev; 402 struct in_device *in_dev = NULL; 403 read_lock(&dev_base_lock); 404 dev = __dev_get_by_index(ifindex); 405 if (dev) 406 in_dev = in_dev_get(dev); 407 read_unlock(&dev_base_lock); 408 return in_dev; 409 } 410 411 /* Called only from RTNL semaphored context. No locks. */ 412 413 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, u32 prefix, 414 u32 mask) 415 { 416 ASSERT_RTNL(); 417 418 for_primary_ifa(in_dev) { 419 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa)) 420 return ifa; 421 } endfor_ifa(in_dev); 422 return NULL; 423 } 424 425 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 426 { 427 struct rtattr **rta = arg; 428 struct in_device *in_dev; 429 struct ifaddrmsg *ifm = NLMSG_DATA(nlh); 430 struct in_ifaddr *ifa, **ifap; 431 432 ASSERT_RTNL(); 433 434 if ((in_dev = inetdev_by_index(ifm->ifa_index)) == NULL) 435 goto out; 436 __in_dev_put(in_dev); 437 438 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 439 ifap = &ifa->ifa_next) { 440 if ((rta[IFA_LOCAL - 1] && 441 memcmp(RTA_DATA(rta[IFA_LOCAL - 1]), 442 &ifa->ifa_local, 4)) || 443 (rta[IFA_LABEL - 1] && 444 rtattr_strcmp(rta[IFA_LABEL - 1], ifa->ifa_label)) || 445 (rta[IFA_ADDRESS - 1] && 446 (ifm->ifa_prefixlen != ifa->ifa_prefixlen || 447 !inet_ifa_match(*(u32*)RTA_DATA(rta[IFA_ADDRESS - 1]), 448 ifa)))) 449 continue; 450 inet_del_ifa(in_dev, ifap, 1); 451 return 0; 452 } 453 out: 454 return -EADDRNOTAVAIL; 455 } 456 457 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 458 { 459 struct rtattr **rta = arg; 460 struct net_device *dev; 461 struct in_device *in_dev; 462 struct ifaddrmsg *ifm = NLMSG_DATA(nlh); 463 struct in_ifaddr *ifa; 464 int rc = -EINVAL; 465 466 ASSERT_RTNL(); 467 468 if (ifm->ifa_prefixlen > 32 || !rta[IFA_LOCAL - 1]) 469 goto out; 470 471 rc = -ENODEV; 472 if ((dev = __dev_get_by_index(ifm->ifa_index)) == NULL) 473 goto out; 474 475 rc = -ENOBUFS; 476 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL) { 477 in_dev = inetdev_init(dev); 478 if (!in_dev) 479 goto out; 480 } 481 482 if ((ifa = inet_alloc_ifa()) == NULL) 483 goto out; 484 485 if (!rta[IFA_ADDRESS - 1]) 486 rta[IFA_ADDRESS - 1] = rta[IFA_LOCAL - 1]; 487 memcpy(&ifa->ifa_local, RTA_DATA(rta[IFA_LOCAL - 1]), 4); 488 memcpy(&ifa->ifa_address, RTA_DATA(rta[IFA_ADDRESS - 1]), 4); 489 ifa->ifa_prefixlen = ifm->ifa_prefixlen; 490 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen); 491 if (rta[IFA_BROADCAST - 1]) 492 memcpy(&ifa->ifa_broadcast, 493 RTA_DATA(rta[IFA_BROADCAST - 1]), 4); 494 if (rta[IFA_ANYCAST - 1]) 495 memcpy(&ifa->ifa_anycast, RTA_DATA(rta[IFA_ANYCAST - 1]), 4); 496 ifa->ifa_flags = ifm->ifa_flags; 497 ifa->ifa_scope = ifm->ifa_scope; 498 in_dev_hold(in_dev); 499 ifa->ifa_dev = in_dev; 500 if (rta[IFA_LABEL - 1]) 501 rtattr_strlcpy(ifa->ifa_label, rta[IFA_LABEL - 1], IFNAMSIZ); 502 else 503 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 504 505 rc = inet_insert_ifa(ifa); 506 out: 507 return rc; 508 } 509 510 /* 511 * Determine a default network mask, based on the IP address. 512 */ 513 514 static __inline__ int inet_abc_len(u32 addr) 515 { 516 int rc = -1; /* Something else, probably a multicast. */ 517 518 if (ZERONET(addr)) 519 rc = 0; 520 else { 521 addr = ntohl(addr); 522 523 if (IN_CLASSA(addr)) 524 rc = 8; 525 else if (IN_CLASSB(addr)) 526 rc = 16; 527 else if (IN_CLASSC(addr)) 528 rc = 24; 529 } 530 531 return rc; 532 } 533 534 535 int devinet_ioctl(unsigned int cmd, void __user *arg) 536 { 537 struct ifreq ifr; 538 struct sockaddr_in sin_orig; 539 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr; 540 struct in_device *in_dev; 541 struct in_ifaddr **ifap = NULL; 542 struct in_ifaddr *ifa = NULL; 543 struct net_device *dev; 544 char *colon; 545 int ret = -EFAULT; 546 int tryaddrmatch = 0; 547 548 /* 549 * Fetch the caller's info block into kernel space 550 */ 551 552 if (copy_from_user(&ifr, arg, sizeof(struct ifreq))) 553 goto out; 554 ifr.ifr_name[IFNAMSIZ - 1] = 0; 555 556 /* save original address for comparison */ 557 memcpy(&sin_orig, sin, sizeof(*sin)); 558 559 colon = strchr(ifr.ifr_name, ':'); 560 if (colon) 561 *colon = 0; 562 563 #ifdef CONFIG_KMOD 564 dev_load(ifr.ifr_name); 565 #endif 566 567 switch(cmd) { 568 case SIOCGIFADDR: /* Get interface address */ 569 case SIOCGIFBRDADDR: /* Get the broadcast address */ 570 case SIOCGIFDSTADDR: /* Get the destination address */ 571 case SIOCGIFNETMASK: /* Get the netmask for the interface */ 572 /* Note that these ioctls will not sleep, 573 so that we do not impose a lock. 574 One day we will be forced to put shlock here (I mean SMP) 575 */ 576 tryaddrmatch = (sin_orig.sin_family == AF_INET); 577 memset(sin, 0, sizeof(*sin)); 578 sin->sin_family = AF_INET; 579 break; 580 581 case SIOCSIFFLAGS: 582 ret = -EACCES; 583 if (!capable(CAP_NET_ADMIN)) 584 goto out; 585 break; 586 case SIOCSIFADDR: /* Set interface address (and family) */ 587 case SIOCSIFBRDADDR: /* Set the broadcast address */ 588 case SIOCSIFDSTADDR: /* Set the destination address */ 589 case SIOCSIFNETMASK: /* Set the netmask for the interface */ 590 ret = -EACCES; 591 if (!capable(CAP_NET_ADMIN)) 592 goto out; 593 ret = -EINVAL; 594 if (sin->sin_family != AF_INET) 595 goto out; 596 break; 597 default: 598 ret = -EINVAL; 599 goto out; 600 } 601 602 rtnl_lock(); 603 604 ret = -ENODEV; 605 if ((dev = __dev_get_by_name(ifr.ifr_name)) == NULL) 606 goto done; 607 608 if (colon) 609 *colon = ':'; 610 611 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) { 612 if (tryaddrmatch) { 613 /* Matthias Andree */ 614 /* compare label and address (4.4BSD style) */ 615 /* note: we only do this for a limited set of ioctls 616 and only if the original address family was AF_INET. 617 This is checked above. */ 618 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 619 ifap = &ifa->ifa_next) { 620 if (!strcmp(ifr.ifr_name, ifa->ifa_label) && 621 sin_orig.sin_addr.s_addr == 622 ifa->ifa_address) { 623 break; /* found */ 624 } 625 } 626 } 627 /* we didn't get a match, maybe the application is 628 4.3BSD-style and passed in junk so we fall back to 629 comparing just the label */ 630 if (!ifa) { 631 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 632 ifap = &ifa->ifa_next) 633 if (!strcmp(ifr.ifr_name, ifa->ifa_label)) 634 break; 635 } 636 } 637 638 ret = -EADDRNOTAVAIL; 639 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS) 640 goto done; 641 642 switch(cmd) { 643 case SIOCGIFADDR: /* Get interface address */ 644 sin->sin_addr.s_addr = ifa->ifa_local; 645 goto rarok; 646 647 case SIOCGIFBRDADDR: /* Get the broadcast address */ 648 sin->sin_addr.s_addr = ifa->ifa_broadcast; 649 goto rarok; 650 651 case SIOCGIFDSTADDR: /* Get the destination address */ 652 sin->sin_addr.s_addr = ifa->ifa_address; 653 goto rarok; 654 655 case SIOCGIFNETMASK: /* Get the netmask for the interface */ 656 sin->sin_addr.s_addr = ifa->ifa_mask; 657 goto rarok; 658 659 case SIOCSIFFLAGS: 660 if (colon) { 661 ret = -EADDRNOTAVAIL; 662 if (!ifa) 663 break; 664 ret = 0; 665 if (!(ifr.ifr_flags & IFF_UP)) 666 inet_del_ifa(in_dev, ifap, 1); 667 break; 668 } 669 ret = dev_change_flags(dev, ifr.ifr_flags); 670 break; 671 672 case SIOCSIFADDR: /* Set interface address (and family) */ 673 ret = -EINVAL; 674 if (inet_abc_len(sin->sin_addr.s_addr) < 0) 675 break; 676 677 if (!ifa) { 678 ret = -ENOBUFS; 679 if ((ifa = inet_alloc_ifa()) == NULL) 680 break; 681 if (colon) 682 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ); 683 else 684 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 685 } else { 686 ret = 0; 687 if (ifa->ifa_local == sin->sin_addr.s_addr) 688 break; 689 inet_del_ifa(in_dev, ifap, 0); 690 ifa->ifa_broadcast = 0; 691 ifa->ifa_anycast = 0; 692 } 693 694 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr; 695 696 if (!(dev->flags & IFF_POINTOPOINT)) { 697 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address); 698 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen); 699 if ((dev->flags & IFF_BROADCAST) && 700 ifa->ifa_prefixlen < 31) 701 ifa->ifa_broadcast = ifa->ifa_address | 702 ~ifa->ifa_mask; 703 } else { 704 ifa->ifa_prefixlen = 32; 705 ifa->ifa_mask = inet_make_mask(32); 706 } 707 ret = inet_set_ifa(dev, ifa); 708 break; 709 710 case SIOCSIFBRDADDR: /* Set the broadcast address */ 711 ret = 0; 712 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) { 713 inet_del_ifa(in_dev, ifap, 0); 714 ifa->ifa_broadcast = sin->sin_addr.s_addr; 715 inet_insert_ifa(ifa); 716 } 717 break; 718 719 case SIOCSIFDSTADDR: /* Set the destination address */ 720 ret = 0; 721 if (ifa->ifa_address == sin->sin_addr.s_addr) 722 break; 723 ret = -EINVAL; 724 if (inet_abc_len(sin->sin_addr.s_addr) < 0) 725 break; 726 ret = 0; 727 inet_del_ifa(in_dev, ifap, 0); 728 ifa->ifa_address = sin->sin_addr.s_addr; 729 inet_insert_ifa(ifa); 730 break; 731 732 case SIOCSIFNETMASK: /* Set the netmask for the interface */ 733 734 /* 735 * The mask we set must be legal. 736 */ 737 ret = -EINVAL; 738 if (bad_mask(sin->sin_addr.s_addr, 0)) 739 break; 740 ret = 0; 741 if (ifa->ifa_mask != sin->sin_addr.s_addr) { 742 u32 old_mask = ifa->ifa_mask; 743 inet_del_ifa(in_dev, ifap, 0); 744 ifa->ifa_mask = sin->sin_addr.s_addr; 745 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask); 746 747 /* See if current broadcast address matches 748 * with current netmask, then recalculate 749 * the broadcast address. Otherwise it's a 750 * funny address, so don't touch it since 751 * the user seems to know what (s)he's doing... 752 */ 753 if ((dev->flags & IFF_BROADCAST) && 754 (ifa->ifa_prefixlen < 31) && 755 (ifa->ifa_broadcast == 756 (ifa->ifa_local|~old_mask))) { 757 ifa->ifa_broadcast = (ifa->ifa_local | 758 ~sin->sin_addr.s_addr); 759 } 760 inet_insert_ifa(ifa); 761 } 762 break; 763 } 764 done: 765 rtnl_unlock(); 766 out: 767 return ret; 768 rarok: 769 rtnl_unlock(); 770 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0; 771 goto out; 772 } 773 774 static int inet_gifconf(struct net_device *dev, char __user *buf, int len) 775 { 776 struct in_device *in_dev = __in_dev_get_rtnl(dev); 777 struct in_ifaddr *ifa; 778 struct ifreq ifr; 779 int done = 0; 780 781 if (!in_dev || (ifa = in_dev->ifa_list) == NULL) 782 goto out; 783 784 for (; ifa; ifa = ifa->ifa_next) { 785 if (!buf) { 786 done += sizeof(ifr); 787 continue; 788 } 789 if (len < (int) sizeof(ifr)) 790 break; 791 memset(&ifr, 0, sizeof(struct ifreq)); 792 if (ifa->ifa_label) 793 strcpy(ifr.ifr_name, ifa->ifa_label); 794 else 795 strcpy(ifr.ifr_name, dev->name); 796 797 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET; 798 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr = 799 ifa->ifa_local; 800 801 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) { 802 done = -EFAULT; 803 break; 804 } 805 buf += sizeof(struct ifreq); 806 len -= sizeof(struct ifreq); 807 done += sizeof(struct ifreq); 808 } 809 out: 810 return done; 811 } 812 813 u32 inet_select_addr(const struct net_device *dev, u32 dst, int scope) 814 { 815 u32 addr = 0; 816 struct in_device *in_dev; 817 818 rcu_read_lock(); 819 in_dev = __in_dev_get_rcu(dev); 820 if (!in_dev) 821 goto no_in_dev; 822 823 for_primary_ifa(in_dev) { 824 if (ifa->ifa_scope > scope) 825 continue; 826 if (!dst || inet_ifa_match(dst, ifa)) { 827 addr = ifa->ifa_local; 828 break; 829 } 830 if (!addr) 831 addr = ifa->ifa_local; 832 } endfor_ifa(in_dev); 833 no_in_dev: 834 rcu_read_unlock(); 835 836 if (addr) 837 goto out; 838 839 /* Not loopback addresses on loopback should be preferred 840 in this case. It is importnat that lo is the first interface 841 in dev_base list. 842 */ 843 read_lock(&dev_base_lock); 844 rcu_read_lock(); 845 for (dev = dev_base; dev; dev = dev->next) { 846 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) 847 continue; 848 849 for_primary_ifa(in_dev) { 850 if (ifa->ifa_scope != RT_SCOPE_LINK && 851 ifa->ifa_scope <= scope) { 852 addr = ifa->ifa_local; 853 goto out_unlock_both; 854 } 855 } endfor_ifa(in_dev); 856 } 857 out_unlock_both: 858 read_unlock(&dev_base_lock); 859 rcu_read_unlock(); 860 out: 861 return addr; 862 } 863 864 static u32 confirm_addr_indev(struct in_device *in_dev, u32 dst, 865 u32 local, int scope) 866 { 867 int same = 0; 868 u32 addr = 0; 869 870 for_ifa(in_dev) { 871 if (!addr && 872 (local == ifa->ifa_local || !local) && 873 ifa->ifa_scope <= scope) { 874 addr = ifa->ifa_local; 875 if (same) 876 break; 877 } 878 if (!same) { 879 same = (!local || inet_ifa_match(local, ifa)) && 880 (!dst || inet_ifa_match(dst, ifa)); 881 if (same && addr) { 882 if (local || !dst) 883 break; 884 /* Is the selected addr into dst subnet? */ 885 if (inet_ifa_match(addr, ifa)) 886 break; 887 /* No, then can we use new local src? */ 888 if (ifa->ifa_scope <= scope) { 889 addr = ifa->ifa_local; 890 break; 891 } 892 /* search for large dst subnet for addr */ 893 same = 0; 894 } 895 } 896 } endfor_ifa(in_dev); 897 898 return same? addr : 0; 899 } 900 901 /* 902 * Confirm that local IP address exists using wildcards: 903 * - dev: only on this interface, 0=any interface 904 * - dst: only in the same subnet as dst, 0=any dst 905 * - local: address, 0=autoselect the local address 906 * - scope: maximum allowed scope value for the local address 907 */ 908 u32 inet_confirm_addr(const struct net_device *dev, u32 dst, u32 local, int scope) 909 { 910 u32 addr = 0; 911 struct in_device *in_dev; 912 913 if (dev) { 914 rcu_read_lock(); 915 if ((in_dev = __in_dev_get_rcu(dev))) 916 addr = confirm_addr_indev(in_dev, dst, local, scope); 917 rcu_read_unlock(); 918 919 return addr; 920 } 921 922 read_lock(&dev_base_lock); 923 rcu_read_lock(); 924 for (dev = dev_base; dev; dev = dev->next) { 925 if ((in_dev = __in_dev_get_rcu(dev))) { 926 addr = confirm_addr_indev(in_dev, dst, local, scope); 927 if (addr) 928 break; 929 } 930 } 931 rcu_read_unlock(); 932 read_unlock(&dev_base_lock); 933 934 return addr; 935 } 936 937 /* 938 * Device notifier 939 */ 940 941 int register_inetaddr_notifier(struct notifier_block *nb) 942 { 943 return blocking_notifier_chain_register(&inetaddr_chain, nb); 944 } 945 946 int unregister_inetaddr_notifier(struct notifier_block *nb) 947 { 948 return blocking_notifier_chain_unregister(&inetaddr_chain, nb); 949 } 950 951 /* Rename ifa_labels for a device name change. Make some effort to preserve existing 952 * alias numbering and to create unique labels if possible. 953 */ 954 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev) 955 { 956 struct in_ifaddr *ifa; 957 int named = 0; 958 959 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) { 960 char old[IFNAMSIZ], *dot; 961 962 memcpy(old, ifa->ifa_label, IFNAMSIZ); 963 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 964 if (named++ == 0) 965 continue; 966 dot = strchr(ifa->ifa_label, ':'); 967 if (dot == NULL) { 968 sprintf(old, ":%d", named); 969 dot = old; 970 } 971 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) { 972 strcat(ifa->ifa_label, dot); 973 } else { 974 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot); 975 } 976 } 977 } 978 979 /* Called only under RTNL semaphore */ 980 981 static int inetdev_event(struct notifier_block *this, unsigned long event, 982 void *ptr) 983 { 984 struct net_device *dev = ptr; 985 struct in_device *in_dev = __in_dev_get_rtnl(dev); 986 987 ASSERT_RTNL(); 988 989 if (!in_dev) { 990 if (event == NETDEV_REGISTER && dev == &loopback_dev) { 991 in_dev = inetdev_init(dev); 992 if (!in_dev) 993 panic("devinet: Failed to create loopback\n"); 994 in_dev->cnf.no_xfrm = 1; 995 in_dev->cnf.no_policy = 1; 996 } 997 goto out; 998 } 999 1000 switch (event) { 1001 case NETDEV_REGISTER: 1002 printk(KERN_DEBUG "inetdev_event: bug\n"); 1003 dev->ip_ptr = NULL; 1004 break; 1005 case NETDEV_UP: 1006 if (dev->mtu < 68) 1007 break; 1008 if (dev == &loopback_dev) { 1009 struct in_ifaddr *ifa; 1010 if ((ifa = inet_alloc_ifa()) != NULL) { 1011 ifa->ifa_local = 1012 ifa->ifa_address = htonl(INADDR_LOOPBACK); 1013 ifa->ifa_prefixlen = 8; 1014 ifa->ifa_mask = inet_make_mask(8); 1015 in_dev_hold(in_dev); 1016 ifa->ifa_dev = in_dev; 1017 ifa->ifa_scope = RT_SCOPE_HOST; 1018 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 1019 inet_insert_ifa(ifa); 1020 } 1021 } 1022 ip_mc_up(in_dev); 1023 break; 1024 case NETDEV_DOWN: 1025 ip_mc_down(in_dev); 1026 break; 1027 case NETDEV_CHANGEMTU: 1028 if (dev->mtu >= 68) 1029 break; 1030 /* MTU falled under 68, disable IP */ 1031 case NETDEV_UNREGISTER: 1032 inetdev_destroy(in_dev); 1033 break; 1034 case NETDEV_CHANGENAME: 1035 /* Do not notify about label change, this event is 1036 * not interesting to applications using netlink. 1037 */ 1038 inetdev_changename(dev, in_dev); 1039 1040 #ifdef CONFIG_SYSCTL 1041 devinet_sysctl_unregister(&in_dev->cnf); 1042 neigh_sysctl_unregister(in_dev->arp_parms); 1043 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4, 1044 NET_IPV4_NEIGH, "ipv4", NULL, NULL); 1045 devinet_sysctl_register(in_dev, &in_dev->cnf); 1046 #endif 1047 break; 1048 } 1049 out: 1050 return NOTIFY_DONE; 1051 } 1052 1053 static struct notifier_block ip_netdev_notifier = { 1054 .notifier_call =inetdev_event, 1055 }; 1056 1057 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa, 1058 u32 pid, u32 seq, int event, unsigned int flags) 1059 { 1060 struct ifaddrmsg *ifm; 1061 struct nlmsghdr *nlh; 1062 unsigned char *b = skb->tail; 1063 1064 nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*ifm), flags); 1065 ifm = NLMSG_DATA(nlh); 1066 ifm->ifa_family = AF_INET; 1067 ifm->ifa_prefixlen = ifa->ifa_prefixlen; 1068 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT; 1069 ifm->ifa_scope = ifa->ifa_scope; 1070 ifm->ifa_index = ifa->ifa_dev->dev->ifindex; 1071 if (ifa->ifa_address) 1072 RTA_PUT(skb, IFA_ADDRESS, 4, &ifa->ifa_address); 1073 if (ifa->ifa_local) 1074 RTA_PUT(skb, IFA_LOCAL, 4, &ifa->ifa_local); 1075 if (ifa->ifa_broadcast) 1076 RTA_PUT(skb, IFA_BROADCAST, 4, &ifa->ifa_broadcast); 1077 if (ifa->ifa_anycast) 1078 RTA_PUT(skb, IFA_ANYCAST, 4, &ifa->ifa_anycast); 1079 if (ifa->ifa_label[0]) 1080 RTA_PUT(skb, IFA_LABEL, IFNAMSIZ, &ifa->ifa_label); 1081 nlh->nlmsg_len = skb->tail - b; 1082 return skb->len; 1083 1084 nlmsg_failure: 1085 rtattr_failure: 1086 skb_trim(skb, b - skb->data); 1087 return -1; 1088 } 1089 1090 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb) 1091 { 1092 int idx, ip_idx; 1093 struct net_device *dev; 1094 struct in_device *in_dev; 1095 struct in_ifaddr *ifa; 1096 int s_ip_idx, s_idx = cb->args[0]; 1097 1098 s_ip_idx = ip_idx = cb->args[1]; 1099 read_lock(&dev_base_lock); 1100 for (dev = dev_base, idx = 0; dev; dev = dev->next, idx++) { 1101 if (idx < s_idx) 1102 continue; 1103 if (idx > s_idx) 1104 s_ip_idx = 0; 1105 rcu_read_lock(); 1106 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) { 1107 rcu_read_unlock(); 1108 continue; 1109 } 1110 1111 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa; 1112 ifa = ifa->ifa_next, ip_idx++) { 1113 if (ip_idx < s_ip_idx) 1114 continue; 1115 if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid, 1116 cb->nlh->nlmsg_seq, 1117 RTM_NEWADDR, NLM_F_MULTI) <= 0) { 1118 rcu_read_unlock(); 1119 goto done; 1120 } 1121 } 1122 rcu_read_unlock(); 1123 } 1124 1125 done: 1126 read_unlock(&dev_base_lock); 1127 cb->args[0] = idx; 1128 cb->args[1] = ip_idx; 1129 1130 return skb->len; 1131 } 1132 1133 static void rtmsg_ifa(int event, struct in_ifaddr* ifa) 1134 { 1135 int size = NLMSG_SPACE(sizeof(struct ifaddrmsg) + 128); 1136 struct sk_buff *skb = alloc_skb(size, GFP_KERNEL); 1137 1138 if (!skb) 1139 netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, ENOBUFS); 1140 else if (inet_fill_ifaddr(skb, ifa, 0, 0, event, 0) < 0) { 1141 kfree_skb(skb); 1142 netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, EINVAL); 1143 } else { 1144 netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV4_IFADDR, GFP_KERNEL); 1145 } 1146 } 1147 1148 static struct rtnetlink_link inet_rtnetlink_table[RTM_NR_MSGTYPES] = { 1149 [RTM_NEWADDR - RTM_BASE] = { .doit = inet_rtm_newaddr, }, 1150 [RTM_DELADDR - RTM_BASE] = { .doit = inet_rtm_deladdr, }, 1151 [RTM_GETADDR - RTM_BASE] = { .dumpit = inet_dump_ifaddr, }, 1152 [RTM_NEWROUTE - RTM_BASE] = { .doit = inet_rtm_newroute, }, 1153 [RTM_DELROUTE - RTM_BASE] = { .doit = inet_rtm_delroute, }, 1154 [RTM_GETROUTE - RTM_BASE] = { .doit = inet_rtm_getroute, 1155 .dumpit = inet_dump_fib, }, 1156 #ifdef CONFIG_IP_MULTIPLE_TABLES 1157 [RTM_NEWRULE - RTM_BASE] = { .doit = inet_rtm_newrule, }, 1158 [RTM_DELRULE - RTM_BASE] = { .doit = inet_rtm_delrule, }, 1159 [RTM_GETRULE - RTM_BASE] = { .dumpit = inet_dump_rules, }, 1160 #endif 1161 }; 1162 1163 #ifdef CONFIG_SYSCTL 1164 1165 void inet_forward_change(void) 1166 { 1167 struct net_device *dev; 1168 int on = ipv4_devconf.forwarding; 1169 1170 ipv4_devconf.accept_redirects = !on; 1171 ipv4_devconf_dflt.forwarding = on; 1172 1173 read_lock(&dev_base_lock); 1174 for (dev = dev_base; dev; dev = dev->next) { 1175 struct in_device *in_dev; 1176 rcu_read_lock(); 1177 in_dev = __in_dev_get_rcu(dev); 1178 if (in_dev) 1179 in_dev->cnf.forwarding = on; 1180 rcu_read_unlock(); 1181 } 1182 read_unlock(&dev_base_lock); 1183 1184 rt_cache_flush(0); 1185 } 1186 1187 static int devinet_sysctl_forward(ctl_table *ctl, int write, 1188 struct file* filp, void __user *buffer, 1189 size_t *lenp, loff_t *ppos) 1190 { 1191 int *valp = ctl->data; 1192 int val = *valp; 1193 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 1194 1195 if (write && *valp != val) { 1196 if (valp == &ipv4_devconf.forwarding) 1197 inet_forward_change(); 1198 else if (valp != &ipv4_devconf_dflt.forwarding) 1199 rt_cache_flush(0); 1200 } 1201 1202 return ret; 1203 } 1204 1205 int ipv4_doint_and_flush(ctl_table *ctl, int write, 1206 struct file* filp, void __user *buffer, 1207 size_t *lenp, loff_t *ppos) 1208 { 1209 int *valp = ctl->data; 1210 int val = *valp; 1211 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 1212 1213 if (write && *valp != val) 1214 rt_cache_flush(0); 1215 1216 return ret; 1217 } 1218 1219 int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen, 1220 void __user *oldval, size_t __user *oldlenp, 1221 void __user *newval, size_t newlen, 1222 void **context) 1223 { 1224 int *valp = table->data; 1225 int new; 1226 1227 if (!newval || !newlen) 1228 return 0; 1229 1230 if (newlen != sizeof(int)) 1231 return -EINVAL; 1232 1233 if (get_user(new, (int __user *)newval)) 1234 return -EFAULT; 1235 1236 if (new == *valp) 1237 return 0; 1238 1239 if (oldval && oldlenp) { 1240 size_t len; 1241 1242 if (get_user(len, oldlenp)) 1243 return -EFAULT; 1244 1245 if (len) { 1246 if (len > table->maxlen) 1247 len = table->maxlen; 1248 if (copy_to_user(oldval, valp, len)) 1249 return -EFAULT; 1250 if (put_user(len, oldlenp)) 1251 return -EFAULT; 1252 } 1253 } 1254 1255 *valp = new; 1256 rt_cache_flush(0); 1257 return 1; 1258 } 1259 1260 1261 static struct devinet_sysctl_table { 1262 struct ctl_table_header *sysctl_header; 1263 ctl_table devinet_vars[__NET_IPV4_CONF_MAX]; 1264 ctl_table devinet_dev[2]; 1265 ctl_table devinet_conf_dir[2]; 1266 ctl_table devinet_proto_dir[2]; 1267 ctl_table devinet_root_dir[2]; 1268 } devinet_sysctl = { 1269 .devinet_vars = { 1270 { 1271 .ctl_name = NET_IPV4_CONF_FORWARDING, 1272 .procname = "forwarding", 1273 .data = &ipv4_devconf.forwarding, 1274 .maxlen = sizeof(int), 1275 .mode = 0644, 1276 .proc_handler = &devinet_sysctl_forward, 1277 }, 1278 { 1279 .ctl_name = NET_IPV4_CONF_MC_FORWARDING, 1280 .procname = "mc_forwarding", 1281 .data = &ipv4_devconf.mc_forwarding, 1282 .maxlen = sizeof(int), 1283 .mode = 0444, 1284 .proc_handler = &proc_dointvec, 1285 }, 1286 { 1287 .ctl_name = NET_IPV4_CONF_ACCEPT_REDIRECTS, 1288 .procname = "accept_redirects", 1289 .data = &ipv4_devconf.accept_redirects, 1290 .maxlen = sizeof(int), 1291 .mode = 0644, 1292 .proc_handler = &proc_dointvec, 1293 }, 1294 { 1295 .ctl_name = NET_IPV4_CONF_SECURE_REDIRECTS, 1296 .procname = "secure_redirects", 1297 .data = &ipv4_devconf.secure_redirects, 1298 .maxlen = sizeof(int), 1299 .mode = 0644, 1300 .proc_handler = &proc_dointvec, 1301 }, 1302 { 1303 .ctl_name = NET_IPV4_CONF_SHARED_MEDIA, 1304 .procname = "shared_media", 1305 .data = &ipv4_devconf.shared_media, 1306 .maxlen = sizeof(int), 1307 .mode = 0644, 1308 .proc_handler = &proc_dointvec, 1309 }, 1310 { 1311 .ctl_name = NET_IPV4_CONF_RP_FILTER, 1312 .procname = "rp_filter", 1313 .data = &ipv4_devconf.rp_filter, 1314 .maxlen = sizeof(int), 1315 .mode = 0644, 1316 .proc_handler = &proc_dointvec, 1317 }, 1318 { 1319 .ctl_name = NET_IPV4_CONF_SEND_REDIRECTS, 1320 .procname = "send_redirects", 1321 .data = &ipv4_devconf.send_redirects, 1322 .maxlen = sizeof(int), 1323 .mode = 0644, 1324 .proc_handler = &proc_dointvec, 1325 }, 1326 { 1327 .ctl_name = NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE, 1328 .procname = "accept_source_route", 1329 .data = &ipv4_devconf.accept_source_route, 1330 .maxlen = sizeof(int), 1331 .mode = 0644, 1332 .proc_handler = &proc_dointvec, 1333 }, 1334 { 1335 .ctl_name = NET_IPV4_CONF_PROXY_ARP, 1336 .procname = "proxy_arp", 1337 .data = &ipv4_devconf.proxy_arp, 1338 .maxlen = sizeof(int), 1339 .mode = 0644, 1340 .proc_handler = &proc_dointvec, 1341 }, 1342 { 1343 .ctl_name = NET_IPV4_CONF_MEDIUM_ID, 1344 .procname = "medium_id", 1345 .data = &ipv4_devconf.medium_id, 1346 .maxlen = sizeof(int), 1347 .mode = 0644, 1348 .proc_handler = &proc_dointvec, 1349 }, 1350 { 1351 .ctl_name = NET_IPV4_CONF_BOOTP_RELAY, 1352 .procname = "bootp_relay", 1353 .data = &ipv4_devconf.bootp_relay, 1354 .maxlen = sizeof(int), 1355 .mode = 0644, 1356 .proc_handler = &proc_dointvec, 1357 }, 1358 { 1359 .ctl_name = NET_IPV4_CONF_LOG_MARTIANS, 1360 .procname = "log_martians", 1361 .data = &ipv4_devconf.log_martians, 1362 .maxlen = sizeof(int), 1363 .mode = 0644, 1364 .proc_handler = &proc_dointvec, 1365 }, 1366 { 1367 .ctl_name = NET_IPV4_CONF_TAG, 1368 .procname = "tag", 1369 .data = &ipv4_devconf.tag, 1370 .maxlen = sizeof(int), 1371 .mode = 0644, 1372 .proc_handler = &proc_dointvec, 1373 }, 1374 { 1375 .ctl_name = NET_IPV4_CONF_ARPFILTER, 1376 .procname = "arp_filter", 1377 .data = &ipv4_devconf.arp_filter, 1378 .maxlen = sizeof(int), 1379 .mode = 0644, 1380 .proc_handler = &proc_dointvec, 1381 }, 1382 { 1383 .ctl_name = NET_IPV4_CONF_ARP_ANNOUNCE, 1384 .procname = "arp_announce", 1385 .data = &ipv4_devconf.arp_announce, 1386 .maxlen = sizeof(int), 1387 .mode = 0644, 1388 .proc_handler = &proc_dointvec, 1389 }, 1390 { 1391 .ctl_name = NET_IPV4_CONF_ARP_IGNORE, 1392 .procname = "arp_ignore", 1393 .data = &ipv4_devconf.arp_ignore, 1394 .maxlen = sizeof(int), 1395 .mode = 0644, 1396 .proc_handler = &proc_dointvec, 1397 }, 1398 { 1399 .ctl_name = NET_IPV4_CONF_ARP_ACCEPT, 1400 .procname = "arp_accept", 1401 .data = &ipv4_devconf.arp_accept, 1402 .maxlen = sizeof(int), 1403 .mode = 0644, 1404 .proc_handler = &proc_dointvec, 1405 }, 1406 { 1407 .ctl_name = NET_IPV4_CONF_NOXFRM, 1408 .procname = "disable_xfrm", 1409 .data = &ipv4_devconf.no_xfrm, 1410 .maxlen = sizeof(int), 1411 .mode = 0644, 1412 .proc_handler = &ipv4_doint_and_flush, 1413 .strategy = &ipv4_doint_and_flush_strategy, 1414 }, 1415 { 1416 .ctl_name = NET_IPV4_CONF_NOPOLICY, 1417 .procname = "disable_policy", 1418 .data = &ipv4_devconf.no_policy, 1419 .maxlen = sizeof(int), 1420 .mode = 0644, 1421 .proc_handler = &ipv4_doint_and_flush, 1422 .strategy = &ipv4_doint_and_flush_strategy, 1423 }, 1424 { 1425 .ctl_name = NET_IPV4_CONF_FORCE_IGMP_VERSION, 1426 .procname = "force_igmp_version", 1427 .data = &ipv4_devconf.force_igmp_version, 1428 .maxlen = sizeof(int), 1429 .mode = 0644, 1430 .proc_handler = &ipv4_doint_and_flush, 1431 .strategy = &ipv4_doint_and_flush_strategy, 1432 }, 1433 { 1434 .ctl_name = NET_IPV4_CONF_PROMOTE_SECONDARIES, 1435 .procname = "promote_secondaries", 1436 .data = &ipv4_devconf.promote_secondaries, 1437 .maxlen = sizeof(int), 1438 .mode = 0644, 1439 .proc_handler = &ipv4_doint_and_flush, 1440 .strategy = &ipv4_doint_and_flush_strategy, 1441 }, 1442 }, 1443 .devinet_dev = { 1444 { 1445 .ctl_name = NET_PROTO_CONF_ALL, 1446 .procname = "all", 1447 .mode = 0555, 1448 .child = devinet_sysctl.devinet_vars, 1449 }, 1450 }, 1451 .devinet_conf_dir = { 1452 { 1453 .ctl_name = NET_IPV4_CONF, 1454 .procname = "conf", 1455 .mode = 0555, 1456 .child = devinet_sysctl.devinet_dev, 1457 }, 1458 }, 1459 .devinet_proto_dir = { 1460 { 1461 .ctl_name = NET_IPV4, 1462 .procname = "ipv4", 1463 .mode = 0555, 1464 .child = devinet_sysctl.devinet_conf_dir, 1465 }, 1466 }, 1467 .devinet_root_dir = { 1468 { 1469 .ctl_name = CTL_NET, 1470 .procname = "net", 1471 .mode = 0555, 1472 .child = devinet_sysctl.devinet_proto_dir, 1473 }, 1474 }, 1475 }; 1476 1477 static void devinet_sysctl_register(struct in_device *in_dev, 1478 struct ipv4_devconf *p) 1479 { 1480 int i; 1481 struct net_device *dev = in_dev ? in_dev->dev : NULL; 1482 struct devinet_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL); 1483 char *dev_name = NULL; 1484 1485 if (!t) 1486 return; 1487 memcpy(t, &devinet_sysctl, sizeof(*t)); 1488 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) { 1489 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf; 1490 t->devinet_vars[i].de = NULL; 1491 } 1492 1493 if (dev) { 1494 dev_name = dev->name; 1495 t->devinet_dev[0].ctl_name = dev->ifindex; 1496 } else { 1497 dev_name = "default"; 1498 t->devinet_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT; 1499 } 1500 1501 /* 1502 * Make a copy of dev_name, because '.procname' is regarded as const 1503 * by sysctl and we wouldn't want anyone to change it under our feet 1504 * (see SIOCSIFNAME). 1505 */ 1506 dev_name = kstrdup(dev_name, GFP_KERNEL); 1507 if (!dev_name) 1508 goto free; 1509 1510 t->devinet_dev[0].procname = dev_name; 1511 t->devinet_dev[0].child = t->devinet_vars; 1512 t->devinet_dev[0].de = NULL; 1513 t->devinet_conf_dir[0].child = t->devinet_dev; 1514 t->devinet_conf_dir[0].de = NULL; 1515 t->devinet_proto_dir[0].child = t->devinet_conf_dir; 1516 t->devinet_proto_dir[0].de = NULL; 1517 t->devinet_root_dir[0].child = t->devinet_proto_dir; 1518 t->devinet_root_dir[0].de = NULL; 1519 1520 t->sysctl_header = register_sysctl_table(t->devinet_root_dir, 0); 1521 if (!t->sysctl_header) 1522 goto free_procname; 1523 1524 p->sysctl = t; 1525 return; 1526 1527 /* error path */ 1528 free_procname: 1529 kfree(dev_name); 1530 free: 1531 kfree(t); 1532 return; 1533 } 1534 1535 static void devinet_sysctl_unregister(struct ipv4_devconf *p) 1536 { 1537 if (p->sysctl) { 1538 struct devinet_sysctl_table *t = p->sysctl; 1539 p->sysctl = NULL; 1540 unregister_sysctl_table(t->sysctl_header); 1541 kfree(t->devinet_dev[0].procname); 1542 kfree(t); 1543 } 1544 } 1545 #endif 1546 1547 void __init devinet_init(void) 1548 { 1549 register_gifconf(PF_INET, inet_gifconf); 1550 register_netdevice_notifier(&ip_netdev_notifier); 1551 rtnetlink_links[PF_INET] = inet_rtnetlink_table; 1552 #ifdef CONFIG_SYSCTL 1553 devinet_sysctl.sysctl_header = 1554 register_sysctl_table(devinet_sysctl.devinet_root_dir, 0); 1555 devinet_sysctl_register(NULL, &ipv4_devconf_dflt); 1556 #endif 1557 } 1558 1559 EXPORT_SYMBOL(in_dev_finish_destroy); 1560 EXPORT_SYMBOL(inet_select_addr); 1561 EXPORT_SYMBOL(inetdev_by_index); 1562 EXPORT_SYMBOL(register_inetaddr_notifier); 1563 EXPORT_SYMBOL(unregister_inetaddr_notifier); 1564