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 * Alexey I. Froloff : RFC6106 (DNSSL) support
19 * Pierre Ynard : export userland ND options
20 * through netlink (RDNSS support)
21 * Lars Fenneberg : fixed MTU setting on receipt
23 * Janos Farkas : kmalloc failure checks
24 * Alexey Kuznetsov : state machine reworked
25 * and moved to net/core.
26 * Pekka Savola : RFC2461 validation
27 * YOSHIFUJI Hideaki @USAGI : Verify ND options properly
30 #define pr_fmt(fmt) "ICMPv6: " fmt
32 #include <linux/module.h>
33 #include <linux/errno.h>
34 #include <linux/types.h>
35 #include <linux/socket.h>
36 #include <linux/sockios.h>
37 #include <linux/sched.h>
38 #include <linux/net.h>
39 #include <linux/in6.h>
40 #include <linux/route.h>
41 #include <linux/init.h>
42 #include <linux/rcupdate.h>
43 #include <linux/slab.h>
45 #include <linux/sysctl.h>
48 #include <linux/if_addr.h>
49 #include <linux/if_arp.h>
50 #include <linux/ipv6.h>
51 #include <linux/icmpv6.h>
52 #include <linux/jhash.h>
58 #include <net/protocol.h>
59 #include <net/ndisc.h>
60 #include <net/ip6_route.h>
61 #include <net/addrconf.h>
64 #include <net/netlink.h>
65 #include <linux/rtnetlink.h>
68 #include <net/ip6_checksum.h>
69 #include <net/inet_common.h>
70 #include <linux/proc_fs.h>
72 #include <linux/netfilter.h>
73 #include <linux/netfilter_ipv6.h>
75 /* Set to 3 to get tracing... */
78 #define ND_PRINTK(val, level, fmt, ...) \
80 if (val <= ND_DEBUG) \
81 net_##level##_ratelimited(fmt, ##__VA_ARGS__); \
84 static u32 ndisc_hash(const void *pkey,
85 const struct net_device *dev,
87 static int ndisc_constructor(struct neighbour *neigh);
88 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
89 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
90 static int pndisc_constructor(struct pneigh_entry *n);
91 static void pndisc_destructor(struct pneigh_entry *n);
92 static void pndisc_redo(struct sk_buff *skb);
94 static const struct neigh_ops ndisc_generic_ops = {
96 .solicit = ndisc_solicit,
97 .error_report = ndisc_error_report,
98 .output = neigh_resolve_output,
99 .connected_output = neigh_connected_output,
102 static const struct neigh_ops ndisc_hh_ops = {
104 .solicit = ndisc_solicit,
105 .error_report = ndisc_error_report,
106 .output = neigh_resolve_output,
107 .connected_output = neigh_resolve_output,
111 static const struct neigh_ops ndisc_direct_ops = {
113 .output = neigh_direct_output,
114 .connected_output = neigh_direct_output,
117 struct neigh_table nd_tbl = {
119 .key_len = sizeof(struct in6_addr),
121 .constructor = ndisc_constructor,
122 .pconstructor = pndisc_constructor,
123 .pdestructor = pndisc_destructor,
124 .proxy_redo = pndisc_redo,
128 .base_reachable_time = ND_REACHABLE_TIME,
129 .retrans_time = ND_RETRANS_TIMER,
130 .gc_staletime = 60 * HZ,
131 .reachable_time = ND_REACHABLE_TIME,
132 .delay_probe_time = 5 * HZ,
133 .queue_len_bytes = 64*1024,
136 .anycast_delay = 1 * HZ,
137 .proxy_delay = (8 * HZ) / 10,
140 .gc_interval = 30 * HZ,
146 static inline int ndisc_opt_addr_space(struct net_device *dev)
148 return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type));
151 static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len,
152 unsigned short addr_type)
154 int space = NDISC_OPT_SPACE(data_len);
155 int pad = ndisc_addr_option_pad(addr_type);
160 memset(opt + 2, 0, pad);
164 memcpy(opt+2, data, data_len);
167 if ((space -= data_len) > 0)
168 memset(opt, 0, space);
172 static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
173 struct nd_opt_hdr *end)
176 if (!cur || !end || cur >= end)
178 type = cur->nd_opt_type;
180 cur = ((void *)cur) + (cur->nd_opt_len << 3);
181 } while(cur < end && cur->nd_opt_type != type);
182 return cur <= end && cur->nd_opt_type == type ? cur : NULL;
185 static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
187 return opt->nd_opt_type == ND_OPT_RDNSS ||
188 opt->nd_opt_type == ND_OPT_DNSSL;
191 static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur,
192 struct nd_opt_hdr *end)
194 if (!cur || !end || cur >= end)
197 cur = ((void *)cur) + (cur->nd_opt_len << 3);
198 } while(cur < end && !ndisc_is_useropt(cur));
199 return cur <= end && ndisc_is_useropt(cur) ? cur : NULL;
202 struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
203 struct ndisc_options *ndopts)
205 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
207 if (!nd_opt || opt_len < 0 || !ndopts)
209 memset(ndopts, 0, sizeof(*ndopts));
212 if (opt_len < sizeof(struct nd_opt_hdr))
214 l = nd_opt->nd_opt_len << 3;
215 if (opt_len < l || l == 0)
217 switch (nd_opt->nd_opt_type) {
218 case ND_OPT_SOURCE_LL_ADDR:
219 case ND_OPT_TARGET_LL_ADDR:
221 case ND_OPT_REDIRECT_HDR:
222 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
224 "%s: duplicated ND6 option found: type=%d\n",
225 __func__, nd_opt->nd_opt_type);
227 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
230 case ND_OPT_PREFIX_INFO:
231 ndopts->nd_opts_pi_end = nd_opt;
232 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
233 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
235 #ifdef CONFIG_IPV6_ROUTE_INFO
236 case ND_OPT_ROUTE_INFO:
237 ndopts->nd_opts_ri_end = nd_opt;
238 if (!ndopts->nd_opts_ri)
239 ndopts->nd_opts_ri = nd_opt;
243 if (ndisc_is_useropt(nd_opt)) {
244 ndopts->nd_useropts_end = nd_opt;
245 if (!ndopts->nd_useropts)
246 ndopts->nd_useropts = nd_opt;
249 * Unknown options must be silently ignored,
250 * to accommodate future extension to the
254 "%s: ignored unsupported option; type=%d, len=%d\n",
261 nd_opt = ((void *)nd_opt) + l;
266 int ndisc_mc_map(const struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
270 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
272 ipv6_eth_mc_map(addr, buf);
275 ipv6_arcnet_mc_map(addr, buf);
277 case ARPHRD_INFINIBAND:
278 ipv6_ib_mc_map(addr, dev->broadcast, buf);
281 return ipv6_ipgre_mc_map(addr, dev->broadcast, buf);
284 memcpy(buf, dev->broadcast, dev->addr_len);
291 EXPORT_SYMBOL(ndisc_mc_map);
293 static u32 ndisc_hash(const void *pkey,
294 const struct net_device *dev,
297 return ndisc_hashfn(pkey, dev, hash_rnd);
300 static int ndisc_constructor(struct neighbour *neigh)
302 struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;
303 struct net_device *dev = neigh->dev;
304 struct inet6_dev *in6_dev;
305 struct neigh_parms *parms;
306 bool is_multicast = ipv6_addr_is_multicast(addr);
308 in6_dev = in6_dev_get(dev);
309 if (in6_dev == NULL) {
313 parms = in6_dev->nd_parms;
314 __neigh_parms_put(neigh->parms);
315 neigh->parms = neigh_parms_clone(parms);
317 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
318 if (!dev->header_ops) {
319 neigh->nud_state = NUD_NOARP;
320 neigh->ops = &ndisc_direct_ops;
321 neigh->output = neigh_direct_output;
324 neigh->nud_state = NUD_NOARP;
325 ndisc_mc_map(addr, neigh->ha, dev, 1);
326 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
327 neigh->nud_state = NUD_NOARP;
328 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
329 if (dev->flags&IFF_LOOPBACK)
330 neigh->type = RTN_LOCAL;
331 } else if (dev->flags&IFF_POINTOPOINT) {
332 neigh->nud_state = NUD_NOARP;
333 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
335 if (dev->header_ops->cache)
336 neigh->ops = &ndisc_hh_ops;
338 neigh->ops = &ndisc_generic_ops;
339 if (neigh->nud_state&NUD_VALID)
340 neigh->output = neigh->ops->connected_output;
342 neigh->output = neigh->ops->output;
344 in6_dev_put(in6_dev);
348 static int pndisc_constructor(struct pneigh_entry *n)
350 struct in6_addr *addr = (struct in6_addr*)&n->key;
351 struct in6_addr maddr;
352 struct net_device *dev = n->dev;
354 if (dev == NULL || __in6_dev_get(dev) == NULL)
356 addrconf_addr_solict_mult(addr, &maddr);
357 ipv6_dev_mc_inc(dev, &maddr);
361 static void pndisc_destructor(struct pneigh_entry *n)
363 struct in6_addr *addr = (struct in6_addr*)&n->key;
364 struct in6_addr maddr;
365 struct net_device *dev = n->dev;
367 if (dev == NULL || __in6_dev_get(dev) == NULL)
369 addrconf_addr_solict_mult(addr, &maddr);
370 ipv6_dev_mc_dec(dev, &maddr);
373 struct sk_buff *ndisc_build_skb(struct net_device *dev,
374 const struct in6_addr *daddr,
375 const struct in6_addr *saddr,
376 struct icmp6hdr *icmp6h,
377 const struct in6_addr *target,
380 struct net *net = dev_net(dev);
381 struct sock *sk = net->ipv6.ndisc_sk;
383 struct icmp6hdr *hdr;
384 int hlen = LL_RESERVED_SPACE(dev);
385 int tlen = dev->needed_tailroom;
393 len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0);
395 len += ndisc_opt_addr_space(dev);
397 skb = sock_alloc_send_skb(sk,
398 (MAX_HEADER + sizeof(struct ipv6hdr) +
402 ND_PRINTK(0, err, "ND: %s failed to allocate an skb, err=%d\n",
407 skb_reserve(skb, hlen);
408 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
410 skb->transport_header = skb->tail;
413 hdr = (struct icmp6hdr *)skb_transport_header(skb);
414 memcpy(hdr, icmp6h, sizeof(*hdr));
416 opt = skb_transport_header(skb) + sizeof(struct icmp6hdr);
418 *(struct in6_addr *)opt = *target;
419 opt += sizeof(*target);
423 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr,
424 dev->addr_len, dev->type);
426 hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len,
434 EXPORT_SYMBOL(ndisc_build_skb);
436 void ndisc_send_skb(struct sk_buff *skb,
437 struct net_device *dev,
438 struct neighbour *neigh,
439 const struct in6_addr *daddr,
440 const struct in6_addr *saddr,
441 struct icmp6hdr *icmp6h)
444 struct dst_entry *dst;
445 struct net *net = dev_net(dev);
446 struct sock *sk = net->ipv6.ndisc_sk;
447 struct inet6_dev *idev;
451 type = icmp6h->icmp6_type;
453 icmpv6_flow_init(sk, &fl6, type, saddr, daddr, dev->ifindex);
454 dst = icmp6_dst_alloc(dev, neigh, &fl6);
460 skb_dst_set(skb, dst);
463 idev = __in6_dev_get(dst->dev);
464 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
466 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
469 ICMP6MSGOUT_INC_STATS(net, idev, type);
470 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
476 EXPORT_SYMBOL(ndisc_send_skb);
479 * Send a Neighbour Discover packet
481 static void __ndisc_send(struct net_device *dev,
482 struct neighbour *neigh,
483 const struct in6_addr *daddr,
484 const struct in6_addr *saddr,
485 struct icmp6hdr *icmp6h, const struct in6_addr *target,
490 skb = ndisc_build_skb(dev, daddr, saddr, icmp6h, target, llinfo);
494 ndisc_send_skb(skb, dev, neigh, daddr, saddr, icmp6h);
497 static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
498 const struct in6_addr *daddr,
499 const struct in6_addr *solicited_addr,
500 int router, int solicited, int override, int inc_opt)
502 struct in6_addr tmpaddr;
503 struct inet6_ifaddr *ifp;
504 const struct in6_addr *src_addr;
505 struct icmp6hdr icmp6h = {
506 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
509 /* for anycast or proxy, solicited_addr != src_addr */
510 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
512 src_addr = solicited_addr;
513 if (ifp->flags & IFA_F_OPTIMISTIC)
515 inc_opt |= ifp->idev->cnf.force_tllao;
518 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
519 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
525 icmp6h.icmp6_router = router;
526 icmp6h.icmp6_solicited = solicited;
527 icmp6h.icmp6_override = override;
529 __ndisc_send(dev, neigh, daddr, src_addr,
530 &icmp6h, solicited_addr,
531 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
534 static void ndisc_send_unsol_na(struct net_device *dev)
536 struct inet6_dev *idev;
537 struct inet6_ifaddr *ifa;
538 struct in6_addr mcaddr;
540 idev = in6_dev_get(dev);
544 read_lock_bh(&idev->lock);
545 list_for_each_entry(ifa, &idev->addr_list, if_list) {
546 addrconf_addr_solict_mult(&ifa->addr, &mcaddr);
547 ndisc_send_na(dev, NULL, &mcaddr, &ifa->addr,
548 /*router=*/ !!idev->cnf.forwarding,
549 /*solicited=*/ false, /*override=*/ true,
552 read_unlock_bh(&idev->lock);
557 void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
558 const struct in6_addr *solicit,
559 const struct in6_addr *daddr, const struct in6_addr *saddr)
561 struct in6_addr addr_buf;
562 struct icmp6hdr icmp6h = {
563 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
567 if (ipv6_get_lladdr(dev, &addr_buf,
568 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
573 __ndisc_send(dev, neigh, daddr, saddr,
575 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
578 void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
579 const struct in6_addr *daddr)
581 struct icmp6hdr icmp6h = {
582 .icmp6_type = NDISC_ROUTER_SOLICITATION,
584 int send_sllao = dev->addr_len;
586 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
588 * According to section 2.2 of RFC 4429, we must not
589 * send router solicitations with a sllao from
590 * optimistic addresses, but we may send the solicitation
591 * if we don't include the sllao. So here we check
592 * if our address is optimistic, and if so, we
593 * suppress the inclusion of the sllao.
596 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
599 if (ifp->flags & IFA_F_OPTIMISTIC) {
608 __ndisc_send(dev, NULL, daddr, saddr,
610 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
614 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
617 * "The sender MUST return an ICMP
618 * destination unreachable"
620 dst_link_failure(skb);
624 /* Called with locked neigh: either read or both */
626 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
628 struct in6_addr *saddr = NULL;
629 struct in6_addr mcaddr;
630 struct net_device *dev = neigh->dev;
631 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
632 int probes = atomic_read(&neigh->probes);
634 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
635 saddr = &ipv6_hdr(skb)->saddr;
637 if ((probes -= neigh->parms->ucast_probes) < 0) {
638 if (!(neigh->nud_state & NUD_VALID)) {
640 "%s: trying to ucast probe in NUD_INVALID: %pI6\n",
643 ndisc_send_ns(dev, neigh, target, target, saddr);
644 } else if ((probes -= neigh->parms->app_probes) < 0) {
649 addrconf_addr_solict_mult(target, &mcaddr);
650 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
654 static int pndisc_is_router(const void *pkey,
655 struct net_device *dev)
657 struct pneigh_entry *n;
660 read_lock_bh(&nd_tbl.lock);
661 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
663 ret = !!(n->flags & NTF_ROUTER);
664 read_unlock_bh(&nd_tbl.lock);
669 static void ndisc_recv_ns(struct sk_buff *skb)
671 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
672 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
673 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
675 u32 ndoptlen = skb->tail - (skb->transport_header +
676 offsetof(struct nd_msg, opt));
677 struct ndisc_options ndopts;
678 struct net_device *dev = skb->dev;
679 struct inet6_ifaddr *ifp;
680 struct inet6_dev *idev = NULL;
681 struct neighbour *neigh;
682 int dad = ipv6_addr_any(saddr);
686 if (ipv6_addr_is_multicast(&msg->target)) {
687 ND_PRINTK(2, warn, "NS: multicast target address\n");
693 * DAD has to be destined for solicited node multicast address.
696 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
697 daddr->s6_addr32[1] == htonl(0x00000000) &&
698 daddr->s6_addr32[2] == htonl(0x00000001) &&
699 daddr->s6_addr [12] == 0xff )) {
700 ND_PRINTK(2, warn, "NS: bad DAD packet (wrong destination)\n");
704 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
705 ND_PRINTK(2, warn, "NS: invalid ND options\n");
709 if (ndopts.nd_opts_src_lladdr) {
710 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
713 "NS: invalid link-layer address length\n");
718 * If the IP source address is the unspecified address,
719 * there MUST NOT be source link-layer address option
724 "NS: bad DAD packet (link-layer address option)\n");
729 inc = ipv6_addr_is_multicast(daddr);
731 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
734 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
737 * We are colliding with another node
739 * so fail our DAD process
741 addrconf_dad_failure(ifp);
745 * This is not a dad solicitation.
746 * If we are an optimistic node,
748 * Otherwise, we should ignore it.
750 if (!(ifp->flags & IFA_F_OPTIMISTIC))
757 struct net *net = dev_net(dev);
759 idev = in6_dev_get(dev);
761 /* XXX: count this drop? */
765 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
766 (idev->cnf.forwarding &&
767 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
768 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
769 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
770 skb->pkt_type != PACKET_HOST &&
772 idev->nd_parms->proxy_delay != 0) {
774 * for anycast or proxy,
775 * sender should delay its response
776 * by a random time between 0 and
777 * MAX_ANYCAST_DELAY_TIME seconds.
778 * (RFC2461) -- yoshfuji
780 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
782 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
790 is_router = !!idev->cnf.forwarding;
793 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
794 is_router, 0, (ifp != NULL), 1);
799 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
801 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
804 * update / create cache entry
805 * for the source address
807 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
808 !inc || lladdr || !dev->addr_len);
810 neigh_update(neigh, lladdr, NUD_STALE,
811 NEIGH_UPDATE_F_WEAK_OVERRIDE|
812 NEIGH_UPDATE_F_OVERRIDE);
813 if (neigh || !dev->header_ops) {
814 ndisc_send_na(dev, neigh, saddr, &msg->target,
816 1, (ifp != NULL && inc), inc);
818 neigh_release(neigh);
828 static void ndisc_recv_na(struct sk_buff *skb)
830 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
831 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
832 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
834 u32 ndoptlen = skb->tail - (skb->transport_header +
835 offsetof(struct nd_msg, opt));
836 struct ndisc_options ndopts;
837 struct net_device *dev = skb->dev;
838 struct inet6_ifaddr *ifp;
839 struct neighbour *neigh;
841 if (skb->len < sizeof(struct nd_msg)) {
842 ND_PRINTK(2, warn, "NA: packet too short\n");
846 if (ipv6_addr_is_multicast(&msg->target)) {
847 ND_PRINTK(2, warn, "NA: target address is multicast\n");
851 if (ipv6_addr_is_multicast(daddr) &&
852 msg->icmph.icmp6_solicited) {
853 ND_PRINTK(2, warn, "NA: solicited NA is multicasted\n");
857 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
858 ND_PRINTK(2, warn, "NS: invalid ND option\n");
861 if (ndopts.nd_opts_tgt_lladdr) {
862 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
865 "NA: invalid link-layer address length\n");
869 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
871 if (skb->pkt_type != PACKET_LOOPBACK
872 && (ifp->flags & IFA_F_TENTATIVE)) {
873 addrconf_dad_failure(ifp);
876 /* What should we make now? The advertisement
877 is invalid, but ndisc specs say nothing
878 about it. It could be misconfiguration, or
879 an smart proxy agent tries to help us :-)
881 We should not print the error if NA has been
882 received from loopback - it is just our own
883 unsolicited advertisement.
885 if (skb->pkt_type != PACKET_LOOPBACK)
887 "NA: someone advertises our address %pI6 on %s!\n",
888 &ifp->addr, ifp->idev->dev->name);
892 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
895 u8 old_flags = neigh->flags;
896 struct net *net = dev_net(dev);
898 if (neigh->nud_state & NUD_FAILED)
902 * Don't update the neighbor cache entry on a proxy NA from
903 * ourselves because either the proxied node is off link or it
904 * has already sent a NA to us.
906 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
907 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
908 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
909 /* XXX: idev->cnf.prixy_ndp */
913 neigh_update(neigh, lladdr,
914 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
915 NEIGH_UPDATE_F_WEAK_OVERRIDE|
916 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
917 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
918 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
920 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
922 * Change: router to host
925 rt = rt6_get_dflt_router(saddr, dev);
931 neigh_release(neigh);
935 static void ndisc_recv_rs(struct sk_buff *skb)
937 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
938 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
939 struct neighbour *neigh;
940 struct inet6_dev *idev;
941 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
942 struct ndisc_options ndopts;
945 if (skb->len < sizeof(*rs_msg))
948 idev = __in6_dev_get(skb->dev);
950 ND_PRINTK(1, err, "RS: can't find in6 device\n");
954 /* Don't accept RS if we're not in router mode */
955 if (!idev->cnf.forwarding)
959 * Don't update NCE if src = ::;
960 * this implies that the source node has no ip address assigned yet.
962 if (ipv6_addr_any(saddr))
965 /* Parse ND options */
966 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
967 ND_PRINTK(2, notice, "NS: invalid ND option, ignored\n");
971 if (ndopts.nd_opts_src_lladdr) {
972 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
978 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
980 neigh_update(neigh, lladdr, NUD_STALE,
981 NEIGH_UPDATE_F_WEAK_OVERRIDE|
982 NEIGH_UPDATE_F_OVERRIDE|
983 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
984 neigh_release(neigh);
990 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
992 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
994 struct nlmsghdr *nlh;
995 struct nduseroptmsg *ndmsg;
996 struct net *net = dev_net(ra->dev);
998 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
999 + (opt->nd_opt_len << 3));
1000 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1002 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1008 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1010 goto nla_put_failure;
1013 ndmsg = nlmsg_data(nlh);
1014 ndmsg->nduseropt_family = AF_INET6;
1015 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
1016 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1017 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1018 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1020 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1022 if (nla_put(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1023 &ipv6_hdr(ra)->saddr))
1024 goto nla_put_failure;
1025 nlmsg_end(skb, nlh);
1027 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
1034 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1037 static inline int accept_ra(struct inet6_dev *in6_dev)
1040 * If forwarding is enabled, RA are not accepted unless the special
1041 * hybrid mode (accept_ra=2) is enabled.
1043 if (in6_dev->cnf.forwarding && in6_dev->cnf.accept_ra < 2)
1046 return in6_dev->cnf.accept_ra;
1049 static void ndisc_router_discovery(struct sk_buff *skb)
1051 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1052 struct neighbour *neigh = NULL;
1053 struct inet6_dev *in6_dev;
1054 struct rt6_info *rt = NULL;
1056 struct ndisc_options ndopts;
1058 unsigned int pref = 0;
1060 __u8 * opt = (__u8 *)(ra_msg + 1);
1062 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
1064 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1065 ND_PRINTK(2, warn, "RA: source address is not link-local\n");
1069 ND_PRINTK(2, warn, "RA: packet too short\n");
1073 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1074 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1075 ND_PRINTK(2, warn, "RA: from host or unauthorized router\n");
1081 * set the RA_RECV flag in the interface
1084 in6_dev = __in6_dev_get(skb->dev);
1085 if (in6_dev == NULL) {
1086 ND_PRINTK(0, err, "RA: can't find inet6 device for %s\n",
1091 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1092 ND_PRINTK(2, warn, "RA: invalid ND options\n");
1096 if (!accept_ra(in6_dev))
1097 goto skip_linkparms;
1099 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1100 /* skip link-specific parameters from interior routers */
1101 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1102 goto skip_linkparms;
1105 if (in6_dev->if_flags & IF_RS_SENT) {
1107 * flag that an RA was received after an RS was sent
1108 * out on this interface.
1110 in6_dev->if_flags |= IF_RA_RCVD;
1114 * Remember the managed/otherconf flags from most recently
1115 * received RA message (RFC 2462) -- yoshfuji
1117 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1119 (ra_msg->icmph.icmp6_addrconf_managed ?
1120 IF_RA_MANAGED : 0) |
1121 (ra_msg->icmph.icmp6_addrconf_other ?
1122 IF_RA_OTHERCONF : 0);
1124 if (!in6_dev->cnf.accept_ra_defrtr)
1127 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
1130 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1132 #ifdef CONFIG_IPV6_ROUTER_PREF
1133 pref = ra_msg->icmph.icmp6_router_pref;
1134 /* 10b is handled as if it were 00b (medium) */
1135 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1136 !in6_dev->cnf.accept_ra_rtr_pref)
1137 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1140 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1143 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1146 "RA: %s got default router without neighbour\n",
1152 if (rt && lifetime == 0) {
1157 if (rt == NULL && lifetime) {
1158 ND_PRINTK(3, dbg, "RA: adding default router\n");
1160 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1163 "RA: %s failed to add default route\n",
1168 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1169 if (neigh == NULL) {
1171 "RA: %s got default router without neighbour\n",
1176 neigh->flags |= NTF_ROUTER;
1178 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1182 rt6_set_expires(rt, jiffies + (HZ * lifetime));
1183 if (ra_msg->icmph.icmp6_hop_limit) {
1184 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1186 dst_metric_set(&rt->dst, RTAX_HOPLIMIT,
1187 ra_msg->icmph.icmp6_hop_limit);
1193 * Update Reachable Time and Retrans Timer
1196 if (in6_dev->nd_parms) {
1197 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1199 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1200 rtime = (rtime*HZ)/1000;
1203 in6_dev->nd_parms->retrans_time = rtime;
1204 in6_dev->tstamp = jiffies;
1205 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1208 rtime = ntohl(ra_msg->reachable_time);
1209 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1210 rtime = (rtime*HZ)/1000;
1215 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1216 in6_dev->nd_parms->base_reachable_time = rtime;
1217 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1218 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1219 in6_dev->tstamp = jiffies;
1220 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1232 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1236 if (ndopts.nd_opts_src_lladdr) {
1237 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1241 "RA: invalid link-layer address length\n");
1245 neigh_update(neigh, lladdr, NUD_STALE,
1246 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1247 NEIGH_UPDATE_F_OVERRIDE|
1248 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1249 NEIGH_UPDATE_F_ISROUTER);
1252 if (!accept_ra(in6_dev))
1255 #ifdef CONFIG_IPV6_ROUTE_INFO
1256 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
1257 goto skip_routeinfo;
1259 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1260 struct nd_opt_hdr *p;
1261 for (p = ndopts.nd_opts_ri;
1263 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1264 struct route_info *ri = (struct route_info *)p;
1265 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1266 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1267 ri->prefix_len == 0)
1270 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1272 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1273 &ipv6_hdr(skb)->saddr);
1280 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1281 /* skip link-specific ndopts from interior routers */
1282 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1286 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1287 struct nd_opt_hdr *p;
1288 for (p = ndopts.nd_opts_pi;
1290 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1291 addrconf_prefix_rcv(skb->dev, (u8 *)p,
1292 (p->nd_opt_len) << 3,
1293 ndopts.nd_opts_src_lladdr != NULL);
1297 if (ndopts.nd_opts_mtu) {
1301 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1304 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1305 ND_PRINTK(2, warn, "RA: invalid mtu: %d\n", mtu);
1306 } else if (in6_dev->cnf.mtu6 != mtu) {
1307 in6_dev->cnf.mtu6 = mtu;
1310 dst_metric_set(&rt->dst, RTAX_MTU, mtu);
1312 rt6_mtu_change(skb->dev, mtu);
1316 if (ndopts.nd_useropts) {
1317 struct nd_opt_hdr *p;
1318 for (p = ndopts.nd_useropts;
1320 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1321 ndisc_ra_useropt(skb, p);
1325 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1326 ND_PRINTK(2, warn, "RA: invalid RA options\n");
1331 neigh_release(neigh);
1334 static void ndisc_redirect_rcv(struct sk_buff *skb)
1336 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1337 switch (skb->ndisc_nodetype) {
1338 case NDISC_NODETYPE_HOST:
1339 case NDISC_NODETYPE_NODEFAULT:
1341 "Redirect: from host or unauthorized router\n");
1346 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1348 "Redirect: source address is not link-local\n");
1352 icmpv6_notify(skb, NDISC_REDIRECT, 0, 0);
1355 void ndisc_send_redirect(struct sk_buff *skb, const struct in6_addr *target)
1357 struct net_device *dev = skb->dev;
1358 struct net *net = dev_net(dev);
1359 struct sock *sk = net->ipv6.ndisc_sk;
1360 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1361 struct inet_peer *peer;
1362 struct sk_buff *buff;
1363 struct icmp6hdr *icmph;
1364 struct in6_addr saddr_buf;
1365 struct in6_addr *addrp;
1366 struct rt6_info *rt;
1367 struct dst_entry *dst;
1368 struct inet6_dev *idev;
1374 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1377 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1378 ND_PRINTK(2, warn, "Redirect: no link-local address on %s\n",
1383 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1384 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1386 "Redirect: target address is not link-local unicast\n");
1390 icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT,
1391 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
1393 dst = ip6_route_output(net, NULL, &fl6);
1398 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
1402 rt = (struct rt6_info *) dst;
1404 if (rt->rt6i_flags & RTF_GATEWAY) {
1406 "Redirect: destination is not a neighbour\n");
1409 peer = inet_getpeer_v6(net->ipv6.peers, &rt->rt6i_dst.addr, 1);
1410 ret = inet_peer_xrlim_allow(peer, 1*HZ);
1416 if (dev->addr_len) {
1417 struct neighbour *neigh = dst_neigh_lookup(skb_dst(skb), target);
1420 "Redirect: no neigh for target address\n");
1424 read_lock_bh(&neigh->lock);
1425 if (neigh->nud_state & NUD_VALID) {
1426 memcpy(ha_buf, neigh->ha, dev->addr_len);
1427 read_unlock_bh(&neigh->lock);
1429 len += ndisc_opt_addr_space(dev);
1431 read_unlock_bh(&neigh->lock);
1433 neigh_release(neigh);
1436 rd_len = min_t(unsigned int,
1437 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1441 hlen = LL_RESERVED_SPACE(dev);
1442 tlen = dev->needed_tailroom;
1443 buff = sock_alloc_send_skb(sk,
1444 (MAX_HEADER + sizeof(struct ipv6hdr) +
1449 "Redirect: %s failed to allocate an skb, err=%d\n",
1454 skb_reserve(buff, hlen);
1455 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
1456 IPPROTO_ICMPV6, len);
1458 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
1460 icmph = icmp6_hdr(buff);
1462 memset(icmph, 0, sizeof(struct icmp6hdr));
1463 icmph->icmp6_type = NDISC_REDIRECT;
1466 * copy target and destination addresses
1469 addrp = (struct in6_addr *)(icmph + 1);
1472 *addrp = ipv6_hdr(skb)->daddr;
1474 opt = (u8*) (addrp + 1);
1477 * include target_address option
1481 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1482 dev->addr_len, dev->type);
1485 * build redirect option and copy skb over to the new packet.
1489 *(opt++) = ND_OPT_REDIRECT_HDR;
1490 *(opt++) = (rd_len >> 3);
1493 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
1495 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
1496 len, IPPROTO_ICMPV6,
1497 csum_partial(icmph, len, 0));
1499 skb_dst_set(buff, dst);
1501 idev = __in6_dev_get(dst->dev);
1502 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
1503 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1506 ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT);
1507 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
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_transport_header(skb);
1532 __skb_push(skb, skb->data - skb_transport_header(skb));
1534 if (ipv6_hdr(skb)->hop_limit != 255) {
1535 ND_PRINTK(2, warn, "NDISC: invalid hop-limit: %d\n",
1536 ipv6_hdr(skb)->hop_limit);
1540 if (msg->icmph.icmp6_code != 0) {
1541 ND_PRINTK(2, warn, "NDISC: invalid ICMPv6 code: %d\n",
1542 msg->icmph.icmp6_code);
1546 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1548 switch (msg->icmph.icmp6_type) {
1549 case NDISC_NEIGHBOUR_SOLICITATION:
1553 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1557 case NDISC_ROUTER_SOLICITATION:
1561 case NDISC_ROUTER_ADVERTISEMENT:
1562 ndisc_router_discovery(skb);
1565 case NDISC_REDIRECT:
1566 ndisc_redirect_rcv(skb);
1573 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1575 struct net_device *dev = ptr;
1576 struct net *net = dev_net(dev);
1579 case NETDEV_CHANGEADDR:
1580 neigh_changeaddr(&nd_tbl, dev);
1581 fib6_run_gc(~0UL, net);
1584 neigh_ifdown(&nd_tbl, dev);
1585 fib6_run_gc(~0UL, net);
1587 case NETDEV_NOTIFY_PEERS:
1588 ndisc_send_unsol_na(dev);
1597 static struct notifier_block ndisc_netdev_notifier = {
1598 .notifier_call = ndisc_netdev_event,
1601 #ifdef CONFIG_SYSCTL
1602 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1603 const char *func, const char *dev_name)
1605 static char warncomm[TASK_COMM_LEN];
1607 if (strcmp(warncomm, current->comm) && warned < 5) {
1608 strcpy(warncomm, current->comm);
1609 pr_warn("process `%s' is using deprecated sysctl (%s) net.ipv6.neigh.%s.%s - use net.ipv6.neigh.%s.%s_ms instead\n",
1611 dev_name, ctl->procname,
1612 dev_name, ctl->procname);
1617 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos)
1619 struct net_device *dev = ctl->extra1;
1620 struct inet6_dev *idev;
1623 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1624 (strcmp(ctl->procname, "base_reachable_time") == 0))
1625 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1627 if (strcmp(ctl->procname, "retrans_time") == 0)
1628 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1630 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1631 ret = proc_dointvec_jiffies(ctl, write,
1632 buffer, lenp, ppos);
1634 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1635 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1636 ret = proc_dointvec_ms_jiffies(ctl, write,
1637 buffer, lenp, ppos);
1641 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1642 if (ctl->data == &idev->nd_parms->base_reachable_time)
1643 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1644 idev->tstamp = jiffies;
1645 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1654 static int __net_init ndisc_net_init(struct net *net)
1656 struct ipv6_pinfo *np;
1660 err = inet_ctl_sock_create(&sk, PF_INET6,
1661 SOCK_RAW, IPPROTO_ICMPV6, net);
1664 "NDISC: Failed to initialize the control socket (err %d)\n",
1669 net->ipv6.ndisc_sk = sk;
1672 np->hop_limit = 255;
1673 /* Do not loopback ndisc messages */
1679 static void __net_exit ndisc_net_exit(struct net *net)
1681 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1684 static struct pernet_operations ndisc_net_ops = {
1685 .init = ndisc_net_init,
1686 .exit = ndisc_net_exit,
1689 int __init ndisc_init(void)
1693 err = register_pernet_subsys(&ndisc_net_ops);
1697 * Initialize the neighbour table
1699 neigh_table_init(&nd_tbl);
1701 #ifdef CONFIG_SYSCTL
1702 err = neigh_sysctl_register(NULL, &nd_tbl.parms, "ipv6",
1703 &ndisc_ifinfo_sysctl_change);
1705 goto out_unregister_pernet;
1707 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1709 goto out_unregister_sysctl;
1713 out_unregister_sysctl:
1714 #ifdef CONFIG_SYSCTL
1715 neigh_sysctl_unregister(&nd_tbl.parms);
1716 out_unregister_pernet:
1718 unregister_pernet_subsys(&ndisc_net_ops);
1722 void ndisc_cleanup(void)
1724 unregister_netdevice_notifier(&ndisc_netdev_notifier);
1725 #ifdef CONFIG_SYSCTL
1726 neigh_sysctl_unregister(&nd_tbl.parms);
1728 neigh_table_clear(&nd_tbl);
1729 unregister_pernet_subsys(&ndisc_net_ops);