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>
63 #include <linux/sysctl.h>
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>
76 #include <net/protocol.h>
77 #include <net/ndisc.h>
78 #include <net/ip6_route.h>
79 #include <net/addrconf.h>
82 #include <net/netlink.h>
83 #include <linux/rtnetlink.h>
86 #include <net/ip6_checksum.h>
87 #include <net/inet_common.h>
88 #include <linux/proc_fs.h>
90 #include <linux/netfilter.h>
91 #include <linux/netfilter_ipv6.h>
93 static u32 ndisc_hash(const void *pkey, const struct net_device *dev);
94 static int ndisc_constructor(struct neighbour *neigh);
95 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
96 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
97 static int pndisc_constructor(struct pneigh_entry *n);
98 static void pndisc_destructor(struct pneigh_entry *n);
99 static void pndisc_redo(struct sk_buff *skb);
101 static struct neigh_ops ndisc_generic_ops = {
103 .solicit = ndisc_solicit,
104 .error_report = ndisc_error_report,
105 .output = neigh_resolve_output,
106 .connected_output = neigh_connected_output,
107 .hh_output = dev_queue_xmit,
108 .queue_xmit = dev_queue_xmit,
111 static struct neigh_ops ndisc_hh_ops = {
113 .solicit = ndisc_solicit,
114 .error_report = ndisc_error_report,
115 .output = neigh_resolve_output,
116 .connected_output = neigh_resolve_output,
117 .hh_output = dev_queue_xmit,
118 .queue_xmit = dev_queue_xmit,
122 static struct neigh_ops ndisc_direct_ops = {
124 .output = dev_queue_xmit,
125 .connected_output = dev_queue_xmit,
126 .hh_output = dev_queue_xmit,
127 .queue_xmit = dev_queue_xmit,
130 struct neigh_table nd_tbl = {
132 .entry_size = sizeof(struct neighbour) + sizeof(struct in6_addr),
133 .key_len = sizeof(struct in6_addr),
135 .constructor = ndisc_constructor,
136 .pconstructor = pndisc_constructor,
137 .pdestructor = pndisc_destructor,
138 .proxy_redo = pndisc_redo,
142 .base_reachable_time = 30 * HZ,
143 .retrans_time = 1 * HZ,
144 .gc_staletime = 60 * HZ,
145 .reachable_time = 30 * HZ,
146 .delay_probe_time = 5 * HZ,
150 .anycast_delay = 1 * HZ,
151 .proxy_delay = (8 * HZ) / 10,
154 .gc_interval = 30 * HZ,
161 struct ndisc_options {
162 struct nd_opt_hdr *nd_opt_array[__ND_OPT_ARRAY_MAX];
163 #ifdef CONFIG_IPV6_ROUTE_INFO
164 struct nd_opt_hdr *nd_opts_ri;
165 struct nd_opt_hdr *nd_opts_ri_end;
167 struct nd_opt_hdr *nd_useropts;
168 struct nd_opt_hdr *nd_useropts_end;
171 #define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR]
172 #define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR]
173 #define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO]
174 #define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END]
175 #define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR]
176 #define nd_opts_mtu nd_opt_array[ND_OPT_MTU]
178 #define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
181 * Return the padding between the option length and the start of the
182 * link addr. Currently only IP-over-InfiniBand needs this, although
183 * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may
184 * also need a pad of 2.
186 static int ndisc_addr_option_pad(unsigned short type)
189 case ARPHRD_INFINIBAND: return 2;
194 static inline int ndisc_opt_addr_space(struct net_device *dev)
196 return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type));
199 static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len,
200 unsigned short addr_type)
202 int space = NDISC_OPT_SPACE(data_len);
203 int pad = ndisc_addr_option_pad(addr_type);
208 memset(opt + 2, 0, pad);
212 memcpy(opt+2, data, data_len);
215 if ((space -= data_len) > 0)
216 memset(opt, 0, space);
220 static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
221 struct nd_opt_hdr *end)
224 if (!cur || !end || cur >= end)
226 type = cur->nd_opt_type;
228 cur = ((void *)cur) + (cur->nd_opt_len << 3);
229 } while(cur < end && cur->nd_opt_type != type);
230 return (cur <= end && cur->nd_opt_type == type ? cur : NULL);
233 static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
235 return (opt->nd_opt_type == ND_OPT_RDNSS);
238 static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur,
239 struct nd_opt_hdr *end)
241 if (!cur || !end || cur >= end)
244 cur = ((void *)cur) + (cur->nd_opt_len << 3);
245 } while(cur < end && !ndisc_is_useropt(cur));
246 return (cur <= end && ndisc_is_useropt(cur) ? cur : NULL);
249 static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
250 struct ndisc_options *ndopts)
252 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
254 if (!nd_opt || opt_len < 0 || !ndopts)
256 memset(ndopts, 0, sizeof(*ndopts));
259 if (opt_len < sizeof(struct nd_opt_hdr))
261 l = nd_opt->nd_opt_len << 3;
262 if (opt_len < l || l == 0)
264 switch (nd_opt->nd_opt_type) {
265 case ND_OPT_SOURCE_LL_ADDR:
266 case ND_OPT_TARGET_LL_ADDR:
268 case ND_OPT_REDIRECT_HDR:
269 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
270 ND_PRINTK2(KERN_WARNING
271 "%s(): duplicated ND6 option found: type=%d\n",
273 nd_opt->nd_opt_type);
275 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
278 case ND_OPT_PREFIX_INFO:
279 ndopts->nd_opts_pi_end = nd_opt;
280 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
281 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
283 #ifdef CONFIG_IPV6_ROUTE_INFO
284 case ND_OPT_ROUTE_INFO:
285 ndopts->nd_opts_ri_end = nd_opt;
286 if (!ndopts->nd_opts_ri)
287 ndopts->nd_opts_ri = nd_opt;
291 if (ndisc_is_useropt(nd_opt)) {
292 ndopts->nd_useropts_end = nd_opt;
293 if (!ndopts->nd_useropts)
294 ndopts->nd_useropts = nd_opt;
297 * Unknown options must be silently ignored,
298 * to accommodate future extension to the
301 ND_PRINTK2(KERN_NOTICE
302 "%s(): ignored unsupported option; type=%d, len=%d\n",
304 nd_opt->nd_opt_type, nd_opt->nd_opt_len);
308 nd_opt = ((void *)nd_opt) + l;
313 static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p,
314 struct net_device *dev)
316 u8 *lladdr = (u8 *)(p + 1);
317 int lladdrlen = p->nd_opt_len << 3;
318 int prepad = ndisc_addr_option_pad(dev->type);
319 if (lladdrlen != NDISC_OPT_SPACE(dev->addr_len + prepad))
321 return (lladdr + prepad);
324 int ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
328 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
330 ipv6_eth_mc_map(addr, buf);
332 case ARPHRD_IEEE802_TR:
333 ipv6_tr_mc_map(addr,buf);
336 ipv6_arcnet_mc_map(addr, buf);
338 case ARPHRD_INFINIBAND:
339 ipv6_ib_mc_map(addr, dev->broadcast, buf);
343 memcpy(buf, dev->broadcast, dev->addr_len);
350 EXPORT_SYMBOL(ndisc_mc_map);
352 static u32 ndisc_hash(const void *pkey, const struct net_device *dev)
354 const u32 *p32 = pkey;
358 for (i = 0; i < (sizeof(struct in6_addr) / sizeof(u32)); i++)
361 return jhash_2words(addr_hash, dev->ifindex, nd_tbl.hash_rnd);
364 static int ndisc_constructor(struct neighbour *neigh)
366 struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;
367 struct net_device *dev = neigh->dev;
368 struct inet6_dev *in6_dev;
369 struct neigh_parms *parms;
370 int is_multicast = ipv6_addr_is_multicast(addr);
373 in6_dev = in6_dev_get(dev);
374 if (in6_dev == NULL) {
379 parms = in6_dev->nd_parms;
380 __neigh_parms_put(neigh->parms);
381 neigh->parms = neigh_parms_clone(parms);
384 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
385 if (!dev->header_ops) {
386 neigh->nud_state = NUD_NOARP;
387 neigh->ops = &ndisc_direct_ops;
388 neigh->output = neigh->ops->queue_xmit;
391 neigh->nud_state = NUD_NOARP;
392 ndisc_mc_map(addr, neigh->ha, dev, 1);
393 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
394 neigh->nud_state = NUD_NOARP;
395 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
396 if (dev->flags&IFF_LOOPBACK)
397 neigh->type = RTN_LOCAL;
398 } else if (dev->flags&IFF_POINTOPOINT) {
399 neigh->nud_state = NUD_NOARP;
400 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
402 if (dev->header_ops->cache)
403 neigh->ops = &ndisc_hh_ops;
405 neigh->ops = &ndisc_generic_ops;
406 if (neigh->nud_state&NUD_VALID)
407 neigh->output = neigh->ops->connected_output;
409 neigh->output = neigh->ops->output;
411 in6_dev_put(in6_dev);
415 static int pndisc_constructor(struct pneigh_entry *n)
417 struct in6_addr *addr = (struct in6_addr*)&n->key;
418 struct in6_addr maddr;
419 struct net_device *dev = n->dev;
421 if (dev == NULL || __in6_dev_get(dev) == NULL)
423 addrconf_addr_solict_mult(addr, &maddr);
424 ipv6_dev_mc_inc(dev, &maddr);
428 static void pndisc_destructor(struct pneigh_entry *n)
430 struct in6_addr *addr = (struct in6_addr*)&n->key;
431 struct in6_addr maddr;
432 struct net_device *dev = n->dev;
434 if (dev == NULL || __in6_dev_get(dev) == NULL)
436 addrconf_addr_solict_mult(addr, &maddr);
437 ipv6_dev_mc_dec(dev, &maddr);
441 * Send a Neighbour Advertisement
443 static void __ndisc_send(struct net_device *dev,
444 struct neighbour *neigh,
445 struct in6_addr *daddr, struct in6_addr *saddr,
446 struct icmp6hdr *icmp6h, struct in6_addr *target,
450 struct dst_entry *dst;
451 struct net *net = dev_net(dev);
452 struct sock *sk = net->ipv6.ndisc_sk;
454 struct icmp6hdr *hdr;
455 struct inet6_dev *idev;
460 type = icmp6h->icmp6_type;
462 icmpv6_flow_init(sk, &fl, type, saddr, daddr, dev->ifindex);
464 dst = icmp6_dst_alloc(dev, neigh, daddr);
468 err = xfrm_lookup(&dst, &fl, NULL, 0);
475 len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0);
477 len += ndisc_opt_addr_space(dev);
479 skb = sock_alloc_send_skb(sk,
480 (MAX_HEADER + sizeof(struct ipv6hdr) +
481 len + LL_RESERVED_SPACE(dev)),
485 "ICMPv6 ND: %s() failed to allocate an skb.\n",
491 skb_reserve(skb, LL_RESERVED_SPACE(dev));
492 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
494 skb->transport_header = skb->tail;
497 hdr = (struct icmp6hdr *)skb_transport_header(skb);
498 memcpy(hdr, icmp6h, sizeof(*hdr));
500 opt = skb_transport_header(skb) + sizeof(struct icmp6hdr);
502 ipv6_addr_copy((struct in6_addr *)opt, target);
503 opt += sizeof(*target);
507 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr,
508 dev->addr_len, dev->type);
510 hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len,
512 csum_partial((__u8 *) hdr,
517 idev = in6_dev_get(dst->dev);
518 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
520 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
523 ICMP6MSGOUT_INC_STATS(idev, type);
524 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
527 if (likely(idev != NULL))
531 static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
532 struct in6_addr *daddr, struct in6_addr *solicited_addr,
533 int router, int solicited, int override, int inc_opt)
535 struct in6_addr tmpaddr;
536 struct inet6_ifaddr *ifp;
537 struct in6_addr *src_addr;
538 struct icmp6hdr icmp6h = {
539 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
542 /* for anycast or proxy, solicited_addr != src_addr */
543 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
545 src_addr = solicited_addr;
546 if (ifp->flags & IFA_F_OPTIMISTIC)
550 if (ipv6_dev_get_saddr(dev, daddr,
551 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
557 icmp6h.icmp6_router = router;
558 icmp6h.icmp6_solicited = solicited;
559 icmp6h.icmp6_override = override;
561 __ndisc_send(dev, neigh, daddr, src_addr,
562 &icmp6h, solicited_addr,
563 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
566 void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
567 struct in6_addr *solicit,
568 struct in6_addr *daddr, struct in6_addr *saddr)
570 struct in6_addr addr_buf;
571 struct icmp6hdr icmp6h = {
572 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
576 if (ipv6_get_lladdr(dev, &addr_buf,
577 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
582 __ndisc_send(dev, neigh, daddr, saddr,
584 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
587 void ndisc_send_rs(struct net_device *dev, struct in6_addr *saddr,
588 struct in6_addr *daddr)
590 struct icmp6hdr icmp6h = {
591 .icmp6_type = NDISC_ROUTER_SOLICITATION,
593 int send_sllao = dev->addr_len;
595 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
597 * According to section 2.2 of RFC 4429, we must not
598 * send router solicitations with a sllao from
599 * optimistic addresses, but we may send the solicitation
600 * if we don't include the sllao. So here we check
601 * if our address is optimistic, and if so, we
602 * suppress the inclusion of the sllao.
605 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
608 if (ifp->flags & IFA_F_OPTIMISTIC) {
617 __ndisc_send(dev, NULL, daddr, saddr,
619 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
623 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
626 * "The sender MUST return an ICMP
627 * destination unreachable"
629 dst_link_failure(skb);
633 /* Called with locked neigh: either read or both */
635 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
637 struct in6_addr *saddr = NULL;
638 struct in6_addr mcaddr;
639 struct net_device *dev = neigh->dev;
640 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
641 int probes = atomic_read(&neigh->probes);
643 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
644 saddr = &ipv6_hdr(skb)->saddr;
646 if ((probes -= neigh->parms->ucast_probes) < 0) {
647 if (!(neigh->nud_state & NUD_VALID)) {
648 ND_PRINTK1(KERN_DEBUG
649 "%s(): trying to ucast probe in NUD_INVALID: "
654 ndisc_send_ns(dev, neigh, target, target, saddr);
655 } else if ((probes -= neigh->parms->app_probes) < 0) {
660 addrconf_addr_solict_mult(target, &mcaddr);
661 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
665 static int pndisc_is_router(const void *pkey,
666 struct net_device *dev)
668 struct pneigh_entry *n;
671 read_lock_bh(&nd_tbl.lock);
672 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
674 ret = !!(n->flags & NTF_ROUTER);
675 read_unlock_bh(&nd_tbl.lock);
680 static void ndisc_recv_ns(struct sk_buff *skb)
682 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
683 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
684 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
686 u32 ndoptlen = skb->tail - (skb->transport_header +
687 offsetof(struct nd_msg, opt));
688 struct ndisc_options ndopts;
689 struct net_device *dev = skb->dev;
690 struct inet6_ifaddr *ifp;
691 struct inet6_dev *idev = NULL;
692 struct neighbour *neigh;
693 int dad = ipv6_addr_any(saddr);
697 if (ipv6_addr_is_multicast(&msg->target)) {
698 ND_PRINTK2(KERN_WARNING
699 "ICMPv6 NS: multicast target address");
705 * DAD has to be destined for solicited node multicast address.
708 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
709 daddr->s6_addr32[1] == htonl(0x00000000) &&
710 daddr->s6_addr32[2] == htonl(0x00000001) &&
711 daddr->s6_addr [12] == 0xff )) {
712 ND_PRINTK2(KERN_WARNING
713 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
717 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
718 ND_PRINTK2(KERN_WARNING
719 "ICMPv6 NS: invalid ND options\n");
723 if (ndopts.nd_opts_src_lladdr) {
724 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
726 ND_PRINTK2(KERN_WARNING
727 "ICMPv6 NS: invalid link-layer address length\n");
732 * If the IP source address is the unspecified address,
733 * there MUST NOT be source link-layer address option
737 ND_PRINTK2(KERN_WARNING
738 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
743 inc = ipv6_addr_is_multicast(daddr);
745 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
748 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
750 if (dev->type == ARPHRD_IEEE802_TR) {
751 const unsigned char *sadr;
752 sadr = skb_mac_header(skb);
753 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
754 sadr[9] == dev->dev_addr[1] &&
755 sadr[10] == dev->dev_addr[2] &&
756 sadr[11] == dev->dev_addr[3] &&
757 sadr[12] == dev->dev_addr[4] &&
758 sadr[13] == dev->dev_addr[5]) {
759 /* looped-back to us */
765 * We are colliding with another node
767 * so fail our DAD process
769 addrconf_dad_failure(ifp);
773 * This is not a dad solicitation.
774 * If we are an optimistic node,
776 * Otherwise, we should ignore it.
778 if (!(ifp->flags & IFA_F_OPTIMISTIC))
785 idev = in6_dev_get(dev);
787 /* XXX: count this drop? */
791 if (ipv6_chk_acast_addr(dev_net(dev), dev, &msg->target) ||
792 (idev->cnf.forwarding &&
793 (ipv6_devconf.proxy_ndp || idev->cnf.proxy_ndp) &&
794 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
795 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
796 skb->pkt_type != PACKET_HOST &&
798 idev->nd_parms->proxy_delay != 0) {
800 * for anycast or proxy,
801 * sender should delay its response
802 * by a random time between 0 and
803 * MAX_ANYCAST_DELAY_TIME seconds.
804 * (RFC2461) -- yoshfuji
806 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
808 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
816 is_router = !!idev->cnf.forwarding;
819 struct in6_addr maddr;
821 ipv6_addr_all_nodes(&maddr);
822 ndisc_send_na(dev, NULL, &maddr, &msg->target,
823 is_router, 0, (ifp != NULL), 1);
828 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
830 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
833 * update / create cache entry
834 * for the source address
836 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
837 !inc || lladdr || !dev->addr_len);
839 neigh_update(neigh, lladdr, NUD_STALE,
840 NEIGH_UPDATE_F_WEAK_OVERRIDE|
841 NEIGH_UPDATE_F_OVERRIDE);
842 if (neigh || !dev->header_ops) {
843 ndisc_send_na(dev, neigh, saddr, &msg->target,
845 1, (ifp != NULL && inc), inc);
847 neigh_release(neigh);
859 static void ndisc_recv_na(struct sk_buff *skb)
861 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
862 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
863 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
865 u32 ndoptlen = skb->tail - (skb->transport_header +
866 offsetof(struct nd_msg, opt));
867 struct ndisc_options ndopts;
868 struct net_device *dev = skb->dev;
869 struct inet6_ifaddr *ifp;
870 struct neighbour *neigh;
872 if (skb->len < sizeof(struct nd_msg)) {
873 ND_PRINTK2(KERN_WARNING
874 "ICMPv6 NA: packet too short\n");
878 if (ipv6_addr_is_multicast(&msg->target)) {
879 ND_PRINTK2(KERN_WARNING
880 "ICMPv6 NA: target address is multicast.\n");
884 if (ipv6_addr_is_multicast(daddr) &&
885 msg->icmph.icmp6_solicited) {
886 ND_PRINTK2(KERN_WARNING
887 "ICMPv6 NA: solicited NA is multicasted.\n");
891 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
892 ND_PRINTK2(KERN_WARNING
893 "ICMPv6 NS: invalid ND option\n");
896 if (ndopts.nd_opts_tgt_lladdr) {
897 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
899 ND_PRINTK2(KERN_WARNING
900 "ICMPv6 NA: invalid link-layer address length\n");
904 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
906 if (ifp->flags & IFA_F_TENTATIVE) {
907 addrconf_dad_failure(ifp);
910 /* What should we make now? The advertisement
911 is invalid, but ndisc specs say nothing
912 about it. It could be misconfiguration, or
913 an smart proxy agent tries to help us :-)
915 ND_PRINTK1(KERN_WARNING
916 "ICMPv6 NA: someone advertises our address on %s!\n",
917 ifp->idev->dev->name);
921 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
924 u8 old_flags = neigh->flags;
926 if (neigh->nud_state & NUD_FAILED)
930 * Don't update the neighbor cache entry on a proxy NA from
931 * ourselves because either the proxied node is off link or it
932 * has already sent a NA to us.
934 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
935 ipv6_devconf.forwarding && ipv6_devconf.proxy_ndp &&
936 pneigh_lookup(&nd_tbl, dev_net(dev), &msg->target, dev, 0)) {
937 /* XXX: idev->cnf.prixy_ndp */
941 neigh_update(neigh, lladdr,
942 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
943 NEIGH_UPDATE_F_WEAK_OVERRIDE|
944 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
945 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
946 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
948 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
950 * Change: router to host
953 rt = rt6_get_dflt_router(saddr, dev);
959 neigh_release(neigh);
963 static void ndisc_recv_rs(struct sk_buff *skb)
965 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
966 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
967 struct neighbour *neigh;
968 struct inet6_dev *idev;
969 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
970 struct ndisc_options ndopts;
973 if (skb->len < sizeof(*rs_msg))
976 idev = in6_dev_get(skb->dev);
979 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
983 /* Don't accept RS if we're not in router mode */
984 if (!idev->cnf.forwarding)
988 * Don't update NCE if src = ::;
989 * this implies that the source node has no ip address assigned yet.
991 if (ipv6_addr_any(saddr))
994 /* Parse ND options */
995 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
997 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1001 if (ndopts.nd_opts_src_lladdr) {
1002 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1008 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1010 neigh_update(neigh, lladdr, NUD_STALE,
1011 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1012 NEIGH_UPDATE_F_OVERRIDE|
1013 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1014 neigh_release(neigh);
1020 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1022 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1023 struct sk_buff *skb;
1024 struct nlmsghdr *nlh;
1025 struct nduseroptmsg *ndmsg;
1026 struct net *net = dev_net(ra->dev);
1028 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1029 + (opt->nd_opt_len << 3));
1030 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1032 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1038 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1040 goto nla_put_failure;
1043 ndmsg = nlmsg_data(nlh);
1044 ndmsg->nduseropt_family = AF_INET6;
1045 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
1046 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1047 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1048 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1050 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1052 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1053 &ipv6_hdr(ra)->saddr);
1054 nlmsg_end(skb, nlh);
1056 err = rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL,
1067 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1070 static void ndisc_router_discovery(struct sk_buff *skb)
1072 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1073 struct neighbour *neigh = NULL;
1074 struct inet6_dev *in6_dev;
1075 struct rt6_info *rt = NULL;
1077 struct ndisc_options ndopts;
1079 unsigned int pref = 0;
1081 __u8 * opt = (__u8 *)(ra_msg + 1);
1083 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
1085 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1086 ND_PRINTK2(KERN_WARNING
1087 "ICMPv6 RA: source address is not link-local.\n");
1091 ND_PRINTK2(KERN_WARNING
1092 "ICMPv6 RA: packet too short\n");
1096 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1097 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1098 ND_PRINTK2(KERN_WARNING
1099 "ICMPv6 RA: from host or unauthorized router\n");
1105 * set the RA_RECV flag in the interface
1108 in6_dev = in6_dev_get(skb->dev);
1109 if (in6_dev == NULL) {
1111 "ICMPv6 RA: can't find inet6 device for %s.\n",
1115 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {
1116 in6_dev_put(in6_dev);
1120 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1121 in6_dev_put(in6_dev);
1122 ND_PRINTK2(KERN_WARNING
1123 "ICMP6 RA: invalid ND options\n");
1127 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1128 /* skip link-specific parameters from interior routers */
1129 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1130 goto skip_linkparms;
1133 if (in6_dev->if_flags & IF_RS_SENT) {
1135 * flag that an RA was received after an RS was sent
1136 * out on this interface.
1138 in6_dev->if_flags |= IF_RA_RCVD;
1142 * Remember the managed/otherconf flags from most recently
1143 * received RA message (RFC 2462) -- yoshfuji
1145 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1147 (ra_msg->icmph.icmp6_addrconf_managed ?
1148 IF_RA_MANAGED : 0) |
1149 (ra_msg->icmph.icmp6_addrconf_other ?
1150 IF_RA_OTHERCONF : 0);
1152 if (!in6_dev->cnf.accept_ra_defrtr)
1155 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1157 #ifdef CONFIG_IPV6_ROUTER_PREF
1158 pref = ra_msg->icmph.icmp6_router_pref;
1159 /* 10b is handled as if it were 00b (medium) */
1160 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1161 !in6_dev->cnf.accept_ra_rtr_pref)
1162 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1165 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1168 neigh = rt->rt6i_nexthop;
1170 if (rt && lifetime == 0) {
1176 if (rt == NULL && lifetime) {
1177 ND_PRINTK3(KERN_DEBUG
1178 "ICMPv6 RA: adding default router.\n");
1180 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1183 "ICMPv6 RA: %s() failed to add default route.\n",
1185 in6_dev_put(in6_dev);
1189 neigh = rt->rt6i_nexthop;
1190 if (neigh == NULL) {
1192 "ICMPv6 RA: %s() got default router without neighbour.\n",
1194 dst_release(&rt->u.dst);
1195 in6_dev_put(in6_dev);
1198 neigh->flags |= NTF_ROUTER;
1200 rt->rt6i_flags |= (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1204 rt->rt6i_expires = jiffies + (HZ * lifetime);
1206 if (ra_msg->icmph.icmp6_hop_limit) {
1207 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1209 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;
1215 * Update Reachable Time and Retrans Timer
1218 if (in6_dev->nd_parms) {
1219 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1221 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1222 rtime = (rtime*HZ)/1000;
1225 in6_dev->nd_parms->retrans_time = rtime;
1226 in6_dev->tstamp = jiffies;
1227 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1230 rtime = ntohl(ra_msg->reachable_time);
1231 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1232 rtime = (rtime*HZ)/1000;
1237 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1238 in6_dev->nd_parms->base_reachable_time = rtime;
1239 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1240 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1241 in6_dev->tstamp = jiffies;
1242 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1247 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1256 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1260 if (ndopts.nd_opts_src_lladdr) {
1261 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1264 ND_PRINTK2(KERN_WARNING
1265 "ICMPv6 RA: invalid link-layer address length\n");
1269 neigh_update(neigh, lladdr, NUD_STALE,
1270 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1271 NEIGH_UPDATE_F_OVERRIDE|
1272 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1273 NEIGH_UPDATE_F_ISROUTER);
1276 #ifdef CONFIG_IPV6_ROUTE_INFO
1277 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1278 struct nd_opt_hdr *p;
1279 for (p = ndopts.nd_opts_ri;
1281 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1282 struct route_info *ri = (struct route_info *)p;
1283 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1284 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1285 ri->prefix_len == 0)
1288 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1290 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1291 &ipv6_hdr(skb)->saddr);
1296 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1297 /* skip link-specific ndopts from interior routers */
1298 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1302 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1303 struct nd_opt_hdr *p;
1304 for (p = ndopts.nd_opts_pi;
1306 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1307 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1311 if (ndopts.nd_opts_mtu) {
1315 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1318 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1319 ND_PRINTK2(KERN_WARNING
1320 "ICMPv6 RA: invalid mtu: %d\n",
1322 } else if (in6_dev->cnf.mtu6 != mtu) {
1323 in6_dev->cnf.mtu6 = mtu;
1326 rt->u.dst.metrics[RTAX_MTU-1] = mtu;
1328 rt6_mtu_change(skb->dev, mtu);
1332 if (ndopts.nd_useropts) {
1333 struct nd_opt_hdr *p;
1334 for (p = ndopts.nd_useropts;
1336 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1337 ndisc_ra_useropt(skb, p);
1341 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1342 ND_PRINTK2(KERN_WARNING
1343 "ICMPv6 RA: invalid RA options");
1347 dst_release(&rt->u.dst);
1349 neigh_release(neigh);
1350 in6_dev_put(in6_dev);
1353 static void ndisc_redirect_rcv(struct sk_buff *skb)
1355 struct inet6_dev *in6_dev;
1356 struct icmp6hdr *icmph;
1357 struct in6_addr *dest;
1358 struct in6_addr *target; /* new first hop to destination */
1359 struct neighbour *neigh;
1361 struct ndisc_options ndopts;
1365 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1366 switch (skb->ndisc_nodetype) {
1367 case NDISC_NODETYPE_HOST:
1368 case NDISC_NODETYPE_NODEFAULT:
1369 ND_PRINTK2(KERN_WARNING
1370 "ICMPv6 Redirect: from host or unauthorized router\n");
1375 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1376 ND_PRINTK2(KERN_WARNING
1377 "ICMPv6 Redirect: source address is not link-local.\n");
1381 optlen = skb->tail - skb->transport_header;
1382 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1385 ND_PRINTK2(KERN_WARNING
1386 "ICMPv6 Redirect: packet too short\n");
1390 icmph = icmp6_hdr(skb);
1391 target = (struct in6_addr *) (icmph + 1);
1394 if (ipv6_addr_is_multicast(dest)) {
1395 ND_PRINTK2(KERN_WARNING
1396 "ICMPv6 Redirect: destination address is multicast.\n");
1400 if (ipv6_addr_equal(dest, target)) {
1402 } else if (ipv6_addr_type(target) !=
1403 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1404 ND_PRINTK2(KERN_WARNING
1405 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1409 in6_dev = in6_dev_get(skb->dev);
1412 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1413 in6_dev_put(in6_dev);
1418 * The IP source address of the Redirect MUST be the same as the current
1419 * first-hop router for the specified ICMP Destination Address.
1422 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1423 ND_PRINTK2(KERN_WARNING
1424 "ICMPv6 Redirect: invalid ND options\n");
1425 in6_dev_put(in6_dev);
1428 if (ndopts.nd_opts_tgt_lladdr) {
1429 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1432 ND_PRINTK2(KERN_WARNING
1433 "ICMPv6 Redirect: invalid link-layer address length\n");
1434 in6_dev_put(in6_dev);
1439 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1441 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1442 &ipv6_hdr(skb)->saddr, neigh, lladdr,
1444 neigh_release(neigh);
1446 in6_dev_put(in6_dev);
1449 void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
1450 struct in6_addr *target)
1452 struct net_device *dev = skb->dev;
1453 struct net *net = dev_net(dev);
1454 struct sock *sk = net->ipv6.ndisc_sk;
1455 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1456 struct sk_buff *buff;
1457 struct icmp6hdr *icmph;
1458 struct in6_addr saddr_buf;
1459 struct in6_addr *addrp;
1460 struct rt6_info *rt;
1461 struct dst_entry *dst;
1462 struct inet6_dev *idev;
1467 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1469 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1470 ND_PRINTK2(KERN_WARNING
1471 "ICMPv6 Redirect: no link-local address on %s\n",
1476 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1477 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1478 ND_PRINTK2(KERN_WARNING
1479 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1483 icmpv6_flow_init(sk, &fl, NDISC_REDIRECT,
1484 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
1486 dst = ip6_route_output(net, NULL, &fl);
1490 err = xfrm_lookup(&dst, &fl, NULL, 0);
1494 rt = (struct rt6_info *) dst;
1496 if (rt->rt6i_flags & RTF_GATEWAY) {
1497 ND_PRINTK2(KERN_WARNING
1498 "ICMPv6 Redirect: destination is not a neighbour.\n");
1502 if (!xrlim_allow(dst, 1*HZ)) {
1507 if (dev->addr_len) {
1508 read_lock_bh(&neigh->lock);
1509 if (neigh->nud_state & NUD_VALID) {
1510 memcpy(ha_buf, neigh->ha, dev->addr_len);
1511 read_unlock_bh(&neigh->lock);
1513 len += ndisc_opt_addr_space(dev);
1515 read_unlock_bh(&neigh->lock);
1518 rd_len = min_t(unsigned int,
1519 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1523 buff = sock_alloc_send_skb(sk,
1524 (MAX_HEADER + sizeof(struct ipv6hdr) +
1525 len + LL_RESERVED_SPACE(dev)),
1529 "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
1535 skb_reserve(buff, LL_RESERVED_SPACE(dev));
1536 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
1537 IPPROTO_ICMPV6, len);
1539 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
1541 icmph = icmp6_hdr(buff);
1543 memset(icmph, 0, sizeof(struct icmp6hdr));
1544 icmph->icmp6_type = NDISC_REDIRECT;
1547 * copy target and destination addresses
1550 addrp = (struct in6_addr *)(icmph + 1);
1551 ipv6_addr_copy(addrp, target);
1553 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
1555 opt = (u8*) (addrp + 1);
1558 * include target_address option
1562 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1563 dev->addr_len, dev->type);
1566 * build redirect option and copy skb over to the new packet.
1570 *(opt++) = ND_OPT_REDIRECT_HDR;
1571 *(opt++) = (rd_len >> 3);
1574 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
1576 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
1577 len, IPPROTO_ICMPV6,
1578 csum_partial((u8 *) icmph, len, 0));
1581 idev = in6_dev_get(dst->dev);
1582 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
1583 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1586 ICMP6MSGOUT_INC_STATS(idev, NDISC_REDIRECT);
1587 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
1590 if (likely(idev != NULL))
1594 static void pndisc_redo(struct sk_buff *skb)
1600 int ndisc_rcv(struct sk_buff *skb)
1604 if (!pskb_may_pull(skb, skb->len))
1607 msg = (struct nd_msg *)skb_transport_header(skb);
1609 __skb_push(skb, skb->data - skb_transport_header(skb));
1611 if (ipv6_hdr(skb)->hop_limit != 255) {
1612 ND_PRINTK2(KERN_WARNING
1613 "ICMPv6 NDISC: invalid hop-limit: %d\n",
1614 ipv6_hdr(skb)->hop_limit);
1618 if (msg->icmph.icmp6_code != 0) {
1619 ND_PRINTK2(KERN_WARNING
1620 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1621 msg->icmph.icmp6_code);
1625 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1627 switch (msg->icmph.icmp6_type) {
1628 case NDISC_NEIGHBOUR_SOLICITATION:
1632 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1636 case NDISC_ROUTER_SOLICITATION:
1640 case NDISC_ROUTER_ADVERTISEMENT:
1641 ndisc_router_discovery(skb);
1644 case NDISC_REDIRECT:
1645 ndisc_redirect_rcv(skb);
1652 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1654 struct net_device *dev = ptr;
1655 struct net *net = dev_net(dev);
1658 case NETDEV_CHANGEADDR:
1659 neigh_changeaddr(&nd_tbl, dev);
1660 fib6_run_gc(~0UL, net);
1663 neigh_ifdown(&nd_tbl, dev);
1664 fib6_run_gc(~0UL, net);
1673 static struct notifier_block ndisc_netdev_notifier = {
1674 .notifier_call = ndisc_netdev_event,
1677 #ifdef CONFIG_SYSCTL
1678 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1679 const char *func, const char *dev_name)
1681 static char warncomm[TASK_COMM_LEN];
1683 if (strcmp(warncomm, current->comm) && warned < 5) {
1684 strcpy(warncomm, current->comm);
1686 "process `%s' is using deprecated sysctl (%s) "
1687 "net.ipv6.neigh.%s.%s; "
1688 "Use net.ipv6.neigh.%s.%s_ms "
1691 dev_name, ctl->procname,
1692 dev_name, ctl->procname);
1697 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)
1699 struct net_device *dev = ctl->extra1;
1700 struct inet6_dev *idev;
1703 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1704 (strcmp(ctl->procname, "base_reachable_time") == 0))
1705 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1707 if (strcmp(ctl->procname, "retrans_time") == 0)
1708 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1710 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1711 ret = proc_dointvec_jiffies(ctl, write,
1712 filp, buffer, lenp, ppos);
1714 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1715 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1716 ret = proc_dointvec_ms_jiffies(ctl, write,
1717 filp, buffer, lenp, ppos);
1721 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1722 if (ctl->data == &idev->nd_parms->base_reachable_time)
1723 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1724 idev->tstamp = jiffies;
1725 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1731 static int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl, int __user *name,
1732 int nlen, void __user *oldval,
1733 size_t __user *oldlenp,
1734 void __user *newval, size_t newlen)
1736 struct net_device *dev = ctl->extra1;
1737 struct inet6_dev *idev;
1740 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1741 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1742 ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");
1744 switch (ctl->ctl_name) {
1745 case NET_NEIGH_REACHABLE_TIME:
1746 ret = sysctl_jiffies(ctl, name, nlen,
1747 oldval, oldlenp, newval, newlen);
1749 case NET_NEIGH_RETRANS_TIME_MS:
1750 case NET_NEIGH_REACHABLE_TIME_MS:
1751 ret = sysctl_ms_jiffies(ctl, name, nlen,
1752 oldval, oldlenp, newval, newlen);
1758 if (newval && newlen && ret > 0 &&
1759 dev && (idev = in6_dev_get(dev)) != NULL) {
1760 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1761 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1762 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1763 idev->tstamp = jiffies;
1764 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1773 static int ndisc_net_init(struct net *net)
1775 struct ipv6_pinfo *np;
1779 err = inet_ctl_sock_create(&sk, PF_INET6,
1780 SOCK_RAW, IPPROTO_ICMPV6, net);
1783 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1788 net->ipv6.ndisc_sk = sk;
1791 np->hop_limit = 255;
1792 /* Do not loopback ndisc messages */
1798 static void ndisc_net_exit(struct net *net)
1800 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1803 static struct pernet_operations ndisc_net_ops = {
1804 .init = ndisc_net_init,
1805 .exit = ndisc_net_exit,
1808 int __init ndisc_init(void)
1812 err = register_pernet_subsys(&ndisc_net_ops);
1816 * Initialize the neighbour table
1818 neigh_table_init(&nd_tbl);
1820 #ifdef CONFIG_SYSCTL
1821 err = neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6,
1822 NET_IPV6_NEIGH, "ipv6",
1823 &ndisc_ifinfo_sysctl_change,
1824 &ndisc_ifinfo_sysctl_strategy);
1826 goto out_unregister_pernet;
1828 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1830 goto out_unregister_sysctl;
1834 out_unregister_sysctl:
1835 #ifdef CONFIG_SYSCTL
1836 neigh_sysctl_unregister(&nd_tbl.parms);
1837 out_unregister_pernet:
1839 unregister_pernet_subsys(&ndisc_net_ops);
1843 void ndisc_cleanup(void)
1845 unregister_netdevice_notifier(&ndisc_netdev_notifier);
1846 #ifdef CONFIG_SYSCTL
1847 neigh_sysctl_unregister(&nd_tbl.parms);
1849 neigh_table_clear(&nd_tbl);
1850 unregister_pernet_subsys(&ndisc_net_ops);