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