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