net/ipv6/ndisc.c

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