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