2 * Neighbour Discovery for IPv6
3 * Linux INET6 implementation
6 * Pedro Roque <roque@di.fc.ul.pt>
7 * Mike Shaver <shaver@ingenia.com>
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.
18 * Pierre Ynard : export userland ND options
19 * through netlink (RDNSS support)
20 * Lars Fenneberg : fixed MTU setting on receipt
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
29 /* Set to 3 to get tracing... */
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
40 #define ND_PRINTK1 ND_PRINTK
44 #define ND_PRINTK2 ND_PRINTK
48 #define ND_PRINTK3 ND_PRINTK
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>
64 #include <linux/sysctl.h>
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>
77 #include <net/protocol.h>
78 #include <net/ndisc.h>
79 #include <net/ip6_route.h>
80 #include <net/addrconf.h>
83 #include <net/netlink.h>
84 #include <linux/rtnetlink.h>
87 #include <net/ip6_checksum.h>
88 #include <net/inet_common.h>
89 #include <linux/proc_fs.h>
91 #include <linux/netfilter.h>
92 #include <linux/netfilter_ipv6.h>
94 static u32 ndisc_hash(const void *pkey,
95 const struct net_device *dev,
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);
104 static const struct neigh_ops ndisc_generic_ops = {
106 .solicit = ndisc_solicit,
107 .error_report = ndisc_error_report,
108 .output = neigh_resolve_output,
109 .connected_output = neigh_connected_output,
112 static const struct neigh_ops ndisc_hh_ops = {
114 .solicit = ndisc_solicit,
115 .error_report = ndisc_error_report,
116 .output = neigh_resolve_output,
117 .connected_output = neigh_resolve_output,
121 static const struct neigh_ops ndisc_direct_ops = {
123 .output = neigh_direct_output,
124 .connected_output = neigh_direct_output,
127 struct neigh_table nd_tbl = {
129 .entry_size = sizeof(struct neighbour) + sizeof(struct in6_addr),
130 .key_len = sizeof(struct in6_addr),
132 .constructor = ndisc_constructor,
133 .pconstructor = pndisc_constructor,
134 .pdestructor = pndisc_destructor,
135 .proxy_redo = pndisc_redo,
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,
147 .anycast_delay = 1 * HZ,
148 .proxy_delay = (8 * HZ) / 10,
151 .gc_interval = 30 * HZ,
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;
164 struct nd_opt_hdr *nd_useropts;
165 struct nd_opt_hdr *nd_useropts_end;
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]
175 #define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
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.
183 static int ndisc_addr_option_pad(unsigned short type)
186 case ARPHRD_INFINIBAND: return 2;
191 static inline int ndisc_opt_addr_space(struct net_device *dev)
193 return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type));
196 static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len,
197 unsigned short addr_type)
199 int space = NDISC_OPT_SPACE(data_len);
200 int pad = ndisc_addr_option_pad(addr_type);
205 memset(opt + 2, 0, pad);
209 memcpy(opt+2, data, data_len);
212 if ((space -= data_len) > 0)
213 memset(opt, 0, space);
217 static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
218 struct nd_opt_hdr *end)
221 if (!cur || !end || cur >= end)
223 type = cur->nd_opt_type;
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;
230 static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
232 return opt->nd_opt_type == ND_OPT_RDNSS;
235 static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur,
236 struct nd_opt_hdr *end)
238 if (!cur || !end || cur >= end)
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;
246 static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
247 struct ndisc_options *ndopts)
249 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
251 if (!nd_opt || opt_len < 0 || !ndopts)
253 memset(ndopts, 0, sizeof(*ndopts));
256 if (opt_len < sizeof(struct nd_opt_hdr))
258 l = nd_opt->nd_opt_len << 3;
259 if (opt_len < l || l == 0)
261 switch (nd_opt->nd_opt_type) {
262 case ND_OPT_SOURCE_LL_ADDR:
263 case ND_OPT_TARGET_LL_ADDR:
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",
270 nd_opt->nd_opt_type);
272 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
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;
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;
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;
294 * Unknown options must be silently ignored,
295 * to accommodate future extension to the
298 ND_PRINTK2(KERN_NOTICE
299 "%s(): ignored unsupported option; type=%d, len=%d\n",
301 nd_opt->nd_opt_type, nd_opt->nd_opt_len);
305 nd_opt = ((void *)nd_opt) + l;
310 static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p,
311 struct net_device *dev)
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))
318 return lladdr + prepad;
321 int ndisc_mc_map(const struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
325 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
327 ipv6_eth_mc_map(addr, buf);
329 case ARPHRD_IEEE802_TR:
330 ipv6_tr_mc_map(addr,buf);
333 ipv6_arcnet_mc_map(addr, buf);
335 case ARPHRD_INFINIBAND:
336 ipv6_ib_mc_map(addr, dev->broadcast, buf);
339 return ipv6_ipgre_mc_map(addr, dev->broadcast, buf);
342 memcpy(buf, dev->broadcast, dev->addr_len);
349 EXPORT_SYMBOL(ndisc_mc_map);
351 static u32 ndisc_hash(const void *pkey,
352 const struct net_device *dev,
355 const u32 *p32 = pkey;
359 for (i = 0; i < (sizeof(struct in6_addr) / sizeof(u32)); i++)
362 return jhash_2words(addr_hash, dev->ifindex, hash_rnd);
365 static int ndisc_constructor(struct neighbour *neigh)
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);
373 in6_dev = in6_dev_get(dev);
374 if (in6_dev == NULL) {
378 parms = in6_dev->nd_parms;
379 __neigh_parms_put(neigh->parms);
380 neigh->parms = neigh_parms_clone(parms);
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;
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);
400 if (dev->header_ops->cache)
401 neigh->ops = &ndisc_hh_ops;
403 neigh->ops = &ndisc_generic_ops;
404 if (neigh->nud_state&NUD_VALID)
405 neigh->output = neigh->ops->connected_output;
407 neigh->output = neigh->ops->output;
409 in6_dev_put(in6_dev);
413 static int pndisc_constructor(struct pneigh_entry *n)
415 struct in6_addr *addr = (struct in6_addr*)&n->key;
416 struct in6_addr maddr;
417 struct net_device *dev = n->dev;
419 if (dev == NULL || __in6_dev_get(dev) == NULL)
421 addrconf_addr_solict_mult(addr, &maddr);
422 ipv6_dev_mc_inc(dev, &maddr);
426 static void pndisc_destructor(struct pneigh_entry *n)
428 struct in6_addr *addr = (struct in6_addr*)&n->key;
429 struct in6_addr maddr;
430 struct net_device *dev = n->dev;
432 if (dev == NULL || __in6_dev_get(dev) == NULL)
434 addrconf_addr_solict_mult(addr, &maddr);
435 ipv6_dev_mc_dec(dev, &maddr);
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,
445 struct net *net = dev_net(dev);
446 struct sock *sk = net->ipv6.ndisc_sk;
448 struct icmp6hdr *hdr;
455 len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0);
457 len += ndisc_opt_addr_space(dev);
459 skb = alloc_skb((MAX_HEADER + sizeof(struct ipv6hdr) +
460 len + LL_ALLOCATED_SPACE(dev)), GFP_ATOMIC);
463 "ICMPv6 ND: %s() failed to allocate an skb.\n",
468 skb_reserve(skb, LL_RESERVED_SPACE(dev));
469 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
471 skb->transport_header = skb->tail;
474 hdr = (struct icmp6hdr *)skb_transport_header(skb);
475 memcpy(hdr, icmp6h, sizeof(*hdr));
477 opt = skb_transport_header(skb) + sizeof(struct icmp6hdr);
479 ipv6_addr_copy((struct in6_addr *)opt, target);
480 opt += sizeof(*target);
484 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr,
485 dev->addr_len, dev->type);
487 hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len,
492 /* Manually assign socket ownership as we avoid calling
493 * sock_alloc_send_pskb() to bypass wmem buffer limits
495 skb_set_owner_w(skb, sk);
500 EXPORT_SYMBOL(ndisc_build_skb);
502 void ndisc_send_skb(struct sk_buff *skb,
503 struct net_device *dev,
504 struct neighbour *neigh,
505 const struct in6_addr *daddr,
506 const struct in6_addr *saddr,
507 struct icmp6hdr *icmp6h)
510 struct dst_entry *dst;
511 struct net *net = dev_net(dev);
512 struct sock *sk = net->ipv6.ndisc_sk;
513 struct inet6_dev *idev;
517 type = icmp6h->icmp6_type;
519 icmpv6_flow_init(sk, &fl6, type, saddr, daddr, dev->ifindex);
521 dst = icmp6_dst_alloc(dev, neigh, daddr);
527 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
533 skb_dst_set(skb, dst);
536 idev = __in6_dev_get(dst->dev);
537 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
539 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
542 ICMP6MSGOUT_INC_STATS(net, idev, type);
543 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
549 EXPORT_SYMBOL(ndisc_send_skb);
552 * Send a Neighbour Discover packet
554 static void __ndisc_send(struct net_device *dev,
555 struct neighbour *neigh,
556 const struct in6_addr *daddr,
557 const struct in6_addr *saddr,
558 struct icmp6hdr *icmp6h, const struct in6_addr *target,
563 skb = ndisc_build_skb(dev, daddr, saddr, icmp6h, target, llinfo);
567 ndisc_send_skb(skb, dev, neigh, daddr, saddr, icmp6h);
570 static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
571 const struct in6_addr *daddr,
572 const struct in6_addr *solicited_addr,
573 int router, int solicited, int override, int inc_opt)
575 struct in6_addr tmpaddr;
576 struct inet6_ifaddr *ifp;
577 const struct in6_addr *src_addr;
578 struct icmp6hdr icmp6h = {
579 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
582 /* for anycast or proxy, solicited_addr != src_addr */
583 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
585 src_addr = solicited_addr;
586 if (ifp->flags & IFA_F_OPTIMISTIC)
588 inc_opt |= ifp->idev->cnf.force_tllao;
591 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
592 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
598 icmp6h.icmp6_router = router;
599 icmp6h.icmp6_solicited = solicited;
600 icmp6h.icmp6_override = override;
602 __ndisc_send(dev, neigh, daddr, src_addr,
603 &icmp6h, solicited_addr,
604 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
607 static void ndisc_send_unsol_na(struct net_device *dev)
609 struct inet6_dev *idev;
610 struct inet6_ifaddr *ifa;
611 struct in6_addr mcaddr = IN6ADDR_LINKLOCAL_ALLNODES_INIT;
613 idev = in6_dev_get(dev);
617 read_lock_bh(&idev->lock);
618 list_for_each_entry(ifa, &idev->addr_list, if_list) {
619 ndisc_send_na(dev, NULL, &mcaddr, &ifa->addr,
620 /*router=*/ !!idev->cnf.forwarding,
621 /*solicited=*/ false, /*override=*/ true,
624 read_unlock_bh(&idev->lock);
629 void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
630 const struct in6_addr *solicit,
631 const struct in6_addr *daddr, const struct in6_addr *saddr)
633 struct in6_addr addr_buf;
634 struct icmp6hdr icmp6h = {
635 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
639 if (ipv6_get_lladdr(dev, &addr_buf,
640 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
645 __ndisc_send(dev, neigh, daddr, saddr,
647 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
650 void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
651 const struct in6_addr *daddr)
653 struct icmp6hdr icmp6h = {
654 .icmp6_type = NDISC_ROUTER_SOLICITATION,
656 int send_sllao = dev->addr_len;
658 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
660 * According to section 2.2 of RFC 4429, we must not
661 * send router solicitations with a sllao from
662 * optimistic addresses, but we may send the solicitation
663 * if we don't include the sllao. So here we check
664 * if our address is optimistic, and if so, we
665 * suppress the inclusion of the sllao.
668 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
671 if (ifp->flags & IFA_F_OPTIMISTIC) {
680 __ndisc_send(dev, NULL, daddr, saddr,
682 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
686 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
689 * "The sender MUST return an ICMP
690 * destination unreachable"
692 dst_link_failure(skb);
696 /* Called with locked neigh: either read or both */
698 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
700 struct in6_addr *saddr = NULL;
701 struct in6_addr mcaddr;
702 struct net_device *dev = neigh->dev;
703 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
704 int probes = atomic_read(&neigh->probes);
706 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
707 saddr = &ipv6_hdr(skb)->saddr;
709 if ((probes -= neigh->parms->ucast_probes) < 0) {
710 if (!(neigh->nud_state & NUD_VALID)) {
711 ND_PRINTK1(KERN_DEBUG "%s(): trying to ucast probe in NUD_INVALID: %pI6\n",
714 ndisc_send_ns(dev, neigh, target, target, saddr);
715 } else if ((probes -= neigh->parms->app_probes) < 0) {
720 addrconf_addr_solict_mult(target, &mcaddr);
721 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
725 static int pndisc_is_router(const void *pkey,
726 struct net_device *dev)
728 struct pneigh_entry *n;
731 read_lock_bh(&nd_tbl.lock);
732 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
734 ret = !!(n->flags & NTF_ROUTER);
735 read_unlock_bh(&nd_tbl.lock);
740 static void ndisc_recv_ns(struct sk_buff *skb)
742 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
743 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
744 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
746 u32 ndoptlen = skb->tail - (skb->transport_header +
747 offsetof(struct nd_msg, opt));
748 struct ndisc_options ndopts;
749 struct net_device *dev = skb->dev;
750 struct inet6_ifaddr *ifp;
751 struct inet6_dev *idev = NULL;
752 struct neighbour *neigh;
753 int dad = ipv6_addr_any(saddr);
757 if (ipv6_addr_is_multicast(&msg->target)) {
758 ND_PRINTK2(KERN_WARNING
759 "ICMPv6 NS: multicast target address");
765 * DAD has to be destined for solicited node multicast address.
768 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
769 daddr->s6_addr32[1] == htonl(0x00000000) &&
770 daddr->s6_addr32[2] == htonl(0x00000001) &&
771 daddr->s6_addr [12] == 0xff )) {
772 ND_PRINTK2(KERN_WARNING
773 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
777 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
778 ND_PRINTK2(KERN_WARNING
779 "ICMPv6 NS: invalid ND options\n");
783 if (ndopts.nd_opts_src_lladdr) {
784 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
786 ND_PRINTK2(KERN_WARNING
787 "ICMPv6 NS: invalid link-layer address length\n");
792 * If the IP source address is the unspecified address,
793 * there MUST NOT be source link-layer address option
797 ND_PRINTK2(KERN_WARNING
798 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
803 inc = ipv6_addr_is_multicast(daddr);
805 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
808 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
810 if (dev->type == ARPHRD_IEEE802_TR) {
811 const unsigned char *sadr;
812 sadr = skb_mac_header(skb);
813 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
814 sadr[9] == dev->dev_addr[1] &&
815 sadr[10] == dev->dev_addr[2] &&
816 sadr[11] == dev->dev_addr[3] &&
817 sadr[12] == dev->dev_addr[4] &&
818 sadr[13] == dev->dev_addr[5]) {
819 /* looped-back to us */
825 * We are colliding with another node
827 * so fail our DAD process
829 addrconf_dad_failure(ifp);
833 * This is not a dad solicitation.
834 * If we are an optimistic node,
836 * Otherwise, we should ignore it.
838 if (!(ifp->flags & IFA_F_OPTIMISTIC))
845 struct net *net = dev_net(dev);
847 idev = in6_dev_get(dev);
849 /* XXX: count this drop? */
853 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
854 (idev->cnf.forwarding &&
855 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
856 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
857 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
858 skb->pkt_type != PACKET_HOST &&
860 idev->nd_parms->proxy_delay != 0) {
862 * for anycast or proxy,
863 * sender should delay its response
864 * by a random time between 0 and
865 * MAX_ANYCAST_DELAY_TIME seconds.
866 * (RFC2461) -- yoshfuji
868 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
870 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
878 is_router = !!idev->cnf.forwarding;
881 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
882 is_router, 0, (ifp != NULL), 1);
887 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
889 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
892 * update / create cache entry
893 * for the source address
895 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
896 !inc || lladdr || !dev->addr_len);
898 neigh_update(neigh, lladdr, NUD_STALE,
899 NEIGH_UPDATE_F_WEAK_OVERRIDE|
900 NEIGH_UPDATE_F_OVERRIDE);
901 if (neigh || !dev->header_ops) {
902 ndisc_send_na(dev, neigh, saddr, &msg->target,
904 1, (ifp != NULL && inc), inc);
906 neigh_release(neigh);
916 static void ndisc_recv_na(struct sk_buff *skb)
918 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
919 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
920 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
922 u32 ndoptlen = skb->tail - (skb->transport_header +
923 offsetof(struct nd_msg, opt));
924 struct ndisc_options ndopts;
925 struct net_device *dev = skb->dev;
926 struct inet6_ifaddr *ifp;
927 struct neighbour *neigh;
929 if (skb->len < sizeof(struct nd_msg)) {
930 ND_PRINTK2(KERN_WARNING
931 "ICMPv6 NA: packet too short\n");
935 if (ipv6_addr_is_multicast(&msg->target)) {
936 ND_PRINTK2(KERN_WARNING
937 "ICMPv6 NA: target address is multicast.\n");
941 if (ipv6_addr_is_multicast(daddr) &&
942 msg->icmph.icmp6_solicited) {
943 ND_PRINTK2(KERN_WARNING
944 "ICMPv6 NA: solicited NA is multicasted.\n");
948 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
949 ND_PRINTK2(KERN_WARNING
950 "ICMPv6 NS: invalid ND option\n");
953 if (ndopts.nd_opts_tgt_lladdr) {
954 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
956 ND_PRINTK2(KERN_WARNING
957 "ICMPv6 NA: invalid link-layer address length\n");
961 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
963 if (skb->pkt_type != PACKET_LOOPBACK
964 && (ifp->flags & IFA_F_TENTATIVE)) {
965 addrconf_dad_failure(ifp);
968 /* What should we make now? The advertisement
969 is invalid, but ndisc specs say nothing
970 about it. It could be misconfiguration, or
971 an smart proxy agent tries to help us :-)
973 We should not print the error if NA has been
974 received from loopback - it is just our own
975 unsolicited advertisement.
977 if (skb->pkt_type != PACKET_LOOPBACK)
978 ND_PRINTK1(KERN_WARNING
979 "ICMPv6 NA: someone advertises our address %pI6 on %s!\n",
980 &ifp->addr, ifp->idev->dev->name);
984 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
987 u8 old_flags = neigh->flags;
988 struct net *net = dev_net(dev);
990 if (neigh->nud_state & NUD_FAILED)
994 * Don't update the neighbor cache entry on a proxy NA from
995 * ourselves because either the proxied node is off link or it
996 * has already sent a NA to us.
998 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
999 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
1000 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
1001 /* XXX: idev->cnf.prixy_ndp */
1005 neigh_update(neigh, lladdr,
1006 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
1007 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1008 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
1009 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1010 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
1012 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
1014 * Change: router to host
1016 struct rt6_info *rt;
1017 rt = rt6_get_dflt_router(saddr, dev);
1023 neigh_release(neigh);
1027 static void ndisc_recv_rs(struct sk_buff *skb)
1029 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
1030 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
1031 struct neighbour *neigh;
1032 struct inet6_dev *idev;
1033 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
1034 struct ndisc_options ndopts;
1037 if (skb->len < sizeof(*rs_msg))
1040 idev = __in6_dev_get(skb->dev);
1042 if (net_ratelimit())
1043 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1047 /* Don't accept RS if we're not in router mode */
1048 if (!idev->cnf.forwarding)
1052 * Don't update NCE if src = ::;
1053 * this implies that the source node has no ip address assigned yet.
1055 if (ipv6_addr_any(saddr))
1058 /* Parse ND options */
1059 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
1060 if (net_ratelimit())
1061 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1065 if (ndopts.nd_opts_src_lladdr) {
1066 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1072 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1074 neigh_update(neigh, lladdr, NUD_STALE,
1075 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1076 NEIGH_UPDATE_F_OVERRIDE|
1077 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1078 neigh_release(neigh);
1084 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1086 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1087 struct sk_buff *skb;
1088 struct nlmsghdr *nlh;
1089 struct nduseroptmsg *ndmsg;
1090 struct net *net = dev_net(ra->dev);
1092 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1093 + (opt->nd_opt_len << 3));
1094 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1096 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1102 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1104 goto nla_put_failure;
1107 ndmsg = nlmsg_data(nlh);
1108 ndmsg->nduseropt_family = AF_INET6;
1109 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
1110 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1111 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1112 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1114 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1116 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1117 &ipv6_hdr(ra)->saddr);
1118 nlmsg_end(skb, nlh);
1120 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
1127 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1130 static inline int accept_ra(struct inet6_dev *in6_dev)
1133 * If forwarding is enabled, RA are not accepted unless the special
1134 * hybrid mode (accept_ra=2) is enabled.
1136 if (in6_dev->cnf.forwarding && in6_dev->cnf.accept_ra < 2)
1139 return in6_dev->cnf.accept_ra;
1142 static void ndisc_router_discovery(struct sk_buff *skb)
1144 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1145 struct neighbour *neigh = NULL;
1146 struct inet6_dev *in6_dev;
1147 struct rt6_info *rt = NULL;
1149 struct ndisc_options ndopts;
1151 unsigned int pref = 0;
1153 __u8 * opt = (__u8 *)(ra_msg + 1);
1155 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
1157 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1158 ND_PRINTK2(KERN_WARNING
1159 "ICMPv6 RA: source address is not link-local.\n");
1163 ND_PRINTK2(KERN_WARNING
1164 "ICMPv6 RA: packet too short\n");
1168 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1169 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1170 ND_PRINTK2(KERN_WARNING
1171 "ICMPv6 RA: from host or unauthorized router\n");
1177 * set the RA_RECV flag in the interface
1180 in6_dev = __in6_dev_get(skb->dev);
1181 if (in6_dev == NULL) {
1183 "ICMPv6 RA: can't find inet6 device for %s.\n",
1188 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1189 ND_PRINTK2(KERN_WARNING
1190 "ICMP6 RA: invalid ND options\n");
1194 if (!accept_ra(in6_dev))
1195 goto skip_linkparms;
1197 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1198 /* skip link-specific parameters from interior routers */
1199 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1200 goto skip_linkparms;
1203 if (in6_dev->if_flags & IF_RS_SENT) {
1205 * flag that an RA was received after an RS was sent
1206 * out on this interface.
1208 in6_dev->if_flags |= IF_RA_RCVD;
1212 * Remember the managed/otherconf flags from most recently
1213 * received RA message (RFC 2462) -- yoshfuji
1215 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1217 (ra_msg->icmph.icmp6_addrconf_managed ?
1218 IF_RA_MANAGED : 0) |
1219 (ra_msg->icmph.icmp6_addrconf_other ?
1220 IF_RA_OTHERCONF : 0);
1222 if (!in6_dev->cnf.accept_ra_defrtr)
1225 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
1228 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1230 #ifdef CONFIG_IPV6_ROUTER_PREF
1231 pref = ra_msg->icmph.icmp6_router_pref;
1232 /* 10b is handled as if it were 00b (medium) */
1233 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1234 !in6_dev->cnf.accept_ra_rtr_pref)
1235 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1238 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1241 neigh = dst_get_neighbour(&rt->dst);
1243 if (rt && lifetime == 0) {
1249 if (rt == NULL && lifetime) {
1250 ND_PRINTK3(KERN_DEBUG
1251 "ICMPv6 RA: adding default router.\n");
1253 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1256 "ICMPv6 RA: %s() failed to add default route.\n",
1261 neigh = dst_get_neighbour(&rt->dst);
1262 if (neigh == NULL) {
1264 "ICMPv6 RA: %s() got default router without neighbour.\n",
1266 dst_release(&rt->dst);
1269 neigh->flags |= NTF_ROUTER;
1271 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1275 rt->rt6i_expires = jiffies + (HZ * lifetime);
1277 if (ra_msg->icmph.icmp6_hop_limit) {
1278 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1280 dst_metric_set(&rt->dst, RTAX_HOPLIMIT,
1281 ra_msg->icmph.icmp6_hop_limit);
1287 * Update Reachable Time and Retrans Timer
1290 if (in6_dev->nd_parms) {
1291 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1293 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1294 rtime = (rtime*HZ)/1000;
1297 in6_dev->nd_parms->retrans_time = rtime;
1298 in6_dev->tstamp = jiffies;
1299 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1302 rtime = ntohl(ra_msg->reachable_time);
1303 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1304 rtime = (rtime*HZ)/1000;
1309 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1310 in6_dev->nd_parms->base_reachable_time = rtime;
1311 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1312 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1313 in6_dev->tstamp = jiffies;
1314 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1326 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1330 if (ndopts.nd_opts_src_lladdr) {
1331 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1334 ND_PRINTK2(KERN_WARNING
1335 "ICMPv6 RA: invalid link-layer address length\n");
1339 neigh_update(neigh, lladdr, NUD_STALE,
1340 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1341 NEIGH_UPDATE_F_OVERRIDE|
1342 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1343 NEIGH_UPDATE_F_ISROUTER);
1346 if (!accept_ra(in6_dev))
1349 #ifdef CONFIG_IPV6_ROUTE_INFO
1350 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
1351 goto skip_routeinfo;
1353 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1354 struct nd_opt_hdr *p;
1355 for (p = ndopts.nd_opts_ri;
1357 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1358 struct route_info *ri = (struct route_info *)p;
1359 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1360 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1361 ri->prefix_len == 0)
1364 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1366 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1367 &ipv6_hdr(skb)->saddr);
1374 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1375 /* skip link-specific ndopts from interior routers */
1376 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1380 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1381 struct nd_opt_hdr *p;
1382 for (p = ndopts.nd_opts_pi;
1384 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1385 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1389 if (ndopts.nd_opts_mtu) {
1393 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1396 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1397 ND_PRINTK2(KERN_WARNING
1398 "ICMPv6 RA: invalid mtu: %d\n",
1400 } else if (in6_dev->cnf.mtu6 != mtu) {
1401 in6_dev->cnf.mtu6 = mtu;
1404 dst_metric_set(&rt->dst, RTAX_MTU, mtu);
1406 rt6_mtu_change(skb->dev, mtu);
1410 if (ndopts.nd_useropts) {
1411 struct nd_opt_hdr *p;
1412 for (p = ndopts.nd_useropts;
1414 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1415 ndisc_ra_useropt(skb, p);
1419 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1420 ND_PRINTK2(KERN_WARNING
1421 "ICMPv6 RA: invalid RA options");
1425 dst_release(&rt->dst);
1427 neigh_release(neigh);
1430 static void ndisc_redirect_rcv(struct sk_buff *skb)
1432 struct inet6_dev *in6_dev;
1433 struct icmp6hdr *icmph;
1434 const struct in6_addr *dest;
1435 const struct in6_addr *target; /* new first hop to destination */
1436 struct neighbour *neigh;
1438 struct ndisc_options ndopts;
1442 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1443 switch (skb->ndisc_nodetype) {
1444 case NDISC_NODETYPE_HOST:
1445 case NDISC_NODETYPE_NODEFAULT:
1446 ND_PRINTK2(KERN_WARNING
1447 "ICMPv6 Redirect: from host or unauthorized router\n");
1452 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1453 ND_PRINTK2(KERN_WARNING
1454 "ICMPv6 Redirect: source address is not link-local.\n");
1458 optlen = skb->tail - skb->transport_header;
1459 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1462 ND_PRINTK2(KERN_WARNING
1463 "ICMPv6 Redirect: packet too short\n");
1467 icmph = icmp6_hdr(skb);
1468 target = (const struct in6_addr *) (icmph + 1);
1471 if (ipv6_addr_is_multicast(dest)) {
1472 ND_PRINTK2(KERN_WARNING
1473 "ICMPv6 Redirect: destination address is multicast.\n");
1477 if (ipv6_addr_equal(dest, target)) {
1479 } else if (ipv6_addr_type(target) !=
1480 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1481 ND_PRINTK2(KERN_WARNING
1482 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1486 in6_dev = __in6_dev_get(skb->dev);
1489 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1493 * The IP source address of the Redirect MUST be the same as the current
1494 * first-hop router for the specified ICMP Destination Address.
1497 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1498 ND_PRINTK2(KERN_WARNING
1499 "ICMPv6 Redirect: invalid ND options\n");
1502 if (ndopts.nd_opts_tgt_lladdr) {
1503 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1506 ND_PRINTK2(KERN_WARNING
1507 "ICMPv6 Redirect: invalid link-layer address length\n");
1512 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1514 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1515 &ipv6_hdr(skb)->saddr, neigh, lladdr,
1517 neigh_release(neigh);
1521 void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
1522 const struct in6_addr *target)
1524 struct net_device *dev = skb->dev;
1525 struct net *net = dev_net(dev);
1526 struct sock *sk = net->ipv6.ndisc_sk;
1527 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1528 struct sk_buff *buff;
1529 struct icmp6hdr *icmph;
1530 struct in6_addr saddr_buf;
1531 struct in6_addr *addrp;
1532 struct rt6_info *rt;
1533 struct dst_entry *dst;
1534 struct inet6_dev *idev;
1539 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1541 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1542 ND_PRINTK2(KERN_WARNING
1543 "ICMPv6 Redirect: no link-local address on %s\n",
1548 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1549 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1550 ND_PRINTK2(KERN_WARNING
1551 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1555 icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT,
1556 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
1558 dst = ip6_route_output(net, NULL, &fl6);
1562 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
1566 rt = (struct rt6_info *) dst;
1568 if (rt->rt6i_flags & RTF_GATEWAY) {
1569 ND_PRINTK2(KERN_WARNING
1570 "ICMPv6 Redirect: destination is not a neighbour.\n");
1574 rt6_bind_peer(rt, 1);
1575 if (!inet_peer_xrlim_allow(rt->rt6i_peer, 1*HZ))
1578 if (dev->addr_len) {
1579 read_lock_bh(&neigh->lock);
1580 if (neigh->nud_state & NUD_VALID) {
1581 memcpy(ha_buf, neigh->ha, dev->addr_len);
1582 read_unlock_bh(&neigh->lock);
1584 len += ndisc_opt_addr_space(dev);
1586 read_unlock_bh(&neigh->lock);
1589 rd_len = min_t(unsigned int,
1590 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1594 buff = sock_alloc_send_skb(sk,
1595 (MAX_HEADER + sizeof(struct ipv6hdr) +
1596 len + LL_ALLOCATED_SPACE(dev)),
1600 "ICMPv6 Redirect: %s() failed to allocate an skb, err=%d.\n",
1605 skb_reserve(buff, LL_RESERVED_SPACE(dev));
1606 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
1607 IPPROTO_ICMPV6, len);
1609 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
1611 icmph = icmp6_hdr(buff);
1613 memset(icmph, 0, sizeof(struct icmp6hdr));
1614 icmph->icmp6_type = NDISC_REDIRECT;
1617 * copy target and destination addresses
1620 addrp = (struct in6_addr *)(icmph + 1);
1621 ipv6_addr_copy(addrp, target);
1623 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
1625 opt = (u8*) (addrp + 1);
1628 * include target_address option
1632 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1633 dev->addr_len, dev->type);
1636 * build redirect option and copy skb over to the new packet.
1640 *(opt++) = ND_OPT_REDIRECT_HDR;
1641 *(opt++) = (rd_len >> 3);
1644 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
1646 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
1647 len, IPPROTO_ICMPV6,
1648 csum_partial(icmph, len, 0));
1650 skb_dst_set(buff, dst);
1652 idev = __in6_dev_get(dst->dev);
1653 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
1654 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1657 ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT);
1658 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
1668 static void pndisc_redo(struct sk_buff *skb)
1674 int ndisc_rcv(struct sk_buff *skb)
1678 if (!pskb_may_pull(skb, skb->len))
1681 msg = (struct nd_msg *)skb_transport_header(skb);
1683 __skb_push(skb, skb->data - skb_transport_header(skb));
1685 if (ipv6_hdr(skb)->hop_limit != 255) {
1686 ND_PRINTK2(KERN_WARNING
1687 "ICMPv6 NDISC: invalid hop-limit: %d\n",
1688 ipv6_hdr(skb)->hop_limit);
1692 if (msg->icmph.icmp6_code != 0) {
1693 ND_PRINTK2(KERN_WARNING
1694 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1695 msg->icmph.icmp6_code);
1699 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1701 switch (msg->icmph.icmp6_type) {
1702 case NDISC_NEIGHBOUR_SOLICITATION:
1706 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1710 case NDISC_ROUTER_SOLICITATION:
1714 case NDISC_ROUTER_ADVERTISEMENT:
1715 ndisc_router_discovery(skb);
1718 case NDISC_REDIRECT:
1719 ndisc_redirect_rcv(skb);
1726 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1728 struct net_device *dev = ptr;
1729 struct net *net = dev_net(dev);
1732 case NETDEV_CHANGEADDR:
1733 neigh_changeaddr(&nd_tbl, dev);
1734 fib6_run_gc(~0UL, net);
1737 neigh_ifdown(&nd_tbl, dev);
1738 fib6_run_gc(~0UL, net);
1740 case NETDEV_NOTIFY_PEERS:
1741 ndisc_send_unsol_na(dev);
1750 static struct notifier_block ndisc_netdev_notifier = {
1751 .notifier_call = ndisc_netdev_event,
1754 #ifdef CONFIG_SYSCTL
1755 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1756 const char *func, const char *dev_name)
1758 static char warncomm[TASK_COMM_LEN];
1760 if (strcmp(warncomm, current->comm) && warned < 5) {
1761 strcpy(warncomm, current->comm);
1763 "process `%s' is using deprecated sysctl (%s) "
1764 "net.ipv6.neigh.%s.%s; "
1765 "Use net.ipv6.neigh.%s.%s_ms "
1768 dev_name, ctl->procname,
1769 dev_name, ctl->procname);
1774 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos)
1776 struct net_device *dev = ctl->extra1;
1777 struct inet6_dev *idev;
1780 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1781 (strcmp(ctl->procname, "base_reachable_time") == 0))
1782 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1784 if (strcmp(ctl->procname, "retrans_time") == 0)
1785 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1787 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1788 ret = proc_dointvec_jiffies(ctl, write,
1789 buffer, lenp, ppos);
1791 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1792 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1793 ret = proc_dointvec_ms_jiffies(ctl, write,
1794 buffer, lenp, ppos);
1798 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1799 if (ctl->data == &idev->nd_parms->base_reachable_time)
1800 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1801 idev->tstamp = jiffies;
1802 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1811 static int __net_init ndisc_net_init(struct net *net)
1813 struct ipv6_pinfo *np;
1817 err = inet_ctl_sock_create(&sk, PF_INET6,
1818 SOCK_RAW, IPPROTO_ICMPV6, net);
1821 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1826 net->ipv6.ndisc_sk = sk;
1829 np->hop_limit = 255;
1830 /* Do not loopback ndisc messages */
1836 static void __net_exit ndisc_net_exit(struct net *net)
1838 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1841 static struct pernet_operations ndisc_net_ops = {
1842 .init = ndisc_net_init,
1843 .exit = ndisc_net_exit,
1846 int __init ndisc_init(void)
1850 err = register_pernet_subsys(&ndisc_net_ops);
1854 * Initialize the neighbour table
1856 neigh_table_init(&nd_tbl);
1858 #ifdef CONFIG_SYSCTL
1859 err = neigh_sysctl_register(NULL, &nd_tbl.parms, "ipv6",
1860 &ndisc_ifinfo_sysctl_change);
1862 goto out_unregister_pernet;
1864 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1866 goto out_unregister_sysctl;
1870 out_unregister_sysctl:
1871 #ifdef CONFIG_SYSCTL
1872 neigh_sysctl_unregister(&nd_tbl.parms);
1873 out_unregister_pernet:
1875 unregister_pernet_subsys(&ndisc_net_ops);
1879 void ndisc_cleanup(void)
1881 unregister_netdevice_notifier(&ndisc_netdev_notifier);
1882 #ifdef CONFIG_SYSCTL
1883 neigh_sysctl_unregister(&nd_tbl.parms);
1885 neigh_table_clear(&nd_tbl);
1886 unregister_pernet_subsys(&ndisc_net_ops);