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