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,
110 .hh_output = dev_queue_xmit,
111 .queue_xmit = dev_queue_xmit,
114 static const struct neigh_ops ndisc_hh_ops = {
116 .solicit = ndisc_solicit,
117 .error_report = ndisc_error_report,
118 .output = neigh_resolve_output,
119 .connected_output = neigh_resolve_output,
120 .hh_output = dev_queue_xmit,
121 .queue_xmit = dev_queue_xmit,
125 static const struct neigh_ops ndisc_direct_ops = {
127 .output = dev_queue_xmit,
128 .connected_output = dev_queue_xmit,
129 .hh_output = dev_queue_xmit,
130 .queue_xmit = dev_queue_xmit,
133 struct neigh_table nd_tbl = {
135 .entry_size = sizeof(struct neighbour) + sizeof(struct in6_addr),
136 .key_len = sizeof(struct in6_addr),
138 .constructor = ndisc_constructor,
139 .pconstructor = pndisc_constructor,
140 .pdestructor = pndisc_destructor,
141 .proxy_redo = pndisc_redo,
145 .base_reachable_time = ND_REACHABLE_TIME,
146 .retrans_time = ND_RETRANS_TIMER,
147 .gc_staletime = 60 * HZ,
148 .reachable_time = ND_REACHABLE_TIME,
149 .delay_probe_time = 5 * HZ,
153 .anycast_delay = 1 * HZ,
154 .proxy_delay = (8 * HZ) / 10,
157 .gc_interval = 30 * HZ,
164 struct ndisc_options {
165 struct nd_opt_hdr *nd_opt_array[__ND_OPT_ARRAY_MAX];
166 #ifdef CONFIG_IPV6_ROUTE_INFO
167 struct nd_opt_hdr *nd_opts_ri;
168 struct nd_opt_hdr *nd_opts_ri_end;
170 struct nd_opt_hdr *nd_useropts;
171 struct nd_opt_hdr *nd_useropts_end;
174 #define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR]
175 #define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR]
176 #define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO]
177 #define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END]
178 #define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR]
179 #define nd_opts_mtu nd_opt_array[ND_OPT_MTU]
181 #define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
184 * Return the padding between the option length and the start of the
185 * link addr. Currently only IP-over-InfiniBand needs this, although
186 * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may
187 * also need a pad of 2.
189 static int ndisc_addr_option_pad(unsigned short type)
192 case ARPHRD_INFINIBAND: return 2;
197 static inline int ndisc_opt_addr_space(struct net_device *dev)
199 return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type));
202 static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len,
203 unsigned short addr_type)
205 int space = NDISC_OPT_SPACE(data_len);
206 int pad = ndisc_addr_option_pad(addr_type);
211 memset(opt + 2, 0, pad);
215 memcpy(opt+2, data, data_len);
218 if ((space -= data_len) > 0)
219 memset(opt, 0, space);
223 static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
224 struct nd_opt_hdr *end)
227 if (!cur || !end || cur >= end)
229 type = cur->nd_opt_type;
231 cur = ((void *)cur) + (cur->nd_opt_len << 3);
232 } while(cur < end && cur->nd_opt_type != type);
233 return cur <= end && cur->nd_opt_type == type ? cur : NULL;
236 static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
238 return opt->nd_opt_type == ND_OPT_RDNSS;
241 static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur,
242 struct nd_opt_hdr *end)
244 if (!cur || !end || cur >= end)
247 cur = ((void *)cur) + (cur->nd_opt_len << 3);
248 } while(cur < end && !ndisc_is_useropt(cur));
249 return cur <= end && ndisc_is_useropt(cur) ? cur : NULL;
252 static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
253 struct ndisc_options *ndopts)
255 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
257 if (!nd_opt || opt_len < 0 || !ndopts)
259 memset(ndopts, 0, sizeof(*ndopts));
262 if (opt_len < sizeof(struct nd_opt_hdr))
264 l = nd_opt->nd_opt_len << 3;
265 if (opt_len < l || l == 0)
267 switch (nd_opt->nd_opt_type) {
268 case ND_OPT_SOURCE_LL_ADDR:
269 case ND_OPT_TARGET_LL_ADDR:
271 case ND_OPT_REDIRECT_HDR:
272 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
273 ND_PRINTK2(KERN_WARNING
274 "%s(): duplicated ND6 option found: type=%d\n",
276 nd_opt->nd_opt_type);
278 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
281 case ND_OPT_PREFIX_INFO:
282 ndopts->nd_opts_pi_end = nd_opt;
283 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
284 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
286 #ifdef CONFIG_IPV6_ROUTE_INFO
287 case ND_OPT_ROUTE_INFO:
288 ndopts->nd_opts_ri_end = nd_opt;
289 if (!ndopts->nd_opts_ri)
290 ndopts->nd_opts_ri = nd_opt;
294 if (ndisc_is_useropt(nd_opt)) {
295 ndopts->nd_useropts_end = nd_opt;
296 if (!ndopts->nd_useropts)
297 ndopts->nd_useropts = nd_opt;
300 * Unknown options must be silently ignored,
301 * to accommodate future extension to the
304 ND_PRINTK2(KERN_NOTICE
305 "%s(): ignored unsupported option; type=%d, len=%d\n",
307 nd_opt->nd_opt_type, nd_opt->nd_opt_len);
311 nd_opt = ((void *)nd_opt) + l;
316 static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p,
317 struct net_device *dev)
319 u8 *lladdr = (u8 *)(p + 1);
320 int lladdrlen = p->nd_opt_len << 3;
321 int prepad = ndisc_addr_option_pad(dev->type);
322 if (lladdrlen != NDISC_OPT_SPACE(dev->addr_len + prepad))
324 return lladdr + prepad;
327 int ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
331 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
333 ipv6_eth_mc_map(addr, buf);
335 case ARPHRD_IEEE802_TR:
336 ipv6_tr_mc_map(addr,buf);
339 ipv6_arcnet_mc_map(addr, buf);
341 case ARPHRD_INFINIBAND:
342 ipv6_ib_mc_map(addr, dev->broadcast, buf);
345 return ipv6_ipgre_mc_map(addr, dev->broadcast, buf);
348 memcpy(buf, dev->broadcast, dev->addr_len);
355 EXPORT_SYMBOL(ndisc_mc_map);
357 static u32 ndisc_hash(const void *pkey,
358 const struct net_device *dev,
361 const u32 *p32 = pkey;
365 for (i = 0; i < (sizeof(struct in6_addr) / sizeof(u32)); i++)
368 return jhash_2words(addr_hash, dev->ifindex, hash_rnd);
371 static int ndisc_constructor(struct neighbour *neigh)
373 struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;
374 struct net_device *dev = neigh->dev;
375 struct inet6_dev *in6_dev;
376 struct neigh_parms *parms;
377 int is_multicast = ipv6_addr_is_multicast(addr);
380 in6_dev = in6_dev_get(dev);
381 if (in6_dev == NULL) {
386 parms = in6_dev->nd_parms;
387 __neigh_parms_put(neigh->parms);
388 neigh->parms = neigh_parms_clone(parms);
391 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
392 if (!dev->header_ops) {
393 neigh->nud_state = NUD_NOARP;
394 neigh->ops = &ndisc_direct_ops;
395 neigh->output = neigh->ops->queue_xmit;
398 neigh->nud_state = NUD_NOARP;
399 ndisc_mc_map(addr, neigh->ha, dev, 1);
400 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
401 neigh->nud_state = NUD_NOARP;
402 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
403 if (dev->flags&IFF_LOOPBACK)
404 neigh->type = RTN_LOCAL;
405 } else if (dev->flags&IFF_POINTOPOINT) {
406 neigh->nud_state = NUD_NOARP;
407 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
409 if (dev->header_ops->cache)
410 neigh->ops = &ndisc_hh_ops;
412 neigh->ops = &ndisc_generic_ops;
413 if (neigh->nud_state&NUD_VALID)
414 neigh->output = neigh->ops->connected_output;
416 neigh->output = neigh->ops->output;
418 in6_dev_put(in6_dev);
422 static int pndisc_constructor(struct pneigh_entry *n)
424 struct in6_addr *addr = (struct in6_addr*)&n->key;
425 struct in6_addr maddr;
426 struct net_device *dev = n->dev;
428 if (dev == NULL || __in6_dev_get(dev) == NULL)
430 addrconf_addr_solict_mult(addr, &maddr);
431 ipv6_dev_mc_inc(dev, &maddr);
435 static void pndisc_destructor(struct pneigh_entry *n)
437 struct in6_addr *addr = (struct in6_addr*)&n->key;
438 struct in6_addr maddr;
439 struct net_device *dev = n->dev;
441 if (dev == NULL || __in6_dev_get(dev) == NULL)
443 addrconf_addr_solict_mult(addr, &maddr);
444 ipv6_dev_mc_dec(dev, &maddr);
447 struct sk_buff *ndisc_build_skb(struct net_device *dev,
448 const struct in6_addr *daddr,
449 const struct in6_addr *saddr,
450 struct icmp6hdr *icmp6h,
451 const struct in6_addr *target,
454 struct net *net = dev_net(dev);
455 struct sock *sk = net->ipv6.ndisc_sk;
457 struct icmp6hdr *hdr;
465 len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0);
467 len += ndisc_opt_addr_space(dev);
469 skb = sock_alloc_send_skb(sk,
470 (MAX_HEADER + sizeof(struct ipv6hdr) +
471 len + LL_ALLOCATED_SPACE(dev)),
475 "ICMPv6 ND: %s() failed to allocate an skb, err=%d.\n",
480 skb_reserve(skb, LL_RESERVED_SPACE(dev));
481 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
483 skb->transport_header = skb->tail;
486 hdr = (struct icmp6hdr *)skb_transport_header(skb);
487 memcpy(hdr, icmp6h, sizeof(*hdr));
489 opt = skb_transport_header(skb) + sizeof(struct icmp6hdr);
491 ipv6_addr_copy((struct in6_addr *)opt, target);
492 opt += sizeof(*target);
496 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr,
497 dev->addr_len, dev->type);
499 hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len,
507 EXPORT_SYMBOL(ndisc_build_skb);
509 void ndisc_send_skb(struct sk_buff *skb,
510 struct net_device *dev,
511 struct neighbour *neigh,
512 const struct in6_addr *daddr,
513 const struct in6_addr *saddr,
514 struct icmp6hdr *icmp6h)
517 struct dst_entry *dst;
518 struct net *net = dev_net(dev);
519 struct sock *sk = net->ipv6.ndisc_sk;
520 struct inet6_dev *idev;
524 type = icmp6h->icmp6_type;
526 icmpv6_flow_init(sk, &fl6, type, saddr, daddr, dev->ifindex);
528 dst = icmp6_dst_alloc(dev, neigh, daddr);
534 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
540 skb_dst_set(skb, dst);
542 idev = in6_dev_get(dst->dev);
543 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
545 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
548 ICMP6MSGOUT_INC_STATS(net, idev, type);
549 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
552 if (likely(idev != NULL))
556 EXPORT_SYMBOL(ndisc_send_skb);
559 * Send a Neighbour Discover packet
561 static void __ndisc_send(struct net_device *dev,
562 struct neighbour *neigh,
563 const struct in6_addr *daddr,
564 const struct in6_addr *saddr,
565 struct icmp6hdr *icmp6h, const struct in6_addr *target,
570 skb = ndisc_build_skb(dev, daddr, saddr, icmp6h, target, llinfo);
574 ndisc_send_skb(skb, dev, neigh, daddr, saddr, icmp6h);
577 static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
578 const struct in6_addr *daddr,
579 const struct in6_addr *solicited_addr,
580 int router, int solicited, int override, int inc_opt)
582 struct in6_addr tmpaddr;
583 struct inet6_ifaddr *ifp;
584 const struct in6_addr *src_addr;
585 struct icmp6hdr icmp6h = {
586 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
589 /* for anycast or proxy, solicited_addr != src_addr */
590 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
592 src_addr = solicited_addr;
593 if (ifp->flags & IFA_F_OPTIMISTIC)
595 inc_opt |= ifp->idev->cnf.force_tllao;
598 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
599 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
605 icmp6h.icmp6_router = router;
606 icmp6h.icmp6_solicited = solicited;
607 icmp6h.icmp6_override = override;
609 __ndisc_send(dev, neigh, daddr, src_addr,
610 &icmp6h, solicited_addr,
611 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
614 void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
615 const struct in6_addr *solicit,
616 const struct in6_addr *daddr, const struct in6_addr *saddr)
618 struct in6_addr addr_buf;
619 struct icmp6hdr icmp6h = {
620 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
624 if (ipv6_get_lladdr(dev, &addr_buf,
625 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
630 __ndisc_send(dev, neigh, daddr, saddr,
632 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
635 void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
636 const struct in6_addr *daddr)
638 struct icmp6hdr icmp6h = {
639 .icmp6_type = NDISC_ROUTER_SOLICITATION,
641 int send_sllao = dev->addr_len;
643 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
645 * According to section 2.2 of RFC 4429, we must not
646 * send router solicitations with a sllao from
647 * optimistic addresses, but we may send the solicitation
648 * if we don't include the sllao. So here we check
649 * if our address is optimistic, and if so, we
650 * suppress the inclusion of the sllao.
653 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
656 if (ifp->flags & IFA_F_OPTIMISTIC) {
665 __ndisc_send(dev, NULL, daddr, saddr,
667 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
671 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
674 * "The sender MUST return an ICMP
675 * destination unreachable"
677 dst_link_failure(skb);
681 /* Called with locked neigh: either read or both */
683 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
685 struct in6_addr *saddr = NULL;
686 struct in6_addr mcaddr;
687 struct net_device *dev = neigh->dev;
688 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
689 int probes = atomic_read(&neigh->probes);
691 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
692 saddr = &ipv6_hdr(skb)->saddr;
694 if ((probes -= neigh->parms->ucast_probes) < 0) {
695 if (!(neigh->nud_state & NUD_VALID)) {
696 ND_PRINTK1(KERN_DEBUG "%s(): trying to ucast probe in NUD_INVALID: %pI6\n",
699 ndisc_send_ns(dev, neigh, target, target, saddr);
700 } else if ((probes -= neigh->parms->app_probes) < 0) {
705 addrconf_addr_solict_mult(target, &mcaddr);
706 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
710 static int pndisc_is_router(const void *pkey,
711 struct net_device *dev)
713 struct pneigh_entry *n;
716 read_lock_bh(&nd_tbl.lock);
717 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
719 ret = !!(n->flags & NTF_ROUTER);
720 read_unlock_bh(&nd_tbl.lock);
725 static void ndisc_recv_ns(struct sk_buff *skb)
727 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
728 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
729 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
731 u32 ndoptlen = skb->tail - (skb->transport_header +
732 offsetof(struct nd_msg, opt));
733 struct ndisc_options ndopts;
734 struct net_device *dev = skb->dev;
735 struct inet6_ifaddr *ifp;
736 struct inet6_dev *idev = NULL;
737 struct neighbour *neigh;
738 int dad = ipv6_addr_any(saddr);
742 if (ipv6_addr_is_multicast(&msg->target)) {
743 ND_PRINTK2(KERN_WARNING
744 "ICMPv6 NS: multicast target address");
750 * DAD has to be destined for solicited node multicast address.
753 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
754 daddr->s6_addr32[1] == htonl(0x00000000) &&
755 daddr->s6_addr32[2] == htonl(0x00000001) &&
756 daddr->s6_addr [12] == 0xff )) {
757 ND_PRINTK2(KERN_WARNING
758 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
762 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
763 ND_PRINTK2(KERN_WARNING
764 "ICMPv6 NS: invalid ND options\n");
768 if (ndopts.nd_opts_src_lladdr) {
769 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
771 ND_PRINTK2(KERN_WARNING
772 "ICMPv6 NS: invalid link-layer address length\n");
777 * If the IP source address is the unspecified address,
778 * there MUST NOT be source link-layer address option
782 ND_PRINTK2(KERN_WARNING
783 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
788 inc = ipv6_addr_is_multicast(daddr);
790 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
793 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
795 if (dev->type == ARPHRD_IEEE802_TR) {
796 const unsigned char *sadr;
797 sadr = skb_mac_header(skb);
798 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
799 sadr[9] == dev->dev_addr[1] &&
800 sadr[10] == dev->dev_addr[2] &&
801 sadr[11] == dev->dev_addr[3] &&
802 sadr[12] == dev->dev_addr[4] &&
803 sadr[13] == dev->dev_addr[5]) {
804 /* looped-back to us */
810 * We are colliding with another node
812 * so fail our DAD process
814 addrconf_dad_failure(ifp);
818 * This is not a dad solicitation.
819 * If we are an optimistic node,
821 * Otherwise, we should ignore it.
823 if (!(ifp->flags & IFA_F_OPTIMISTIC))
830 struct net *net = dev_net(dev);
832 idev = in6_dev_get(dev);
834 /* XXX: count this drop? */
838 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
839 (idev->cnf.forwarding &&
840 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
841 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
842 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
843 skb->pkt_type != PACKET_HOST &&
845 idev->nd_parms->proxy_delay != 0) {
847 * for anycast or proxy,
848 * sender should delay its response
849 * by a random time between 0 and
850 * MAX_ANYCAST_DELAY_TIME seconds.
851 * (RFC2461) -- yoshfuji
853 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
855 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
863 is_router = !!idev->cnf.forwarding;
866 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
867 is_router, 0, (ifp != NULL), 1);
872 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
874 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
877 * update / create cache entry
878 * for the source address
880 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
881 !inc || lladdr || !dev->addr_len);
883 neigh_update(neigh, lladdr, NUD_STALE,
884 NEIGH_UPDATE_F_WEAK_OVERRIDE|
885 NEIGH_UPDATE_F_OVERRIDE);
886 if (neigh || !dev->header_ops) {
887 ndisc_send_na(dev, neigh, saddr, &msg->target,
889 1, (ifp != NULL && inc), inc);
891 neigh_release(neigh);
901 static void ndisc_recv_na(struct sk_buff *skb)
903 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
904 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
905 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
907 u32 ndoptlen = skb->tail - (skb->transport_header +
908 offsetof(struct nd_msg, opt));
909 struct ndisc_options ndopts;
910 struct net_device *dev = skb->dev;
911 struct inet6_ifaddr *ifp;
912 struct neighbour *neigh;
914 if (skb->len < sizeof(struct nd_msg)) {
915 ND_PRINTK2(KERN_WARNING
916 "ICMPv6 NA: packet too short\n");
920 if (ipv6_addr_is_multicast(&msg->target)) {
921 ND_PRINTK2(KERN_WARNING
922 "ICMPv6 NA: target address is multicast.\n");
926 if (ipv6_addr_is_multicast(daddr) &&
927 msg->icmph.icmp6_solicited) {
928 ND_PRINTK2(KERN_WARNING
929 "ICMPv6 NA: solicited NA is multicasted.\n");
933 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
934 ND_PRINTK2(KERN_WARNING
935 "ICMPv6 NS: invalid ND option\n");
938 if (ndopts.nd_opts_tgt_lladdr) {
939 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
941 ND_PRINTK2(KERN_WARNING
942 "ICMPv6 NA: invalid link-layer address length\n");
946 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
948 if (skb->pkt_type != PACKET_LOOPBACK
949 && (ifp->flags & IFA_F_TENTATIVE)) {
950 addrconf_dad_failure(ifp);
953 /* What should we make now? The advertisement
954 is invalid, but ndisc specs say nothing
955 about it. It could be misconfiguration, or
956 an smart proxy agent tries to help us :-)
958 We should not print the error if NA has been
959 received from loopback - it is just our own
960 unsolicited advertisement.
962 if (skb->pkt_type != PACKET_LOOPBACK)
963 ND_PRINTK1(KERN_WARNING
964 "ICMPv6 NA: someone advertises our address %pI6 on %s!\n",
965 &ifp->addr, ifp->idev->dev->name);
969 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
972 u8 old_flags = neigh->flags;
973 struct net *net = dev_net(dev);
975 if (neigh->nud_state & NUD_FAILED)
979 * Don't update the neighbor cache entry on a proxy NA from
980 * ourselves because either the proxied node is off link or it
981 * has already sent a NA to us.
983 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
984 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
985 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
986 /* XXX: idev->cnf.prixy_ndp */
990 neigh_update(neigh, lladdr,
991 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
992 NEIGH_UPDATE_F_WEAK_OVERRIDE|
993 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
994 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
995 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
997 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
999 * Change: router to host
1001 struct rt6_info *rt;
1002 rt = rt6_get_dflt_router(saddr, dev);
1008 neigh_release(neigh);
1012 static void ndisc_recv_rs(struct sk_buff *skb)
1014 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
1015 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
1016 struct neighbour *neigh;
1017 struct inet6_dev *idev;
1018 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
1019 struct ndisc_options ndopts;
1022 if (skb->len < sizeof(*rs_msg))
1025 idev = in6_dev_get(skb->dev);
1027 if (net_ratelimit())
1028 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1032 /* Don't accept RS if we're not in router mode */
1033 if (!idev->cnf.forwarding)
1037 * Don't update NCE if src = ::;
1038 * this implies that the source node has no ip address assigned yet.
1040 if (ipv6_addr_any(saddr))
1043 /* Parse ND options */
1044 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
1045 if (net_ratelimit())
1046 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1050 if (ndopts.nd_opts_src_lladdr) {
1051 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1057 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1059 neigh_update(neigh, lladdr, NUD_STALE,
1060 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1061 NEIGH_UPDATE_F_OVERRIDE|
1062 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1063 neigh_release(neigh);
1069 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1071 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1072 struct sk_buff *skb;
1073 struct nlmsghdr *nlh;
1074 struct nduseroptmsg *ndmsg;
1075 struct net *net = dev_net(ra->dev);
1077 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1078 + (opt->nd_opt_len << 3));
1079 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1081 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1087 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1089 goto nla_put_failure;
1092 ndmsg = nlmsg_data(nlh);
1093 ndmsg->nduseropt_family = AF_INET6;
1094 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
1095 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1096 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1097 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1099 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1101 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1102 &ipv6_hdr(ra)->saddr);
1103 nlmsg_end(skb, nlh);
1105 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
1112 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1115 static inline int accept_ra(struct inet6_dev *in6_dev)
1118 * If forwarding is enabled, RA are not accepted unless the special
1119 * hybrid mode (accept_ra=2) is enabled.
1121 if (in6_dev->cnf.forwarding && in6_dev->cnf.accept_ra < 2)
1124 return in6_dev->cnf.accept_ra;
1127 static void ndisc_router_discovery(struct sk_buff *skb)
1129 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1130 struct neighbour *neigh = NULL;
1131 struct inet6_dev *in6_dev;
1132 struct rt6_info *rt = NULL;
1134 struct ndisc_options ndopts;
1136 unsigned int pref = 0;
1138 __u8 * opt = (__u8 *)(ra_msg + 1);
1140 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
1142 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1143 ND_PRINTK2(KERN_WARNING
1144 "ICMPv6 RA: source address is not link-local.\n");
1148 ND_PRINTK2(KERN_WARNING
1149 "ICMPv6 RA: packet too short\n");
1153 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1154 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1155 ND_PRINTK2(KERN_WARNING
1156 "ICMPv6 RA: from host or unauthorized router\n");
1162 * set the RA_RECV flag in the interface
1165 in6_dev = in6_dev_get(skb->dev);
1166 if (in6_dev == NULL) {
1168 "ICMPv6 RA: can't find inet6 device for %s.\n",
1173 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1174 in6_dev_put(in6_dev);
1175 ND_PRINTK2(KERN_WARNING
1176 "ICMP6 RA: invalid ND options\n");
1180 if (!accept_ra(in6_dev))
1181 goto skip_linkparms;
1183 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1184 /* skip link-specific parameters from interior routers */
1185 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1186 goto skip_linkparms;
1189 if (in6_dev->if_flags & IF_RS_SENT) {
1191 * flag that an RA was received after an RS was sent
1192 * out on this interface.
1194 in6_dev->if_flags |= IF_RA_RCVD;
1198 * Remember the managed/otherconf flags from most recently
1199 * received RA message (RFC 2462) -- yoshfuji
1201 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1203 (ra_msg->icmph.icmp6_addrconf_managed ?
1204 IF_RA_MANAGED : 0) |
1205 (ra_msg->icmph.icmp6_addrconf_other ?
1206 IF_RA_OTHERCONF : 0);
1208 if (!in6_dev->cnf.accept_ra_defrtr)
1211 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1213 #ifdef CONFIG_IPV6_ROUTER_PREF
1214 pref = ra_msg->icmph.icmp6_router_pref;
1215 /* 10b is handled as if it were 00b (medium) */
1216 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1217 !in6_dev->cnf.accept_ra_rtr_pref)
1218 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1221 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1224 neigh = rt->rt6i_nexthop;
1226 if (rt && lifetime == 0) {
1232 if (rt == NULL && lifetime) {
1233 ND_PRINTK3(KERN_DEBUG
1234 "ICMPv6 RA: adding default router.\n");
1236 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1239 "ICMPv6 RA: %s() failed to add default route.\n",
1241 in6_dev_put(in6_dev);
1245 neigh = rt->rt6i_nexthop;
1246 if (neigh == NULL) {
1248 "ICMPv6 RA: %s() got default router without neighbour.\n",
1250 dst_release(&rt->dst);
1251 in6_dev_put(in6_dev);
1254 neigh->flags |= NTF_ROUTER;
1256 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1260 rt->rt6i_expires = jiffies + (HZ * lifetime);
1262 if (ra_msg->icmph.icmp6_hop_limit) {
1263 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1265 dst_metric_set(&rt->dst, RTAX_HOPLIMIT,
1266 ra_msg->icmph.icmp6_hop_limit);
1272 * Update Reachable Time and Retrans Timer
1275 if (in6_dev->nd_parms) {
1276 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1278 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1279 rtime = (rtime*HZ)/1000;
1282 in6_dev->nd_parms->retrans_time = rtime;
1283 in6_dev->tstamp = jiffies;
1284 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1287 rtime = ntohl(ra_msg->reachable_time);
1288 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1289 rtime = (rtime*HZ)/1000;
1294 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1295 in6_dev->nd_parms->base_reachable_time = rtime;
1296 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1297 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1298 in6_dev->tstamp = jiffies;
1299 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1311 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1315 if (ndopts.nd_opts_src_lladdr) {
1316 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1319 ND_PRINTK2(KERN_WARNING
1320 "ICMPv6 RA: invalid link-layer address length\n");
1324 neigh_update(neigh, lladdr, NUD_STALE,
1325 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1326 NEIGH_UPDATE_F_OVERRIDE|
1327 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1328 NEIGH_UPDATE_F_ISROUTER);
1331 if (!accept_ra(in6_dev))
1334 #ifdef CONFIG_IPV6_ROUTE_INFO
1335 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1336 struct nd_opt_hdr *p;
1337 for (p = ndopts.nd_opts_ri;
1339 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1340 struct route_info *ri = (struct route_info *)p;
1341 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1342 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1343 ri->prefix_len == 0)
1346 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1348 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1349 &ipv6_hdr(skb)->saddr);
1354 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1355 /* skip link-specific ndopts from interior routers */
1356 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1360 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1361 struct nd_opt_hdr *p;
1362 for (p = ndopts.nd_opts_pi;
1364 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1365 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1369 if (ndopts.nd_opts_mtu) {
1373 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1376 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1377 ND_PRINTK2(KERN_WARNING
1378 "ICMPv6 RA: invalid mtu: %d\n",
1380 } else if (in6_dev->cnf.mtu6 != mtu) {
1381 in6_dev->cnf.mtu6 = mtu;
1384 dst_metric_set(&rt->dst, RTAX_MTU, mtu);
1386 rt6_mtu_change(skb->dev, mtu);
1390 if (ndopts.nd_useropts) {
1391 struct nd_opt_hdr *p;
1392 for (p = ndopts.nd_useropts;
1394 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1395 ndisc_ra_useropt(skb, p);
1399 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1400 ND_PRINTK2(KERN_WARNING
1401 "ICMPv6 RA: invalid RA options");
1405 dst_release(&rt->dst);
1407 neigh_release(neigh);
1408 in6_dev_put(in6_dev);
1411 static void ndisc_redirect_rcv(struct sk_buff *skb)
1413 struct inet6_dev *in6_dev;
1414 struct icmp6hdr *icmph;
1415 struct in6_addr *dest;
1416 struct in6_addr *target; /* new first hop to destination */
1417 struct neighbour *neigh;
1419 struct ndisc_options ndopts;
1423 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1424 switch (skb->ndisc_nodetype) {
1425 case NDISC_NODETYPE_HOST:
1426 case NDISC_NODETYPE_NODEFAULT:
1427 ND_PRINTK2(KERN_WARNING
1428 "ICMPv6 Redirect: from host or unauthorized router\n");
1433 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1434 ND_PRINTK2(KERN_WARNING
1435 "ICMPv6 Redirect: source address is not link-local.\n");
1439 optlen = skb->tail - skb->transport_header;
1440 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1443 ND_PRINTK2(KERN_WARNING
1444 "ICMPv6 Redirect: packet too short\n");
1448 icmph = icmp6_hdr(skb);
1449 target = (struct in6_addr *) (icmph + 1);
1452 if (ipv6_addr_is_multicast(dest)) {
1453 ND_PRINTK2(KERN_WARNING
1454 "ICMPv6 Redirect: destination address is multicast.\n");
1458 if (ipv6_addr_equal(dest, target)) {
1460 } else if (ipv6_addr_type(target) !=
1461 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1462 ND_PRINTK2(KERN_WARNING
1463 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1467 in6_dev = in6_dev_get(skb->dev);
1470 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1471 in6_dev_put(in6_dev);
1476 * The IP source address of the Redirect MUST be the same as the current
1477 * first-hop router for the specified ICMP Destination Address.
1480 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1481 ND_PRINTK2(KERN_WARNING
1482 "ICMPv6 Redirect: invalid ND options\n");
1483 in6_dev_put(in6_dev);
1486 if (ndopts.nd_opts_tgt_lladdr) {
1487 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1490 ND_PRINTK2(KERN_WARNING
1491 "ICMPv6 Redirect: invalid link-layer address length\n");
1492 in6_dev_put(in6_dev);
1497 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1499 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1500 &ipv6_hdr(skb)->saddr, neigh, lladdr,
1502 neigh_release(neigh);
1504 in6_dev_put(in6_dev);
1507 void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
1508 const struct in6_addr *target)
1510 struct net_device *dev = skb->dev;
1511 struct net *net = dev_net(dev);
1512 struct sock *sk = net->ipv6.ndisc_sk;
1513 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1514 struct sk_buff *buff;
1515 struct icmp6hdr *icmph;
1516 struct in6_addr saddr_buf;
1517 struct in6_addr *addrp;
1518 struct rt6_info *rt;
1519 struct dst_entry *dst;
1520 struct inet6_dev *idev;
1525 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1527 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1528 ND_PRINTK2(KERN_WARNING
1529 "ICMPv6 Redirect: no link-local address on %s\n",
1534 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1535 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1536 ND_PRINTK2(KERN_WARNING
1537 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1541 icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT,
1542 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
1544 dst = ip6_route_output(net, NULL, &fl6);
1548 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
1552 rt = (struct rt6_info *) dst;
1554 if (rt->rt6i_flags & RTF_GATEWAY) {
1555 ND_PRINTK2(KERN_WARNING
1556 "ICMPv6 Redirect: destination is not a neighbour.\n");
1560 rt6_bind_peer(rt, 1);
1561 if (inet_peer_xrlim_allow(rt->rt6i_peer, 1*HZ))
1564 if (dev->addr_len) {
1565 read_lock_bh(&neigh->lock);
1566 if (neigh->nud_state & NUD_VALID) {
1567 memcpy(ha_buf, neigh->ha, dev->addr_len);
1568 read_unlock_bh(&neigh->lock);
1570 len += ndisc_opt_addr_space(dev);
1572 read_unlock_bh(&neigh->lock);
1575 rd_len = min_t(unsigned int,
1576 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1580 buff = sock_alloc_send_skb(sk,
1581 (MAX_HEADER + sizeof(struct ipv6hdr) +
1582 len + LL_ALLOCATED_SPACE(dev)),
1586 "ICMPv6 Redirect: %s() failed to allocate an skb, err=%d.\n",
1591 skb_reserve(buff, LL_RESERVED_SPACE(dev));
1592 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
1593 IPPROTO_ICMPV6, len);
1595 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
1597 icmph = icmp6_hdr(buff);
1599 memset(icmph, 0, sizeof(struct icmp6hdr));
1600 icmph->icmp6_type = NDISC_REDIRECT;
1603 * copy target and destination addresses
1606 addrp = (struct in6_addr *)(icmph + 1);
1607 ipv6_addr_copy(addrp, target);
1609 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
1611 opt = (u8*) (addrp + 1);
1614 * include target_address option
1618 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1619 dev->addr_len, dev->type);
1622 * build redirect option and copy skb over to the new packet.
1626 *(opt++) = ND_OPT_REDIRECT_HDR;
1627 *(opt++) = (rd_len >> 3);
1630 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
1632 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
1633 len, IPPROTO_ICMPV6,
1634 csum_partial(icmph, len, 0));
1636 skb_dst_set(buff, dst);
1637 idev = in6_dev_get(dst->dev);
1638 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
1639 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1642 ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT);
1643 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
1646 if (likely(idev != NULL))
1654 static void pndisc_redo(struct sk_buff *skb)
1660 int ndisc_rcv(struct sk_buff *skb)
1664 if (!pskb_may_pull(skb, skb->len))
1667 msg = (struct nd_msg *)skb_transport_header(skb);
1669 __skb_push(skb, skb->data - skb_transport_header(skb));
1671 if (ipv6_hdr(skb)->hop_limit != 255) {
1672 ND_PRINTK2(KERN_WARNING
1673 "ICMPv6 NDISC: invalid hop-limit: %d\n",
1674 ipv6_hdr(skb)->hop_limit);
1678 if (msg->icmph.icmp6_code != 0) {
1679 ND_PRINTK2(KERN_WARNING
1680 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1681 msg->icmph.icmp6_code);
1685 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1687 switch (msg->icmph.icmp6_type) {
1688 case NDISC_NEIGHBOUR_SOLICITATION:
1692 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1696 case NDISC_ROUTER_SOLICITATION:
1700 case NDISC_ROUTER_ADVERTISEMENT:
1701 ndisc_router_discovery(skb);
1704 case NDISC_REDIRECT:
1705 ndisc_redirect_rcv(skb);
1712 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1714 struct net_device *dev = ptr;
1715 struct net *net = dev_net(dev);
1718 case NETDEV_CHANGEADDR:
1719 neigh_changeaddr(&nd_tbl, dev);
1720 fib6_run_gc(~0UL, net);
1723 neigh_ifdown(&nd_tbl, dev);
1724 fib6_run_gc(~0UL, net);
1733 static struct notifier_block ndisc_netdev_notifier = {
1734 .notifier_call = ndisc_netdev_event,
1737 #ifdef CONFIG_SYSCTL
1738 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1739 const char *func, const char *dev_name)
1741 static char warncomm[TASK_COMM_LEN];
1743 if (strcmp(warncomm, current->comm) && warned < 5) {
1744 strcpy(warncomm, current->comm);
1746 "process `%s' is using deprecated sysctl (%s) "
1747 "net.ipv6.neigh.%s.%s; "
1748 "Use net.ipv6.neigh.%s.%s_ms "
1751 dev_name, ctl->procname,
1752 dev_name, ctl->procname);
1757 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos)
1759 struct net_device *dev = ctl->extra1;
1760 struct inet6_dev *idev;
1763 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1764 (strcmp(ctl->procname, "base_reachable_time") == 0))
1765 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1767 if (strcmp(ctl->procname, "retrans_time") == 0)
1768 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1770 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1771 ret = proc_dointvec_jiffies(ctl, write,
1772 buffer, lenp, ppos);
1774 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1775 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1776 ret = proc_dointvec_ms_jiffies(ctl, write,
1777 buffer, lenp, ppos);
1781 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1782 if (ctl->data == &idev->nd_parms->base_reachable_time)
1783 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1784 idev->tstamp = jiffies;
1785 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1794 static int __net_init ndisc_net_init(struct net *net)
1796 struct ipv6_pinfo *np;
1800 err = inet_ctl_sock_create(&sk, PF_INET6,
1801 SOCK_RAW, IPPROTO_ICMPV6, net);
1804 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1809 net->ipv6.ndisc_sk = sk;
1812 np->hop_limit = 255;
1813 /* Do not loopback ndisc messages */
1819 static void __net_exit ndisc_net_exit(struct net *net)
1821 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1824 static struct pernet_operations ndisc_net_ops = {
1825 .init = ndisc_net_init,
1826 .exit = ndisc_net_exit,
1829 int __init ndisc_init(void)
1833 err = register_pernet_subsys(&ndisc_net_ops);
1837 * Initialize the neighbour table
1839 neigh_table_init(&nd_tbl);
1841 #ifdef CONFIG_SYSCTL
1842 err = neigh_sysctl_register(NULL, &nd_tbl.parms, "ipv6",
1843 &ndisc_ifinfo_sysctl_change);
1845 goto out_unregister_pernet;
1847 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1849 goto out_unregister_sysctl;
1853 out_unregister_sysctl:
1854 #ifdef CONFIG_SYSCTL
1855 neigh_sysctl_unregister(&nd_tbl.parms);
1856 out_unregister_pernet:
1858 unregister_pernet_subsys(&ndisc_net_ops);
1862 void ndisc_cleanup(void)
1864 unregister_netdevice_notifier(&ndisc_netdev_notifier);
1865 #ifdef CONFIG_SYSCTL
1866 neigh_sysctl_unregister(&nd_tbl.parms);
1868 neigh_table_clear(&nd_tbl);
1869 unregister_pernet_subsys(&ndisc_net_ops);