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 bool ndisc_key_eq(const struct neighbour *neigh, const void *pkey);
88 static int ndisc_constructor(struct neighbour *neigh);
89 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
90 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
91 static int pndisc_constructor(struct pneigh_entry *n);
92 static void pndisc_destructor(struct pneigh_entry *n);
93 static void pndisc_redo(struct sk_buff *skb);
95 static const struct neigh_ops ndisc_generic_ops = {
97 .solicit = ndisc_solicit,
98 .error_report = ndisc_error_report,
99 .output = neigh_resolve_output,
100 .connected_output = neigh_connected_output,
103 static const struct neigh_ops ndisc_hh_ops = {
105 .solicit = ndisc_solicit,
106 .error_report = ndisc_error_report,
107 .output = neigh_resolve_output,
108 .connected_output = neigh_resolve_output,
112 static const struct neigh_ops ndisc_direct_ops = {
114 .output = neigh_direct_output,
115 .connected_output = neigh_direct_output,
118 struct neigh_table nd_tbl = {
120 .key_len = sizeof(struct in6_addr),
121 .protocol = cpu_to_be16(ETH_P_IPV6),
123 .key_eq = ndisc_key_eq,
124 .constructor = ndisc_constructor,
125 .pconstructor = pndisc_constructor,
126 .pdestructor = pndisc_destructor,
127 .proxy_redo = pndisc_redo,
131 .reachable_time = ND_REACHABLE_TIME,
133 [NEIGH_VAR_MCAST_PROBES] = 3,
134 [NEIGH_VAR_UCAST_PROBES] = 3,
135 [NEIGH_VAR_RETRANS_TIME] = ND_RETRANS_TIMER,
136 [NEIGH_VAR_BASE_REACHABLE_TIME] = ND_REACHABLE_TIME,
137 [NEIGH_VAR_DELAY_PROBE_TIME] = 5 * HZ,
138 [NEIGH_VAR_GC_STALETIME] = 60 * HZ,
139 [NEIGH_VAR_QUEUE_LEN_BYTES] = 64 * 1024,
140 [NEIGH_VAR_PROXY_QLEN] = 64,
141 [NEIGH_VAR_ANYCAST_DELAY] = 1 * HZ,
142 [NEIGH_VAR_PROXY_DELAY] = (8 * HZ) / 10,
145 .gc_interval = 30 * HZ,
151 static void ndisc_fill_addr_option(struct sk_buff *skb, int type, void *data)
153 int pad = ndisc_addr_option_pad(skb->dev->type);
154 int data_len = skb->dev->addr_len;
155 int space = ndisc_opt_addr_space(skb->dev);
156 u8 *opt = skb_put(skb, space);
161 memset(opt + 2, 0, pad);
165 memcpy(opt+2, data, data_len);
170 memset(opt, 0, space);
173 static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
174 struct nd_opt_hdr *end)
177 if (!cur || !end || cur >= end)
179 type = cur->nd_opt_type;
181 cur = ((void *)cur) + (cur->nd_opt_len << 3);
182 } while (cur < end && cur->nd_opt_type != type);
183 return cur <= end && cur->nd_opt_type == type ? cur : NULL;
186 static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
188 return opt->nd_opt_type == ND_OPT_RDNSS ||
189 opt->nd_opt_type == ND_OPT_DNSSL;
192 static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur,
193 struct nd_opt_hdr *end)
195 if (!cur || !end || cur >= end)
198 cur = ((void *)cur) + (cur->nd_opt_len << 3);
199 } while (cur < end && !ndisc_is_useropt(cur));
200 return cur <= end && ndisc_is_useropt(cur) ? cur : NULL;
203 struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
204 struct ndisc_options *ndopts)
206 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
208 if (!nd_opt || opt_len < 0 || !ndopts)
210 memset(ndopts, 0, sizeof(*ndopts));
213 if (opt_len < sizeof(struct nd_opt_hdr))
215 l = nd_opt->nd_opt_len << 3;
216 if (opt_len < l || l == 0)
218 switch (nd_opt->nd_opt_type) {
219 case ND_OPT_SOURCE_LL_ADDR:
220 case ND_OPT_TARGET_LL_ADDR:
222 case ND_OPT_REDIRECT_HDR:
223 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
225 "%s: duplicated ND6 option found: type=%d\n",
226 __func__, nd_opt->nd_opt_type);
228 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
231 case ND_OPT_PREFIX_INFO:
232 ndopts->nd_opts_pi_end = nd_opt;
233 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
234 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
236 #ifdef CONFIG_IPV6_ROUTE_INFO
237 case ND_OPT_ROUTE_INFO:
238 ndopts->nd_opts_ri_end = nd_opt;
239 if (!ndopts->nd_opts_ri)
240 ndopts->nd_opts_ri = nd_opt;
244 if (ndisc_is_useropt(nd_opt)) {
245 ndopts->nd_useropts_end = nd_opt;
246 if (!ndopts->nd_useropts)
247 ndopts->nd_useropts = nd_opt;
250 * Unknown options must be silently ignored,
251 * to accommodate future extension to the
255 "%s: ignored unsupported option; type=%d, len=%d\n",
262 nd_opt = ((void *)nd_opt) + l;
267 int ndisc_mc_map(const struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
271 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
273 ipv6_eth_mc_map(addr, buf);
276 ipv6_arcnet_mc_map(addr, buf);
278 case ARPHRD_INFINIBAND:
279 ipv6_ib_mc_map(addr, dev->broadcast, buf);
282 return ipv6_ipgre_mc_map(addr, dev->broadcast, buf);
285 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 bool ndisc_key_eq(const struct neighbour *n, const void *pkey)
302 return neigh_key_eq128(n, pkey);
305 static int ndisc_constructor(struct neighbour *neigh)
307 struct in6_addr *addr = (struct in6_addr *)&neigh->primary_key;
308 struct net_device *dev = neigh->dev;
309 struct inet6_dev *in6_dev;
310 struct neigh_parms *parms;
311 bool is_multicast = ipv6_addr_is_multicast(addr);
313 in6_dev = in6_dev_get(dev);
318 parms = in6_dev->nd_parms;
319 __neigh_parms_put(neigh->parms);
320 neigh->parms = neigh_parms_clone(parms);
322 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
323 if (!dev->header_ops) {
324 neigh->nud_state = NUD_NOARP;
325 neigh->ops = &ndisc_direct_ops;
326 neigh->output = neigh_direct_output;
329 neigh->nud_state = NUD_NOARP;
330 ndisc_mc_map(addr, neigh->ha, dev, 1);
331 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
332 neigh->nud_state = NUD_NOARP;
333 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
334 if (dev->flags&IFF_LOOPBACK)
335 neigh->type = RTN_LOCAL;
336 } else if (dev->flags&IFF_POINTOPOINT) {
337 neigh->nud_state = NUD_NOARP;
338 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
340 if (dev->header_ops->cache)
341 neigh->ops = &ndisc_hh_ops;
343 neigh->ops = &ndisc_generic_ops;
344 if (neigh->nud_state&NUD_VALID)
345 neigh->output = neigh->ops->connected_output;
347 neigh->output = neigh->ops->output;
349 in6_dev_put(in6_dev);
353 static int pndisc_constructor(struct pneigh_entry *n)
355 struct in6_addr *addr = (struct in6_addr *)&n->key;
356 struct in6_addr maddr;
357 struct net_device *dev = n->dev;
359 if (!dev || !__in6_dev_get(dev))
361 addrconf_addr_solict_mult(addr, &maddr);
362 ipv6_dev_mc_inc(dev, &maddr);
366 static void pndisc_destructor(struct pneigh_entry *n)
368 struct in6_addr *addr = (struct in6_addr *)&n->key;
369 struct in6_addr maddr;
370 struct net_device *dev = n->dev;
372 if (!dev || !__in6_dev_get(dev))
374 addrconf_addr_solict_mult(addr, &maddr);
375 ipv6_dev_mc_dec(dev, &maddr);
378 static struct sk_buff *ndisc_alloc_skb(struct net_device *dev,
381 int hlen = LL_RESERVED_SPACE(dev);
382 int tlen = dev->needed_tailroom;
383 struct sock *sk = dev_net(dev)->ipv6.ndisc_sk;
386 skb = alloc_skb(hlen + sizeof(struct ipv6hdr) + len + tlen, GFP_ATOMIC);
388 ND_PRINTK(0, err, "ndisc: %s failed to allocate an skb\n",
393 skb->protocol = htons(ETH_P_IPV6);
396 skb_reserve(skb, hlen + sizeof(struct ipv6hdr));
397 skb_reset_transport_header(skb);
399 /* Manually assign socket ownership as we avoid calling
400 * sock_alloc_send_pskb() to bypass wmem buffer limits
402 skb_set_owner_w(skb, sk);
407 static void ip6_nd_hdr(struct sk_buff *skb,
408 const struct in6_addr *saddr,
409 const struct in6_addr *daddr,
410 int hop_limit, int len)
414 skb_push(skb, sizeof(*hdr));
415 skb_reset_network_header(skb);
418 ip6_flow_hdr(hdr, 0, 0);
420 hdr->payload_len = htons(len);
421 hdr->nexthdr = IPPROTO_ICMPV6;
422 hdr->hop_limit = hop_limit;
428 static void ndisc_send_skb(struct sk_buff *skb,
429 const struct in6_addr *daddr,
430 const struct in6_addr *saddr)
432 struct dst_entry *dst = skb_dst(skb);
433 struct net *net = dev_net(skb->dev);
434 struct sock *sk = net->ipv6.ndisc_sk;
435 struct inet6_dev *idev;
437 struct icmp6hdr *icmp6h = icmp6_hdr(skb);
440 type = icmp6h->icmp6_type;
445 icmpv6_flow_init(sk, &fl6, type, saddr, daddr, skb->dev->ifindex);
446 dst = icmp6_dst_alloc(skb->dev, &fl6);
452 skb_dst_set(skb, dst);
455 icmp6h->icmp6_cksum = csum_ipv6_magic(saddr, daddr, skb->len,
460 ip6_nd_hdr(skb, saddr, daddr, inet6_sk(sk)->hop_limit, skb->len);
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,
467 net, sk, skb, NULL, dst->dev,
470 ICMP6MSGOUT_INC_STATS(net, idev, type);
471 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
477 void ndisc_send_na(struct net_device *dev, const struct in6_addr *daddr,
478 const struct in6_addr *solicited_addr,
479 bool router, bool solicited, bool override, bool inc_opt)
482 struct in6_addr tmpaddr;
483 struct inet6_ifaddr *ifp;
484 const struct in6_addr *src_addr;
488 /* for anycast or proxy, solicited_addr != src_addr */
489 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
491 src_addr = solicited_addr;
492 if (ifp->flags & IFA_F_OPTIMISTIC)
494 inc_opt |= ifp->idev->cnf.force_tllao;
497 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
498 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
507 optlen += ndisc_opt_addr_space(dev);
509 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
513 msg = (struct nd_msg *)skb_put(skb, sizeof(*msg));
514 *msg = (struct nd_msg) {
516 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
517 .icmp6_router = router,
518 .icmp6_solicited = solicited,
519 .icmp6_override = override,
521 .target = *solicited_addr,
525 ndisc_fill_addr_option(skb, ND_OPT_TARGET_LL_ADDR,
529 ndisc_send_skb(skb, daddr, src_addr);
532 static void ndisc_send_unsol_na(struct net_device *dev)
534 struct inet6_dev *idev;
535 struct inet6_ifaddr *ifa;
537 idev = in6_dev_get(dev);
541 read_lock_bh(&idev->lock);
542 list_for_each_entry(ifa, &idev->addr_list, if_list) {
543 ndisc_send_na(dev, &in6addr_linklocal_allnodes, &ifa->addr,
544 /*router=*/ !!idev->cnf.forwarding,
545 /*solicited=*/ false, /*override=*/ true,
548 read_unlock_bh(&idev->lock);
553 void ndisc_send_ns(struct net_device *dev, const struct in6_addr *solicit,
554 const struct in6_addr *daddr, const struct in6_addr *saddr,
555 struct sk_buff *oskb)
558 struct in6_addr addr_buf;
559 int inc_opt = dev->addr_len;
564 if (ipv6_get_lladdr(dev, &addr_buf,
565 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
570 if (ipv6_addr_any(saddr))
573 optlen += ndisc_opt_addr_space(dev);
575 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
579 msg = (struct nd_msg *)skb_put(skb, sizeof(*msg));
580 *msg = (struct nd_msg) {
582 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
588 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
591 if (!(dev->priv_flags & IFF_XMIT_DST_RELEASE) && oskb)
592 skb_dst_copy(skb, oskb);
594 ndisc_send_skb(skb, daddr, saddr);
597 void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
598 const struct in6_addr *daddr)
602 int send_sllao = dev->addr_len;
605 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
607 * According to section 2.2 of RFC 4429, we must not
608 * send router solicitations with a sllao from
609 * optimistic addresses, but we may send the solicitation
610 * if we don't include the sllao. So here we check
611 * if our address is optimistic, and if so, we
612 * suppress the inclusion of the sllao.
615 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
618 if (ifp->flags & IFA_F_OPTIMISTIC) {
628 optlen += ndisc_opt_addr_space(dev);
630 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
634 msg = (struct rs_msg *)skb_put(skb, sizeof(*msg));
635 *msg = (struct rs_msg) {
637 .icmp6_type = NDISC_ROUTER_SOLICITATION,
642 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
645 ndisc_send_skb(skb, daddr, saddr);
649 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
652 * "The sender MUST return an ICMP
653 * destination unreachable"
655 dst_link_failure(skb);
659 /* Called with locked neigh: either read or both */
661 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
663 struct in6_addr *saddr = NULL;
664 struct in6_addr mcaddr;
665 struct net_device *dev = neigh->dev;
666 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
667 int probes = atomic_read(&neigh->probes);
669 if (skb && ipv6_chk_addr_and_flags(dev_net(dev), &ipv6_hdr(skb)->saddr,
671 IFA_F_TENTATIVE|IFA_F_OPTIMISTIC))
672 saddr = &ipv6_hdr(skb)->saddr;
673 probes -= NEIGH_VAR(neigh->parms, UCAST_PROBES);
675 if (!(neigh->nud_state & NUD_VALID)) {
677 "%s: trying to ucast probe in NUD_INVALID: %pI6\n",
680 ndisc_send_ns(dev, target, target, saddr, skb);
681 } else if ((probes -= NEIGH_VAR(neigh->parms, APP_PROBES)) < 0) {
684 addrconf_addr_solict_mult(target, &mcaddr);
685 ndisc_send_ns(dev, target, &mcaddr, saddr, skb);
689 static int pndisc_is_router(const void *pkey,
690 struct net_device *dev)
692 struct pneigh_entry *n;
695 read_lock_bh(&nd_tbl.lock);
696 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
698 ret = !!(n->flags & NTF_ROUTER);
699 read_unlock_bh(&nd_tbl.lock);
704 static void ndisc_recv_ns(struct sk_buff *skb)
706 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
707 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
708 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
710 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
711 offsetof(struct nd_msg, opt));
712 struct ndisc_options ndopts;
713 struct net_device *dev = skb->dev;
714 struct inet6_ifaddr *ifp;
715 struct inet6_dev *idev = NULL;
716 struct neighbour *neigh;
717 int dad = ipv6_addr_any(saddr);
721 if (skb->len < sizeof(struct nd_msg)) {
722 ND_PRINTK(2, warn, "NS: packet too short\n");
726 if (ipv6_addr_is_multicast(&msg->target)) {
727 ND_PRINTK(2, warn, "NS: multicast target address\n");
733 * DAD has to be destined for solicited node multicast address.
735 if (dad && !ipv6_addr_is_solict_mult(daddr)) {
736 ND_PRINTK(2, warn, "NS: bad DAD packet (wrong destination)\n");
740 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
741 ND_PRINTK(2, warn, "NS: invalid ND options\n");
745 if (ndopts.nd_opts_src_lladdr) {
746 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
749 "NS: invalid link-layer address length\n");
754 * If the IP source address is the unspecified address,
755 * there MUST NOT be source link-layer address option
760 "NS: bad DAD packet (link-layer address option)\n");
765 inc = ipv6_addr_is_multicast(daddr);
767 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
770 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
773 * We are colliding with another node
775 * so fail our DAD process
777 addrconf_dad_failure(ifp);
781 * This is not a dad solicitation.
782 * If we are an optimistic node,
784 * Otherwise, we should ignore it.
786 if (!(ifp->flags & IFA_F_OPTIMISTIC))
793 struct net *net = dev_net(dev);
795 idev = in6_dev_get(dev);
797 /* XXX: count this drop? */
801 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
802 (idev->cnf.forwarding &&
803 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
804 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
805 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
806 skb->pkt_type != PACKET_HOST &&
808 NEIGH_VAR(idev->nd_parms, PROXY_DELAY) != 0) {
810 * for anycast or proxy,
811 * sender should delay its response
812 * by a random time between 0 and
813 * MAX_ANYCAST_DELAY_TIME seconds.
814 * (RFC2461) -- yoshfuji
816 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
818 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
826 is_router = idev->cnf.forwarding;
829 ndisc_send_na(dev, &in6addr_linklocal_allnodes, &msg->target,
830 !!is_router, false, (ifp != NULL), true);
835 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
837 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
840 * update / create cache entry
841 * for the source address
843 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
844 !inc || lladdr || !dev->addr_len);
846 neigh_update(neigh, lladdr, NUD_STALE,
847 NEIGH_UPDATE_F_WEAK_OVERRIDE|
848 NEIGH_UPDATE_F_OVERRIDE);
849 if (neigh || !dev->header_ops) {
850 ndisc_send_na(dev, saddr, &msg->target, !!is_router,
851 true, (ifp != NULL && inc), inc);
853 neigh_release(neigh);
863 static void ndisc_recv_na(struct sk_buff *skb)
865 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
866 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
867 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
869 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
870 offsetof(struct nd_msg, opt));
871 struct ndisc_options ndopts;
872 struct net_device *dev = skb->dev;
873 struct inet6_ifaddr *ifp;
874 struct neighbour *neigh;
876 if (skb->len < sizeof(struct nd_msg)) {
877 ND_PRINTK(2, warn, "NA: packet too short\n");
881 if (ipv6_addr_is_multicast(&msg->target)) {
882 ND_PRINTK(2, warn, "NA: target address is multicast\n");
886 if (ipv6_addr_is_multicast(daddr) &&
887 msg->icmph.icmp6_solicited) {
888 ND_PRINTK(2, warn, "NA: solicited NA is multicasted\n");
892 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
893 ND_PRINTK(2, warn, "NS: invalid ND option\n");
896 if (ndopts.nd_opts_tgt_lladdr) {
897 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
900 "NA: invalid link-layer address length\n");
904 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
906 if (skb->pkt_type != PACKET_LOOPBACK
907 && (ifp->flags & IFA_F_TENTATIVE)) {
908 addrconf_dad_failure(ifp);
911 /* What should we make now? The advertisement
912 is invalid, but ndisc specs say nothing
913 about it. It could be misconfiguration, or
914 an smart proxy agent tries to help us :-)
916 We should not print the error if NA has been
917 received from loopback - it is just our own
918 unsolicited advertisement.
920 if (skb->pkt_type != PACKET_LOOPBACK)
922 "NA: someone advertises our address %pI6 on %s!\n",
923 &ifp->addr, ifp->idev->dev->name);
927 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
930 u8 old_flags = neigh->flags;
931 struct net *net = dev_net(dev);
933 if (neigh->nud_state & NUD_FAILED)
937 * Don't update the neighbor cache entry on a proxy NA from
938 * ourselves because either the proxied node is off link or it
939 * has already sent a NA to us.
941 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
942 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
943 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
944 /* XXX: idev->cnf.proxy_ndp */
948 neigh_update(neigh, lladdr,
949 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
950 NEIGH_UPDATE_F_WEAK_OVERRIDE|
951 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
952 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
953 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
955 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
957 * Change: router to host
959 rt6_clean_tohost(dev_net(dev), saddr);
963 neigh_release(neigh);
967 static void ndisc_recv_rs(struct sk_buff *skb)
969 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
970 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
971 struct neighbour *neigh;
972 struct inet6_dev *idev;
973 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
974 struct ndisc_options ndopts;
977 if (skb->len < sizeof(*rs_msg))
980 idev = __in6_dev_get(skb->dev);
982 ND_PRINTK(1, err, "RS: can't find in6 device\n");
986 /* Don't accept RS if we're not in router mode */
987 if (!idev->cnf.forwarding)
991 * Don't update NCE if src = ::;
992 * this implies that the source node has no ip address assigned yet.
994 if (ipv6_addr_any(saddr))
997 /* Parse ND options */
998 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
999 ND_PRINTK(2, notice, "NS: invalid ND option, ignored\n");
1003 if (ndopts.nd_opts_src_lladdr) {
1004 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1010 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1012 neigh_update(neigh, lladdr, NUD_STALE,
1013 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1014 NEIGH_UPDATE_F_OVERRIDE|
1015 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1016 neigh_release(neigh);
1022 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1024 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1025 struct sk_buff *skb;
1026 struct nlmsghdr *nlh;
1027 struct nduseroptmsg *ndmsg;
1028 struct net *net = dev_net(ra->dev);
1030 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1031 + (opt->nd_opt_len << 3));
1032 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1034 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1040 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1042 goto nla_put_failure;
1045 ndmsg = nlmsg_data(nlh);
1046 ndmsg->nduseropt_family = AF_INET6;
1047 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
1048 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1049 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1050 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1052 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1054 if (nla_put_in6_addr(skb, NDUSEROPT_SRCADDR, &ipv6_hdr(ra)->saddr))
1055 goto nla_put_failure;
1056 nlmsg_end(skb, nlh);
1058 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
1065 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1068 static void ndisc_router_discovery(struct sk_buff *skb)
1070 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1071 struct neighbour *neigh = NULL;
1072 struct inet6_dev *in6_dev;
1073 struct rt6_info *rt = NULL;
1075 struct ndisc_options ndopts;
1077 unsigned int pref = 0;
1079 bool send_ifinfo_notify = false;
1081 __u8 *opt = (__u8 *)(ra_msg + 1);
1083 optlen = (skb_tail_pointer(skb) - skb_transport_header(skb)) -
1084 sizeof(struct ra_msg);
1087 "RA: %s, dev: %s\n",
1088 __func__, skb->dev->name);
1089 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1090 ND_PRINTK(2, warn, "RA: source address is not link-local\n");
1094 ND_PRINTK(2, warn, "RA: packet too short\n");
1098 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1099 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1100 ND_PRINTK(2, warn, "RA: from host or unauthorized router\n");
1106 * set the RA_RECV flag in the interface
1109 in6_dev = __in6_dev_get(skb->dev);
1111 ND_PRINTK(0, err, "RA: can't find inet6 device for %s\n",
1116 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1117 ND_PRINTK(2, warn, "RA: invalid ND options\n");
1121 if (!ipv6_accept_ra(in6_dev)) {
1123 "RA: %s, did not accept ra for dev: %s\n",
1124 __func__, skb->dev->name);
1125 goto skip_linkparms;
1128 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1129 /* skip link-specific parameters from interior routers */
1130 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) {
1132 "RA: %s, nodetype is NODEFAULT, dev: %s\n",
1133 __func__, skb->dev->name);
1134 goto skip_linkparms;
1138 if (in6_dev->if_flags & IF_RS_SENT) {
1140 * flag that an RA was received after an RS was sent
1141 * out on this interface.
1143 in6_dev->if_flags |= IF_RA_RCVD;
1147 * Remember the managed/otherconf flags from most recently
1148 * received RA message (RFC 2462) -- yoshfuji
1150 old_if_flags = in6_dev->if_flags;
1151 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1153 (ra_msg->icmph.icmp6_addrconf_managed ?
1154 IF_RA_MANAGED : 0) |
1155 (ra_msg->icmph.icmp6_addrconf_other ?
1156 IF_RA_OTHERCONF : 0);
1158 if (old_if_flags != in6_dev->if_flags)
1159 send_ifinfo_notify = true;
1161 if (!in6_dev->cnf.accept_ra_defrtr) {
1163 "RA: %s, defrtr is false for dev: %s\n",
1164 __func__, skb->dev->name);
1168 /* Do not accept RA with source-addr found on local machine unless
1169 * accept_ra_from_local is set to true.
1171 if (!in6_dev->cnf.accept_ra_from_local &&
1172 ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr,
1175 "RA from local address detected on dev: %s: default router ignored\n",
1180 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1182 #ifdef CONFIG_IPV6_ROUTER_PREF
1183 pref = ra_msg->icmph.icmp6_router_pref;
1184 /* 10b is handled as if it were 00b (medium) */
1185 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1186 !in6_dev->cnf.accept_ra_rtr_pref)
1187 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1190 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1193 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1196 "RA: %s got default router without neighbour\n",
1202 if (rt && lifetime == 0) {
1207 ND_PRINTK(3, info, "RA: rt: %p lifetime: %d, for dev: %s\n",
1208 rt, lifetime, skb->dev->name);
1209 if (!rt && lifetime) {
1210 ND_PRINTK(3, info, "RA: adding default router\n");
1212 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1215 "RA: %s failed to add default route\n",
1220 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1223 "RA: %s got default router without neighbour\n",
1228 neigh->flags |= NTF_ROUTER;
1230 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1234 rt6_set_expires(rt, jiffies + (HZ * lifetime));
1235 if (in6_dev->cnf.accept_ra_min_hop_limit < 256 &&
1236 ra_msg->icmph.icmp6_hop_limit) {
1237 if (in6_dev->cnf.accept_ra_min_hop_limit <= ra_msg->icmph.icmp6_hop_limit) {
1238 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1240 dst_metric_set(&rt->dst, RTAX_HOPLIMIT,
1241 ra_msg->icmph.icmp6_hop_limit);
1243 ND_PRINTK(2, warn, "RA: Got route advertisement with lower hop_limit than minimum\n");
1250 * Update Reachable Time and Retrans Timer
1253 if (in6_dev->nd_parms) {
1254 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1256 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1257 rtime = (rtime*HZ)/1000;
1260 NEIGH_VAR_SET(in6_dev->nd_parms, RETRANS_TIME, rtime);
1261 in6_dev->tstamp = jiffies;
1262 send_ifinfo_notify = true;
1265 rtime = ntohl(ra_msg->reachable_time);
1266 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1267 rtime = (rtime*HZ)/1000;
1272 if (rtime != NEIGH_VAR(in6_dev->nd_parms, BASE_REACHABLE_TIME)) {
1273 NEIGH_VAR_SET(in6_dev->nd_parms,
1274 BASE_REACHABLE_TIME, rtime);
1275 NEIGH_VAR_SET(in6_dev->nd_parms,
1276 GC_STALETIME, 3 * rtime);
1277 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1278 in6_dev->tstamp = jiffies;
1279 send_ifinfo_notify = true;
1285 * Send a notify if RA changed managed/otherconf flags or timer settings
1287 if (send_ifinfo_notify)
1288 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1297 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1301 if (ndopts.nd_opts_src_lladdr) {
1302 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1306 "RA: invalid link-layer address length\n");
1310 neigh_update(neigh, lladdr, NUD_STALE,
1311 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1312 NEIGH_UPDATE_F_OVERRIDE|
1313 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1314 NEIGH_UPDATE_F_ISROUTER);
1317 if (!ipv6_accept_ra(in6_dev)) {
1319 "RA: %s, accept_ra is false for dev: %s\n",
1320 __func__, skb->dev->name);
1324 #ifdef CONFIG_IPV6_ROUTE_INFO
1325 if (!in6_dev->cnf.accept_ra_from_local &&
1326 ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr,
1329 "RA from local address detected on dev: %s: router info ignored.\n",
1331 goto skip_routeinfo;
1334 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1335 struct nd_opt_hdr *p;
1336 for (p = ndopts.nd_opts_ri;
1338 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1339 struct route_info *ri = (struct route_info *)p;
1340 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1341 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1342 ri->prefix_len == 0)
1345 if (ri->prefix_len == 0 &&
1346 !in6_dev->cnf.accept_ra_defrtr)
1348 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1350 rt6_route_rcv(skb->dev, (u8 *)p, (p->nd_opt_len) << 3,
1351 &ipv6_hdr(skb)->saddr);
1358 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1359 /* skip link-specific ndopts from interior routers */
1360 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) {
1362 "RA: %s, nodetype is NODEFAULT (interior routes), dev: %s\n",
1363 __func__, skb->dev->name);
1368 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1369 struct nd_opt_hdr *p;
1370 for (p = ndopts.nd_opts_pi;
1372 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1373 addrconf_prefix_rcv(skb->dev, (u8 *)p,
1374 (p->nd_opt_len) << 3,
1375 ndopts.nd_opts_src_lladdr != NULL);
1379 if (ndopts.nd_opts_mtu && in6_dev->cnf.accept_ra_mtu) {
1383 memcpy(&n, ((u8 *)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1386 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1387 ND_PRINTK(2, warn, "RA: invalid mtu: %d\n", mtu);
1388 } else if (in6_dev->cnf.mtu6 != mtu) {
1389 in6_dev->cnf.mtu6 = mtu;
1392 dst_metric_set(&rt->dst, RTAX_MTU, mtu);
1394 rt6_mtu_change(skb->dev, mtu);
1398 if (ndopts.nd_useropts) {
1399 struct nd_opt_hdr *p;
1400 for (p = ndopts.nd_useropts;
1402 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1403 ndisc_ra_useropt(skb, p);
1407 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1408 ND_PRINTK(2, warn, "RA: invalid RA options\n");
1413 neigh_release(neigh);
1416 static void ndisc_redirect_rcv(struct sk_buff *skb)
1419 struct ndisc_options ndopts;
1420 struct rd_msg *msg = (struct rd_msg *)skb_transport_header(skb);
1421 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
1422 offsetof(struct rd_msg, opt));
1424 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1425 switch (skb->ndisc_nodetype) {
1426 case NDISC_NODETYPE_HOST:
1427 case NDISC_NODETYPE_NODEFAULT:
1429 "Redirect: from host or unauthorized router\n");
1434 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1436 "Redirect: source address is not link-local\n");
1440 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts))
1443 if (!ndopts.nd_opts_rh) {
1444 ip6_redirect_no_header(skb, dev_net(skb->dev),
1445 skb->dev->ifindex, 0);
1449 hdr = (u8 *)ndopts.nd_opts_rh;
1451 if (!pskb_pull(skb, hdr - skb_transport_header(skb)))
1454 icmpv6_notify(skb, NDISC_REDIRECT, 0, 0);
1457 static void ndisc_fill_redirect_hdr_option(struct sk_buff *skb,
1458 struct sk_buff *orig_skb,
1461 u8 *opt = skb_put(skb, rd_len);
1464 *(opt++) = ND_OPT_REDIRECT_HDR;
1465 *(opt++) = (rd_len >> 3);
1468 memcpy(opt, ipv6_hdr(orig_skb), rd_len - 8);
1471 void ndisc_send_redirect(struct sk_buff *skb, const struct in6_addr *target)
1473 struct net_device *dev = skb->dev;
1474 struct net *net = dev_net(dev);
1475 struct sock *sk = net->ipv6.ndisc_sk;
1477 struct inet_peer *peer;
1478 struct sk_buff *buff;
1480 struct in6_addr saddr_buf;
1481 struct rt6_info *rt;
1482 struct dst_entry *dst;
1485 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1488 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1489 ND_PRINTK(2, warn, "Redirect: no link-local address on %s\n",
1494 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1495 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1497 "Redirect: target address is not link-local unicast\n");
1501 icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT,
1502 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
1504 dst = ip6_route_output(net, NULL, &fl6);
1509 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
1513 rt = (struct rt6_info *) dst;
1515 if (rt->rt6i_flags & RTF_GATEWAY) {
1517 "Redirect: destination is not a neighbour\n");
1520 peer = inet_getpeer_v6(net->ipv6.peers, &ipv6_hdr(skb)->saddr, 1);
1521 ret = inet_peer_xrlim_allow(peer, 1*HZ);
1527 if (dev->addr_len) {
1528 struct neighbour *neigh = dst_neigh_lookup(skb_dst(skb), target);
1531 "Redirect: no neigh for target address\n");
1535 read_lock_bh(&neigh->lock);
1536 if (neigh->nud_state & NUD_VALID) {
1537 memcpy(ha_buf, neigh->ha, dev->addr_len);
1538 read_unlock_bh(&neigh->lock);
1540 optlen += ndisc_opt_addr_space(dev);
1542 read_unlock_bh(&neigh->lock);
1544 neigh_release(neigh);
1547 rd_len = min_t(unsigned int,
1548 IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(*msg) - optlen,
1553 buff = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
1557 msg = (struct rd_msg *)skb_put(buff, sizeof(*msg));
1558 *msg = (struct rd_msg) {
1560 .icmp6_type = NDISC_REDIRECT,
1563 .dest = ipv6_hdr(skb)->daddr,
1567 * include target_address option
1571 ndisc_fill_addr_option(buff, ND_OPT_TARGET_LL_ADDR, ha);
1574 * build redirect option and copy skb over to the new packet.
1578 ndisc_fill_redirect_hdr_option(buff, skb, rd_len);
1580 skb_dst_set(buff, dst);
1581 ndisc_send_skb(buff, &ipv6_hdr(skb)->saddr, &saddr_buf);
1588 static void pndisc_redo(struct sk_buff *skb)
1594 static bool ndisc_suppress_frag_ndisc(struct sk_buff *skb)
1596 struct inet6_dev *idev = __in6_dev_get(skb->dev);
1600 if (IP6CB(skb)->flags & IP6SKB_FRAGMENTED &&
1601 idev->cnf.suppress_frag_ndisc) {
1602 net_warn_ratelimited("Received fragmented ndisc packet. Carefully consider disabling suppress_frag_ndisc.\n");
1608 int ndisc_rcv(struct sk_buff *skb)
1612 if (ndisc_suppress_frag_ndisc(skb))
1615 if (skb_linearize(skb))
1618 msg = (struct nd_msg *)skb_transport_header(skb);
1620 __skb_push(skb, skb->data - skb_transport_header(skb));
1622 if (ipv6_hdr(skb)->hop_limit != 255) {
1623 ND_PRINTK(2, warn, "NDISC: invalid hop-limit: %d\n",
1624 ipv6_hdr(skb)->hop_limit);
1628 if (msg->icmph.icmp6_code != 0) {
1629 ND_PRINTK(2, warn, "NDISC: invalid ICMPv6 code: %d\n",
1630 msg->icmph.icmp6_code);
1634 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1636 switch (msg->icmph.icmp6_type) {
1637 case NDISC_NEIGHBOUR_SOLICITATION:
1641 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1645 case NDISC_ROUTER_SOLICITATION:
1649 case NDISC_ROUTER_ADVERTISEMENT:
1650 ndisc_router_discovery(skb);
1653 case NDISC_REDIRECT:
1654 ndisc_redirect_rcv(skb);
1661 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1663 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1664 struct netdev_notifier_change_info *change_info;
1665 struct net *net = dev_net(dev);
1666 struct inet6_dev *idev;
1669 case NETDEV_CHANGEADDR:
1670 neigh_changeaddr(&nd_tbl, dev);
1671 fib6_run_gc(0, net, false);
1672 idev = in6_dev_get(dev);
1675 if (idev->cnf.ndisc_notify)
1676 ndisc_send_unsol_na(dev);
1681 if (change_info->flags_changed & IFF_NOARP)
1682 neigh_changeaddr(&nd_tbl, dev);
1685 neigh_ifdown(&nd_tbl, dev);
1686 fib6_run_gc(0, net, false);
1688 case NETDEV_NOTIFY_PEERS:
1689 ndisc_send_unsol_na(dev);
1698 static struct notifier_block ndisc_netdev_notifier = {
1699 .notifier_call = ndisc_netdev_event,
1702 #ifdef CONFIG_SYSCTL
1703 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1704 const char *func, const char *dev_name)
1706 static char warncomm[TASK_COMM_LEN];
1708 if (strcmp(warncomm, current->comm) && warned < 5) {
1709 strcpy(warncomm, current->comm);
1710 pr_warn("process `%s' is using deprecated sysctl (%s) net.ipv6.neigh.%s.%s - use net.ipv6.neigh.%s.%s_ms instead\n",
1712 dev_name, ctl->procname,
1713 dev_name, ctl->procname);
1718 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos)
1720 struct net_device *dev = ctl->extra1;
1721 struct inet6_dev *idev;
1724 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1725 (strcmp(ctl->procname, "base_reachable_time") == 0))
1726 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1728 if (strcmp(ctl->procname, "retrans_time") == 0)
1729 ret = neigh_proc_dointvec(ctl, write, buffer, lenp, ppos);
1731 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1732 ret = neigh_proc_dointvec_jiffies(ctl, write,
1733 buffer, lenp, ppos);
1735 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1736 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1737 ret = neigh_proc_dointvec_ms_jiffies(ctl, write,
1738 buffer, lenp, ppos);
1742 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1743 if (ctl->data == &NEIGH_VAR(idev->nd_parms, BASE_REACHABLE_TIME))
1744 idev->nd_parms->reachable_time =
1745 neigh_rand_reach_time(NEIGH_VAR(idev->nd_parms, BASE_REACHABLE_TIME));
1746 idev->tstamp = jiffies;
1747 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1756 static int __net_init ndisc_net_init(struct net *net)
1758 struct ipv6_pinfo *np;
1762 err = inet_ctl_sock_create(&sk, PF_INET6,
1763 SOCK_RAW, IPPROTO_ICMPV6, net);
1766 "NDISC: Failed to initialize the control socket (err %d)\n",
1771 net->ipv6.ndisc_sk = sk;
1774 np->hop_limit = 255;
1775 /* Do not loopback ndisc messages */
1781 static void __net_exit ndisc_net_exit(struct net *net)
1783 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1786 static struct pernet_operations ndisc_net_ops = {
1787 .init = ndisc_net_init,
1788 .exit = ndisc_net_exit,
1791 int __init ndisc_init(void)
1795 err = register_pernet_subsys(&ndisc_net_ops);
1799 * Initialize the neighbour table
1801 neigh_table_init(NEIGH_ND_TABLE, &nd_tbl);
1803 #ifdef CONFIG_SYSCTL
1804 err = neigh_sysctl_register(NULL, &nd_tbl.parms,
1805 ndisc_ifinfo_sysctl_change);
1807 goto out_unregister_pernet;
1812 #ifdef CONFIG_SYSCTL
1813 out_unregister_pernet:
1814 unregister_pernet_subsys(&ndisc_net_ops);
1819 int __init ndisc_late_init(void)
1821 return register_netdevice_notifier(&ndisc_netdev_notifier);
1824 void ndisc_late_cleanup(void)
1826 unregister_netdevice_notifier(&ndisc_netdev_notifier);
1829 void ndisc_cleanup(void)
1831 #ifdef CONFIG_SYSCTL
1832 neigh_sysctl_unregister(&nd_tbl.parms);
1834 neigh_table_clear(NEIGH_ND_TABLE, &nd_tbl);
1835 unregister_pernet_subsys(&ndisc_net_ops);