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