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 * Lars Fenneberg : fixed MTU setting on receipt
21 * Janos Farkas : kmalloc failure checks
22 * Alexey Kuznetsov : state machine reworked
23 * and moved to net/core.
24 * Pekka Savola : RFC2461 validation
25 * YOSHIFUJI Hideaki @USAGI : Verify ND options properly
28 /* Set to 3 to get tracing... */
31 #define ND_PRINTK(fmt, args...) do { if (net_ratelimit()) { printk(fmt, ## args); } } while(0)
32 #define ND_NOPRINTK(x...) do { ; } while(0)
33 #define ND_PRINTK0 ND_PRINTK
34 #define ND_PRINTK1 ND_NOPRINTK
35 #define ND_PRINTK2 ND_NOPRINTK
36 #define ND_PRINTK3 ND_NOPRINTK
39 #define ND_PRINTK1 ND_PRINTK
43 #define ND_PRINTK2 ND_PRINTK
47 #define ND_PRINTK3 ND_PRINTK
50 #include <linux/module.h>
51 #include <linux/errno.h>
52 #include <linux/types.h>
53 #include <linux/socket.h>
54 #include <linux/sockios.h>
55 #include <linux/sched.h>
56 #include <linux/net.h>
57 #include <linux/in6.h>
58 #include <linux/route.h>
59 #include <linux/init.h>
60 #include <linux/rcupdate.h>
62 #include <linux/sysctl.h>
65 #include <linux/if_addr.h>
66 #include <linux/if_arp.h>
67 #include <linux/ipv6.h>
68 #include <linux/icmpv6.h>
69 #include <linux/jhash.h>
75 #include <net/protocol.h>
76 #include <net/ndisc.h>
77 #include <net/ip6_route.h>
78 #include <net/addrconf.h>
82 #include <net/ip6_checksum.h>
83 #include <linux/proc_fs.h>
85 #include <linux/netfilter.h>
86 #include <linux/netfilter_ipv6.h>
88 static struct socket *ndisc_socket;
90 static u32 ndisc_hash(const void *pkey, const struct net_device *dev);
91 static int ndisc_constructor(struct neighbour *neigh);
92 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
93 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
94 static int pndisc_constructor(struct pneigh_entry *n);
95 static void pndisc_destructor(struct pneigh_entry *n);
96 static void pndisc_redo(struct sk_buff *skb);
98 static struct neigh_ops ndisc_generic_ops = {
100 .solicit = ndisc_solicit,
101 .error_report = ndisc_error_report,
102 .output = neigh_resolve_output,
103 .connected_output = neigh_connected_output,
104 .hh_output = dev_queue_xmit,
105 .queue_xmit = dev_queue_xmit,
108 static struct neigh_ops ndisc_hh_ops = {
110 .solicit = ndisc_solicit,
111 .error_report = ndisc_error_report,
112 .output = neigh_resolve_output,
113 .connected_output = neigh_resolve_output,
114 .hh_output = dev_queue_xmit,
115 .queue_xmit = dev_queue_xmit,
119 static struct neigh_ops ndisc_direct_ops = {
121 .output = dev_queue_xmit,
122 .connected_output = dev_queue_xmit,
123 .hh_output = dev_queue_xmit,
124 .queue_xmit = dev_queue_xmit,
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 = 30 * HZ,
140 .retrans_time = 1 * HZ,
141 .gc_staletime = 60 * HZ,
142 .reachable_time = 30 * HZ,
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;
166 #define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR]
167 #define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR]
168 #define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO]
169 #define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END]
170 #define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR]
171 #define nd_opts_mtu nd_opt_array[ND_OPT_MTU]
173 #define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
176 * Return the padding between the option length and the start of the
177 * link addr. Currently only IP-over-InfiniBand needs this, although
178 * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may
179 * also need a pad of 2.
181 static int ndisc_addr_option_pad(unsigned short type)
184 case ARPHRD_INFINIBAND: return 2;
189 static inline int ndisc_opt_addr_space(struct net_device *dev)
191 return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type));
194 static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len,
195 unsigned short addr_type)
197 int space = NDISC_OPT_SPACE(data_len);
198 int pad = ndisc_addr_option_pad(addr_type);
203 memset(opt + 2, 0, pad);
207 memcpy(opt+2, data, data_len);
210 if ((space -= data_len) > 0)
211 memset(opt, 0, space);
215 static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
216 struct nd_opt_hdr *end)
219 if (!cur || !end || cur >= end)
221 type = cur->nd_opt_type;
223 cur = ((void *)cur) + (cur->nd_opt_len << 3);
224 } while(cur < end && cur->nd_opt_type != type);
225 return (cur <= end && cur->nd_opt_type == type ? cur : NULL);
228 static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
229 struct ndisc_options *ndopts)
231 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
233 if (!nd_opt || opt_len < 0 || !ndopts)
235 memset(ndopts, 0, sizeof(*ndopts));
238 if (opt_len < sizeof(struct nd_opt_hdr))
240 l = nd_opt->nd_opt_len << 3;
241 if (opt_len < l || l == 0)
243 switch (nd_opt->nd_opt_type) {
244 case ND_OPT_SOURCE_LL_ADDR:
245 case ND_OPT_TARGET_LL_ADDR:
247 case ND_OPT_REDIRECT_HDR:
248 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
249 ND_PRINTK2(KERN_WARNING
250 "%s(): duplicated ND6 option found: type=%d\n",
252 nd_opt->nd_opt_type);
254 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
257 case ND_OPT_PREFIX_INFO:
258 ndopts->nd_opts_pi_end = nd_opt;
259 if (ndopts->nd_opt_array[nd_opt->nd_opt_type] == 0)
260 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
262 #ifdef CONFIG_IPV6_ROUTE_INFO
263 case ND_OPT_ROUTE_INFO:
264 ndopts->nd_opts_ri_end = nd_opt;
265 if (!ndopts->nd_opts_ri)
266 ndopts->nd_opts_ri = nd_opt;
271 * Unknown options must be silently ignored,
272 * to accommodate future extension to the protocol.
274 ND_PRINTK2(KERN_NOTICE
275 "%s(): ignored unsupported option; type=%d, len=%d\n",
277 nd_opt->nd_opt_type, nd_opt->nd_opt_len);
280 nd_opt = ((void *)nd_opt) + l;
285 static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p,
286 struct net_device *dev)
288 u8 *lladdr = (u8 *)(p + 1);
289 int lladdrlen = p->nd_opt_len << 3;
290 int prepad = ndisc_addr_option_pad(dev->type);
291 if (lladdrlen != NDISC_OPT_SPACE(dev->addr_len + prepad))
293 return (lladdr + prepad);
296 int ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
300 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
302 ipv6_eth_mc_map(addr, buf);
304 case ARPHRD_IEEE802_TR:
305 ipv6_tr_mc_map(addr,buf);
308 ipv6_arcnet_mc_map(addr, buf);
310 case ARPHRD_INFINIBAND:
311 ipv6_ib_mc_map(addr, buf);
315 memcpy(buf, dev->broadcast, dev->addr_len);
322 static u32 ndisc_hash(const void *pkey, const struct net_device *dev)
324 const u32 *p32 = pkey;
328 for (i = 0; i < (sizeof(struct in6_addr) / sizeof(u32)); i++)
331 return jhash_2words(addr_hash, dev->ifindex, nd_tbl.hash_rnd);
334 static int ndisc_constructor(struct neighbour *neigh)
336 struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;
337 struct net_device *dev = neigh->dev;
338 struct inet6_dev *in6_dev;
339 struct neigh_parms *parms;
340 int is_multicast = ipv6_addr_is_multicast(addr);
343 in6_dev = in6_dev_get(dev);
344 if (in6_dev == NULL) {
349 parms = in6_dev->nd_parms;
350 __neigh_parms_put(neigh->parms);
351 neigh->parms = neigh_parms_clone(parms);
354 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
355 if (dev->hard_header == NULL) {
356 neigh->nud_state = NUD_NOARP;
357 neigh->ops = &ndisc_direct_ops;
358 neigh->output = neigh->ops->queue_xmit;
361 neigh->nud_state = NUD_NOARP;
362 ndisc_mc_map(addr, neigh->ha, dev, 1);
363 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
364 neigh->nud_state = NUD_NOARP;
365 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
366 if (dev->flags&IFF_LOOPBACK)
367 neigh->type = RTN_LOCAL;
368 } else if (dev->flags&IFF_POINTOPOINT) {
369 neigh->nud_state = NUD_NOARP;
370 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
372 if (dev->hard_header_cache)
373 neigh->ops = &ndisc_hh_ops;
375 neigh->ops = &ndisc_generic_ops;
376 if (neigh->nud_state&NUD_VALID)
377 neigh->output = neigh->ops->connected_output;
379 neigh->output = neigh->ops->output;
381 in6_dev_put(in6_dev);
385 static int pndisc_constructor(struct pneigh_entry *n)
387 struct in6_addr *addr = (struct in6_addr*)&n->key;
388 struct in6_addr maddr;
389 struct net_device *dev = n->dev;
391 if (dev == NULL || __in6_dev_get(dev) == NULL)
393 addrconf_addr_solict_mult(addr, &maddr);
394 ipv6_dev_mc_inc(dev, &maddr);
398 static void pndisc_destructor(struct pneigh_entry *n)
400 struct in6_addr *addr = (struct in6_addr*)&n->key;
401 struct in6_addr maddr;
402 struct net_device *dev = n->dev;
404 if (dev == NULL || __in6_dev_get(dev) == NULL)
406 addrconf_addr_solict_mult(addr, &maddr);
407 ipv6_dev_mc_dec(dev, &maddr);
411 * Send a Neighbour Advertisement
414 static inline void ndisc_flow_init(struct flowi *fl, u8 type,
415 struct in6_addr *saddr, struct in6_addr *daddr,
418 memset(fl, 0, sizeof(*fl));
419 ipv6_addr_copy(&fl->fl6_src, saddr);
420 ipv6_addr_copy(&fl->fl6_dst, daddr);
421 fl->proto = IPPROTO_ICMPV6;
422 fl->fl_icmp_type = type;
423 fl->fl_icmp_code = 0;
425 security_sk_classify_flow(ndisc_socket->sk, fl);
428 static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
429 struct in6_addr *daddr, struct in6_addr *solicited_addr,
430 int router, int solicited, int override, int inc_opt)
432 struct in6_addr tmpaddr;
433 struct inet6_ifaddr *ifp;
434 struct inet6_dev *idev;
436 struct dst_entry* dst;
437 struct sock *sk = ndisc_socket->sk;
438 struct in6_addr *src_addr;
444 len = sizeof(struct icmp6hdr) + sizeof(struct in6_addr);
446 /* for anycast or proxy, solicited_addr != src_addr */
447 ifp = ipv6_get_ifaddr(solicited_addr, dev, 1);
449 src_addr = solicited_addr;
452 if (ipv6_dev_get_saddr(dev, daddr, &tmpaddr))
457 ndisc_flow_init(&fl, NDISC_NEIGHBOUR_ADVERTISEMENT, src_addr, daddr,
460 dst = ndisc_dst_alloc(dev, neigh, daddr, ip6_output);
464 err = xfrm_lookup(&dst, &fl, NULL, 0);
470 len += ndisc_opt_addr_space(dev);
475 skb = sock_alloc_send_skb(sk, MAX_HEADER + len + LL_RESERVED_SPACE(dev),
480 "ICMPv6 NA: %s() failed to allocate an skb.\n",
486 skb_reserve(skb, LL_RESERVED_SPACE(dev));
487 ip6_nd_hdr(sk, skb, dev, src_addr, daddr, IPPROTO_ICMPV6, len);
489 msg = (struct nd_msg *)skb_put(skb, len);
490 skb->h.raw = (unsigned char*)msg;
492 msg->icmph.icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT;
493 msg->icmph.icmp6_code = 0;
494 msg->icmph.icmp6_cksum = 0;
496 msg->icmph.icmp6_unused = 0;
497 msg->icmph.icmp6_router = router;
498 msg->icmph.icmp6_solicited = solicited;
499 msg->icmph.icmp6_override = !!override;
501 /* Set the target address. */
502 ipv6_addr_copy(&msg->target, solicited_addr);
505 ndisc_fill_addr_option(msg->opt, ND_OPT_TARGET_LL_ADDR, dev->dev_addr,
506 dev->addr_len, dev->type);
509 msg->icmph.icmp6_cksum = csum_ipv6_magic(src_addr, daddr, len,
511 csum_partial((__u8 *) msg,
515 idev = in6_dev_get(dst->dev);
516 IP6_INC_STATS(IPSTATS_MIB_OUTREQUESTS);
517 err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, dst_output);
519 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTNEIGHBORADVERTISEMENTS);
520 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
523 if (likely(idev != NULL))
527 void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
528 struct in6_addr *solicit,
529 struct in6_addr *daddr, struct in6_addr *saddr)
532 struct dst_entry* dst;
533 struct inet6_dev *idev;
534 struct sock *sk = ndisc_socket->sk;
537 struct in6_addr addr_buf;
543 if (ipv6_get_lladdr(dev, &addr_buf))
548 ndisc_flow_init(&fl, NDISC_NEIGHBOUR_SOLICITATION, saddr, daddr,
551 dst = ndisc_dst_alloc(dev, neigh, daddr, ip6_output);
555 err = xfrm_lookup(&dst, &fl, NULL, 0);
559 len = sizeof(struct icmp6hdr) + sizeof(struct in6_addr);
560 send_llinfo = dev->addr_len && !ipv6_addr_any(saddr);
562 len += ndisc_opt_addr_space(dev);
564 skb = sock_alloc_send_skb(sk, MAX_HEADER + len + LL_RESERVED_SPACE(dev),
568 "ICMPv6 NA: %s() failed to allocate an skb.\n",
574 skb_reserve(skb, LL_RESERVED_SPACE(dev));
575 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
577 msg = (struct nd_msg *)skb_put(skb, len);
578 skb->h.raw = (unsigned char*)msg;
579 msg->icmph.icmp6_type = NDISC_NEIGHBOUR_SOLICITATION;
580 msg->icmph.icmp6_code = 0;
581 msg->icmph.icmp6_cksum = 0;
582 msg->icmph.icmp6_unused = 0;
584 /* Set the target address. */
585 ipv6_addr_copy(&msg->target, solicit);
588 ndisc_fill_addr_option(msg->opt, ND_OPT_SOURCE_LL_ADDR, dev->dev_addr,
589 dev->addr_len, dev->type);
592 msg->icmph.icmp6_cksum = csum_ipv6_magic(&skb->nh.ipv6h->saddr,
595 csum_partial((__u8 *) msg,
599 idev = in6_dev_get(dst->dev);
600 IP6_INC_STATS(IPSTATS_MIB_OUTREQUESTS);
601 err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, dst_output);
603 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTNEIGHBORSOLICITS);
604 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
607 if (likely(idev != NULL))
611 void ndisc_send_rs(struct net_device *dev, struct in6_addr *saddr,
612 struct in6_addr *daddr)
615 struct dst_entry* dst;
616 struct inet6_dev *idev;
617 struct sock *sk = ndisc_socket->sk;
619 struct icmp6hdr *hdr;
624 ndisc_flow_init(&fl, NDISC_ROUTER_SOLICITATION, saddr, daddr,
627 dst = ndisc_dst_alloc(dev, NULL, daddr, ip6_output);
631 err = xfrm_lookup(&dst, &fl, NULL, 0);
635 len = sizeof(struct icmp6hdr);
637 len += ndisc_opt_addr_space(dev);
639 skb = sock_alloc_send_skb(sk, MAX_HEADER + len + LL_RESERVED_SPACE(dev),
643 "ICMPv6 RS: %s() failed to allocate an skb.\n",
649 skb_reserve(skb, LL_RESERVED_SPACE(dev));
650 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
652 hdr = (struct icmp6hdr *)skb_put(skb, len);
653 skb->h.raw = (unsigned char*)hdr;
654 hdr->icmp6_type = NDISC_ROUTER_SOLICITATION;
656 hdr->icmp6_cksum = 0;
657 hdr->icmp6_unused = 0;
659 opt = (u8*) (hdr + 1);
662 ndisc_fill_addr_option(opt, ND_OPT_SOURCE_LL_ADDR, dev->dev_addr,
663 dev->addr_len, dev->type);
666 hdr->icmp6_cksum = csum_ipv6_magic(&skb->nh.ipv6h->saddr, daddr, len,
668 csum_partial((__u8 *) hdr, len, 0));
672 idev = in6_dev_get(dst->dev);
673 IP6_INC_STATS(IPSTATS_MIB_OUTREQUESTS);
674 err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, dst_output);
676 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTROUTERSOLICITS);
677 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
680 if (likely(idev != NULL))
685 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
688 * "The sender MUST return an ICMP
689 * destination unreachable"
691 dst_link_failure(skb);
695 /* Called with locked neigh: either read or both */
697 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
699 struct in6_addr *saddr = NULL;
700 struct in6_addr mcaddr;
701 struct net_device *dev = neigh->dev;
702 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
703 int probes = atomic_read(&neigh->probes);
705 if (skb && ipv6_chk_addr(&skb->nh.ipv6h->saddr, dev, 1))
706 saddr = &skb->nh.ipv6h->saddr;
708 if ((probes -= neigh->parms->ucast_probes) < 0) {
709 if (!(neigh->nud_state & NUD_VALID)) {
710 ND_PRINTK1(KERN_DEBUG
711 "%s(): trying to ucast probe in NUD_INVALID: "
716 ndisc_send_ns(dev, neigh, target, target, saddr);
717 } else if ((probes -= neigh->parms->app_probes) < 0) {
722 addrconf_addr_solict_mult(target, &mcaddr);
723 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
727 static void ndisc_recv_ns(struct sk_buff *skb)
729 struct nd_msg *msg = (struct nd_msg *)skb->h.raw;
730 struct in6_addr *saddr = &skb->nh.ipv6h->saddr;
731 struct in6_addr *daddr = &skb->nh.ipv6h->daddr;
733 u32 ndoptlen = skb->tail - msg->opt;
734 struct ndisc_options ndopts;
735 struct net_device *dev = skb->dev;
736 struct inet6_ifaddr *ifp;
737 struct inet6_dev *idev = NULL;
738 struct neighbour *neigh;
739 struct pneigh_entry *pneigh = NULL;
740 int dad = ipv6_addr_any(saddr);
744 if (ipv6_addr_is_multicast(&msg->target)) {
745 ND_PRINTK2(KERN_WARNING
746 "ICMPv6 NS: multicast target address");
752 * DAD has to be destined for solicited node multicast address.
755 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
756 daddr->s6_addr32[1] == htonl(0x00000000) &&
757 daddr->s6_addr32[2] == htonl(0x00000001) &&
758 daddr->s6_addr [12] == 0xff )) {
759 ND_PRINTK2(KERN_WARNING
760 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
764 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
765 ND_PRINTK2(KERN_WARNING
766 "ICMPv6 NS: invalid ND options\n");
770 if (ndopts.nd_opts_src_lladdr) {
771 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
773 ND_PRINTK2(KERN_WARNING
774 "ICMPv6 NS: invalid link-layer address length\n");
779 * If the IP source address is the unspecified address,
780 * there MUST NOT be source link-layer address option
784 ND_PRINTK2(KERN_WARNING
785 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
790 inc = ipv6_addr_is_multicast(daddr);
792 if ((ifp = ipv6_get_ifaddr(&msg->target, dev, 1)) != NULL) {
793 if (ifp->flags & IFA_F_TENTATIVE) {
794 /* Address is tentative. If the source
795 is unspecified address, it is someone
796 does DAD, otherwise we ignore solicitations
797 until DAD timer expires.
801 if (dev->type == ARPHRD_IEEE802_TR) {
802 unsigned char *sadr = skb->mac.raw;
803 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
804 sadr[9] == dev->dev_addr[1] &&
805 sadr[10] == dev->dev_addr[2] &&
806 sadr[11] == dev->dev_addr[3] &&
807 sadr[12] == dev->dev_addr[4] &&
808 sadr[13] == dev->dev_addr[5]) {
809 /* looped-back to us */
813 addrconf_dad_failure(ifp);
819 idev = in6_dev_get(dev);
821 /* XXX: count this drop? */
825 if (ipv6_chk_acast_addr(dev, &msg->target) ||
826 (idev->cnf.forwarding &&
827 (pneigh = pneigh_lookup(&nd_tbl,
828 &msg->target, dev, 0)) != NULL)) {
829 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
830 skb->pkt_type != PACKET_HOST &&
832 idev->nd_parms->proxy_delay != 0) {
834 * for anycast or proxy,
835 * sender should delay its response
836 * by a random time between 0 and
837 * MAX_ANYCAST_DELAY_TIME seconds.
838 * (RFC2461) -- yoshfuji
840 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
842 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
850 is_router = pneigh->flags & NTF_ROUTER;
852 is_router = idev->cnf.forwarding;
855 struct in6_addr maddr;
857 ipv6_addr_all_nodes(&maddr);
858 ndisc_send_na(dev, NULL, &maddr, &msg->target,
859 is_router, 0, (ifp != NULL), 1);
864 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
866 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
869 * update / create cache entry
870 * for the source address
872 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
873 !inc || lladdr || !dev->addr_len);
875 neigh_update(neigh, lladdr, NUD_STALE,
876 NEIGH_UPDATE_F_WEAK_OVERRIDE|
877 NEIGH_UPDATE_F_OVERRIDE);
878 if (neigh || !dev->hard_header) {
879 ndisc_send_na(dev, neigh, saddr, &msg->target,
881 1, (ifp != NULL && inc), inc);
883 neigh_release(neigh);
895 static void ndisc_recv_na(struct sk_buff *skb)
897 struct nd_msg *msg = (struct nd_msg *)skb->h.raw;
898 struct in6_addr *saddr = &skb->nh.ipv6h->saddr;
899 struct in6_addr *daddr = &skb->nh.ipv6h->daddr;
901 u32 ndoptlen = skb->tail - msg->opt;
902 struct ndisc_options ndopts;
903 struct net_device *dev = skb->dev;
904 struct inet6_ifaddr *ifp;
905 struct neighbour *neigh;
907 if (skb->len < sizeof(struct nd_msg)) {
908 ND_PRINTK2(KERN_WARNING
909 "ICMPv6 NA: packet too short\n");
913 if (ipv6_addr_is_multicast(&msg->target)) {
914 ND_PRINTK2(KERN_WARNING
915 "ICMPv6 NA: target address is multicast.\n");
919 if (ipv6_addr_is_multicast(daddr) &&
920 msg->icmph.icmp6_solicited) {
921 ND_PRINTK2(KERN_WARNING
922 "ICMPv6 NA: solicited NA is multicasted.\n");
926 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
927 ND_PRINTK2(KERN_WARNING
928 "ICMPv6 NS: invalid ND option\n");
931 if (ndopts.nd_opts_tgt_lladdr) {
932 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
934 ND_PRINTK2(KERN_WARNING
935 "ICMPv6 NA: invalid link-layer address length\n");
939 if ((ifp = ipv6_get_ifaddr(&msg->target, dev, 1))) {
940 if (ifp->flags & IFA_F_TENTATIVE) {
941 addrconf_dad_failure(ifp);
944 /* What should we make now? The advertisement
945 is invalid, but ndisc specs say nothing
946 about it. It could be misconfiguration, or
947 an smart proxy agent tries to help us :-)
949 ND_PRINTK1(KERN_WARNING
950 "ICMPv6 NA: someone advertises our address on %s!\n",
951 ifp->idev->dev->name);
955 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
958 u8 old_flags = neigh->flags;
960 if (neigh->nud_state & NUD_FAILED)
964 * Don't update the neighbor cache entry on a proxy NA from
965 * ourselves because either the proxied node is off link or it
966 * has already sent a NA to us.
968 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
969 pneigh_lookup(&nd_tbl, &msg->target, dev, 0))
972 neigh_update(neigh, lladdr,
973 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
974 NEIGH_UPDATE_F_WEAK_OVERRIDE|
975 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
976 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
977 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
979 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
981 * Change: router to host
984 rt = rt6_get_dflt_router(saddr, dev);
990 neigh_release(neigh);
994 static void ndisc_recv_rs(struct sk_buff *skb)
996 struct rs_msg *rs_msg = (struct rs_msg *) skb->h.raw;
997 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
998 struct neighbour *neigh;
999 struct inet6_dev *idev;
1000 struct in6_addr *saddr = &skb->nh.ipv6h->saddr;
1001 struct ndisc_options ndopts;
1004 if (skb->len < sizeof(*rs_msg))
1007 idev = in6_dev_get(skb->dev);
1009 if (net_ratelimit())
1010 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1014 /* Don't accept RS if we're not in router mode */
1015 if (!idev->cnf.forwarding)
1019 * Don't update NCE if src = ::;
1020 * this implies that the source node has no ip address assigned yet.
1022 if (ipv6_addr_any(saddr))
1025 /* Parse ND options */
1026 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
1027 if (net_ratelimit())
1028 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1032 if (ndopts.nd_opts_src_lladdr) {
1033 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1039 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1041 neigh_update(neigh, lladdr, NUD_STALE,
1042 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1043 NEIGH_UPDATE_F_OVERRIDE|
1044 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1045 neigh_release(neigh);
1051 static void ndisc_router_discovery(struct sk_buff *skb)
1053 struct ra_msg *ra_msg = (struct ra_msg *) skb->h.raw;
1054 struct neighbour *neigh = NULL;
1055 struct inet6_dev *in6_dev;
1056 struct rt6_info *rt = NULL;
1058 struct ndisc_options ndopts;
1060 unsigned int pref = 0;
1062 __u8 * opt = (__u8 *)(ra_msg + 1);
1064 optlen = (skb->tail - skb->h.raw) - sizeof(struct ra_msg);
1066 if (!(ipv6_addr_type(&skb->nh.ipv6h->saddr) & IPV6_ADDR_LINKLOCAL)) {
1067 ND_PRINTK2(KERN_WARNING
1068 "ICMPv6 RA: source address is not link-local.\n");
1072 ND_PRINTK2(KERN_WARNING
1073 "ICMPv6 RA: packet too short\n");
1078 * set the RA_RECV flag in the interface
1081 in6_dev = in6_dev_get(skb->dev);
1082 if (in6_dev == NULL) {
1084 "ICMPv6 RA: can't find inet6 device for %s.\n",
1088 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {
1089 in6_dev_put(in6_dev);
1093 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1094 in6_dev_put(in6_dev);
1095 ND_PRINTK2(KERN_WARNING
1096 "ICMP6 RA: invalid ND options\n");
1100 if (in6_dev->if_flags & IF_RS_SENT) {
1102 * flag that an RA was received after an RS was sent
1103 * out on this interface.
1105 in6_dev->if_flags |= IF_RA_RCVD;
1109 * Remember the managed/otherconf flags from most recently
1110 * received RA message (RFC 2462) -- yoshfuji
1112 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1114 (ra_msg->icmph.icmp6_addrconf_managed ?
1115 IF_RA_MANAGED : 0) |
1116 (ra_msg->icmph.icmp6_addrconf_other ?
1117 IF_RA_OTHERCONF : 0);
1119 if (!in6_dev->cnf.accept_ra_defrtr)
1122 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1124 #ifdef CONFIG_IPV6_ROUTER_PREF
1125 pref = ra_msg->icmph.icmp6_router_pref;
1126 /* 10b is handled as if it were 00b (medium) */
1127 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1128 in6_dev->cnf.accept_ra_rtr_pref)
1129 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1132 rt = rt6_get_dflt_router(&skb->nh.ipv6h->saddr, skb->dev);
1135 neigh = rt->rt6i_nexthop;
1137 if (rt && lifetime == 0) {
1143 if (rt == NULL && lifetime) {
1144 ND_PRINTK3(KERN_DEBUG
1145 "ICMPv6 RA: adding default router.\n");
1147 rt = rt6_add_dflt_router(&skb->nh.ipv6h->saddr, skb->dev, pref);
1150 "ICMPv6 RA: %s() failed to add default route.\n",
1152 in6_dev_put(in6_dev);
1156 neigh = rt->rt6i_nexthop;
1157 if (neigh == NULL) {
1159 "ICMPv6 RA: %s() got default router without neighbour.\n",
1161 dst_release(&rt->u.dst);
1162 in6_dev_put(in6_dev);
1165 neigh->flags |= NTF_ROUTER;
1167 rt->rt6i_flags |= (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1171 rt->rt6i_expires = jiffies + (HZ * lifetime);
1173 if (ra_msg->icmph.icmp6_hop_limit) {
1174 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1176 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;
1182 * Update Reachable Time and Retrans Timer
1185 if (in6_dev->nd_parms) {
1186 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1188 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1189 rtime = (rtime*HZ)/1000;
1192 in6_dev->nd_parms->retrans_time = rtime;
1193 in6_dev->tstamp = jiffies;
1194 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1197 rtime = ntohl(ra_msg->reachable_time);
1198 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1199 rtime = (rtime*HZ)/1000;
1204 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1205 in6_dev->nd_parms->base_reachable_time = rtime;
1206 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1207 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1208 in6_dev->tstamp = jiffies;
1209 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1219 neigh = __neigh_lookup(&nd_tbl, &skb->nh.ipv6h->saddr,
1223 if (ndopts.nd_opts_src_lladdr) {
1224 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1227 ND_PRINTK2(KERN_WARNING
1228 "ICMPv6 RA: invalid link-layer address length\n");
1232 neigh_update(neigh, lladdr, NUD_STALE,
1233 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1234 NEIGH_UPDATE_F_OVERRIDE|
1235 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1236 NEIGH_UPDATE_F_ISROUTER);
1239 #ifdef CONFIG_IPV6_ROUTE_INFO
1240 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1241 struct nd_opt_hdr *p;
1242 for (p = ndopts.nd_opts_ri;
1244 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1245 if (((struct route_info *)p)->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1247 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1248 &skb->nh.ipv6h->saddr);
1253 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1254 struct nd_opt_hdr *p;
1255 for (p = ndopts.nd_opts_pi;
1257 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1258 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1262 if (ndopts.nd_opts_mtu) {
1265 memcpy(&mtu, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1268 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1269 ND_PRINTK2(KERN_WARNING
1270 "ICMPv6 RA: invalid mtu: %d\n",
1272 } else if (in6_dev->cnf.mtu6 != mtu) {
1273 in6_dev->cnf.mtu6 = mtu;
1276 rt->u.dst.metrics[RTAX_MTU-1] = mtu;
1278 rt6_mtu_change(skb->dev, mtu);
1282 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1283 ND_PRINTK2(KERN_WARNING
1284 "ICMPv6 RA: invalid RA options");
1288 dst_release(&rt->u.dst);
1290 neigh_release(neigh);
1291 in6_dev_put(in6_dev);
1294 static void ndisc_redirect_rcv(struct sk_buff *skb)
1296 struct inet6_dev *in6_dev;
1297 struct icmp6hdr *icmph;
1298 struct in6_addr *dest;
1299 struct in6_addr *target; /* new first hop to destination */
1300 struct neighbour *neigh;
1302 struct ndisc_options ndopts;
1306 if (!(ipv6_addr_type(&skb->nh.ipv6h->saddr) & IPV6_ADDR_LINKLOCAL)) {
1307 ND_PRINTK2(KERN_WARNING
1308 "ICMPv6 Redirect: source address is not link-local.\n");
1312 optlen = skb->tail - skb->h.raw;
1313 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1316 ND_PRINTK2(KERN_WARNING
1317 "ICMPv6 Redirect: packet too short\n");
1321 icmph = (struct icmp6hdr *) skb->h.raw;
1322 target = (struct in6_addr *) (icmph + 1);
1325 if (ipv6_addr_is_multicast(dest)) {
1326 ND_PRINTK2(KERN_WARNING
1327 "ICMPv6 Redirect: destination address is multicast.\n");
1331 if (ipv6_addr_equal(dest, target)) {
1333 } else if (!(ipv6_addr_type(target) & IPV6_ADDR_LINKLOCAL)) {
1334 ND_PRINTK2(KERN_WARNING
1335 "ICMPv6 Redirect: target address is not link-local.\n");
1339 in6_dev = in6_dev_get(skb->dev);
1342 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1343 in6_dev_put(in6_dev);
1348 * The IP source address of the Redirect MUST be the same as the current
1349 * first-hop router for the specified ICMP Destination Address.
1352 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1353 ND_PRINTK2(KERN_WARNING
1354 "ICMPv6 Redirect: invalid ND options\n");
1355 in6_dev_put(in6_dev);
1358 if (ndopts.nd_opts_tgt_lladdr) {
1359 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1362 ND_PRINTK2(KERN_WARNING
1363 "ICMPv6 Redirect: invalid link-layer address length\n");
1364 in6_dev_put(in6_dev);
1369 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1371 rt6_redirect(dest, &skb->nh.ipv6h->daddr,
1372 &skb->nh.ipv6h->saddr, neigh, lladdr,
1374 neigh_release(neigh);
1376 in6_dev_put(in6_dev);
1379 void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
1380 struct in6_addr *target)
1382 struct sock *sk = ndisc_socket->sk;
1383 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1384 struct sk_buff *buff;
1385 struct icmp6hdr *icmph;
1386 struct in6_addr saddr_buf;
1387 struct in6_addr *addrp;
1388 struct net_device *dev;
1389 struct rt6_info *rt;
1390 struct dst_entry *dst;
1391 struct inet6_dev *idev;
1397 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1401 if (ipv6_get_lladdr(dev, &saddr_buf)) {
1402 ND_PRINTK2(KERN_WARNING
1403 "ICMPv6 Redirect: no link-local address on %s\n",
1408 ndisc_flow_init(&fl, NDISC_REDIRECT, &saddr_buf, &skb->nh.ipv6h->saddr,
1411 dst = ip6_route_output(NULL, &fl);
1415 err = xfrm_lookup(&dst, &fl, NULL, 0);
1419 rt = (struct rt6_info *) dst;
1421 if (rt->rt6i_flags & RTF_GATEWAY) {
1422 ND_PRINTK2(KERN_WARNING
1423 "ICMPv6 Redirect: destination is not a neighbour.\n");
1427 if (!xrlim_allow(dst, 1*HZ)) {
1432 if (dev->addr_len) {
1433 read_lock_bh(&neigh->lock);
1434 if (neigh->nud_state & NUD_VALID) {
1435 memcpy(ha_buf, neigh->ha, dev->addr_len);
1436 read_unlock_bh(&neigh->lock);
1438 len += ndisc_opt_addr_space(dev);
1440 read_unlock_bh(&neigh->lock);
1443 rd_len = min_t(unsigned int,
1444 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1448 buff = sock_alloc_send_skb(sk, MAX_HEADER + len + LL_RESERVED_SPACE(dev),
1452 "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
1460 skb_reserve(buff, LL_RESERVED_SPACE(dev));
1461 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &skb->nh.ipv6h->saddr,
1462 IPPROTO_ICMPV6, len);
1464 icmph = (struct icmp6hdr *)skb_put(buff, len);
1465 buff->h.raw = (unsigned char*)icmph;
1467 memset(icmph, 0, sizeof(struct icmp6hdr));
1468 icmph->icmp6_type = NDISC_REDIRECT;
1471 * copy target and destination addresses
1474 addrp = (struct in6_addr *)(icmph + 1);
1475 ipv6_addr_copy(addrp, target);
1477 ipv6_addr_copy(addrp, &skb->nh.ipv6h->daddr);
1479 opt = (u8*) (addrp + 1);
1482 * include target_address option
1486 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1487 dev->addr_len, dev->type);
1490 * build redirect option and copy skb over to the new packet.
1494 *(opt++) = ND_OPT_REDIRECT_HDR;
1495 *(opt++) = (rd_len >> 3);
1498 memcpy(opt, skb->nh.ipv6h, rd_len - 8);
1500 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &skb->nh.ipv6h->saddr,
1501 len, IPPROTO_ICMPV6,
1502 csum_partial((u8 *) icmph, len, 0));
1505 idev = in6_dev_get(dst->dev);
1506 IP6_INC_STATS(IPSTATS_MIB_OUTREQUESTS);
1507 err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, buff, NULL, dst->dev, dst_output);
1509 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTREDIRECTS);
1510 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
1513 if (likely(idev != NULL))
1517 static void pndisc_redo(struct sk_buff *skb)
1523 int ndisc_rcv(struct sk_buff *skb)
1527 if (!pskb_may_pull(skb, skb->len))
1530 msg = (struct nd_msg *) skb->h.raw;
1532 __skb_push(skb, skb->data-skb->h.raw);
1534 if (skb->nh.ipv6h->hop_limit != 255) {
1535 ND_PRINTK2(KERN_WARNING
1536 "ICMPv6 NDISC: invalid hop-limit: %d\n",
1537 skb->nh.ipv6h->hop_limit);
1541 if (msg->icmph.icmp6_code != 0) {
1542 ND_PRINTK2(KERN_WARNING
1543 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1544 msg->icmph.icmp6_code);
1548 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1550 switch (msg->icmph.icmp6_type) {
1551 case NDISC_NEIGHBOUR_SOLICITATION:
1555 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1559 case NDISC_ROUTER_SOLICITATION:
1563 case NDISC_ROUTER_ADVERTISEMENT:
1564 ndisc_router_discovery(skb);
1567 case NDISC_REDIRECT:
1568 ndisc_redirect_rcv(skb);
1575 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1577 struct net_device *dev = ptr;
1580 case NETDEV_CHANGEADDR:
1581 neigh_changeaddr(&nd_tbl, dev);
1585 neigh_ifdown(&nd_tbl, dev);
1595 static struct notifier_block ndisc_netdev_notifier = {
1596 .notifier_call = ndisc_netdev_event,
1599 #ifdef CONFIG_SYSCTL
1600 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1601 const char *func, const char *dev_name)
1603 static char warncomm[TASK_COMM_LEN];
1605 if (strcmp(warncomm, current->comm) && warned < 5) {
1606 strcpy(warncomm, current->comm);
1608 "process `%s' is using deprecated sysctl (%s) "
1609 "net.ipv6.neigh.%s.%s; "
1610 "Use net.ipv6.neigh.%s.%s_ms "
1613 dev_name, ctl->procname,
1614 dev_name, ctl->procname);
1619 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)
1621 struct net_device *dev = ctl->extra1;
1622 struct inet6_dev *idev;
1625 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1626 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1627 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1629 switch (ctl->ctl_name) {
1630 case NET_NEIGH_RETRANS_TIME:
1631 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1633 case NET_NEIGH_REACHABLE_TIME:
1634 ret = proc_dointvec_jiffies(ctl, write,
1635 filp, buffer, lenp, ppos);
1637 case NET_NEIGH_RETRANS_TIME_MS:
1638 case NET_NEIGH_REACHABLE_TIME_MS:
1639 ret = proc_dointvec_ms_jiffies(ctl, write,
1640 filp, buffer, lenp, ppos);
1646 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1647 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1648 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1649 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1650 idev->tstamp = jiffies;
1651 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1657 static int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl, int __user *name,
1658 int nlen, void __user *oldval,
1659 size_t __user *oldlenp,
1660 void __user *newval, size_t newlen,
1663 struct net_device *dev = ctl->extra1;
1664 struct inet6_dev *idev;
1667 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1668 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1669 ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");
1671 switch (ctl->ctl_name) {
1672 case NET_NEIGH_REACHABLE_TIME:
1673 ret = sysctl_jiffies(ctl, name, nlen,
1674 oldval, oldlenp, newval, newlen,
1677 case NET_NEIGH_RETRANS_TIME_MS:
1678 case NET_NEIGH_REACHABLE_TIME_MS:
1679 ret = sysctl_ms_jiffies(ctl, name, nlen,
1680 oldval, oldlenp, newval, newlen,
1687 if (newval && newlen && ret > 0 &&
1688 dev && (idev = in6_dev_get(dev)) != NULL) {
1689 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1690 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1691 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1692 idev->tstamp = jiffies;
1693 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1702 int __init ndisc_init(struct net_proto_family *ops)
1704 struct ipv6_pinfo *np;
1708 err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6, &ndisc_socket);
1711 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1713 ndisc_socket = NULL; /* For safety. */
1717 sk = ndisc_socket->sk;
1719 sk->sk_allocation = GFP_ATOMIC;
1720 np->hop_limit = 255;
1721 /* Do not loopback ndisc messages */
1723 sk->sk_prot->unhash(sk);
1726 * Initialize the neighbour table
1729 neigh_table_init(&nd_tbl);
1731 #ifdef CONFIG_SYSCTL
1732 neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6, NET_IPV6_NEIGH,
1734 &ndisc_ifinfo_sysctl_change,
1735 &ndisc_ifinfo_sysctl_strategy);
1738 register_netdevice_notifier(&ndisc_netdev_notifier);
1742 void ndisc_cleanup(void)
1744 #ifdef CONFIG_SYSCTL
1745 neigh_sysctl_unregister(&nd_tbl.parms);
1747 neigh_table_clear(&nd_tbl);
1748 sock_release(ndisc_socket);
1749 ndisc_socket = NULL; /* For safety. */