net/ipv6/ndisc.c

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