Pileus Git - ~andy/linux/blob - 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(&skb->nh.ipv6h->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(&skb->nh.ipv6h->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(&skb->nh.ipv6h->saddr, dev, 1))
 740                 saddr = &skb->nh.ipv6h->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 = &skb->nh.ipv6h->saddr;
 765         struct in6_addr *daddr = &skb->nh.ipv6h->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                                         unsigned char *sadr = skb->mac.raw;
 832                                         if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
 833                                             sadr[9] == dev->dev_addr[1] &&
 834                                             sadr[10] == dev->dev_addr[2] &&
 835                                             sadr[11] == dev->dev_addr[3] &&
 836                                             sadr[12] == dev->dev_addr[4] &&
 837                                             sadr[13] == dev->dev_addr[5]) {
 838                                                 /* looped-back to us */
 839                                                 goto out;
 840                                         }
 841                                 }
 842
 843                                 /*
 844                                  * We are colliding with another node
 845                                  * who is doing DAD
 846                                  * so fail our DAD process
 847                                  */
 848                                 addrconf_dad_failure(ifp);
 849                                 goto out;
 850                         } else {
 851                                 /*
 852                                  * This is not a dad solicitation.
 853                                  * If we are an optimistic node,
 854                                  * we should respond.
 855                                  * Otherwise, we should ignore it.
 856                                  */
 857                                 if (!(ifp->flags & IFA_F_OPTIMISTIC))
 858                                         goto out;
 859                         }
 860                 }
 861
 862                 idev = ifp->idev;
 863         } else {
 864                 idev = in6_dev_get(dev);
 865                 if (!idev) {
 866                         /* XXX: count this drop? */
 867                         return;
 868                 }
 869
 870                 if (ipv6_chk_acast_addr(dev, &msg->target) ||
 871                     (idev->cnf.forwarding &&
 872                      (ipv6_devconf.proxy_ndp || idev->cnf.proxy_ndp) &&
 873                      (pneigh = pneigh_lookup(&nd_tbl,
 874                                              &msg->target, dev, 0)) != NULL)) {
 875                         if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
 876                             skb->pkt_type != PACKET_HOST &&
 877                             inc != 0 &&
 878                             idev->nd_parms->proxy_delay != 0) {
 879                                 /*
 880                                  * for anycast or proxy,
 881                                  * sender should delay its response
 882                                  * by a random time between 0 and
 883                                  * MAX_ANYCAST_DELAY_TIME seconds.
 884                                  * (RFC2461) -- yoshfuji
 885                                  */
 886                                 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
 887                                 if (n)
 888                                         pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
 889                                 goto out;
 890                         }
 891                 } else
 892                         goto out;
 893         }
 894
 895         is_router = !!(pneigh ? pneigh->flags & NTF_ROUTER : idev->cnf.forwarding);
 896
 897         if (dad) {
 898                 struct in6_addr maddr;
 899
 900                 ipv6_addr_all_nodes(&maddr);
 901                 ndisc_send_na(dev, NULL, &maddr, &msg->target,
 902                               is_router, 0, (ifp != NULL), 1);
 903                 goto out;
 904         }
 905
 906         if (inc)
 907                 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
 908         else
 909                 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
 910
 911         /*
 912          *      update / create cache entry
 913          *      for the source address
 914          */
 915         neigh = __neigh_lookup(&nd_tbl, saddr, dev,
 916                                !inc || lladdr || !dev->addr_len);
 917         if (neigh)
 918                 neigh_update(neigh, lladdr, NUD_STALE,
 919                              NEIGH_UPDATE_F_WEAK_OVERRIDE|
 920                              NEIGH_UPDATE_F_OVERRIDE);
 921         if (neigh || !dev->hard_header) {
 922                 ndisc_send_na(dev, neigh, saddr, &msg->target,
 923                               is_router,
 924                               1, (ifp != NULL && inc), inc);
 925                 if (neigh)
 926                         neigh_release(neigh);
 927         }
 928
 929 out:
 930         if (ifp)
 931                 in6_ifa_put(ifp);
 932         else
 933                 in6_dev_put(idev);
 934
 935         return;
 936 }
 937
 938 static void ndisc_recv_na(struct sk_buff *skb)
 939 {
 940         struct nd_msg *msg = (struct nd_msg *)skb->h.raw;
 941         struct in6_addr *saddr = &skb->nh.ipv6h->saddr;
 942         struct in6_addr *daddr = &skb->nh.ipv6h->daddr;
 943         u8 *lladdr = NULL;
 944         u32 ndoptlen = skb->tail - msg->opt;
 945         struct ndisc_options ndopts;
 946         struct net_device *dev = skb->dev;
 947         struct inet6_ifaddr *ifp;
 948         struct neighbour *neigh;
 949
 950         if (skb->len < sizeof(struct nd_msg)) {
 951                 ND_PRINTK2(KERN_WARNING
 952                            "ICMPv6 NA: packet too short\n");
 953                 return;
 954         }
 955
 956         if (ipv6_addr_is_multicast(&msg->target)) {
 957                 ND_PRINTK2(KERN_WARNING
 958                            "ICMPv6 NA: target address is multicast.\n");
 959                 return;
 960         }
 961
 962         if (ipv6_addr_is_multicast(daddr) &&
 963             msg->icmph.icmp6_solicited) {
 964                 ND_PRINTK2(KERN_WARNING
 965                            "ICMPv6 NA: solicited NA is multicasted.\n");
 966                 return;
 967         }
 968
 969         if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
 970                 ND_PRINTK2(KERN_WARNING
 971                            "ICMPv6 NS: invalid ND option\n");
 972                 return;
 973         }
 974         if (ndopts.nd_opts_tgt_lladdr) {
 975                 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
 976                 if (!lladdr) {
 977                         ND_PRINTK2(KERN_WARNING
 978                                    "ICMPv6 NA: invalid link-layer address length\n");
 979                         return;
 980                 }
 981         }
 982         if ((ifp = ipv6_get_ifaddr(&msg->target, dev, 1))) {
 983                 if (ifp->flags & IFA_F_TENTATIVE) {
 984                         addrconf_dad_failure(ifp);
 985                         return;
 986                 }
 987                 /* What should we make now? The advertisement
 988                    is invalid, but ndisc specs say nothing
 989                    about it. It could be misconfiguration, or
 990                    an smart proxy agent tries to help us :-)
 991                  */
 992                 ND_PRINTK1(KERN_WARNING
 993                            "ICMPv6 NA: someone advertises our address on %s!\n",
 994                            ifp->idev->dev->name);
 995                 in6_ifa_put(ifp);
 996                 return;
 997         }
 998         neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
 999
