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