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