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;
456 len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0);
458 len += ndisc_opt_addr_space(dev);
460 skb = sock_alloc_send_skb(sk,
461 (MAX_HEADER + sizeof(struct ipv6hdr) +
462 len + LL_ALLOCATED_SPACE(dev)),
466 "ICMPv6 ND: %s() failed to allocate an skb, err=%d.\n",
471 skb_reserve(skb, LL_RESERVED_SPACE(dev));
472 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
474 skb->transport_header = skb->tail;
477 hdr = (struct icmp6hdr *)skb_transport_header(skb);
478 memcpy(hdr, icmp6h, sizeof(*hdr));
480 opt = skb_transport_header(skb) + sizeof(struct icmp6hdr);
482 ipv6_addr_copy((struct in6_addr *)opt, target);
483 opt += sizeof(*target);
487 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr,
488 dev->addr_len, dev->type);
490 hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len,
498 EXPORT_SYMBOL(ndisc_build_skb);
500 void ndisc_send_skb(struct sk_buff *skb,
501 struct net_device *dev,
502 struct neighbour *neigh,
503 const struct in6_addr *daddr,
504 const struct in6_addr *saddr,
505 struct icmp6hdr *icmp6h)
508 struct dst_entry *dst;
509 struct net *net = dev_net(dev);
510 struct sock *sk = net->ipv6.ndisc_sk;
511 struct inet6_dev *idev;
515 type = icmp6h->icmp6_type;
517 icmpv6_flow_init(sk, &fl6, type, saddr, daddr, dev->ifindex);
519 dst = icmp6_dst_alloc(dev, neigh, daddr);
525 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
531 skb_dst_set(skb, dst);
534 idev = __in6_dev_get(dst->dev);
535 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
537 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
540 ICMP6MSGOUT_INC_STATS(net, idev, type);
541 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
547 EXPORT_SYMBOL(ndisc_send_skb);
550 * Send a Neighbour Discover packet
552 static void __ndisc_send(struct net_device *dev,
553 struct neighbour *neigh,
554 const struct in6_addr *daddr,
555 const struct in6_addr *saddr,
556 struct icmp6hdr *icmp6h, const struct in6_addr *target,
561 skb = ndisc_build_skb(dev, daddr, saddr, icmp6h, target, llinfo);
565 ndisc_send_skb(skb, dev, neigh, daddr, saddr, icmp6h);
568 static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
569 const struct in6_addr *daddr,
570 const struct in6_addr *solicited_addr,
571 int router, int solicited, int override, int inc_opt)
573 struct in6_addr tmpaddr;
574 struct inet6_ifaddr *ifp;
575 const struct in6_addr *src_addr;
576 struct icmp6hdr icmp6h = {
577 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
580 /* for anycast or proxy, solicited_addr != src_addr */
581 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
583 src_addr = solicited_addr;
584 if (ifp->flags & IFA_F_OPTIMISTIC)
586 inc_opt |= ifp->idev->cnf.force_tllao;
589 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
590 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
596 icmp6h.icmp6_router = router;
597 icmp6h.icmp6_solicited = solicited;
598 icmp6h.icmp6_override = override;
600 __ndisc_send(dev, neigh, daddr, src_addr,
601 &icmp6h, solicited_addr,
602 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
605 static void ndisc_send_unsol_na(struct net_device *dev)
607 struct inet6_dev *idev;
608 struct inet6_ifaddr *ifa;
609 struct in6_addr mcaddr = IN6ADDR_LINKLOCAL_ALLNODES_INIT;
611 idev = in6_dev_get(dev);
615 read_lock_bh(&idev->lock);
616 list_for_each_entry(ifa, &idev->addr_list, if_list) {
617 ndisc_send_na(dev, NULL, &mcaddr, &ifa->addr,
618 /*router=*/ !!idev->cnf.forwarding,
619 /*solicited=*/ false, /*override=*/ true,
622 read_unlock_bh(&idev->lock);
627 void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
628 const struct in6_addr *solicit,
629 const struct in6_addr *daddr, const struct in6_addr *saddr)
631 struct in6_addr addr_buf;
632 struct icmp6hdr icmp6h = {
633 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
637 if (ipv6_get_lladdr(dev, &addr_buf,
638 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
643 __ndisc_send(dev, neigh, daddr, saddr,
645 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
648 void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
649 const struct in6_addr *daddr)
651 struct icmp6hdr icmp6h = {
652 .icmp6_type = NDISC_ROUTER_SOLICITATION,
654 int send_sllao = dev->addr_len;
656 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
658 * According to section 2.2 of RFC 4429, we must not
659 * send router solicitations with a sllao from
660 * optimistic addresses, but we may send the solicitation
661 * if we don't include the sllao. So here we check
662 * if our address is optimistic, and if so, we
663 * suppress the inclusion of the sllao.
666 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
669 if (ifp->flags & IFA_F_OPTIMISTIC) {
678 __ndisc_send(dev, NULL, daddr, saddr,
680 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
684 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
687 * "The sender MUST return an ICMP
688 * destination unreachable"
690 dst_link_failure(skb);
694 /* Called with locked neigh: either read or both */
696 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
698 struct in6_addr *saddr = NULL;
699 struct in6_addr mcaddr;
700 struct net_device *dev = neigh->dev;
701 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
702 int probes = atomic_read(&neigh->probes);
704 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
705 saddr = &ipv6_hdr(skb)->saddr;
707 if ((probes -= neigh->parms->ucast_probes) < 0) {
708 if (!(neigh->nud_state & NUD_VALID)) {
709 ND_PRINTK1(KERN_DEBUG "%s(): trying to ucast probe in NUD_INVALID: %pI6\n",
712 ndisc_send_ns(dev, neigh, target, target, saddr);
713 } else if ((probes -= neigh->parms->app_probes) < 0) {
718 addrconf_addr_solict_mult(target, &mcaddr);
719 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
723 static int pndisc_is_router(const void *pkey,
724 struct net_device *dev)
726 struct pneigh_entry *n;
729 read_lock_bh(&nd_tbl.lock);
730 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
732 ret = !!(n->flags & NTF_ROUTER);
733 read_unlock_bh(&nd_tbl.lock);
738 static void ndisc_recv_ns(struct sk_buff *skb)
740 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
741 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
742 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
744 u32 ndoptlen = skb->tail - (skb->transport_header +
745 offsetof(struct nd_msg, opt));
746 struct ndisc_options ndopts;
747 struct net_device *dev = skb->dev;
748 struct inet6_ifaddr *ifp;
749 struct inet6_dev *idev = NULL;
750 struct neighbour *neigh;
751 int dad = ipv6_addr_any(saddr);
755 if (ipv6_addr_is_multicast(&msg->target)) {
756 ND_PRINTK2(KERN_WARNING
757 "ICMPv6 NS: multicast target address");
763 * DAD has to be destined for solicited node multicast address.
766 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
767 daddr->s6_addr32[1] == htonl(0x00000000) &&
768 daddr->s6_addr32[2] == htonl(0x00000001) &&
769 daddr->s6_addr [12] == 0xff )) {
770 ND_PRINTK2(KERN_WARNING
771 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
775 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
776 ND_PRINTK2(KERN_WARNING
777 "ICMPv6 NS: invalid ND options\n");
781 if (ndopts.nd_opts_src_lladdr) {
782 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
784 ND_PRINTK2(KERN_WARNING
785 "ICMPv6 NS: invalid link-layer address length\n");
790 * If the IP source address is the unspecified address,
791 * there MUST NOT be source link-layer address option
795 ND_PRINTK2(KERN_WARNING
796 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
801 inc = ipv6_addr_is_multicast(daddr);
803 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
806 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
808 if (dev->type == ARPHRD_IEEE802_TR) {
809 const unsigned char *sadr;
810 sadr = skb_mac_header(skb);
811 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
812 sadr[9] == dev->dev_addr[1] &&
813 sadr[10] == dev->dev_addr[2] &&
814 sadr[11] == dev->dev_addr[3] &&
815 sadr[12] == dev->dev_addr[4] &&
816 sadr[13] == dev->dev_addr[5]) {
817 /* looped-back to us */
823 * We are colliding with another node
825 * so fail our DAD process
827 addrconf_dad_failure(ifp);
831 * This is not a dad solicitation.
832 * If we are an optimistic node,
834 * Otherwise, we should ignore it.
836 if (!(ifp->flags & IFA_F_OPTIMISTIC))
843 struct net *net = dev_net(dev);
845 idev = in6_dev_get(dev);
847 /* XXX: count this drop? */
851 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
852 (idev->cnf.forwarding &&
853 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
854 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
855 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
856 skb->pkt_type != PACKET_HOST &&
858 idev->nd_parms->proxy_delay != 0) {
860 * for anycast or proxy,
861 * sender should delay its response
862 * by a random time between 0 and
863 * MAX_ANYCAST_DELAY_TIME seconds.
864 * (RFC2461) -- yoshfuji
866 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
868 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
876 is_router = !!idev->cnf.forwarding;
879 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
880 is_router, 0, (ifp != NULL), 1);
885 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
887 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
890 * update / create cache entry
891 * for the source address
893 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
894 !inc || lladdr || !dev->addr_len);
896 neigh_update(neigh, lladdr, NUD_STALE,
897 NEIGH_UPDATE_F_WEAK_OVERRIDE|
898 NEIGH_UPDATE_F_OVERRIDE);
899 if (neigh || !dev->header_ops) {
900 ndisc_send_na(dev, neigh, saddr, &msg->target,
902 1, (ifp != NULL && inc), inc);
904 neigh_release(neigh);
914 static void ndisc_recv_na(struct sk_buff *skb)
916 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
917 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
918 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
920 u32 ndoptlen = skb->tail - (skb->transport_header +
921 offsetof(struct nd_msg, opt));
922 struct ndisc_options ndopts;
923 struct net_device *dev = skb->dev;
924 struct inet6_ifaddr *ifp;
925 struct neighbour *neigh;
927 if (skb->len < sizeof(struct nd_msg)) {
928 ND_PRINTK2(KERN_WARNING
929 "ICMPv6 NA: packet too short\n");
933 if (ipv6_addr_is_multicast(&msg->target)) {
934 ND_PRINTK2(KERN_WARNING
935 "ICMPv6 NA: target address is multicast.\n");
939 if (ipv6_addr_is_multicast(daddr) &&
940 msg->icmph.icmp6_solicited) {
941 ND_PRINTK2(KERN_WARNING
942 "ICMPv6 NA: solicited NA is multicasted.\n");
946 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
947 ND_PRINTK2(KERN_WARNING
948 "ICMPv6 NS: invalid ND option\n");
951 if (ndopts.nd_opts_tgt_lladdr) {
952 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
954 ND_PRINTK2(KERN_WARNING
955 "ICMPv6 NA: invalid link-layer address length\n");
959 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
961 if (skb->pkt_type != PACKET_LOOPBACK
962 && (ifp->flags & IFA_F_TENTATIVE)) {
963 addrconf_dad_failure(ifp);
966 /* What should we make now? The advertisement
967 is invalid, but ndisc specs say nothing
968 about it. It could be misconfiguration, or
969 an smart proxy agent tries to help us :-)
971 We should not print the error if NA has been
972 received from loopback - it is just our own
973 unsolicited advertisement.
975 if (skb->pkt_type != PACKET_LOOPBACK)
976 ND_PRINTK1(KERN_WARNING
977 "ICMPv6 NA: someone advertises our address %pI6 on %s!\n",
978 &ifp->addr, ifp->idev->dev->name);
982 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
985 u8 old_flags = neigh->flags;
986 struct net *net = dev_net(dev);
988 if (neigh->nud_state & NUD_FAILED)
992 * Don't update the neighbor cache entry on a proxy NA from
993 * ourselves because either the proxied node is off link or it
994 * has already sent a NA to us.
996 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
997 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
998 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
999 /* XXX: idev->cnf.prixy_ndp */
1003 neigh_update(neigh, lladdr,
1004 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
1005 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1006 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
1007 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1008 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
1010 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
1012 * Change: router to host
1014 struct rt6_info *rt;
1015 rt = rt6_get_dflt_router(saddr, dev);
1021 neigh_release(neigh);
1025 static void ndisc_recv_rs(struct sk_buff *skb)
1027 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
1028 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
1029 struct neighbour *neigh;
1030 struct inet6_dev *idev;
1031 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
1032 struct ndisc_options ndopts;
1035 if (skb->len < sizeof(*rs_msg))
1038 idev = __in6_dev_get(skb->dev);
1040 if (net_ratelimit())
1041 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1045 /* Don't accept RS if we're not in router mode */
1046 if (!idev->cnf.forwarding)
1050 * Don't update NCE if src = ::;
1051 * this implies that the source node has no ip address assigned yet.
1053 if (ipv6_addr_any(saddr))
1056 /* Parse ND options */
1057 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
1058 if (net_ratelimit())
1059 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1063 if (ndopts.nd_opts_src_lladdr) {
1064 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1070 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1072 neigh_update(neigh, lladdr, NUD_STALE,
1073 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1074 NEIGH_UPDATE_F_OVERRIDE|
1075 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1076 neigh_release(neigh);
1082 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1084 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1085 struct sk_buff *skb;
1086 struct nlmsghdr *nlh;
1087 struct nduseroptmsg *ndmsg;
1088 struct net *net = dev_net(ra->dev);
1090 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1091 + (opt->nd_opt_len << 3));
1092 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1094 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1100 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1102 goto nla_put_failure;
1105 ndmsg = nlmsg_data(nlh);
1106 ndmsg->nduseropt_family = AF_INET6;
1107 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
1108 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1109 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1110 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1112 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1114 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1115 &ipv6_hdr(ra)->saddr);
1116 nlmsg_end(skb, nlh);
1118 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
1125 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1128 static inline int accept_ra(struct inet6_dev *in6_dev)
1131 * If forwarding is enabled, RA are not accepted unless the special
1132 * hybrid mode (accept_ra=2) is enabled.
1134 if (in6_dev->cnf.forwarding && in6_dev->cnf.accept_ra < 2)
1137 return in6_dev->cnf.accept_ra;
1140 static void ndisc_router_discovery(struct sk_buff *skb)
1142 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1143 struct neighbour *neigh = NULL;
1144 struct inet6_dev *in6_dev;
1145 struct rt6_info *rt = NULL;
1147 struct ndisc_options ndopts;
1149 unsigned int pref = 0;
1151 __u8 * opt = (__u8 *)(ra_msg + 1);
1153 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
1155 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1156 ND_PRINTK2(KERN_WARNING
1157 "ICMPv6 RA: source address is not link-local.\n");
1161 ND_PRINTK2(KERN_WARNING
1162 "ICMPv6 RA: packet too short\n");
1166 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1167 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1168 ND_PRINTK2(KERN_WARNING
1169 "ICMPv6 RA: from host or unauthorized router\n");
1175 * set the RA_RECV flag in the interface
1178 in6_dev = __in6_dev_get(skb->dev);
1179 if (in6_dev == NULL) {
1181 "ICMPv6 RA: can't find inet6 device for %s.\n",
1186 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1187 ND_PRINTK2(KERN_WARNING
1188 "ICMP6 RA: invalid ND options\n");
1192 if (!accept_ra(in6_dev))
1193 goto skip_linkparms;
1195 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1196 /* skip link-specific parameters from interior routers */
1197 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1198 goto skip_linkparms;
1201 if (in6_dev->if_flags & IF_RS_SENT) {
1203 * flag that an RA was received after an RS was sent
1204 * out on this interface.
1206 in6_dev->if_flags |= IF_RA_RCVD;
1210 * Remember the managed/otherconf flags from most recently
1211 * received RA message (RFC 2462) -- yoshfuji
1213 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1215 (ra_msg->icmph.icmp6_addrconf_managed ?
1216 IF_RA_MANAGED : 0) |
1217 (ra_msg->icmph.icmp6_addrconf_other ?
1218 IF_RA_OTHERCONF : 0);
1220 if (!in6_dev->cnf.accept_ra_defrtr)
1223 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
1226 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1228 #ifdef CONFIG_IPV6_ROUTER_PREF
1229 pref = ra_msg->icmph.icmp6_router_pref;
1230 /* 10b is handled as if it were 00b (medium) */
1231 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1232 !in6_dev->cnf.accept_ra_rtr_pref)
1233 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1236 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1239 neigh = dst_get_neighbour(&rt->dst);
1241 if (rt && lifetime == 0) {
1247 if (rt == NULL && lifetime) {
1248 ND_PRINTK3(KERN_DEBUG
1249 "ICMPv6 RA: adding default router.\n");
1251 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1254 "ICMPv6 RA: %s() failed to add default route.\n",
1259 neigh = dst_get_neighbour(&rt->dst);
1260 if (neigh == NULL) {
1262 "ICMPv6 RA: %s() got default router without neighbour.\n",
1264 dst_release(&rt->dst);
1267 neigh->flags |= NTF_ROUTER;
1269 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1273 rt->rt6i_expires = jiffies + (HZ * lifetime);
1275 if (ra_msg->icmph.icmp6_hop_limit) {
1276 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1278 dst_metric_set(&rt->dst, RTAX_HOPLIMIT,
1279 ra_msg->icmph.icmp6_hop_limit);
1285 * Update Reachable Time and Retrans Timer
1288 if (in6_dev->nd_parms) {
1289 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1291 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1292 rtime = (rtime*HZ)/1000;
1295 in6_dev->nd_parms->retrans_time = rtime;
1296 in6_dev->tstamp = jiffies;
1297 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1300 rtime = ntohl(ra_msg->reachable_time);
1301 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1302 rtime = (rtime*HZ)/1000;
1307 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1308 in6_dev->nd_parms->base_reachable_time = rtime;
1309 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1310 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1311 in6_dev->tstamp = jiffies;
1312 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1324 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1328 if (ndopts.nd_opts_src_lladdr) {
1329 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1332 ND_PRINTK2(KERN_WARNING
1333 "ICMPv6 RA: invalid link-layer address length\n");
1337 neigh_update(neigh, lladdr, NUD_STALE,
1338 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1339 NEIGH_UPDATE_F_OVERRIDE|
1340 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1341 NEIGH_UPDATE_F_ISROUTER);
1344 if (!accept_ra(in6_dev))
1347 #ifdef CONFIG_IPV6_ROUTE_INFO
1348 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
1349 goto skip_routeinfo;
1351 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1352 struct nd_opt_hdr *p;
1353 for (p = ndopts.nd_opts_ri;
1355 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1356 struct route_info *ri = (struct route_info *)p;
1357 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1358 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1359 ri->prefix_len == 0)
1362 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1364 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1365 &ipv6_hdr(skb)->saddr);
1372 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1373 /* skip link-specific ndopts from interior routers */
1374 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1378 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1379 struct nd_opt_hdr *p;
1380 for (p = ndopts.nd_opts_pi;
1382 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1383 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1387 if (ndopts.nd_opts_mtu) {
1391 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1394 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1395 ND_PRINTK2(KERN_WARNING
1396 "ICMPv6 RA: invalid mtu: %d\n",
1398 } else if (in6_dev->cnf.mtu6 != mtu) {
1399 in6_dev->cnf.mtu6 = mtu;
1402 dst_metric_set(&rt->dst, RTAX_MTU, mtu);
1404 rt6_mtu_change(skb->dev, mtu);
1408 if (ndopts.nd_useropts) {
1409 struct nd_opt_hdr *p;
1410 for (p = ndopts.nd_useropts;
1412 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1413 ndisc_ra_useropt(skb, p);
1417 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1418 ND_PRINTK2(KERN_WARNING
1419 "ICMPv6 RA: invalid RA options");
1423 dst_release(&rt->dst);
1425 neigh_release(neigh);
1428 static void ndisc_redirect_rcv(struct sk_buff *skb)
1430 struct inet6_dev *in6_dev;
1431 struct icmp6hdr *icmph;
1432 const struct in6_addr *dest;
1433 const struct in6_addr *target; /* new first hop to destination */
1434 struct neighbour *neigh;
1436 struct ndisc_options ndopts;
1440 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1441 switch (skb->ndisc_nodetype) {
1442 case NDISC_NODETYPE_HOST:
1443 case NDISC_NODETYPE_NODEFAULT:
1444 ND_PRINTK2(KERN_WARNING
1445 "ICMPv6 Redirect: from host or unauthorized router\n");
1450 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1451 ND_PRINTK2(KERN_WARNING
1452 "ICMPv6 Redirect: source address is not link-local.\n");
1456 optlen = skb->tail - skb->transport_header;
1457 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1460 ND_PRINTK2(KERN_WARNING
1461 "ICMPv6 Redirect: packet too short\n");
1465 icmph = icmp6_hdr(skb);
1466 target = (const struct in6_addr *) (icmph + 1);
1469 if (ipv6_addr_is_multicast(dest)) {
1470 ND_PRINTK2(KERN_WARNING
1471 "ICMPv6 Redirect: destination address is multicast.\n");
1475 if (ipv6_addr_equal(dest, target)) {
1477 } else if (ipv6_addr_type(target) !=
1478 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1479 ND_PRINTK2(KERN_WARNING
1480 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1484 in6_dev = __in6_dev_get(skb->dev);
1487 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1491 * The IP source address of the Redirect MUST be the same as the current
1492 * first-hop router for the specified ICMP Destination Address.
1495 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1496 ND_PRINTK2(KERN_WARNING
1497 "ICMPv6 Redirect: invalid ND options\n");
1500 if (ndopts.nd_opts_tgt_lladdr) {
1501 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1504 ND_PRINTK2(KERN_WARNING
1505 "ICMPv6 Redirect: invalid link-layer address length\n");
1510 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1512 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1513 &ipv6_hdr(skb)->saddr, neigh, lladdr,
1515 neigh_release(neigh);
1519 void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
1520 const struct in6_addr *target)
1522 struct net_device *dev = skb->dev;
1523 struct net *net = dev_net(dev);
1524 struct sock *sk = net->ipv6.ndisc_sk;
1525 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1526 struct sk_buff *buff;
1527 struct icmp6hdr *icmph;
1528 struct in6_addr saddr_buf;
1529 struct in6_addr *addrp;
1530 struct rt6_info *rt;
1531 struct dst_entry *dst;
1532 struct inet6_dev *idev;
1537 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1539 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1540 ND_PRINTK2(KERN_WARNING
1541 "ICMPv6 Redirect: no link-local address on %s\n",
1546 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1547 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1548 ND_PRINTK2(KERN_WARNING
1549 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1553 icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT,
1554 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
1556 dst = ip6_route_output(net, NULL, &fl6);
1560 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
1564 rt = (struct rt6_info *) dst;
1566 if (rt->rt6i_flags & RTF_GATEWAY) {
1567 ND_PRINTK2(KERN_WARNING
1568 "ICMPv6 Redirect: destination is not a neighbour.\n");
1572 rt6_bind_peer(rt, 1);
1573 if (!inet_peer_xrlim_allow(rt->rt6i_peer, 1*HZ))
1576 if (dev->addr_len) {
1577 read_lock_bh(&neigh->lock);
1578 if (neigh->nud_state & NUD_VALID) {
1579 memcpy(ha_buf, neigh->ha, dev->addr_len);
1580 read_unlock_bh(&neigh->lock);
1582 len += ndisc_opt_addr_space(dev);
1584 read_unlock_bh(&neigh->lock);
1587 rd_len = min_t(unsigned int,
1588 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1592 buff = sock_alloc_send_skb(sk,
1593 (MAX_HEADER + sizeof(struct ipv6hdr) +
1594 len + LL_ALLOCATED_SPACE(dev)),
1598 "ICMPv6 Redirect: %s() failed to allocate an skb, err=%d.\n",
1603 skb_reserve(buff, LL_RESERVED_SPACE(dev));
1604 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
1605 IPPROTO_ICMPV6, len);
1607 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
1609 icmph = icmp6_hdr(buff);
1611 memset(icmph, 0, sizeof(struct icmp6hdr));
1612 icmph->icmp6_type = NDISC_REDIRECT;
1615 * copy target and destination addresses
1618 addrp = (struct in6_addr *)(icmph + 1);
1619 ipv6_addr_copy(addrp, target);
1621 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
1623 opt = (u8*) (addrp + 1);
1626 * include target_address option
1630 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1631 dev->addr_len, dev->type);
1634 * build redirect option and copy skb over to the new packet.
1638 *(opt++) = ND_OPT_REDIRECT_HDR;
1639 *(opt++) = (rd_len >> 3);
1642 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
1644 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
1645 len, IPPROTO_ICMPV6,
1646 csum_partial(icmph, len, 0));
1648 skb_dst_set(buff, dst);
1650 idev = __in6_dev_get(dst->dev);
1651 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
1652 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1655 ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT);
1656 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
1666 static void pndisc_redo(struct sk_buff *skb)
1672 int ndisc_rcv(struct sk_buff *skb)
1676 if (!pskb_may_pull(skb, skb->len))
1679 msg = (struct nd_msg *)skb_transport_header(skb);
1681 __skb_push(skb, skb->data - skb_transport_header(skb));
1683 if (ipv6_hdr(skb)->hop_limit != 255) {
1684 ND_PRINTK2(KERN_WARNING
1685 "ICMPv6 NDISC: invalid hop-limit: %d\n",
1686 ipv6_hdr(skb)->hop_limit);
1690 if (msg->icmph.icmp6_code != 0) {
1691 ND_PRINTK2(KERN_WARNING
1692 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1693 msg->icmph.icmp6_code);
1697 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1699 switch (msg->icmph.icmp6_type) {
1700 case NDISC_NEIGHBOUR_SOLICITATION:
1704 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1708 case NDISC_ROUTER_SOLICITATION:
1712 case NDISC_ROUTER_ADVERTISEMENT:
1713 ndisc_router_discovery(skb);
1716 case NDISC_REDIRECT:
1717 ndisc_redirect_rcv(skb);
1724 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1726 struct net_device *dev = ptr;
1727 struct net *net = dev_net(dev);
1730 case NETDEV_CHANGEADDR:
1731 neigh_changeaddr(&nd_tbl, dev);
1732 fib6_run_gc(~0UL, net);
1735 neigh_ifdown(&nd_tbl, dev);
1736 fib6_run_gc(~0UL, net);
1738 case NETDEV_NOTIFY_PEERS:
1739 ndisc_send_unsol_na(dev);
1748 static struct notifier_block ndisc_netdev_notifier = {
1749 .notifier_call = ndisc_netdev_event,
1752 #ifdef CONFIG_SYSCTL
1753 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1754 const char *func, const char *dev_name)
1756 static char warncomm[TASK_COMM_LEN];
1758 if (strcmp(warncomm, current->comm) && warned < 5) {
1759 strcpy(warncomm, current->comm);
1761 "process `%s' is using deprecated sysctl (%s) "
1762 "net.ipv6.neigh.%s.%s; "
1763 "Use net.ipv6.neigh.%s.%s_ms "
1766 dev_name, ctl->procname,
1767 dev_name, ctl->procname);
1772 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos)
1774 struct net_device *dev = ctl->extra1;
1775 struct inet6_dev *idev;
1778 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1779 (strcmp(ctl->procname, "base_reachable_time") == 0))
1780 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1782 if (strcmp(ctl->procname, "retrans_time") == 0)
1783 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1785 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1786 ret = proc_dointvec_jiffies(ctl, write,
1787 buffer, lenp, ppos);
1789 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1790 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1791 ret = proc_dointvec_ms_jiffies(ctl, write,
1792 buffer, lenp, ppos);
1796 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1797 if (ctl->data == &idev->nd_parms->base_reachable_time)
1798 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1799 idev->tstamp = jiffies;
1800 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1809 static int __net_init ndisc_net_init(struct net *net)
1811 struct ipv6_pinfo *np;
1815 err = inet_ctl_sock_create(&sk, PF_INET6,
1816 SOCK_RAW, IPPROTO_ICMPV6, net);
1819 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1824 net->ipv6.ndisc_sk = sk;
1827 np->hop_limit = 255;
1828 /* Do not loopback ndisc messages */
1834 static void __net_exit ndisc_net_exit(struct net *net)
1836 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1839 static struct pernet_operations ndisc_net_ops = {
1840 .init = ndisc_net_init,
1841 .exit = ndisc_net_exit,
1844 int __init ndisc_init(void)
1848 err = register_pernet_subsys(&ndisc_net_ops);
1852 * Initialize the neighbour table
1854 neigh_table_init(&nd_tbl);
1856 #ifdef CONFIG_SYSCTL
1857 err = neigh_sysctl_register(NULL, &nd_tbl.parms, "ipv6",
1858 &ndisc_ifinfo_sysctl_change);
1860 goto out_unregister_pernet;
1862 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1864 goto out_unregister_sysctl;
1868 out_unregister_sysctl:
1869 #ifdef CONFIG_SYSCTL
1870 neigh_sysctl_unregister(&nd_tbl.parms);
1871 out_unregister_pernet:
1873 unregister_pernet_subsys(&ndisc_net_ops);
1877 void ndisc_cleanup(void)
1879 unregister_netdevice_notifier(&ndisc_netdev_notifier);
1880 #ifdef CONFIG_SYSCTL
1881 neigh_sysctl_unregister(&nd_tbl.parms);
1883 neigh_table_clear(&nd_tbl);
1884 unregister_pernet_subsys(&ndisc_net_ops);