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