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        rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
1099        return;
1100
1101nla_put_failure:
1102        nlmsg_free(skb);
1103        err = -EMSGSIZE;
1104errout:
1105        rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1106}
1107
1108static void ndisc_router_discovery(struct sk_buff *skb)
1109{
1110        struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1111        struct neighbour *neigh = NULL;
1112        struct inet6_dev *in6_dev;
1113        struct rt6_info *rt = NULL;
1114        int lifetime;
1115        struct ndisc_options ndopts;
1116        int optlen;
1117        unsigned int pref = 0;
1118
1119        __u8 * opt = (__u8 *)(ra_msg + 1);
1120
1121        optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
1122
1123        if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1124                ND_PRINTK2(KERN_WARNING
1125                           "ICMPv6 RA: source address is not link-local.\n");
1126                return;
1127        }
1128        if (optlen < 0) {
1129                ND_PRINTK2(KERN_WARNING
1130                           "ICMPv6 RA: packet too short\n");
1131                return;
1132        }
1133
1134#ifdef CONFIG_IPV6_NDISC_NODETYPE
1135        if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1136                ND_PRINTK2(KERN_WARNING
1137                           "ICMPv6 RA: from host or unauthorized router\n");
1138                return;
1139        }
1140#endif
1141
1142        /*
1143         *      set the RA_RECV flag in the interface
1144         */
1145
1146        in6_dev = in6_dev_get(skb->dev);
1147        if (in6_dev == NULL) {
1148                ND_PRINTK0(KERN_ERR
1149                           "ICMPv6 RA: can't find inet6 device for %s.\n",
1150                           skb->dev->name);
1151                return;
1152        }
1153        if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {
1154                in6_dev_put(in6_dev);
1155                return;
1156        }
1157
1158        if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1159                in6_dev_put(in6_dev);
1160                ND_PRINTK2(KERN_WARNING
1161                           "ICMP6 RA: invalid ND options\n");
1162                return;
1163        }
1164
1165#ifdef CONFIG_IPV6_NDISC_NODETYPE
1166        /* skip link-specific parameters from interior routers */
1167        if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1168                goto skip_linkparms;
1169#endif
1170
1171        if (in6_dev->if_flags & IF_RS_SENT) {
1172                /*
1173                 *      flag that an RA was received after an RS was sent
1174                 *      out on this interface.
1175                 */
1176                in6_dev->if_flags |= IF_RA_RCVD;
1177        }
1178
1179        /*
1180         * Remember the managed/otherconf flags from most recently
1181         * received RA message (RFC 2462) -- yoshfuji
1182         */
1183        in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1184                                IF_RA_OTHERCONF)) |
1185                                (ra_msg->icmph.icmp6_addrconf_managed ?
1186                                        IF_RA_MANAGED : 0) |
1187                                (ra_msg->icmph.icmp6_addrconf_other ?
1188                                        IF_RA_OTHERCONF : 0);
1189
1190        if (!in6_dev->cnf.accept_ra_defrtr)
1191                goto skip_defrtr;
1192
1193        lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1194
1195#ifdef CONFIG_IPV6_ROUTER_PREF
1196        pref = ra_msg->icmph.icmp6_router_pref;
1197        /* 10b is handled as if it were 00b (medium) */
1198        if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1199            !in6_dev->cnf.accept_ra_rtr_pref)
1200                pref = ICMPV6_ROUTER_PREF_MEDIUM;
1201#endif
1202
1203        rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1204
1205        if (rt)
1206                neigh = rt->rt6i_nexthop;
1207
1208        if (rt && lifetime == 0) {
1209                neigh_clone(neigh);
1210                ip6_del_rt(rt);
1211                rt = NULL;
1212        }
1213
1214        if (rt == NULL && lifetime) {
1215                ND_PRINTK3(KERN_DEBUG
1216                           "ICMPv6 RA: adding default router.\n");
1217
1218                rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1219                if (rt == NULL) {
1220                        ND_PRINTK0(KERN_ERR
1221                                   "ICMPv6 RA: %s() failed to add default route.\n",
1222                                   __func__);
1223                        in6_dev_put(in6_dev);
1224                        return;
1225                }
1226
1227                neigh = rt->rt6i_nexthop;
1228                if (neigh == NULL) {
1229                        ND_PRINTK0(KERN_ERR
1230                                   "ICMPv6 RA: %s() got default router without neighbour.\n",
1231                                   __func__);
1232                        dst_release(&rt->u.dst);
1233                        in6_dev_put(in6_dev);
1234                        return;
1235                }
1236                neigh->flags |= NTF_ROUTER;
1237        } else if (rt) {
1238                rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1239        }
1240
1241        if (rt)
1242                rt->rt6i_expires = jiffies + (HZ * lifetime);
1243
1244        if (ra_msg->icmph.icmp6_hop_limit) {
1245                in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1246                if (rt)
1247                        rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;
1248        }
1249
1250skip_defrtr:
1251
1252        /*
1253         *      Update Reachable Time and Retrans Timer
1254         */
1255
1256        if (in6_dev->nd_parms) {
1257                unsigned long rtime = ntohl(ra_msg->retrans_timer);
1258
1259                if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1260                        rtime = (rtime*HZ)/1000;
1261                        if (rtime < HZ/10)
1262                                rtime = HZ/10;
1263                        in6_dev->nd_parms->retrans_time = rtime;
1264                        in6_dev->tstamp = jiffies;
1265                        inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1266                }
1267
1268                rtime = ntohl(ra_msg->reachable_time);
1269                if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1270                        rtime = (rtime*HZ)/1000;
1271
1272                        if (rtime < HZ/10)
1273                                rtime = HZ/10;
1274
1275                        if (rtime != in6_dev->nd_parms->base_reachable_time) {
1276                                in6_dev->nd_parms->base_reachable_time = rtime;
1277                                in6_dev->nd_parms->gc_staletime = 3 * rtime;
1278                                in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1279                                in6_dev->tstamp = jiffies;
1280                                inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1281                        }
1282                }
1283        }
1284
1285#ifdef CONFIG_IPV6_NDISC_NODETYPE
1286skip_linkparms:
1287#endif
1288
1289        /*
1290         *      Process options.
1291         */
1292
1293        if (!neigh)
1294                neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1295                                       skb->dev, 1);
1296        if (neigh) {
1297                u8 *lladdr = NULL;
1298                if (ndopts.nd_opts_src_lladdr) {
1299                        lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1300                                                     skb->dev);
1301                        if (!lladdr) {
1302                                ND_PRINTK2(KERN_WARNING
1303                                           "ICMPv6 RA: invalid link-layer address length\n");
1304                                goto out;
1305                        }
1306                }
1307                neigh_update(neigh, lladdr, NUD_STALE,
1308                             NEIGH_UPDATE_F_WEAK_OVERRIDE|
1309                             NEIGH_UPDATE_F_OVERRIDE|
1310                             NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1311                             NEIGH_UPDATE_F_ISROUTER);
1312        }
1313
1314#ifdef CONFIG_IPV6_ROUTE_INFO
1315        if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1316                struct nd_opt_hdr *p;
1317                for (p = ndopts.nd_opts_ri;
1318                     p;
1319                     p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1320                        struct route_info *ri = (struct route_info *)p;
1321#ifdef CONFIG_IPV6_NDISC_NODETYPE
1322                        if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1323                            ri->prefix_len == 0)
1324                                continue;
1325#endif
1326                        if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1327                                continue;
1328                        rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1329                                      &ipv6_hdr(skb)->saddr);
1330                }
1331        }
1332#endif
1333
1334#ifdef CONFIG_IPV6_NDISC_NODETYPE
1335        /* skip link-specific ndopts from interior routers */
1336        if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1337                goto out;
1338#endif
1339
1340        if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1341                struct nd_opt_hdr *p;
1342                for (p = ndopts.nd_opts_pi;
1343                     p;
1344                     p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1345                        addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1346                }
1347        }
1348
1349        if (ndopts.nd_opts_mtu) {
1350                __be32 n;
1351                u32 mtu;
1352
1353                memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1354                mtu = ntohl(n);
1355
1356                if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1357                        ND_PRINTK2(KERN_WARNING
1358                                   "ICMPv6 RA: invalid mtu: %d\n",
1359                                   mtu);
1360                } else if (in6_dev->cnf.mtu6 != mtu) {
1361                        in6_dev->cnf.mtu6 = mtu;
1362
1363                        if (rt)
1364                                rt->u.dst.metrics[RTAX_MTU-1] = mtu;
1365
1366                        rt6_mtu_change(skb->dev, mtu);
1367                }
1368        }
1369
1370        if (ndopts.nd_useropts) {
1371                struct nd_opt_hdr *p;
1372                for (p = ndopts.nd_useropts;
1373                     p;
1374                     p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1375                        ndisc_ra_useropt(skb, p);
1376                }
1377        }
1378
1379        if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1380                ND_PRINTK2(KERN_WARNING
1381                           "ICMPv6 RA: invalid RA options");
1382        }
1383out:
1384        if (rt)
1385                dst_release(&rt->u.dst);
1386        else if (neigh)
1387                neigh_release(neigh);
1388        in6_dev_put(in6_dev);
1389}
1390
1391static void ndisc_redirect_rcv(struct sk_buff *skb)
1392{
1393        struct inet6_dev *in6_dev;
1394        struct icmp6hdr *icmph;
1395        struct in6_addr *dest;
1396        struct in6_addr *target;        /* new first hop to destination */
1397        struct neighbour *neigh;
1398        int on_link = 0;
1399        struct ndisc_options ndopts;
1400        int optlen;
1401        u8 *lladdr = NULL;
1402
1403#ifdef CONFIG_IPV6_NDISC_NODETYPE
1404        switch (skb->ndisc_nodetype) {
1405        case NDISC_NODETYPE_HOST:
1406        case NDISC_NODETYPE_NODEFAULT:
1407                ND_PRINTK2(KERN_WARNING
1408                           "ICMPv6 Redirect: from host or unauthorized router\n");
1409                return;
1410        }
1411#endif
1412
1413        if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1414                ND_PRINTK2(KERN_WARNING
1415                           "ICMPv6 Redirect: source address is not link-local.\n");
1416                return;
1417        }
1418
1419        optlen = skb->tail - skb->transport_header;
1420        optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1421
1422        if (optlen < 0) {
1423                ND_PRINTK2(KERN_WARNING
1424                           "ICMPv6 Redirect: packet too short\n");
1425                return;
1426        }
1427
1428        icmph = icmp6_hdr(skb);
1429        target = (struct in6_addr *) (icmph + 1);
1430        dest = target + 1;
1431
1432        if (ipv6_addr_is_multicast(dest)) {
1433                ND_PRINTK2(KERN_WARNING
1434                           "ICMPv6 Redirect: destination address is multicast.\n");
1435                return;
1436        }
1437
1438        if (ipv6_addr_equal(dest, target)) {
1439                on_link = 1;
1440        } else if (ipv6_addr_type(target) !=
1441                   (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1442                ND_PRINTK2(KERN_WARNING
1443                           "ICMPv6 Redirect: target address is not link-local unicast.\n");
1444                return;
1445        }
1446
1447        in6_dev = in6_dev_get(skb->dev);
1448        if (!in6_dev)
1449                return;
1450        if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1451                in6_dev_put(in6_dev);
1452                return;
1453        }
1454
1455        /* RFC2461 8.1:
1456         *      The IP source address of the Redirect MUST be the same as the current
1457         *      first-hop router for the specified ICMP Destination Address.
1458         */
1459
1460        if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1461                ND_PRINTK2(KERN_WARNING
1462                           "ICMPv6 Redirect: invalid ND options\n");
1463                in6_dev_put(in6_dev);
1464                return;
1465        }
1466        if (ndopts.nd_opts_tgt_lladdr) {
1467                lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1468                                             skb->dev);
1469                if (!lladdr) {
1470                        ND_PRINTK2(KERN_WARNING
1471                                   "ICMPv6 Redirect: invalid link-layer address length\n");
1472                        in6_dev_put(in6_dev);
1473                        return;
1474                }
1475        }
1476
1477        neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1478        if (neigh) {
1479                rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1480                             &ipv6_hdr(skb)->saddr, neigh, lladdr,
1481                             on_link);
1482                neigh_release(neigh);
1483        }
1484        in6_dev_put(in6_dev);
1485}
1486
1487void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
1488                         const struct in6_addr *target)
1489{
1490        struct net_device *dev = skb->dev;
1491        struct net *net = dev_net(dev);
1492        struct sock *sk = net->ipv6.ndisc_sk;
1493        int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1494        struct sk_buff *buff;
1495        struct icmp6hdr *icmph;
1496        struct in6_addr saddr_buf;
1497        struct in6_addr *addrp;
1498        struct rt6_info *rt;
1499        struct dst_entry *dst;
1500        struct inet6_dev *idev;
1501        struct flowi fl;
1502        u8 *opt;
1503        int rd_len;
1504        int err;
1505        u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1506
1507        if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1508                ND_PRINTK2(KERN_WARNING
1509                           "ICMPv6 Redirect: no link-local address on %s\n",
1510                           dev->name);
1511                return;
1512        }
1513
1514        if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1515            ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1516                ND_PRINTK2(KERN_WARNING
1517                        "ICMPv6 Redirect: target address is not link-local unicast.\n");
1518                return;
1519        }
1520
1521        icmpv6_flow_init(sk, &fl, NDISC_REDIRECT,
1522                         &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
1523
1524        dst = ip6_route_output(net, NULL, &fl);
1525        if (dst == NULL)
1526                return;
1527
1528        err = xfrm_lookup(net, &dst, &fl, NULL, 0);
1529        if (err)
1530                return;
1531
1532        rt = (struct rt6_info *) dst;
1533
1534        if (rt->rt6i_flags & RTF_GATEWAY) {
1535                ND_PRINTK2(KERN_WARNING
1536                           "ICMPv6 Redirect: destination is not a neighbour.\n");
1537                goto release;
1538        }
1539        if (!xrlim_allow(dst, 1*HZ))
1540                goto release;
1541
1542        if (dev->addr_len) {
1543                read_lock_bh(&neigh->lock);
1544                if (neigh->nud_state & NUD_VALID) {
1545                        memcpy(ha_buf, neigh->ha, dev->addr_len);
1546                        read_unlock_bh(&neigh->lock);
1547                        ha = ha_buf;
1548                        len += ndisc_opt_addr_space(dev);
1549                } else
1550                        read_unlock_bh(&neigh->lock);
1551        }
1552
1553        rd_len = min_t(unsigned int,
1554                     IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1555        rd_len &= ~0x7;
1556        len += rd_len;
1557
1558        buff = sock_alloc_send_skb(sk,
1559                                   (MAX_HEADER + sizeof(struct ipv6hdr) +
1560                                    len + LL_ALLOCATED_SPACE(dev)),
1561                                   1, &err);
1562        if (buff == NULL) {
1563                ND_PRINTK0(KERN_ERR
1564                           "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
1565                           __func__);
1566                goto release;
1567        }
1568
1569        skb_reserve(buff, LL_RESERVED_SPACE(dev));
1570        ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
1571                   IPPROTO_ICMPV6, len);
1572
1573        skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
1574        skb_put(buff, len);
1575        icmph = icmp6_hdr(buff);
1576
1577        memset(icmph, 0, sizeof(struct icmp6hdr));
1578        icmph->icmp6_type = NDISC_REDIRECT;
1579
1580        /*
1581         *      copy target and destination addresses
1582         */
1583
1584        addrp = (struct in6_addr *)(icmph + 1);
1585        ipv6_addr_copy(addrp, target);
1586        addrp++;
1587        ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
1588
1589        opt = (u8*) (addrp + 1);
1590
1591        /*
1592         *      include target_address option
1593         */
1594
1595        if (ha)
1596                opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1597                                             dev->addr_len, dev->type);
1598
1599        /*
1600         *      build redirect option and copy skb over to the new packet.
1601         */
1602
1603        memset(opt, 0, 8);
1604        *(opt++) = ND_OPT_REDIRECT_HDR;
1605        *(opt++) = (rd_len >> 3);
1606        opt += 6;
1607
1608        memcpy(opt, ipv6_hdr(skb), rd_len - 8);
1609
1610        icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
1611                                             len, IPPROTO_ICMPV6,
1612                                             csum_partial(icmph, len, 0));
1613
1614        buff->dst = dst;
1615        idev = in6_dev_get(dst->dev);
1616        IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTREQUESTS);
1617        err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1618                      dst_output);
1619        if (!err) {
1620                ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT);
1621                ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
1622        }
1623
1624        if (likely(idev != NULL))
1625                in6_dev_put(idev);
1626        return;
1627
1628release:
1629        dst_release(dst);
1630}
1631
1632static void pndisc_redo(struct sk_buff *skb)
1633{
1634        ndisc_recv_ns(skb);
1635        kfree_skb(skb);
1636}
1637
1638int ndisc_rcv(struct sk_buff *skb)
1639{
1640        struct nd_msg *msg;
1641
1642        if (!pskb_may_pull(skb, skb->len))
1643                return 0;
1644
1645        msg = (struct nd_msg *)skb_transport_header(skb);
1646
1647        __skb_push(skb, skb->data - skb_transport_header(skb));
1648
1649        if (ipv6_hdr(skb)->hop_limit != 255) {
1650                ND_PRINTK2(KERN_WARNING
1651                           "ICMPv6 NDISC: invalid hop-limit: %d\n",
1652                           ipv6_hdr(skb)->hop_limit);
1653                return 0;
1654        }
1655
1656        if (msg->icmph.icmp6_code != 0) {
1657                ND_PRINTK2(KERN_WARNING
1658                           "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1659                           msg->icmph.icmp6_code);
1660                return 0;
1661        }
1662
1663        memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1664
1665        switch (msg->icmph.icmp6_type) {
1666        case NDISC_NEIGHBOUR_SOLICITATION:
1667                ndisc_recv_ns(skb);
1668                break;
1669
1670        case NDISC_NEIGHBOUR_ADVERTISEMENT:
1671                ndisc_recv_na(skb);
1672                break;
1673
1674        case NDISC_ROUTER_SOLICITATION:
1675                ndisc_recv_rs(skb);
1676                break;
1677
1678        case NDISC_ROUTER_ADVERTISEMENT:
1679                ndisc_router_discovery(skb);
1680                break;
1681
1682        case NDISC_REDIRECT:
1683                ndisc_redirect_rcv(skb);
1684                break;
1685        }
1686
1687        return 0;
1688}
1689
1690static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1691{
1692        struct net_device *dev = ptr;
1693        struct net *net = dev_net(dev);
1694
1695        switch (event) {
1696        case NETDEV_CHANGEADDR:
1697                neigh_changeaddr(&nd_tbl, dev);
1698                fib6_run_gc(~0UL, net);
1699                break;
1700        case NETDEV_DOWN:
1701                neigh_ifdown(&nd_tbl, dev);
1702                fib6_run_gc(~0UL, net);
1703                break;
1704        default:
1705                break;
1706        }
1707
1708        return NOTIFY_DONE;
1709}
1710
1711static struct notifier_block ndisc_netdev_notifier = {
1712        .notifier_call = ndisc_netdev_event,
1713};
1714
1715#ifdef CONFIG_SYSCTL
1716static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1717                                         const char *func, const char *dev_name)
1718{
1719        static char warncomm[TASK_COMM_LEN];
1720        static int warned;
1721        if (strcmp(warncomm, current->comm) && warned < 5) {
1722                strcpy(warncomm, current->comm);
1723                printk(KERN_WARNING
1724                        "process `%s' is using deprecated sysctl (%s) "
1725                        "net.ipv6.neigh.%s.%s; "
1726                        "Use net.ipv6.neigh.%s.%s_ms "
1727                        "instead.\n",
1728                        warncomm, func,
1729                        dev_name, ctl->procname,
1730                        dev_name, ctl->procname);
1731                warned++;
1732        }
1733}
1734
1735int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)
1736{
1737        struct net_device *dev = ctl->extra1;
1738        struct inet6_dev *idev;
1739        int ret;
1740
1741        if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1742            (strcmp(ctl->procname, "base_reachable_time") == 0))
1743                ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1744
1745        if (strcmp(ctl->procname, "retrans_time") == 0)
1746                ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1747
1748        else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1749                ret = proc_dointvec_jiffies(ctl, write,
1750                                            filp, buffer, lenp, ppos);
1751
1752        else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1753                 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1754                ret = proc_dointvec_ms_jiffies(ctl, write,
1755                                               filp, buffer, lenp, ppos);
1756        else
1757                ret = -1;
1758
1759        if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1760                if (ctl->data == &idev->nd_parms->base_reachable_time)
1761                        idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1762                idev->tstamp = jiffies;
1763                inet6_ifinfo_notify(RTM_NEWLINK, idev);
1764                in6_dev_put(idev);
1765        }
1766        return ret;
1767}
1768
1769int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl,
1770                                 void __user *oldval, size_t __user *oldlenp,
1771                                 void __user *newval, size_t newlen)
1772{
1773        struct net_device *dev = ctl->extra1;
1774        struct inet6_dev *idev;
1775        int ret;
1776
1777        if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1778            ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1779                ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");
1780
1781        switch (ctl->ctl_name) {
1782        case NET_NEIGH_REACHABLE_TIME:
1783                ret = sysctl_jiffies(ctl, oldval, oldlenp, newval, newlen);
1784                break;
1785        case NET_NEIGH_RETRANS_TIME_MS:
1786        case NET_NEIGH_REACHABLE_TIME_MS:
1787                 ret = sysctl_ms_jiffies(ctl, oldval, oldlenp, newval, newlen);
1788                 break;
1789        default:
1790                ret = 0;
1791        }
1792
1793        if (newval && newlen && ret > 0 &&
1794            dev && (idev = in6_dev_get(dev)) != NULL) {
1795                if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1796                    ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1797                        idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1798                idev->tstamp = jiffies;
1799                inet6_ifinfo_notify(RTM_NEWLINK, idev);
1800                in6_dev_put(idev);
1801        }
1802
1803        return ret;
1804}
1805
1806#endif
1807
1808static int ndisc_net_init(struct net *net)
1809{
1810        struct ipv6_pinfo *np;
1811        struct sock *sk;
1812        int err;
1813
1814        err = inet_ctl_sock_create(&sk, PF_INET6,
1815                                   SOCK_RAW, IPPROTO_ICMPV6, net);
1816        if (err < 0) {
1817                ND_PRINTK0(KERN_ERR
1818                           "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1819                           err);
1820                return err;
1821        }
1822
1823        net->ipv6.ndisc_sk = sk;
1824
1825        np = inet6_sk(sk);
1826        np->hop_limit = 255;
1827        /* Do not loopback ndisc messages */
1828        np->mc_loop = 0;
1829
1830        return 0;
1831}
1832
1833static void ndisc_net_exit(struct net *net)
1834{
1835        inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1836}
1837
1838static struct pernet_operations ndisc_net_ops = {
1839        .init = ndisc_net_init,
1840        .exit = ndisc_net_exit,
1841};
1842
1843int __init ndisc_init(void)
1844{
1845        int err;
1846
1847        err = register_pernet_subsys(&ndisc_net_ops);
1848        if (err)
1849                return err;
1850        /*
1851         * Initialize the neighbour table
1852         */
1853        neigh_table_init(&nd_tbl);
1854
1855#ifdef CONFIG_SYSCTL
1856        err = neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6,
1857                                    NET_IPV6_NEIGH, "ipv6",
1858                                    &ndisc_ifinfo_sysctl_change,
1859                                    &ndisc_ifinfo_sysctl_strategy);
1860        if (err)
1861                goto out_unregister_pernet;
1862#endif
1863        err = register_netdevice_notifier(&ndisc_netdev_notifier);
1864        if (err)
1865                goto out_unregister_sysctl;
1866out:
1867        return err;
1868
1869out_unregister_sysctl:
1870#ifdef CONFIG_SYSCTL
1871        neigh_sysctl_unregister(&nd_tbl.parms);
1872out_unregister_pernet:
1873#endif
1874        unregister_pernet_subsys(&ndisc_net_ops);
1875        goto out;
1876}
1877
1878void ndisc_cleanup(void)
1879{
1880        unregister_netdevice_notifier(&ndisc_netdev_notifier);
1881#ifdef CONFIG_SYSCTL
1882        neigh_sysctl_unregister(&nd_tbl.parms);
1883#endif
1884        neigh_table_clear(&nd_tbl);
1885        unregister_pernet_subsys(&ndisc_net_ops);
1886}
1887