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