net/ipv6/ndisc.c

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