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