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/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 66 struct ipv4_devconf ipv4_devconf = { 67 .accept_redirects = 1, 68 .send_redirects = 1, 69 .secure_redirects = 1, 70 .shared_media = 1, 71 }; 72 73 static 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 81 static void rtmsg_ifa(int event, struct in_ifaddr *); 82 83 static struct notifier_block *inetaddr_chain; 84 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 85 int destroy); 86 #ifdef CONFIG_SYSCTL 87 static void devinet_sysctl_register(struct in_device *in_dev, 88 struct ipv4_devconf *p); 89 static void devinet_sysctl_unregister(struct ipv4_devconf *p); 90 #endif 91 92 /* Locks all the inet devices. */ 93 94 static struct in_ifaddr *inet_alloc_ifa(void) 95 { 96 struct in_ifaddr *ifa = kmalloc(sizeof(*ifa), GFP_KERNEL); 97 98 if (ifa) { 99 memset(ifa, 0, sizeof(*ifa)); 100 INIT_RCU_HEAD(&ifa->rcu_head); 101 } 102 103 return ifa; 104 } 105 106 static void inet_rcu_free_ifa(struct rcu_head *head) 107 { 108 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head); 109 if (ifa->ifa_dev) 110 in_dev_put(ifa->ifa_dev); 111 kfree(ifa); 112 } 113 114 static inline void inet_free_ifa(struct in_ifaddr *ifa) 115 { 116 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa); 117 } 118 119 void in_dev_finish_destroy(struct in_device *idev) 120 { 121 struct net_device *dev = idev->dev; 122 123 BUG_TRAP(!idev->ifa_list); 124 BUG_TRAP(!idev->mc_list); 125 #ifdef NET_REFCNT_DEBUG 126 printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n", 127 idev, dev ? dev->name : "NIL"); 128 #endif 129 dev_put(dev); 130 if (!idev->dead) 131 printk("Freeing alive in_device %p\n", idev); 132 else { 133 kfree(idev); 134 } 135 } 136 137 struct in_device *inetdev_init(struct net_device *dev) 138 { 139 struct in_device *in_dev; 140 141 ASSERT_RTNL(); 142 143 in_dev = kmalloc(sizeof(*in_dev), GFP_KERNEL); 144 if (!in_dev) 145 goto out; 146 memset(in_dev, 0, sizeof(*in_dev)); 147 INIT_RCU_HEAD(&in_dev->rcu_head); 148 memcpy(&in_dev->cnf, &ipv4_devconf_dflt, sizeof(in_dev->cnf)); 149 in_dev->cnf.sysctl = NULL; 150 in_dev->dev = dev; 151 if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL) 152 goto out_kfree; 153 /* Reference in_dev->dev */ 154 dev_hold(dev); 155 #ifdef CONFIG_SYSCTL 156 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4, 157 NET_IPV4_NEIGH, "ipv4", NULL, NULL); 158 #endif 159 160 /* Account for reference dev->ip_ptr */ 161 in_dev_hold(in_dev); 162 rcu_assign_pointer(dev->ip_ptr, in_dev); 163 164 #ifdef CONFIG_SYSCTL 165 devinet_sysctl_register(in_dev, &in_dev->cnf); 166 #endif 167 ip_mc_init_dev(in_dev); 168 if (dev->flags & IFF_UP) 169 ip_mc_up(in_dev); 170 out: 171 return in_dev; 172 out_kfree: 173 kfree(in_dev); 174 in_dev = NULL; 175 goto out; 176 } 177 178 static void in_dev_rcu_put(struct rcu_head *head) 179 { 180 struct in_device *idev = container_of(head, struct in_device, rcu_head); 181 in_dev_put(idev); 182 } 183 184 static void inetdev_destroy(struct in_device *in_dev) 185 { 186 struct in_ifaddr *ifa; 187 struct net_device *dev; 188 189 ASSERT_RTNL(); 190 191 dev = in_dev->dev; 192 if (dev == &loopback_dev) 193 return; 194 195 in_dev->dead = 1; 196 197 ip_mc_destroy_dev(in_dev); 198 199 while ((ifa = in_dev->ifa_list) != NULL) { 200 inet_del_ifa(in_dev, &in_dev->ifa_list, 0); 201 inet_free_ifa(ifa); 202 } 203 204 #ifdef CONFIG_SYSCTL 205 devinet_sysctl_unregister(&in_dev->cnf); 206 #endif 207 208 dev->ip_ptr = NULL; 209 210 #ifdef CONFIG_SYSCTL 211 neigh_sysctl_unregister(in_dev->arp_parms); 212 #endif 213 neigh_parms_release(&arp_tbl, in_dev->arp_parms); 214 arp_ifdown(dev); 215 216 call_rcu(&in_dev->rcu_head, in_dev_rcu_put); 217 } 218 219 int inet_addr_onlink(struct in_device *in_dev, u32 a, u32 b) 220 { 221 rcu_read_lock(); 222 for_primary_ifa(in_dev) { 223 if (inet_ifa_match(a, ifa)) { 224 if (!b || inet_ifa_match(b, ifa)) { 225 rcu_read_unlock(); 226 return 1; 227 } 228 } 229 } endfor_ifa(in_dev); 230 rcu_read_unlock(); 231 return 0; 232 } 233 234 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 235 int destroy) 236 { 237 struct in_ifaddr *promote = NULL; 238 struct in_ifaddr *ifa, *ifa1 = *ifap; 239 struct in_ifaddr *last_prim = in_dev->ifa_list; 240 struct in_ifaddr *prev_prom = NULL; 241 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev); 242 243 ASSERT_RTNL(); 244 245 /* 1. Deleting primary ifaddr forces deletion all secondaries 246 * unless alias promotion is set 247 **/ 248 249 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) { 250 struct in_ifaddr **ifap1 = &ifa1->ifa_next; 251 252 while ((ifa = *ifap1) != NULL) { 253 if (!(ifa->ifa_flags & IFA_F_SECONDARY) && 254 ifa1->ifa_scope <= ifa->ifa_scope) 255 last_prim = ifa; 256 257 if (!(ifa->ifa_flags & IFA_F_SECONDARY) || 258 ifa1->ifa_mask != ifa->ifa_mask || 259 !inet_ifa_match(ifa1->ifa_address, ifa)) { 260 ifap1 = &ifa->ifa_next; 261 prev_prom = ifa; 262 continue; 263 } 264 265 if (!do_promote) { 266 *ifap1 = ifa->ifa_next; 267 268 rtmsg_ifa(RTM_DELADDR, ifa); 269 notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa); 270 inet_free_ifa(ifa); 271 } else { 272 promote = ifa; 273 break; 274 } 275 } 276 } 277 278 /* 2. Unlink it */ 279 280 *ifap = ifa1->ifa_next; 281 282 /* 3. Announce address deletion */ 283 284 /* Send message first, then call notifier. 285 At first sight, FIB update triggered by notifier 286 will refer to already deleted ifaddr, that could confuse 287 netlink listeners. It is not true: look, gated sees 288 that route deleted and if it still thinks that ifaddr 289 is valid, it will try to restore deleted routes... Grr. 290 So that, this order is correct. 291 */ 292 rtmsg_ifa(RTM_DELADDR, ifa1); 293 notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1); 294 295 if (promote) { 296 297 if (prev_prom) { 298 prev_prom->ifa_next = promote->ifa_next; 299 promote->ifa_next = last_prim->ifa_next; 300 last_prim->ifa_next = promote; 301 } 302 303 promote->ifa_flags &= ~IFA_F_SECONDARY; 304 rtmsg_ifa(RTM_NEWADDR, promote); 305 notifier_call_chain(&inetaddr_chain, 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 322 static 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 notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa); 369 370 return 0; 371 } 372 373 static 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 396 struct 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 410 struct 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 422 static 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 } 450 out: 451 return -EADDRNOTAVAIL; 452 } 453 454 static 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); 503 out: 504 return rc; 505 } 506 507 /* 508 * Determine a default network mask, based on the IP address. 509 */ 510 511 static __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 532 int 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 } 761 done: 762 rtnl_unlock(); 763 out: 764 return ret; 765 rarok: 766 rtnl_unlock(); 767 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0; 768 goto out; 769 } 770 771 static 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 } 806 out: 807 return done; 808 } 809 810 u32 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); 830 no_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 } 854 out_unlock_both: 855 read_unlock(&dev_base_lock); 856 rcu_read_unlock(); 857 out: 858 return addr; 859 } 860 861 static 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 */ 905 u32 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 938 int register_inetaddr_notifier(struct notifier_block *nb) 939 { 940 return notifier_chain_register(&inetaddr_chain, nb); 941 } 942 943 int unregister_inetaddr_notifier(struct notifier_block *nb) 944 { 945 return 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 */ 951 static 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 978 static 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 } 1046 out: 1047 return NOTIFY_DONE; 1048 } 1049 1050 static struct notifier_block ip_netdev_notifier = { 1051 .notifier_call =inetdev_event, 1052 }; 1053 1054 static 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 1081 nlmsg_failure: 1082 rtattr_failure: 1083 skb_trim(skb, b - skb->data); 1084 return -1; 1085 } 1086 1087 static 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 1122 done: 1123 read_unlock(&dev_base_lock); 1124 cb->args[0] = idx; 1125 cb->args[1] = ip_idx; 1126 1127 return skb->len; 1128 } 1129 1130 static 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, current->pid, 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 1145 static 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 1162 void 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 1184 static 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 1202 int 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 1216 int 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 1258 static 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_NOXFRM, 1397 .procname = "disable_xfrm", 1398 .data = &ipv4_devconf.no_xfrm, 1399 .maxlen = sizeof(int), 1400 .mode = 0644, 1401 .proc_handler = &ipv4_doint_and_flush, 1402 .strategy = &ipv4_doint_and_flush_strategy, 1403 }, 1404 { 1405 .ctl_name = NET_IPV4_CONF_NOPOLICY, 1406 .procname = "disable_policy", 1407 .data = &ipv4_devconf.no_policy, 1408 .maxlen = sizeof(int), 1409 .mode = 0644, 1410 .proc_handler = &ipv4_doint_and_flush, 1411 .strategy = &ipv4_doint_and_flush_strategy, 1412 }, 1413 { 1414 .ctl_name = NET_IPV4_CONF_FORCE_IGMP_VERSION, 1415 .procname = "force_igmp_version", 1416 .data = &ipv4_devconf.force_igmp_version, 1417 .maxlen = sizeof(int), 1418 .mode = 0644, 1419 .proc_handler = &ipv4_doint_and_flush, 1420 .strategy = &ipv4_doint_and_flush_strategy, 1421 }, 1422 { 1423 .ctl_name = NET_IPV4_CONF_PROMOTE_SECONDARIES, 1424 .procname = "promote_secondaries", 1425 .data = &ipv4_devconf.promote_secondaries, 1426 .maxlen = sizeof(int), 1427 .mode = 0644, 1428 .proc_handler = &ipv4_doint_and_flush, 1429 .strategy = &ipv4_doint_and_flush_strategy, 1430 }, 1431 }, 1432 .devinet_dev = { 1433 { 1434 .ctl_name = NET_PROTO_CONF_ALL, 1435 .procname = "all", 1436 .mode = 0555, 1437 .child = devinet_sysctl.devinet_vars, 1438 }, 1439 }, 1440 .devinet_conf_dir = { 1441 { 1442 .ctl_name = NET_IPV4_CONF, 1443 .procname = "conf", 1444 .mode = 0555, 1445 .child = devinet_sysctl.devinet_dev, 1446 }, 1447 }, 1448 .devinet_proto_dir = { 1449 { 1450 .ctl_name = NET_IPV4, 1451 .procname = "ipv4", 1452 .mode = 0555, 1453 .child = devinet_sysctl.devinet_conf_dir, 1454 }, 1455 }, 1456 .devinet_root_dir = { 1457 { 1458 .ctl_name = CTL_NET, 1459 .procname = "net", 1460 .mode = 0555, 1461 .child = devinet_sysctl.devinet_proto_dir, 1462 }, 1463 }, 1464 }; 1465 1466 static void devinet_sysctl_register(struct in_device *in_dev, 1467 struct ipv4_devconf *p) 1468 { 1469 int i; 1470 struct net_device *dev = in_dev ? in_dev->dev : NULL; 1471 struct devinet_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL); 1472 char *dev_name = NULL; 1473 1474 if (!t) 1475 return; 1476 memcpy(t, &devinet_sysctl, sizeof(*t)); 1477 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) { 1478 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf; 1479 t->devinet_vars[i].de = NULL; 1480 } 1481 1482 if (dev) { 1483 dev_name = dev->name; 1484 t->devinet_dev[0].ctl_name = dev->ifindex; 1485 } else { 1486 dev_name = "default"; 1487 t->devinet_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT; 1488 } 1489 1490 /* 1491 * Make a copy of dev_name, because '.procname' is regarded as const 1492 * by sysctl and we wouldn't want anyone to change it under our feet 1493 * (see SIOCSIFNAME). 1494 */ 1495 dev_name = kstrdup(dev_name, GFP_KERNEL); 1496 if (!dev_name) 1497 goto free; 1498 1499 t->devinet_dev[0].procname = dev_name; 1500 t->devinet_dev[0].child = t->devinet_vars; 1501 t->devinet_dev[0].de = NULL; 1502 t->devinet_conf_dir[0].child = t->devinet_dev; 1503 t->devinet_conf_dir[0].de = NULL; 1504 t->devinet_proto_dir[0].child = t->devinet_conf_dir; 1505 t->devinet_proto_dir[0].de = NULL; 1506 t->devinet_root_dir[0].child = t->devinet_proto_dir; 1507 t->devinet_root_dir[0].de = NULL; 1508 1509 t->sysctl_header = register_sysctl_table(t->devinet_root_dir, 0); 1510 if (!t->sysctl_header) 1511 goto free_procname; 1512 1513 p->sysctl = t; 1514 return; 1515 1516 /* error path */ 1517 free_procname: 1518 kfree(dev_name); 1519 free: 1520 kfree(t); 1521 return; 1522 } 1523 1524 static void devinet_sysctl_unregister(struct ipv4_devconf *p) 1525 { 1526 if (p->sysctl) { 1527 struct devinet_sysctl_table *t = p->sysctl; 1528 p->sysctl = NULL; 1529 unregister_sysctl_table(t->sysctl_header); 1530 kfree(t->devinet_dev[0].procname); 1531 kfree(t); 1532 } 1533 } 1534 #endif 1535 1536 void __init devinet_init(void) 1537 { 1538 register_gifconf(PF_INET, inet_gifconf); 1539 register_netdevice_notifier(&ip_netdev_notifier); 1540 rtnetlink_links[PF_INET] = inet_rtnetlink_table; 1541 #ifdef CONFIG_SYSCTL 1542 devinet_sysctl.sysctl_header = 1543 register_sysctl_table(devinet_sysctl.devinet_root_dir, 0); 1544 devinet_sysctl_register(NULL, &ipv4_devconf_dflt); 1545 #endif 1546 } 1547 1548 EXPORT_SYMBOL(devinet_ioctl); 1549 EXPORT_SYMBOL(in_dev_finish_destroy); 1550 EXPORT_SYMBOL(inet_select_addr); 1551 EXPORT_SYMBOL(inetdev_by_index); 1552 EXPORT_SYMBOL(register_inetaddr_notifier); 1553 EXPORT_SYMBOL(unregister_inetaddr_notifier); 1554