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