1000         if (neigh) {
1001                 u8 old_flags = neigh->flags;
1002
1003                 if (neigh->nud_state & NUD_FAILED)
1004                         goto out;
1005
1006                 /*
1007                  * Don't update the neighbor cache entry on a proxy NA from
1008                  * ourselves because either the proxied node is off link or it
1009                  * has already sent a NA to us.
1010                  */
1011                 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
1012                     ipv6_devconf.forwarding && ipv6_devconf.proxy_ndp &&
1013                     pneigh_lookup(&nd_tbl, &msg->target, dev, 0)) {
1014                         /* XXX: idev->cnf.prixy_ndp */
1015                         goto out;
1016                 }
1017
1018                 neigh_update(neigh, lladdr,
1019                              msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
1020                              NEIGH_UPDATE_F_WEAK_OVERRIDE|
1021                              (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
1022                              NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1023                              (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
1024
1025                 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
1026                         /*
1027                          * Change: router to host
1028                          */
1029                         struct rt6_info *rt;
1030                         rt = rt6_get_dflt_router(saddr, dev);
1031                         if (rt)
1032                                 ip6_del_rt(rt);
1033                 }
1034
1035 out:
1036                 neigh_release(neigh);
1037         }
1038 }
1039
1040 static void ndisc_recv_rs(struct sk_buff *skb)
1041 {
1042         struct rs_msg *rs_msg = (struct rs_msg *) skb->h.raw;
1043         unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
1044         struct neighbour *neigh;
1045         struct inet6_dev *idev;
1046         struct in6_addr *saddr = &skb->nh.ipv6h->saddr;
1047         struct ndisc_options ndopts;
1048         u8 *lladdr = NULL;
1049
1050         if (skb->len < sizeof(*rs_msg))
1051                 return;
1052
1053         idev = in6_dev_get(skb->dev);
1054         if (!idev) {
1055                 if (net_ratelimit())
1056                         ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1057                 return;
1058         }
1059
1060         /* Don't accept RS if we're not in router mode */
1061         if (!idev->cnf.forwarding)
1062                 goto out;
1063
1064         /*
1065          * Don't update NCE if src = ::;
1066          * this implies that the source node has no ip address assigned yet.
1067          */
1068         if (ipv6_addr_any(saddr))
1069                 goto out;
1070
1071         /* Parse ND options */
1072         if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
1073                 if (net_ratelimit())
1074                         ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1075                 goto out;
1076         }
1077
1078         if (ndopts.nd_opts_src_lladdr) {
1079                 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1080                                              skb->dev);
1081                 if (!lladdr)
1082                         goto out;
1083         }
1084
1085         neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1086         if (neigh) {
1087                 neigh_update(neigh, lladdr, NUD_STALE,
1088                              NEIGH_UPDATE_F_WEAK_OVERRIDE|
1089                              NEIGH_UPDATE_F_OVERRIDE|
1090                              NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1091                 neigh_release(neigh);
1092         }
1093 out:
1094         in6_dev_put(idev);
1095 }
1096
1097 static void ndisc_router_discovery(struct sk_buff *skb)
1098 {
1099         struct ra_msg *ra_msg = (struct ra_msg *) skb->h.raw;
1100         struct neighbour *neigh = NULL;
1101         struct inet6_dev *in6_dev;
1102         struct rt6_info *rt = NULL;
1103         int lifetime;
1104         struct ndisc_options ndopts;
1105         int optlen;
1106         unsigned int pref = 0;
1107
1108         __u8 * opt = (__u8 *)(ra_msg + 1);
1109
1110         optlen = (skb->tail - skb->h.raw) - sizeof(struct ra_msg);
1111
1112         if (!(ipv6_addr_type(&skb->nh.ipv6h->saddr) & IPV6_ADDR_LINKLOCAL)) {
1113                 ND_PRINTK2(KERN_WARNING
1114                            "ICMPv6 RA: source address is not link-local.\n");
1115                 return;
1116         }
1117         if (optlen < 0) {
1118                 ND_PRINTK2(KERN_WARNING
1119                            "ICMPv6 RA: packet too short\n");
1120                 return;
1121         }
1122
1123         /*
1124          *      set the RA_RECV flag in the interface
1125          */
1126
1127         in6_dev = in6_dev_get(skb->dev);
1128         if (in6_dev == NULL) {
1129                 ND_PRINTK0(KERN_ERR
1130                            "ICMPv6 RA: can't find inet6 device for %s.\n",
1131                            skb->dev->name);
1132                 return;
1133         }
1134         if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {
1135                 in6_dev_put(in6_dev);
1136                 return;
1137         }
1138
1139         if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1140                 in6_dev_put(in6_dev);
1141                 ND_PRINTK2(KERN_WARNING
1142                            "ICMP6 RA: invalid ND options\n");
1143                 return;
1144         }
1145
1146         if (in6_dev->if_flags & IF_RS_SENT) {
1147                 /*
1148                  *      flag that an RA was received after an RS was sent
1149                  *      out on this interface.
1150                  */
1151                 in6_dev->if_flags |= IF_RA_RCVD;
1152         }
1153
1154         /*
1155          * Remember the managed/otherconf flags from most recently
1156          * received RA message (RFC 2462) -- yoshfuji
1157          */
1158         in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1159                                 IF_RA_OTHERCONF)) |
1160                                 (ra_msg->icmph.icmp6_addrconf_managed ?
1161                                         IF_RA_MANAGED : 0) |
1162                                 (ra_msg->icmph.icmp6_addrconf_other ?
1163                                         IF_RA_OTHERCONF : 0);
1164
1165         if (!in6_dev->cnf.accept_ra_defrtr)
1166                 goto skip_defrtr;
1167
1168         lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1169
1170 #ifdef CONFIG_IPV6_ROUTER_PREF
1171         pref = ra_msg->icmph.icmp6_router_pref;
1172         /* 10b is handled as if it were 00b (medium) */
1173         if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1174             in6_dev->cnf.accept_ra_rtr_pref)
1175                 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1176 #endif
1177
1178         rt = rt6_get_dflt_router(&skb->nh.ipv6h->saddr, skb->dev);
1179
1180         if (rt)
1181                 neigh = rt->rt6i_nexthop;
1182
1183         if (rt && lifetime == 0) {
1184                 neigh_clone(neigh);
1185                 ip6_del_rt(rt);
1186                 rt = NULL;
1187         }
1188
1189         if (rt == NULL && lifetime) {
1190                 ND_PRINTK3(KERN_DEBUG
1191                            "ICMPv6 RA: adding default router.\n");
1192
1193                 rt = rt6_add_dflt_router(&skb->nh.ipv6h->saddr, skb->dev, pref);
1194                 if (rt == NULL) {
1195                         ND_PRINTK0(KERN_ERR
1196                                    "ICMPv6 RA: %s() failed to add default route.\n",
1197                                    __FUNCTION__);
1198                         in6_dev_put(in6_dev);
1199                         return;
1200                 }
1201
1202                 neigh = rt->rt6i_nexthop;
1203                 if (neigh == NULL) {
1204                         ND_PRINTK0(KERN_ERR
1205                                    "ICMPv6 RA: %s() got default router without neighbour.\n",
1206                                    __FUNCTION__);
1207                         dst_release(&rt->u.dst);
1208                         in6_dev_put(in6_dev);
1209                         return;
1210                 }
1211                 neigh->flags |= NTF_ROUTER;
1212         } else if (rt) {
1213                 rt->rt6i_flags |= (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1214         }
1215
1216         if (rt)
1217                 rt->rt6i_expires = jiffies + (HZ * lifetime);
1218
1219         if (ra_msg->icmph.icmp6_hop_limit) {
1220                 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1221                 if (rt)
1222                         rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;
1223         }
1224
1225 skip_defrtr:
1226
1227         /*
1228          *      Update Reachable Time and Retrans Timer
1229          */
1230
1231         if (in6_dev->nd_parms) {
1232                 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1233
1234                 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1235                         rtime = (rtime*HZ)/1000;
1236                         if (rtime < HZ/10)
1237                                 rtime = HZ/10;
1238                         in6_dev->nd_parms->retrans_time = rtime;
1239                         in6_dev->tstamp = jiffies;
1240                         inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1241                 }
1242
1243                 rtime = ntohl(ra_msg->reachable_time);
1244                 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1245                         rtime = (rtime*HZ)/1000;
1246
1247                         if (rtime < HZ/10)
1248                                 rtime = HZ/10;
1249
1250                         if (rtime != in6_dev->nd_parms->base_reachable_time) {
1251                                 in6_dev->nd_parms->base_reachable_time = rtime;
1252                                 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1253                                 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1254                                 in6_dev->tstamp = jiffies;
1255                                 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1256                         }
1257                 }
1258         }
1259
1260         /*
1261          *      Process options.
1262          */
1263
1264         if (!neigh)
1265                 neigh = __neigh_lookup(&nd_tbl, &skb->nh.ipv6h->saddr,
1266                                        skb->dev, 1);
1267         if (neigh) {
1268                 u8 *lladdr = NULL;
1269                 if (ndopts.nd_opts_src_lladdr) {
1270                         lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1271                                                      skb->dev);
1272                         if (!lladdr) {
1273                                 ND_PRINTK2(KERN_WARNING
1274                                            "ICMPv6 RA: invalid link-layer address length\n");
1275                                 goto out;
1276                         }
1277                 }
1278                 neigh_update(neigh, lladdr, NUD_STALE,
1279                              NEIGH_UPDATE_F_WEAK_OVERRIDE|
1280                              NEIGH_UPDATE_F_OVERRIDE|
1281                              NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1282                              NEIGH_UPDATE_F_ISROUTER);
1283         }
1284
1285 #ifdef CONFIG_IPV6_ROUTE_INFO
1286         if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1287                 struct nd_opt_hdr *p;
1288                 for (p = ndopts.nd_opts_ri;
1289                      p;
1290                      p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1291                         if (((struct route_info *)p)->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1292                                 continue;
1293                         rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1294                                       &skb->nh.ipv6h->saddr);
1295                 }
1296         }
1297 #endif
1298
1299         if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1300                 struct nd_opt_hdr *p;
1301                 for (p = ndopts.nd_opts_pi;
1302                      p;
1303                      p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1304                         addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1305                 }
1306         }
1307
1308         if (ndopts.nd_opts_mtu) {
1309                 __be32 n;
1310                 u32 mtu;
1311
1312                 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1313                 mtu = ntohl(n);
1314
1315                 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1316                         ND_PRINTK2(KERN_WARNING
1317                                    "ICMPv6 RA: invalid mtu: %d\n",
1318                                    mtu);
1319                 } else if (in6_dev->cnf.mtu6 != mtu) {
1320                         in6_dev->cnf.mtu6 = mtu;
1321
1322                         if (rt)
1323                                 rt->u.dst.metrics[RTAX_MTU-1] = mtu;
1324
1325                         rt6_mtu_change(skb->dev, mtu);
1326                 }
1327         }
1328
1329         if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1330                 ND_PRINTK2(KERN_WARNING
1331                            "ICMPv6 RA: invalid RA options");
1332         }
1333 out:
1334         if (rt)
1335                 dst_release(&rt->u.dst);
1336         else if (neigh)
1337                 neigh_release(neigh);
1338         in6_dev_put(in6_dev);
1339 }
1340
1341 static void ndisc_redirect_rcv(struct sk_buff *skb)
1342 {
1343         struct inet6_dev *in6_dev;
1344         struct icmp6hdr *icmph;
1345         struct in6_addr *dest;
1346         struct in6_addr *target;        /* new first hop to destination */
1347         struct neighbour *neigh;
1348         int on_link = 0;
1349         struct ndisc_options ndopts;
1350         int optlen;
1351         u8 *lladdr = NULL;
1352
1353         if (!(ipv6_addr_type(&skb->nh.ipv6h->saddr) & IPV6_ADDR_LINKLOCAL)) {
1354                 ND_PRINTK2(KERN_WARNING
1355                            "ICMPv6 Redirect: source address is not link-local.\n");
1356                 return;
1357         }
1358
1359         optlen = skb->tail - skb->h.raw;
1360         optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1361
1362         if (optlen < 0) {
1363                 ND_PRINTK2(KERN_WARNING
1364                            "ICMPv6 Redirect: packet too short\n");
1365                 return;
1366         }
1367
1368         icmph = (struct icmp6hdr *) skb->h.raw;
1369         target = (struct in6_addr *) (icmph + 1);
1370         dest = target + 1;
1371
1372         if (ipv6_addr_is_multicast(dest)) {
1373                 ND_PRINTK2(KERN_WARNING
1374                            "ICMPv6 Redirect: destination address is multicast.\n");
1375                 return;
1376         }
1377
1378         if (ipv6_addr_equal(dest, target)) {
1379                 on_link = 1;
1380         } else if (!(ipv6_addr_type(target) & IPV6_ADDR_LINKLOCAL)) {
1381                 ND_PRINTK2(KERN_WARNING
1382                            "ICMPv6 Redirect: target address is not link-local.\n");
1383                 return;
1384         }
1385
1386         in6_dev = in6_dev_get(skb->dev);
1387         if (!in6_dev)
1388                 return;
1389         if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1390                 in6_dev_put(in6_dev);
1391                 return;
1392         }
1393
1394         /* RFC2461 8.1:
1395          *      The IP source address of the Redirect MUST be the same as the current
1396          *      first-hop router for the specified ICMP Destination Address.
1397          */
1398
1399         if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1400                 ND_PRINTK2(KERN_WARNING
1401                            "ICMPv6 Redirect: invalid ND options\n");
1402                 in6_dev_put(in6_dev);
1403                 return;
1404         }
1405         if (ndopts.nd_opts_tgt_lladdr) {
1406                 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1407                                              skb->dev);
1408                 if (!lladdr) {
1409                         ND_PRINTK2(KERN_WARNING
1410                                    "ICMPv6 Redirect: invalid link-layer address length\n");
1411                         in6_dev_put(in6_dev);
1412                         return;
1413                 }
1414         }
1415
1416         neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1417         if (neigh) {
1418                 rt6_redirect(dest, &skb->nh.ipv6h->daddr,
1419                              &skb->nh.ipv6h->saddr, neigh, lladdr,
1420                              on_link);
1421                 neigh_release(neigh);
1422         }
1423         in6_dev_put(in6_dev);
1424 }
1425
1426 void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
1427                          struct in6_addr *target)
1428 {
1429         struct sock *sk = ndisc_socket->sk;
1430         int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1431         struct sk_buff *buff;
1432         struct icmp6hdr *icmph;
1433         struct in6_addr saddr_buf;
1434         struct in6_addr *addrp;
1435         struct net_device *dev;
1436         struct rt6_info *rt;
1437         struct dst_entry *dst;
1438         struct inet6_dev *idev;
1439         struct flowi fl;
1440         u8 *opt;
1441         int rd_len;
1442         int err;
1443         int hlen;
1444         u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1445
1446         dev = skb->dev;
1447
1448         if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1449                 ND_PRINTK2(KERN_WARNING
1450                            "ICMPv6 Redirect: no link-local address on %s\n",
1451                            dev->name);
1452                 return;
1453         }
1454
1455         if (!ipv6_addr_equal(&skb->nh.ipv6h->daddr, target) &&
1456             !(ipv6_addr_type(target) & IPV6_ADDR_LINKLOCAL)) {
1457                 ND_PRINTK2(KERN_WARNING
1458                         "ICMPv6 Redirect: target address is not link-local.\n");
1459                 return;
1460         }
1461
1462         ndisc_flow_init(&fl, NDISC_REDIRECT, &saddr_buf, &skb->nh.ipv6h->saddr,
1463                         dev->ifindex);
1464
1465         dst = ip6_route_output(NULL, &fl);
1466         if (dst == NULL)
1467                 return;
1468
1469         err = xfrm_lookup(&dst, &fl, NULL, 0);
1470         if (err)
1471                 return;
1472
1473         rt = (struct rt6_info *) dst;
1474
1475         if (rt->rt6i_flags & RTF_GATEWAY) {
1476                 ND_PRINTK2(KERN_WARNING
1477                            "ICMPv6 Redirect: destination is not a neighbour.\n");
1478                 dst_release(dst);
1479                 return;
1480         }
1481         if (!xrlim_allow(dst, 1*HZ)) {
1482                 dst_release(dst);
1483                 return;
1484         }
1485
1486         if (dev->addr_len) {
1487                 read_lock_bh(&neigh->lock);
1488                 if (neigh->nud_state & NUD_VALID) {
1489                         memcpy(ha_buf, neigh->ha, dev->addr_len);
1490                         read_unlock_bh(&neigh->lock);
1491                         ha = ha_buf;
1492                         len += ndisc_opt_addr_space(dev);
1493                 } else
1494                         read_unlock_bh(&neigh->lock);
1495         }
1496
1497         rd_len = min_t(unsigned int,
1498                      IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1499         rd_len &= ~0x7;
1500         len += rd_len;
1501
1502         buff = sock_alloc_send_skb(sk,
1503                                    (MAX_HEADER + sizeof(struct ipv6hdr) +
1504                                     len + LL_RESERVED_SPACE(dev)),
1505                                    1, &err);
1506         if (buff == NULL) {
1507                 ND_PRINTK0(KERN_ERR
1508                            "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
1509                            __FUNCTION__);
1510                 dst_release(dst);
1511                 return;
1512         }
1513
1514         hlen = 0;
1515
1516         skb_reserve(buff, LL_RESERVED_SPACE(dev));
1517         ip6_nd_hdr(sk, buff, dev, &saddr_buf, &skb->nh.ipv6h->saddr,
1518                    IPPROTO_ICMPV6, len);
1519
1520         icmph = (struct icmp6hdr *)skb_put(buff, len);
1521         buff->h.raw = (unsigned char*)icmph;
1522
1523         memset(icmph, 0, sizeof(struct icmp6hdr));
1524         icmph->icmp6_type = NDISC_REDIRECT;
1525
1526         /*
1527          *      copy target and destination addresses
1528          */
1529
1530         addrp = (struct in6_addr *)(icmph + 1);
1531         ipv6_addr_copy(addrp, target);
1532         addrp++;
1533         ipv6_addr_copy(addrp, &skb->nh.ipv6h->daddr);
1534
1535         opt = (u8*) (addrp + 1);
1536
1537         /*
1538          *      include target_address option
1539          */
1540
1541         if (ha)
1542                 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1543                                              dev->addr_len, dev->type);
1544
1545         /*
1546          *      build redirect option and copy skb over to the new packet.
1547          */
1548
1549         memset(opt, 0, 8);
1550         *(opt++) = ND_OPT_REDIRECT_HDR;
1551         *(opt++) = (rd_len >> 3);
1552         opt += 6;
1553
1554         memcpy(opt, skb->nh.ipv6h, rd_len - 8);
1555
1556         icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &skb->nh.ipv6h->saddr,
1557                                              len, IPPROTO_ICMPV6,
1558                                              csum_partial((u8 *) icmph, len, 0));
1559
1560         buff->dst = dst;
1561         idev = in6_dev_get(dst->dev);
1562         IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
1563         err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, buff, NULL, dst->dev, dst_output);
1564         if (!err) {
1565                 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTREDIRECTS);
1566                 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
1567         }
1568
1569         if (likely(idev != NULL))
1570                 in6_dev_put(idev);
1571 }
1572
1573 static void pndisc_redo(struct sk_buff *skb)
1574 {
1575         ndisc_recv_ns(skb);
1576         kfree_skb(skb);
1577 }
1578
1579 int ndisc_rcv(struct sk_buff *skb)
1580 {
1581         struct nd_msg *msg;
1582
1583         if (!pskb_may_pull(skb, skb->len))
1584                 return 0;
1585
1586         msg = (struct nd_msg *) skb->h.raw;
1587
1588         __skb_push(skb, skb->data-skb->h.raw);
1589
1590         if (skb->nh.ipv6h->hop_limit != 255) {
1591                 ND_PRINTK2(KERN_WARNING
1592                            "ICMPv6 NDISC: invalid hop-limit: %d\n",
1593                            skb->nh.ipv6h->hop_limit);
1594                 return 0;
1595         }
1596
1597         if (msg->icmph.icmp6_code != 0) {
1598                 ND_PRINTK2(KERN_WARNING
1599                            "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1600                            msg->icmph.icmp6_code);
1601                 return 0;
1602         }
1603
1604         memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1605
1606         switch (msg->icmph.icmp6_type) {
1607         case NDISC_NEIGHBOUR_SOLICITATION:
1608                 ndisc_recv_ns(skb);
1609                 break;
1610
1611         case NDISC_NEIGHBOUR_ADVERTISEMENT:
1612                 ndisc_recv_na(skb);
1613                 break;
1614
1615         case NDISC_ROUTER_SOLICITATION:
1616                 ndisc_recv_rs(skb);
1617                 break;
1618
1619         case NDISC_ROUTER_ADVERTISEMENT:
1620                 ndisc_router_discovery(skb);
1621                 break;
1622
1623         case NDISC_REDIRECT:
1624                 ndisc_redirect_rcv(skb);
1625                 break;
1626         };
1627
1628         return 0;
1629 }
1630
1631 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1632 {
1633         struct net_device *dev = ptr;
1634
1635         switch (event) {
1636         case NETDEV_CHANGEADDR:
1637                 neigh_changeaddr(&nd_tbl, dev);
1638                 fib6_run_gc(~0UL);
1639                 break;
1640         case NETDEV_DOWN:
1641                 neigh_ifdown(&nd_tbl, dev);
1642                 fib6_run_gc(~0UL);
1643                 break;
1644         default:
1645                 break;
1646         }
1647
1648         return NOTIFY_DONE;
1649 }
1650
1651 static struct notifier_block ndisc_netdev_notifier = {
1652         .notifier_call = ndisc_netdev_event,
1653 };
1654
1655 #ifdef CONFIG_SYSCTL
1656 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1657                                          const char *func, const char *dev_name)
1658 {
1659         static char warncomm[TASK_COMM_LEN];
1660         static int warned;
1661         if (strcmp(warncomm, current->comm) && warned < 5) {
1662                 strcpy(warncomm, current->comm);
1663                 printk(KERN_WARNING
1664                         "process `%s' is using deprecated sysctl (%s) "
1665                         "net.ipv6.neigh.%s.%s; "
1666                         "Use net.ipv6.neigh.%s.%s_ms "
1667                         "instead.\n",
1668                         warncomm, func,
1669                         dev_name, ctl->procname,
1670                         dev_name, ctl->procname);
1671                 warned++;
1672         }
1673 }
1674
1675 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)
1676 {
1677         struct net_device *dev = ctl->extra1;
1678         struct inet6_dev *idev;
1679         int ret;
1680
1681         if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1682             ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1683                 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1684
1685         switch (ctl->ctl_name) {
1686         case NET_NEIGH_RETRANS_TIME:
1687                 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1688                 break;
1689         case NET_NEIGH_REACHABLE_TIME:
1690                 ret = proc_dointvec_jiffies(ctl, write,
1691                                             filp, buffer, lenp, ppos);
1692                 break;
1693         case NET_NEIGH_RETRANS_TIME_MS:
1694         case NET_NEIGH_REACHABLE_TIME_MS:
1695                 ret = proc_dointvec_ms_jiffies(ctl, write,
1696                                                filp, buffer, lenp, ppos);
1697                 break;
1698         default:
1699                 ret = -1;
1700         }
1701
1702         if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1703                 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1704                     ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1705                         idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1706                 idev->tstamp = jiffies;
1707                 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1708                 in6_dev_put(idev);
1709         }
1710         return ret;
1711 }
1712
1713 static int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl, int __user *name,
1714                                         int nlen, void __user *oldval,
1715                                         size_t __user *oldlenp,
1716                                         void __user *newval, size_t newlen)
1717 {
1718         struct net_device *dev = ctl->extra1;
1719         struct inet6_dev *idev;
1720         int ret;
1721
1722         if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1723             ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1724                 ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");
1725
1726         switch (ctl->ctl_name) {
1727         case NET_NEIGH_REACHABLE_TIME:
1728                 ret = sysctl_jiffies(ctl, name, nlen,
1729                                      oldval, oldlenp, newval, newlen);
1730                 break;
1731         case NET_NEIGH_RETRANS_TIME_MS:
1732         case NET_NEIGH_REACHABLE_TIME_MS:
1733                  ret = sysctl_ms_jiffies(ctl, name, nlen,
1734                                          oldval, oldlenp, newval, newlen);
1735                  break;
1736         default:
1737                 ret = 0;
1738         }
1739
1740         if (newval && newlen && ret > 0 &&
1741             dev && (idev = in6_dev_get(dev)) != NULL) {
1742                 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1743                     ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1744                         idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1745                 idev->tstamp = jiffies;
1746                 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1747                 in6_dev_put(idev);
1748         }
1749
1750         return ret;
1751 }
1752
1753 #endif
1754
1755 int __init ndisc_init(struct net_proto_family *ops)
1756 {
1757         struct ipv6_pinfo *np;
1758         struct sock *sk;
1759         int err;
1760
1761         err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6, &ndisc_socket);
1762         if (err < 0) {
1763                 ND_PRINTK0(KERN_ERR
1764                            "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1765                            err);
1766                 ndisc_socket = NULL; /* For safety. */
1767                 return err;
1768         }
1769
1770         sk = ndisc_socket->sk;
1771         np = inet6_sk(sk);
1772         sk->sk_allocation = GFP_ATOMIC;
1773         np->hop_limit = 255;
1774         /* Do not loopback ndisc messages */
1775         np->mc_loop = 0;
1776         sk->sk_prot->unhash(sk);
1777
1778         /*
1779          * Initialize the neighbour table
1780          */
1781
1782         neigh_table_init(&nd_tbl);
1783
1784 #ifdef CONFIG_SYSCTL
1785         neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6, NET_IPV6_NEIGH,
1786                               "ipv6",
1787                               &ndisc_ifinfo_sysctl_change,
1788                               &ndisc_ifinfo_sysctl_strategy);
1789 #endif
1790
1791         register_netdevice_notifier(&ndisc_netdev_notifier);
1792         return 0;
1793 }
1794
1795 void ndisc_cleanup(void)
1796 {
1797         unregister_netdevice_notifier(&ndisc_netdev_notifier);
1798 #ifdef CONFIG_SYSCTL
1799         neigh_sysctl_unregister(&nd_tbl.parms);
1800 #endif
1801         neigh_table_clear(&nd_tbl);
1802         sock_release(ndisc_socket);
1803         ndisc_socket = NULL; /* For safety. */
1804 }