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;
376 skb = alloc_skb(hlen + sizeof(struct ipv6hdr) + len + tlen, GFP_ATOMIC);
378 ND_PRINTK(0, err, "ndisc: %s failed to allocate an skb\n",
383 skb->protocol = htons(ETH_P_IPV6);
386 skb_reserve(skb, hlen + sizeof(struct ipv6hdr));
387 skb_reset_transport_header(skb);
389 /* Manually assign socket ownership as we avoid calling
390 * sock_alloc_send_pskb() to bypass wmem buffer limits
392 skb_set_owner_w(skb, sk);
397 static void ip6_nd_hdr(struct sk_buff *skb,
398 const struct in6_addr *saddr,
399 const struct in6_addr *daddr,
400 int hop_limit, int len)
404 skb_push(skb, sizeof(*hdr));
405 skb_reset_network_header(skb);
408 ip6_flow_hdr(hdr, 0, 0);
410 hdr->payload_len = htons(len);
411 hdr->nexthdr = IPPROTO_ICMPV6;
412 hdr->hop_limit = hop_limit;
418 static void ndisc_send_skb(struct sk_buff *skb,
419 const struct in6_addr *daddr,
420 const struct in6_addr *saddr)
422 struct dst_entry *dst = skb_dst(skb);
423 struct net *net = dev_net(skb->dev);
424 struct sock *sk = net->ipv6.ndisc_sk;
425 struct inet6_dev *idev;
427 struct icmp6hdr *icmp6h = icmp6_hdr(skb);
430 type = icmp6h->icmp6_type;
433 struct sock *sk = net->ipv6.ndisc_sk;
436 icmpv6_flow_init(sk, &fl6, type, saddr, daddr, skb->dev->ifindex);
437 dst = icmp6_dst_alloc(skb->dev, &fl6);
443 skb_dst_set(skb, dst);
446 icmp6h->icmp6_cksum = csum_ipv6_magic(saddr, daddr, skb->len,
451 ip6_nd_hdr(skb, saddr, daddr, inet6_sk(sk)->hop_limit, skb->len);
454 idev = __in6_dev_get(dst->dev);
455 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
457 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
460 ICMP6MSGOUT_INC_STATS(net, idev, type);
461 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
467 static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
468 const struct in6_addr *daddr,
469 const struct in6_addr *solicited_addr,
470 bool router, bool solicited, bool override, bool inc_opt)
473 struct in6_addr tmpaddr;
474 struct inet6_ifaddr *ifp;
475 const struct in6_addr *src_addr;
479 /* for anycast or proxy, solicited_addr != src_addr */
480 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
482 src_addr = solicited_addr;
483 if (ifp->flags & IFA_F_OPTIMISTIC)
485 inc_opt |= ifp->idev->cnf.force_tllao;
488 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
489 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
498 optlen += ndisc_opt_addr_space(dev);
500 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
504 msg = (struct nd_msg *)skb_put(skb, sizeof(*msg));
505 *msg = (struct nd_msg) {
507 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
508 .icmp6_router = router,
509 .icmp6_solicited = solicited,
510 .icmp6_override = override,
512 .target = *solicited_addr,
516 ndisc_fill_addr_option(skb, ND_OPT_TARGET_LL_ADDR,
520 ndisc_send_skb(skb, daddr, src_addr);
523 static void ndisc_send_unsol_na(struct net_device *dev)
525 struct inet6_dev *idev;
526 struct inet6_ifaddr *ifa;
528 idev = in6_dev_get(dev);
532 read_lock_bh(&idev->lock);
533 list_for_each_entry(ifa, &idev->addr_list, if_list) {
534 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &ifa->addr,
535 /*router=*/ !!idev->cnf.forwarding,
536 /*solicited=*/ false, /*override=*/ true,
539 read_unlock_bh(&idev->lock);
544 void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
545 const struct in6_addr *solicit,
546 const struct in6_addr *daddr, const struct in6_addr *saddr)
549 struct in6_addr addr_buf;
550 int inc_opt = dev->addr_len;
555 if (ipv6_get_lladdr(dev, &addr_buf,
556 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
561 if (ipv6_addr_any(saddr))
564 optlen += ndisc_opt_addr_space(dev);
566 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
570 msg = (struct nd_msg *)skb_put(skb, sizeof(*msg));
571 *msg = (struct nd_msg) {
573 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
579 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
582 ndisc_send_skb(skb, daddr, saddr);
585 void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
586 const struct in6_addr *daddr)
590 int send_sllao = dev->addr_len;
593 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
595 * According to section 2.2 of RFC 4429, we must not
596 * send router solicitations with a sllao from
597 * optimistic addresses, but we may send the solicitation
598 * if we don't include the sllao. So here we check
599 * if our address is optimistic, and if so, we
600 * suppress the inclusion of the sllao.
603 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
606 if (ifp->flags & IFA_F_OPTIMISTIC) {
616 optlen += ndisc_opt_addr_space(dev);
618 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
622 msg = (struct rs_msg *)skb_put(skb, sizeof(*msg));
623 *msg = (struct rs_msg) {
625 .icmp6_type = NDISC_ROUTER_SOLICITATION,
630 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
633 ndisc_send_skb(skb, daddr, saddr);
637 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
640 * "The sender MUST return an ICMP
641 * destination unreachable"
643 dst_link_failure(skb);
647 /* Called with locked neigh: either read or both */
649 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
651 struct in6_addr *saddr = NULL;
652 struct in6_addr mcaddr;
653 struct net_device *dev = neigh->dev;
654 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
655 int probes = atomic_read(&neigh->probes);
657 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
658 saddr = &ipv6_hdr(skb)->saddr;
660 if ((probes -= neigh->parms->ucast_probes) < 0) {
661 if (!(neigh->nud_state & NUD_VALID)) {
663 "%s: trying to ucast probe in NUD_INVALID: %pI6\n",
666 ndisc_send_ns(dev, neigh, target, target, saddr);
667 } else if ((probes -= neigh->parms->app_probes) < 0) {
672 addrconf_addr_solict_mult(target, &mcaddr);
673 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
677 static int pndisc_is_router(const void *pkey,
678 struct net_device *dev)
680 struct pneigh_entry *n;
683 read_lock_bh(&nd_tbl.lock);
684 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
686 ret = !!(n->flags & NTF_ROUTER);
687 read_unlock_bh(&nd_tbl.lock);
692 static void ndisc_recv_ns(struct sk_buff *skb)
694 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
695 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
696 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
698 u32 ndoptlen = skb->tail - (skb->transport_header +
699 offsetof(struct nd_msg, opt));
700 struct ndisc_options ndopts;
701 struct net_device *dev = skb->dev;
702 struct inet6_ifaddr *ifp;
703 struct inet6_dev *idev = NULL;
704 struct neighbour *neigh;
705 int dad = ipv6_addr_any(saddr);
709 if (skb->len < sizeof(struct nd_msg)) {
710 ND_PRINTK(2, warn, "NS: packet too short\n");
714 if (ipv6_addr_is_multicast(&msg->target)) {
715 ND_PRINTK(2, warn, "NS: multicast target address\n");
721 * DAD has to be destined for solicited node multicast address.
723 if (dad && !ipv6_addr_is_solict_mult(daddr)) {
724 ND_PRINTK(2, warn, "NS: bad DAD packet (wrong destination)\n");
728 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
729 ND_PRINTK(2, warn, "NS: invalid ND options\n");
733 if (ndopts.nd_opts_src_lladdr) {
734 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
737 "NS: invalid link-layer address length\n");
742 * If the IP source address is the unspecified address,
743 * there MUST NOT be source link-layer address option
748 "NS: bad DAD packet (link-layer address option)\n");
753 inc = ipv6_addr_is_multicast(daddr);
755 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
758 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
761 * We are colliding with another node
763 * so fail our DAD process
765 addrconf_dad_failure(ifp);
769 * This is not a dad solicitation.
770 * If we are an optimistic node,
772 * Otherwise, we should ignore it.
774 if (!(ifp->flags & IFA_F_OPTIMISTIC))
781 struct net *net = dev_net(dev);
783 idev = in6_dev_get(dev);
785 /* XXX: count this drop? */
789 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
790 (idev->cnf.forwarding &&
791 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
792 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
793 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
794 skb->pkt_type != PACKET_HOST &&
796 idev->nd_parms->proxy_delay != 0) {
798 * for anycast or proxy,
799 * sender should delay its response
800 * by a random time between 0 and
801 * MAX_ANYCAST_DELAY_TIME seconds.
802 * (RFC2461) -- yoshfuji
804 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
806 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
814 is_router = idev->cnf.forwarding;
817 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
818 !!is_router, false, (ifp != NULL), true);
823 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
825 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
828 * update / create cache entry
829 * for the source address
831 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
832 !inc || lladdr || !dev->addr_len);
834 neigh_update(neigh, lladdr, NUD_STALE,
835 NEIGH_UPDATE_F_WEAK_OVERRIDE|
836 NEIGH_UPDATE_F_OVERRIDE);
837 if (neigh || !dev->header_ops) {
838 ndisc_send_na(dev, neigh, saddr, &msg->target,
840 true, (ifp != NULL && inc), inc);
842 neigh_release(neigh);
852 static void ndisc_recv_na(struct sk_buff *skb)
854 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
855 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
856 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
858 u32 ndoptlen = skb->tail - (skb->transport_header +
859 offsetof(struct nd_msg, opt));
860 struct ndisc_options ndopts;
861 struct net_device *dev = skb->dev;
862 struct inet6_ifaddr *ifp;
863 struct neighbour *neigh;
865 if (skb->len < sizeof(struct nd_msg)) {
866 ND_PRINTK(2, warn, "NA: packet too short\n");
870 if (ipv6_addr_is_multicast(&msg->target)) {
871 ND_PRINTK(2, warn, "NA: target address is multicast\n");
875 if (ipv6_addr_is_multicast(daddr) &&
876 msg->icmph.icmp6_solicited) {
877 ND_PRINTK(2, warn, "NA: solicited NA is multicasted\n");
881 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
882 ND_PRINTK(2, warn, "NS: invalid ND option\n");
885 if (ndopts.nd_opts_tgt_lladdr) {
886 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
889 "NA: invalid link-layer address length\n");
893 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
895 if (skb->pkt_type != PACKET_LOOPBACK
896 && (ifp->flags & IFA_F_TENTATIVE)) {
897 addrconf_dad_failure(ifp);
900 /* What should we make now? The advertisement
901 is invalid, but ndisc specs say nothing
902 about it. It could be misconfiguration, or
903 an smart proxy agent tries to help us :-)
905 We should not print the error if NA has been
906 received from loopback - it is just our own
907 unsolicited advertisement.
909 if (skb->pkt_type != PACKET_LOOPBACK)
911 "NA: someone advertises our address %pI6 on %s!\n",
912 &ifp->addr, ifp->idev->dev->name);
916 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
919 u8 old_flags = neigh->flags;
920 struct net *net = dev_net(dev);
922 if (neigh->nud_state & NUD_FAILED)
926 * Don't update the neighbor cache entry on a proxy NA from
927 * ourselves because either the proxied node is off link or it
928 * has already sent a NA to us.
930 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
931 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
932 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
933 /* XXX: idev->cnf.proxy_ndp */
937 neigh_update(neigh, lladdr,
938 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
939 NEIGH_UPDATE_F_WEAK_OVERRIDE|
940 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
941 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
942 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
944 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
946 * Change: router to host
949 rt = rt6_get_dflt_router(saddr, dev);
955 neigh_release(neigh);
959 static void ndisc_recv_rs(struct sk_buff *skb)
961 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
962 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
963 struct neighbour *neigh;
964 struct inet6_dev *idev;
965 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
966 struct ndisc_options ndopts;
969 if (skb->len < sizeof(*rs_msg))
972 idev = __in6_dev_get(skb->dev);
974 ND_PRINTK(1, err, "RS: can't find in6 device\n");
978 /* Don't accept RS if we're not in router mode */
979 if (!idev->cnf.forwarding)
983 * Don't update NCE if src = ::;
984 * this implies that the source node has no ip address assigned yet.
986 if (ipv6_addr_any(saddr))
989 /* Parse ND options */
990 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
991 ND_PRINTK(2, notice, "NS: invalid ND option, ignored\n");
995 if (ndopts.nd_opts_src_lladdr) {
996 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1002 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1004 neigh_update(neigh, lladdr, NUD_STALE,
1005 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1006 NEIGH_UPDATE_F_OVERRIDE|
1007 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1008 neigh_release(neigh);
1014 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1016 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1017 struct sk_buff *skb;
1018 struct nlmsghdr *nlh;
1019 struct nduseroptmsg *ndmsg;
1020 struct net *net = dev_net(ra->dev);
1022 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1023 + (opt->nd_opt_len << 3));
1024 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1026 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1032 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1034 goto nla_put_failure;
1037 ndmsg = nlmsg_data(nlh);
1038 ndmsg->nduseropt_family = AF_INET6;
1039 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
1040 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1041 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1042 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1044 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1046 if (nla_put(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1047 &ipv6_hdr(ra)->saddr))
1048 goto nla_put_failure;
1049 nlmsg_end(skb, nlh);
1051 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
1058 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1061 static void ndisc_router_discovery(struct sk_buff *skb)
1063 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1064 struct neighbour *neigh = NULL;
1065 struct inet6_dev *in6_dev;
1066 struct rt6_info *rt = NULL;
1068 struct ndisc_options ndopts;
1070 unsigned int pref = 0;
1072 __u8 * opt = (__u8 *)(ra_msg + 1);
1074 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
1076 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1077 ND_PRINTK(2, warn, "RA: source address is not link-local\n");
1081 ND_PRINTK(2, warn, "RA: packet too short\n");
1085 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1086 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1087 ND_PRINTK(2, warn, "RA: from host or unauthorized router\n");
1093 * set the RA_RECV flag in the interface
1096 in6_dev = __in6_dev_get(skb->dev);
1097 if (in6_dev == NULL) {
1098 ND_PRINTK(0, err, "RA: can't find inet6 device for %s\n",
1103 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1104 ND_PRINTK(2, warn, "RA: invalid ND options\n");
1108 if (!ipv6_accept_ra(in6_dev))
1109 goto skip_linkparms;
1111 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1112 /* skip link-specific parameters from interior routers */
1113 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1114 goto skip_linkparms;
1117 if (in6_dev->if_flags & IF_RS_SENT) {
1119 * flag that an RA was received after an RS was sent
1120 * out on this interface.
1122 in6_dev->if_flags |= IF_RA_RCVD;
1126 * Remember the managed/otherconf flags from most recently
1127 * received RA message (RFC 2462) -- yoshfuji
1129 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1131 (ra_msg->icmph.icmp6_addrconf_managed ?
1132 IF_RA_MANAGED : 0) |
1133 (ra_msg->icmph.icmp6_addrconf_other ?
1134 IF_RA_OTHERCONF : 0);
1136 if (!in6_dev->cnf.accept_ra_defrtr)
1139 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
1142 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1144 #ifdef CONFIG_IPV6_ROUTER_PREF
1145 pref = ra_msg->icmph.icmp6_router_pref;
1146 /* 10b is handled as if it were 00b (medium) */
1147 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1148 !in6_dev->cnf.accept_ra_rtr_pref)
1149 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1152 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1155 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1158 "RA: %s got default router without neighbour\n",
1164 if (rt && lifetime == 0) {
1169 if (rt == NULL && lifetime) {
1170 ND_PRINTK(3, dbg, "RA: adding default router\n");
1172 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1175 "RA: %s failed to add default route\n",
1180 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1181 if (neigh == NULL) {
1183 "RA: %s got default router without neighbour\n",
1188 neigh->flags |= NTF_ROUTER;
1190 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1194 rt6_set_expires(rt, jiffies + (HZ * lifetime));
1195 if (ra_msg->icmph.icmp6_hop_limit) {
1196 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1198 dst_metric_set(&rt->dst, RTAX_HOPLIMIT,
1199 ra_msg->icmph.icmp6_hop_limit);
1205 * Update Reachable Time and Retrans Timer
1208 if (in6_dev->nd_parms) {
1209 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1211 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1212 rtime = (rtime*HZ)/1000;
1215 in6_dev->nd_parms->retrans_time = rtime;
1216 in6_dev->tstamp = jiffies;
1217 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1220 rtime = ntohl(ra_msg->reachable_time);
1221 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1222 rtime = (rtime*HZ)/1000;
1227 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1228 in6_dev->nd_parms->base_reachable_time = rtime;
1229 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1230 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1231 in6_dev->tstamp = jiffies;
1232 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1244 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1248 if (ndopts.nd_opts_src_lladdr) {
1249 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1253 "RA: invalid link-layer address length\n");
1257 neigh_update(neigh, lladdr, NUD_STALE,
1258 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1259 NEIGH_UPDATE_F_OVERRIDE|
1260 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1261 NEIGH_UPDATE_F_ISROUTER);
1264 if (!ipv6_accept_ra(in6_dev))
1267 #ifdef CONFIG_IPV6_ROUTE_INFO
1268 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0))
1269 goto skip_routeinfo;
1271 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1272 struct nd_opt_hdr *p;
1273 for (p = ndopts.nd_opts_ri;
1275 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1276 struct route_info *ri = (struct route_info *)p;
1277 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1278 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1279 ri->prefix_len == 0)
1282 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1284 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1285 &ipv6_hdr(skb)->saddr);
1292 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1293 /* skip link-specific ndopts from interior routers */
1294 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1298 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1299 struct nd_opt_hdr *p;
1300 for (p = ndopts.nd_opts_pi;
1302 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1303 addrconf_prefix_rcv(skb->dev, (u8 *)p,
1304 (p->nd_opt_len) << 3,
1305 ndopts.nd_opts_src_lladdr != NULL);
1309 if (ndopts.nd_opts_mtu) {
1313 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1316 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1317 ND_PRINTK(2, warn, "RA: invalid mtu: %d\n", mtu);
1318 } else if (in6_dev->cnf.mtu6 != mtu) {
1319 in6_dev->cnf.mtu6 = mtu;
1322 dst_metric_set(&rt->dst, RTAX_MTU, mtu);
1324 rt6_mtu_change(skb->dev, mtu);
1328 if (ndopts.nd_useropts) {
1329 struct nd_opt_hdr *p;
1330 for (p = ndopts.nd_useropts;
1332 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1333 ndisc_ra_useropt(skb, p);
1337 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1338 ND_PRINTK(2, warn, "RA: invalid RA options\n");
1343 neigh_release(neigh);
1346 static void ndisc_redirect_rcv(struct sk_buff *skb)
1349 struct ndisc_options ndopts;
1350 struct rd_msg *msg = (struct rd_msg *)skb_transport_header(skb);
1351 u32 ndoptlen = skb->tail - (skb->transport_header +
1352 offsetof(struct rd_msg, opt));
1354 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1355 switch (skb->ndisc_nodetype) {
1356 case NDISC_NODETYPE_HOST:
1357 case NDISC_NODETYPE_NODEFAULT:
1359 "Redirect: from host or unauthorized router\n");
1364 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1366 "Redirect: source address is not link-local\n");
1370 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts))
1373 if (!ndopts.nd_opts_rh)
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 int ndisc_rcv(struct sk_buff *skb)
1525 if (skb_linearize(skb))
1528 msg = (struct nd_msg *)skb_transport_header(skb);
1530 __skb_push(skb, skb->data - skb_transport_header(skb));
1532 if (ipv6_hdr(skb)->hop_limit != 255) {
1533 ND_PRINTK(2, warn, "NDISC: invalid hop-limit: %d\n",
1534 ipv6_hdr(skb)->hop_limit);
1538 if (msg->icmph.icmp6_code != 0) {
1539 ND_PRINTK(2, warn, "NDISC: invalid ICMPv6 code: %d\n",
1540 msg->icmph.icmp6_code);
1544 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1546 switch (msg->icmph.icmp6_type) {
1547 case NDISC_NEIGHBOUR_SOLICITATION:
1551 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1555 case NDISC_ROUTER_SOLICITATION:
1559 case NDISC_ROUTER_ADVERTISEMENT:
1560 ndisc_router_discovery(skb);
1563 case NDISC_REDIRECT:
1564 ndisc_redirect_rcv(skb);
1571 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1573 struct net_device *dev = ptr;
1574 struct net *net = dev_net(dev);
1575 struct inet6_dev *idev;
1578 case NETDEV_CHANGEADDR:
1579 neigh_changeaddr(&nd_tbl, dev);
1580 fib6_run_gc(~0UL, net);
1581 idev = in6_dev_get(dev);
1584 if (idev->cnf.ndisc_notify)
1585 ndisc_send_unsol_na(dev);
1589 neigh_ifdown(&nd_tbl, dev);
1590 fib6_run_gc(~0UL, net);
1592 case NETDEV_NOTIFY_PEERS:
1593 ndisc_send_unsol_na(dev);
1602 static struct notifier_block ndisc_netdev_notifier = {
1603 .notifier_call = ndisc_netdev_event,
1606 #ifdef CONFIG_SYSCTL
1607 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1608 const char *func, const char *dev_name)
1610 static char warncomm[TASK_COMM_LEN];
1612 if (strcmp(warncomm, current->comm) && warned < 5) {
1613 strcpy(warncomm, current->comm);
1614 pr_warn("process `%s' is using deprecated sysctl (%s) net.ipv6.neigh.%s.%s - use net.ipv6.neigh.%s.%s_ms instead\n",
1616 dev_name, ctl->procname,
1617 dev_name, ctl->procname);
1622 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos)
1624 struct net_device *dev = ctl->extra1;
1625 struct inet6_dev *idev;
1628 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1629 (strcmp(ctl->procname, "base_reachable_time") == 0))
1630 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1632 if (strcmp(ctl->procname, "retrans_time") == 0)
1633 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1635 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1636 ret = proc_dointvec_jiffies(ctl, write,
1637 buffer, lenp, ppos);
1639 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1640 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1641 ret = proc_dointvec_ms_jiffies(ctl, write,
1642 buffer, lenp, ppos);
1646 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1647 if (ctl->data == &idev->nd_parms->base_reachable_time)
1648 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1649 idev->tstamp = jiffies;
1650 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1659 static int __net_init ndisc_net_init(struct net *net)
1661 struct ipv6_pinfo *np;
1665 err = inet_ctl_sock_create(&sk, PF_INET6,
1666 SOCK_RAW, IPPROTO_ICMPV6, net);
1669 "NDISC: Failed to initialize the control socket (err %d)\n",
1674 net->ipv6.ndisc_sk = sk;
1677 np->hop_limit = 255;
1678 /* Do not loopback ndisc messages */
1684 static void __net_exit ndisc_net_exit(struct net *net)
1686 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1689 static struct pernet_operations ndisc_net_ops = {
1690 .init = ndisc_net_init,
1691 .exit = ndisc_net_exit,
1694 int __init ndisc_init(void)
1698 err = register_pernet_subsys(&ndisc_net_ops);
1702 * Initialize the neighbour table
1704 neigh_table_init(&nd_tbl);
1706 #ifdef CONFIG_SYSCTL
1707 err = neigh_sysctl_register(NULL, &nd_tbl.parms, "ipv6",
1708 &ndisc_ifinfo_sysctl_change);
1710 goto out_unregister_pernet;
1712 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1714 goto out_unregister_sysctl;
1718 out_unregister_sysctl:
1719 #ifdef CONFIG_SYSCTL
1720 neigh_sysctl_unregister(&nd_tbl.parms);
1721 out_unregister_pernet:
1723 unregister_pernet_subsys(&ndisc_net_ops);
1727 void ndisc_cleanup(void)
1729 unregister_netdevice_notifier(&ndisc_netdev_notifier);
1730 #ifdef CONFIG_SYSCTL
1731 neigh_sysctl_unregister(&nd_tbl.parms);
1733 neigh_table_clear(&nd_tbl);
1734 unregister_pernet_subsys(&ndisc_net_ops);