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