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