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 <linux/proc_fs.h>
89 #include <linux/netfilter.h>
90 #include <linux/netfilter_ipv6.h>
92 static u32 ndisc_hash(const void *pkey, const struct net_device *dev);
93 static int ndisc_constructor(struct neighbour *neigh);
94 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
95 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
96 static int pndisc_constructor(struct pneigh_entry *n);
97 static void pndisc_destructor(struct pneigh_entry *n);
98 static void pndisc_redo(struct sk_buff *skb);
100 static struct neigh_ops ndisc_generic_ops = {
102 .solicit = ndisc_solicit,
103 .error_report = ndisc_error_report,
104 .output = neigh_resolve_output,
105 .connected_output = neigh_connected_output,
106 .hh_output = dev_queue_xmit,
107 .queue_xmit = dev_queue_xmit,
110 static struct neigh_ops ndisc_hh_ops = {
112 .solicit = ndisc_solicit,
113 .error_report = ndisc_error_report,
114 .output = neigh_resolve_output,
115 .connected_output = neigh_resolve_output,
116 .hh_output = dev_queue_xmit,
117 .queue_xmit = dev_queue_xmit,
121 static struct neigh_ops ndisc_direct_ops = {
123 .output = dev_queue_xmit,
124 .connected_output = dev_queue_xmit,
125 .hh_output = dev_queue_xmit,
126 .queue_xmit = dev_queue_xmit,
129 struct neigh_table nd_tbl = {
131 .entry_size = sizeof(struct neighbour) + sizeof(struct in6_addr),
132 .key_len = sizeof(struct in6_addr),
134 .constructor = ndisc_constructor,
135 .pconstructor = pndisc_constructor,
136 .pdestructor = pndisc_destructor,
137 .proxy_redo = pndisc_redo,
141 .base_reachable_time = 30 * HZ,
142 .retrans_time = 1 * HZ,
143 .gc_staletime = 60 * HZ,
144 .reachable_time = 30 * HZ,
145 .delay_probe_time = 5 * HZ,
149 .anycast_delay = 1 * HZ,
150 .proxy_delay = (8 * HZ) / 10,
153 .gc_interval = 30 * HZ,
160 struct ndisc_options {
161 struct nd_opt_hdr *nd_opt_array[__ND_OPT_ARRAY_MAX];
162 #ifdef CONFIG_IPV6_ROUTE_INFO
163 struct nd_opt_hdr *nd_opts_ri;
164 struct nd_opt_hdr *nd_opts_ri_end;
166 struct nd_opt_hdr *nd_useropts;
167 struct nd_opt_hdr *nd_useropts_end;
170 #define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR]
171 #define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR]
172 #define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO]
173 #define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END]
174 #define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR]
175 #define nd_opts_mtu nd_opt_array[ND_OPT_MTU]
177 #define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
180 * Return the padding between the option length and the start of the
181 * link addr. Currently only IP-over-InfiniBand needs this, although
182 * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may
183 * also need a pad of 2.
185 static int ndisc_addr_option_pad(unsigned short type)
188 case ARPHRD_INFINIBAND: return 2;
193 static inline int ndisc_opt_addr_space(struct net_device *dev)
195 return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type));
198 static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len,
199 unsigned short addr_type)
201 int space = NDISC_OPT_SPACE(data_len);
202 int pad = ndisc_addr_option_pad(addr_type);
207 memset(opt + 2, 0, pad);
211 memcpy(opt+2, data, data_len);
214 if ((space -= data_len) > 0)
215 memset(opt, 0, space);
219 static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
220 struct nd_opt_hdr *end)
223 if (!cur || !end || cur >= end)
225 type = cur->nd_opt_type;
227 cur = ((void *)cur) + (cur->nd_opt_len << 3);
228 } while(cur < end && cur->nd_opt_type != type);
229 return (cur <= end && cur->nd_opt_type == type ? cur : NULL);
232 static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
234 return (opt->nd_opt_type == ND_OPT_RDNSS);
237 static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur,
238 struct nd_opt_hdr *end)
240 if (!cur || !end || cur >= end)
243 cur = ((void *)cur) + (cur->nd_opt_len << 3);
244 } while(cur < end && !ndisc_is_useropt(cur));
245 return (cur <= end && ndisc_is_useropt(cur) ? cur : NULL);
248 static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
249 struct ndisc_options *ndopts)
251 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
253 if (!nd_opt || opt_len < 0 || !ndopts)
255 memset(ndopts, 0, sizeof(*ndopts));
258 if (opt_len < sizeof(struct nd_opt_hdr))
260 l = nd_opt->nd_opt_len << 3;
261 if (opt_len < l || l == 0)
263 switch (nd_opt->nd_opt_type) {
264 case ND_OPT_SOURCE_LL_ADDR:
265 case ND_OPT_TARGET_LL_ADDR:
267 case ND_OPT_REDIRECT_HDR:
268 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
269 ND_PRINTK2(KERN_WARNING
270 "%s(): duplicated ND6 option found: type=%d\n",
272 nd_opt->nd_opt_type);
274 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
277 case ND_OPT_PREFIX_INFO:
278 ndopts->nd_opts_pi_end = nd_opt;
279 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
280 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
282 #ifdef CONFIG_IPV6_ROUTE_INFO
283 case ND_OPT_ROUTE_INFO:
284 ndopts->nd_opts_ri_end = nd_opt;
285 if (!ndopts->nd_opts_ri)
286 ndopts->nd_opts_ri = nd_opt;
290 if (ndisc_is_useropt(nd_opt)) {
291 ndopts->nd_useropts_end = nd_opt;
292 if (!ndopts->nd_useropts)
293 ndopts->nd_useropts = nd_opt;
296 * Unknown options must be silently ignored,
297 * to accommodate future extension to the
300 ND_PRINTK2(KERN_NOTICE
301 "%s(): ignored unsupported option; type=%d, len=%d\n",
303 nd_opt->nd_opt_type, nd_opt->nd_opt_len);
307 nd_opt = ((void *)nd_opt) + l;
312 static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p,
313 struct net_device *dev)
315 u8 *lladdr = (u8 *)(p + 1);
316 int lladdrlen = p->nd_opt_len << 3;
317 int prepad = ndisc_addr_option_pad(dev->type);
318 if (lladdrlen != NDISC_OPT_SPACE(dev->addr_len + prepad))
320 return (lladdr + prepad);
323 int ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
327 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
329 ipv6_eth_mc_map(addr, buf);
331 case ARPHRD_IEEE802_TR:
332 ipv6_tr_mc_map(addr,buf);
335 ipv6_arcnet_mc_map(addr, buf);
337 case ARPHRD_INFINIBAND:
338 ipv6_ib_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, const struct net_device *dev)
353 const u32 *p32 = pkey;
357 for (i = 0; i < (sizeof(struct in6_addr) / sizeof(u32)); i++)
360 return jhash_2words(addr_hash, dev->ifindex, nd_tbl.hash_rnd);
363 static int ndisc_constructor(struct neighbour *neigh)
365 struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;
366 struct net_device *dev = neigh->dev;
367 struct inet6_dev *in6_dev;
368 struct neigh_parms *parms;
369 int is_multicast = ipv6_addr_is_multicast(addr);
372 in6_dev = in6_dev_get(dev);
373 if (in6_dev == NULL) {
378 parms = in6_dev->nd_parms;
379 __neigh_parms_put(neigh->parms);
380 neigh->parms = neigh_parms_clone(parms);
383 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
384 if (!dev->header_ops) {
385 neigh->nud_state = NUD_NOARP;
386 neigh->ops = &ndisc_direct_ops;
387 neigh->output = neigh->ops->queue_xmit;
390 neigh->nud_state = NUD_NOARP;
391 ndisc_mc_map(addr, neigh->ha, dev, 1);
392 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
393 neigh->nud_state = NUD_NOARP;
394 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
395 if (dev->flags&IFF_LOOPBACK)
396 neigh->type = RTN_LOCAL;
397 } else if (dev->flags&IFF_POINTOPOINT) {
398 neigh->nud_state = NUD_NOARP;
399 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
401 if (dev->header_ops->cache)
402 neigh->ops = &ndisc_hh_ops;
404 neigh->ops = &ndisc_generic_ops;
405 if (neigh->nud_state&NUD_VALID)
406 neigh->output = neigh->ops->connected_output;
408 neigh->output = neigh->ops->output;
410 in6_dev_put(in6_dev);
414 static int pndisc_constructor(struct pneigh_entry *n)
416 struct in6_addr *addr = (struct in6_addr*)&n->key;
417 struct in6_addr maddr;
418 struct net_device *dev = n->dev;
420 if (dev == NULL || __in6_dev_get(dev) == NULL)
422 addrconf_addr_solict_mult(addr, &maddr);
423 ipv6_dev_mc_inc(dev, &maddr);
427 static void pndisc_destructor(struct pneigh_entry *n)
429 struct in6_addr *addr = (struct in6_addr*)&n->key;
430 struct in6_addr maddr;
431 struct net_device *dev = n->dev;
433 if (dev == NULL || __in6_dev_get(dev) == NULL)
435 addrconf_addr_solict_mult(addr, &maddr);
436 ipv6_dev_mc_dec(dev, &maddr);
440 * Send a Neighbour Advertisement
442 static void __ndisc_send(struct net_device *dev,
443 struct neighbour *neigh,
444 struct in6_addr *daddr, struct in6_addr *saddr,
445 struct icmp6hdr *icmp6h, struct in6_addr *target,
449 struct dst_entry *dst;
450 struct net *net = dev_net(dev);
451 struct sock *sk = net->ipv6.ndisc_sk;
453 struct icmp6hdr *hdr;
454 struct inet6_dev *idev;
459 type = icmp6h->icmp6_type;
461 icmpv6_flow_init(sk, &fl, type, saddr, daddr, dev->ifindex);
463 dst = icmp6_dst_alloc(dev, neigh, daddr);
467 err = xfrm_lookup(&dst, &fl, NULL, 0);
474 len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0);
476 len += ndisc_opt_addr_space(dev);
478 skb = sock_alloc_send_skb(sk,
479 (MAX_HEADER + sizeof(struct ipv6hdr) +
480 len + LL_RESERVED_SPACE(dev)),
484 "ICMPv6 ND: %s() failed to allocate an skb.\n",
490 skb_reserve(skb, LL_RESERVED_SPACE(dev));
491 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
493 skb->transport_header = skb->tail;
496 hdr = (struct icmp6hdr *)skb_transport_header(skb);
497 memcpy(hdr, icmp6h, sizeof(*hdr));
499 opt = skb_transport_header(skb) + sizeof(struct icmp6hdr);
501 ipv6_addr_copy((struct in6_addr *)opt, target);
502 opt += sizeof(*target);
506 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr,
507 dev->addr_len, dev->type);
509 hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len,
511 csum_partial((__u8 *) hdr,
516 idev = in6_dev_get(dst->dev);
517 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
519 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
522 ICMP6MSGOUT_INC_STATS(idev, type);
523 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
526 if (likely(idev != NULL))
530 static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
531 struct in6_addr *daddr, struct in6_addr *solicited_addr,
532 int router, int solicited, int override, int inc_opt)
534 struct in6_addr tmpaddr;
535 struct inet6_ifaddr *ifp;
536 struct in6_addr *src_addr;
537 struct icmp6hdr icmp6h = {
538 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
541 /* for anycast or proxy, solicited_addr != src_addr */
542 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
544 src_addr = solicited_addr;
545 if (ifp->flags & IFA_F_OPTIMISTIC)
549 if (ipv6_dev_get_saddr(dev, daddr,
550 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
556 icmp6h.icmp6_router = router;
557 icmp6h.icmp6_solicited = solicited;
558 icmp6h.icmp6_override = override;
560 __ndisc_send(dev, neigh, daddr, src_addr,
561 &icmp6h, solicited_addr,
562 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
565 void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
566 struct in6_addr *solicit,
567 struct in6_addr *daddr, struct in6_addr *saddr)
569 struct in6_addr addr_buf;
570 struct icmp6hdr icmp6h = {
571 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
575 if (ipv6_get_lladdr(dev, &addr_buf,
576 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
581 __ndisc_send(dev, neigh, daddr, saddr,
583 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
586 void ndisc_send_rs(struct net_device *dev, struct in6_addr *saddr,
587 struct in6_addr *daddr)
589 struct icmp6hdr icmp6h = {
590 .icmp6_type = NDISC_ROUTER_SOLICITATION,
592 int send_sllao = dev->addr_len;
594 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
596 * According to section 2.2 of RFC 4429, we must not
597 * send router solicitations with a sllao from
598 * optimistic addresses, but we may send the solicitation
599 * if we don't include the sllao. So here we check
600 * if our address is optimistic, and if so, we
601 * suppress the inclusion of the sllao.
604 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
607 if (ifp->flags & IFA_F_OPTIMISTIC) {
616 __ndisc_send(dev, NULL, daddr, saddr,
618 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
622 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
625 * "The sender MUST return an ICMP
626 * destination unreachable"
628 dst_link_failure(skb);
632 /* Called with locked neigh: either read or both */
634 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
636 struct in6_addr *saddr = NULL;
637 struct in6_addr mcaddr;
638 struct net_device *dev = neigh->dev;
639 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
640 int probes = atomic_read(&neigh->probes);
642 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
643 saddr = &ipv6_hdr(skb)->saddr;
645 if ((probes -= neigh->parms->ucast_probes) < 0) {
646 if (!(neigh->nud_state & NUD_VALID)) {
647 ND_PRINTK1(KERN_DEBUG
648 "%s(): trying to ucast probe in NUD_INVALID: "
653 ndisc_send_ns(dev, neigh, target, target, saddr);
654 } else if ((probes -= neigh->parms->app_probes) < 0) {
659 addrconf_addr_solict_mult(target, &mcaddr);
660 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
664 static void ndisc_recv_ns(struct sk_buff *skb)
666 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
667 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
668 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
670 u32 ndoptlen = skb->tail - (skb->transport_header +
671 offsetof(struct nd_msg, opt));
672 struct ndisc_options ndopts;
673 struct net_device *dev = skb->dev;
674 struct inet6_ifaddr *ifp;
675 struct inet6_dev *idev = NULL;
676 struct neighbour *neigh;
677 struct pneigh_entry *pneigh = NULL;
678 int dad = ipv6_addr_any(saddr);
682 if (ipv6_addr_is_multicast(&msg->target)) {
683 ND_PRINTK2(KERN_WARNING
684 "ICMPv6 NS: multicast target address");
690 * DAD has to be destined for solicited node multicast address.
693 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
694 daddr->s6_addr32[1] == htonl(0x00000000) &&
695 daddr->s6_addr32[2] == htonl(0x00000001) &&
696 daddr->s6_addr [12] == 0xff )) {
697 ND_PRINTK2(KERN_WARNING
698 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
702 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
703 ND_PRINTK2(KERN_WARNING
704 "ICMPv6 NS: invalid ND options\n");
708 if (ndopts.nd_opts_src_lladdr) {
709 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
711 ND_PRINTK2(KERN_WARNING
712 "ICMPv6 NS: invalid link-layer address length\n");
717 * If the IP source address is the unspecified address,
718 * there MUST NOT be source link-layer address option
722 ND_PRINTK2(KERN_WARNING
723 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
728 inc = ipv6_addr_is_multicast(daddr);
730 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
733 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
735 if (dev->type == ARPHRD_IEEE802_TR) {
736 const unsigned char *sadr;
737 sadr = skb_mac_header(skb);
738 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
739 sadr[9] == dev->dev_addr[1] &&
740 sadr[10] == dev->dev_addr[2] &&
741 sadr[11] == dev->dev_addr[3] &&
742 sadr[12] == dev->dev_addr[4] &&
743 sadr[13] == dev->dev_addr[5]) {
744 /* looped-back to us */
750 * We are colliding with another node
752 * so fail our DAD process
754 addrconf_dad_failure(ifp);
758 * This is not a dad solicitation.
759 * If we are an optimistic node,
761 * Otherwise, we should ignore it.
763 if (!(ifp->flags & IFA_F_OPTIMISTIC))
770 idev = in6_dev_get(dev);
772 /* XXX: count this drop? */
776 if (ipv6_chk_acast_addr(dev_net(dev), dev, &msg->target) ||
777 (idev->cnf.forwarding &&
778 (ipv6_devconf.proxy_ndp || idev->cnf.proxy_ndp) &&
779 (pneigh = pneigh_lookup(&nd_tbl, dev_net(dev),
780 &msg->target, dev, 0)) != NULL)) {
781 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
782 skb->pkt_type != PACKET_HOST &&
784 idev->nd_parms->proxy_delay != 0) {
786 * for anycast or proxy,
787 * sender should delay its response
788 * by a random time between 0 and
789 * MAX_ANYCAST_DELAY_TIME seconds.
790 * (RFC2461) -- yoshfuji
792 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
794 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
801 is_router = !!(pneigh ? pneigh->flags & NTF_ROUTER : idev->cnf.forwarding);
804 struct in6_addr maddr;
806 ipv6_addr_all_nodes(&maddr);
807 ndisc_send_na(dev, NULL, &maddr, &msg->target,
808 is_router, 0, (ifp != NULL), 1);
813 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
815 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
818 * update / create cache entry
819 * for the source address
821 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
822 !inc || lladdr || !dev->addr_len);
824 neigh_update(neigh, lladdr, NUD_STALE,
825 NEIGH_UPDATE_F_WEAK_OVERRIDE|
826 NEIGH_UPDATE_F_OVERRIDE);
827 if (neigh || !dev->header_ops) {
828 ndisc_send_na(dev, neigh, saddr, &msg->target,
830 1, (ifp != NULL && inc), inc);
832 neigh_release(neigh);
844 static void ndisc_recv_na(struct sk_buff *skb)
846 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
847 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
848 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
850 u32 ndoptlen = skb->tail - (skb->transport_header +
851 offsetof(struct nd_msg, opt));
852 struct ndisc_options ndopts;
853 struct net_device *dev = skb->dev;
854 struct inet6_ifaddr *ifp;
855 struct neighbour *neigh;
857 if (skb->len < sizeof(struct nd_msg)) {
858 ND_PRINTK2(KERN_WARNING
859 "ICMPv6 NA: packet too short\n");
863 if (ipv6_addr_is_multicast(&msg->target)) {
864 ND_PRINTK2(KERN_WARNING
865 "ICMPv6 NA: target address is multicast.\n");
869 if (ipv6_addr_is_multicast(daddr) &&
870 msg->icmph.icmp6_solicited) {
871 ND_PRINTK2(KERN_WARNING
872 "ICMPv6 NA: solicited NA is multicasted.\n");
876 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
877 ND_PRINTK2(KERN_WARNING
878 "ICMPv6 NS: invalid ND option\n");
881 if (ndopts.nd_opts_tgt_lladdr) {
882 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
884 ND_PRINTK2(KERN_WARNING
885 "ICMPv6 NA: invalid link-layer address length\n");
889 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
891 if (ifp->flags & IFA_F_TENTATIVE) {
892 addrconf_dad_failure(ifp);
895 /* What should we make now? The advertisement
896 is invalid, but ndisc specs say nothing
897 about it. It could be misconfiguration, or
898 an smart proxy agent tries to help us :-)
900 ND_PRINTK1(KERN_WARNING
901 "ICMPv6 NA: someone advertises our address on %s!\n",
902 ifp->idev->dev->name);
906 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
909 u8 old_flags = neigh->flags;
911 if (neigh->nud_state & NUD_FAILED)
915 * Don't update the neighbor cache entry on a proxy NA from
916 * ourselves because either the proxied node is off link or it
917 * has already sent a NA to us.
919 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
920 ipv6_devconf.forwarding && ipv6_devconf.proxy_ndp &&
921 pneigh_lookup(&nd_tbl, dev_net(dev), &msg->target, dev, 0)) {
922 /* XXX: idev->cnf.prixy_ndp */
926 neigh_update(neigh, lladdr,
927 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
928 NEIGH_UPDATE_F_WEAK_OVERRIDE|
929 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
930 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
931 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
933 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
935 * Change: router to host
938 rt = rt6_get_dflt_router(saddr, dev);
944 neigh_release(neigh);
948 static void ndisc_recv_rs(struct sk_buff *skb)
950 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
951 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
952 struct neighbour *neigh;
953 struct inet6_dev *idev;
954 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
955 struct ndisc_options ndopts;
958 if (skb->len < sizeof(*rs_msg))
961 idev = in6_dev_get(skb->dev);
964 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
968 /* Don't accept RS if we're not in router mode */
969 if (!idev->cnf.forwarding)
973 * Don't update NCE if src = ::;
974 * this implies that the source node has no ip address assigned yet.
976 if (ipv6_addr_any(saddr))
979 /* Parse ND options */
980 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
982 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
986 if (ndopts.nd_opts_src_lladdr) {
987 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
993 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
995 neigh_update(neigh, lladdr, NUD_STALE,
996 NEIGH_UPDATE_F_WEAK_OVERRIDE|
997 NEIGH_UPDATE_F_OVERRIDE|
998 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
999 neigh_release(neigh);
1005 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1007 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1008 struct sk_buff *skb;
1009 struct nlmsghdr *nlh;
1010 struct nduseroptmsg *ndmsg;
1011 struct net *net = dev_net(ra->dev);
1013 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1014 + (opt->nd_opt_len << 3));
1015 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1017 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1023 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1025 goto nla_put_failure;
1028 ndmsg = nlmsg_data(nlh);
1029 ndmsg->nduseropt_family = AF_INET6;
1030 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
1031 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1032 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1033 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1035 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1037 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1038 &ipv6_hdr(ra)->saddr);
1039 nlmsg_end(skb, nlh);
1041 err = rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL,
1052 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1055 static void ndisc_router_discovery(struct sk_buff *skb)
1057 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1058 struct neighbour *neigh = NULL;
1059 struct inet6_dev *in6_dev;
1060 struct rt6_info *rt = NULL;
1062 struct ndisc_options ndopts;
1064 unsigned int pref = 0;
1066 __u8 * opt = (__u8 *)(ra_msg + 1);
1068 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
1070 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1071 ND_PRINTK2(KERN_WARNING
1072 "ICMPv6 RA: source address is not link-local.\n");
1076 ND_PRINTK2(KERN_WARNING
1077 "ICMPv6 RA: packet too short\n");
1082 * set the RA_RECV flag in the interface
1085 in6_dev = in6_dev_get(skb->dev);
1086 if (in6_dev == NULL) {
1088 "ICMPv6 RA: can't find inet6 device for %s.\n",
1092 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {
1093 in6_dev_put(in6_dev);
1097 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1098 in6_dev_put(in6_dev);
1099 ND_PRINTK2(KERN_WARNING
1100 "ICMP6 RA: invalid ND options\n");
1104 if (in6_dev->if_flags & IF_RS_SENT) {
1106 * flag that an RA was received after an RS was sent
1107 * out on this interface.
1109 in6_dev->if_flags |= IF_RA_RCVD;
1113 * Remember the managed/otherconf flags from most recently
1114 * received RA message (RFC 2462) -- yoshfuji
1116 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1118 (ra_msg->icmph.icmp6_addrconf_managed ?
1119 IF_RA_MANAGED : 0) |
1120 (ra_msg->icmph.icmp6_addrconf_other ?
1121 IF_RA_OTHERCONF : 0);
1123 if (!in6_dev->cnf.accept_ra_defrtr)
1126 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1128 #ifdef CONFIG_IPV6_ROUTER_PREF
1129 pref = ra_msg->icmph.icmp6_router_pref;
1130 /* 10b is handled as if it were 00b (medium) */
1131 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1132 !in6_dev->cnf.accept_ra_rtr_pref)
1133 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1136 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1139 neigh = rt->rt6i_nexthop;
1141 if (rt && lifetime == 0) {
1147 if (rt == NULL && lifetime) {
1148 ND_PRINTK3(KERN_DEBUG
1149 "ICMPv6 RA: adding default router.\n");
1151 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1154 "ICMPv6 RA: %s() failed to add default route.\n",
1156 in6_dev_put(in6_dev);
1160 neigh = rt->rt6i_nexthop;
1161 if (neigh == NULL) {
1163 "ICMPv6 RA: %s() got default router without neighbour.\n",
1165 dst_release(&rt->u.dst);
1166 in6_dev_put(in6_dev);
1169 neigh->flags |= NTF_ROUTER;
1171 rt->rt6i_flags |= (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1175 rt->rt6i_expires = jiffies + (HZ * lifetime);
1177 if (ra_msg->icmph.icmp6_hop_limit) {
1178 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1180 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;
1186 * Update Reachable Time and Retrans Timer
1189 if (in6_dev->nd_parms) {
1190 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1192 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1193 rtime = (rtime*HZ)/1000;
1196 in6_dev->nd_parms->retrans_time = rtime;
1197 in6_dev->tstamp = jiffies;
1198 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1201 rtime = ntohl(ra_msg->reachable_time);
1202 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1203 rtime = (rtime*HZ)/1000;
1208 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1209 in6_dev->nd_parms->base_reachable_time = rtime;
1210 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1211 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1212 in6_dev->tstamp = jiffies;
1213 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1223 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1227 if (ndopts.nd_opts_src_lladdr) {
1228 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1231 ND_PRINTK2(KERN_WARNING
1232 "ICMPv6 RA: invalid link-layer address length\n");
1236 neigh_update(neigh, lladdr, NUD_STALE,
1237 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1238 NEIGH_UPDATE_F_OVERRIDE|
1239 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1240 NEIGH_UPDATE_F_ISROUTER);
1243 #ifdef CONFIG_IPV6_ROUTE_INFO
1244 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1245 struct nd_opt_hdr *p;
1246 for (p = ndopts.nd_opts_ri;
1248 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1249 if (((struct route_info *)p)->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1251 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1252 &ipv6_hdr(skb)->saddr);
1257 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1258 struct nd_opt_hdr *p;
1259 for (p = ndopts.nd_opts_pi;
1261 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1262 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1266 if (ndopts.nd_opts_mtu) {
1270 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1273 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1274 ND_PRINTK2(KERN_WARNING
1275 "ICMPv6 RA: invalid mtu: %d\n",
1277 } else if (in6_dev->cnf.mtu6 != mtu) {
1278 in6_dev->cnf.mtu6 = mtu;
1281 rt->u.dst.metrics[RTAX_MTU-1] = mtu;
1283 rt6_mtu_change(skb->dev, mtu);
1287 if (ndopts.nd_useropts) {
1288 struct nd_opt_hdr *p;
1289 for (p = ndopts.nd_useropts;
1291 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1292 ndisc_ra_useropt(skb, p);
1296 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1297 ND_PRINTK2(KERN_WARNING
1298 "ICMPv6 RA: invalid RA options");
1302 dst_release(&rt->u.dst);
1304 neigh_release(neigh);
1305 in6_dev_put(in6_dev);
1308 static void ndisc_redirect_rcv(struct sk_buff *skb)
1310 struct inet6_dev *in6_dev;
1311 struct icmp6hdr *icmph;
1312 struct in6_addr *dest;
1313 struct in6_addr *target; /* new first hop to destination */
1314 struct neighbour *neigh;
1316 struct ndisc_options ndopts;
1320 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1321 ND_PRINTK2(KERN_WARNING
1322 "ICMPv6 Redirect: source address is not link-local.\n");
1326 optlen = skb->tail - skb->transport_header;
1327 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1330 ND_PRINTK2(KERN_WARNING
1331 "ICMPv6 Redirect: packet too short\n");
1335 icmph = icmp6_hdr(skb);
1336 target = (struct in6_addr *) (icmph + 1);
1339 if (ipv6_addr_is_multicast(dest)) {
1340 ND_PRINTK2(KERN_WARNING
1341 "ICMPv6 Redirect: destination address is multicast.\n");
1345 if (ipv6_addr_equal(dest, target)) {
1347 } else if (ipv6_addr_type(target) !=
1348 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1349 ND_PRINTK2(KERN_WARNING
1350 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1354 in6_dev = in6_dev_get(skb->dev);
1357 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1358 in6_dev_put(in6_dev);
1363 * The IP source address of the Redirect MUST be the same as the current
1364 * first-hop router for the specified ICMP Destination Address.
1367 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1368 ND_PRINTK2(KERN_WARNING
1369 "ICMPv6 Redirect: invalid ND options\n");
1370 in6_dev_put(in6_dev);
1373 if (ndopts.nd_opts_tgt_lladdr) {
1374 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1377 ND_PRINTK2(KERN_WARNING
1378 "ICMPv6 Redirect: invalid link-layer address length\n");
1379 in6_dev_put(in6_dev);
1384 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1386 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1387 &ipv6_hdr(skb)->saddr, neigh, lladdr,
1389 neigh_release(neigh);
1391 in6_dev_put(in6_dev);
1394 void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
1395 struct in6_addr *target)
1397 struct net_device *dev = skb->dev;
1398 struct net *net = dev_net(dev);
1399 struct sock *sk = net->ipv6.ndisc_sk;
1400 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1401 struct sk_buff *buff;
1402 struct icmp6hdr *icmph;
1403 struct in6_addr saddr_buf;
1404 struct in6_addr *addrp;
1405 struct rt6_info *rt;
1406 struct dst_entry *dst;
1407 struct inet6_dev *idev;
1412 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1414 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1415 ND_PRINTK2(KERN_WARNING
1416 "ICMPv6 Redirect: no link-local address on %s\n",
1421 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1422 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1423 ND_PRINTK2(KERN_WARNING
1424 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1428 icmpv6_flow_init(sk, &fl, NDISC_REDIRECT,
1429 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
1431 dst = ip6_route_output(net, NULL, &fl);
1435 err = xfrm_lookup(&dst, &fl, NULL, 0);
1439 rt = (struct rt6_info *) dst;
1441 if (rt->rt6i_flags & RTF_GATEWAY) {
1442 ND_PRINTK2(KERN_WARNING
1443 "ICMPv6 Redirect: destination is not a neighbour.\n");
1447 if (!xrlim_allow(dst, 1*HZ)) {
1452 if (dev->addr_len) {
1453 read_lock_bh(&neigh->lock);
1454 if (neigh->nud_state & NUD_VALID) {
1455 memcpy(ha_buf, neigh->ha, dev->addr_len);
1456 read_unlock_bh(&neigh->lock);
1458 len += ndisc_opt_addr_space(dev);
1460 read_unlock_bh(&neigh->lock);
1463 rd_len = min_t(unsigned int,
1464 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1468 buff = sock_alloc_send_skb(sk,
1469 (MAX_HEADER + sizeof(struct ipv6hdr) +
1470 len + LL_RESERVED_SPACE(dev)),
1474 "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
1480 skb_reserve(buff, LL_RESERVED_SPACE(dev));
1481 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
1482 IPPROTO_ICMPV6, len);
1484 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
1486 icmph = icmp6_hdr(buff);
1488 memset(icmph, 0, sizeof(struct icmp6hdr));
1489 icmph->icmp6_type = NDISC_REDIRECT;
1492 * copy target and destination addresses
1495 addrp = (struct in6_addr *)(icmph + 1);
1496 ipv6_addr_copy(addrp, target);
1498 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
1500 opt = (u8*) (addrp + 1);
1503 * include target_address option
1507 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1508 dev->addr_len, dev->type);
1511 * build redirect option and copy skb over to the new packet.
1515 *(opt++) = ND_OPT_REDIRECT_HDR;
1516 *(opt++) = (rd_len >> 3);
1519 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
1521 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
1522 len, IPPROTO_ICMPV6,
1523 csum_partial((u8 *) icmph, len, 0));
1526 idev = in6_dev_get(dst->dev);
1527 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
1528 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1531 ICMP6MSGOUT_INC_STATS(idev, NDISC_REDIRECT);
1532 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
1535 if (likely(idev != NULL))
1539 static void pndisc_redo(struct sk_buff *skb)
1545 int ndisc_rcv(struct sk_buff *skb)
1549 if (!pskb_may_pull(skb, skb->len))
1552 msg = (struct nd_msg *)skb_transport_header(skb);
1554 __skb_push(skb, skb->data - skb_transport_header(skb));
1556 if (ipv6_hdr(skb)->hop_limit != 255) {
1557 ND_PRINTK2(KERN_WARNING
1558 "ICMPv6 NDISC: invalid hop-limit: %d\n",
1559 ipv6_hdr(skb)->hop_limit);
1563 if (msg->icmph.icmp6_code != 0) {
1564 ND_PRINTK2(KERN_WARNING
1565 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1566 msg->icmph.icmp6_code);
1570 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1572 switch (msg->icmph.icmp6_type) {
1573 case NDISC_NEIGHBOUR_SOLICITATION:
1577 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1581 case NDISC_ROUTER_SOLICITATION:
1585 case NDISC_ROUTER_ADVERTISEMENT:
1586 ndisc_router_discovery(skb);
1589 case NDISC_REDIRECT:
1590 ndisc_redirect_rcv(skb);
1597 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1599 struct net_device *dev = ptr;
1600 struct net *net = dev_net(dev);
1603 case NETDEV_CHANGEADDR:
1604 neigh_changeaddr(&nd_tbl, dev);
1605 fib6_run_gc(~0UL, net);
1608 neigh_ifdown(&nd_tbl, dev);
1609 fib6_run_gc(~0UL, net);
1618 static struct notifier_block ndisc_netdev_notifier = {
1619 .notifier_call = ndisc_netdev_event,
1622 #ifdef CONFIG_SYSCTL
1623 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1624 const char *func, const char *dev_name)
1626 static char warncomm[TASK_COMM_LEN];
1628 if (strcmp(warncomm, current->comm) && warned < 5) {
1629 strcpy(warncomm, current->comm);
1631 "process `%s' is using deprecated sysctl (%s) "
1632 "net.ipv6.neigh.%s.%s; "
1633 "Use net.ipv6.neigh.%s.%s_ms "
1636 dev_name, ctl->procname,
1637 dev_name, ctl->procname);
1642 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)
1644 struct net_device *dev = ctl->extra1;
1645 struct inet6_dev *idev;
1648 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1649 (strcmp(ctl->procname, "base_reachable_time") == 0))
1650 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1652 if (strcmp(ctl->procname, "retrans_time") == 0)
1653 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1655 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1656 ret = proc_dointvec_jiffies(ctl, write,
1657 filp, buffer, lenp, ppos);
1659 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1660 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1661 ret = proc_dointvec_ms_jiffies(ctl, write,
1662 filp, buffer, lenp, ppos);
1666 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1667 if (ctl->data == &idev->nd_parms->base_reachable_time)
1668 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1669 idev->tstamp = jiffies;
1670 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1676 static int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl, int __user *name,
1677 int nlen, void __user *oldval,
1678 size_t __user *oldlenp,
1679 void __user *newval, size_t newlen)
1681 struct net_device *dev = ctl->extra1;
1682 struct inet6_dev *idev;
1685 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1686 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1687 ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");
1689 switch (ctl->ctl_name) {
1690 case NET_NEIGH_REACHABLE_TIME:
1691 ret = sysctl_jiffies(ctl, name, nlen,
1692 oldval, oldlenp, newval, newlen);
1694 case NET_NEIGH_RETRANS_TIME_MS:
1695 case NET_NEIGH_REACHABLE_TIME_MS:
1696 ret = sysctl_ms_jiffies(ctl, name, nlen,
1697 oldval, oldlenp, newval, newlen);
1703 if (newval && newlen && ret > 0 &&
1704 dev && (idev = in6_dev_get(dev)) != NULL) {
1705 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1706 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1707 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1708 idev->tstamp = jiffies;
1709 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1718 static int ndisc_net_init(struct net *net)
1720 struct socket *sock;
1721 struct ipv6_pinfo *np;
1725 err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6, &sock);
1728 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1733 net->ipv6.ndisc_sk = sk = sock->sk;
1734 sk_change_net(sk, net);
1737 sk->sk_allocation = GFP_ATOMIC;
1738 np->hop_limit = 255;
1739 /* Do not loopback ndisc messages */
1741 sk->sk_prot->unhash(sk);
1746 static void ndisc_net_exit(struct net *net)
1748 sk_release_kernel(net->ipv6.ndisc_sk);
1751 static struct pernet_operations ndisc_net_ops = {
1752 .init = ndisc_net_init,
1753 .exit = ndisc_net_exit,
1756 int __init ndisc_init(void)
1760 err = register_pernet_subsys(&ndisc_net_ops);
1764 * Initialize the neighbour table
1766 neigh_table_init(&nd_tbl);
1768 #ifdef CONFIG_SYSCTL
1769 err = neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6,
1770 NET_IPV6_NEIGH, "ipv6",
1771 &ndisc_ifinfo_sysctl_change,
1772 &ndisc_ifinfo_sysctl_strategy);
1774 goto out_unregister_pernet;
1776 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1778 goto out_unregister_sysctl;
1782 out_unregister_sysctl:
1783 #ifdef CONFIG_SYSCTL
1784 neigh_sysctl_unregister(&nd_tbl.parms);
1785 out_unregister_pernet:
1787 unregister_pernet_subsys(&ndisc_net_ops);
1791 void ndisc_cleanup(void)
1793 unregister_netdevice_notifier(&ndisc_netdev_notifier);
1794 #ifdef CONFIG_SYSCTL
1795 neigh_sysctl_unregister(&nd_tbl.parms);
1797 neigh_table_clear(&nd_tbl);
1798 unregister_pernet_subsys(&ndisc_net_ops);