net/ipv6/ndisc.c

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