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 void ndisc_fill_addr_option(struct sk_buff *skb, int type, void *data)
148 int pad = ndisc_addr_option_pad(skb->dev->type);
149 int data_len = skb->dev->addr_len;
150 int space = ndisc_opt_addr_space(skb->dev);
151 u8 *opt = skb_put(skb, space);
156 memset(opt + 2, 0, pad);
160 memcpy(opt+2, data, data_len);
163 if ((space -= data_len) > 0)
164 memset(opt, 0, space);
167 static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
168 struct nd_opt_hdr *end)
171 if (!cur || !end || cur >= end)
173 type = cur->nd_opt_type;
175 cur = ((void *)cur) + (cur->nd_opt_len << 3);
176 } while(cur < end && cur->nd_opt_type != type);
177 return cur <= end && cur->nd_opt_type == type ? cur : NULL;
180 static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
182 return opt->nd_opt_type == ND_OPT_RDNSS ||
183 opt->nd_opt_type == ND_OPT_DNSSL;
186 static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur,
187 struct nd_opt_hdr *end)
189 if (!cur || !end || cur >= end)
192 cur = ((void *)cur) + (cur->nd_opt_len << 3);
193 } while(cur < end && !ndisc_is_useropt(cur));
194 return cur <= end && ndisc_is_useropt(cur) ? cur : NULL;
197 struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
198 struct ndisc_options *ndopts)
200 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
202 if (!nd_opt || opt_len < 0 || !ndopts)
204 memset(ndopts, 0, sizeof(*ndopts));
207 if (opt_len < sizeof(struct nd_opt_hdr))
209 l = nd_opt->nd_opt_len << 3;
210 if (opt_len < l || l == 0)
212 switch (nd_opt->nd_opt_type) {
213 case ND_OPT_SOURCE_LL_ADDR:
214 case ND_OPT_TARGET_LL_ADDR:
216 case ND_OPT_REDIRECT_HDR:
217 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
219 "%s: duplicated ND6 option found: type=%d\n",
220 __func__, nd_opt->nd_opt_type);
222 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
225 case ND_OPT_PREFIX_INFO:
226 ndopts->nd_opts_pi_end = nd_opt;
227 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
228 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
230 #ifdef CONFIG_IPV6_ROUTE_INFO
231 case ND_OPT_ROUTE_INFO:
232 ndopts->nd_opts_ri_end = nd_opt;
233 if (!ndopts->nd_opts_ri)
234 ndopts->nd_opts_ri = nd_opt;
238 if (ndisc_is_useropt(nd_opt)) {
239 ndopts->nd_useropts_end = nd_opt;
240 if (!ndopts->nd_useropts)
241 ndopts->nd_useropts = nd_opt;
244 * Unknown options must be silently ignored,
245 * to accommodate future extension to the
249 "%s: ignored unsupported option; type=%d, len=%d\n",
256 nd_opt = ((void *)nd_opt) + l;
261 int ndisc_mc_map(const struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
265 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
267 ipv6_eth_mc_map(addr, buf);
270 ipv6_arcnet_mc_map(addr, buf);
272 case ARPHRD_INFINIBAND:
273 ipv6_ib_mc_map(addr, dev->broadcast, buf);
276 return ipv6_ipgre_mc_map(addr, dev->broadcast, buf);
279 memcpy(buf, dev->broadcast, dev->addr_len);
286 EXPORT_SYMBOL(ndisc_mc_map);
288 static u32 ndisc_hash(const void *pkey,
289 const struct net_device *dev,
292 return ndisc_hashfn(pkey, dev, hash_rnd);
295 static int ndisc_constructor(struct neighbour *neigh)
297 struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;
298 struct net_device *dev = neigh->dev;
299 struct inet6_dev *in6_dev;
300 struct neigh_parms *parms;
301 bool is_multicast = ipv6_addr_is_multicast(addr);
303 in6_dev = in6_dev_get(dev);
304 if (in6_dev == NULL) {
308 parms = in6_dev->nd_parms;
309 __neigh_parms_put(neigh->parms);
310 neigh->parms = neigh_parms_clone(parms);
312 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
313 if (!dev->header_ops) {
314 neigh->nud_state = NUD_NOARP;
315 neigh->ops = &ndisc_direct_ops;
316 neigh->output = neigh_direct_output;
319 neigh->nud_state = NUD_NOARP;
320 ndisc_mc_map(addr, neigh->ha, dev, 1);
321 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
322 neigh->nud_state = NUD_NOARP;
323 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
324 if (dev->flags&IFF_LOOPBACK)
325 neigh->type = RTN_LOCAL;
326 } else if (dev->flags&IFF_POINTOPOINT) {
327 neigh->nud_state = NUD_NOARP;
328 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
330 if (dev->header_ops->cache)
331 neigh->ops = &ndisc_hh_ops;
333 neigh->ops = &ndisc_generic_ops;
334 if (neigh->nud_state&NUD_VALID)
335 neigh->output = neigh->ops->connected_output;
337 neigh->output = neigh->ops->output;
339 in6_dev_put(in6_dev);
343 static int pndisc_constructor(struct pneigh_entry *n)
345 struct in6_addr *addr = (struct in6_addr*)&n->key;
346 struct in6_addr maddr;
347 struct net_device *dev = n->dev;
349 if (dev == NULL || __in6_dev_get(dev) == NULL)
351 addrconf_addr_solict_mult(addr, &maddr);
352 ipv6_dev_mc_inc(dev, &maddr);
356 static void pndisc_destructor(struct pneigh_entry *n)
358 struct in6_addr *addr = (struct in6_addr*)&n->key;
359 struct in6_addr maddr;
360 struct net_device *dev = n->dev;
362 if (dev == NULL || __in6_dev_get(dev) == NULL)
364 addrconf_addr_solict_mult(addr, &maddr);
365 ipv6_dev_mc_dec(dev, &maddr);
368 static struct sk_buff *ndisc_alloc_skb(struct net_device *dev,
371 int hlen = LL_RESERVED_SPACE(dev);
372 int tlen = dev->needed_tailroom;
373 struct sock *sk = dev_net(dev)->ipv6.ndisc_sk;
377 skb = sock_alloc_send_skb(sk,
378 hlen + sizeof(struct ipv6hdr) + len + tlen,
381 ND_PRINTK(0, err, "ndisc: %s failed to allocate an skb, err=%d\n",
386 skb->protocol = htons(ETH_P_IPV6);
389 skb_reserve(skb, hlen + sizeof(struct ipv6hdr));
390 skb_reset_transport_header(skb);
395 static void ip6_nd_hdr(struct sk_buff *skb,
396 const struct in6_addr *saddr,
397 const struct in6_addr *daddr,
398 int hop_limit, int len)
402 skb_push(skb, sizeof(*hdr));
403 skb_reset_network_header(skb);
406 ip6_flow_hdr(hdr, 0, 0);
408 hdr->payload_len = htons(len);
409 hdr->nexthdr = IPPROTO_ICMPV6;
410 hdr->hop_limit = hop_limit;
416 static void ndisc_send_skb(struct sk_buff *skb,
417 const struct in6_addr *daddr,
418 const struct in6_addr *saddr)
420 struct dst_entry *dst = skb_dst(skb);
421 struct net *net = dev_net(skb->dev);
422 struct sock *sk = net->ipv6.ndisc_sk;
423 struct inet6_dev *idev;
425 struct icmp6hdr *icmp6h = icmp6_hdr(skb);
428 type = icmp6h->icmp6_type;
433 icmpv6_flow_init(sk, &fl6, type, saddr, daddr, skb->dev->ifindex);
434 dst = icmp6_dst_alloc(skb->dev, &fl6);
440 skb_dst_set(skb, dst);
443 icmp6h->icmp6_cksum = csum_ipv6_magic(saddr, daddr, skb->len,
448 ip6_nd_hdr(skb, saddr, daddr, inet6_sk(sk)->hop_limit, skb->len);
451 idev = __in6_dev_get(dst->dev);
452 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
454 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
457 ICMP6MSGOUT_INC_STATS(net, idev, type);
458 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
464 void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
465 const struct in6_addr *daddr,
466 const struct in6_addr *solicited_addr,
467 bool router, bool solicited, bool override, bool inc_opt)
470 struct in6_addr tmpaddr;
471 struct inet6_ifaddr *ifp;
472 const struct in6_addr *src_addr;
476 /* for anycast or proxy, solicited_addr != src_addr */
477 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
479 src_addr = solicited_addr;
480 if (ifp->flags & IFA_F_OPTIMISTIC)
482 inc_opt |= ifp->idev->cnf.force_tllao;
485 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
486 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
495 optlen += ndisc_opt_addr_space(dev);
497 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
501 msg = (struct nd_msg *)skb_put(skb, sizeof(*msg));
502 *msg = (struct nd_msg) {
504 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
505 .icmp6_router = router,
506 .icmp6_solicited = solicited,
507 .icmp6_override = override,
509 .target = *solicited_addr,
513 ndisc_fill_addr_option(skb, ND_OPT_TARGET_LL_ADDR,
517 ndisc_send_skb(skb, daddr, src_addr);
520 static void ndisc_send_unsol_na(struct net_device *dev)
522 struct inet6_dev *idev;
523 struct inet6_ifaddr *ifa;
525 idev = in6_dev_get(dev);
529 read_lock_bh(&idev->lock);
530 list_for_each_entry(ifa, &idev->addr_list, if_list) {
531 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &ifa->addr,
532 /*router=*/ !!idev->cnf.forwarding,
533 /*solicited=*/ false, /*override=*/ true,
536 read_unlock_bh(&idev->lock);
541 void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
542 const struct in6_addr *solicit,
543 const struct in6_addr *daddr, const struct in6_addr *saddr)
546 struct in6_addr addr_buf;
547 int inc_opt = dev->addr_len;
552 if (ipv6_get_lladdr(dev, &addr_buf,
553 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
558 if (ipv6_addr_any(saddr))
561 optlen += ndisc_opt_addr_space(dev);
563 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
567 msg = (struct nd_msg *)skb_put(skb, sizeof(*msg));
568 *msg = (struct nd_msg) {
570 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
576 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
579 ndisc_send_skb(skb, daddr, saddr);
582 void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
583 const struct in6_addr *daddr)
587 int send_sllao = dev->addr_len;
590 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
592 * According to section 2.2 of RFC 4429, we must not
593 * send router solicitations with a sllao from
594 * optimistic addresses, but we may send the solicitation
595 * if we don't include the sllao. So here we check
596 * if our address is optimistic, and if so, we
597 * suppress the inclusion of the sllao.
600 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
603 if (ifp->flags & IFA_F_OPTIMISTIC) {
613 optlen += ndisc_opt_addr_space(dev);
615 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
619 msg = (struct rs_msg *)skb_put(skb, sizeof(*msg));
620 *msg = (struct rs_msg) {
622 .icmp6_type = NDISC_ROUTER_SOLICITATION,
627 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
630 ndisc_send_skb(skb, daddr, saddr);
634 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
637 * "The sender MUST return an ICMP
638 * destination unreachable"
640 dst_link_failure(skb);
644 /* Called with locked neigh: either read or both */
646 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
648 struct in6_addr *saddr = NULL;
649 struct in6_addr mcaddr;
650 struct net_device *dev = neigh->dev;
651 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
652 int probes = atomic_read(&neigh->probes);
654 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
655 saddr = &ipv6_hdr(skb)->saddr;
657 if ((probes -= neigh->parms->ucast_probes) < 0) {
658 if (!(neigh->nud_state & NUD_VALID)) {
660 "%s: trying to ucast probe in NUD_INVALID: %pI6\n",
663 ndisc_send_ns(dev, neigh, target, target, saddr);
664 } else if ((probes -= neigh->parms->app_probes) < 0) {
669 addrconf_addr_solict_mult(target, &mcaddr);
670 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
674 static int pndisc_is_router(const void *pkey,
675 struct net_device *dev)
677 struct pneigh_entry *n;
680 read_lock_bh(&nd_tbl.lock);
681 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
683 ret = !!(n->flags & NTF_ROUTER);
684 read_unlock_bh(&nd_tbl.lock);
689 static void ndisc_recv_ns(struct sk_buff *skb)
691 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
692 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
693 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
695 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
696 offsetof(struct nd_msg, opt));
697 struct ndisc_options ndopts;
698 struct net_device *dev = skb->dev;
699 struct inet6_ifaddr *ifp;
700 struct inet6_dev *idev = NULL;
701 struct neighbour *neigh;
702 int dad = ipv6_addr_any(saddr);
706 if (skb->len < sizeof(struct nd_msg)) {
707 ND_PRINTK(2, warn, "NS: packet too short\n");
711 if (ipv6_addr_is_multicast(&msg->target)) {
712 ND_PRINTK(2, warn, "NS: multicast target address\n");
718 * DAD has to be destined for solicited node multicast address.
720 if (dad && !ipv6_addr_is_solict_mult(daddr)) {
721 ND_PRINTK(2, warn, "NS: bad DAD packet (wrong destination)\n");
725 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
726 ND_PRINTK(2, warn, "NS: invalid ND options\n");
730 if (ndopts.nd_opts_src_lladdr) {
731 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
734 "NS: invalid link-layer address length\n");
739 * If the IP source address is the unspecified address,
740 * there MUST NOT be source link-layer address option
745 "NS: bad DAD packet (link-layer address option)\n");
750 inc = ipv6_addr_is_multicast(daddr);
752 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
755 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
758 * We are colliding with another node
760 * so fail our DAD process
762 addrconf_dad_failure(ifp);
766 * This is not a dad solicitation.
767 * If we are an optimistic node,
769 * Otherwise, we should ignore it.
771 if (!(ifp->flags & IFA_F_OPTIMISTIC))
778 struct net *net = dev_net(dev);
780 idev = in6_dev_get(dev);
782 /* XXX: count this drop? */
786 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
787 (idev->cnf.forwarding &&
788 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
789 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
790 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
791 skb->pkt_type != PACKET_HOST &&
793 idev->nd_parms->proxy_delay != 0) {
795 * for anycast or proxy,
796 * sender should delay its response
797 * by a random time between 0 and
798 * MAX_ANYCAST_DELAY_TIME seconds.
799 * (RFC2461) -- yoshfuji
801 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
803 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
811 is_router = idev->cnf.forwarding;
814 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
815 !!is_router, false, (ifp != NULL), true);
820 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
822 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
825 * update / create cache entry
826 * for the source address
828 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
829 !inc || lladdr || !dev->addr_len);
831 neigh_update(neigh, lladdr, NUD_STALE,
832 NEIGH_UPDATE_F_WEAK_OVERRIDE|
833 NEIGH_UPDATE_F_OVERRIDE);
834 if (neigh || !dev->header_ops) {
835 ndisc_send_na(dev, neigh, saddr, &msg->target,
837 true, (ifp != NULL && inc), inc);
839 neigh_release(neigh);
849 static void ndisc_recv_na(struct sk_buff *skb)
851 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
852 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
853 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
855 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
856 offsetof(struct nd_msg, opt));
857 struct ndisc_options ndopts;
858 struct net_device *dev = skb->dev;
859 struct inet6_ifaddr *ifp;
860 struct neighbour *neigh;
862 if (skb->len < sizeof(struct nd_msg)) {
863 ND_PRINTK(2, warn, "NA: packet too short\n");
867 if (ipv6_addr_is_multicast(&msg->target)) {
868 ND_PRINTK(2, warn, "NA: target address is multicast\n");
872 if (ipv6_addr_is_multicast(daddr) &&
873 msg->icmph.icmp6_solicited) {
874 ND_PRINTK(2, warn, "NA: solicited NA is multicasted\n");
878 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
879 ND_PRINTK(2, warn, "NS: invalid ND option\n");
882 if (ndopts.nd_opts_tgt_lladdr) {
883 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
886 "NA: invalid link-layer address length\n");
890 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
892 if (skb->pkt_type != PACKET_LOOPBACK
893 && (ifp->flags & IFA_F_TENTATIVE)) {
894 addrconf_dad_failure(ifp);
897 /* What should we make now? The advertisement
898 is invalid, but ndisc specs say nothing
899 about it. It could be misconfiguration, or
900 an smart proxy agent tries to help us :-)
902 We should not print the error if NA has been
903 received from loopback - it is just our own
904 unsolicited advertisement.
906 if (skb->pkt_type != PACKET_LOOPBACK)
908 "NA: someone advertises our address %pI6 on %s!\n",
909 &ifp->addr, ifp->idev->dev->name);
913 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
916 u8 old_flags = neigh->flags;
917 struct net *net = dev_net(dev);
919 if (neigh->nud_state & NUD_FAILED)
923 * Don't update the neighbor cache entry on a proxy NA from
924 * ourselves because either the proxied node is off link or it
925 * has already sent a NA to us.
927 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
928 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
929 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
930 /* XXX: idev->cnf.proxy_ndp */
934 neigh_update(neigh, lladdr,
935 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
936 NEIGH_UPDATE_F_WEAK_OVERRIDE|
937 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
938 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
939 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
941 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
943 * Change: router to host
946 rt = rt6_get_dflt_router(saddr, dev);
952 neigh_release(neigh);
956 static void ndisc_recv_rs(struct sk_buff *skb)
958 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
959 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
960 struct neighbour *neigh;
961 struct inet6_dev *idev;
962 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
963 struct ndisc_options ndopts;
966 if (skb->len < sizeof(*rs_msg))
969 idev = __in6_dev_get(skb->dev);
971 ND_PRINTK(1, err, "RS: can't find in6 device\n");
975 /* Don't accept RS if we're not in router mode */
976 if (!idev->cnf.forwarding)
980 * Don't update NCE if src = ::;
981 * this implies that the source node has no ip address assigned yet.
983 if (ipv6_addr_any(saddr))
986 /* Parse ND options */
987 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
988 ND_PRINTK(2, notice, "NS: invalid ND option, ignored\n");
992 if (ndopts.nd_opts_src_lladdr) {
993 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
999 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1001 neigh_update(neigh, lladdr, NUD_STALE,
1002 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1003 NEIGH_UPDATE_F_OVERRIDE|
1004 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1005 neigh_release(neigh);
1011 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1013 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1014 struct sk_buff *skb;
1015 struct nlmsghdr *nlh;
1016 struct nduseroptmsg *ndmsg;
1017 struct net *net = dev_net(ra->dev);
1019 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1020 + (opt->nd_opt_len << 3));
1021 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1023 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1029 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1031 goto nla_put_failure;
1034 ndmsg = nlmsg_data(nlh);
1035 ndmsg->nduseropt_family = AF_INET6;
1036 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
1037 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1038 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1039 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1041 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1043 if (nla_put(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1044 &ipv6_hdr(ra)->saddr))
1045 goto nla_put_failure;
1046 nlmsg_end(skb, nlh);
1048 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
1055 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1058 static void ndisc_router_discovery(struct sk_buff *skb)
1060 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1061 struct neighbour *neigh = NULL;
1062 struct inet6_dev *in6_dev;
1063 struct rt6_info *rt = NULL;
1065 struct ndisc_options ndopts;
1067 unsigned int pref = 0;
1069 __u8 * opt = (__u8 *)(ra_msg + 1);
1071 optlen = (skb_tail_pointer(skb) - skb_transport_header(skb)) -
1072 sizeof(struct ra_msg);
1074 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1075 ND_PRINTK(2, warn, "RA: source address is not link-local\n");
1079 ND_PRINTK(2, warn, "RA: packet too short\n");
1083 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1084 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1085 ND_PRINTK(2, warn, "RA: from host or unauthorized router\n");
1091 * set the RA_RECV flag in the interface
1094 in6_dev = __in6_dev_get(skb->dev);
1095 if (in6_dev == NULL) {
1096 ND_PRINTK(0, err, "RA: can't find inet6 device for %s\n",
1101 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1102 ND_PRINTK(2, warn, "RA: invalid ND options\n");
1106 if (!ipv6_accept_ra(in6_dev))
1107 goto skip_linkparms;
1109 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1110 /* skip link-specific parameters from interior routers */
1111 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1112 goto skip_linkparms;
1115 if (in6_dev->if_flags & IF_RS_SENT) {
1117 * flag that an RA was received after an RS was sent
1118 * out on this interface.
1120 in6_dev->if_flags |= IF_RA_RCVD;
1124 * Remember the managed/otherconf flags from most recently
1125 * received RA message (RFC 2462) -- yoshfuji
1127 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1129 (ra_msg->icmph.icmp6_addrconf_managed ?
1130 IF_RA_MANAGED : 0) |
1131 (ra_msg->icmph.icmp6_addrconf_other ?
1132 IF_RA_OTHERCONF : 0);
1134 if (!in6_dev->cnf.accept_ra_defrtr)
1137 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
1140 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1142 #ifdef CONFIG_IPV6_ROUTER_PREF
1143 pref = ra_msg->icmph.icmp6_router_pref;
1144 /* 10b is handled as if it were 00b (medium) */
1145 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1146 !in6_dev->cnf.accept_ra_rtr_pref)
1147 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1150 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1153 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1156 "RA: %s got default router without neighbour\n",
1162 if (rt && lifetime == 0) {
1167 if (rt == NULL && lifetime) {
1168 ND_PRINTK(3, dbg, "RA: adding default router\n");
1170 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1173 "RA: %s failed to add default route\n",
1178 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1179 if (neigh == NULL) {
1181 "RA: %s got default router without neighbour\n",
1186 neigh->flags |= NTF_ROUTER;
1188 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1192 rt6_set_expires(rt, jiffies + (HZ * lifetime));
1193 if (ra_msg->icmph.icmp6_hop_limit) {
1194 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1196 dst_metric_set(&rt->dst, RTAX_HOPLIMIT,
1197 ra_msg->icmph.icmp6_hop_limit);
1203 * Update Reachable Time and Retrans Timer
1206 if (in6_dev->nd_parms) {
1207 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1209 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1210 rtime = (rtime*HZ)/1000;
1213 in6_dev->nd_parms->retrans_time = rtime;
1214 in6_dev->tstamp = jiffies;
1215 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1218 rtime = ntohl(ra_msg->reachable_time);
1219 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1220 rtime = (rtime*HZ)/1000;
1225 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1226 in6_dev->nd_parms->base_reachable_time = rtime;
1227 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1228 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1229 in6_dev->tstamp = jiffies;
1230 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1242 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1246 if (ndopts.nd_opts_src_lladdr) {
1247 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1251 "RA: invalid link-layer address length\n");
1255 neigh_update(neigh, lladdr, NUD_STALE,
1256 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1257 NEIGH_UPDATE_F_OVERRIDE|
1258 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1259 NEIGH_UPDATE_F_ISROUTER);
1262 if (!ipv6_accept_ra(in6_dev))
1265 #ifdef CONFIG_IPV6_ROUTE_INFO
1266 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
1267 goto skip_routeinfo;
1269 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1270 struct nd_opt_hdr *p;
1271 for (p = ndopts.nd_opts_ri;
1273 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1274 struct route_info *ri = (struct route_info *)p;
1275 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1276 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1277 ri->prefix_len == 0)
1280 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1282 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1283 &ipv6_hdr(skb)->saddr);
1290 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1291 /* skip link-specific ndopts from interior routers */
1292 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1296 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1297 struct nd_opt_hdr *p;
1298 for (p = ndopts.nd_opts_pi;
1300 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1301 addrconf_prefix_rcv(skb->dev, (u8 *)p,
1302 (p->nd_opt_len) << 3,
1303 ndopts.nd_opts_src_lladdr != NULL);
1307 if (ndopts.nd_opts_mtu) {
1311 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1314 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1315 ND_PRINTK(2, warn, "RA: invalid mtu: %d\n", mtu);
1316 } else if (in6_dev->cnf.mtu6 != mtu) {
1317 in6_dev->cnf.mtu6 = mtu;
1320 dst_metric_set(&rt->dst, RTAX_MTU, mtu);
1322 rt6_mtu_change(skb->dev, mtu);
1326 if (ndopts.nd_useropts) {
1327 struct nd_opt_hdr *p;
1328 for (p = ndopts.nd_useropts;
1330 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1331 ndisc_ra_useropt(skb, p);
1335 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1336 ND_PRINTK(2, warn, "RA: invalid RA options\n");
1341 neigh_release(neigh);
1344 static void ndisc_redirect_rcv(struct sk_buff *skb)
1347 struct ndisc_options ndopts;
1348 struct rd_msg *msg = (struct rd_msg *)skb_transport_header(skb);
1349 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
1350 offsetof(struct rd_msg, opt));
1352 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1353 switch (skb->ndisc_nodetype) {
1354 case NDISC_NODETYPE_HOST:
1355 case NDISC_NODETYPE_NODEFAULT:
1357 "Redirect: from host or unauthorized router\n");
1362 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1364 "Redirect: source address is not link-local\n");
1368 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts))
1371 if (!ndopts.nd_opts_rh) {
1372 ip6_redirect_no_header(skb, dev_net(skb->dev), 0, 0);
1376 hdr = (u8 *)ndopts.nd_opts_rh;
1378 if (!pskb_pull(skb, hdr - skb_transport_header(skb)))
1381 icmpv6_notify(skb, NDISC_REDIRECT, 0, 0);
1384 static void ndisc_fill_redirect_hdr_option(struct sk_buff *skb,
1385 struct sk_buff *orig_skb,
1388 u8 *opt = skb_put(skb, rd_len);
1391 *(opt++) = ND_OPT_REDIRECT_HDR;
1392 *(opt++) = (rd_len >> 3);
1395 memcpy(opt, ipv6_hdr(orig_skb), rd_len - 8);
1398 void ndisc_send_redirect(struct sk_buff *skb, const struct in6_addr *target)
1400 struct net_device *dev = skb->dev;
1401 struct net *net = dev_net(dev);
1402 struct sock *sk = net->ipv6.ndisc_sk;
1404 struct inet_peer *peer;
1405 struct sk_buff *buff;
1407 struct in6_addr saddr_buf;
1408 struct rt6_info *rt;
1409 struct dst_entry *dst;
1412 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1415 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1416 ND_PRINTK(2, warn, "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)) {
1424 "Redirect: target address is not link-local unicast\n");
1428 icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT,
1429 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
1431 dst = ip6_route_output(net, NULL, &fl6);
1436 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
1440 rt = (struct rt6_info *) dst;
1442 if (rt->rt6i_flags & RTF_GATEWAY) {
1444 "Redirect: destination is not a neighbour\n");
1447 peer = inet_getpeer_v6(net->ipv6.peers, &rt->rt6i_dst.addr, 1);
1448 ret = inet_peer_xrlim_allow(peer, 1*HZ);
1454 if (dev->addr_len) {
1455 struct neighbour *neigh = dst_neigh_lookup(skb_dst(skb), target);
1458 "Redirect: no neigh for target address\n");
1462 read_lock_bh(&neigh->lock);
1463 if (neigh->nud_state & NUD_VALID) {
1464 memcpy(ha_buf, neigh->ha, dev->addr_len);
1465 read_unlock_bh(&neigh->lock);
1467 optlen += ndisc_opt_addr_space(dev);
1469 read_unlock_bh(&neigh->lock);
1471 neigh_release(neigh);
1474 rd_len = min_t(unsigned int,
1475 IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(*msg) - optlen,
1480 buff = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
1484 msg = (struct rd_msg *)skb_put(buff, sizeof(*msg));
1485 *msg = (struct rd_msg) {
1487 .icmp6_type = NDISC_REDIRECT,
1490 .dest = ipv6_hdr(skb)->daddr,
1494 * include target_address option
1498 ndisc_fill_addr_option(buff, ND_OPT_TARGET_LL_ADDR, ha);
1501 * build redirect option and copy skb over to the new packet.
1505 ndisc_fill_redirect_hdr_option(buff, skb, rd_len);
1507 skb_dst_set(buff, dst);
1508 ndisc_send_skb(buff, &ipv6_hdr(skb)->saddr, &saddr_buf);
1515 static void pndisc_redo(struct sk_buff *skb)
1521 static bool ndisc_suppress_frag_ndisc(struct sk_buff *skb)
1523 struct inet6_dev *idev = __in6_dev_get(skb->dev);
1527 if (IP6CB(skb)->flags & IP6SKB_FRAGMENTED &&
1528 idev->cnf.suppress_frag_ndisc) {
1529 net_warn_ratelimited("Received fragmented ndisc packet. Carefully consider disabling suppress_frag_ndisc.\n");
1535 int ndisc_rcv(struct sk_buff *skb)
1539 if (ndisc_suppress_frag_ndisc(skb))
1542 if (skb_linearize(skb))
1545 msg = (struct nd_msg *)skb_transport_header(skb);
1547 __skb_push(skb, skb->data - skb_transport_header(skb));
1549 if (ipv6_hdr(skb)->hop_limit != 255) {
1550 ND_PRINTK(2, warn, "NDISC: invalid hop-limit: %d\n",
1551 ipv6_hdr(skb)->hop_limit);
1555 if (msg->icmph.icmp6_code != 0) {
1556 ND_PRINTK(2, warn, "NDISC: invalid ICMPv6 code: %d\n",
1557 msg->icmph.icmp6_code);
1561 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1563 switch (msg->icmph.icmp6_type) {
1564 case NDISC_NEIGHBOUR_SOLICITATION:
1568 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1572 case NDISC_ROUTER_SOLICITATION:
1576 case NDISC_ROUTER_ADVERTISEMENT:
1577 ndisc_router_discovery(skb);
1580 case NDISC_REDIRECT:
1581 ndisc_redirect_rcv(skb);
1588 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1590 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1591 struct net *net = dev_net(dev);
1592 struct inet6_dev *idev;
1595 case NETDEV_CHANGEADDR:
1596 neigh_changeaddr(&nd_tbl, dev);
1597 fib6_run_gc(0, net, false);
1598 idev = in6_dev_get(dev);
1601 if (idev->cnf.ndisc_notify)
1602 ndisc_send_unsol_na(dev);
1606 neigh_ifdown(&nd_tbl, dev);
1607 fib6_run_gc(0, net, false);
1609 case NETDEV_NOTIFY_PEERS:
1610 ndisc_send_unsol_na(dev);
1619 static struct notifier_block ndisc_netdev_notifier = {
1620 .notifier_call = ndisc_netdev_event,
1623 #ifdef CONFIG_SYSCTL
1624 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1625 const char *func, const char *dev_name)
1627 static char warncomm[TASK_COMM_LEN];
1629 if (strcmp(warncomm, current->comm) && warned < 5) {
1630 strcpy(warncomm, current->comm);
1631 pr_warn("process `%s' is using deprecated sysctl (%s) net.ipv6.neigh.%s.%s - use net.ipv6.neigh.%s.%s_ms instead\n",
1633 dev_name, ctl->procname,
1634 dev_name, ctl->procname);
1639 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos)
1641 struct net_device *dev = ctl->extra1;
1642 struct inet6_dev *idev;
1645 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1646 (strcmp(ctl->procname, "base_reachable_time") == 0))
1647 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1649 if (strcmp(ctl->procname, "retrans_time") == 0)
1650 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1652 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1653 ret = proc_dointvec_jiffies(ctl, write,
1654 buffer, lenp, ppos);
1656 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1657 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1658 ret = proc_dointvec_ms_jiffies(ctl, write,
1659 buffer, lenp, ppos);
1663 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1664 if (ctl->data == &idev->nd_parms->base_reachable_time)
1665 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1666 idev->tstamp = jiffies;
1667 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1676 static int __net_init ndisc_net_init(struct net *net)
1678 struct ipv6_pinfo *np;
1682 err = inet_ctl_sock_create(&sk, PF_INET6,
1683 SOCK_RAW, IPPROTO_ICMPV6, net);
1686 "NDISC: Failed to initialize the control socket (err %d)\n",
1691 net->ipv6.ndisc_sk = sk;
1694 np->hop_limit = 255;
1695 /* Do not loopback ndisc messages */
1701 static void __net_exit ndisc_net_exit(struct net *net)
1703 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1706 static struct pernet_operations ndisc_net_ops = {
1707 .init = ndisc_net_init,
1708 .exit = ndisc_net_exit,
1711 int __init ndisc_init(void)
1715 err = register_pernet_subsys(&ndisc_net_ops);
1719 * Initialize the neighbour table
1721 neigh_table_init(&nd_tbl);
1723 #ifdef CONFIG_SYSCTL
1724 err = neigh_sysctl_register(NULL, &nd_tbl.parms, "ipv6",
1725 &ndisc_ifinfo_sysctl_change);
1727 goto out_unregister_pernet;
1729 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1731 goto out_unregister_sysctl;
1735 out_unregister_sysctl:
1736 #ifdef CONFIG_SYSCTL
1737 neigh_sysctl_unregister(&nd_tbl.parms);
1738 out_unregister_pernet:
1740 unregister_pernet_subsys(&ndisc_net_ops);
1744 void ndisc_cleanup(void)
1746 unregister_netdevice_notifier(&ndisc_netdev_notifier);
1747 #ifdef CONFIG_SYSCTL
1748 neigh_sysctl_unregister(&nd_tbl.parms);
1750 neigh_table_clear(&nd_tbl);
1751 unregister_pernet_subsys(&ndisc_net_ops);