1 /* 2 * IPv6 Address [auto]configuration 3 * Linux INET6 implementation 4 * 5 * Authors: 6 * Pedro Roque <roque@di.fc.ul.pt> 7 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru> 8 * 9 * $Id: addrconf.c,v 1.69 2001/10/31 21:55:54 davem Exp $ 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License 13 * as published by the Free Software Foundation; either version 14 * 2 of the License, or (at your option) any later version. 15 */ 16 17 /* 18 * Changes: 19 * 20 * Janos Farkas : delete timer on ifdown 21 * <chexum@bankinf.banki.hu> 22 * Andi Kleen : kill double kfree on module 23 * unload. 24 * Maciej W. Rozycki : FDDI support 25 * sekiya@USAGI : Don't send too many RS 26 * packets. 27 * yoshfuji@USAGI : Fixed interval between DAD 28 * packets. 29 * YOSHIFUJI Hideaki @USAGI : improved accuracy of 30 * address validation timer. 31 * YOSHIFUJI Hideaki @USAGI : Privacy Extensions (RFC3041) 32 * support. 33 * Yuji SEKIYA @USAGI : Don't assign a same IPv6 34 * address on a same interface. 35 * YOSHIFUJI Hideaki @USAGI : ARCnet support 36 * YOSHIFUJI Hideaki @USAGI : convert /proc/net/if_inet6 to 37 * seq_file. 38 * YOSHIFUJI Hideaki @USAGI : improved source address 39 * selection; consider scope, 40 * status etc. 41 */ 42 43 #include <linux/errno.h> 44 #include <linux/types.h> 45 #include <linux/socket.h> 46 #include <linux/sockios.h> 47 #include <linux/net.h> 48 #include <linux/in6.h> 49 #include <linux/netdevice.h> 50 #include <linux/if_addr.h> 51 #include <linux/if_arp.h> 52 #include <linux/if_arcnet.h> 53 #include <linux/if_infiniband.h> 54 #include <linux/route.h> 55 #include <linux/inetdevice.h> 56 #include <linux/init.h> 57 #ifdef CONFIG_SYSCTL 58 #include <linux/sysctl.h> 59 #endif 60 #include <linux/capability.h> 61 #include <linux/delay.h> 62 #include <linux/notifier.h> 63 #include <linux/string.h> 64 65 #include <net/net_namespace.h> 66 #include <net/sock.h> 67 #include <net/snmp.h> 68 69 #include <net/ipv6.h> 70 #include <net/protocol.h> 71 #include <net/ndisc.h> 72 #include <net/ip6_route.h> 73 #include <net/addrconf.h> 74 #include <net/tcp.h> 75 #include <net/ip.h> 76 #include <net/netlink.h> 77 #include <net/pkt_sched.h> 78 #include <linux/if_tunnel.h> 79 #include <linux/rtnetlink.h> 80 81 #ifdef CONFIG_IPV6_PRIVACY 82 #include <linux/random.h> 83 #endif 84 85 #include <asm/uaccess.h> 86 #include <asm/unaligned.h> 87 88 #include <linux/proc_fs.h> 89 #include <linux/seq_file.h> 90 91 /* Set to 3 to get tracing... */ 92 #define ACONF_DEBUG 2 93 94 #if ACONF_DEBUG >= 3 95 #define ADBG(x) printk x 96 #else 97 #define ADBG(x) 98 #endif 99 100 #define INFINITY_LIFE_TIME 0xFFFFFFFF 101 #define TIME_DELTA(a,b) ((unsigned long)((long)(a) - (long)(b))) 102 103 #ifdef CONFIG_SYSCTL 104 static void addrconf_sysctl_register(struct inet6_dev *idev, struct ipv6_devconf *p); 105 static void addrconf_sysctl_unregister(struct ipv6_devconf *p); 106 #endif 107 108 #ifdef CONFIG_IPV6_PRIVACY 109 static int __ipv6_regen_rndid(struct inet6_dev *idev); 110 static int __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr); 111 static void ipv6_regen_rndid(unsigned long data); 112 113 static int desync_factor = MAX_DESYNC_FACTOR * HZ; 114 #endif 115 116 static int ipv6_count_addresses(struct inet6_dev *idev); 117 118 /* 119 * Configured unicast address hash table 120 */ 121 static struct inet6_ifaddr *inet6_addr_lst[IN6_ADDR_HSIZE]; 122 static DEFINE_RWLOCK(addrconf_hash_lock); 123 124 static void addrconf_verify(unsigned long); 125 126 static DEFINE_TIMER(addr_chk_timer, addrconf_verify, 0, 0); 127 static DEFINE_SPINLOCK(addrconf_verify_lock); 128 129 static void addrconf_join_anycast(struct inet6_ifaddr *ifp); 130 static void addrconf_leave_anycast(struct inet6_ifaddr *ifp); 131 132 static int addrconf_ifdown(struct net_device *dev, int how); 133 134 static void addrconf_dad_start(struct inet6_ifaddr *ifp, u32 flags); 135 static void addrconf_dad_timer(unsigned long data); 136 static void addrconf_dad_completed(struct inet6_ifaddr *ifp); 137 static void addrconf_dad_run(struct inet6_dev *idev); 138 static void addrconf_rs_timer(unsigned long data); 139 static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa); 140 static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa); 141 142 static void inet6_prefix_notify(int event, struct inet6_dev *idev, 143 struct prefix_info *pinfo); 144 static int ipv6_chk_same_addr(const struct in6_addr *addr, struct net_device *dev); 145 146 static ATOMIC_NOTIFIER_HEAD(inet6addr_chain); 147 148 struct ipv6_devconf ipv6_devconf __read_mostly = { 149 .forwarding = 0, 150 .hop_limit = IPV6_DEFAULT_HOPLIMIT, 151 .mtu6 = IPV6_MIN_MTU, 152 .accept_ra = 1, 153 .accept_redirects = 1, 154 .autoconf = 1, 155 .force_mld_version = 0, 156 .dad_transmits = 1, 157 .rtr_solicits = MAX_RTR_SOLICITATIONS, 158 .rtr_solicit_interval = RTR_SOLICITATION_INTERVAL, 159 .rtr_solicit_delay = MAX_RTR_SOLICITATION_DELAY, 160 #ifdef CONFIG_IPV6_PRIVACY 161 .use_tempaddr = 0, 162 .temp_valid_lft = TEMP_VALID_LIFETIME, 163 .temp_prefered_lft = TEMP_PREFERRED_LIFETIME, 164 .regen_max_retry = REGEN_MAX_RETRY, 165 .max_desync_factor = MAX_DESYNC_FACTOR, 166 #endif 167 .max_addresses = IPV6_MAX_ADDRESSES, 168 .accept_ra_defrtr = 1, 169 .accept_ra_pinfo = 1, 170 #ifdef CONFIG_IPV6_ROUTER_PREF 171 .accept_ra_rtr_pref = 1, 172 .rtr_probe_interval = 60 * HZ, 173 #ifdef CONFIG_IPV6_ROUTE_INFO 174 .accept_ra_rt_info_max_plen = 0, 175 #endif 176 #endif 177 .proxy_ndp = 0, 178 .accept_source_route = 0, /* we do not accept RH0 by default. */ 179 }; 180 181 static struct ipv6_devconf ipv6_devconf_dflt __read_mostly = { 182 .forwarding = 0, 183 .hop_limit = IPV6_DEFAULT_HOPLIMIT, 184 .mtu6 = IPV6_MIN_MTU, 185 .accept_ra = 1, 186 .accept_redirects = 1, 187 .autoconf = 1, 188 .dad_transmits = 1, 189 .rtr_solicits = MAX_RTR_SOLICITATIONS, 190 .rtr_solicit_interval = RTR_SOLICITATION_INTERVAL, 191 .rtr_solicit_delay = MAX_RTR_SOLICITATION_DELAY, 192 #ifdef CONFIG_IPV6_PRIVACY 193 .use_tempaddr = 0, 194 .temp_valid_lft = TEMP_VALID_LIFETIME, 195 .temp_prefered_lft = TEMP_PREFERRED_LIFETIME, 196 .regen_max_retry = REGEN_MAX_RETRY, 197 .max_desync_factor = MAX_DESYNC_FACTOR, 198 #endif 199 .max_addresses = IPV6_MAX_ADDRESSES, 200 .accept_ra_defrtr = 1, 201 .accept_ra_pinfo = 1, 202 #ifdef CONFIG_IPV6_ROUTER_PREF 203 .accept_ra_rtr_pref = 1, 204 .rtr_probe_interval = 60 * HZ, 205 #ifdef CONFIG_IPV6_ROUTE_INFO 206 .accept_ra_rt_info_max_plen = 0, 207 #endif 208 #endif 209 .proxy_ndp = 0, 210 .accept_source_route = 0, /* we do not accept RH0 by default. */ 211 }; 212 213 /* IPv6 Wildcard Address and Loopback Address defined by RFC2553 */ 214 const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT; 215 const struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT; 216 217 /* Check if a valid qdisc is available */ 218 static inline int addrconf_qdisc_ok(struct net_device *dev) 219 { 220 return (dev->qdisc != &noop_qdisc); 221 } 222 223 static void addrconf_del_timer(struct inet6_ifaddr *ifp) 224 { 225 if (del_timer(&ifp->timer)) 226 __in6_ifa_put(ifp); 227 } 228 229 enum addrconf_timer_t 230 { 231 AC_NONE, 232 AC_DAD, 233 AC_RS, 234 }; 235 236 static void addrconf_mod_timer(struct inet6_ifaddr *ifp, 237 enum addrconf_timer_t what, 238 unsigned long when) 239 { 240 if (!del_timer(&ifp->timer)) 241 in6_ifa_hold(ifp); 242 243 switch (what) { 244 case AC_DAD: 245 ifp->timer.function = addrconf_dad_timer; 246 break; 247 case AC_RS: 248 ifp->timer.function = addrconf_rs_timer; 249 break; 250 default:; 251 } 252 ifp->timer.expires = jiffies + when; 253 add_timer(&ifp->timer); 254 } 255 256 static int snmp6_alloc_dev(struct inet6_dev *idev) 257 { 258 int err = -ENOMEM; 259 260 if (!idev || !idev->dev) 261 return -EINVAL; 262 263 if (snmp_mib_init((void **)idev->stats.ipv6, 264 sizeof(struct ipstats_mib), 265 __alignof__(struct ipstats_mib)) < 0) 266 goto err_ip; 267 if (snmp_mib_init((void **)idev->stats.icmpv6, 268 sizeof(struct icmpv6_mib), 269 __alignof__(struct icmpv6_mib)) < 0) 270 goto err_icmp; 271 if (snmp_mib_init((void **)idev->stats.icmpv6msg, 272 sizeof(struct icmpv6msg_mib), 273 __alignof__(struct icmpv6msg_mib)) < 0) 274 goto err_icmpmsg; 275 276 return 0; 277 278 err_icmpmsg: 279 snmp_mib_free((void **)idev->stats.icmpv6); 280 err_icmp: 281 snmp_mib_free((void **)idev->stats.ipv6); 282 err_ip: 283 return err; 284 } 285 286 static int snmp6_free_dev(struct inet6_dev *idev) 287 { 288 snmp_mib_free((void **)idev->stats.icmpv6msg); 289 snmp_mib_free((void **)idev->stats.icmpv6); 290 snmp_mib_free((void **)idev->stats.ipv6); 291 return 0; 292 } 293 294 /* Nobody refers to this device, we may destroy it. */ 295 296 static void in6_dev_finish_destroy_rcu(struct rcu_head *head) 297 { 298 struct inet6_dev *idev = container_of(head, struct inet6_dev, rcu); 299 kfree(idev); 300 } 301 302 void in6_dev_finish_destroy(struct inet6_dev *idev) 303 { 304 struct net_device *dev = idev->dev; 305 BUG_TRAP(idev->addr_list==NULL); 306 BUG_TRAP(idev->mc_list==NULL); 307 #ifdef NET_REFCNT_DEBUG 308 printk(KERN_DEBUG "in6_dev_finish_destroy: %s\n", dev ? dev->name : "NIL"); 309 #endif 310 dev_put(dev); 311 if (!idev->dead) { 312 printk("Freeing alive inet6 device %p\n", idev); 313 return; 314 } 315 snmp6_free_dev(idev); 316 call_rcu(&idev->rcu, in6_dev_finish_destroy_rcu); 317 } 318 319 EXPORT_SYMBOL(in6_dev_finish_destroy); 320 321 static struct inet6_dev * ipv6_add_dev(struct net_device *dev) 322 { 323 struct inet6_dev *ndev; 324 struct in6_addr maddr; 325 326 ASSERT_RTNL(); 327 328 if (dev->mtu < IPV6_MIN_MTU) 329 return NULL; 330 331 ndev = kzalloc(sizeof(struct inet6_dev), GFP_KERNEL); 332 333 if (ndev == NULL) 334 return NULL; 335 336 rwlock_init(&ndev->lock); 337 ndev->dev = dev; 338 memcpy(&ndev->cnf, &ipv6_devconf_dflt, sizeof(ndev->cnf)); 339 ndev->cnf.mtu6 = dev->mtu; 340 ndev->cnf.sysctl = NULL; 341 ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl); 342 if (ndev->nd_parms == NULL) { 343 kfree(ndev); 344 return NULL; 345 } 346 /* We refer to the device */ 347 dev_hold(dev); 348 349 if (snmp6_alloc_dev(ndev) < 0) { 350 ADBG((KERN_WARNING 351 "%s(): cannot allocate memory for statistics; dev=%s.\n", 352 __FUNCTION__, dev->name)); 353 neigh_parms_release(&nd_tbl, ndev->nd_parms); 354 ndev->dead = 1; 355 in6_dev_finish_destroy(ndev); 356 return NULL; 357 } 358 359 if (snmp6_register_dev(ndev) < 0) { 360 ADBG((KERN_WARNING 361 "%s(): cannot create /proc/net/dev_snmp6/%s\n", 362 __FUNCTION__, dev->name)); 363 neigh_parms_release(&nd_tbl, ndev->nd_parms); 364 ndev->dead = 1; 365 in6_dev_finish_destroy(ndev); 366 return NULL; 367 } 368 369 /* One reference from device. We must do this before 370 * we invoke __ipv6_regen_rndid(). 371 */ 372 in6_dev_hold(ndev); 373 374 #ifdef CONFIG_IPV6_PRIVACY 375 init_timer(&ndev->regen_timer); 376 ndev->regen_timer.function = ipv6_regen_rndid; 377 ndev->regen_timer.data = (unsigned long) ndev; 378 if ((dev->flags&IFF_LOOPBACK) || 379 dev->type == ARPHRD_TUNNEL || 380 #if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE) 381 dev->type == ARPHRD_SIT || 382 #endif 383 dev->type == ARPHRD_NONE) { 384 printk(KERN_INFO 385 "%s: Disabled Privacy Extensions\n", 386 dev->name); 387 ndev->cnf.use_tempaddr = -1; 388 } else { 389 in6_dev_hold(ndev); 390 ipv6_regen_rndid((unsigned long) ndev); 391 } 392 #endif 393 394 if (netif_running(dev) && addrconf_qdisc_ok(dev)) 395 ndev->if_flags |= IF_READY; 396 397 ipv6_mc_init_dev(ndev); 398 ndev->tstamp = jiffies; 399 #ifdef CONFIG_SYSCTL 400 neigh_sysctl_register(dev, ndev->nd_parms, NET_IPV6, 401 NET_IPV6_NEIGH, "ipv6", 402 &ndisc_ifinfo_sysctl_change, 403 NULL); 404 addrconf_sysctl_register(ndev, &ndev->cnf); 405 #endif 406 /* protected by rtnl_lock */ 407 rcu_assign_pointer(dev->ip6_ptr, ndev); 408 409 /* Join all-node multicast group */ 410 ipv6_addr_all_nodes(&maddr); 411 ipv6_dev_mc_inc(dev, &maddr); 412 413 return ndev; 414 } 415 416 static struct inet6_dev * ipv6_find_idev(struct net_device *dev) 417 { 418 struct inet6_dev *idev; 419 420 ASSERT_RTNL(); 421 422 if ((idev = __in6_dev_get(dev)) == NULL) { 423 if ((idev = ipv6_add_dev(dev)) == NULL) 424 return NULL; 425 } 426 427 if (dev->flags&IFF_UP) 428 ipv6_mc_up(idev); 429 return idev; 430 } 431 432 #ifdef CONFIG_SYSCTL 433 static void dev_forward_change(struct inet6_dev *idev) 434 { 435 struct net_device *dev; 436 struct inet6_ifaddr *ifa; 437 struct in6_addr addr; 438 439 if (!idev) 440 return; 441 dev = idev->dev; 442 if (dev && (dev->flags & IFF_MULTICAST)) { 443 ipv6_addr_all_routers(&addr); 444 445 if (idev->cnf.forwarding) 446 ipv6_dev_mc_inc(dev, &addr); 447 else 448 ipv6_dev_mc_dec(dev, &addr); 449 } 450 for (ifa=idev->addr_list; ifa; ifa=ifa->if_next) { 451 if (ifa->flags&IFA_F_TENTATIVE) 452 continue; 453 if (idev->cnf.forwarding) 454 addrconf_join_anycast(ifa); 455 else 456 addrconf_leave_anycast(ifa); 457 } 458 } 459 460 461 static void addrconf_forward_change(void) 462 { 463 struct net_device *dev; 464 struct inet6_dev *idev; 465 466 read_lock(&dev_base_lock); 467 for_each_netdev(&init_net, dev) { 468 rcu_read_lock(); 469 idev = __in6_dev_get(dev); 470 if (idev) { 471 int changed = (!idev->cnf.forwarding) ^ (!ipv6_devconf.forwarding); 472 idev->cnf.forwarding = ipv6_devconf.forwarding; 473 if (changed) 474 dev_forward_change(idev); 475 } 476 rcu_read_unlock(); 477 } 478 read_unlock(&dev_base_lock); 479 } 480 #endif 481 482 /* Nobody refers to this ifaddr, destroy it */ 483 484 void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp) 485 { 486 BUG_TRAP(ifp->if_next==NULL); 487 BUG_TRAP(ifp->lst_next==NULL); 488 #ifdef NET_REFCNT_DEBUG 489 printk(KERN_DEBUG "inet6_ifa_finish_destroy\n"); 490 #endif 491 492 in6_dev_put(ifp->idev); 493 494 if (del_timer(&ifp->timer)) 495 printk("Timer is still running, when freeing ifa=%p\n", ifp); 496 497 if (!ifp->dead) { 498 printk("Freeing alive inet6 address %p\n", ifp); 499 return; 500 } 501 dst_release(&ifp->rt->u.dst); 502 503 kfree(ifp); 504 } 505 506 static void 507 ipv6_link_dev_addr(struct inet6_dev *idev, struct inet6_ifaddr *ifp) 508 { 509 struct inet6_ifaddr *ifa, **ifap; 510 int ifp_scope = ipv6_addr_src_scope(&ifp->addr); 511 512 /* 513 * Each device address list is sorted in order of scope - 514 * global before linklocal. 515 */ 516 for (ifap = &idev->addr_list; (ifa = *ifap) != NULL; 517 ifap = &ifa->if_next) { 518 if (ifp_scope >= ipv6_addr_src_scope(&ifa->addr)) 519 break; 520 } 521 522 ifp->if_next = *ifap; 523 *ifap = ifp; 524 } 525 526 /* On success it returns ifp with increased reference count */ 527 528 static struct inet6_ifaddr * 529 ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr, int pfxlen, 530 int scope, u32 flags) 531 { 532 struct inet6_ifaddr *ifa = NULL; 533 struct rt6_info *rt; 534 int hash; 535 int err = 0; 536 537 rcu_read_lock_bh(); 538 if (idev->dead) { 539 err = -ENODEV; /*XXX*/ 540 goto out2; 541 } 542 543 write_lock(&addrconf_hash_lock); 544 545 /* Ignore adding duplicate addresses on an interface */ 546 if (ipv6_chk_same_addr(addr, idev->dev)) { 547 ADBG(("ipv6_add_addr: already assigned\n")); 548 err = -EEXIST; 549 goto out; 550 } 551 552 ifa = kzalloc(sizeof(struct inet6_ifaddr), GFP_ATOMIC); 553 554 if (ifa == NULL) { 555 ADBG(("ipv6_add_addr: malloc failed\n")); 556 err = -ENOBUFS; 557 goto out; 558 } 559 560 rt = addrconf_dst_alloc(idev, addr, 0); 561 if (IS_ERR(rt)) { 562 err = PTR_ERR(rt); 563 goto out; 564 } 565 566 ipv6_addr_copy(&ifa->addr, addr); 567 568 spin_lock_init(&ifa->lock); 569 init_timer(&ifa->timer); 570 ifa->timer.data = (unsigned long) ifa; 571 ifa->scope = scope; 572 ifa->prefix_len = pfxlen; 573 ifa->flags = flags | IFA_F_TENTATIVE; 574 ifa->cstamp = ifa->tstamp = jiffies; 575 576 ifa->rt = rt; 577 578 /* 579 * part one of RFC 4429, section 3.3 580 * We should not configure an address as 581 * optimistic if we do not yet know the link 582 * layer address of our nexhop router 583 */ 584 585 if (rt->rt6i_nexthop == NULL) 586 ifa->flags &= ~IFA_F_OPTIMISTIC; 587 588 ifa->idev = idev; 589 in6_dev_hold(idev); 590 /* For caller */ 591 in6_ifa_hold(ifa); 592 593 /* Add to big hash table */ 594 hash = ipv6_addr_hash(addr); 595 596 ifa->lst_next = inet6_addr_lst[hash]; 597 inet6_addr_lst[hash] = ifa; 598 in6_ifa_hold(ifa); 599 write_unlock(&addrconf_hash_lock); 600 601 write_lock(&idev->lock); 602 /* Add to inet6_dev unicast addr list. */ 603 ipv6_link_dev_addr(idev, ifa); 604 605 #ifdef CONFIG_IPV6_PRIVACY 606 if (ifa->flags&IFA_F_TEMPORARY) { 607 ifa->tmp_next = idev->tempaddr_list; 608 idev->tempaddr_list = ifa; 609 in6_ifa_hold(ifa); 610 } 611 #endif 612 613 in6_ifa_hold(ifa); 614 write_unlock(&idev->lock); 615 out2: 616 rcu_read_unlock_bh(); 617 618 if (likely(err == 0)) 619 atomic_notifier_call_chain(&inet6addr_chain, NETDEV_UP, ifa); 620 else { 621 kfree(ifa); 622 ifa = ERR_PTR(err); 623 } 624 625 return ifa; 626 out: 627 write_unlock(&addrconf_hash_lock); 628 goto out2; 629 } 630 631 /* This function wants to get referenced ifp and releases it before return */ 632 633 static void ipv6_del_addr(struct inet6_ifaddr *ifp) 634 { 635 struct inet6_ifaddr *ifa, **ifap; 636 struct inet6_dev *idev = ifp->idev; 637 int hash; 638 int deleted = 0, onlink = 0; 639 unsigned long expires = jiffies; 640 641 hash = ipv6_addr_hash(&ifp->addr); 642 643 ifp->dead = 1; 644 645 write_lock_bh(&addrconf_hash_lock); 646 for (ifap = &inet6_addr_lst[hash]; (ifa=*ifap) != NULL; 647 ifap = &ifa->lst_next) { 648 if (ifa == ifp) { 649 *ifap = ifa->lst_next; 650 __in6_ifa_put(ifp); 651 ifa->lst_next = NULL; 652 break; 653 } 654 } 655 write_unlock_bh(&addrconf_hash_lock); 656 657 write_lock_bh(&idev->lock); 658 #ifdef CONFIG_IPV6_PRIVACY 659 if (ifp->flags&IFA_F_TEMPORARY) { 660 for (ifap = &idev->tempaddr_list; (ifa=*ifap) != NULL; 661 ifap = &ifa->tmp_next) { 662 if (ifa == ifp) { 663 *ifap = ifa->tmp_next; 664 if (ifp->ifpub) { 665 in6_ifa_put(ifp->ifpub); 666 ifp->ifpub = NULL; 667 } 668 __in6_ifa_put(ifp); 669 ifa->tmp_next = NULL; 670 break; 671 } 672 } 673 } 674 #endif 675 676 for (ifap = &idev->addr_list; (ifa=*ifap) != NULL;) { 677 if (ifa == ifp) { 678 *ifap = ifa->if_next; 679 __in6_ifa_put(ifp); 680 ifa->if_next = NULL; 681 if (!(ifp->flags & IFA_F_PERMANENT) || onlink > 0) 682 break; 683 deleted = 1; 684 continue; 685 } else if (ifp->flags & IFA_F_PERMANENT) { 686 if (ipv6_prefix_equal(&ifa->addr, &ifp->addr, 687 ifp->prefix_len)) { 688 if (ifa->flags & IFA_F_PERMANENT) { 689 onlink = 1; 690 if (deleted) 691 break; 692 } else { 693 unsigned long lifetime; 694 695 if (!onlink) 696 onlink = -1; 697 698 spin_lock(&ifa->lock); 699 lifetime = min_t(unsigned long, 700 ifa->valid_lft, 0x7fffffffUL/HZ); 701 if (time_before(expires, 702 ifa->tstamp + lifetime * HZ)) 703 expires = ifa->tstamp + lifetime * HZ; 704 spin_unlock(&ifa->lock); 705 } 706 } 707 } 708 ifap = &ifa->if_next; 709 } 710 write_unlock_bh(&idev->lock); 711 712 ipv6_ifa_notify(RTM_DELADDR, ifp); 713 714 atomic_notifier_call_chain(&inet6addr_chain, NETDEV_DOWN, ifp); 715 716 addrconf_del_timer(ifp); 717 718 /* 719 * Purge or update corresponding prefix 720 * 721 * 1) we don't purge prefix here if address was not permanent. 722 * prefix is managed by its own lifetime. 723 * 2) if there're no addresses, delete prefix. 724 * 3) if there're still other permanent address(es), 725 * corresponding prefix is still permanent. 726 * 4) otherwise, update prefix lifetime to the 727 * longest valid lifetime among the corresponding 728 * addresses on the device. 729 * Note: subsequent RA will update lifetime. 730 * 731 * --yoshfuji 732 */ 733 if ((ifp->flags & IFA_F_PERMANENT) && onlink < 1) { 734 struct in6_addr prefix; 735 struct rt6_info *rt; 736 737 ipv6_addr_prefix(&prefix, &ifp->addr, ifp->prefix_len); 738 rt = rt6_lookup(&prefix, NULL, ifp->idev->dev->ifindex, 1); 739 740 if (rt && ((rt->rt6i_flags & (RTF_GATEWAY | RTF_DEFAULT)) == 0)) { 741 if (onlink == 0) { 742 ip6_del_rt(rt); 743 rt = NULL; 744 } else if (!(rt->rt6i_flags & RTF_EXPIRES)) { 745 rt->rt6i_expires = expires; 746 rt->rt6i_flags |= RTF_EXPIRES; 747 } 748 } 749 dst_release(&rt->u.dst); 750 } 751 752 in6_ifa_put(ifp); 753 } 754 755 #ifdef CONFIG_IPV6_PRIVACY 756 static int ipv6_create_tempaddr(struct inet6_ifaddr *ifp, struct inet6_ifaddr *ift) 757 { 758 struct inet6_dev *idev = ifp->idev; 759 struct in6_addr addr, *tmpaddr; 760 unsigned long tmp_prefered_lft, tmp_valid_lft, tmp_cstamp, tmp_tstamp; 761 int tmp_plen; 762 int ret = 0; 763 int max_addresses; 764 u32 addr_flags; 765 766 write_lock(&idev->lock); 767 if (ift) { 768 spin_lock_bh(&ift->lock); 769 memcpy(&addr.s6_addr[8], &ift->addr.s6_addr[8], 8); 770 spin_unlock_bh(&ift->lock); 771 tmpaddr = &addr; 772 } else { 773 tmpaddr = NULL; 774 } 775 retry: 776 in6_dev_hold(idev); 777 if (idev->cnf.use_tempaddr <= 0) { 778 write_unlock(&idev->lock); 779 printk(KERN_INFO 780 "ipv6_create_tempaddr(): use_tempaddr is disabled.\n"); 781 in6_dev_put(idev); 782 ret = -1; 783 goto out; 784 } 785 spin_lock_bh(&ifp->lock); 786 if (ifp->regen_count++ >= idev->cnf.regen_max_retry) { 787 idev->cnf.use_tempaddr = -1; /*XXX*/ 788 spin_unlock_bh(&ifp->lock); 789 write_unlock(&idev->lock); 790 printk(KERN_WARNING 791 "ipv6_create_tempaddr(): regeneration time exceeded. disabled temporary address support.\n"); 792 in6_dev_put(idev); 793 ret = -1; 794 goto out; 795 } 796 in6_ifa_hold(ifp); 797 memcpy(addr.s6_addr, ifp->addr.s6_addr, 8); 798 if (__ipv6_try_regen_rndid(idev, tmpaddr) < 0) { 799 spin_unlock_bh(&ifp->lock); 800 write_unlock(&idev->lock); 801 printk(KERN_WARNING 802 "ipv6_create_tempaddr(): regeneration of randomized interface id failed.\n"); 803 in6_ifa_put(ifp); 804 in6_dev_put(idev); 805 ret = -1; 806 goto out; 807 } 808 memcpy(&addr.s6_addr[8], idev->rndid, 8); 809 tmp_valid_lft = min_t(__u32, 810 ifp->valid_lft, 811 idev->cnf.temp_valid_lft); 812 tmp_prefered_lft = min_t(__u32, 813 ifp->prefered_lft, 814 idev->cnf.temp_prefered_lft - desync_factor / HZ); 815 tmp_plen = ifp->prefix_len; 816 max_addresses = idev->cnf.max_addresses; 817 tmp_cstamp = ifp->cstamp; 818 tmp_tstamp = ifp->tstamp; 819 spin_unlock_bh(&ifp->lock); 820 821 write_unlock(&idev->lock); 822 823 addr_flags = IFA_F_TEMPORARY; 824 /* set in addrconf_prefix_rcv() */ 825 if (ifp->flags & IFA_F_OPTIMISTIC) 826 addr_flags |= IFA_F_OPTIMISTIC; 827 828 ift = !max_addresses || 829 ipv6_count_addresses(idev) < max_addresses ? 830 ipv6_add_addr(idev, &addr, tmp_plen, 831 ipv6_addr_type(&addr)&IPV6_ADDR_SCOPE_MASK, 832 addr_flags) : NULL; 833 if (!ift || IS_ERR(ift)) { 834 in6_ifa_put(ifp); 835 in6_dev_put(idev); 836 printk(KERN_INFO 837 "ipv6_create_tempaddr(): retry temporary address regeneration.\n"); 838 tmpaddr = &addr; 839 write_lock(&idev->lock); 840 goto retry; 841 } 842 843 spin_lock_bh(&ift->lock); 844 ift->ifpub = ifp; 845 ift->valid_lft = tmp_valid_lft; 846 ift->prefered_lft = tmp_prefered_lft; 847 ift->cstamp = tmp_cstamp; 848 ift->tstamp = tmp_tstamp; 849 spin_unlock_bh(&ift->lock); 850 851 addrconf_dad_start(ift, 0); 852 in6_ifa_put(ift); 853 in6_dev_put(idev); 854 out: 855 return ret; 856 } 857 #endif 858 859 /* 860 * Choose an appropriate source address (RFC3484) 861 */ 862 struct ipv6_saddr_score { 863 int addr_type; 864 unsigned int attrs; 865 int matchlen; 866 int scope; 867 unsigned int rule; 868 }; 869 870 #define IPV6_SADDR_SCORE_LOCAL 0x0001 871 #define IPV6_SADDR_SCORE_PREFERRED 0x0004 872 #define IPV6_SADDR_SCORE_HOA 0x0008 873 #define IPV6_SADDR_SCORE_OIF 0x0010 874 #define IPV6_SADDR_SCORE_LABEL 0x0020 875 #define IPV6_SADDR_SCORE_PRIVACY 0x0040 876 877 static inline int ipv6_saddr_preferred(int type) 878 { 879 if (type & (IPV6_ADDR_MAPPED|IPV6_ADDR_COMPATv4| 880 IPV6_ADDR_LOOPBACK|IPV6_ADDR_RESERVED)) 881 return 1; 882 return 0; 883 } 884 885 /* static matching label */ 886 static inline int ipv6_saddr_label(const struct in6_addr *addr, int type) 887 { 888 /* 889 * prefix (longest match) label 890 * ----------------------------- 891 * ::1/128 0 892 * ::/0 1 893 * 2002::/16 2 894 * ::/96 3 895 * ::ffff:0:0/96 4 896 * fc00::/7 5 897 * 2001::/32 6 898 */ 899 if (type & IPV6_ADDR_LOOPBACK) 900 return 0; 901 else if (type & IPV6_ADDR_COMPATv4) 902 return 3; 903 else if (type & IPV6_ADDR_MAPPED) 904 return 4; 905 else if (addr->s6_addr32[0] == htonl(0x20010000)) 906 return 6; 907 else if (addr->s6_addr16[0] == htons(0x2002)) 908 return 2; 909 else if ((addr->s6_addr[0] & 0xfe) == 0xfc) 910 return 5; 911 return 1; 912 } 913 914 int ipv6_dev_get_saddr(struct net_device *daddr_dev, 915 struct in6_addr *daddr, struct in6_addr *saddr) 916 { 917 struct ipv6_saddr_score hiscore; 918 struct inet6_ifaddr *ifa_result = NULL; 919 int daddr_type = __ipv6_addr_type(daddr); 920 int daddr_scope = __ipv6_addr_src_scope(daddr_type); 921 u32 daddr_label = ipv6_saddr_label(daddr, daddr_type); 922 struct net_device *dev; 923 924 memset(&hiscore, 0, sizeof(hiscore)); 925 926 read_lock(&dev_base_lock); 927 rcu_read_lock(); 928 929 for_each_netdev(&init_net, dev) { 930 struct inet6_dev *idev; 931 struct inet6_ifaddr *ifa; 932 933 /* Rule 0: Candidate Source Address (section 4) 934 * - multicast and link-local destination address, 935 * the set of candidate source address MUST only 936 * include addresses assigned to interfaces 937 * belonging to the same link as the outgoing 938 * interface. 939 * (- For site-local destination addresses, the 940 * set of candidate source addresses MUST only 941 * include addresses assigned to interfaces 942 * belonging to the same site as the outgoing 943 * interface.) 944 */ 945 if ((daddr_type & IPV6_ADDR_MULTICAST || 946 daddr_scope <= IPV6_ADDR_SCOPE_LINKLOCAL) && 947 daddr_dev && dev != daddr_dev) 948 continue; 949 950 idev = __in6_dev_get(dev); 951 if (!idev) 952 continue; 953 954 read_lock_bh(&idev->lock); 955 for (ifa = idev->addr_list; ifa; ifa = ifa->if_next) { 956 struct ipv6_saddr_score score; 957 958 score.addr_type = __ipv6_addr_type(&ifa->addr); 959 960 /* Rule 0: 961 * - Tentative Address (RFC2462 section 5.4) 962 * - A tentative address is not considered 963 * "assigned to an interface" in the traditional 964 * sense, unless it is also flagged as optimistic. 965 * - Candidate Source Address (section 4) 966 * - In any case, anycast addresses, multicast 967 * addresses, and the unspecified address MUST 968 * NOT be included in a candidate set. 969 */ 970 if ((ifa->flags & IFA_F_TENTATIVE) && 971 (!(ifa->flags & IFA_F_OPTIMISTIC))) 972 continue; 973 if (unlikely(score.addr_type == IPV6_ADDR_ANY || 974 score.addr_type & IPV6_ADDR_MULTICAST)) { 975 LIMIT_NETDEBUG(KERN_DEBUG 976 "ADDRCONF: unspecified / multicast address" 977 "assigned as unicast address on %s", 978 dev->name); 979 continue; 980 } 981 982 score.attrs = 0; 983 score.matchlen = 0; 984 score.scope = 0; 985 score.rule = 0; 986 987 if (ifa_result == NULL) { 988 /* record it if the first available entry */ 989 goto record_it; 990 } 991 992 /* Rule 1: Prefer same address */ 993 if (hiscore.rule < 1) { 994 if (ipv6_addr_equal(&ifa_result->addr, daddr)) 995 hiscore.attrs |= IPV6_SADDR_SCORE_LOCAL; 996 hiscore.rule++; 997 } 998 if (ipv6_addr_equal(&ifa->addr, daddr)) { 999 score.attrs |= IPV6_SADDR_SCORE_LOCAL; 1000 if (!(hiscore.attrs & IPV6_SADDR_SCORE_LOCAL)) { 1001 score.rule = 1; 1002 goto record_it; 1003 } 1004 } else { 1005 if (hiscore.attrs & IPV6_SADDR_SCORE_LOCAL) 1006 continue; 1007 } 1008 1009 /* Rule 2: Prefer appropriate scope */ 1010 if (hiscore.rule < 2) { 1011 hiscore.scope = __ipv6_addr_src_scope(hiscore.addr_type); 1012 hiscore.rule++; 1013 } 1014 score.scope = __ipv6_addr_src_scope(score.addr_type); 1015 if (hiscore.scope < score.scope) { 1016 if (hiscore.scope < daddr_scope) { 1017 score.rule = 2; 1018 goto record_it; 1019 } else 1020 continue; 1021 } else if (score.scope < hiscore.scope) { 1022 if (score.scope < daddr_scope) 1023 break; /* addresses sorted by scope */ 1024 else { 1025 score.rule = 2; 1026 goto record_it; 1027 } 1028 } 1029 1030 /* Rule 3: Avoid deprecated and optimistic addresses */ 1031 if (hiscore.rule < 3) { 1032 if (ipv6_saddr_preferred(hiscore.addr_type) || 1033 (((ifa_result->flags & 1034 (IFA_F_DEPRECATED|IFA_F_OPTIMISTIC)) == 0))) 1035 hiscore.attrs |= IPV6_SADDR_SCORE_PREFERRED; 1036 hiscore.rule++; 1037 } 1038 if (ipv6_saddr_preferred(score.addr_type) || 1039 (((ifa->flags & 1040 (IFA_F_DEPRECATED|IFA_F_OPTIMISTIC)) == 0))) { 1041 score.attrs |= IPV6_SADDR_SCORE_PREFERRED; 1042 if (!(hiscore.attrs & IPV6_SADDR_SCORE_PREFERRED)) { 1043 score.rule = 3; 1044 goto record_it; 1045 } 1046 } else { 1047 if (hiscore.attrs & IPV6_SADDR_SCORE_PREFERRED) 1048 continue; 1049 } 1050 1051 /* Rule 4: Prefer home address */ 1052 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE) 1053 if (hiscore.rule < 4) { 1054 if (ifa_result->flags & IFA_F_HOMEADDRESS) 1055 hiscore.attrs |= IPV6_SADDR_SCORE_HOA; 1056 hiscore.rule++; 1057 } 1058 if (ifa->flags & IFA_F_HOMEADDRESS) { 1059 score.attrs |= IPV6_SADDR_SCORE_HOA; 1060 if (!(ifa_result->flags & IFA_F_HOMEADDRESS)) { 1061 score.rule = 4; 1062 goto record_it; 1063 } 1064 } else { 1065 if (hiscore.attrs & IPV6_SADDR_SCORE_HOA) 1066 continue; 1067 } 1068 #else 1069 if (hiscore.rule < 4) 1070 hiscore.rule++; 1071 #endif 1072 1073 /* Rule 5: Prefer outgoing interface */ 1074 if (hiscore.rule < 5) { 1075 if (daddr_dev == NULL || 1076 daddr_dev == ifa_result->idev->dev) 1077 hiscore.attrs |= IPV6_SADDR_SCORE_OIF; 1078 hiscore.rule++; 1079 } 1080 if (daddr_dev == NULL || 1081 daddr_dev == ifa->idev->dev) { 1082 score.attrs |= IPV6_SADDR_SCORE_OIF; 1083 if (!(hiscore.attrs & IPV6_SADDR_SCORE_OIF)) { 1084 score.rule = 5; 1085 goto record_it; 1086 } 1087 } else { 1088 if (hiscore.attrs & IPV6_SADDR_SCORE_OIF) 1089 continue; 1090 } 1091 1092 /* Rule 6: Prefer matching label */ 1093 if (hiscore.rule < 6) { 1094 if (ipv6_saddr_label(&ifa_result->addr, hiscore.addr_type) == daddr_label) 1095 hiscore.attrs |= IPV6_SADDR_SCORE_LABEL; 1096 hiscore.rule++; 1097 } 1098 if (ipv6_saddr_label(&ifa->addr, score.addr_type) == daddr_label) { 1099 score.attrs |= IPV6_SADDR_SCORE_LABEL; 1100 if (!(hiscore.attrs & IPV6_SADDR_SCORE_LABEL)) { 1101 score.rule = 6; 1102 goto record_it; 1103 } 1104 } else { 1105 if (hiscore.attrs & IPV6_SADDR_SCORE_LABEL) 1106 continue; 1107 } 1108 1109 #ifdef CONFIG_IPV6_PRIVACY 1110 /* Rule 7: Prefer public address 1111 * Note: prefer temprary address if use_tempaddr >= 2 1112 */ 1113 if (hiscore.rule < 7) { 1114 if ((!(ifa_result->flags & IFA_F_TEMPORARY)) ^ 1115 (ifa_result->idev->cnf.use_tempaddr >= 2)) 1116 hiscore.attrs |= IPV6_SADDR_SCORE_PRIVACY; 1117 hiscore.rule++; 1118 } 1119 if ((!(ifa->flags & IFA_F_TEMPORARY)) ^ 1120 (ifa->idev->cnf.use_tempaddr >= 2)) { 1121 score.attrs |= IPV6_SADDR_SCORE_PRIVACY; 1122 if (!(hiscore.attrs & IPV6_SADDR_SCORE_PRIVACY)) { 1123 score.rule = 7; 1124 goto record_it; 1125 } 1126 } else { 1127 if (hiscore.attrs & IPV6_SADDR_SCORE_PRIVACY) 1128 continue; 1129 } 1130 #else 1131 if (hiscore.rule < 7) 1132 hiscore.rule++; 1133 #endif 1134 /* Rule 8: Use longest matching prefix */ 1135 if (hiscore.rule < 8) { 1136 hiscore.matchlen = ipv6_addr_diff(&ifa_result->addr, daddr); 1137 hiscore.rule++; 1138 } 1139 score.matchlen = ipv6_addr_diff(&ifa->addr, daddr); 1140 if (score.matchlen > hiscore.matchlen) { 1141 score.rule = 8; 1142 goto record_it; 1143 } 1144 #if 0 1145 else if (score.matchlen < hiscore.matchlen) 1146 continue; 1147 #endif 1148 1149 /* Final Rule: choose first available one */ 1150 continue; 1151 record_it: 1152 if (ifa_result) 1153 in6_ifa_put(ifa_result); 1154 in6_ifa_hold(ifa); 1155 ifa_result = ifa; 1156 hiscore = score; 1157 } 1158 read_unlock_bh(&idev->lock); 1159 } 1160 rcu_read_unlock(); 1161 read_unlock(&dev_base_lock); 1162 1163 if (!ifa_result) 1164 return -EADDRNOTAVAIL; 1165 1166 ipv6_addr_copy(saddr, &ifa_result->addr); 1167 in6_ifa_put(ifa_result); 1168 return 0; 1169 } 1170 1171 1172 int ipv6_get_saddr(struct dst_entry *dst, 1173 struct in6_addr *daddr, struct in6_addr *saddr) 1174 { 1175 return ipv6_dev_get_saddr(dst ? ip6_dst_idev(dst)->dev : NULL, daddr, saddr); 1176 } 1177 1178 EXPORT_SYMBOL(ipv6_get_saddr); 1179 1180 int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr, 1181 unsigned char banned_flags) 1182 { 1183 struct inet6_dev *idev; 1184 int err = -EADDRNOTAVAIL; 1185 1186 rcu_read_lock(); 1187 if ((idev = __in6_dev_get(dev)) != NULL) { 1188 struct inet6_ifaddr *ifp; 1189 1190 read_lock_bh(&idev->lock); 1191 for (ifp=idev->addr_list; ifp; ifp=ifp->if_next) { 1192 if (ifp->scope == IFA_LINK && !(ifp->flags & banned_flags)) { 1193 ipv6_addr_copy(addr, &ifp->addr); 1194 err = 0; 1195 break; 1196 } 1197 } 1198 read_unlock_bh(&idev->lock); 1199 } 1200 rcu_read_unlock(); 1201 return err; 1202 } 1203 1204 static int ipv6_count_addresses(struct inet6_dev *idev) 1205 { 1206 int cnt = 0; 1207 struct inet6_ifaddr *ifp; 1208 1209 read_lock_bh(&idev->lock); 1210 for (ifp=idev->addr_list; ifp; ifp=ifp->if_next) 1211 cnt++; 1212 read_unlock_bh(&idev->lock); 1213 return cnt; 1214 } 1215 1216 int ipv6_chk_addr(struct in6_addr *addr, struct net_device *dev, int strict) 1217 { 1218 struct inet6_ifaddr * ifp; 1219 u8 hash = ipv6_addr_hash(addr); 1220 1221 read_lock_bh(&addrconf_hash_lock); 1222 for(ifp = inet6_addr_lst[hash]; ifp; ifp=ifp->lst_next) { 1223 if (ipv6_addr_equal(&ifp->addr, addr) && 1224 !(ifp->flags&IFA_F_TENTATIVE)) { 1225 if (dev == NULL || ifp->idev->dev == dev || 1226 !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) 1227 break; 1228 } 1229 } 1230 read_unlock_bh(&addrconf_hash_lock); 1231 return ifp != NULL; 1232 } 1233 1234 EXPORT_SYMBOL(ipv6_chk_addr); 1235 1236 static 1237 int ipv6_chk_same_addr(const struct in6_addr *addr, struct net_device *dev) 1238 { 1239 struct inet6_ifaddr * ifp; 1240 u8 hash = ipv6_addr_hash(addr); 1241 1242 for(ifp = inet6_addr_lst[hash]; ifp; ifp=ifp->lst_next) { 1243 if (ipv6_addr_equal(&ifp->addr, addr)) { 1244 if (dev == NULL || ifp->idev->dev == dev) 1245 break; 1246 } 1247 } 1248 return ifp != NULL; 1249 } 1250 1251 struct inet6_ifaddr * ipv6_get_ifaddr(struct in6_addr *addr, struct net_device *dev, int strict) 1252 { 1253 struct inet6_ifaddr * ifp; 1254 u8 hash = ipv6_addr_hash(addr); 1255 1256 read_lock_bh(&addrconf_hash_lock); 1257 for(ifp = inet6_addr_lst[hash]; ifp; ifp=ifp->lst_next) { 1258 if (ipv6_addr_equal(&ifp->addr, addr)) { 1259 if (dev == NULL || ifp->idev->dev == dev || 1260 !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) { 1261 in6_ifa_hold(ifp); 1262 break; 1263 } 1264 } 1265 } 1266 read_unlock_bh(&addrconf_hash_lock); 1267 1268 return ifp; 1269 } 1270 1271 int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2) 1272 { 1273 const struct in6_addr *sk_rcv_saddr6 = &inet6_sk(sk)->rcv_saddr; 1274 const struct in6_addr *sk2_rcv_saddr6 = inet6_rcv_saddr(sk2); 1275 __be32 sk_rcv_saddr = inet_sk(sk)->rcv_saddr; 1276 __be32 sk2_rcv_saddr = inet_rcv_saddr(sk2); 1277 int sk_ipv6only = ipv6_only_sock(sk); 1278 int sk2_ipv6only = inet_v6_ipv6only(sk2); 1279 int addr_type = ipv6_addr_type(sk_rcv_saddr6); 1280 int addr_type2 = sk2_rcv_saddr6 ? ipv6_addr_type(sk2_rcv_saddr6) : IPV6_ADDR_MAPPED; 1281 1282 if (!sk2_rcv_saddr && !sk_ipv6only) 1283 return 1; 1284 1285 if (addr_type2 == IPV6_ADDR_ANY && 1286 !(sk2_ipv6only && addr_type == IPV6_ADDR_MAPPED)) 1287 return 1; 1288 1289 if (addr_type == IPV6_ADDR_ANY && 1290 !(sk_ipv6only && addr_type2 == IPV6_ADDR_MAPPED)) 1291 return 1; 1292 1293 if (sk2_rcv_saddr6 && 1294 ipv6_addr_equal(sk_rcv_saddr6, sk2_rcv_saddr6)) 1295 return 1; 1296 1297 if (addr_type == IPV6_ADDR_MAPPED && 1298 !sk2_ipv6only && 1299 (!sk2_rcv_saddr || !sk_rcv_saddr || sk_rcv_saddr == sk2_rcv_saddr)) 1300 return 1; 1301 1302 return 0; 1303 } 1304 1305 /* Gets referenced address, destroys ifaddr */ 1306 1307 static void addrconf_dad_stop(struct inet6_ifaddr *ifp) 1308 { 1309 if (ifp->flags&IFA_F_PERMANENT) { 1310 spin_lock_bh(&ifp->lock); 1311 addrconf_del_timer(ifp); 1312 ifp->flags |= IFA_F_TENTATIVE; 1313 spin_unlock_bh(&ifp->lock); 1314 in6_ifa_put(ifp); 1315 #ifdef CONFIG_IPV6_PRIVACY 1316 } else if (ifp->flags&IFA_F_TEMPORARY) { 1317 struct inet6_ifaddr *ifpub; 1318 spin_lock_bh(&ifp->lock); 1319 ifpub = ifp->ifpub; 1320 if (ifpub) { 1321 in6_ifa_hold(ifpub); 1322 spin_unlock_bh(&ifp->lock); 1323 ipv6_create_tempaddr(ifpub, ifp); 1324 in6_ifa_put(ifpub); 1325 } else { 1326 spin_unlock_bh(&ifp->lock); 1327 } 1328 ipv6_del_addr(ifp); 1329 #endif 1330 } else 1331 ipv6_del_addr(ifp); 1332 } 1333 1334 void addrconf_dad_failure(struct inet6_ifaddr *ifp) 1335 { 1336 if (net_ratelimit()) 1337 printk(KERN_INFO "%s: duplicate address detected!\n", ifp->idev->dev->name); 1338 addrconf_dad_stop(ifp); 1339 } 1340 1341 /* Join to solicited addr multicast group. */ 1342 1343 void addrconf_join_solict(struct net_device *dev, struct in6_addr *addr) 1344 { 1345 struct in6_addr maddr; 1346 1347 if (dev->flags&(IFF_LOOPBACK|IFF_NOARP)) 1348 return; 1349 1350 addrconf_addr_solict_mult(addr, &maddr); 1351 ipv6_dev_mc_inc(dev, &maddr); 1352 } 1353 1354 void addrconf_leave_solict(struct inet6_dev *idev, struct in6_addr *addr) 1355 { 1356 struct in6_addr maddr; 1357 1358 if (idev->dev->flags&(IFF_LOOPBACK|IFF_NOARP)) 1359 return; 1360 1361 addrconf_addr_solict_mult(addr, &maddr); 1362 __ipv6_dev_mc_dec(idev, &maddr); 1363 } 1364 1365 static void addrconf_join_anycast(struct inet6_ifaddr *ifp) 1366 { 1367 struct in6_addr addr; 1368 ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len); 1369 if (ipv6_addr_any(&addr)) 1370 return; 1371 ipv6_dev_ac_inc(ifp->idev->dev, &addr); 1372 } 1373 1374 static void addrconf_leave_anycast(struct inet6_ifaddr *ifp) 1375 { 1376 struct in6_addr addr; 1377 ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len); 1378 if (ipv6_addr_any(&addr)) 1379 return; 1380 __ipv6_dev_ac_dec(ifp->idev, &addr); 1381 } 1382 1383 static int addrconf_ifid_eui48(u8 *eui, struct net_device *dev) 1384 { 1385 if (dev->addr_len != ETH_ALEN) 1386 return -1; 1387 memcpy(eui, dev->dev_addr, 3); 1388 memcpy(eui + 5, dev->dev_addr + 3, 3); 1389 1390 /* 1391 * The zSeries OSA network cards can be shared among various 1392 * OS instances, but the OSA cards have only one MAC address. 1393 * This leads to duplicate address conflicts in conjunction 1394 * with IPv6 if more than one instance uses the same card. 1395 * 1396 * The driver for these cards can deliver a unique 16-bit 1397 * identifier for each instance sharing the same card. It is 1398 * placed instead of 0xFFFE in the interface identifier. The 1399 * "u" bit of the interface identifier is not inverted in this 1400 * case. Hence the resulting interface identifier has local 1401 * scope according to RFC2373. 1402 */ 1403 if (dev->dev_id) { 1404 eui[3] = (dev->dev_id >> 8) & 0xFF; 1405 eui[4] = dev->dev_id & 0xFF; 1406 } else { 1407 eui[3] = 0xFF; 1408 eui[4] = 0xFE; 1409 eui[0] ^= 2; 1410 } 1411 return 0; 1412 } 1413 1414 static int addrconf_ifid_arcnet(u8 *eui, struct net_device *dev) 1415 { 1416 /* XXX: inherit EUI-64 from other interface -- yoshfuji */ 1417 if (dev->addr_len != ARCNET_ALEN) 1418 return -1; 1419 memset(eui, 0, 7); 1420 eui[7] = *(u8*)dev->dev_addr; 1421 return 0; 1422 } 1423 1424 static int addrconf_ifid_infiniband(u8 *eui, struct net_device *dev) 1425 { 1426 if (dev->addr_len != INFINIBAND_ALEN) 1427 return -1; 1428 memcpy(eui, dev->dev_addr + 12, 8); 1429 eui[0] |= 2; 1430 return 0; 1431 } 1432 1433 static int ipv6_generate_eui64(u8 *eui, struct net_device *dev) 1434 { 1435 switch (dev->type) { 1436 case ARPHRD_ETHER: 1437 case ARPHRD_FDDI: 1438 case ARPHRD_IEEE802_TR: 1439 return addrconf_ifid_eui48(eui, dev); 1440 case ARPHRD_ARCNET: 1441 return addrconf_ifid_arcnet(eui, dev); 1442 case ARPHRD_INFINIBAND: 1443 return addrconf_ifid_infiniband(eui, dev); 1444 } 1445 return -1; 1446 } 1447 1448 static int ipv6_inherit_eui64(u8 *eui, struct inet6_dev *idev) 1449 { 1450 int err = -1; 1451 struct inet6_ifaddr *ifp; 1452 1453 read_lock_bh(&idev->lock); 1454 for (ifp=idev->addr_list; ifp; ifp=ifp->if_next) { 1455 if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) { 1456 memcpy(eui, ifp->addr.s6_addr+8, 8); 1457 err = 0; 1458 break; 1459 } 1460 } 1461 read_unlock_bh(&idev->lock); 1462 return err; 1463 } 1464 1465 #ifdef CONFIG_IPV6_PRIVACY 1466 /* (re)generation of randomized interface identifier (RFC 3041 3.2, 3.5) */ 1467 static int __ipv6_regen_rndid(struct inet6_dev *idev) 1468 { 1469 regen: 1470 get_random_bytes(idev->rndid, sizeof(idev->rndid)); 1471 idev->rndid[0] &= ~0x02; 1472 1473 /* 1474 * <draft-ietf-ipngwg-temp-addresses-v2-00.txt>: 1475 * check if generated address is not inappropriate 1476 * 1477 * - Reserved subnet anycast (RFC 2526) 1478 * 11111101 11....11 1xxxxxxx 1479 * - ISATAP (draft-ietf-ngtrans-isatap-13.txt) 5.1 1480 * 00-00-5E-FE-xx-xx-xx-xx 1481 * - value 0 1482 * - XXX: already assigned to an address on the device 1483 */ 1484 if (idev->rndid[0] == 0xfd && 1485 (idev->rndid[1]&idev->rndid[2]&idev->rndid[3]&idev->rndid[4]&idev->rndid[5]&idev->rndid[6]) == 0xff && 1486 (idev->rndid[7]&0x80)) 1487 goto regen; 1488 if ((idev->rndid[0]|idev->rndid[1]) == 0) { 1489 if (idev->rndid[2] == 0x5e && idev->rndid[3] == 0xfe) 1490 goto regen; 1491 if ((idev->rndid[2]|idev->rndid[3]|idev->rndid[4]|idev->rndid[5]|idev->rndid[6]|idev->rndid[7]) == 0x00) 1492 goto regen; 1493 } 1494 1495 return 0; 1496 } 1497 1498 static void ipv6_regen_rndid(unsigned long data) 1499 { 1500 struct inet6_dev *idev = (struct inet6_dev *) data; 1501 unsigned long expires; 1502 1503 rcu_read_lock_bh(); 1504 write_lock_bh(&idev->lock); 1505 1506 if (idev->dead) 1507 goto out; 1508 1509 if (__ipv6_regen_rndid(idev) < 0) 1510 goto out; 1511 1512 expires = jiffies + 1513 idev->cnf.temp_prefered_lft * HZ - 1514 idev->cnf.regen_max_retry * idev->cnf.dad_transmits * idev->nd_parms->retrans_time - desync_factor; 1515 if (time_before(expires, jiffies)) { 1516 printk(KERN_WARNING 1517 "ipv6_regen_rndid(): too short regeneration interval; timer disabled for %s.\n", 1518 idev->dev->name); 1519 goto out; 1520 } 1521 1522 if (!mod_timer(&idev->regen_timer, expires)) 1523 in6_dev_hold(idev); 1524 1525 out: 1526 write_unlock_bh(&idev->lock); 1527 rcu_read_unlock_bh(); 1528 in6_dev_put(idev); 1529 } 1530 1531 static int __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr) { 1532 int ret = 0; 1533 1534 if (tmpaddr && memcmp(idev->rndid, &tmpaddr->s6_addr[8], 8) == 0) 1535 ret = __ipv6_regen_rndid(idev); 1536 return ret; 1537 } 1538 #endif 1539 1540 /* 1541 * Add prefix route. 1542 */ 1543 1544 static void 1545 addrconf_prefix_route(struct in6_addr *pfx, int plen, struct net_device *dev, 1546 unsigned long expires, u32 flags) 1547 { 1548 struct fib6_config cfg = { 1549 .fc_table = RT6_TABLE_PREFIX, 1550 .fc_metric = IP6_RT_PRIO_ADDRCONF, 1551 .fc_ifindex = dev->ifindex, 1552 .fc_expires = expires, 1553 .fc_dst_len = plen, 1554 .fc_flags = RTF_UP | flags, 1555 }; 1556 1557 ipv6_addr_copy(&cfg.fc_dst, pfx); 1558 1559 /* Prevent useless cloning on PtP SIT. 1560 This thing is done here expecting that the whole 1561 class of non-broadcast devices need not cloning. 1562 */ 1563 #if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE) 1564 if (dev->type == ARPHRD_SIT && (dev->flags & IFF_POINTOPOINT)) 1565 cfg.fc_flags |= RTF_NONEXTHOP; 1566 #endif 1567 1568 ip6_route_add(&cfg); 1569 } 1570 1571 /* Create "default" multicast route to the interface */ 1572 1573 static void addrconf_add_mroute(struct net_device *dev) 1574 { 1575 struct fib6_config cfg = { 1576 .fc_table = RT6_TABLE_LOCAL, 1577 .fc_metric = IP6_RT_PRIO_ADDRCONF, 1578 .fc_ifindex = dev->ifindex, 1579 .fc_dst_len = 8, 1580 .fc_flags = RTF_UP, 1581 }; 1582 1583 ipv6_addr_set(&cfg.fc_dst, htonl(0xFF000000), 0, 0, 0); 1584 1585 ip6_route_add(&cfg); 1586 } 1587 1588 #if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE) 1589 static void sit_route_add(struct net_device *dev) 1590 { 1591 struct fib6_config cfg = { 1592 .fc_table = RT6_TABLE_MAIN, 1593 .fc_metric = IP6_RT_PRIO_ADDRCONF, 1594 .fc_ifindex = dev->ifindex, 1595 .fc_dst_len = 96, 1596 .fc_flags = RTF_UP | RTF_NONEXTHOP, 1597 }; 1598 1599 /* prefix length - 96 bits "::d.d.d.d" */ 1600 ip6_route_add(&cfg); 1601 } 1602 #endif 1603 1604 static void addrconf_add_lroute(struct net_device *dev) 1605 { 1606 struct in6_addr addr; 1607 1608 ipv6_addr_set(&addr, htonl(0xFE800000), 0, 0, 0); 1609 addrconf_prefix_route(&addr, 64, dev, 0, 0); 1610 } 1611 1612 static struct inet6_dev *addrconf_add_dev(struct net_device *dev) 1613 { 1614 struct inet6_dev *idev; 1615 1616 ASSERT_RTNL(); 1617 1618 if ((idev = ipv6_find_idev(dev)) == NULL) 1619 return NULL; 1620 1621 /* Add default multicast route */ 1622 addrconf_add_mroute(dev); 1623 1624 /* Add link local route */ 1625 addrconf_add_lroute(dev); 1626 return idev; 1627 } 1628 1629 void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len) 1630 { 1631 struct prefix_info *pinfo; 1632 __u32 valid_lft; 1633 __u32 prefered_lft; 1634 int addr_type; 1635 unsigned long rt_expires; 1636 struct inet6_dev *in6_dev; 1637 1638 pinfo = (struct prefix_info *) opt; 1639 1640 if (len < sizeof(struct prefix_info)) { 1641 ADBG(("addrconf: prefix option too short\n")); 1642 return; 1643 } 1644 1645 /* 1646 * Validation checks ([ADDRCONF], page 19) 1647 */ 1648 1649 addr_type = ipv6_addr_type(&pinfo->prefix); 1650 1651 if (addr_type & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL)) 1652 return; 1653 1654 valid_lft = ntohl(pinfo->valid); 1655 prefered_lft = ntohl(pinfo->prefered); 1656 1657 if (prefered_lft > valid_lft) { 1658 if (net_ratelimit()) 1659 printk(KERN_WARNING "addrconf: prefix option has invalid lifetime\n"); 1660 return; 1661 } 1662 1663 in6_dev = in6_dev_get(dev); 1664 1665 if (in6_dev == NULL) { 1666 if (net_ratelimit()) 1667 printk(KERN_DEBUG "addrconf: device %s not configured\n", dev->name); 1668 return; 1669 } 1670 1671 /* 1672 * Two things going on here: 1673 * 1) Add routes for on-link prefixes 1674 * 2) Configure prefixes with the auto flag set 1675 */ 1676 1677 /* Avoid arithmetic overflow. Really, we could 1678 save rt_expires in seconds, likely valid_lft, 1679 but it would require division in fib gc, that it 1680 not good. 1681 */ 1682 if (valid_lft >= 0x7FFFFFFF/HZ) 1683 rt_expires = 0x7FFFFFFF - (0x7FFFFFFF % HZ); 1684 else 1685 rt_expires = valid_lft * HZ; 1686 1687 /* 1688 * We convert this (in jiffies) to clock_t later. 1689 * Avoid arithmetic overflow there as well. 1690 * Overflow can happen only if HZ < USER_HZ. 1691 */ 1692 if (HZ < USER_HZ && rt_expires > 0x7FFFFFFF / USER_HZ) 1693 rt_expires = 0x7FFFFFFF / USER_HZ; 1694 1695 if (pinfo->onlink) { 1696 struct rt6_info *rt; 1697 rt = rt6_lookup(&pinfo->prefix, NULL, dev->ifindex, 1); 1698 1699 if (rt && ((rt->rt6i_flags & (RTF_GATEWAY | RTF_DEFAULT)) == 0)) { 1700 if (rt->rt6i_flags&RTF_EXPIRES) { 1701 if (valid_lft == 0) { 1702 ip6_del_rt(rt); 1703 rt = NULL; 1704 } else { 1705 rt->rt6i_expires = jiffies + rt_expires; 1706 } 1707 } 1708 } else if (valid_lft) { 1709 addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len, 1710 dev, jiffies_to_clock_t(rt_expires), RTF_ADDRCONF|RTF_EXPIRES|RTF_PREFIX_RT); 1711 } 1712 if (rt) 1713 dst_release(&rt->u.dst); 1714 } 1715 1716 /* Try to figure out our local address for this prefix */ 1717 1718 if (pinfo->autoconf && in6_dev->cnf.autoconf) { 1719 struct inet6_ifaddr * ifp; 1720 struct in6_addr addr; 1721 int create = 0, update_lft = 0; 1722 1723 if (pinfo->prefix_len == 64) { 1724 memcpy(&addr, &pinfo->prefix, 8); 1725 if (ipv6_generate_eui64(addr.s6_addr + 8, dev) && 1726 ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) { 1727 in6_dev_put(in6_dev); 1728 return; 1729 } 1730 goto ok; 1731 } 1732 if (net_ratelimit()) 1733 printk(KERN_DEBUG "IPv6 addrconf: prefix with wrong length %d\n", 1734 pinfo->prefix_len); 1735 in6_dev_put(in6_dev); 1736 return; 1737 1738 ok: 1739 1740 ifp = ipv6_get_ifaddr(&addr, dev, 1); 1741 1742 if (ifp == NULL && valid_lft) { 1743 int max_addresses = in6_dev->cnf.max_addresses; 1744 u32 addr_flags = 0; 1745 1746 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 1747 if (in6_dev->cnf.optimistic_dad && 1748 !ipv6_devconf.forwarding) 1749 addr_flags = IFA_F_OPTIMISTIC; 1750 #endif 1751 1752 /* Do not allow to create too much of autoconfigured 1753 * addresses; this would be too easy way to crash kernel. 1754 */ 1755 if (!max_addresses || 1756 ipv6_count_addresses(in6_dev) < max_addresses) 1757 ifp = ipv6_add_addr(in6_dev, &addr, pinfo->prefix_len, 1758 addr_type&IPV6_ADDR_SCOPE_MASK, 1759 addr_flags); 1760 1761 if (!ifp || IS_ERR(ifp)) { 1762 in6_dev_put(in6_dev); 1763 return; 1764 } 1765 1766 update_lft = create = 1; 1767 ifp->cstamp = jiffies; 1768 addrconf_dad_start(ifp, RTF_ADDRCONF|RTF_PREFIX_RT); 1769 } 1770 1771 if (ifp) { 1772 int flags; 1773 unsigned long now; 1774 #ifdef CONFIG_IPV6_PRIVACY 1775 struct inet6_ifaddr *ift; 1776 #endif 1777 u32 stored_lft; 1778 1779 /* update lifetime (RFC2462 5.5.3 e) */ 1780 spin_lock(&ifp->lock); 1781 now = jiffies; 1782 if (ifp->valid_lft > (now - ifp->tstamp) / HZ) 1783 stored_lft = ifp->valid_lft - (now - ifp->tstamp) / HZ; 1784 else 1785 stored_lft = 0; 1786 if (!update_lft && stored_lft) { 1787 if (valid_lft > MIN_VALID_LIFETIME || 1788 valid_lft > stored_lft) 1789 update_lft = 1; 1790 else if (stored_lft <= MIN_VALID_LIFETIME) { 1791 /* valid_lft <= stored_lft is always true */ 1792 /* XXX: IPsec */ 1793 update_lft = 0; 1794 } else { 1795 valid_lft = MIN_VALID_LIFETIME; 1796 if (valid_lft < prefered_lft) 1797 prefered_lft = valid_lft; 1798 update_lft = 1; 1799 } 1800 } 1801 1802 if (update_lft) { 1803 ifp->valid_lft = valid_lft; 1804 ifp->prefered_lft = prefered_lft; 1805 ifp->tstamp = now; 1806 flags = ifp->flags; 1807 ifp->flags &= ~IFA_F_DEPRECATED; 1808 spin_unlock(&ifp->lock); 1809 1810 if (!(flags&IFA_F_TENTATIVE)) 1811 ipv6_ifa_notify(0, ifp); 1812 } else 1813 spin_unlock(&ifp->lock); 1814 1815 #ifdef CONFIG_IPV6_PRIVACY 1816 read_lock_bh(&in6_dev->lock); 1817 /* update all temporary addresses in the list */ 1818 for (ift=in6_dev->tempaddr_list; ift; ift=ift->tmp_next) { 1819 /* 1820 * When adjusting the lifetimes of an existing 1821 * temporary address, only lower the lifetimes. 1822 * Implementations must not increase the 1823 * lifetimes of an existing temporary address 1824 * when processing a Prefix Information Option. 1825 */ 1826 spin_lock(&ift->lock); 1827 flags = ift->flags; 1828 if (ift->valid_lft > valid_lft && 1829 ift->valid_lft - valid_lft > (jiffies - ift->tstamp) / HZ) 1830 ift->valid_lft = valid_lft + (jiffies - ift->tstamp) / HZ; 1831 if (ift->prefered_lft > prefered_lft && 1832 ift->prefered_lft - prefered_lft > (jiffies - ift->tstamp) / HZ) 1833 ift->prefered_lft = prefered_lft + (jiffies - ift->tstamp) / HZ; 1834 spin_unlock(&ift->lock); 1835 if (!(flags&IFA_F_TENTATIVE)) 1836 ipv6_ifa_notify(0, ift); 1837 } 1838 1839 if (create && in6_dev->cnf.use_tempaddr > 0) { 1840 /* 1841 * When a new public address is created as described in [ADDRCONF], 1842 * also create a new temporary address. 1843 */ 1844 read_unlock_bh(&in6_dev->lock); 1845 ipv6_create_tempaddr(ifp, NULL); 1846 } else { 1847 read_unlock_bh(&in6_dev->lock); 1848 } 1849 #endif 1850 in6_ifa_put(ifp); 1851 addrconf_verify(0); 1852 } 1853 } 1854 inet6_prefix_notify(RTM_NEWPREFIX, in6_dev, pinfo); 1855 in6_dev_put(in6_dev); 1856 } 1857 1858 /* 1859 * Set destination address. 1860 * Special case for SIT interfaces where we create a new "virtual" 1861 * device. 1862 */ 1863 int addrconf_set_dstaddr(void __user *arg) 1864 { 1865 struct in6_ifreq ireq; 1866 struct net_device *dev; 1867 int err = -EINVAL; 1868 1869 rtnl_lock(); 1870 1871 err = -EFAULT; 1872 if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq))) 1873 goto err_exit; 1874 1875 dev = __dev_get_by_index(&init_net, ireq.ifr6_ifindex); 1876 1877 err = -ENODEV; 1878 if (dev == NULL) 1879 goto err_exit; 1880 1881 #if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE) 1882 if (dev->type == ARPHRD_SIT) { 1883 struct ifreq ifr; 1884 mm_segment_t oldfs; 1885 struct ip_tunnel_parm p; 1886 1887 err = -EADDRNOTAVAIL; 1888 if (!(ipv6_addr_type(&ireq.ifr6_addr) & IPV6_ADDR_COMPATv4)) 1889 goto err_exit; 1890 1891 memset(&p, 0, sizeof(p)); 1892 p.iph.daddr = ireq.ifr6_addr.s6_addr32[3]; 1893 p.iph.saddr = 0; 1894 p.iph.version = 4; 1895 p.iph.ihl = 5; 1896 p.iph.protocol = IPPROTO_IPV6; 1897 p.iph.ttl = 64; 1898 ifr.ifr_ifru.ifru_data = (void __user *)&p; 1899 1900 oldfs = get_fs(); set_fs(KERNEL_DS); 1901 err = dev->do_ioctl(dev, &ifr, SIOCADDTUNNEL); 1902 set_fs(oldfs); 1903 1904 if (err == 0) { 1905 err = -ENOBUFS; 1906 if ((dev = __dev_get_by_name(&init_net, p.name)) == NULL) 1907 goto err_exit; 1908 err = dev_open(dev); 1909 } 1910 } 1911 #endif 1912 1913 err_exit: 1914 rtnl_unlock(); 1915 return err; 1916 } 1917 1918 /* 1919 * Manual configuration of address on an interface 1920 */ 1921 static int inet6_addr_add(int ifindex, struct in6_addr *pfx, int plen, 1922 __u8 ifa_flags, __u32 prefered_lft, __u32 valid_lft) 1923 { 1924 struct inet6_ifaddr *ifp; 1925 struct inet6_dev *idev; 1926 struct net_device *dev; 1927 int scope; 1928 u32 flags = RTF_EXPIRES; 1929 1930 ASSERT_RTNL(); 1931 1932 /* check the lifetime */ 1933 if (!valid_lft || prefered_lft > valid_lft) 1934 return -EINVAL; 1935 1936 if ((dev = __dev_get_by_index(&init_net, ifindex)) == NULL) 1937 return -ENODEV; 1938 1939 if ((idev = addrconf_add_dev(dev)) == NULL) 1940 return -ENOBUFS; 1941 1942 scope = ipv6_addr_scope(pfx); 1943 1944 if (valid_lft == INFINITY_LIFE_TIME) { 1945 ifa_flags |= IFA_F_PERMANENT; 1946 flags = 0; 1947 } else if (valid_lft >= 0x7FFFFFFF/HZ) 1948 valid_lft = 0x7FFFFFFF/HZ; 1949 1950 if (prefered_lft == 0) 1951 ifa_flags |= IFA_F_DEPRECATED; 1952 else if ((prefered_lft >= 0x7FFFFFFF/HZ) && 1953 (prefered_lft != INFINITY_LIFE_TIME)) 1954 prefered_lft = 0x7FFFFFFF/HZ; 1955 1956 ifp = ipv6_add_addr(idev, pfx, plen, scope, ifa_flags); 1957 1958 if (!IS_ERR(ifp)) { 1959 spin_lock_bh(&ifp->lock); 1960 ifp->valid_lft = valid_lft; 1961 ifp->prefered_lft = prefered_lft; 1962 ifp->tstamp = jiffies; 1963 spin_unlock_bh(&ifp->lock); 1964 1965 addrconf_prefix_route(&ifp->addr, ifp->prefix_len, dev, 1966 jiffies_to_clock_t(valid_lft * HZ), flags); 1967 /* 1968 * Note that section 3.1 of RFC 4429 indicates 1969 * that the Optimistic flag should not be set for 1970 * manually configured addresses 1971 */ 1972 addrconf_dad_start(ifp, 0); 1973 in6_ifa_put(ifp); 1974 addrconf_verify(0); 1975 return 0; 1976 } 1977 1978 return PTR_ERR(ifp); 1979 } 1980 1981 static int inet6_addr_del(int ifindex, struct in6_addr *pfx, int plen) 1982 { 1983 struct inet6_ifaddr *ifp; 1984 struct inet6_dev *idev; 1985 struct net_device *dev; 1986 1987 if ((dev = __dev_get_by_index(&init_net, ifindex)) == NULL) 1988 return -ENODEV; 1989 1990 if ((idev = __in6_dev_get(dev)) == NULL) 1991 return -ENXIO; 1992 1993 read_lock_bh(&idev->lock); 1994 for (ifp = idev->addr_list; ifp; ifp=ifp->if_next) { 1995 if (ifp->prefix_len == plen && 1996 ipv6_addr_equal(pfx, &ifp->addr)) { 1997 in6_ifa_hold(ifp); 1998 read_unlock_bh(&idev->lock); 1999 2000 ipv6_del_addr(ifp); 2001 2002 /* If the last address is deleted administratively, 2003 disable IPv6 on this interface. 2004 */ 2005 if (idev->addr_list == NULL) 2006 addrconf_ifdown(idev->dev, 1); 2007 return 0; 2008 } 2009 } 2010 read_unlock_bh(&idev->lock); 2011 return -EADDRNOTAVAIL; 2012 } 2013 2014 2015 int addrconf_add_ifaddr(void __user *arg) 2016 { 2017 struct in6_ifreq ireq; 2018 int err; 2019 2020 if (!capable(CAP_NET_ADMIN)) 2021 return -EPERM; 2022 2023 if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq))) 2024 return -EFAULT; 2025 2026 rtnl_lock(); 2027 err = inet6_addr_add(ireq.ifr6_ifindex, &ireq.ifr6_addr, ireq.ifr6_prefixlen, 2028 IFA_F_PERMANENT, INFINITY_LIFE_TIME, INFINITY_LIFE_TIME); 2029 rtnl_unlock(); 2030 return err; 2031 } 2032 2033 int addrconf_del_ifaddr(void __user *arg) 2034 { 2035 struct in6_ifreq ireq; 2036 int err; 2037 2038 if (!capable(CAP_NET_ADMIN)) 2039 return -EPERM; 2040 2041 if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq))) 2042 return -EFAULT; 2043 2044 rtnl_lock(); 2045 err = inet6_addr_del(ireq.ifr6_ifindex, &ireq.ifr6_addr, ireq.ifr6_prefixlen); 2046 rtnl_unlock(); 2047 return err; 2048 } 2049 2050 #if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE) 2051 static void sit_add_v4_addrs(struct inet6_dev *idev) 2052 { 2053 struct inet6_ifaddr * ifp; 2054 struct in6_addr addr; 2055 struct net_device *dev; 2056 int scope; 2057 2058 ASSERT_RTNL(); 2059 2060 memset(&addr, 0, sizeof(struct in6_addr)); 2061 memcpy(&addr.s6_addr32[3], idev->dev->dev_addr, 4); 2062 2063 if (idev->dev->flags&IFF_POINTOPOINT) { 2064 addr.s6_addr32[0] = htonl(0xfe800000); 2065 scope = IFA_LINK; 2066 } else { 2067 scope = IPV6_ADDR_COMPATv4; 2068 } 2069 2070 if (addr.s6_addr32[3]) { 2071 ifp = ipv6_add_addr(idev, &addr, 128, scope, IFA_F_PERMANENT); 2072 if (!IS_ERR(ifp)) { 2073 spin_lock_bh(&ifp->lock); 2074 ifp->flags &= ~IFA_F_TENTATIVE; 2075 spin_unlock_bh(&ifp->lock); 2076 ipv6_ifa_notify(RTM_NEWADDR, ifp); 2077 in6_ifa_put(ifp); 2078 } 2079 return; 2080 } 2081 2082 for_each_netdev(&init_net, dev) { 2083 struct in_device * in_dev = __in_dev_get_rtnl(dev); 2084 if (in_dev && (dev->flags & IFF_UP)) { 2085 struct in_ifaddr * ifa; 2086 2087 int flag = scope; 2088 2089 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) { 2090 int plen; 2091 2092 addr.s6_addr32[3] = ifa->ifa_local; 2093 2094 if (ifa->ifa_scope == RT_SCOPE_LINK) 2095 continue; 2096 if (ifa->ifa_scope >= RT_SCOPE_HOST) { 2097 if (idev->dev->flags&IFF_POINTOPOINT) 2098 continue; 2099 flag |= IFA_HOST; 2100 } 2101 if (idev->dev->flags&IFF_POINTOPOINT) 2102 plen = 64; 2103 else 2104 plen = 96; 2105 2106 ifp = ipv6_add_addr(idev, &addr, plen, flag, 2107 IFA_F_PERMANENT); 2108 if (!IS_ERR(ifp)) { 2109 spin_lock_bh(&ifp->lock); 2110 ifp->flags &= ~IFA_F_TENTATIVE; 2111 spin_unlock_bh(&ifp->lock); 2112 ipv6_ifa_notify(RTM_NEWADDR, ifp); 2113 in6_ifa_put(ifp); 2114 } 2115 } 2116 } 2117 } 2118 } 2119 #endif 2120 2121 static void init_loopback(struct net_device *dev) 2122 { 2123 struct inet6_dev *idev; 2124 struct inet6_ifaddr * ifp; 2125 2126 /* ::1 */ 2127 2128 ASSERT_RTNL(); 2129 2130 if ((idev = ipv6_find_idev(dev)) == NULL) { 2131 printk(KERN_DEBUG "init loopback: add_dev failed\n"); 2132 return; 2133 } 2134 2135 ifp = ipv6_add_addr(idev, &in6addr_loopback, 128, IFA_HOST, IFA_F_PERMANENT); 2136 if (!IS_ERR(ifp)) { 2137 spin_lock_bh(&ifp->lock); 2138 ifp->flags &= ~IFA_F_TENTATIVE; 2139 spin_unlock_bh(&ifp->lock); 2140 ipv6_ifa_notify(RTM_NEWADDR, ifp); 2141 in6_ifa_put(ifp); 2142 } 2143 } 2144 2145 static void addrconf_add_linklocal(struct inet6_dev *idev, struct in6_addr *addr) 2146 { 2147 struct inet6_ifaddr * ifp; 2148 u32 addr_flags = IFA_F_PERMANENT; 2149 2150 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 2151 if (idev->cnf.optimistic_dad && 2152 !ipv6_devconf.forwarding) 2153 addr_flags |= IFA_F_OPTIMISTIC; 2154 #endif 2155 2156 2157 ifp = ipv6_add_addr(idev, addr, 64, IFA_LINK, addr_flags); 2158 if (!IS_ERR(ifp)) { 2159 addrconf_prefix_route(&ifp->addr, ifp->prefix_len, idev->dev, 0, 0); 2160 addrconf_dad_start(ifp, 0); 2161 in6_ifa_put(ifp); 2162 } 2163 } 2164 2165 static void addrconf_dev_config(struct net_device *dev) 2166 { 2167 struct in6_addr addr; 2168 struct inet6_dev * idev; 2169 2170 ASSERT_RTNL(); 2171 2172 if ((dev->type != ARPHRD_ETHER) && 2173 (dev->type != ARPHRD_FDDI) && 2174 (dev->type != ARPHRD_IEEE802_TR) && 2175 (dev->type != ARPHRD_ARCNET) && 2176 (dev->type != ARPHRD_INFINIBAND)) { 2177 /* Alas, we support only Ethernet autoconfiguration. */ 2178 return; 2179 } 2180 2181 idev = addrconf_add_dev(dev); 2182 if (idev == NULL) 2183 return; 2184 2185 memset(&addr, 0, sizeof(struct in6_addr)); 2186 addr.s6_addr32[0] = htonl(0xFE800000); 2187 2188 if (ipv6_generate_eui64(addr.s6_addr + 8, dev) == 0) 2189 addrconf_add_linklocal(idev, &addr); 2190 } 2191 2192 #if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE) 2193 static void addrconf_sit_config(struct net_device *dev) 2194 { 2195 struct inet6_dev *idev; 2196 2197 ASSERT_RTNL(); 2198 2199 /* 2200 * Configure the tunnel with one of our IPv4 2201 * addresses... we should configure all of 2202 * our v4 addrs in the tunnel 2203 */ 2204 2205 if ((idev = ipv6_find_idev(dev)) == NULL) { 2206 printk(KERN_DEBUG "init sit: add_dev failed\n"); 2207 return; 2208 } 2209 2210 sit_add_v4_addrs(idev); 2211 2212 if (dev->flags&IFF_POINTOPOINT) { 2213 addrconf_add_mroute(dev); 2214 addrconf_add_lroute(dev); 2215 } else 2216 sit_route_add(dev); 2217 } 2218 #endif 2219 2220 static inline int 2221 ipv6_inherit_linklocal(struct inet6_dev *idev, struct net_device *link_dev) 2222 { 2223 struct in6_addr lladdr; 2224 2225 if (!ipv6_get_lladdr(link_dev, &lladdr, IFA_F_TENTATIVE)) { 2226 addrconf_add_linklocal(idev, &lladdr); 2227 return 0; 2228 } 2229 return -1; 2230 } 2231 2232 static void ip6_tnl_add_linklocal(struct inet6_dev *idev) 2233 { 2234 struct net_device *link_dev; 2235 2236 /* first try to inherit the link-local address from the link device */ 2237 if (idev->dev->iflink && 2238 (link_dev = __dev_get_by_index(&init_net, idev->dev->iflink))) { 2239 if (!ipv6_inherit_linklocal(idev, link_dev)) 2240 return; 2241 } 2242 /* then try to inherit it from any device */ 2243 for_each_netdev(&init_net, link_dev) { 2244 if (!ipv6_inherit_linklocal(idev, link_dev)) 2245 return; 2246 } 2247 printk(KERN_DEBUG "init ip6-ip6: add_linklocal failed\n"); 2248 } 2249 2250 /* 2251 * Autoconfigure tunnel with a link-local address so routing protocols, 2252 * DHCPv6, MLD etc. can be run over the virtual link 2253 */ 2254 2255 static void addrconf_ip6_tnl_config(struct net_device *dev) 2256 { 2257 struct inet6_dev *idev; 2258 2259 ASSERT_RTNL(); 2260 2261 if ((idev = addrconf_add_dev(dev)) == NULL) { 2262 printk(KERN_DEBUG "init ip6-ip6: add_dev failed\n"); 2263 return; 2264 } 2265 ip6_tnl_add_linklocal(idev); 2266 } 2267 2268 static int addrconf_notify(struct notifier_block *this, unsigned long event, 2269 void * data) 2270 { 2271 struct net_device *dev = (struct net_device *) data; 2272 struct inet6_dev *idev = __in6_dev_get(dev); 2273 int run_pending = 0; 2274 int err; 2275 2276 if (dev->nd_net != &init_net) 2277 return NOTIFY_DONE; 2278 2279 switch(event) { 2280 case NETDEV_REGISTER: 2281 if (!idev && dev->mtu >= IPV6_MIN_MTU) { 2282 idev = ipv6_add_dev(dev); 2283 if (!idev) 2284 return notifier_from_errno(-ENOMEM); 2285 } 2286 break; 2287 case NETDEV_UP: 2288 case NETDEV_CHANGE: 2289 if (dev->flags & IFF_SLAVE) 2290 break; 2291 2292 if (event == NETDEV_UP) { 2293 if (!addrconf_qdisc_ok(dev)) { 2294 /* device is not ready yet. */ 2295 printk(KERN_INFO 2296 "ADDRCONF(NETDEV_UP): %s: " 2297 "link is not ready\n", 2298 dev->name); 2299 break; 2300 } 2301 2302 if (idev) 2303 idev->if_flags |= IF_READY; 2304 } else { 2305 if (!addrconf_qdisc_ok(dev)) { 2306 /* device is still not ready. */ 2307 break; 2308 } 2309 2310 if (idev) { 2311 if (idev->if_flags & IF_READY) { 2312 /* device is already configured. */ 2313 break; 2314 } 2315 idev->if_flags |= IF_READY; 2316 } 2317 2318 printk(KERN_INFO 2319 "ADDRCONF(NETDEV_CHANGE): %s: " 2320 "link becomes ready\n", 2321 dev->name); 2322 2323 run_pending = 1; 2324 } 2325 2326 switch(dev->type) { 2327 #if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE) 2328 case ARPHRD_SIT: 2329 addrconf_sit_config(dev); 2330 break; 2331 #endif 2332 case ARPHRD_TUNNEL6: 2333 addrconf_ip6_tnl_config(dev); 2334 break; 2335 case ARPHRD_LOOPBACK: 2336 init_loopback(dev); 2337 break; 2338 2339 default: 2340 addrconf_dev_config(dev); 2341 break; 2342 } 2343 if (idev) { 2344 if (run_pending) 2345 addrconf_dad_run(idev); 2346 2347 /* If the MTU changed during the interface down, when the 2348 interface up, the changed MTU must be reflected in the 2349 idev as well as routers. 2350 */ 2351 if (idev->cnf.mtu6 != dev->mtu && dev->mtu >= IPV6_MIN_MTU) { 2352 rt6_mtu_change(dev, dev->mtu); 2353 idev->cnf.mtu6 = dev->mtu; 2354 } 2355 idev->tstamp = jiffies; 2356 inet6_ifinfo_notify(RTM_NEWLINK, idev); 2357 /* If the changed mtu during down is lower than IPV6_MIN_MTU 2358 stop IPv6 on this interface. 2359 */ 2360 if (dev->mtu < IPV6_MIN_MTU) 2361 addrconf_ifdown(dev, event != NETDEV_DOWN); 2362 } 2363 break; 2364 2365 case NETDEV_CHANGEMTU: 2366 if ( idev && dev->mtu >= IPV6_MIN_MTU) { 2367 rt6_mtu_change(dev, dev->mtu); 2368 idev->cnf.mtu6 = dev->mtu; 2369 break; 2370 } 2371 2372 /* MTU falled under IPV6_MIN_MTU. Stop IPv6 on this interface. */ 2373 2374 case NETDEV_DOWN: 2375 case NETDEV_UNREGISTER: 2376 /* 2377 * Remove all addresses from this interface. 2378 */ 2379 addrconf_ifdown(dev, event != NETDEV_DOWN); 2380 break; 2381 2382 case NETDEV_CHANGENAME: 2383 if (idev) { 2384 snmp6_unregister_dev(idev); 2385 #ifdef CONFIG_SYSCTL 2386 addrconf_sysctl_unregister(&idev->cnf); 2387 neigh_sysctl_unregister(idev->nd_parms); 2388 neigh_sysctl_register(dev, idev->nd_parms, 2389 NET_IPV6, NET_IPV6_NEIGH, "ipv6", 2390 &ndisc_ifinfo_sysctl_change, 2391 NULL); 2392 addrconf_sysctl_register(idev, &idev->cnf); 2393 #endif 2394 err = snmp6_register_dev(idev); 2395 if (err) 2396 return notifier_from_errno(err); 2397 } 2398 break; 2399 } 2400 2401 return NOTIFY_OK; 2402 } 2403 2404 /* 2405 * addrconf module should be notified of a device going up 2406 */ 2407 static struct notifier_block ipv6_dev_notf = { 2408 .notifier_call = addrconf_notify, 2409 .priority = 0 2410 }; 2411 2412 static int addrconf_ifdown(struct net_device *dev, int how) 2413 { 2414 struct inet6_dev *idev; 2415 struct inet6_ifaddr *ifa, **bifa; 2416 int i; 2417 2418 ASSERT_RTNL(); 2419 2420 if (dev == init_net.loopback_dev && how == 1) 2421 how = 0; 2422 2423 rt6_ifdown(dev); 2424 neigh_ifdown(&nd_tbl, dev); 2425 2426 idev = __in6_dev_get(dev); 2427 if (idev == NULL) 2428 return -ENODEV; 2429 2430 /* Step 1: remove reference to ipv6 device from parent device. 2431 Do not dev_put! 2432 */ 2433 if (how == 1) { 2434 idev->dead = 1; 2435 2436 /* protected by rtnl_lock */ 2437 rcu_assign_pointer(dev->ip6_ptr, NULL); 2438 2439 /* Step 1.5: remove snmp6 entry */ 2440 snmp6_unregister_dev(idev); 2441 2442 } 2443 2444 /* Step 2: clear hash table */ 2445 for (i=0; i<IN6_ADDR_HSIZE; i++) { 2446 bifa = &inet6_addr_lst[i]; 2447 2448 write_lock_bh(&addrconf_hash_lock); 2449 while ((ifa = *bifa) != NULL) { 2450 if (ifa->idev == idev) { 2451 *bifa = ifa->lst_next; 2452 ifa->lst_next = NULL; 2453 addrconf_del_timer(ifa); 2454 in6_ifa_put(ifa); 2455 continue; 2456 } 2457 bifa = &ifa->lst_next; 2458 } 2459 write_unlock_bh(&addrconf_hash_lock); 2460 } 2461 2462 write_lock_bh(&idev->lock); 2463 2464 /* Step 3: clear flags for stateless addrconf */ 2465 if (how != 1) 2466 idev->if_flags &= ~(IF_RS_SENT|IF_RA_RCVD|IF_READY); 2467 2468 /* Step 4: clear address list */ 2469 #ifdef CONFIG_IPV6_PRIVACY 2470 if (how == 1 && del_timer(&idev->regen_timer)) 2471 in6_dev_put(idev); 2472 2473 /* clear tempaddr list */ 2474 while ((ifa = idev->tempaddr_list) != NULL) { 2475 idev->tempaddr_list = ifa->tmp_next; 2476 ifa->tmp_next = NULL; 2477 ifa->dead = 1; 2478 write_unlock_bh(&idev->lock); 2479 spin_lock_bh(&ifa->lock); 2480 2481 if (ifa->ifpub) { 2482 in6_ifa_put(ifa->ifpub); 2483 ifa->ifpub = NULL; 2484 } 2485 spin_unlock_bh(&ifa->lock); 2486 in6_ifa_put(ifa); 2487 write_lock_bh(&idev->lock); 2488 } 2489 #endif 2490 while ((ifa = idev->addr_list) != NULL) { 2491 idev->addr_list = ifa->if_next; 2492 ifa->if_next = NULL; 2493 ifa->dead = 1; 2494 addrconf_del_timer(ifa); 2495 write_unlock_bh(&idev->lock); 2496 2497 __ipv6_ifa_notify(RTM_DELADDR, ifa); 2498 atomic_notifier_call_chain(&inet6addr_chain, NETDEV_DOWN, ifa); 2499 in6_ifa_put(ifa); 2500 2501 write_lock_bh(&idev->lock); 2502 } 2503 write_unlock_bh(&idev->lock); 2504 2505 /* Step 5: Discard multicast list */ 2506 2507 if (how == 1) 2508 ipv6_mc_destroy_dev(idev); 2509 else 2510 ipv6_mc_down(idev); 2511 2512 idev->tstamp = jiffies; 2513 2514 /* Shot the device (if unregistered) */ 2515 2516 if (how == 1) { 2517 #ifdef CONFIG_SYSCTL 2518 addrconf_sysctl_unregister(&idev->cnf); 2519 neigh_sysctl_unregister(idev->nd_parms); 2520 #endif 2521 neigh_parms_release(&nd_tbl, idev->nd_parms); 2522 neigh_ifdown(&nd_tbl, dev); 2523 in6_dev_put(idev); 2524 } 2525 return 0; 2526 } 2527 2528 static void addrconf_rs_timer(unsigned long data) 2529 { 2530 struct inet6_ifaddr *ifp = (struct inet6_ifaddr *) data; 2531 2532 if (ifp->idev->cnf.forwarding) 2533 goto out; 2534 2535 if (ifp->idev->if_flags & IF_RA_RCVD) { 2536 /* 2537 * Announcement received after solicitation 2538 * was sent 2539 */ 2540 goto out; 2541 } 2542 2543 spin_lock(&ifp->lock); 2544 if (ifp->probes++ < ifp->idev->cnf.rtr_solicits) { 2545 struct in6_addr all_routers; 2546 2547 /* The wait after the last probe can be shorter */ 2548 addrconf_mod_timer(ifp, AC_RS, 2549 (ifp->probes == ifp->idev->cnf.rtr_solicits) ? 2550 ifp->idev->cnf.rtr_solicit_delay : 2551 ifp->idev->cnf.rtr_solicit_interval); 2552 spin_unlock(&ifp->lock); 2553 2554 ipv6_addr_all_routers(&all_routers); 2555 2556 ndisc_send_rs(ifp->idev->dev, &ifp->addr, &all_routers); 2557 } else { 2558 spin_unlock(&ifp->lock); 2559 /* 2560 * Note: we do not support deprecated "all on-link" 2561 * assumption any longer. 2562 */ 2563 printk(KERN_DEBUG "%s: no IPv6 routers present\n", 2564 ifp->idev->dev->name); 2565 } 2566 2567 out: 2568 in6_ifa_put(ifp); 2569 } 2570 2571 /* 2572 * Duplicate Address Detection 2573 */ 2574 static void addrconf_dad_kick(struct inet6_ifaddr *ifp) 2575 { 2576 unsigned long rand_num; 2577 struct inet6_dev *idev = ifp->idev; 2578 2579 if (ifp->flags & IFA_F_OPTIMISTIC) 2580 rand_num = 0; 2581 else 2582 rand_num = net_random() % (idev->cnf.rtr_solicit_delay ? : 1); 2583 2584 ifp->probes = idev->cnf.dad_transmits; 2585 addrconf_mod_timer(ifp, AC_DAD, rand_num); 2586 } 2587 2588 static void addrconf_dad_start(struct inet6_ifaddr *ifp, u32 flags) 2589 { 2590 struct inet6_dev *idev = ifp->idev; 2591 struct net_device *dev = idev->dev; 2592 2593 addrconf_join_solict(dev, &ifp->addr); 2594 2595 net_srandom(ifp->addr.s6_addr32[3]); 2596 2597 read_lock_bh(&idev->lock); 2598 if (ifp->dead) 2599 goto out; 2600 spin_lock_bh(&ifp->lock); 2601 2602 if (dev->flags&(IFF_NOARP|IFF_LOOPBACK) || 2603 !(ifp->flags&IFA_F_TENTATIVE) || 2604 ifp->flags & IFA_F_NODAD) { 2605 ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC); 2606 spin_unlock_bh(&ifp->lock); 2607 read_unlock_bh(&idev->lock); 2608 2609 addrconf_dad_completed(ifp); 2610 return; 2611 } 2612 2613 if (!(idev->if_flags & IF_READY)) { 2614 spin_unlock_bh(&ifp->lock); 2615 read_unlock_bh(&idev->lock); 2616 /* 2617 * If the defice is not ready: 2618 * - keep it tentative if it is a permanent address. 2619 * - otherwise, kill it. 2620 */ 2621 in6_ifa_hold(ifp); 2622 addrconf_dad_stop(ifp); 2623 return; 2624 } 2625 2626 /* 2627 * Optimistic nodes can start receiving 2628 * Frames right away 2629 */ 2630 if(ifp->flags & IFA_F_OPTIMISTIC) 2631 ip6_ins_rt(ifp->rt); 2632 2633 addrconf_dad_kick(ifp); 2634 spin_unlock_bh(&ifp->lock); 2635 out: 2636 read_unlock_bh(&idev->lock); 2637 } 2638 2639 static void addrconf_dad_timer(unsigned long data) 2640 { 2641 struct inet6_ifaddr *ifp = (struct inet6_ifaddr *) data; 2642 struct inet6_dev *idev = ifp->idev; 2643 struct in6_addr unspec; 2644 struct in6_addr mcaddr; 2645 2646 read_lock_bh(&idev->lock); 2647 if (idev->dead) { 2648 read_unlock_bh(&idev->lock); 2649 goto out; 2650 } 2651 spin_lock_bh(&ifp->lock); 2652 if (ifp->probes == 0) { 2653 /* 2654 * DAD was successful 2655 */ 2656 2657 ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC); 2658 spin_unlock_bh(&ifp->lock); 2659 read_unlock_bh(&idev->lock); 2660 2661 addrconf_dad_completed(ifp); 2662 2663 goto out; 2664 } 2665 2666 ifp->probes--; 2667 addrconf_mod_timer(ifp, AC_DAD, ifp->idev->nd_parms->retrans_time); 2668 spin_unlock_bh(&ifp->lock); 2669 read_unlock_bh(&idev->lock); 2670 2671 /* send a neighbour solicitation for our addr */ 2672 memset(&unspec, 0, sizeof(unspec)); 2673 addrconf_addr_solict_mult(&ifp->addr, &mcaddr); 2674 ndisc_send_ns(ifp->idev->dev, NULL, &ifp->addr, &mcaddr, &unspec); 2675 out: 2676 in6_ifa_put(ifp); 2677 } 2678 2679 static void addrconf_dad_completed(struct inet6_ifaddr *ifp) 2680 { 2681 struct net_device * dev = ifp->idev->dev; 2682 2683 /* 2684 * Configure the address for reception. Now it is valid. 2685 */ 2686 2687 ipv6_ifa_notify(RTM_NEWADDR, ifp); 2688 2689 /* If added prefix is link local and forwarding is off, 2690 start sending router solicitations. 2691 */ 2692 2693 if (ifp->idev->cnf.forwarding == 0 && 2694 ifp->idev->cnf.rtr_solicits > 0 && 2695 (dev->flags&IFF_LOOPBACK) == 0 && 2696 (ipv6_addr_type(&ifp->addr) & IPV6_ADDR_LINKLOCAL)) { 2697 struct in6_addr all_routers; 2698 2699 ipv6_addr_all_routers(&all_routers); 2700 2701 /* 2702 * If a host as already performed a random delay 2703 * [...] as part of DAD [...] there is no need 2704 * to delay again before sending the first RS 2705 */ 2706 ndisc_send_rs(ifp->idev->dev, &ifp->addr, &all_routers); 2707 2708 spin_lock_bh(&ifp->lock); 2709 ifp->probes = 1; 2710 ifp->idev->if_flags |= IF_RS_SENT; 2711 addrconf_mod_timer(ifp, AC_RS, ifp->idev->cnf.rtr_solicit_interval); 2712 spin_unlock_bh(&ifp->lock); 2713 } 2714 } 2715 2716 static void addrconf_dad_run(struct inet6_dev *idev) { 2717 struct inet6_ifaddr *ifp; 2718 2719 read_lock_bh(&idev->lock); 2720 for (ifp = idev->addr_list; ifp; ifp = ifp->if_next) { 2721 spin_lock_bh(&ifp->lock); 2722 if (!(ifp->flags & IFA_F_TENTATIVE)) { 2723 spin_unlock_bh(&ifp->lock); 2724 continue; 2725 } 2726 spin_unlock_bh(&ifp->lock); 2727 addrconf_dad_kick(ifp); 2728 } 2729 read_unlock_bh(&idev->lock); 2730 } 2731 2732 #ifdef CONFIG_PROC_FS 2733 struct if6_iter_state { 2734 int bucket; 2735 }; 2736 2737 static struct inet6_ifaddr *if6_get_first(struct seq_file *seq) 2738 { 2739 struct inet6_ifaddr *ifa = NULL; 2740 struct if6_iter_state *state = seq->private; 2741 2742 for (state->bucket = 0; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) { 2743 ifa = inet6_addr_lst[state->bucket]; 2744 if (ifa) 2745 break; 2746 } 2747 return ifa; 2748 } 2749 2750 static struct inet6_ifaddr *if6_get_next(struct seq_file *seq, struct inet6_ifaddr *ifa) 2751 { 2752 struct if6_iter_state *state = seq->private; 2753 2754 ifa = ifa->lst_next; 2755 try_again: 2756 if (!ifa && ++state->bucket < IN6_ADDR_HSIZE) { 2757 ifa = inet6_addr_lst[state->bucket]; 2758 goto try_again; 2759 } 2760 return ifa; 2761 } 2762 2763 static struct inet6_ifaddr *if6_get_idx(struct seq_file *seq, loff_t pos) 2764 { 2765 struct inet6_ifaddr *ifa = if6_get_first(seq); 2766 2767 if (ifa) 2768 while(pos && (ifa = if6_get_next(seq, ifa)) != NULL) 2769 --pos; 2770 return pos ? NULL : ifa; 2771 } 2772 2773 static void *if6_seq_start(struct seq_file *seq, loff_t *pos) 2774 { 2775 read_lock_bh(&addrconf_hash_lock); 2776 return if6_get_idx(seq, *pos); 2777 } 2778 2779 static void *if6_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2780 { 2781 struct inet6_ifaddr *ifa; 2782 2783 ifa = if6_get_next(seq, v); 2784 ++*pos; 2785 return ifa; 2786 } 2787 2788 static void if6_seq_stop(struct seq_file *seq, void *v) 2789 { 2790 read_unlock_bh(&addrconf_hash_lock); 2791 } 2792 2793 static int if6_seq_show(struct seq_file *seq, void *v) 2794 { 2795 struct inet6_ifaddr *ifp = (struct inet6_ifaddr *)v; 2796 seq_printf(seq, 2797 NIP6_SEQFMT " %02x %02x %02x %02x %8s\n", 2798 NIP6(ifp->addr), 2799 ifp->idev->dev->ifindex, 2800 ifp->prefix_len, 2801 ifp->scope, 2802 ifp->flags, 2803 ifp->idev->dev->name); 2804 return 0; 2805 } 2806 2807 static const struct seq_operations if6_seq_ops = { 2808 .start = if6_seq_start, 2809 .next = if6_seq_next, 2810 .show = if6_seq_show, 2811 .stop = if6_seq_stop, 2812 }; 2813 2814 static int if6_seq_open(struct inode *inode, struct file *file) 2815 { 2816 return seq_open_private(file, &if6_seq_ops, 2817 sizeof(struct if6_iter_state)); 2818 } 2819 2820 static const struct file_operations if6_fops = { 2821 .owner = THIS_MODULE, 2822 .open = if6_seq_open, 2823 .read = seq_read, 2824 .llseek = seq_lseek, 2825 .release = seq_release_private, 2826 }; 2827 2828 int __init if6_proc_init(void) 2829 { 2830 if (!proc_net_fops_create(&init_net, "if_inet6", S_IRUGO, &if6_fops)) 2831 return -ENOMEM; 2832 return 0; 2833 } 2834 2835 void if6_proc_exit(void) 2836 { 2837 proc_net_remove(&init_net, "if_inet6"); 2838 } 2839 #endif /* CONFIG_PROC_FS */ 2840 2841 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE) 2842 /* Check if address is a home address configured on any interface. */ 2843 int ipv6_chk_home_addr(struct in6_addr *addr) 2844 { 2845 int ret = 0; 2846 struct inet6_ifaddr * ifp; 2847 u8 hash = ipv6_addr_hash(addr); 2848 read_lock_bh(&addrconf_hash_lock); 2849 for (ifp = inet6_addr_lst[hash]; ifp; ifp = ifp->lst_next) { 2850 if (ipv6_addr_cmp(&ifp->addr, addr) == 0 && 2851 (ifp->flags & IFA_F_HOMEADDRESS)) { 2852 ret = 1; 2853 break; 2854 } 2855 } 2856 read_unlock_bh(&addrconf_hash_lock); 2857 return ret; 2858 } 2859 #endif 2860 2861 /* 2862 * Periodic address status verification 2863 */ 2864 2865 static void addrconf_verify(unsigned long foo) 2866 { 2867 struct inet6_ifaddr *ifp; 2868 unsigned long now, next; 2869 int i; 2870 2871 spin_lock_bh(&addrconf_verify_lock); 2872 now = jiffies; 2873 next = now + ADDR_CHECK_FREQUENCY; 2874 2875 del_timer(&addr_chk_timer); 2876 2877 for (i=0; i < IN6_ADDR_HSIZE; i++) { 2878 2879 restart: 2880 read_lock(&addrconf_hash_lock); 2881 for (ifp=inet6_addr_lst[i]; ifp; ifp=ifp->lst_next) { 2882 unsigned long age; 2883 #ifdef CONFIG_IPV6_PRIVACY 2884 unsigned long regen_advance; 2885 #endif 2886 2887 if (ifp->flags & IFA_F_PERMANENT) 2888 continue; 2889 2890 spin_lock(&ifp->lock); 2891 age = (now - ifp->tstamp) / HZ; 2892 2893 #ifdef CONFIG_IPV6_PRIVACY 2894 regen_advance = ifp->idev->cnf.regen_max_retry * 2895 ifp->idev->cnf.dad_transmits * 2896 ifp->idev->nd_parms->retrans_time / HZ; 2897 #endif 2898 2899 if (ifp->valid_lft != INFINITY_LIFE_TIME && 2900 age >= ifp->valid_lft) { 2901 spin_unlock(&ifp->lock); 2902 in6_ifa_hold(ifp); 2903 read_unlock(&addrconf_hash_lock); 2904 ipv6_del_addr(ifp); 2905 goto restart; 2906 } else if (ifp->prefered_lft == INFINITY_LIFE_TIME) { 2907 spin_unlock(&ifp->lock); 2908 continue; 2909 } else if (age >= ifp->prefered_lft) { 2910 /* jiffies - ifp->tsamp > age >= ifp->prefered_lft */ 2911 int deprecate = 0; 2912 2913 if (!(ifp->flags&IFA_F_DEPRECATED)) { 2914 deprecate = 1; 2915 ifp->flags |= IFA_F_DEPRECATED; 2916 } 2917 2918 if (time_before(ifp->tstamp + ifp->valid_lft * HZ, next)) 2919 next = ifp->tstamp + ifp->valid_lft * HZ; 2920 2921 spin_unlock(&ifp->lock); 2922 2923 if (deprecate) { 2924 in6_ifa_hold(ifp); 2925 read_unlock(&addrconf_hash_lock); 2926 2927 ipv6_ifa_notify(0, ifp); 2928 in6_ifa_put(ifp); 2929 goto restart; 2930 } 2931 #ifdef CONFIG_IPV6_PRIVACY 2932 } else if ((ifp->flags&IFA_F_TEMPORARY) && 2933 !(ifp->flags&IFA_F_TENTATIVE)) { 2934 if (age >= ifp->prefered_lft - regen_advance) { 2935 struct inet6_ifaddr *ifpub = ifp->ifpub; 2936 if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next)) 2937 next = ifp->tstamp + ifp->prefered_lft * HZ; 2938 if (!ifp->regen_count && ifpub) { 2939 ifp->regen_count++; 2940 in6_ifa_hold(ifp); 2941 in6_ifa_hold(ifpub); 2942 spin_unlock(&ifp->lock); 2943 read_unlock(&addrconf_hash_lock); 2944 spin_lock(&ifpub->lock); 2945 ifpub->regen_count = 0; 2946 spin_unlock(&ifpub->lock); 2947 ipv6_create_tempaddr(ifpub, ifp); 2948 in6_ifa_put(ifpub); 2949 in6_ifa_put(ifp); 2950 goto restart; 2951 } 2952 } else if (time_before(ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ, next)) 2953 next = ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ; 2954 spin_unlock(&ifp->lock); 2955 #endif 2956 } else { 2957 /* ifp->prefered_lft <= ifp->valid_lft */ 2958 if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next)) 2959 next = ifp->tstamp + ifp->prefered_lft * HZ; 2960 spin_unlock(&ifp->lock); 2961 } 2962 } 2963 read_unlock(&addrconf_hash_lock); 2964 } 2965 2966 addr_chk_timer.expires = time_before(next, jiffies + HZ) ? jiffies + HZ : next; 2967 add_timer(&addr_chk_timer); 2968 spin_unlock_bh(&addrconf_verify_lock); 2969 } 2970 2971 static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local) 2972 { 2973 struct in6_addr *pfx = NULL; 2974 2975 if (addr) 2976 pfx = nla_data(addr); 2977 2978 if (local) { 2979 if (pfx && nla_memcmp(local, pfx, sizeof(*pfx))) 2980 pfx = NULL; 2981 else 2982 pfx = nla_data(local); 2983 } 2984 2985 return pfx; 2986 } 2987 2988 static const struct nla_policy ifa_ipv6_policy[IFA_MAX+1] = { 2989 [IFA_ADDRESS] = { .len = sizeof(struct in6_addr) }, 2990 [IFA_LOCAL] = { .len = sizeof(struct in6_addr) }, 2991 [IFA_CACHEINFO] = { .len = sizeof(struct ifa_cacheinfo) }, 2992 }; 2993 2994 static int 2995 inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 2996 { 2997 struct ifaddrmsg *ifm; 2998 struct nlattr *tb[IFA_MAX+1]; 2999 struct in6_addr *pfx; 3000 int err; 3001 3002 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy); 3003 if (err < 0) 3004 return err; 3005 3006 ifm = nlmsg_data(nlh); 3007 pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL]); 3008 if (pfx == NULL) 3009 return -EINVAL; 3010 3011 return inet6_addr_del(ifm->ifa_index, pfx, ifm->ifa_prefixlen); 3012 } 3013 3014 static int inet6_addr_modify(struct inet6_ifaddr *ifp, u8 ifa_flags, 3015 u32 prefered_lft, u32 valid_lft) 3016 { 3017 u32 flags = RTF_EXPIRES; 3018 3019 if (!valid_lft || (prefered_lft > valid_lft)) 3020 return -EINVAL; 3021 3022 if (valid_lft == INFINITY_LIFE_TIME) { 3023 ifa_flags |= IFA_F_PERMANENT; 3024 flags = 0; 3025 } else if (valid_lft >= 0x7FFFFFFF/HZ) 3026 valid_lft = 0x7FFFFFFF/HZ; 3027 3028 if (prefered_lft == 0) 3029 ifa_flags |= IFA_F_DEPRECATED; 3030 else if ((prefered_lft >= 0x7FFFFFFF/HZ) && 3031 (prefered_lft != INFINITY_LIFE_TIME)) 3032 prefered_lft = 0x7FFFFFFF/HZ; 3033 3034 spin_lock_bh(&ifp->lock); 3035 ifp->flags = (ifp->flags & ~(IFA_F_DEPRECATED | IFA_F_PERMANENT | IFA_F_NODAD | IFA_F_HOMEADDRESS)) | ifa_flags; 3036 ifp->tstamp = jiffies; 3037 ifp->valid_lft = valid_lft; 3038 ifp->prefered_lft = prefered_lft; 3039 3040 spin_unlock_bh(&ifp->lock); 3041 if (!(ifp->flags&IFA_F_TENTATIVE)) 3042 ipv6_ifa_notify(0, ifp); 3043 3044 addrconf_prefix_route(&ifp->addr, ifp->prefix_len, ifp->idev->dev, 3045 jiffies_to_clock_t(valid_lft * HZ), flags); 3046 addrconf_verify(0); 3047 3048 return 0; 3049 } 3050 3051 static int 3052 inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 3053 { 3054 struct ifaddrmsg *ifm; 3055 struct nlattr *tb[IFA_MAX+1]; 3056 struct in6_addr *pfx; 3057 struct inet6_ifaddr *ifa; 3058 struct net_device *dev; 3059 u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME; 3060 u8 ifa_flags; 3061 int err; 3062 3063 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy); 3064 if (err < 0) 3065 return err; 3066 3067 ifm = nlmsg_data(nlh); 3068 pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL]); 3069 if (pfx == NULL) 3070 return -EINVAL; 3071 3072 if (tb[IFA_CACHEINFO]) { 3073 struct ifa_cacheinfo *ci; 3074 3075 ci = nla_data(tb[IFA_CACHEINFO]); 3076 valid_lft = ci->ifa_valid; 3077 preferred_lft = ci->ifa_prefered; 3078 } else { 3079 preferred_lft = INFINITY_LIFE_TIME; 3080 valid_lft = INFINITY_LIFE_TIME; 3081 } 3082 3083 dev = __dev_get_by_index(&init_net, ifm->ifa_index); 3084 if (dev == NULL) 3085 return -ENODEV; 3086 3087 /* We ignore other flags so far. */ 3088 ifa_flags = ifm->ifa_flags & (IFA_F_NODAD | IFA_F_HOMEADDRESS); 3089 3090 ifa = ipv6_get_ifaddr(pfx, dev, 1); 3091 if (ifa == NULL) { 3092 /* 3093 * It would be best to check for !NLM_F_CREATE here but 3094 * userspace alreay relies on not having to provide this. 3095 */ 3096 return inet6_addr_add(ifm->ifa_index, pfx, ifm->ifa_prefixlen, 3097 ifa_flags, preferred_lft, valid_lft); 3098 } 3099 3100 if (nlh->nlmsg_flags & NLM_F_EXCL || 3101 !(nlh->nlmsg_flags & NLM_F_REPLACE)) 3102 err = -EEXIST; 3103 else 3104 err = inet6_addr_modify(ifa, ifa_flags, preferred_lft, valid_lft); 3105 3106 in6_ifa_put(ifa); 3107 3108 return err; 3109 } 3110 3111 static void put_ifaddrmsg(struct nlmsghdr *nlh, u8 prefixlen, u8 flags, 3112 u8 scope, int ifindex) 3113 { 3114 struct ifaddrmsg *ifm; 3115 3116 ifm = nlmsg_data(nlh); 3117 ifm->ifa_family = AF_INET6; 3118 ifm->ifa_prefixlen = prefixlen; 3119 ifm->ifa_flags = flags; 3120 ifm->ifa_scope = scope; 3121 ifm->ifa_index = ifindex; 3122 } 3123 3124 static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp, 3125 unsigned long tstamp, u32 preferred, u32 valid) 3126 { 3127 struct ifa_cacheinfo ci; 3128 3129 ci.cstamp = (u32)(TIME_DELTA(cstamp, INITIAL_JIFFIES) / HZ * 100 3130 + TIME_DELTA(cstamp, INITIAL_JIFFIES) % HZ * 100 / HZ); 3131 ci.tstamp = (u32)(TIME_DELTA(tstamp, INITIAL_JIFFIES) / HZ * 100 3132 + TIME_DELTA(tstamp, INITIAL_JIFFIES) % HZ * 100 / HZ); 3133 ci.ifa_prefered = preferred; 3134 ci.ifa_valid = valid; 3135 3136 return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci); 3137 } 3138 3139 static inline int rt_scope(int ifa_scope) 3140 { 3141 if (ifa_scope & IFA_HOST) 3142 return RT_SCOPE_HOST; 3143 else if (ifa_scope & IFA_LINK) 3144 return RT_SCOPE_LINK; 3145 else if (ifa_scope & IFA_SITE) 3146 return RT_SCOPE_SITE; 3147 else 3148 return RT_SCOPE_UNIVERSE; 3149 } 3150 3151 static inline int inet6_ifaddr_msgsize(void) 3152 { 3153 return NLMSG_ALIGN(sizeof(struct ifaddrmsg)) 3154 + nla_total_size(16) /* IFA_ADDRESS */ 3155 + nla_total_size(sizeof(struct ifa_cacheinfo)); 3156 } 3157 3158 static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa, 3159 u32 pid, u32 seq, int event, unsigned int flags) 3160 { 3161 struct nlmsghdr *nlh; 3162 u32 preferred, valid; 3163 3164 nlh = nlmsg_put(skb, pid, seq, event, sizeof(struct ifaddrmsg), flags); 3165 if (nlh == NULL) 3166 return -EMSGSIZE; 3167 3168 put_ifaddrmsg(nlh, ifa->prefix_len, ifa->flags, rt_scope(ifa->scope), 3169 ifa->idev->dev->ifindex); 3170 3171 if (!(ifa->flags&IFA_F_PERMANENT)) { 3172 preferred = ifa->prefered_lft; 3173 valid = ifa->valid_lft; 3174 if (preferred != INFINITY_LIFE_TIME) { 3175 long tval = (jiffies - ifa->tstamp)/HZ; 3176 preferred -= tval; 3177 if (valid != INFINITY_LIFE_TIME) 3178 valid -= tval; 3179 } 3180 } else { 3181 preferred = INFINITY_LIFE_TIME; 3182 valid = INFINITY_LIFE_TIME; 3183 } 3184 3185 if (nla_put(skb, IFA_ADDRESS, 16, &ifa->addr) < 0 || 3186 put_cacheinfo(skb, ifa->cstamp, ifa->tstamp, preferred, valid) < 0) { 3187 nlmsg_cancel(skb, nlh); 3188 return -EMSGSIZE; 3189 } 3190 3191 return nlmsg_end(skb, nlh); 3192 } 3193 3194 static int inet6_fill_ifmcaddr(struct sk_buff *skb, struct ifmcaddr6 *ifmca, 3195 u32 pid, u32 seq, int event, u16 flags) 3196 { 3197 struct nlmsghdr *nlh; 3198 u8 scope = RT_SCOPE_UNIVERSE; 3199 int ifindex = ifmca->idev->dev->ifindex; 3200 3201 if (ipv6_addr_scope(&ifmca->mca_addr) & IFA_SITE) 3202 scope = RT_SCOPE_SITE; 3203 3204 nlh = nlmsg_put(skb, pid, seq, event, sizeof(struct ifaddrmsg), flags); 3205 if (nlh == NULL) 3206 return -EMSGSIZE; 3207 3208 put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex); 3209 if (nla_put(skb, IFA_MULTICAST, 16, &ifmca->mca_addr) < 0 || 3210 put_cacheinfo(skb, ifmca->mca_cstamp, ifmca->mca_tstamp, 3211 INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) { 3212 nlmsg_cancel(skb, nlh); 3213 return -EMSGSIZE; 3214 } 3215 3216 return nlmsg_end(skb, nlh); 3217 } 3218 3219 static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca, 3220 u32 pid, u32 seq, int event, unsigned int flags) 3221 { 3222 struct nlmsghdr *nlh; 3223 u8 scope = RT_SCOPE_UNIVERSE; 3224 int ifindex = ifaca->aca_idev->dev->ifindex; 3225 3226 if (ipv6_addr_scope(&ifaca->aca_addr) & IFA_SITE) 3227 scope = RT_SCOPE_SITE; 3228 3229 nlh = nlmsg_put(skb, pid, seq, event, sizeof(struct ifaddrmsg), flags); 3230 if (nlh == NULL) 3231 return -EMSGSIZE; 3232 3233 put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex); 3234 if (nla_put(skb, IFA_ANYCAST, 16, &ifaca->aca_addr) < 0 || 3235 put_cacheinfo(skb, ifaca->aca_cstamp, ifaca->aca_tstamp, 3236 INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) { 3237 nlmsg_cancel(skb, nlh); 3238 return -EMSGSIZE; 3239 } 3240 3241 return nlmsg_end(skb, nlh); 3242 } 3243 3244 enum addr_type_t 3245 { 3246 UNICAST_ADDR, 3247 MULTICAST_ADDR, 3248 ANYCAST_ADDR, 3249 }; 3250 3251 static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb, 3252 enum addr_type_t type) 3253 { 3254 int idx, ip_idx; 3255 int s_idx, s_ip_idx; 3256 int err = 1; 3257 struct net_device *dev; 3258 struct inet6_dev *idev = NULL; 3259 struct inet6_ifaddr *ifa; 3260 struct ifmcaddr6 *ifmca; 3261 struct ifacaddr6 *ifaca; 3262 3263 s_idx = cb->args[0]; 3264 s_ip_idx = ip_idx = cb->args[1]; 3265 3266 idx = 0; 3267 for_each_netdev(&init_net, dev) { 3268 if (idx < s_idx) 3269 goto cont; 3270 if (idx > s_idx) 3271 s_ip_idx = 0; 3272 ip_idx = 0; 3273 if ((idev = in6_dev_get(dev)) == NULL) 3274 goto cont; 3275 read_lock_bh(&idev->lock); 3276 switch (type) { 3277 case UNICAST_ADDR: 3278 /* unicast address incl. temp addr */ 3279 for (ifa = idev->addr_list; ifa; 3280 ifa = ifa->if_next, ip_idx++) { 3281 if (ip_idx < s_ip_idx) 3282 continue; 3283 if ((err = inet6_fill_ifaddr(skb, ifa, 3284 NETLINK_CB(cb->skb).pid, 3285 cb->nlh->nlmsg_seq, RTM_NEWADDR, 3286 NLM_F_MULTI)) <= 0) 3287 goto done; 3288 } 3289 break; 3290 case MULTICAST_ADDR: 3291 /* multicast address */ 3292 for (ifmca = idev->mc_list; ifmca; 3293 ifmca = ifmca->next, ip_idx++) { 3294 if (ip_idx < s_ip_idx) 3295 continue; 3296 if ((err = inet6_fill_ifmcaddr(skb, ifmca, 3297 NETLINK_CB(cb->skb).pid, 3298 cb->nlh->nlmsg_seq, RTM_GETMULTICAST, 3299 NLM_F_MULTI)) <= 0) 3300 goto done; 3301 } 3302 break; 3303 case ANYCAST_ADDR: 3304 /* anycast address */ 3305 for (ifaca = idev->ac_list; ifaca; 3306 ifaca = ifaca->aca_next, ip_idx++) { 3307 if (ip_idx < s_ip_idx) 3308 continue; 3309 if ((err = inet6_fill_ifacaddr(skb, ifaca, 3310 NETLINK_CB(cb->skb).pid, 3311 cb->nlh->nlmsg_seq, RTM_GETANYCAST, 3312 NLM_F_MULTI)) <= 0) 3313 goto done; 3314 } 3315 break; 3316 default: 3317 break; 3318 } 3319 read_unlock_bh(&idev->lock); 3320 in6_dev_put(idev); 3321 cont: 3322 idx++; 3323 } 3324 done: 3325 if (err <= 0) { 3326 read_unlock_bh(&idev->lock); 3327 in6_dev_put(idev); 3328 } 3329 cb->args[0] = idx; 3330 cb->args[1] = ip_idx; 3331 return skb->len; 3332 } 3333 3334 static int inet6_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb) 3335 { 3336 enum addr_type_t type = UNICAST_ADDR; 3337 return inet6_dump_addr(skb, cb, type); 3338 } 3339 3340 static int inet6_dump_ifmcaddr(struct sk_buff *skb, struct netlink_callback *cb) 3341 { 3342 enum addr_type_t type = MULTICAST_ADDR; 3343 return inet6_dump_addr(skb, cb, type); 3344 } 3345 3346 3347 static int inet6_dump_ifacaddr(struct sk_buff *skb, struct netlink_callback *cb) 3348 { 3349 enum addr_type_t type = ANYCAST_ADDR; 3350 return inet6_dump_addr(skb, cb, type); 3351 } 3352 3353 static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr* nlh, 3354 void *arg) 3355 { 3356 struct ifaddrmsg *ifm; 3357 struct nlattr *tb[IFA_MAX+1]; 3358 struct in6_addr *addr = NULL; 3359 struct net_device *dev = NULL; 3360 struct inet6_ifaddr *ifa; 3361 struct sk_buff *skb; 3362 int err; 3363 3364 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy); 3365 if (err < 0) 3366 goto errout; 3367 3368 addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL]); 3369 if (addr == NULL) { 3370 err = -EINVAL; 3371 goto errout; 3372 } 3373 3374 ifm = nlmsg_data(nlh); 3375 if (ifm->ifa_index) 3376 dev = __dev_get_by_index(&init_net, ifm->ifa_index); 3377 3378 if ((ifa = ipv6_get_ifaddr(addr, dev, 1)) == NULL) { 3379 err = -EADDRNOTAVAIL; 3380 goto errout; 3381 } 3382 3383 if ((skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL)) == NULL) { 3384 err = -ENOBUFS; 3385 goto errout_ifa; 3386 } 3387 3388 err = inet6_fill_ifaddr(skb, ifa, NETLINK_CB(in_skb).pid, 3389 nlh->nlmsg_seq, RTM_NEWADDR, 0); 3390 if (err < 0) { 3391 /* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */ 3392 WARN_ON(err == -EMSGSIZE); 3393 kfree_skb(skb); 3394 goto errout_ifa; 3395 } 3396 err = rtnl_unicast(skb, NETLINK_CB(in_skb).pid); 3397 errout_ifa: 3398 in6_ifa_put(ifa); 3399 errout: 3400 return err; 3401 } 3402 3403 static void inet6_ifa_notify(int event, struct inet6_ifaddr *ifa) 3404 { 3405 struct sk_buff *skb; 3406 int err = -ENOBUFS; 3407 3408 skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_ATOMIC); 3409 if (skb == NULL) 3410 goto errout; 3411 3412 err = inet6_fill_ifaddr(skb, ifa, 0, 0, event, 0); 3413 if (err < 0) { 3414 /* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */ 3415 WARN_ON(err == -EMSGSIZE); 3416 kfree_skb(skb); 3417 goto errout; 3418 } 3419 err = rtnl_notify(skb, 0, RTNLGRP_IPV6_IFADDR, NULL, GFP_ATOMIC); 3420 errout: 3421 if (err < 0) 3422 rtnl_set_sk_err(RTNLGRP_IPV6_IFADDR, err); 3423 } 3424 3425 static inline void ipv6_store_devconf(struct ipv6_devconf *cnf, 3426 __s32 *array, int bytes) 3427 { 3428 BUG_ON(bytes < (DEVCONF_MAX * 4)); 3429 3430 memset(array, 0, bytes); 3431 array[DEVCONF_FORWARDING] = cnf->forwarding; 3432 array[DEVCONF_HOPLIMIT] = cnf->hop_limit; 3433 array[DEVCONF_MTU6] = cnf->mtu6; 3434 array[DEVCONF_ACCEPT_RA] = cnf->accept_ra; 3435 array[DEVCONF_ACCEPT_REDIRECTS] = cnf->accept_redirects; 3436 array[DEVCONF_AUTOCONF] = cnf->autoconf; 3437 array[DEVCONF_DAD_TRANSMITS] = cnf->dad_transmits; 3438 array[DEVCONF_RTR_SOLICITS] = cnf->rtr_solicits; 3439 array[DEVCONF_RTR_SOLICIT_INTERVAL] = cnf->rtr_solicit_interval; 3440 array[DEVCONF_RTR_SOLICIT_DELAY] = cnf->rtr_solicit_delay; 3441 array[DEVCONF_FORCE_MLD_VERSION] = cnf->force_mld_version; 3442 #ifdef CONFIG_IPV6_PRIVACY 3443 array[DEVCONF_USE_TEMPADDR] = cnf->use_tempaddr; 3444 array[DEVCONF_TEMP_VALID_LFT] = cnf->temp_valid_lft; 3445 array[DEVCONF_TEMP_PREFERED_LFT] = cnf->temp_prefered_lft; 3446 array[DEVCONF_REGEN_MAX_RETRY] = cnf->regen_max_retry; 3447 array[DEVCONF_MAX_DESYNC_FACTOR] = cnf->max_desync_factor; 3448 #endif 3449 array[DEVCONF_MAX_ADDRESSES] = cnf->max_addresses; 3450 array[DEVCONF_ACCEPT_RA_DEFRTR] = cnf->accept_ra_defrtr; 3451 array[DEVCONF_ACCEPT_RA_PINFO] = cnf->accept_ra_pinfo; 3452 #ifdef CONFIG_IPV6_ROUTER_PREF 3453 array[DEVCONF_ACCEPT_RA_RTR_PREF] = cnf->accept_ra_rtr_pref; 3454 array[DEVCONF_RTR_PROBE_INTERVAL] = cnf->rtr_probe_interval; 3455 #ifdef CONFIG_IPV6_ROUTE_INFO 3456 array[DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN] = cnf->accept_ra_rt_info_max_plen; 3457 #endif 3458 #endif 3459 array[DEVCONF_PROXY_NDP] = cnf->proxy_ndp; 3460 array[DEVCONF_ACCEPT_SOURCE_ROUTE] = cnf->accept_source_route; 3461 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 3462 array[DEVCONF_OPTIMISTIC_DAD] = cnf->optimistic_dad; 3463 #endif 3464 } 3465 3466 static inline size_t inet6_if_nlmsg_size(void) 3467 { 3468 return NLMSG_ALIGN(sizeof(struct ifinfomsg)) 3469 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */ 3470 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */ 3471 + nla_total_size(4) /* IFLA_MTU */ 3472 + nla_total_size(4) /* IFLA_LINK */ 3473 + nla_total_size( /* IFLA_PROTINFO */ 3474 nla_total_size(4) /* IFLA_INET6_FLAGS */ 3475 + nla_total_size(sizeof(struct ifla_cacheinfo)) 3476 + nla_total_size(DEVCONF_MAX * 4) /* IFLA_INET6_CONF */ 3477 + nla_total_size(IPSTATS_MIB_MAX * 8) /* IFLA_INET6_STATS */ 3478 + nla_total_size(ICMP6_MIB_MAX * 8) /* IFLA_INET6_ICMP6STATS */ 3479 ); 3480 } 3481 3482 static inline void __snmp6_fill_stats(u64 *stats, void **mib, int items, 3483 int bytes) 3484 { 3485 int i; 3486 int pad = bytes - sizeof(u64) * items; 3487 BUG_ON(pad < 0); 3488 3489 /* Use put_unaligned() because stats may not be aligned for u64. */ 3490 put_unaligned(items, &stats[0]); 3491 for (i = 1; i < items; i++) 3492 put_unaligned(snmp_fold_field(mib, i), &stats[i]); 3493 3494 memset(&stats[items], 0, pad); 3495 } 3496 3497 static void snmp6_fill_stats(u64 *stats, struct inet6_dev *idev, int attrtype, 3498 int bytes) 3499 { 3500 switch(attrtype) { 3501 case IFLA_INET6_STATS: 3502 __snmp6_fill_stats(stats, (void **)idev->stats.ipv6, IPSTATS_MIB_MAX, bytes); 3503 break; 3504 case IFLA_INET6_ICMP6STATS: 3505 __snmp6_fill_stats(stats, (void **)idev->stats.icmpv6, ICMP6_MIB_MAX, bytes); 3506 break; 3507 } 3508 } 3509 3510 static int inet6_fill_ifinfo(struct sk_buff *skb, struct inet6_dev *idev, 3511 u32 pid, u32 seq, int event, unsigned int flags) 3512 { 3513 struct net_device *dev = idev->dev; 3514 struct nlattr *nla; 3515 struct ifinfomsg *hdr; 3516 struct nlmsghdr *nlh; 3517 void *protoinfo; 3518 struct ifla_cacheinfo ci; 3519 3520 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*hdr), flags); 3521 if (nlh == NULL) 3522 return -EMSGSIZE; 3523 3524 hdr = nlmsg_data(nlh); 3525 hdr->ifi_family = AF_INET6; 3526 hdr->__ifi_pad = 0; 3527 hdr->ifi_type = dev->type; 3528 hdr->ifi_index = dev->ifindex; 3529 hdr->ifi_flags = dev_get_flags(dev); 3530 hdr->ifi_change = 0; 3531 3532 NLA_PUT_STRING(skb, IFLA_IFNAME, dev->name); 3533 3534 if (dev->addr_len) 3535 NLA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr); 3536 3537 NLA_PUT_U32(skb, IFLA_MTU, dev->mtu); 3538 if (dev->ifindex != dev->iflink) 3539 NLA_PUT_U32(skb, IFLA_LINK, dev->iflink); 3540 3541 protoinfo = nla_nest_start(skb, IFLA_PROTINFO); 3542 if (protoinfo == NULL) 3543 goto nla_put_failure; 3544 3545 NLA_PUT_U32(skb, IFLA_INET6_FLAGS, idev->if_flags); 3546 3547 ci.max_reasm_len = IPV6_MAXPLEN; 3548 ci.tstamp = (__u32)(TIME_DELTA(idev->tstamp, INITIAL_JIFFIES) / HZ * 100 3549 + TIME_DELTA(idev->tstamp, INITIAL_JIFFIES) % HZ * 100 / HZ); 3550 ci.reachable_time = idev->nd_parms->reachable_time; 3551 ci.retrans_time = idev->nd_parms->retrans_time; 3552 NLA_PUT(skb, IFLA_INET6_CACHEINFO, sizeof(ci), &ci); 3553 3554 nla = nla_reserve(skb, IFLA_INET6_CONF, DEVCONF_MAX * sizeof(s32)); 3555 if (nla == NULL) 3556 goto nla_put_failure; 3557 ipv6_store_devconf(&idev->cnf, nla_data(nla), nla_len(nla)); 3558 3559 /* XXX - MC not implemented */ 3560 3561 nla = nla_reserve(skb, IFLA_INET6_STATS, IPSTATS_MIB_MAX * sizeof(u64)); 3562 if (nla == NULL) 3563 goto nla_put_failure; 3564 snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_STATS, nla_len(nla)); 3565 3566 nla = nla_reserve(skb, IFLA_INET6_ICMP6STATS, ICMP6_MIB_MAX * sizeof(u64)); 3567 if (nla == NULL) 3568 goto nla_put_failure; 3569 snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_ICMP6STATS, nla_len(nla)); 3570 3571 nla_nest_end(skb, protoinfo); 3572 return nlmsg_end(skb, nlh); 3573 3574 nla_put_failure: 3575 nlmsg_cancel(skb, nlh); 3576 return -EMSGSIZE; 3577 } 3578 3579 static int inet6_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb) 3580 { 3581 int idx, err; 3582 int s_idx = cb->args[0]; 3583 struct net_device *dev; 3584 struct inet6_dev *idev; 3585 3586 read_lock(&dev_base_lock); 3587 idx = 0; 3588 for_each_netdev(&init_net, dev) { 3589 if (idx < s_idx) 3590 goto cont; 3591 if ((idev = in6_dev_get(dev)) == NULL) 3592 goto cont; 3593 err = inet6_fill_ifinfo(skb, idev, NETLINK_CB(cb->skb).pid, 3594 cb->nlh->nlmsg_seq, RTM_NEWLINK, NLM_F_MULTI); 3595 in6_dev_put(idev); 3596 if (err <= 0) 3597 break; 3598 cont: 3599 idx++; 3600 } 3601 read_unlock(&dev_base_lock); 3602 cb->args[0] = idx; 3603 3604 return skb->len; 3605 } 3606 3607 void inet6_ifinfo_notify(int event, struct inet6_dev *idev) 3608 { 3609 struct sk_buff *skb; 3610 int err = -ENOBUFS; 3611 3612 skb = nlmsg_new(inet6_if_nlmsg_size(), GFP_ATOMIC); 3613 if (skb == NULL) 3614 goto errout; 3615 3616 err = inet6_fill_ifinfo(skb, idev, 0, 0, event, 0); 3617 if (err < 0) { 3618 /* -EMSGSIZE implies BUG in inet6_if_nlmsg_size() */ 3619 WARN_ON(err == -EMSGSIZE); 3620 kfree_skb(skb); 3621 goto errout; 3622 } 3623 err = rtnl_notify(skb, 0, RTNLGRP_IPV6_IFADDR, NULL, GFP_ATOMIC); 3624 errout: 3625 if (err < 0) 3626 rtnl_set_sk_err(RTNLGRP_IPV6_IFADDR, err); 3627 } 3628 3629 static inline size_t inet6_prefix_nlmsg_size(void) 3630 { 3631 return NLMSG_ALIGN(sizeof(struct prefixmsg)) 3632 + nla_total_size(sizeof(struct in6_addr)) 3633 + nla_total_size(sizeof(struct prefix_cacheinfo)); 3634 } 3635 3636 static int inet6_fill_prefix(struct sk_buff *skb, struct inet6_dev *idev, 3637 struct prefix_info *pinfo, u32 pid, u32 seq, 3638 int event, unsigned int flags) 3639 { 3640 struct prefixmsg *pmsg; 3641 struct nlmsghdr *nlh; 3642 struct prefix_cacheinfo ci; 3643 3644 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*pmsg), flags); 3645 if (nlh == NULL) 3646 return -EMSGSIZE; 3647 3648 pmsg = nlmsg_data(nlh); 3649 pmsg->prefix_family = AF_INET6; 3650 pmsg->prefix_pad1 = 0; 3651 pmsg->prefix_pad2 = 0; 3652 pmsg->prefix_ifindex = idev->dev->ifindex; 3653 pmsg->prefix_len = pinfo->prefix_len; 3654 pmsg->prefix_type = pinfo->type; 3655 pmsg->prefix_pad3 = 0; 3656 pmsg->prefix_flags = 0; 3657 if (pinfo->onlink) 3658 pmsg->prefix_flags |= IF_PREFIX_ONLINK; 3659 if (pinfo->autoconf) 3660 pmsg->prefix_flags |= IF_PREFIX_AUTOCONF; 3661 3662 NLA_PUT(skb, PREFIX_ADDRESS, sizeof(pinfo->prefix), &pinfo->prefix); 3663 3664 ci.preferred_time = ntohl(pinfo->prefered); 3665 ci.valid_time = ntohl(pinfo->valid); 3666 NLA_PUT(skb, PREFIX_CACHEINFO, sizeof(ci), &ci); 3667 3668 return nlmsg_end(skb, nlh); 3669 3670 nla_put_failure: 3671 nlmsg_cancel(skb, nlh); 3672 return -EMSGSIZE; 3673 } 3674 3675 static void inet6_prefix_notify(int event, struct inet6_dev *idev, 3676 struct prefix_info *pinfo) 3677 { 3678 struct sk_buff *skb; 3679 int err = -ENOBUFS; 3680 3681 skb = nlmsg_new(inet6_prefix_nlmsg_size(), GFP_ATOMIC); 3682 if (skb == NULL) 3683 goto errout; 3684 3685 err = inet6_fill_prefix(skb, idev, pinfo, 0, 0, event, 0); 3686 if (err < 0) { 3687 /* -EMSGSIZE implies BUG in inet6_prefix_nlmsg_size() */ 3688 WARN_ON(err == -EMSGSIZE); 3689 kfree_skb(skb); 3690 goto errout; 3691 } 3692 err = rtnl_notify(skb, 0, RTNLGRP_IPV6_PREFIX, NULL, GFP_ATOMIC); 3693 errout: 3694 if (err < 0) 3695 rtnl_set_sk_err(RTNLGRP_IPV6_PREFIX, err); 3696 } 3697 3698 static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp) 3699 { 3700 inet6_ifa_notify(event ? : RTM_NEWADDR, ifp); 3701 3702 switch (event) { 3703 case RTM_NEWADDR: 3704 /* 3705 * If the address was optimistic 3706 * we inserted the route at the start of 3707 * our DAD process, so we don't need 3708 * to do it again 3709 */ 3710 if (!(ifp->rt->rt6i_node)) 3711 ip6_ins_rt(ifp->rt); 3712 if (ifp->idev->cnf.forwarding) 3713 addrconf_join_anycast(ifp); 3714 break; 3715 case RTM_DELADDR: 3716 if (ifp->idev->cnf.forwarding) 3717 addrconf_leave_anycast(ifp); 3718 addrconf_leave_solict(ifp->idev, &ifp->addr); 3719 dst_hold(&ifp->rt->u.dst); 3720 if (ip6_del_rt(ifp->rt)) 3721 dst_free(&ifp->rt->u.dst); 3722 break; 3723 } 3724 } 3725 3726 static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp) 3727 { 3728 rcu_read_lock_bh(); 3729 if (likely(ifp->idev->dead == 0)) 3730 __ipv6_ifa_notify(event, ifp); 3731 rcu_read_unlock_bh(); 3732 } 3733 3734 #ifdef CONFIG_SYSCTL 3735 3736 static 3737 int addrconf_sysctl_forward(ctl_table *ctl, int write, struct file * filp, 3738 void __user *buffer, size_t *lenp, loff_t *ppos) 3739 { 3740 int *valp = ctl->data; 3741 int val = *valp; 3742 int ret; 3743 3744 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 3745 3746 if (write && valp != &ipv6_devconf_dflt.forwarding) { 3747 if (valp != &ipv6_devconf.forwarding) { 3748 if ((!*valp) ^ (!val)) { 3749 struct inet6_dev *idev = (struct inet6_dev *)ctl->extra1; 3750 if (idev == NULL) 3751 return ret; 3752 dev_forward_change(idev); 3753 } 3754 } else { 3755 ipv6_devconf_dflt.forwarding = ipv6_devconf.forwarding; 3756 addrconf_forward_change(); 3757 } 3758 if (*valp) 3759 rt6_purge_dflt_routers(); 3760 } 3761 3762 return ret; 3763 } 3764 3765 static int addrconf_sysctl_forward_strategy(ctl_table *table, 3766 int __user *name, int nlen, 3767 void __user *oldval, 3768 size_t __user *oldlenp, 3769 void __user *newval, size_t newlen) 3770 { 3771 int *valp = table->data; 3772 int new; 3773 3774 if (!newval || !newlen) 3775 return 0; 3776 if (newlen != sizeof(int)) 3777 return -EINVAL; 3778 if (get_user(new, (int __user *)newval)) 3779 return -EFAULT; 3780 if (new == *valp) 3781 return 0; 3782 if (oldval && oldlenp) { 3783 size_t len; 3784 if (get_user(len, oldlenp)) 3785 return -EFAULT; 3786 if (len) { 3787 if (len > table->maxlen) 3788 len = table->maxlen; 3789 if (copy_to_user(oldval, valp, len)) 3790 return -EFAULT; 3791 if (put_user(len, oldlenp)) 3792 return -EFAULT; 3793 } 3794 } 3795 3796 if (valp != &ipv6_devconf_dflt.forwarding) { 3797 if (valp != &ipv6_devconf.forwarding) { 3798 struct inet6_dev *idev = (struct inet6_dev *)table->extra1; 3799 int changed; 3800 if (unlikely(idev == NULL)) 3801 return -ENODEV; 3802 changed = (!*valp) ^ (!new); 3803 *valp = new; 3804 if (changed) 3805 dev_forward_change(idev); 3806 } else { 3807 *valp = new; 3808 addrconf_forward_change(); 3809 } 3810 3811 if (*valp) 3812 rt6_purge_dflt_routers(); 3813 } else 3814 *valp = new; 3815 3816 return 1; 3817 } 3818 3819 static struct addrconf_sysctl_table 3820 { 3821 struct ctl_table_header *sysctl_header; 3822 ctl_table addrconf_vars[__NET_IPV6_MAX]; 3823 ctl_table addrconf_dev[2]; 3824 ctl_table addrconf_conf_dir[2]; 3825 ctl_table addrconf_proto_dir[2]; 3826 ctl_table addrconf_root_dir[2]; 3827 } addrconf_sysctl __read_mostly = { 3828 .sysctl_header = NULL, 3829 .addrconf_vars = { 3830 { 3831 .ctl_name = NET_IPV6_FORWARDING, 3832 .procname = "forwarding", 3833 .data = &ipv6_devconf.forwarding, 3834 .maxlen = sizeof(int), 3835 .mode = 0644, 3836 .proc_handler = &addrconf_sysctl_forward, 3837 .strategy = &addrconf_sysctl_forward_strategy, 3838 }, 3839 { 3840 .ctl_name = NET_IPV6_HOP_LIMIT, 3841 .procname = "hop_limit", 3842 .data = &ipv6_devconf.hop_limit, 3843 .maxlen = sizeof(int), 3844 .mode = 0644, 3845 .proc_handler = proc_dointvec, 3846 }, 3847 { 3848 .ctl_name = NET_IPV6_MTU, 3849 .procname = "mtu", 3850 .data = &ipv6_devconf.mtu6, 3851 .maxlen = sizeof(int), 3852 .mode = 0644, 3853 .proc_handler = &proc_dointvec, 3854 }, 3855 { 3856 .ctl_name = NET_IPV6_ACCEPT_RA, 3857 .procname = "accept_ra", 3858 .data = &ipv6_devconf.accept_ra, 3859 .maxlen = sizeof(int), 3860 .mode = 0644, 3861 .proc_handler = &proc_dointvec, 3862 }, 3863 { 3864 .ctl_name = NET_IPV6_ACCEPT_REDIRECTS, 3865 .procname = "accept_redirects", 3866 .data = &ipv6_devconf.accept_redirects, 3867 .maxlen = sizeof(int), 3868 .mode = 0644, 3869 .proc_handler = &proc_dointvec, 3870 }, 3871 { 3872 .ctl_name = NET_IPV6_AUTOCONF, 3873 .procname = "autoconf", 3874 .data = &ipv6_devconf.autoconf, 3875 .maxlen = sizeof(int), 3876 .mode = 0644, 3877 .proc_handler = &proc_dointvec, 3878 }, 3879 { 3880 .ctl_name = NET_IPV6_DAD_TRANSMITS, 3881 .procname = "dad_transmits", 3882 .data = &ipv6_devconf.dad_transmits, 3883 .maxlen = sizeof(int), 3884 .mode = 0644, 3885 .proc_handler = &proc_dointvec, 3886 }, 3887 { 3888 .ctl_name = NET_IPV6_RTR_SOLICITS, 3889 .procname = "router_solicitations", 3890 .data = &ipv6_devconf.rtr_solicits, 3891 .maxlen = sizeof(int), 3892 .mode = 0644, 3893 .proc_handler = &proc_dointvec, 3894 }, 3895 { 3896 .ctl_name = NET_IPV6_RTR_SOLICIT_INTERVAL, 3897 .procname = "router_solicitation_interval", 3898 .data = &ipv6_devconf.rtr_solicit_interval, 3899 .maxlen = sizeof(int), 3900 .mode = 0644, 3901 .proc_handler = &proc_dointvec_jiffies, 3902 .strategy = &sysctl_jiffies, 3903 }, 3904 { 3905 .ctl_name = NET_IPV6_RTR_SOLICIT_DELAY, 3906 .procname = "router_solicitation_delay", 3907 .data = &ipv6_devconf.rtr_solicit_delay, 3908 .maxlen = sizeof(int), 3909 .mode = 0644, 3910 .proc_handler = &proc_dointvec_jiffies, 3911 .strategy = &sysctl_jiffies, 3912 }, 3913 { 3914 .ctl_name = NET_IPV6_FORCE_MLD_VERSION, 3915 .procname = "force_mld_version", 3916 .data = &ipv6_devconf.force_mld_version, 3917 .maxlen = sizeof(int), 3918 .mode = 0644, 3919 .proc_handler = &proc_dointvec, 3920 }, 3921 #ifdef CONFIG_IPV6_PRIVACY 3922 { 3923 .ctl_name = NET_IPV6_USE_TEMPADDR, 3924 .procname = "use_tempaddr", 3925 .data = &ipv6_devconf.use_tempaddr, 3926 .maxlen = sizeof(int), 3927 .mode = 0644, 3928 .proc_handler = &proc_dointvec, 3929 }, 3930 { 3931 .ctl_name = NET_IPV6_TEMP_VALID_LFT, 3932 .procname = "temp_valid_lft", 3933 .data = &ipv6_devconf.temp_valid_lft, 3934 .maxlen = sizeof(int), 3935 .mode = 0644, 3936 .proc_handler = &proc_dointvec, 3937 }, 3938 { 3939 .ctl_name = NET_IPV6_TEMP_PREFERED_LFT, 3940 .procname = "temp_prefered_lft", 3941 .data = &ipv6_devconf.temp_prefered_lft, 3942 .maxlen = sizeof(int), 3943 .mode = 0644, 3944 .proc_handler = &proc_dointvec, 3945 }, 3946 { 3947 .ctl_name = NET_IPV6_REGEN_MAX_RETRY, 3948 .procname = "regen_max_retry", 3949 .data = &ipv6_devconf.regen_max_retry, 3950 .maxlen = sizeof(int), 3951 .mode = 0644, 3952 .proc_handler = &proc_dointvec, 3953 }, 3954 { 3955 .ctl_name = NET_IPV6_MAX_DESYNC_FACTOR, 3956 .procname = "max_desync_factor", 3957 .data = &ipv6_devconf.max_desync_factor, 3958 .maxlen = sizeof(int), 3959 .mode = 0644, 3960 .proc_handler = &proc_dointvec, 3961 }, 3962 #endif 3963 { 3964 .ctl_name = NET_IPV6_MAX_ADDRESSES, 3965 .procname = "max_addresses", 3966 .data = &ipv6_devconf.max_addresses, 3967 .maxlen = sizeof(int), 3968 .mode = 0644, 3969 .proc_handler = &proc_dointvec, 3970 }, 3971 { 3972 .ctl_name = NET_IPV6_ACCEPT_RA_DEFRTR, 3973 .procname = "accept_ra_defrtr", 3974 .data = &ipv6_devconf.accept_ra_defrtr, 3975 .maxlen = sizeof(int), 3976 .mode = 0644, 3977 .proc_handler = &proc_dointvec, 3978 }, 3979 { 3980 .ctl_name = NET_IPV6_ACCEPT_RA_PINFO, 3981 .procname = "accept_ra_pinfo", 3982 .data = &ipv6_devconf.accept_ra_pinfo, 3983 .maxlen = sizeof(int), 3984 .mode = 0644, 3985 .proc_handler = &proc_dointvec, 3986 }, 3987 #ifdef CONFIG_IPV6_ROUTER_PREF 3988 { 3989 .ctl_name = NET_IPV6_ACCEPT_RA_RTR_PREF, 3990 .procname = "accept_ra_rtr_pref", 3991 .data = &ipv6_devconf.accept_ra_rtr_pref, 3992 .maxlen = sizeof(int), 3993 .mode = 0644, 3994 .proc_handler = &proc_dointvec, 3995 }, 3996 { 3997 .ctl_name = NET_IPV6_RTR_PROBE_INTERVAL, 3998 .procname = "router_probe_interval", 3999 .data = &ipv6_devconf.rtr_probe_interval, 4000 .maxlen = sizeof(int), 4001 .mode = 0644, 4002 .proc_handler = &proc_dointvec_jiffies, 4003 .strategy = &sysctl_jiffies, 4004 }, 4005 #ifdef CONFIG_IPV6_ROUTE_INFO 4006 { 4007 .ctl_name = NET_IPV6_ACCEPT_RA_RT_INFO_MAX_PLEN, 4008 .procname = "accept_ra_rt_info_max_plen", 4009 .data = &ipv6_devconf.accept_ra_rt_info_max_plen, 4010 .maxlen = sizeof(int), 4011 .mode = 0644, 4012 .proc_handler = &proc_dointvec, 4013 }, 4014 #endif 4015 #endif 4016 { 4017 .ctl_name = NET_IPV6_PROXY_NDP, 4018 .procname = "proxy_ndp", 4019 .data = &ipv6_devconf.proxy_ndp, 4020 .maxlen = sizeof(int), 4021 .mode = 0644, 4022 .proc_handler = &proc_dointvec, 4023 }, 4024 { 4025 .ctl_name = NET_IPV6_ACCEPT_SOURCE_ROUTE, 4026 .procname = "accept_source_route", 4027 .data = &ipv6_devconf.accept_source_route, 4028 .maxlen = sizeof(int), 4029 .mode = 0644, 4030 .proc_handler = &proc_dointvec, 4031 }, 4032 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 4033 { 4034 .ctl_name = CTL_UNNUMBERED, 4035 .procname = "optimistic_dad", 4036 .data = &ipv6_devconf.optimistic_dad, 4037 .maxlen = sizeof(int), 4038 .mode = 0644, 4039 .proc_handler = &proc_dointvec, 4040 4041 }, 4042 #endif 4043 { 4044 .ctl_name = 0, /* sentinel */ 4045 } 4046 }, 4047 .addrconf_dev = { 4048 { 4049 .ctl_name = NET_PROTO_CONF_ALL, 4050 .procname = "all", 4051 .mode = 0555, 4052 .child = addrconf_sysctl.addrconf_vars, 4053 }, 4054 { 4055 .ctl_name = 0, /* sentinel */ 4056 } 4057 }, 4058 .addrconf_conf_dir = { 4059 { 4060 .ctl_name = NET_IPV6_CONF, 4061 .procname = "conf", 4062 .mode = 0555, 4063 .child = addrconf_sysctl.addrconf_dev, 4064 }, 4065 { 4066 .ctl_name = 0, /* sentinel */ 4067 } 4068 }, 4069 .addrconf_proto_dir = { 4070 { 4071 .ctl_name = NET_IPV6, 4072 .procname = "ipv6", 4073 .mode = 0555, 4074 .child = addrconf_sysctl.addrconf_conf_dir, 4075 }, 4076 { 4077 .ctl_name = 0, /* sentinel */ 4078 } 4079 }, 4080 .addrconf_root_dir = { 4081 { 4082 .ctl_name = CTL_NET, 4083 .procname = "net", 4084 .mode = 0555, 4085 .child = addrconf_sysctl.addrconf_proto_dir, 4086 }, 4087 { 4088 .ctl_name = 0, /* sentinel */ 4089 } 4090 }, 4091 }; 4092 4093 static void addrconf_sysctl_register(struct inet6_dev *idev, struct ipv6_devconf *p) 4094 { 4095 int i; 4096 struct net_device *dev = idev ? idev->dev : NULL; 4097 struct addrconf_sysctl_table *t; 4098 char *dev_name = NULL; 4099 4100 t = kmemdup(&addrconf_sysctl, sizeof(*t), GFP_KERNEL); 4101 if (t == NULL) 4102 return; 4103 for (i=0; t->addrconf_vars[i].data; i++) { 4104 t->addrconf_vars[i].data += (char*)p - (char*)&ipv6_devconf; 4105 t->addrconf_vars[i].extra1 = idev; /* embedded; no ref */ 4106 } 4107 if (dev) { 4108 dev_name = dev->name; 4109 t->addrconf_dev[0].ctl_name = dev->ifindex; 4110 } else { 4111 dev_name = "default"; 4112 t->addrconf_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT; 4113 } 4114 4115 /* 4116 * Make a copy of dev_name, because '.procname' is regarded as const 4117 * by sysctl and we wouldn't want anyone to change it under our feet 4118 * (see SIOCSIFNAME). 4119 */ 4120 dev_name = kstrdup(dev_name, GFP_KERNEL); 4121 if (!dev_name) 4122 goto free; 4123 4124 t->addrconf_dev[0].procname = dev_name; 4125 4126 t->addrconf_dev[0].child = t->addrconf_vars; 4127 t->addrconf_conf_dir[0].child = t->addrconf_dev; 4128 t->addrconf_proto_dir[0].child = t->addrconf_conf_dir; 4129 t->addrconf_root_dir[0].child = t->addrconf_proto_dir; 4130 4131 t->sysctl_header = register_sysctl_table(t->addrconf_root_dir); 4132 if (t->sysctl_header == NULL) 4133 goto free_procname; 4134 else 4135 p->sysctl = t; 4136 return; 4137 4138 /* error path */ 4139 free_procname: 4140 kfree(dev_name); 4141 free: 4142 kfree(t); 4143 4144 return; 4145 } 4146 4147 static void addrconf_sysctl_unregister(struct ipv6_devconf *p) 4148 { 4149 if (p->sysctl) { 4150 struct addrconf_sysctl_table *t = p->sysctl; 4151 p->sysctl = NULL; 4152 unregister_sysctl_table(t->sysctl_header); 4153 kfree(t->addrconf_dev[0].procname); 4154 kfree(t); 4155 } 4156 } 4157 4158 4159 #endif 4160 4161 /* 4162 * Device notifier 4163 */ 4164 4165 int register_inet6addr_notifier(struct notifier_block *nb) 4166 { 4167 return atomic_notifier_chain_register(&inet6addr_chain, nb); 4168 } 4169 4170 EXPORT_SYMBOL(register_inet6addr_notifier); 4171 4172 int unregister_inet6addr_notifier(struct notifier_block *nb) 4173 { 4174 return atomic_notifier_chain_unregister(&inet6addr_chain,nb); 4175 } 4176 4177 EXPORT_SYMBOL(unregister_inet6addr_notifier); 4178 4179 /* 4180 * Init / cleanup code 4181 */ 4182 4183 int __init addrconf_init(void) 4184 { 4185 int err = 0; 4186 4187 /* The addrconf netdev notifier requires that loopback_dev 4188 * has it's ipv6 private information allocated and setup 4189 * before it can bring up and give link-local addresses 4190 * to other devices which are up. 4191 * 4192 * Unfortunately, loopback_dev is not necessarily the first 4193 * entry in the global dev_base list of net devices. In fact, 4194 * it is likely to be the very last entry on that list. 4195 * So this causes the notifier registry below to try and 4196 * give link-local addresses to all devices besides loopback_dev 4197 * first, then loopback_dev, which cases all the non-loopback_dev 4198 * devices to fail to get a link-local address. 4199 * 4200 * So, as a temporary fix, allocate the ipv6 structure for 4201 * loopback_dev first by hand. 4202 * Longer term, all of the dependencies ipv6 has upon the loopback 4203 * device and it being up should be removed. 4204 */ 4205 rtnl_lock(); 4206 if (!ipv6_add_dev(init_net.loopback_dev)) 4207 err = -ENOMEM; 4208 rtnl_unlock(); 4209 if (err) 4210 return err; 4211 4212 ip6_null_entry.u.dst.dev = init_net.loopback_dev; 4213 ip6_null_entry.rt6i_idev = in6_dev_get(init_net.loopback_dev); 4214 #ifdef CONFIG_IPV6_MULTIPLE_TABLES 4215 ip6_prohibit_entry.u.dst.dev = init_net.loopback_dev; 4216 ip6_prohibit_entry.rt6i_idev = in6_dev_get(init_net.loopback_dev); 4217 ip6_blk_hole_entry.u.dst.dev = init_net.loopback_dev; 4218 ip6_blk_hole_entry.rt6i_idev = in6_dev_get(init_net.loopback_dev); 4219 #endif 4220 4221 register_netdevice_notifier(&ipv6_dev_notf); 4222 4223 addrconf_verify(0); 4224 4225 err = __rtnl_register(PF_INET6, RTM_GETLINK, NULL, inet6_dump_ifinfo); 4226 if (err < 0) 4227 goto errout; 4228 4229 /* Only the first call to __rtnl_register can fail */ 4230 __rtnl_register(PF_INET6, RTM_NEWADDR, inet6_rtm_newaddr, NULL); 4231 __rtnl_register(PF_INET6, RTM_DELADDR, inet6_rtm_deladdr, NULL); 4232 __rtnl_register(PF_INET6, RTM_GETADDR, inet6_rtm_getaddr, inet6_dump_ifaddr); 4233 __rtnl_register(PF_INET6, RTM_GETMULTICAST, NULL, inet6_dump_ifmcaddr); 4234 __rtnl_register(PF_INET6, RTM_GETANYCAST, NULL, inet6_dump_ifacaddr); 4235 4236 #ifdef CONFIG_SYSCTL 4237 addrconf_sysctl.sysctl_header = 4238 register_sysctl_table(addrconf_sysctl.addrconf_root_dir); 4239 addrconf_sysctl_register(NULL, &ipv6_devconf_dflt); 4240 #endif 4241 4242 return 0; 4243 errout: 4244 unregister_netdevice_notifier(&ipv6_dev_notf); 4245 4246 return err; 4247 } 4248 4249 void __exit addrconf_cleanup(void) 4250 { 4251 struct net_device *dev; 4252 struct inet6_ifaddr *ifa; 4253 int i; 4254 4255 unregister_netdevice_notifier(&ipv6_dev_notf); 4256 4257 #ifdef CONFIG_SYSCTL 4258 addrconf_sysctl_unregister(&ipv6_devconf_dflt); 4259 addrconf_sysctl_unregister(&ipv6_devconf); 4260 #endif 4261 4262 rtnl_lock(); 4263 4264 /* 4265 * clean dev list. 4266 */ 4267 4268 for_each_netdev(&init_net, dev) { 4269 if (__in6_dev_get(dev) == NULL) 4270 continue; 4271 addrconf_ifdown(dev, 1); 4272 } 4273 addrconf_ifdown(init_net.loopback_dev, 2); 4274 4275 /* 4276 * Check hash table. 4277 */ 4278 4279 write_lock_bh(&addrconf_hash_lock); 4280 for (i=0; i < IN6_ADDR_HSIZE; i++) { 4281 for (ifa=inet6_addr_lst[i]; ifa; ) { 4282 struct inet6_ifaddr *bifa; 4283 4284 bifa = ifa; 4285 ifa = ifa->lst_next; 4286 printk(KERN_DEBUG "bug: IPv6 address leakage detected: ifa=%p\n", bifa); 4287 /* Do not free it; something is wrong. 4288 Now we can investigate it with debugger. 4289 */ 4290 } 4291 } 4292 write_unlock_bh(&addrconf_hash_lock); 4293 4294 del_timer(&addr_chk_timer); 4295 4296 rtnl_unlock(); 4297 4298 #ifdef CONFIG_PROC_FS 4299 proc_net_remove(&init_net, "if_inet6"); 4300 #endif 4301 } 4302