linux/net/ipv6/ndisc.c
<<
>>
Prefs
   1/*
   2 *      Neighbour Discovery for IPv6
   3 *      Linux INET6 implementation
   4 *
   5 *      Authors:
   6 *      Pedro Roque             <roque@di.fc.ul.pt>
   7 *      Mike Shaver             <shaver@ingenia.com>
   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 *      Pierre Ynard                    :       export userland ND options
  19 *                                              through netlink (RDNSS support)
  20 *      Lars Fenneberg                  :       fixed MTU setting on receipt
  21 *                                              of an RA.
  22 *      Janos Farkas                    :       kmalloc failure checks
  23 *      Alexey Kuznetsov                :       state machine reworked
  24 *                                              and moved to net/core.
  25 *      Pekka Savola                    :       RFC2461 validation
  26 *      YOSHIFUJI Hideaki @USAGI        :       Verify ND options properly
  27 */
  28
  29/* Set to 3 to get tracing... */
  30#define ND_DEBUG 1
  31
  32#define ND_PRINTK(fmt, args...) do { if (net_ratelimit()) { printk(fmt, ## args); } } while(0)
  33#define ND_NOPRINTK(x...) do { ; } while(0)
  34#define ND_PRINTK0 ND_PRINTK
  35#define ND_PRINTK1 ND_NOPRINTK
  36#define ND_PRINTK2 ND_NOPRINTK
  37#define ND_PRINTK3 ND_NOPRINTK
  38#if ND_DEBUG >= 1
  39#undef ND_PRINTK1
  40#define ND_PRINTK1 ND_PRINTK
  41#endif
  42#if ND_DEBUG >= 2
  43#undef ND_PRINTK2
  44#define ND_PRINTK2 ND_PRINTK
  45#endif
  46#if ND_DEBUG >= 3
  47#undef ND_PRINTK3
  48#define ND_PRINTK3 ND_PRINTK
  49#endif
  50
  51#include <linux/module.h>
  52#include <linux/errno.h>
  53#include <linux/types.h>
  54#include <linux/socket.h>
  55#include <linux/sockios.h>
  56#include <linux/sched.h>
  57#include <linux/net.h>
  58#include <linux/in6.h>
  59#include <linux/route.h>
  60#include <linux/init.h>
  61#include <linux/rcupdate.h>
  62#ifdef CONFIG_SYSCTL
  63#include <linux/sysctl.h>
  64#endif
  65
  66#include <linux/if_addr.h>
  67#include <linux/if_arp.h>
  68#include <linux/ipv6.h>
  69#include <linux/icmpv6.h>
  70#include <linux/jhash.h>
  71
  72#include <net/sock.h>
  73#include <net/snmp.h>
  74
  75#include <net/ipv6.h>
  76#include <net/protocol.h>
  77#include <net/ndisc.h>
  78#include <net/ip6_route.h>
  79#include <net/addrconf.h>
  80#include <net/icmp.h>
  81
  82#include <net/netlink.h>
  83#include <linux/rtnetlink.h>
  84
  85#include <net/flow.h>
  86#include <net/ip6_checksum.h>
  87#include <net/inet_common.h>
  88#include <linux/proc_fs.h>
  89
  90#include <linux/netfilter.h>
  91#include <linux/netfilter_ipv6.h>
  92
  93static u32 ndisc_hash(const void *pkey, const struct net_device *dev);
  94static int ndisc_constructor(struct neighbour *neigh);
  95static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
  96static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
  97static int pndisc_constructor(struct pneigh_entry *n);
  98static void pndisc_destructor(struct pneigh_entry *n);
  99static void pndisc_redo(struct sk_buff *skb);
 100
 101static struct neigh_ops ndisc_generic_ops = {
 102        .family =               AF_INET6,
 103        .solicit =              ndisc_solicit,
 104        .error_report =         ndisc_error_report,
 105        .output =               neigh_resolve_output,
 106        .connected_output =     neigh_connected_output,
 107        .hh_output =            dev_queue_xmit,
 108        .queue_xmit =           dev_queue_xmit,
 109};
 110
 111static struct neigh_ops ndisc_hh_ops = {
 112        .family =               AF_INET6,
 113        .solicit =              ndisc_solicit,
 114        .error_report =         ndisc_error_report,
 115        .output =               neigh_resolve_output,
 116        .connected_output =     neigh_resolve_output,
 117        .hh_output =            dev_queue_xmit,
 118        .queue_xmit =           dev_queue_xmit,
 119};
 120
 121
 122static struct neigh_ops ndisc_direct_ops = {
 123        .family =               AF_INET6,
 124        .output =               dev_queue_xmit,
 125        .connected_output =     dev_queue_xmit,
 126        .hh_output =            dev_queue_xmit,
 127        .queue_xmit =           dev_queue_xmit,
 128};
 129
 130struct neigh_table nd_tbl = {
 131        .family =       AF_INET6,
 132        .entry_size =   sizeof(struct neighbour) + sizeof(struct in6_addr),
 133        .key_len =      sizeof(struct in6_addr),
 134        .hash =         ndisc_hash,
 135        .constructor =  ndisc_constructor,
 136        .pconstructor = pndisc_constructor,
 137        .pdestructor =  pndisc_destructor,
 138        .proxy_redo =   pndisc_redo,
 139        .id =           "ndisc_cache",
 140        .parms = {
 141                .tbl =                  &nd_tbl,
 142                .base_reachable_time =  30 * HZ,
 143                .retrans_time =  1 * HZ,
 144                .gc_staletime = 60 * HZ,
 145                .reachable_time =               30 * HZ,
 146                .delay_probe_time =      5 * HZ,
 147                .queue_len =             3,
 148                .ucast_probes =  3,
 149                .mcast_probes =  3,
 150                .anycast_delay =         1 * HZ,
 151                .proxy_delay =          (8 * HZ) / 10,
 152                .proxy_qlen =           64,
 153        },
 154        .gc_interval =    30 * HZ,
 155        .gc_thresh1 =    128,
 156        .gc_thresh2 =    512,
 157        .gc_thresh3 =   1024,
 158};
 159
 160/* ND options */
 161struct ndisc_options {
 162        struct nd_opt_hdr *nd_opt_array[__ND_OPT_ARRAY_MAX];
 163#ifdef CONFIG_IPV6_ROUTE_INFO
 164        struct nd_opt_hdr *nd_opts_ri;
 165        struct nd_opt_hdr *nd_opts_ri_end;
 166#endif
 167        struct nd_opt_hdr *nd_useropts;
 168        struct nd_opt_hdr *nd_useropts_end;
 169};
 170
 171#define nd_opts_src_lladdr      nd_opt_array[ND_OPT_SOURCE_LL_ADDR]
 172#define nd_opts_tgt_lladdr      nd_opt_array[ND_OPT_TARGET_LL_ADDR]
 173#define nd_opts_pi              nd_opt_array[ND_OPT_PREFIX_INFO]
 174#define nd_opts_pi_end          nd_opt_array[__ND_OPT_PREFIX_INFO_END]
 175#define nd_opts_rh              nd_opt_array[ND_OPT_REDIRECT_HDR]
 176#define nd_opts_mtu             nd_opt_array[ND_OPT_MTU]
 177
 178#define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
 179
 180/*
 181 * Return the padding between the option length and the start of the
 182 * link addr.  Currently only IP-over-InfiniBand needs this, although
 183 * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may
 184 * also need a pad of 2.
 185 */
 186static int ndisc_addr_option_pad(unsigned short type)
 187{
 188        switch (type) {
 189        case ARPHRD_INFINIBAND: return 2;
 190        default:                return 0;
 191        }
 192}
 193
 194static inline int ndisc_opt_addr_space(struct net_device *dev)
 195{
 196        return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type));
 197}
 198
 199static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len,
 200                                  unsigned short addr_type)
 201{
 202        int space = NDISC_OPT_SPACE(data_len);
 203        int pad   = ndisc_addr_option_pad(addr_type);
 204
 205        opt[0] = type;
 206        opt[1] = space>>3;
 207
 208        memset(opt + 2, 0, pad);
 209        opt   += pad;
 210        space -= pad;
 211
 212        memcpy(opt+2, data, data_len);
 213        data_len += 2;
 214        opt += data_len;
 215        if ((space -= data_len) > 0)
 216                memset(opt, 0, space);
 217        return opt + space;
 218}
 219
 220static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
 221                                            struct nd_opt_hdr *end)
 222{
 223        int type;
 224        if (!cur || !end || cur >= end)
 225                return NULL;
 226        type = cur->nd_opt_type;
 227        do {
 228                cur = ((void *)cur) + (cur->nd_opt_len << 3);
 229        } while(cur < end && cur->nd_opt_type != type);
 230        return (cur <= end && cur->nd_opt_type == type ? cur : NULL);
 231}
 232
 233static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
 234{
 235        return (opt->nd_opt_type == ND_OPT_RDNSS);
 236}
 237
 238static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur,
 239                                             struct nd_opt_hdr *end)
 240{
 241        if (!cur || !end || cur >= end)
 242                return NULL;
 243        do {
 244                cur = ((void *)cur) + (cur->nd_opt_len << 3);
 245        } while(cur < end && !ndisc_is_useropt(cur));
 246        return (cur <= end && ndisc_is_useropt(cur) ? cur : NULL);
 247}
 248
 249static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
 250                                                 struct ndisc_options *ndopts)
 251{
 252        struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
 253
 254        if (!nd_opt || opt_len < 0 || !ndopts)
 255                return NULL;
 256        memset(ndopts, 0, sizeof(*ndopts));
 257        while (opt_len) {
 258                int l;
 259                if (opt_len < sizeof(struct nd_opt_hdr))
 260                        return NULL;
 261                l = nd_opt->nd_opt_len << 3;
 262                if (opt_len < l || l == 0)
 263                        return NULL;
 264                switch (nd_opt->nd_opt_type) {
 265                case ND_OPT_SOURCE_LL_ADDR:
 266                case ND_OPT_TARGET_LL_ADDR:
 267                case ND_OPT_MTU:
 268                case ND_OPT_REDIRECT_HDR:
 269                        if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
 270                                ND_PRINTK2(KERN_WARNING
 271                                           "%s(): duplicated ND6 option found: type=%d\n",
 272                                           __func__,
 273                                           nd_opt->nd_opt_type);
 274                        } else {
 275                                ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
 276                        }
 277                        break;
 278                case ND_OPT_PREFIX_INFO:
 279                        ndopts->nd_opts_pi_end = nd_opt;
 280                        if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
 281                                ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
 282                        break;
 283#ifdef CONFIG_IPV6_ROUTE_INFO
 284                case ND_OPT_ROUTE_INFO:
 285                        ndopts->nd_opts_ri_end = nd_opt;
 286                        if (!ndopts->nd_opts_ri)
 287                                ndopts->nd_opts_ri = nd_opt;
 288                        break;
 289#endif
 290                default:
 291                        if (ndisc_is_useropt(nd_opt)) {
 292                                ndopts->nd_useropts_end = nd_opt;
 293                                if (!ndopts->nd_useropts)
 294                                        ndopts->nd_useropts = nd_opt;
 295                        } else {
 296                                /*
 297                                 * Unknown options must be silently ignored,
 298                                 * to accommodate future extension to the
 299                                 * protocol.
 300                                 */
 301                                ND_PRINTK2(KERN_NOTICE
 302                                           "%s(): ignored unsupported option; type=%d, len=%d\n",
 303                                           __func__,
 304                                           nd_opt->nd_opt_type, nd_opt->nd_opt_len);
 305                        }
 306                }
 307                opt_len -= l;
 308                nd_opt = ((void *)nd_opt) + l;
 309        }
 310        return ndopts;
 311}
 312
 313static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p,
 314                                      struct net_device *dev)
 315{
 316        u8 *lladdr = (u8 *)(p + 1);
 317        int lladdrlen = p->nd_opt_len << 3;
 318        int prepad = ndisc_addr_option_pad(dev->type);
 319        if (lladdrlen != NDISC_OPT_SPACE(dev->addr_len + prepad))
 320                return NULL;
 321        return (lladdr + prepad);
 322}
 323
 324int ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
 325{
 326        switch (dev->type) {
 327        case ARPHRD_ETHER:
 328        case ARPHRD_IEEE802:    /* Not sure. Check it later. --ANK */
 329        case ARPHRD_FDDI:
 330                ipv6_eth_mc_map(addr, buf);
 331                return 0;
 332        case ARPHRD_IEEE802_TR:
 333                ipv6_tr_mc_map(addr,buf);
 334                return 0;
 335        case ARPHRD_ARCNET:
 336                ipv6_arcnet_mc_map(addr, buf);
 337                return 0;
 338        case ARPHRD_INFINIBAND:
 339                ipv6_ib_mc_map(addr, dev->broadcast, buf);
 340                return 0;
 341        default:
 342                if (dir) {
 343                        memcpy(buf, dev->broadcast, dev->addr_len);
 344                        return 0;
 345                }
 346        }
 347        return -EINVAL;
 348}
 349
 350EXPORT_SYMBOL(ndisc_mc_map);
 351
 352static u32 ndisc_hash(const void *pkey, const struct net_device *dev)
 353{
 354        const u32 *p32 = pkey;
 355        u32 addr_hash, i;
 356
 357        addr_hash = 0;
 358        for (i = 0; i < (sizeof(struct in6_addr) / sizeof(u32)); i++)
 359                addr_hash ^= *p32++;
 360
 361        return jhash_2words(addr_hash, dev->ifindex, nd_tbl.hash_rnd);
 362}
 363
 364static int ndisc_constructor(struct neighbour *neigh)
 365{
 366        struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;
 367        struct net_device *dev = neigh->dev;
 368        struct inet6_dev *in6_dev;
 369        struct neigh_parms *parms;
 370        int is_multicast = ipv6_addr_is_multicast(addr);
 371
 372        rcu_read_lock();
 373        in6_dev = in6_dev_get(dev);
 374        if (in6_dev == NULL) {
 375                rcu_read_unlock();
 376                return -EINVAL;
 377        }
 378
 379        parms = in6_dev->nd_parms;
 380        __neigh_parms_put(neigh->parms);
 381        neigh->parms = neigh_parms_clone(parms);
 382        rcu_read_unlock();
 383
 384        neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
 385        if (!dev->header_ops) {
 386                neigh->nud_state = NUD_NOARP;
 387                neigh->ops = &ndisc_direct_ops;
 388                neigh->output = neigh->ops->queue_xmit;
 389        } else {
 390                if (is_multicast) {
 391                        neigh->nud_state = NUD_NOARP;
 392                        ndisc_mc_map(addr, neigh->ha, dev, 1);
 393                } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
 394                        neigh->nud_state = NUD_NOARP;
 395                        memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
 396                        if (dev->flags&IFF_LOOPBACK)
 397                                neigh->type = RTN_LOCAL;
 398                } else if (dev->flags&IFF_POINTOPOINT) {
 399                        neigh->nud_state = NUD_NOARP;
 400                        memcpy(neigh->ha, dev->broadcast, dev->addr_len);
 401                }
 402                if (dev->header_ops->cache)
 403                        neigh->ops = &ndisc_hh_ops;
 404                else
 405                        neigh->ops = &ndisc_generic_ops;
 406                if (neigh->nud_state&NUD_VALID)
 407                        neigh->output = neigh->ops->connected_output;
 408                else
 409                        neigh->output = neigh->ops->output;
 410        }
 411        in6_dev_put(in6_dev);
 412        return 0;
 413}
 414
 415static int pndisc_constructor(struct pneigh_entry *n)
 416{
 417        struct in6_addr *addr = (struct in6_addr*)&n->key;
 418        struct in6_addr maddr;
 419        struct net_device *dev = n->dev;
 420
 421        if (dev == NULL || __in6_dev_get(dev) == NULL)
 422                return -EINVAL;
 423        addrconf_addr_solict_mult(addr, &maddr);
 424        ipv6_dev_mc_inc(dev, &maddr);
 425        return 0;
 426}
 427
 428static void pndisc_destructor(struct pneigh_entry *n)
 429{
 430        struct in6_addr *addr = (struct in6_addr*)&n->key;
 431        struct in6_addr maddr;
 432        struct net_device *dev = n->dev;
 433
 434        if (dev == NULL || __in6_dev_get(dev) == NULL)
 435                return;
 436        addrconf_addr_solict_mult(addr, &maddr);
 437        ipv6_dev_mc_dec(dev, &maddr);
 438}
 439
 440struct sk_buff *ndisc_build_skb(struct net_device *dev,
 441                                const struct in6_addr *daddr,
 442                                const struct in6_addr *saddr,
 443                                struct icmp6hdr *icmp6h,
 444                                const struct in6_addr *target,
 445                                int llinfo)
 446{
 447        struct net *net = dev_net(dev);
 448        struct sock *sk = net->ipv6.ndisc_sk;
 449        struct sk_buff *skb;
 450        struct icmp6hdr *hdr;
 451        int len;
 452        int err;
 453        u8 *opt;
 454
 455        if (!dev->addr_len)
 456                llinfo = 0;
 457
 458        len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0);
 459        if (llinfo)
 460                len += ndisc_opt_addr_space(dev);
 461
 462        skb = sock_alloc_send_skb(sk,
 463                                  (MAX_HEADER + sizeof(struct ipv6hdr) +
 464                                   len + LL_ALLOCATED_SPACE(dev)),
 465                                  1, &err);
 466        if (!skb) {
 467                ND_PRINTK0(KERN_ERR
 468                           "ICMPv6 ND: %s() failed to allocate an skb.\n",
 469                           __func__);
 470                return NULL;
 471        }
 472
 473        skb_reserve(skb, LL_RESERVED_SPACE(dev));
 474        ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
 475
 476        skb->transport_header = skb->tail;
 477        skb_put(skb, len);
 478
 479        hdr = (struct icmp6hdr *)skb_transport_header(skb);
 480        memcpy(hdr, icmp6h, sizeof(*hdr));
 481
 482        opt = skb_transport_header(skb) + sizeof(struct icmp6hdr);
 483        if (target) {
 484                ipv6_addr_copy((struct in6_addr *)opt, target);
 485                opt += sizeof(*target);
 486        }
 487
 488        if (llinfo)
 489                ndisc_fill_addr_option(opt, llinfo, dev->dev_addr,
 490                                       dev->addr_len, dev->type);
 491
 492        hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len,
 493                                           IPPROTO_ICMPV6,
 494                                           csum_partial(hdr,
 495                                                        len, 0));
 496
 497        return skb;
 498}
 499
 500EXPORT_SYMBOL(ndisc_build_skb);
 501
 502void ndisc_send_skb(struct sk_buff *skb,
 503                    struct net_device *dev,
 504                    struct neighbour *neigh,
 505                    const struct in6_addr *daddr,
 506                    const struct in6_addr *saddr,
 507                    struct icmp6hdr *icmp6h)
 508{
 509        struct flowi fl;
 510        struct dst_entry *dst;
 511        struct net *net = dev_net(dev);
 512        struct sock *sk = net->ipv6.ndisc_sk;
 513        struct inet6_dev *idev;
 514        int err;
 515        u8 type;
 516
 517        type = icmp6h->icmp6_type;
 518
 519        icmpv6_flow_init(sk, &fl, type, saddr, daddr, dev->ifindex);
 520
 521        dst = icmp6_dst_alloc(dev, neigh, daddr);
 522        if (!dst) {
 523                kfree_skb(skb);
 524                return;
 525        }
 526
 527        err = xfrm_lookup(net, &dst, &fl, NULL, 0);
 528        if (err < 0) {
 529                kfree_skb(skb);
 530                return;
 531        }
 532
 533        skb->dst = dst;
 534
 535        idev = in6_dev_get(dst->dev);
 536        IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTREQUESTS);
 537
 538        err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
 539                      dst_output);
 540        if (!err) {
 541                ICMP6MSGOUT_INC_STATS(net, idev, type);
 542                ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
 543        }
 544
 545        if (likely(idev != NULL))
 546                in6_dev_put(idev);
 547}
 548
 549EXPORT_SYMBOL(ndisc_send_skb);
 550
 551/*
 552 *      Send a Neighbour Discover packet
 553 */
 554static void __ndisc_send(struct net_device *dev,
 555                         struct neighbour *neigh,
 556                         const struct in6_addr *daddr,
 557                         const struct in6_addr *saddr,
 558                         struct icmp6hdr *icmp6h, const struct in6_addr *target,
 559                         int llinfo)
 560{
 561        struct sk_buff *skb;
 562
 563        skb = ndisc_build_skb(dev, daddr, saddr, icmp6h, target, llinfo);
 564        if (!skb)
 565                return;
 566
 567        ndisc_send_skb(skb, dev, neigh, daddr, saddr, icmp6h);
 568}
 569
 570static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
 571                          const struct in6_addr *daddr,
 572                          const struct in6_addr *solicited_addr,
 573                          int router, int solicited, int override, int inc_opt)
 574{
 575        struct in6_addr tmpaddr;
 576        struct inet6_ifaddr *ifp;
 577        const struct in6_addr *src_addr;
 578        struct icmp6hdr icmp6h = {
 579                .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
 580        };
 581
 582        /* for anycast or proxy, solicited_addr != src_addr */
 583        ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
 584        if (ifp) {
 585                src_addr = solicited_addr;
 586                if (ifp->flags & IFA_F_OPTIMISTIC)
 587                        override = 0;
 588                in6_ifa_put(ifp);
 589        } else {
 590                if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
 591                                       inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
 592                                       &tmpaddr))
 593                        return;
 594                src_addr = &tmpaddr;
 595        }
 596
 597        icmp6h.icmp6_router = router;
 598        icmp6h.icmp6_solicited = solicited;
 599        icmp6h.icmp6_override = override;
 600
 601        __ndisc_send(dev, neigh, daddr, src_addr,
 602                     &icmp6h, solicited_addr,
 603                     inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
 604}
 605
 606void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
 607                   const struct in6_addr *solicit,
 608                   const struct in6_addr *daddr, const struct in6_addr *saddr)
 609{
 610        struct in6_addr addr_buf;
 611        struct icmp6hdr icmp6h = {
 612                .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
 613        };
 614
 615        if (saddr == NULL) {
 616                if (ipv6_get_lladdr(dev, &addr_buf,
 617                                   (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
 618                        return;
 619                saddr = &addr_buf;
 620        }
 621
 622        __ndisc_send(dev, neigh, daddr, saddr,
 623                     &icmp6h, solicit,
 624                     !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
 625}
 626
 627void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
 628                   const struct in6_addr *daddr)
 629{
 630        struct icmp6hdr icmp6h = {
 631                .icmp6_type = NDISC_ROUTER_SOLICITATION,
 632        };
 633        int send_sllao = dev->addr_len;
 634
 635#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
 636        /*
 637         * According to section 2.2 of RFC 4429, we must not
 638         * send router solicitations with a sllao from
 639         * optimistic addresses, but we may send the solicitation
 640         * if we don't include the sllao.  So here we check
 641         * if our address is optimistic, and if so, we
 642         * suppress the inclusion of the sllao.
 643         */
 644        if (send_sllao) {
 645                struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
 646                                                           dev, 1);
 647                if (ifp) {
 648                        if (ifp->flags & IFA_F_OPTIMISTIC)  {
 649                                send_sllao = 0;
 650                        }
 651                        in6_ifa_put(ifp);
 652                } else {
 653                        send_sllao = 0;
 654                }
 655        }
 656#endif
 657        __ndisc_send(dev, NULL, daddr, saddr,
 658                     &icmp6h, NULL,
 659                     send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
 660}
 661
 662
 663static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
 664{
 665        /*
 666         *      "The sender MUST return an ICMP
 667         *       destination unreachable"
 668         */
 669        dst_link_failure(skb);
 670        kfree_skb(skb);
 671}
 672
 673/* Called with locked neigh: either read or both */
 674
 675static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
 676{
 677        struct in6_addr *saddr = NULL;
 678        struct in6_addr mcaddr;
 679        struct net_device *dev = neigh->dev;
 680        struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
 681        int probes = atomic_read(&neigh->probes);
 682
 683        if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
 684                saddr = &ipv6_hdr(skb)->saddr;
 685
 686        if ((probes -= neigh->parms->ucast_probes) < 0) {
 687                if (!(neigh->nud_state & NUD_VALID)) {
 688                        ND_PRINTK1(KERN_DEBUG "%s(): trying to ucast probe in NUD_INVALID: %pI6\n",
 689                                   __func__, target);
 690                }
 691                ndisc_send_ns(dev, neigh, target, target, saddr);
 692        } else if ((probes -= neigh->parms->app_probes) < 0) {
 693#ifdef CONFIG_ARPD
 694                neigh_app_ns(neigh);
 695#endif
 696        } else {
 697                addrconf_addr_solict_mult(target, &mcaddr);
 698                ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
 699        }
 700}
 701
 702static int pndisc_is_router(const void *pkey,
 703                            struct net_device *dev)
 704{
 705        struct pneigh_entry *n;
 706        int ret = -1;
 707
 708        read_lock_bh(&nd_tbl.lock);
 709        n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
 710        if (n)
 711                ret = !!(n->flags & NTF_ROUTER);
 712        read_unlock_bh(&nd_tbl.lock);
 713
 714        return ret;
 715}
 716
 717static void ndisc_recv_ns(struct sk_buff *skb)
 718{
 719        struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
 720        struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
 721        struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
 722        u8 *lladdr = NULL;
 723        u32 ndoptlen = skb->tail - (skb->transport_header +
 724                                    offsetof(struct nd_msg, opt));
 725        struct ndisc_options ndopts;
 726        struct net_device *dev = skb->dev;
 727        struct inet6_ifaddr *ifp;
 728        struct inet6_dev *idev = NULL;
 729        struct neighbour *neigh;
 730        int dad = ipv6_addr_any(saddr);
 731        int inc;
 732        int is_router = -1;
 733
 734        if (ipv6_addr_is_multicast(&msg->target)) {
 735                ND_PRINTK2(KERN_WARNING
 736                           "ICMPv6 NS: multicast target address");
 737                return;
 738        }
 739
 740        /*
 741         * RFC2461 7.1.1:
 742         * DAD has to be destined for solicited node multicast address.
 743         */
 744        if (dad &&
 745            !(daddr->s6_addr32[0] == htonl(0xff020000) &&
 746              daddr->s6_addr32[1] == htonl(0x00000000) &&
 747              daddr->s6_addr32[2] == htonl(0x00000001) &&
 748              daddr->s6_addr [12] == 0xff )) {
 749                ND_PRINTK2(KERN_WARNING
 750                           "ICMPv6 NS: bad DAD packet (wrong destination)\n");
 751                return;
 752        }
 753
 754        if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
 755                ND_PRINTK2(KERN_WARNING
 756                           "ICMPv6 NS: invalid ND options\n");
 757                return;
 758        }
 759
 760        if (ndopts.nd_opts_src_lladdr) {
 761                lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
 762                if (!lladdr) {
 763                        ND_PRINTK2(KERN_WARNING
 764                                   "ICMPv6 NS: invalid link-layer address length\n");
 765                        return;
 766                }
 767
 768                /* RFC2461 7.1.1:
 769                 *      If the IP source address is the unspecified address,
 770                 *      there MUST NOT be source link-layer address option
 771                 *      in the message.
 772                 */
 773                if (dad) {
 774                        ND_PRINTK2(KERN_WARNING
 775                                   "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
 776                        return;
 777                }
 778        }
 779
 780        inc = ipv6_addr_is_multicast(daddr);
 781
 782        ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
 783        if (ifp) {
 784
 785                if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
 786                        if (dad) {
 787                                if (dev->type == ARPHRD_IEEE802_TR) {
 788                                        const unsigned char *sadr;
 789                                        sadr = skb_mac_header(skb);
 790                                        if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
 791                                            sadr[9] == dev->dev_addr[1] &&
 792                                            sadr[10] == dev->dev_addr[2] &&
 793                                            sadr[11] == dev->dev_addr[3] &&
 794                                            sadr[12] == dev->dev_addr[4] &&
 795                                            sadr[13] == dev->dev_addr[5]) {
 796                                                /* looped-back to us */
 797                                                goto out;
 798                                        }
 799                                }
 800
 801                                /*
 802                                 * We are colliding with another node
 803                                 * who is doing DAD
 804                                 * so fail our DAD process
 805                                 */
 806                                addrconf_dad_failure(ifp);
 807                                return;
 808                        } else {
 809                                /*
 810                                 * This is not a dad solicitation.
 811                                 * If we are an optimistic node,
 812                                 * we should respond.
 813                                 * Otherwise, we should ignore it.
 814                                 */
 815                                if (!(ifp->flags & IFA_F_OPTIMISTIC))
 816                                        goto out;
 817                        }
 818                }
 819
 820                idev = ifp->idev;
 821        } else {
 822                struct net *net = dev_net(dev);
 823
 824                idev = in6_dev_get(dev);
 825                if (!idev) {
 826                        /* XXX: count this drop? */
 827                        return;
 828                }
 829
 830                if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
 831                    (idev->cnf.forwarding &&
 832                     (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
 833                     (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
 834                        if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
 835                            skb->pkt_type != PACKET_HOST &&
 836                            inc != 0 &&
 837                            idev->nd_parms->proxy_delay != 0) {
 838                                /*
 839                                 * for anycast or proxy,
 840                                 * sender should delay its response
 841                                 * by a random time between 0 and
 842                                 * MAX_ANYCAST_DELAY_TIME seconds.
 843                                 * (RFC2461) -- yoshfuji
 844                                 */
 845                                struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
 846                                if (n)
 847                                        pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
 848                                goto out;
 849                        }
 850                } else
 851                        goto out;
 852        }
 853
 854        if (is_router < 0)
 855                is_router = !!idev->cnf.forwarding;
 856
 857        if (dad) {
 858                ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
 859                              is_router, 0, (ifp != NULL), 1);
 860                goto out;
 861        }
 862
 863        if (inc)
 864                NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
 865        else
 866                NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
 867
 868        /*
 869         *      update / create cache entry
 870         *      for the source address
 871         */
 872        neigh = __neigh_lookup(&nd_tbl, saddr, dev,
 873                               !inc || lladdr || !dev->addr_len);
 874        if (neigh)
 875                neigh_update(neigh, lladdr, NUD_STALE,
 876                             NEIGH_UPDATE_F_WEAK_OVERRIDE|
 877                             NEIGH_UPDATE_F_OVERRIDE);
 878        if (neigh || !dev->header_ops) {
 879                ndisc_send_na(dev, neigh, saddr, &msg->target,
 880                              is_router,
 881                              1, (ifp != NULL && inc), inc);
 882                if (neigh)
 883                        neigh_release(neigh);
 884        }
 885
 886out:
 887        if (ifp)
 888                in6_ifa_put(ifp);
 889        else
 890                in6_dev_put(idev);
 891
 892        return;
 893}
 894
 895static void ndisc_recv_na(struct sk_buff *skb)
 896{
 897        struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
 898        struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
 899        struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
 900        u8 *lladdr = NULL;
 901        u32 ndoptlen = skb->tail - (skb->transport_header +
 902                                    offsetof(struct nd_msg, opt));
 903        struct ndisc_options ndopts;
 904        struct net_device *dev = skb->dev;
 905        struct inet6_ifaddr *ifp;
 906        struct neighbour *neigh;
 907
 908        if (skb->len < sizeof(struct nd_msg)) {
 909                ND_PRINTK2(KERN_WARNING
 910                           "ICMPv6 NA: packet too short\n");
 911                return;
 912        }
 913
 914        if (ipv6_addr_is_multicast(&msg->target)) {
 915                ND_PRINTK2(KERN_WARNING
 916                           "ICMPv6 NA: target address is multicast.\n");
 917                return;
 918        }
 919
 920        if (ipv6_addr_is_multicast(daddr) &&
 921            msg->icmph.icmp6_solicited) {
 922                ND_PRINTK2(KERN_WARNING
 923                           "ICMPv6 NA: solicited NA is multicasted.\n");
 924                return;
 925        }
 926
 927        if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
 928                ND_PRINTK2(KERN_WARNING
 929                           "ICMPv6 NS: invalid ND option\n");
 930                return;
 931        }
 932        if (ndopts.nd_opts_tgt_lladdr) {
 933                lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
 934                if (!lladdr) {
 935                        ND_PRINTK2(KERN_WARNING
 936                                   "ICMPv6 NA: invalid link-layer address length\n");
 937                        return;
 938                }
 939        }
 940        ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
 941        if (ifp) {
 942                if (ifp->flags & IFA_F_TENTATIVE) {
 943                        addrconf_dad_failure(ifp);
 944                        return;
 945                }
 946                /* What should we make now? The advertisement
 947                   is invalid, but ndisc specs say nothing
 948                   about it. It could be misconfiguration, or
 949                   an smart proxy agent tries to help us :-)
 950
 951                   We should not print the error if NA has been
 952                   received from loopback - it is just our own
 953                   unsolicited advertisement.
 954                 */
 955                if (skb->pkt_type != PACKET_LOOPBACK)
 956                        ND_PRINTK1(KERN_WARNING
 957                           "ICMPv6 NA: someone advertises our address on %s!\n",
 958                           ifp->idev->dev->name);
 959                in6_ifa_put(ifp);
 960                return;
 961        }
 962        neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
 963
 964        if (neigh) {
 965                u8 old_flags = neigh->flags;
 966                struct net *net = dev_net(dev);
 967
 968                if (neigh->nud_state & NUD_FAILED)
 969                        goto out;
 970
 971                /*
 972                 * Don't update the neighbor cache entry on a proxy NA from
 973                 * ourselves because either the proxied node is off link or it
 974                 * has already sent a NA to us.
 975                 */
 976                if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
 977                    net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
 978                    pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
 979                        /* XXX: idev->cnf.prixy_ndp */
 980                        goto out;
 981                }
 982
 983                neigh_update(neigh, lladdr,
 984                             msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
 985                             NEIGH_UPDATE_F_WEAK_OVERRIDE|
 986                             (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
 987                             NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
 988                             (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
 989
 990                if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
 991                        /*
 992                         * Change: router to host
 993                         */
 994                        struct rt6_info *rt;
 995                        rt = rt6_get_dflt_router(saddr, dev);
 996                        if (rt)
 997                                ip6_del_rt(rt);
 998                }
 999
1000out:
1001                neigh_release(neigh);
1002        }
1003}
1004
1005static void ndisc_recv_rs(struct sk_buff *skb)
1006{
1007        struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
1008        unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
1009        struct neighbour *neigh;
1010        struct inet6_dev *idev;
1011        struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
1012        struct ndisc_options ndopts;
1013        u8 *lladdr = NULL;
1014
1015        if (skb->len < sizeof(*rs_msg))
1016                return;
1017
1018        idev = in6_dev_get(skb->dev);
1019        if (!idev) {
1020                if (net_ratelimit())
1021                        ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1022                return;
1023        }
1024
1025        /* Don't accept RS if we're not in router mode */
1026        if (!idev->cnf.forwarding)
1027                goto out;
1028
1029        /*
1030         * Don't update NCE if src = ::;
1031         * this implies that the source node has no ip address assigned yet.
1032         */
1033        if (ipv6_addr_any(saddr))
1034                goto out;
1035
1036        /* Parse ND options */
1037        if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
1038                if (net_ratelimit())
1039                        ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1040                goto out;
1041        }
1042
1043        if (ndopts.nd_opts_src_lladdr) {
1044                lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1045                                             skb->dev);
1046                if (!lladdr)
1047                        goto out;
1048        }
1049
1050        neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1051        if (neigh) {
1052                neigh_update(neigh, lladdr, NUD_STALE,
1053                             NEIGH_UPDATE_F_WEAK_OVERRIDE|
1054                             NEIGH_UPDATE_F_OVERRIDE|
1055                             NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1056                neigh_release(neigh);
1057        }
1058out:
1059        in6_dev_put(idev);
1060}
1061
1062static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1063{
1064        struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1065        struct sk_buff *skb;
1066        struct nlmsghdr *nlh;
1067        struct nduseroptmsg *ndmsg;
1068        struct net *net = dev_net(ra->dev);
1069        int err;
1070        int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1071                                    + (opt->nd_opt_len << 3));
1072        size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1073
1074        skb = nlmsg_new(msg_size, GFP_ATOMIC);
1075        if (skb == NULL) {
1076                err = -ENOBUFS;
1077                goto errout;
1078        }
1079
1080        nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1081        if (nlh == NULL) {
1082                goto nla_put_failure;
1083        }
1084
1085        ndmsg = nlmsg_data(nlh);
1086        ndmsg->nduseropt_family = AF_INET6;
1087        ndmsg->nduseropt_ifindex = ra->dev->ifindex;
1088        ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1089        ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1090        ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1091
1092        memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1093
1094        NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1095                &ipv6_hdr(ra)->saddr);
1096        nlmsg_end(skb, nlh);
1097
1098        err = rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL,
1099                          GFP_ATOMIC);
1100        if (err < 0)
1101                goto errout;
1102
1103        return;
1104
1105nla_put_failure:
1106        nlmsg_free(skb);
1107        err = -EMSGSIZE;
1108errout:
1109        rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1110}
1111
1112static void ndisc_router_discovery(struct sk_buff *skb)
1113{
1114        struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1115        struct neighbour *neigh = NULL;
1116        struct inet6_dev *in6_dev;
1117        struct rt6_info *rt = NULL;
1118        int lifetime;
1119        struct ndisc_options ndopts;
1120        int optlen;
1121        unsigned int pref = 0;
1122
1123        __u8 * opt = (__u8 *)(ra_msg + 1);
1124
1125        optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
1126
1127        if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1128                ND_PRINTK2(KERN_WARNING
1129                           "ICMPv6 RA: source address is not link-local.\n");
1130                return;
1131        }
1132        if (optlen < 0) {
1133                ND_PRINTK2(KERN_WARNING
1134                           "ICMPv6 RA: packet too short\n");
1135                return;
1136        }
1137
1138#ifdef CONFIG_IPV6_NDISC_NODETYPE
1139        if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1140                ND_PRINTK2(KERN_WARNING
1141                           "ICMPv6 RA: from host or unauthorized router\n");
1142                return;
1143        }
1144#endif
1145
1146        /*
1147         *      set the RA_RECV flag in the interface
1148         */
1149
1150        in6_dev = in6_dev_get(skb->dev);
1151        if (in6_dev == NULL) {
1152                ND_PRINTK0(KERN_ERR
1153                           "ICMPv6 RA: can't find inet6 device for %s.\n",
1154                           skb->dev->name);
1155                return;
1156        }
1157        if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {
1158                in6_dev_put(in6_dev);
1159                return;
1160        }
1161
1162        if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1163                in6_dev_put(in6_dev);
1164                ND_PRINTK2(KERN_WARNING
1165                           "ICMP6 RA: invalid ND options\n");
1166                return;
1167        }
1168
1169#ifdef CONFIG_IPV6_NDISC_NODETYPE
1170        /* skip link-specific parameters from interior routers */
1171        if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1172                goto skip_linkparms;
1173#endif
1174
1175        if (in6_dev->if_flags & IF_RS_SENT) {
1176                /*
1177                 *      flag that an RA was received after an RS was sent
1178                 *      out on this interface.
1179                 */
1180                in6_dev->if_flags |= IF_RA_RCVD;
1181        }
1182
1183        /*
1184         * Remember the managed/otherconf flags from most recently
1185         * received RA message (RFC 2462) -- yoshfuji
1186         */
1187        in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1188                                IF_RA_OTHERCONF)) |
1189                                (ra_msg->icmph.icmp6_addrconf_managed ?
1190                                        IF_RA_MANAGED : 0) |
1191                                (ra_msg->icmph.icmp6_addrconf_other ?
1192                                        IF_RA_OTHERCONF : 0);
1193
1194        if (!in6_dev->cnf.accept_ra_defrtr)
1195                goto skip_defrtr;
1196
1197        lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1198
1199#ifdef CONFIG_IPV6_ROUTER_PREF
1200        pref = ra_msg->icmph.icmp6_router_pref;
1201        /* 10b is handled as if it were 00b (medium) */
1202        if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1203            !in6_dev->cnf.accept_ra_rtr_pref)
1204                pref = ICMPV6_ROUTER_PREF_MEDIUM;
1205#endif
1206
1207        rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1208
1209        if (rt)
1210                neigh = rt->rt6i_nexthop;
1211
1212        if (rt && lifetime == 0) {
1213                neigh_clone(neigh);
1214                ip6_del_rt(rt);
1215                rt = NULL;
1216        }
1217
1218        if (rt == NULL && lifetime) {
1219                ND_PRINTK3(KERN_DEBUG
1220                           "ICMPv6 RA: adding default router.\n");
1221
1222                rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1223                if (rt == NULL) {
1224                        ND_PRINTK0(KERN_ERR
1225                                   "ICMPv6 RA: %s() failed to add default route.\n",
1226                                   __func__);
1227                        in6_dev_put(in6_dev);
1228                        return;
1229                }
1230
1231                neigh = rt->rt6i_nexthop;
1232                if (neigh == NULL) {
1233                        ND_PRINTK0(KERN_ERR
1234                                   "ICMPv6 RA: %s() got default router without neighbour.\n",
1235                                   __func__);
1236                        dst_release(&rt->u.dst);
1237                        in6_dev_put(in6_dev);
1238                        return;
1239                }
1240                neigh->flags |= NTF_ROUTER;
1241        } else if (rt) {
1242                rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1243        }
1244
1245        if (rt)
1246                rt->rt6i_expires = jiffies + (HZ * lifetime);
1247
1248        if (ra_msg->icmph.icmp6_hop_limit) {
1249                in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1250                if (rt)
1251                        rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;
1252        }
1253
1254skip_defrtr:
1255
1256        /*
1257         *      Update Reachable Time and Retrans Timer
1258         */
1259
1260        if (in6_dev->nd_parms) {
1261                unsigned long rtime = ntohl(ra_msg->retrans_timer);
1262
1263                if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1264                        rtime = (rtime*HZ)/1000;
1265                        if (rtime < HZ/10)
1266                                rtime = HZ/10;
1267                        in6_dev->nd_parms->retrans_time = rtime;
1268                        in6_dev->tstamp = jiffies;
1269                        inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1270                }
1271
1272                rtime = ntohl(ra_msg->reachable_time);
1273                if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1274                        rtime = (rtime*HZ)/1000;
1275
1276                        if (rtime < HZ/10)
1277                                rtime = HZ/10;
1278
1279                        if (rtime != in6_dev->nd_parms->base_reachable_time) {
1280                                in6_dev->nd_parms->base_reachable_time = rtime;
1281                                in6_dev->nd_parms->gc_staletime = 3 * rtime;
1282                                in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1283                                in6_dev->tstamp = jiffies;
1284                                inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1285                        }
1286                }
1287        }
1288
1289#ifdef CONFIG_IPV6_NDISC_NODETYPE
1290skip_linkparms:
1291#endif
1292
1293        /*
1294         *      Process options.
1295         */
1296
1297        if (!neigh)
1298                neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1299                                       skb->dev, 1);
1300        if (neigh) {
1301                u8 *lladdr = NULL;
1302                if (ndopts.nd_opts_src_lladdr) {
1303                        lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1304                                                     skb->dev);
1305                        if (!lladdr) {
1306                                ND_PRINTK2(KERN_WARNING
1307                                           "ICMPv6 RA: invalid link-layer address length\n");
1308                                goto out;
1309                        }
1310                }
1311                neigh_update(neigh, lladdr, NUD_STALE,
1312                             NEIGH_UPDATE_F_WEAK_OVERRIDE|
1313                             NEIGH_UPDATE_F_OVERRIDE|
1314                             NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1315                             NEIGH_UPDATE_F_ISROUTER);
1316        }
1317
1318#ifdef CONFIG_IPV6_ROUTE_INFO
1319        if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1320                struct nd_opt_hdr *p;
1321                for (p = ndopts.nd_opts_ri;
1322                     p;
1323                     p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1324                        struct route_info *ri = (struct route_info *)p;
1325#ifdef CONFIG_IPV6_NDISC_NODETYPE
1326                        if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1327                            ri->prefix_len == 0)
1328                                continue;
1329#endif
1330                        if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1331                                continue;
1332                        rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1333                                      &ipv6_hdr(skb)->saddr);
1334                }
1335        }
1336#endif
1337
1338#ifdef CONFIG_IPV6_NDISC_NODETYPE
1339        /* skip link-specific ndopts from interior routers */
1340        if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1341                goto out;
1342#endif
1343
1344        if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1345                struct nd_opt_hdr *p;
1346                for (p = ndopts.nd_opts_pi;
1347                     p;
1348                     p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1349                        addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1350                }
1351        }
1352
1353        if (ndopts.nd_opts_mtu) {
1354                __be32 n;
1355                u32 mtu;
1356
1357                memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1358                mtu = ntohl(n);
1359
1360                if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1361                        ND_PRINTK2(KERN_WARNING
1362                                   "ICMPv6 RA: invalid mtu: %d\n",
1363                                   mtu);
1364                } else if (in6_dev->cnf.mtu6 != mtu) {
1365                        in6_dev->cnf.mtu6 = mtu;
1366
1367                        if (rt)
1368                                rt->u.dst.metrics[RTAX_MTU-1] = mtu;
1369
1370                        rt6_mtu_change(skb->dev, mtu);
1371                }
1372        }
1373
1374        if (ndopts.nd_useropts) {
1375                struct nd_opt_hdr *p;
1376                for (p = ndopts.nd_useropts;
1377                     p;
1378                     p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1379                        ndisc_ra_useropt(skb, p);
1380                }
1381        }
1382
1383        if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1384                ND_PRINTK2(KERN_WARNING
1385                           "ICMPv6 RA: invalid RA options");
1386        }
1387out:
1388        if (rt)
1389                dst_release(&rt->u.dst);
1390        else if (neigh)
1391                neigh_release(neigh);
1392        in6_dev_put(in6_dev);
1393}
1394
1395static void ndisc_redirect_rcv(struct sk_buff *skb)
1396{
1397        struct inet6_dev *in6_dev;
1398        struct icmp6hdr *icmph;
1399        struct in6_addr *dest;
1400        struct in6_addr *target;        /* new first hop to destination */
1401        struct neighbour *neigh;
1402        int on_link = 0;
1403        struct ndisc_options ndopts;
1404        int optlen;
1405        u8 *lladdr = NULL;
1406
1407#ifdef CONFIG_IPV6_NDISC_NODETYPE
1408        switch (skb->ndisc_nodetype) {
1409        case NDISC_NODETYPE_HOST:
1410        case NDISC_NODETYPE_NODEFAULT:
1411                ND_PRINTK2(KERN_WARNING
1412                           "ICMPv6 Redirect: from host or unauthorized router\n");
1413                return;
1414        }
1415#endif
1416
1417        if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1418                ND_PRINTK2(KERN_WARNING
1419                           "ICMPv6 Redirect: source address is not link-local.\n");
1420                return;
1421        }
1422
1423        optlen = skb->tail - skb->transport_header;
1424        optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1425
1426        if (optlen < 0) {
1427                ND_PRINTK2(KERN_WARNING
1428                           "ICMPv6 Redirect: packet too short\n");
1429                return;
1430        }
1431
1432        icmph = icmp6_hdr(skb);
1433        target = (struct in6_addr *) (icmph + 1);
1434        dest = target + 1;
1435
1436        if (ipv6_addr_is_multicast(dest)) {
1437                ND_PRINTK2(KERN_WARNING
1438                           "ICMPv6 Redirect: destination address is multicast.\n");
1439                return;
1440        }
1441
1442        if (ipv6_addr_equal(dest, target)) {
1443                on_link = 1;
1444        } else if (ipv6_addr_type(target) !=
1445                   (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1446                ND_PRINTK2(KERN_WARNING
1447                           "ICMPv6 Redirect: target address is not link-local unicast.\n");
1448                return;
1449        }
1450
1451        in6_dev = in6_dev_get(skb->dev);
1452        if (!in6_dev)
1453                return;
1454        if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1455                in6_dev_put(in6_dev);
1456                return;
1457        }
1458
1459        /* RFC2461 8.1:
1460         *      The IP source address of the Redirect MUST be the same as the current
1461         *      first-hop router for the specified ICMP Destination Address.
1462         */
1463
1464        if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1465                ND_PRINTK2(KERN_WARNING
1466                           "ICMPv6 Redirect: invalid ND options\n");
1467                in6_dev_put(in6_dev);
1468                return;
1469        }
1470        if (ndopts.nd_opts_tgt_lladdr) {
1471                lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1472                                             skb->dev);
1473                if (!lladdr) {
1474                        ND_PRINTK2(KERN_WARNING
1475                                   "ICMPv6 Redirect: invalid link-layer address length\n");
1476                        in6_dev_put(in6_dev);
1477                        return;
1478                }
1479        }
1480
1481        neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1482        if (neigh) {
1483                rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1484                             &ipv6_hdr(skb)->saddr, neigh, lladdr,
1485                             on_link);
1486                neigh_release(neigh);
1487        }
1488        in6_dev_put(in6_dev);
1489}
1490
1491void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
1492                         const struct in6_addr *target)
1493{
1494        struct net_device *dev = skb->dev;
1495        struct net *net = dev_net(dev);
1496        struct sock *sk = net->ipv6.ndisc_sk;
1497        int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1498        struct sk_buff *buff;
1499        struct icmp6hdr *icmph;
1500        struct in6_addr saddr_buf;
1501        struct in6_addr *addrp;
1502        struct rt6_info *rt;
1503        struct dst_entry *dst;
1504        struct inet6_dev *idev;
1505        struct flowi fl;
1506        u8 *opt;
1507        int rd_len;
1508        int err;
1509        u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1510
1511        if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1512                ND_PRINTK2(KERN_WARNING
1513                           "ICMPv6 Redirect: no link-local address on %s\n",
1514                           dev->name);
1515                return;
1516        }
1517
1518        if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1519            ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1520                ND_PRINTK2(KERN_WARNING
1521                        "ICMPv6 Redirect: target address is not link-local unicast.\n");
1522                return;
1523        }
1524
1525        icmpv6_flow_init(sk, &fl, NDISC_REDIRECT,
1526                         &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
1527
1528        dst = ip6_route_output(net, NULL, &fl);
1529        if (dst == NULL)
1530                return;
1531
1532        err = xfrm_lookup(net, &dst, &fl, NULL, 0);
1533        if (err)
1534                return;
1535
1536        rt = (struct rt6_info *) dst;
1537
1538        if (rt->rt6i_flags & RTF_GATEWAY) {
1539                ND_PRINTK2(KERN_WARNING
1540                           "ICMPv6 Redirect: destination is not a neighbour.\n");
1541                dst_release(dst);
1542                return;
1543        }
1544        if (!xrlim_allow(dst, 1*HZ)) {
1545                dst_release(dst);
1546                return;
1547        }
1548
1549        if (dev->addr_len) {
1550                read_lock_bh(&neigh->lock);
1551                if (neigh->nud_state & NUD_VALID) {
1552                        memcpy(ha_buf, neigh->ha, dev->addr_len);
1553                        read_unlock_bh(&neigh->lock);
1554                        ha = ha_buf;
1555                        len += ndisc_opt_addr_space(dev);
1556                } else
1557                        read_unlock_bh(&neigh->lock);
1558        }
1559
1560        rd_len = min_t(unsigned int,
1561                     IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1562        rd_len &= ~0x7;
1563        len += rd_len;
1564
1565        buff = sock_alloc_send_skb(sk,
1566                                   (MAX_HEADER + sizeof(struct ipv6hdr) +
1567                                    len + LL_ALLOCATED_SPACE(dev)),
1568                                   1, &err);
1569        if (buff == NULL) {
1570                ND_PRINTK0(KERN_ERR
1571                           "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
1572                           __func__);
1573                dst_release(dst);
1574                return;
1575        }
1576
1577        skb_reserve(buff, LL_RESERVED_SPACE(dev));
1578        ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
1579                   IPPROTO_ICMPV6, len);
1580
1581        skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
1582        skb_put(buff, len);
1583        icmph = icmp6_hdr(buff);
1584
1585        memset(icmph, 0, sizeof(struct icmp6hdr));
1586        icmph->icmp6_type = NDISC_REDIRECT;
1587
1588        /*
1589         *      copy target and destination addresses
1590         */
1591
1592        addrp = (struct in6_addr *)(icmph + 1);
1593        ipv6_addr_copy(addrp, target);
1594        addrp++;
1595        ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
1596
1597        opt = (u8*) (addrp + 1);
1598
1599        /*
1600         *      include target_address option
1601         */
1602
1603        if (ha)
1604                opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1605                                             dev->addr_len, dev->type);
1606
1607        /*
1608         *      build redirect option and copy skb over to the new packet.
1609         */
1610
1611        memset(opt, 0, 8);
1612        *(opt++) = ND_OPT_REDIRECT_HDR;
1613        *(opt++) = (rd_len >> 3);
1614        opt += 6;
1615
1616        memcpy(opt, ipv6_hdr(skb), rd_len - 8);
1617
1618        icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
1619                                             len, IPPROTO_ICMPV6,
1620                                             csum_partial(icmph, len, 0));
1621
1622        buff->dst = dst;
1623        idev = in6_dev_get(dst->dev);
1624        IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTREQUESTS);
1625        err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1626                      dst_output);
1627        if (!err) {
1628                ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT);
1629                ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
1630        }
1631
1632        if (likely(idev != NULL))
1633                in6_dev_put(idev);
1634}
1635
1636static void pndisc_redo(struct sk_buff *skb)
1637{
1638        ndisc_recv_ns(skb);
1639        kfree_skb(skb);
1640}
1641
1642int ndisc_rcv(struct sk_buff *skb)
1643{
1644        struct nd_msg *msg;
1645
1646        if (!pskb_may_pull(skb, skb->len))
1647                return 0;
1648
1649        msg = (struct nd_msg *)skb_transport_header(skb);
1650
1651        __skb_push(skb, skb->data - skb_transport_header(skb));
1652
1653        if (ipv6_hdr(skb)->hop_limit != 255) {
1654                ND_PRINTK2(KERN_WARNING
1655                           "ICMPv6 NDISC: invalid hop-limit: %d\n",
1656                           ipv6_hdr(skb)->hop_limit);
1657                return 0;
1658        }
1659
1660        if (msg->icmph.icmp6_code != 0) {
1661                ND_PRINTK2(KERN_WARNING
1662                           "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1663                           msg->icmph.icmp6_code);
1664                return 0;
1665        }
1666
1667        memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1668
1669        switch (msg->icmph.icmp6_type) {
1670        case NDISC_NEIGHBOUR_SOLICITATION:
1671                ndisc_recv_ns(skb);
1672                break;
1673
1674        case NDISC_NEIGHBOUR_ADVERTISEMENT:
1675                ndisc_recv_na(skb);
1676                break;
1677
1678        case NDISC_ROUTER_SOLICITATION:
1679                ndisc_recv_rs(skb);
1680                break;
1681
1682        case NDISC_ROUTER_ADVERTISEMENT:
1683                ndisc_router_discovery(skb);
1684                break;
1685
1686        case NDISC_REDIRECT:
1687                ndisc_redirect_rcv(skb);
1688                break;
1689        }
1690
1691        return 0;
1692}
1693
1694static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1695{
1696        struct net_device *dev = ptr;
1697        struct net *net = dev_net(dev);
1698
1699        switch (event) {
1700        case NETDEV_CHANGEADDR:
1701                neigh_changeaddr(&nd_tbl, dev);
1702                fib6_run_gc(~0UL, net);
1703                break;
1704        case NETDEV_DOWN:
1705                neigh_ifdown(&nd_tbl, dev);
1706                fib6_run_gc(~0UL, net);
1707                break;
1708        default:
1709                break;
1710        }
1711
1712        return NOTIFY_DONE;
1713}
1714
1715static struct notifier_block ndisc_netdev_notifier = {
1716        .notifier_call = ndisc_netdev_event,
1717};
1718
1719#ifdef CONFIG_SYSCTL
1720static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1721                                         const char *func, const char *dev_name)
1722{
1723        static char warncomm[TASK_COMM_LEN];
1724        static int warned;
1725        if (strcmp(warncomm, current->comm) && warned < 5) {
1726                strcpy(warncomm, current->comm);
1727                printk(KERN_WARNING
1728                        "process `%s' is using deprecated sysctl (%s) "
1729                        "net.ipv6.neigh.%s.%s; "
1730                        "Use net.ipv6.neigh.%s.%s_ms "
1731                        "instead.\n",
1732                        warncomm, func,
1733                        dev_name, ctl->procname,
1734                        dev_name, ctl->procname);
1735                warned++;
1736        }
1737}
1738
1739int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)
1740{
1741        struct net_device *dev = ctl->extra1;
1742        struct inet6_dev *idev;
1743        int ret;
1744
1745        if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1746            (strcmp(ctl->procname, "base_reachable_time") == 0))
1747                ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1748
1749        if (strcmp(ctl->procname, "retrans_time") == 0)
1750                ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1751
1752        else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1753                ret = proc_dointvec_jiffies(ctl, write,
1754                                            filp, buffer, lenp, ppos);
1755
1756        else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1757                 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1758                ret = proc_dointvec_ms_jiffies(ctl, write,
1759                                               filp, buffer, lenp, ppos);
1760        else
1761                ret = -1;
1762
1763        if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1764                if (ctl->data == &idev->nd_parms->base_reachable_time)
1765                        idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1766                idev->tstamp = jiffies;
1767                inet6_ifinfo_notify(RTM_NEWLINK, idev);
1768                in6_dev_put(idev);
1769        }
1770        return ret;
1771}
1772
1773int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl,
1774                                 void __user *oldval, size_t __user *oldlenp,
1775                                 void __user *newval, size_t newlen)
1776{
1777        struct net_device *dev = ctl->extra1;
1778        struct inet6_dev *idev;
1779        int ret;
1780
1781        if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1782            ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1783                ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");
1784
1785        switch (ctl->ctl_name) {
1786        case NET_NEIGH_REACHABLE_TIME:
1787                ret = sysctl_jiffies(ctl, oldval, oldlenp, newval, newlen);
1788                break;
1789        case NET_NEIGH_RETRANS_TIME_MS:
1790        case NET_NEIGH_REACHABLE_TIME_MS:
1791                 ret = sysctl_ms_jiffies(ctl, oldval, oldlenp, newval, newlen);
1792                 break;
1793        default:
1794                ret = 0;
1795        }
1796
1797        if (newval && newlen && ret > 0 &&
1798            dev && (idev = in6_dev_get(dev)) != NULL) {
1799                if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1800                    ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1801                        idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1802                idev->tstamp = jiffies;
1803                inet6_ifinfo_notify(RTM_NEWLINK, idev);
1804                in6_dev_put(idev);
1805        }
1806
1807        return ret;
1808}
1809
1810#endif
1811
1812static int ndisc_net_init(struct net *net)
1813{
1814        struct ipv6_pinfo *np;
1815        struct sock *sk;
1816        int err;
1817
1818        err = inet_ctl_sock_create(&sk, PF_INET6,
1819                                   SOCK_RAW, IPPROTO_ICMPV6, net);
1820        if (err < 0) {
1821                ND_PRINTK0(KERN_ERR
1822                           "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1823                           err);
1824                return err;
1825        }
1826
1827        net->ipv6.ndisc_sk = sk;
1828
1829        np = inet6_sk(sk);
1830        np->hop_limit = 255;
1831        /* Do not loopback ndisc messages */
1832        np->mc_loop = 0;
1833
1834        return 0;
1835}
1836
1837static void ndisc_net_exit(struct net *net)
1838{
1839        inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1840}
1841
1842static struct pernet_operations ndisc_net_ops = {
1843        .init = ndisc_net_init,
1844        .exit = ndisc_net_exit,
1845};
1846
1847int __init ndisc_init(void)
1848{
1849        int err;
1850
1851        err = register_pernet_subsys(&ndisc_net_ops);
1852        if (err)
1853                return err;
1854        /*
1855         * Initialize the neighbour table
1856         */
1857        neigh_table_init(&nd_tbl);
1858
1859#ifdef CONFIG_SYSCTL
1860        err = neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6,
1861                                    NET_IPV6_NEIGH, "ipv6",
1862                                    &ndisc_ifinfo_sysctl_change,
1863                                    &ndisc_ifinfo_sysctl_strategy);
1864        if (err)
1865                goto out_unregister_pernet;
1866#endif
1867        err = register_netdevice_notifier(&ndisc_netdev_notifier);
1868        if (err)
1869                goto out_unregister_sysctl;
1870out:
1871        return err;
1872
1873out_unregister_sysctl:
1874#ifdef CONFIG_SYSCTL
1875        neigh_sysctl_unregister(&nd_tbl.parms);
1876out_unregister_pernet:
1877#endif
1878        unregister_pernet_subsys(&ndisc_net_ops);
1879        goto out;
1880}
1881
1882void ndisc_cleanup(void)
1883{
1884        unregister_netdevice_notifier(&ndisc_netdev_notifier);
1885#ifdef CONFIG_SYSCTL
1886        neigh_sysctl_unregister(&nd_tbl.parms);
1887#endif
1888        neigh_table_clear(&nd_tbl);
1889        unregister_pernet_subsys(&ndisc_net_ops);
1890}
1891