xref: /openbmc/linux/net/ipv6/ndisc.c (revision 82003e04)
1 /*
2  *	Neighbour Discovery for IPv6
3  *	Linux INET6 implementation
4  *
5  *	Authors:
6  *	Pedro Roque		<roque@di.fc.ul.pt>
7  *	Mike Shaver		<shaver@ingenia.com>
8  *
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.
13  */
14 
15 /*
16  *	Changes:
17  *
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
22  *						of an RA.
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
28  */
29 
30 #define pr_fmt(fmt) "ICMPv6: " fmt
31 
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>
44 #ifdef CONFIG_SYSCTL
45 #include <linux/sysctl.h>
46 #endif
47 
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>
53 
54 #include <net/sock.h>
55 #include <net/snmp.h>
56 
57 #include <net/ipv6.h>
58 #include <net/protocol.h>
59 #include <net/ndisc.h>
60 #include <net/ip6_route.h>
61 #include <net/addrconf.h>
62 #include <net/icmp.h>
63 
64 #include <net/netlink.h>
65 #include <linux/rtnetlink.h>
66 
67 #include <net/flow.h>
68 #include <net/ip6_checksum.h>
69 #include <net/inet_common.h>
70 #include <linux/proc_fs.h>
71 
72 #include <linux/netfilter.h>
73 #include <linux/netfilter_ipv6.h>
74 
75 static u32 ndisc_hash(const void *pkey,
76 		      const struct net_device *dev,
77 		      __u32 *hash_rnd);
78 static bool ndisc_key_eq(const struct neighbour *neigh, const void *pkey);
79 static int ndisc_constructor(struct neighbour *neigh);
80 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
81 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
82 static int pndisc_constructor(struct pneigh_entry *n);
83 static void pndisc_destructor(struct pneigh_entry *n);
84 static void pndisc_redo(struct sk_buff *skb);
85 
86 static const struct neigh_ops ndisc_generic_ops = {
87 	.family =		AF_INET6,
88 	.solicit =		ndisc_solicit,
89 	.error_report =		ndisc_error_report,
90 	.output =		neigh_resolve_output,
91 	.connected_output =	neigh_connected_output,
92 };
93 
94 static const struct neigh_ops ndisc_hh_ops = {
95 	.family =		AF_INET6,
96 	.solicit =		ndisc_solicit,
97 	.error_report =		ndisc_error_report,
98 	.output =		neigh_resolve_output,
99 	.connected_output =	neigh_resolve_output,
100 };
101 
102 
103 static const struct neigh_ops ndisc_direct_ops = {
104 	.family =		AF_INET6,
105 	.output =		neigh_direct_output,
106 	.connected_output =	neigh_direct_output,
107 };
108 
109 struct neigh_table nd_tbl = {
110 	.family =	AF_INET6,
111 	.key_len =	sizeof(struct in6_addr),
112 	.protocol =	cpu_to_be16(ETH_P_IPV6),
113 	.hash =		ndisc_hash,
114 	.key_eq =	ndisc_key_eq,
115 	.constructor =	ndisc_constructor,
116 	.pconstructor =	pndisc_constructor,
117 	.pdestructor =	pndisc_destructor,
118 	.proxy_redo =	pndisc_redo,
119 	.id =		"ndisc_cache",
120 	.parms = {
121 		.tbl			= &nd_tbl,
122 		.reachable_time		= ND_REACHABLE_TIME,
123 		.data = {
124 			[NEIGH_VAR_MCAST_PROBES] = 3,
125 			[NEIGH_VAR_UCAST_PROBES] = 3,
126 			[NEIGH_VAR_RETRANS_TIME] = ND_RETRANS_TIMER,
127 			[NEIGH_VAR_BASE_REACHABLE_TIME] = ND_REACHABLE_TIME,
128 			[NEIGH_VAR_DELAY_PROBE_TIME] = 5 * HZ,
129 			[NEIGH_VAR_GC_STALETIME] = 60 * HZ,
130 			[NEIGH_VAR_QUEUE_LEN_BYTES] = 64 * 1024,
131 			[NEIGH_VAR_PROXY_QLEN] = 64,
132 			[NEIGH_VAR_ANYCAST_DELAY] = 1 * HZ,
133 			[NEIGH_VAR_PROXY_DELAY] = (8 * HZ) / 10,
134 		},
135 	},
136 	.gc_interval =	  30 * HZ,
137 	.gc_thresh1 =	 128,
138 	.gc_thresh2 =	 512,
139 	.gc_thresh3 =	1024,
140 };
141 EXPORT_SYMBOL_GPL(nd_tbl);
142 
143 void __ndisc_fill_addr_option(struct sk_buff *skb, int type, void *data,
144 			      int data_len, int pad)
145 {
146 	int space = __ndisc_opt_addr_space(data_len, pad);
147 	u8 *opt = skb_put(skb, space);
148 
149 	opt[0] = type;
150 	opt[1] = space>>3;
151 
152 	memset(opt + 2, 0, pad);
153 	opt   += pad;
154 	space -= pad;
155 
156 	memcpy(opt+2, data, data_len);
157 	data_len += 2;
158 	opt += data_len;
159 	space -= data_len;
160 	if (space > 0)
161 		memset(opt, 0, space);
162 }
163 EXPORT_SYMBOL_GPL(__ndisc_fill_addr_option);
164 
165 static inline void ndisc_fill_addr_option(struct sk_buff *skb, int type,
166 					  void *data, u8 icmp6_type)
167 {
168 	__ndisc_fill_addr_option(skb, type, data, skb->dev->addr_len,
169 				 ndisc_addr_option_pad(skb->dev->type));
170 	ndisc_ops_fill_addr_option(skb->dev, skb, icmp6_type);
171 }
172 
173 static inline void ndisc_fill_redirect_addr_option(struct sk_buff *skb,
174 						   void *ha,
175 						   const u8 *ops_data)
176 {
177 	ndisc_fill_addr_option(skb, ND_OPT_TARGET_LL_ADDR, ha, NDISC_REDIRECT);
178 	ndisc_ops_fill_redirect_addr_option(skb->dev, skb, ops_data);
179 }
180 
181 static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
182 					    struct nd_opt_hdr *end)
183 {
184 	int type;
185 	if (!cur || !end || cur >= end)
186 		return NULL;
187 	type = cur->nd_opt_type;
188 	do {
189 		cur = ((void *)cur) + (cur->nd_opt_len << 3);
190 	} while (cur < end && cur->nd_opt_type != type);
191 	return cur <= end && cur->nd_opt_type == type ? cur : NULL;
192 }
193 
194 static inline int ndisc_is_useropt(const struct net_device *dev,
195 				   struct nd_opt_hdr *opt)
196 {
197 	return opt->nd_opt_type == ND_OPT_RDNSS ||
198 		opt->nd_opt_type == ND_OPT_DNSSL ||
199 		ndisc_ops_is_useropt(dev, opt->nd_opt_type);
200 }
201 
202 static struct nd_opt_hdr *ndisc_next_useropt(const struct net_device *dev,
203 					     struct nd_opt_hdr *cur,
204 					     struct nd_opt_hdr *end)
205 {
206 	if (!cur || !end || cur >= end)
207 		return NULL;
208 	do {
209 		cur = ((void *)cur) + (cur->nd_opt_len << 3);
210 	} while (cur < end && !ndisc_is_useropt(dev, cur));
211 	return cur <= end && ndisc_is_useropt(dev, cur) ? cur : NULL;
212 }
213 
214 struct ndisc_options *ndisc_parse_options(const struct net_device *dev,
215 					  u8 *opt, int opt_len,
216 					  struct ndisc_options *ndopts)
217 {
218 	struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
219 
220 	if (!nd_opt || opt_len < 0 || !ndopts)
221 		return NULL;
222 	memset(ndopts, 0, sizeof(*ndopts));
223 	while (opt_len) {
224 		int l;
225 		if (opt_len < sizeof(struct nd_opt_hdr))
226 			return NULL;
227 		l = nd_opt->nd_opt_len << 3;
228 		if (opt_len < l || l == 0)
229 			return NULL;
230 		if (ndisc_ops_parse_options(dev, nd_opt, ndopts))
231 			goto next_opt;
232 		switch (nd_opt->nd_opt_type) {
233 		case ND_OPT_SOURCE_LL_ADDR:
234 		case ND_OPT_TARGET_LL_ADDR:
235 		case ND_OPT_MTU:
236 		case ND_OPT_REDIRECT_HDR:
237 			if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
238 				ND_PRINTK(2, warn,
239 					  "%s: duplicated ND6 option found: type=%d\n",
240 					  __func__, nd_opt->nd_opt_type);
241 			} else {
242 				ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
243 			}
244 			break;
245 		case ND_OPT_PREFIX_INFO:
246 			ndopts->nd_opts_pi_end = nd_opt;
247 			if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
248 				ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
249 			break;
250 #ifdef CONFIG_IPV6_ROUTE_INFO
251 		case ND_OPT_ROUTE_INFO:
252 			ndopts->nd_opts_ri_end = nd_opt;
253 			if (!ndopts->nd_opts_ri)
254 				ndopts->nd_opts_ri = nd_opt;
255 			break;
256 #endif
257 		default:
258 			if (ndisc_is_useropt(dev, nd_opt)) {
259 				ndopts->nd_useropts_end = nd_opt;
260 				if (!ndopts->nd_useropts)
261 					ndopts->nd_useropts = nd_opt;
262 			} else {
263 				/*
264 				 * Unknown options must be silently ignored,
265 				 * to accommodate future extension to the
266 				 * protocol.
267 				 */
268 				ND_PRINTK(2, notice,
269 					  "%s: ignored unsupported option; type=%d, len=%d\n",
270 					  __func__,
271 					  nd_opt->nd_opt_type,
272 					  nd_opt->nd_opt_len);
273 			}
274 		}
275 next_opt:
276 		opt_len -= l;
277 		nd_opt = ((void *)nd_opt) + l;
278 	}
279 	return ndopts;
280 }
281 
282 int ndisc_mc_map(const struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
283 {
284 	switch (dev->type) {
285 	case ARPHRD_ETHER:
286 	case ARPHRD_IEEE802:	/* Not sure. Check it later. --ANK */
287 	case ARPHRD_FDDI:
288 		ipv6_eth_mc_map(addr, buf);
289 		return 0;
290 	case ARPHRD_ARCNET:
291 		ipv6_arcnet_mc_map(addr, buf);
292 		return 0;
293 	case ARPHRD_INFINIBAND:
294 		ipv6_ib_mc_map(addr, dev->broadcast, buf);
295 		return 0;
296 	case ARPHRD_IPGRE:
297 		return ipv6_ipgre_mc_map(addr, dev->broadcast, buf);
298 	default:
299 		if (dir) {
300 			memcpy(buf, dev->broadcast, dev->addr_len);
301 			return 0;
302 		}
303 	}
304 	return -EINVAL;
305 }
306 EXPORT_SYMBOL(ndisc_mc_map);
307 
308 static u32 ndisc_hash(const void *pkey,
309 		      const struct net_device *dev,
310 		      __u32 *hash_rnd)
311 {
312 	return ndisc_hashfn(pkey, dev, hash_rnd);
313 }
314 
315 static bool ndisc_key_eq(const struct neighbour *n, const void *pkey)
316 {
317 	return neigh_key_eq128(n, pkey);
318 }
319 
320 static int ndisc_constructor(struct neighbour *neigh)
321 {
322 	struct in6_addr *addr = (struct in6_addr *)&neigh->primary_key;
323 	struct net_device *dev = neigh->dev;
324 	struct inet6_dev *in6_dev;
325 	struct neigh_parms *parms;
326 	bool is_multicast = ipv6_addr_is_multicast(addr);
327 
328 	in6_dev = in6_dev_get(dev);
329 	if (!in6_dev) {
330 		return -EINVAL;
331 	}
332 
333 	parms = in6_dev->nd_parms;
334 	__neigh_parms_put(neigh->parms);
335 	neigh->parms = neigh_parms_clone(parms);
336 
337 	neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
338 	if (!dev->header_ops) {
339 		neigh->nud_state = NUD_NOARP;
340 		neigh->ops = &ndisc_direct_ops;
341 		neigh->output = neigh_direct_output;
342 	} else {
343 		if (is_multicast) {
344 			neigh->nud_state = NUD_NOARP;
345 			ndisc_mc_map(addr, neigh->ha, dev, 1);
346 		} else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
347 			neigh->nud_state = NUD_NOARP;
348 			memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
349 			if (dev->flags&IFF_LOOPBACK)
350 				neigh->type = RTN_LOCAL;
351 		} else if (dev->flags&IFF_POINTOPOINT) {
352 			neigh->nud_state = NUD_NOARP;
353 			memcpy(neigh->ha, dev->broadcast, dev->addr_len);
354 		}
355 		if (dev->header_ops->cache)
356 			neigh->ops = &ndisc_hh_ops;
357 		else
358 			neigh->ops = &ndisc_generic_ops;
359 		if (neigh->nud_state&NUD_VALID)
360 			neigh->output = neigh->ops->connected_output;
361 		else
362 			neigh->output = neigh->ops->output;
363 	}
364 	in6_dev_put(in6_dev);
365 	return 0;
366 }
367 
368 static int pndisc_constructor(struct pneigh_entry *n)
369 {
370 	struct in6_addr *addr = (struct in6_addr *)&n->key;
371 	struct in6_addr maddr;
372 	struct net_device *dev = n->dev;
373 
374 	if (!dev || !__in6_dev_get(dev))
375 		return -EINVAL;
376 	addrconf_addr_solict_mult(addr, &maddr);
377 	ipv6_dev_mc_inc(dev, &maddr);
378 	return 0;
379 }
380 
381 static void pndisc_destructor(struct pneigh_entry *n)
382 {
383 	struct in6_addr *addr = (struct in6_addr *)&n->key;
384 	struct in6_addr maddr;
385 	struct net_device *dev = n->dev;
386 
387 	if (!dev || !__in6_dev_get(dev))
388 		return;
389 	addrconf_addr_solict_mult(addr, &maddr);
390 	ipv6_dev_mc_dec(dev, &maddr);
391 }
392 
393 static struct sk_buff *ndisc_alloc_skb(struct net_device *dev,
394 				       int len)
395 {
396 	int hlen = LL_RESERVED_SPACE(dev);
397 	int tlen = dev->needed_tailroom;
398 	struct sock *sk = dev_net(dev)->ipv6.ndisc_sk;
399 	struct sk_buff *skb;
400 
401 	skb = alloc_skb(hlen + sizeof(struct ipv6hdr) + len + tlen, GFP_ATOMIC);
402 	if (!skb) {
403 		ND_PRINTK(0, err, "ndisc: %s failed to allocate an skb\n",
404 			  __func__);
405 		return NULL;
406 	}
407 
408 	skb->protocol = htons(ETH_P_IPV6);
409 	skb->dev = dev;
410 
411 	skb_reserve(skb, hlen + sizeof(struct ipv6hdr));
412 	skb_reset_transport_header(skb);
413 
414 	/* Manually assign socket ownership as we avoid calling
415 	 * sock_alloc_send_pskb() to bypass wmem buffer limits
416 	 */
417 	skb_set_owner_w(skb, sk);
418 
419 	return skb;
420 }
421 
422 static void ip6_nd_hdr(struct sk_buff *skb,
423 		       const struct in6_addr *saddr,
424 		       const struct in6_addr *daddr,
425 		       int hop_limit, int len)
426 {
427 	struct ipv6hdr *hdr;
428 
429 	skb_push(skb, sizeof(*hdr));
430 	skb_reset_network_header(skb);
431 	hdr = ipv6_hdr(skb);
432 
433 	ip6_flow_hdr(hdr, 0, 0);
434 
435 	hdr->payload_len = htons(len);
436 	hdr->nexthdr = IPPROTO_ICMPV6;
437 	hdr->hop_limit = hop_limit;
438 
439 	hdr->saddr = *saddr;
440 	hdr->daddr = *daddr;
441 }
442 
443 static void ndisc_send_skb(struct sk_buff *skb,
444 			   const struct in6_addr *daddr,
445 			   const struct in6_addr *saddr)
446 {
447 	struct dst_entry *dst = skb_dst(skb);
448 	struct net *net = dev_net(skb->dev);
449 	struct sock *sk = net->ipv6.ndisc_sk;
450 	struct inet6_dev *idev;
451 	int err;
452 	struct icmp6hdr *icmp6h = icmp6_hdr(skb);
453 	u8 type;
454 
455 	type = icmp6h->icmp6_type;
456 
457 	if (!dst) {
458 		struct flowi6 fl6;
459 		int oif = skb->dev->ifindex;
460 
461 		icmpv6_flow_init(sk, &fl6, type, saddr, daddr, oif);
462 		dst = icmp6_dst_alloc(skb->dev, &fl6);
463 		if (IS_ERR(dst)) {
464 			kfree_skb(skb);
465 			return;
466 		}
467 
468 		skb_dst_set(skb, dst);
469 	}
470 
471 	icmp6h->icmp6_cksum = csum_ipv6_magic(saddr, daddr, skb->len,
472 					      IPPROTO_ICMPV6,
473 					      csum_partial(icmp6h,
474 							   skb->len, 0));
475 
476 	ip6_nd_hdr(skb, saddr, daddr, inet6_sk(sk)->hop_limit, skb->len);
477 
478 	rcu_read_lock();
479 	idev = __in6_dev_get(dst->dev);
480 	IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
481 
482 	err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT,
483 		      net, sk, skb, NULL, dst->dev,
484 		      dst_output);
485 	if (!err) {
486 		ICMP6MSGOUT_INC_STATS(net, idev, type);
487 		ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
488 	}
489 
490 	rcu_read_unlock();
491 }
492 
493 void ndisc_send_na(struct net_device *dev, const struct in6_addr *daddr,
494 		   const struct in6_addr *solicited_addr,
495 		   bool router, bool solicited, bool override, bool inc_opt)
496 {
497 	struct sk_buff *skb;
498 	struct in6_addr tmpaddr;
499 	struct inet6_ifaddr *ifp;
500 	const struct in6_addr *src_addr;
501 	struct nd_msg *msg;
502 	int optlen = 0;
503 
504 	/* for anycast or proxy, solicited_addr != src_addr */
505 	ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
506 	if (ifp) {
507 		src_addr = solicited_addr;
508 		if (ifp->flags & IFA_F_OPTIMISTIC)
509 			override = false;
510 		inc_opt |= ifp->idev->cnf.force_tllao;
511 		in6_ifa_put(ifp);
512 	} else {
513 		if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
514 				       inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
515 				       &tmpaddr))
516 			return;
517 		src_addr = &tmpaddr;
518 	}
519 
520 	if (!dev->addr_len)
521 		inc_opt = 0;
522 	if (inc_opt)
523 		optlen += ndisc_opt_addr_space(dev,
524 					       NDISC_NEIGHBOUR_ADVERTISEMENT);
525 
526 	skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
527 	if (!skb)
528 		return;
529 
530 	msg = (struct nd_msg *)skb_put(skb, sizeof(*msg));
531 	*msg = (struct nd_msg) {
532 		.icmph = {
533 			.icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
534 			.icmp6_router = router,
535 			.icmp6_solicited = solicited,
536 			.icmp6_override = override,
537 		},
538 		.target = *solicited_addr,
539 	};
540 
541 	if (inc_opt)
542 		ndisc_fill_addr_option(skb, ND_OPT_TARGET_LL_ADDR,
543 				       dev->dev_addr,
544 				       NDISC_NEIGHBOUR_ADVERTISEMENT);
545 
546 	ndisc_send_skb(skb, daddr, src_addr);
547 }
548 
549 static void ndisc_send_unsol_na(struct net_device *dev)
550 {
551 	struct inet6_dev *idev;
552 	struct inet6_ifaddr *ifa;
553 
554 	idev = in6_dev_get(dev);
555 	if (!idev)
556 		return;
557 
558 	read_lock_bh(&idev->lock);
559 	list_for_each_entry(ifa, &idev->addr_list, if_list) {
560 		ndisc_send_na(dev, &in6addr_linklocal_allnodes, &ifa->addr,
561 			      /*router=*/ !!idev->cnf.forwarding,
562 			      /*solicited=*/ false, /*override=*/ true,
563 			      /*inc_opt=*/ true);
564 	}
565 	read_unlock_bh(&idev->lock);
566 
567 	in6_dev_put(idev);
568 }
569 
570 void ndisc_send_ns(struct net_device *dev, const struct in6_addr *solicit,
571 		   const struct in6_addr *daddr, const struct in6_addr *saddr)
572 {
573 	struct sk_buff *skb;
574 	struct in6_addr addr_buf;
575 	int inc_opt = dev->addr_len;
576 	int optlen = 0;
577 	struct nd_msg *msg;
578 
579 	if (!saddr) {
580 		if (ipv6_get_lladdr(dev, &addr_buf,
581 				   (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
582 			return;
583 		saddr = &addr_buf;
584 	}
585 
586 	if (ipv6_addr_any(saddr))
587 		inc_opt = false;
588 	if (inc_opt)
589 		optlen += ndisc_opt_addr_space(dev,
590 					       NDISC_NEIGHBOUR_SOLICITATION);
591 
592 	skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
593 	if (!skb)
594 		return;
595 
596 	msg = (struct nd_msg *)skb_put(skb, sizeof(*msg));
597 	*msg = (struct nd_msg) {
598 		.icmph = {
599 			.icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
600 		},
601 		.target = *solicit,
602 	};
603 
604 	if (inc_opt)
605 		ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
606 				       dev->dev_addr,
607 				       NDISC_NEIGHBOUR_SOLICITATION);
608 
609 	ndisc_send_skb(skb, daddr, saddr);
610 }
611 
612 void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
613 		   const struct in6_addr *daddr)
614 {
615 	struct sk_buff *skb;
616 	struct rs_msg *msg;
617 	int send_sllao = dev->addr_len;
618 	int optlen = 0;
619 
620 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
621 	/*
622 	 * According to section 2.2 of RFC 4429, we must not
623 	 * send router solicitations with a sllao from
624 	 * optimistic addresses, but we may send the solicitation
625 	 * if we don't include the sllao.  So here we check
626 	 * if our address is optimistic, and if so, we
627 	 * suppress the inclusion of the sllao.
628 	 */
629 	if (send_sllao) {
630 		struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
631 							   dev, 1);
632 		if (ifp) {
633 			if (ifp->flags & IFA_F_OPTIMISTIC)  {
634 				send_sllao = 0;
635 			}
636 			in6_ifa_put(ifp);
637 		} else {
638 			send_sllao = 0;
639 		}
640 	}
641 #endif
642 	if (send_sllao)
643 		optlen += ndisc_opt_addr_space(dev, NDISC_ROUTER_SOLICITATION);
644 
645 	skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
646 	if (!skb)
647 		return;
648 
649 	msg = (struct rs_msg *)skb_put(skb, sizeof(*msg));
650 	*msg = (struct rs_msg) {
651 		.icmph = {
652 			.icmp6_type = NDISC_ROUTER_SOLICITATION,
653 		},
654 	};
655 
656 	if (send_sllao)
657 		ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
658 				       dev->dev_addr,
659 				       NDISC_ROUTER_SOLICITATION);
660 
661 	ndisc_send_skb(skb, daddr, saddr);
662 }
663 
664 
665 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
666 {
667 	/*
668 	 *	"The sender MUST return an ICMP
669 	 *	 destination unreachable"
670 	 */
671 	dst_link_failure(skb);
672 	kfree_skb(skb);
673 }
674 
675 /* Called with locked neigh: either read or both */
676 
677 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
678 {
679 	struct in6_addr *saddr = NULL;
680 	struct in6_addr mcaddr;
681 	struct net_device *dev = neigh->dev;
682 	struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
683 	int probes = atomic_read(&neigh->probes);
684 
685 	if (skb && ipv6_chk_addr_and_flags(dev_net(dev), &ipv6_hdr(skb)->saddr,
686 					   dev, 1,
687 					   IFA_F_TENTATIVE|IFA_F_OPTIMISTIC))
688 		saddr = &ipv6_hdr(skb)->saddr;
689 	probes -= NEIGH_VAR(neigh->parms, UCAST_PROBES);
690 	if (probes < 0) {
691 		if (!(neigh->nud_state & NUD_VALID)) {
692 			ND_PRINTK(1, dbg,
693 				  "%s: trying to ucast probe in NUD_INVALID: %pI6\n",
694 				  __func__, target);
695 		}
696 		ndisc_send_ns(dev, target, target, saddr);
697 	} else if ((probes -= NEIGH_VAR(neigh->parms, APP_PROBES)) < 0) {
698 		neigh_app_ns(neigh);
699 	} else {
700 		addrconf_addr_solict_mult(target, &mcaddr);
701 		ndisc_send_ns(dev, target, &mcaddr, saddr);
702 	}
703 }
704 
705 static int pndisc_is_router(const void *pkey,
706 			    struct net_device *dev)
707 {
708 	struct pneigh_entry *n;
709 	int ret = -1;
710 
711 	read_lock_bh(&nd_tbl.lock);
712 	n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
713 	if (n)
714 		ret = !!(n->flags & NTF_ROUTER);
715 	read_unlock_bh(&nd_tbl.lock);
716 
717 	return ret;
718 }
719 
720 void ndisc_update(const struct net_device *dev, struct neighbour *neigh,
721 		  const u8 *lladdr, u8 new, u32 flags, u8 icmp6_type,
722 		  struct ndisc_options *ndopts)
723 {
724 	neigh_update(neigh, lladdr, new, flags);
725 	/* report ndisc ops about neighbour update */
726 	ndisc_ops_update(dev, neigh, flags, icmp6_type, ndopts);
727 }
728 
729 static void ndisc_recv_ns(struct sk_buff *skb)
730 {
731 	struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
732 	const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
733 	const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
734 	u8 *lladdr = NULL;
735 	u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
736 				    offsetof(struct nd_msg, opt));
737 	struct ndisc_options ndopts;
738 	struct net_device *dev = skb->dev;
739 	struct inet6_ifaddr *ifp;
740 	struct inet6_dev *idev = NULL;
741 	struct neighbour *neigh;
742 	int dad = ipv6_addr_any(saddr);
743 	bool inc;
744 	int is_router = -1;
745 
746 	if (skb->len < sizeof(struct nd_msg)) {
747 		ND_PRINTK(2, warn, "NS: packet too short\n");
748 		return;
749 	}
750 
751 	if (ipv6_addr_is_multicast(&msg->target)) {
752 		ND_PRINTK(2, warn, "NS: multicast target address\n");
753 		return;
754 	}
755 
756 	/*
757 	 * RFC2461 7.1.1:
758 	 * DAD has to be destined for solicited node multicast address.
759 	 */
760 	if (dad && !ipv6_addr_is_solict_mult(daddr)) {
761 		ND_PRINTK(2, warn, "NS: bad DAD packet (wrong destination)\n");
762 		return;
763 	}
764 
765 	if (!ndisc_parse_options(dev, msg->opt, ndoptlen, &ndopts)) {
766 		ND_PRINTK(2, warn, "NS: invalid ND options\n");
767 		return;
768 	}
769 
770 	if (ndopts.nd_opts_src_lladdr) {
771 		lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
772 		if (!lladdr) {
773 			ND_PRINTK(2, warn,
774 				  "NS: invalid link-layer address length\n");
775 			return;
776 		}
777 
778 		/* RFC2461 7.1.1:
779 		 *	If the IP source address is the unspecified address,
780 		 *	there MUST NOT be source link-layer address option
781 		 *	in the message.
782 		 */
783 		if (dad) {
784 			ND_PRINTK(2, warn,
785 				  "NS: bad DAD packet (link-layer address option)\n");
786 			return;
787 		}
788 	}
789 
790 	inc = ipv6_addr_is_multicast(daddr);
791 
792 	ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
793 	if (ifp) {
794 have_ifp:
795 		if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
796 			if (dad) {
797 				/*
798 				 * We are colliding with another node
799 				 * who is doing DAD
800 				 * so fail our DAD process
801 				 */
802 				addrconf_dad_failure(ifp);
803 				return;
804 			} else {
805 				/*
806 				 * This is not a dad solicitation.
807 				 * If we are an optimistic node,
808 				 * we should respond.
809 				 * Otherwise, we should ignore it.
810 				 */
811 				if (!(ifp->flags & IFA_F_OPTIMISTIC))
812 					goto out;
813 			}
814 		}
815 
816 		idev = ifp->idev;
817 	} else {
818 		struct net *net = dev_net(dev);
819 
820 		/* perhaps an address on the master device */
821 		if (netif_is_l3_slave(dev)) {
822 			struct net_device *mdev;
823 
824 			mdev = netdev_master_upper_dev_get_rcu(dev);
825 			if (mdev) {
826 				ifp = ipv6_get_ifaddr(net, &msg->target, mdev, 1);
827 				if (ifp)
828 					goto have_ifp;
829 			}
830 		}
831 
832 		idev = in6_dev_get(dev);
833 		if (!idev) {
834 			/* XXX: count this drop? */
835 			return;
836 		}
837 
838 		if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
839 		    (idev->cnf.forwarding &&
840 		     (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
841 		     (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
842 			if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
843 			    skb->pkt_type != PACKET_HOST &&
844 			    inc &&
845 			    NEIGH_VAR(idev->nd_parms, PROXY_DELAY) != 0) {
846 				/*
847 				 * for anycast or proxy,
848 				 * sender should delay its response
849 				 * by a random time between 0 and
850 				 * MAX_ANYCAST_DELAY_TIME seconds.
851 				 * (RFC2461) -- yoshfuji
852 				 */
853 				struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
854 				if (n)
855 					pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
856 				goto out;
857 			}
858 		} else
859 			goto out;
860 	}
861 
862 	if (is_router < 0)
863 		is_router = idev->cnf.forwarding;
864 
865 	if (dad) {
866 		ndisc_send_na(dev, &in6addr_linklocal_allnodes, &msg->target,
867 			      !!is_router, false, (ifp != NULL), true);
868 		goto out;
869 	}
870 
871 	if (inc)
872 		NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
873 	else
874 		NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
875 
876 	/*
877 	 *	update / create cache entry
878 	 *	for the source address
879 	 */
880 	neigh = __neigh_lookup(&nd_tbl, saddr, dev,
881 			       !inc || lladdr || !dev->addr_len);
882 	if (neigh)
883 		ndisc_update(dev, neigh, lladdr, NUD_STALE,
884 			     NEIGH_UPDATE_F_WEAK_OVERRIDE|
885 			     NEIGH_UPDATE_F_OVERRIDE,
886 			     NDISC_NEIGHBOUR_SOLICITATION, &ndopts);
887 	if (neigh || !dev->header_ops) {
888 		ndisc_send_na(dev, saddr, &msg->target, !!is_router,
889 			      true, (ifp != NULL && inc), inc);
890 		if (neigh)
891 			neigh_release(neigh);
892 	}
893 
894 out:
895 	if (ifp)
896 		in6_ifa_put(ifp);
897 	else
898 		in6_dev_put(idev);
899 }
900 
901 static void ndisc_recv_na(struct sk_buff *skb)
902 {
903 	struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
904 	struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
905 	const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
906 	u8 *lladdr = NULL;
907 	u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
908 				    offsetof(struct nd_msg, opt));
909 	struct ndisc_options ndopts;
910 	struct net_device *dev = skb->dev;
911 	struct inet6_dev *idev = __in6_dev_get(dev);
912 	struct inet6_ifaddr *ifp;
913 	struct neighbour *neigh;
914 
915 	if (skb->len < sizeof(struct nd_msg)) {
916 		ND_PRINTK(2, warn, "NA: packet too short\n");
917 		return;
918 	}
919 
920 	if (ipv6_addr_is_multicast(&msg->target)) {
921 		ND_PRINTK(2, warn, "NA: target address is multicast\n");
922 		return;
923 	}
924 
925 	if (ipv6_addr_is_multicast(daddr) &&
926 	    msg->icmph.icmp6_solicited) {
927 		ND_PRINTK(2, warn, "NA: solicited NA is multicasted\n");
928 		return;
929 	}
930 
931 	/* For some 802.11 wireless deployments (and possibly other networks),
932 	 * there will be a NA proxy and unsolicitd packets are attacks
933 	 * and thus should not be accepted.
934 	 */
935 	if (!msg->icmph.icmp6_solicited && idev &&
936 	    idev->cnf.drop_unsolicited_na)
937 		return;
938 
939 	if (!ndisc_parse_options(dev, msg->opt, ndoptlen, &ndopts)) {
940 		ND_PRINTK(2, warn, "NS: invalid ND option\n");
941 		return;
942 	}
943 	if (ndopts.nd_opts_tgt_lladdr) {
944 		lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
945 		if (!lladdr) {
946 			ND_PRINTK(2, warn,
947 				  "NA: invalid link-layer address length\n");
948 			return;
949 		}
950 	}
951 	ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
952 	if (ifp) {
953 		if (skb->pkt_type != PACKET_LOOPBACK
954 		    && (ifp->flags & IFA_F_TENTATIVE)) {
955 				addrconf_dad_failure(ifp);
956 				return;
957 		}
958 		/* What should we make now? The advertisement
959 		   is invalid, but ndisc specs say nothing
960 		   about it. It could be misconfiguration, or
961 		   an smart proxy agent tries to help us :-)
962 
963 		   We should not print the error if NA has been
964 		   received from loopback - it is just our own
965 		   unsolicited advertisement.
966 		 */
967 		if (skb->pkt_type != PACKET_LOOPBACK)
968 			ND_PRINTK(1, warn,
969 				  "NA: someone advertises our address %pI6 on %s!\n",
970 				  &ifp->addr, ifp->idev->dev->name);
971 		in6_ifa_put(ifp);
972 		return;
973 	}
974 	neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
975 
976 	if (neigh) {
977 		u8 old_flags = neigh->flags;
978 		struct net *net = dev_net(dev);
979 
980 		if (neigh->nud_state & NUD_FAILED)
981 			goto out;
982 
983 		/*
984 		 * Don't update the neighbor cache entry on a proxy NA from
985 		 * ourselves because either the proxied node is off link or it
986 		 * has already sent a NA to us.
987 		 */
988 		if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
989 		    net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
990 		    pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
991 			/* XXX: idev->cnf.proxy_ndp */
992 			goto out;
993 		}
994 
995 		ndisc_update(dev, neigh, lladdr,
996 			     msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
997 			     NEIGH_UPDATE_F_WEAK_OVERRIDE|
998 			     (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
999 			     NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1000 			     (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0),
1001 			     NDISC_NEIGHBOUR_ADVERTISEMENT, &ndopts);
1002 
1003 		if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
1004 			/*
1005 			 * Change: router to host
1006 			 */
1007 			rt6_clean_tohost(dev_net(dev),  saddr);
1008 		}
1009 
1010 out:
1011 		neigh_release(neigh);
1012 	}
1013 }
1014 
1015 static void ndisc_recv_rs(struct sk_buff *skb)
1016 {
1017 	struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
1018 	unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
1019 	struct neighbour *neigh;
1020 	struct inet6_dev *idev;
1021 	const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
1022 	struct ndisc_options ndopts;
1023 	u8 *lladdr = NULL;
1024 
1025 	if (skb->len < sizeof(*rs_msg))
1026 		return;
1027 
1028 	idev = __in6_dev_get(skb->dev);
1029 	if (!idev) {
1030 		ND_PRINTK(1, err, "RS: can't find in6 device\n");
1031 		return;
1032 	}
1033 
1034 	/* Don't accept RS if we're not in router mode */
1035 	if (!idev->cnf.forwarding)
1036 		goto out;
1037 
1038 	/*
1039 	 * Don't update NCE if src = ::;
1040 	 * this implies that the source node has no ip address assigned yet.
1041 	 */
1042 	if (ipv6_addr_any(saddr))
1043 		goto out;
1044 
1045 	/* Parse ND options */
1046 	if (!ndisc_parse_options(skb->dev, rs_msg->opt, ndoptlen, &ndopts)) {
1047 		ND_PRINTK(2, notice, "NS: invalid ND option, ignored\n");
1048 		goto out;
1049 	}
1050 
1051 	if (ndopts.nd_opts_src_lladdr) {
1052 		lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1053 					     skb->dev);
1054 		if (!lladdr)
1055 			goto out;
1056 	}
1057 
1058 	neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1059 	if (neigh) {
1060 		ndisc_update(skb->dev, neigh, lladdr, NUD_STALE,
1061 			     NEIGH_UPDATE_F_WEAK_OVERRIDE|
1062 			     NEIGH_UPDATE_F_OVERRIDE|
1063 			     NEIGH_UPDATE_F_OVERRIDE_ISROUTER,
1064 			     NDISC_ROUTER_SOLICITATION, &ndopts);
1065 		neigh_release(neigh);
1066 	}
1067 out:
1068 	return;
1069 }
1070 
1071 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1072 {
1073 	struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1074 	struct sk_buff *skb;
1075 	struct nlmsghdr *nlh;
1076 	struct nduseroptmsg *ndmsg;
1077 	struct net *net = dev_net(ra->dev);
1078 	int err;
1079 	int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1080 				    + (opt->nd_opt_len << 3));
1081 	size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1082 
1083 	skb = nlmsg_new(msg_size, GFP_ATOMIC);
1084 	if (!skb) {
1085 		err = -ENOBUFS;
1086 		goto errout;
1087 	}
1088 
1089 	nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1090 	if (!nlh) {
1091 		goto nla_put_failure;
1092 	}
1093 
1094 	ndmsg = nlmsg_data(nlh);
1095 	ndmsg->nduseropt_family = AF_INET6;
1096 	ndmsg->nduseropt_ifindex = ra->dev->ifindex;
1097 	ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1098 	ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1099 	ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1100 
1101 	memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1102 
1103 	if (nla_put_in6_addr(skb, NDUSEROPT_SRCADDR, &ipv6_hdr(ra)->saddr))
1104 		goto nla_put_failure;
1105 	nlmsg_end(skb, nlh);
1106 
1107 	rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
1108 	return;
1109 
1110 nla_put_failure:
1111 	nlmsg_free(skb);
1112 	err = -EMSGSIZE;
1113 errout:
1114 	rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1115 }
1116 
1117 static void ndisc_router_discovery(struct sk_buff *skb)
1118 {
1119 	struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1120 	struct neighbour *neigh = NULL;
1121 	struct inet6_dev *in6_dev;
1122 	struct rt6_info *rt = NULL;
1123 	int lifetime;
1124 	struct ndisc_options ndopts;
1125 	int optlen;
1126 	unsigned int pref = 0;
1127 	__u32 old_if_flags;
1128 	bool send_ifinfo_notify = false;
1129 
1130 	__u8 *opt = (__u8 *)(ra_msg + 1);
1131 
1132 	optlen = (skb_tail_pointer(skb) - skb_transport_header(skb)) -
1133 		sizeof(struct ra_msg);
1134 
1135 	ND_PRINTK(2, info,
1136 		  "RA: %s, dev: %s\n",
1137 		  __func__, skb->dev->name);
1138 	if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1139 		ND_PRINTK(2, warn, "RA: source address is not link-local\n");
1140 		return;
1141 	}
1142 	if (optlen < 0) {
1143 		ND_PRINTK(2, warn, "RA: packet too short\n");
1144 		return;
1145 	}
1146 
1147 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1148 	if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1149 		ND_PRINTK(2, warn, "RA: from host or unauthorized router\n");
1150 		return;
1151 	}
1152 #endif
1153 
1154 	/*
1155 	 *	set the RA_RECV flag in the interface
1156 	 */
1157 
1158 	in6_dev = __in6_dev_get(skb->dev);
1159 	if (!in6_dev) {
1160 		ND_PRINTK(0, err, "RA: can't find inet6 device for %s\n",
1161 			  skb->dev->name);
1162 		return;
1163 	}
1164 
1165 	if (!ndisc_parse_options(skb->dev, opt, optlen, &ndopts)) {
1166 		ND_PRINTK(2, warn, "RA: invalid ND options\n");
1167 		return;
1168 	}
1169 
1170 	if (!ipv6_accept_ra(in6_dev)) {
1171 		ND_PRINTK(2, info,
1172 			  "RA: %s, did not accept ra for dev: %s\n",
1173 			  __func__, skb->dev->name);
1174 		goto skip_linkparms;
1175 	}
1176 
1177 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1178 	/* skip link-specific parameters from interior routers */
1179 	if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) {
1180 		ND_PRINTK(2, info,
1181 			  "RA: %s, nodetype is NODEFAULT, dev: %s\n",
1182 			  __func__, skb->dev->name);
1183 		goto skip_linkparms;
1184 	}
1185 #endif
1186 
1187 	if (in6_dev->if_flags & IF_RS_SENT) {
1188 		/*
1189 		 *	flag that an RA was received after an RS was sent
1190 		 *	out on this interface.
1191 		 */
1192 		in6_dev->if_flags |= IF_RA_RCVD;
1193 	}
1194 
1195 	/*
1196 	 * Remember the managed/otherconf flags from most recently
1197 	 * received RA message (RFC 2462) -- yoshfuji
1198 	 */
1199 	old_if_flags = in6_dev->if_flags;
1200 	in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1201 				IF_RA_OTHERCONF)) |
1202 				(ra_msg->icmph.icmp6_addrconf_managed ?
1203 					IF_RA_MANAGED : 0) |
1204 				(ra_msg->icmph.icmp6_addrconf_other ?
1205 					IF_RA_OTHERCONF : 0);
1206 
1207 	if (old_if_flags != in6_dev->if_flags)
1208 		send_ifinfo_notify = true;
1209 
1210 	if (!in6_dev->cnf.accept_ra_defrtr) {
1211 		ND_PRINTK(2, info,
1212 			  "RA: %s, defrtr is false for dev: %s\n",
1213 			  __func__, skb->dev->name);
1214 		goto skip_defrtr;
1215 	}
1216 
1217 	/* Do not accept RA with source-addr found on local machine unless
1218 	 * accept_ra_from_local is set to true.
1219 	 */
1220 	if (!in6_dev->cnf.accept_ra_from_local &&
1221 	    ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr,
1222 			  in6_dev->dev, 0)) {
1223 		ND_PRINTK(2, info,
1224 			  "RA from local address detected on dev: %s: default router ignored\n",
1225 			  skb->dev->name);
1226 		goto skip_defrtr;
1227 	}
1228 
1229 	lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1230 
1231 #ifdef CONFIG_IPV6_ROUTER_PREF
1232 	pref = ra_msg->icmph.icmp6_router_pref;
1233 	/* 10b is handled as if it were 00b (medium) */
1234 	if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1235 	    !in6_dev->cnf.accept_ra_rtr_pref)
1236 		pref = ICMPV6_ROUTER_PREF_MEDIUM;
1237 #endif
1238 
1239 	rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1240 
1241 	if (rt) {
1242 		neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1243 		if (!neigh) {
1244 			ND_PRINTK(0, err,
1245 				  "RA: %s got default router without neighbour\n",
1246 				  __func__);
1247 			ip6_rt_put(rt);
1248 			return;
1249 		}
1250 	}
1251 	if (rt && lifetime == 0) {
1252 		ip6_del_rt(rt);
1253 		rt = NULL;
1254 	}
1255 
1256 	ND_PRINTK(3, info, "RA: rt: %p  lifetime: %d, for dev: %s\n",
1257 		  rt, lifetime, skb->dev->name);
1258 	if (!rt && lifetime) {
1259 		ND_PRINTK(3, info, "RA: adding default router\n");
1260 
1261 		rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1262 		if (!rt) {
1263 			ND_PRINTK(0, err,
1264 				  "RA: %s failed to add default route\n",
1265 				  __func__);
1266 			return;
1267 		}
1268 
1269 		neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1270 		if (!neigh) {
1271 			ND_PRINTK(0, err,
1272 				  "RA: %s got default router without neighbour\n",
1273 				  __func__);
1274 			ip6_rt_put(rt);
1275 			return;
1276 		}
1277 		neigh->flags |= NTF_ROUTER;
1278 	} else if (rt) {
1279 		rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1280 	}
1281 
1282 	if (rt)
1283 		rt6_set_expires(rt, jiffies + (HZ * lifetime));
1284 	if (in6_dev->cnf.accept_ra_min_hop_limit < 256 &&
1285 	    ra_msg->icmph.icmp6_hop_limit) {
1286 		if (in6_dev->cnf.accept_ra_min_hop_limit <= ra_msg->icmph.icmp6_hop_limit) {
1287 			in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1288 			if (rt)
1289 				dst_metric_set(&rt->dst, RTAX_HOPLIMIT,
1290 					       ra_msg->icmph.icmp6_hop_limit);
1291 		} else {
1292 			ND_PRINTK(2, warn, "RA: Got route advertisement with lower hop_limit than minimum\n");
1293 		}
1294 	}
1295 
1296 skip_defrtr:
1297 
1298 	/*
1299 	 *	Update Reachable Time and Retrans Timer
1300 	 */
1301 
1302 	if (in6_dev->nd_parms) {
1303 		unsigned long rtime = ntohl(ra_msg->retrans_timer);
1304 
1305 		if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1306 			rtime = (rtime*HZ)/1000;
1307 			if (rtime < HZ/10)
1308 				rtime = HZ/10;
1309 			NEIGH_VAR_SET(in6_dev->nd_parms, RETRANS_TIME, rtime);
1310 			in6_dev->tstamp = jiffies;
1311 			send_ifinfo_notify = true;
1312 		}
1313 
1314 		rtime = ntohl(ra_msg->reachable_time);
1315 		if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1316 			rtime = (rtime*HZ)/1000;
1317 
1318 			if (rtime < HZ/10)
1319 				rtime = HZ/10;
1320 
1321 			if (rtime != NEIGH_VAR(in6_dev->nd_parms, BASE_REACHABLE_TIME)) {
1322 				NEIGH_VAR_SET(in6_dev->nd_parms,
1323 					      BASE_REACHABLE_TIME, rtime);
1324 				NEIGH_VAR_SET(in6_dev->nd_parms,
1325 					      GC_STALETIME, 3 * rtime);
1326 				in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1327 				in6_dev->tstamp = jiffies;
1328 				send_ifinfo_notify = true;
1329 			}
1330 		}
1331 	}
1332 
1333 	/*
1334 	 *	Send a notify if RA changed managed/otherconf flags or timer settings
1335 	 */
1336 	if (send_ifinfo_notify)
1337 		inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1338 
1339 skip_linkparms:
1340 
1341 	/*
1342 	 *	Process options.
1343 	 */
1344 
1345 	if (!neigh)
1346 		neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1347 				       skb->dev, 1);
1348 	if (neigh) {
1349 		u8 *lladdr = NULL;
1350 		if (ndopts.nd_opts_src_lladdr) {
1351 			lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1352 						     skb->dev);
1353 			if (!lladdr) {
1354 				ND_PRINTK(2, warn,
1355 					  "RA: invalid link-layer address length\n");
1356 				goto out;
1357 			}
1358 		}
1359 		ndisc_update(skb->dev, neigh, lladdr, NUD_STALE,
1360 			     NEIGH_UPDATE_F_WEAK_OVERRIDE|
1361 			     NEIGH_UPDATE_F_OVERRIDE|
1362 			     NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1363 			     NEIGH_UPDATE_F_ISROUTER,
1364 			     NDISC_ROUTER_ADVERTISEMENT, &ndopts);
1365 	}
1366 
1367 	if (!ipv6_accept_ra(in6_dev)) {
1368 		ND_PRINTK(2, info,
1369 			  "RA: %s, accept_ra is false for dev: %s\n",
1370 			  __func__, skb->dev->name);
1371 		goto out;
1372 	}
1373 
1374 #ifdef CONFIG_IPV6_ROUTE_INFO
1375 	if (!in6_dev->cnf.accept_ra_from_local &&
1376 	    ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr,
1377 			  in6_dev->dev, 0)) {
1378 		ND_PRINTK(2, info,
1379 			  "RA from local address detected on dev: %s: router info ignored.\n",
1380 			  skb->dev->name);
1381 		goto skip_routeinfo;
1382 	}
1383 
1384 	if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1385 		struct nd_opt_hdr *p;
1386 		for (p = ndopts.nd_opts_ri;
1387 		     p;
1388 		     p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1389 			struct route_info *ri = (struct route_info *)p;
1390 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1391 			if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1392 			    ri->prefix_len == 0)
1393 				continue;
1394 #endif
1395 			if (ri->prefix_len == 0 &&
1396 			    !in6_dev->cnf.accept_ra_defrtr)
1397 				continue;
1398 			if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1399 				continue;
1400 			rt6_route_rcv(skb->dev, (u8 *)p, (p->nd_opt_len) << 3,
1401 				      &ipv6_hdr(skb)->saddr);
1402 		}
1403 	}
1404 
1405 skip_routeinfo:
1406 #endif
1407 
1408 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1409 	/* skip link-specific ndopts from interior routers */
1410 	if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) {
1411 		ND_PRINTK(2, info,
1412 			  "RA: %s, nodetype is NODEFAULT (interior routes), dev: %s\n",
1413 			  __func__, skb->dev->name);
1414 		goto out;
1415 	}
1416 #endif
1417 
1418 	if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1419 		struct nd_opt_hdr *p;
1420 		for (p = ndopts.nd_opts_pi;
1421 		     p;
1422 		     p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1423 			addrconf_prefix_rcv(skb->dev, (u8 *)p,
1424 					    (p->nd_opt_len) << 3,
1425 					    ndopts.nd_opts_src_lladdr != NULL);
1426 		}
1427 	}
1428 
1429 	if (ndopts.nd_opts_mtu && in6_dev->cnf.accept_ra_mtu) {
1430 		__be32 n;
1431 		u32 mtu;
1432 
1433 		memcpy(&n, ((u8 *)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1434 		mtu = ntohl(n);
1435 
1436 		if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1437 			ND_PRINTK(2, warn, "RA: invalid mtu: %d\n", mtu);
1438 		} else if (in6_dev->cnf.mtu6 != mtu) {
1439 			in6_dev->cnf.mtu6 = mtu;
1440 
1441 			if (rt)
1442 				dst_metric_set(&rt->dst, RTAX_MTU, mtu);
1443 
1444 			rt6_mtu_change(skb->dev, mtu);
1445 		}
1446 	}
1447 
1448 	if (ndopts.nd_useropts) {
1449 		struct nd_opt_hdr *p;
1450 		for (p = ndopts.nd_useropts;
1451 		     p;
1452 		     p = ndisc_next_useropt(skb->dev, p,
1453 					    ndopts.nd_useropts_end)) {
1454 			ndisc_ra_useropt(skb, p);
1455 		}
1456 	}
1457 
1458 	if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1459 		ND_PRINTK(2, warn, "RA: invalid RA options\n");
1460 	}
1461 out:
1462 	ip6_rt_put(rt);
1463 	if (neigh)
1464 		neigh_release(neigh);
1465 }
1466 
1467 static void ndisc_redirect_rcv(struct sk_buff *skb)
1468 {
1469 	u8 *hdr;
1470 	struct ndisc_options ndopts;
1471 	struct rd_msg *msg = (struct rd_msg *)skb_transport_header(skb);
1472 	u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
1473 				    offsetof(struct rd_msg, opt));
1474 
1475 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1476 	switch (skb->ndisc_nodetype) {
1477 	case NDISC_NODETYPE_HOST:
1478 	case NDISC_NODETYPE_NODEFAULT:
1479 		ND_PRINTK(2, warn,
1480 			  "Redirect: from host or unauthorized router\n");
1481 		return;
1482 	}
1483 #endif
1484 
1485 	if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1486 		ND_PRINTK(2, warn,
1487 			  "Redirect: source address is not link-local\n");
1488 		return;
1489 	}
1490 
1491 	if (!ndisc_parse_options(skb->dev, msg->opt, ndoptlen, &ndopts))
1492 		return;
1493 
1494 	if (!ndopts.nd_opts_rh) {
1495 		ip6_redirect_no_header(skb, dev_net(skb->dev),
1496 					skb->dev->ifindex, 0);
1497 		return;
1498 	}
1499 
1500 	hdr = (u8 *)ndopts.nd_opts_rh;
1501 	hdr += 8;
1502 	if (!pskb_pull(skb, hdr - skb_transport_header(skb)))
1503 		return;
1504 
1505 	icmpv6_notify(skb, NDISC_REDIRECT, 0, 0);
1506 }
1507 
1508 static void ndisc_fill_redirect_hdr_option(struct sk_buff *skb,
1509 					   struct sk_buff *orig_skb,
1510 					   int rd_len)
1511 {
1512 	u8 *opt = skb_put(skb, rd_len);
1513 
1514 	memset(opt, 0, 8);
1515 	*(opt++) = ND_OPT_REDIRECT_HDR;
1516 	*(opt++) = (rd_len >> 3);
1517 	opt += 6;
1518 
1519 	memcpy(opt, ipv6_hdr(orig_skb), rd_len - 8);
1520 }
1521 
1522 void ndisc_send_redirect(struct sk_buff *skb, const struct in6_addr *target)
1523 {
1524 	struct net_device *dev = skb->dev;
1525 	struct net *net = dev_net(dev);
1526 	struct sock *sk = net->ipv6.ndisc_sk;
1527 	int optlen = 0;
1528 	struct inet_peer *peer;
1529 	struct sk_buff *buff;
1530 	struct rd_msg *msg;
1531 	struct in6_addr saddr_buf;
1532 	struct rt6_info *rt;
1533 	struct dst_entry *dst;
1534 	struct flowi6 fl6;
1535 	int rd_len;
1536 	u8 ha_buf[MAX_ADDR_LEN], *ha = NULL,
1537 	   ops_data_buf[NDISC_OPS_REDIRECT_DATA_SPACE], *ops_data = NULL;
1538 	bool ret;
1539 
1540 	if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1541 		ND_PRINTK(2, warn, "Redirect: no link-local address on %s\n",
1542 			  dev->name);
1543 		return;
1544 	}
1545 
1546 	if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1547 	    ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1548 		ND_PRINTK(2, warn,
1549 			  "Redirect: target address is not link-local unicast\n");
1550 		return;
1551 	}
1552 
1553 	icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT,
1554 			 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
1555 
1556 	dst = ip6_route_output(net, NULL, &fl6);
1557 	if (dst->error) {
1558 		dst_release(dst);
1559 		return;
1560 	}
1561 	dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
1562 	if (IS_ERR(dst))
1563 		return;
1564 
1565 	rt = (struct rt6_info *) dst;
1566 
1567 	if (rt->rt6i_flags & RTF_GATEWAY) {
1568 		ND_PRINTK(2, warn,
1569 			  "Redirect: destination is not a neighbour\n");
1570 		goto release;
1571 	}
1572 	peer = inet_getpeer_v6(net->ipv6.peers, &ipv6_hdr(skb)->saddr, 1);
1573 	ret = inet_peer_xrlim_allow(peer, 1*HZ);
1574 	if (peer)
1575 		inet_putpeer(peer);
1576 	if (!ret)
1577 		goto release;
1578 
1579 	if (dev->addr_len) {
1580 		struct neighbour *neigh = dst_neigh_lookup(skb_dst(skb), target);
1581 		if (!neigh) {
1582 			ND_PRINTK(2, warn,
1583 				  "Redirect: no neigh for target address\n");
1584 			goto release;
1585 		}
1586 
1587 		read_lock_bh(&neigh->lock);
1588 		if (neigh->nud_state & NUD_VALID) {
1589 			memcpy(ha_buf, neigh->ha, dev->addr_len);
1590 			read_unlock_bh(&neigh->lock);
1591 			ha = ha_buf;
1592 			optlen += ndisc_redirect_opt_addr_space(dev, neigh,
1593 								ops_data_buf,
1594 								&ops_data);
1595 		} else
1596 			read_unlock_bh(&neigh->lock);
1597 
1598 		neigh_release(neigh);
1599 	}
1600 
1601 	rd_len = min_t(unsigned int,
1602 		       IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(*msg) - optlen,
1603 		       skb->len + 8);
1604 	rd_len &= ~0x7;
1605 	optlen += rd_len;
1606 
1607 	buff = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
1608 	if (!buff)
1609 		goto release;
1610 
1611 	msg = (struct rd_msg *)skb_put(buff, sizeof(*msg));
1612 	*msg = (struct rd_msg) {
1613 		.icmph = {
1614 			.icmp6_type = NDISC_REDIRECT,
1615 		},
1616 		.target = *target,
1617 		.dest = ipv6_hdr(skb)->daddr,
1618 	};
1619 
1620 	/*
1621 	 *	include target_address option
1622 	 */
1623 
1624 	if (ha)
1625 		ndisc_fill_redirect_addr_option(buff, ha, ops_data);
1626 
1627 	/*
1628 	 *	build redirect option and copy skb over to the new packet.
1629 	 */
1630 
1631 	if (rd_len)
1632 		ndisc_fill_redirect_hdr_option(buff, skb, rd_len);
1633 
1634 	skb_dst_set(buff, dst);
1635 	ndisc_send_skb(buff, &ipv6_hdr(skb)->saddr, &saddr_buf);
1636 	return;
1637 
1638 release:
1639 	dst_release(dst);
1640 }
1641 
1642 static void pndisc_redo(struct sk_buff *skb)
1643 {
1644 	ndisc_recv_ns(skb);
1645 	kfree_skb(skb);
1646 }
1647 
1648 static bool ndisc_suppress_frag_ndisc(struct sk_buff *skb)
1649 {
1650 	struct inet6_dev *idev = __in6_dev_get(skb->dev);
1651 
1652 	if (!idev)
1653 		return true;
1654 	if (IP6CB(skb)->flags & IP6SKB_FRAGMENTED &&
1655 	    idev->cnf.suppress_frag_ndisc) {
1656 		net_warn_ratelimited("Received fragmented ndisc packet. Carefully consider disabling suppress_frag_ndisc.\n");
1657 		return true;
1658 	}
1659 	return false;
1660 }
1661 
1662 int ndisc_rcv(struct sk_buff *skb)
1663 {
1664 	struct nd_msg *msg;
1665 
1666 	if (ndisc_suppress_frag_ndisc(skb))
1667 		return 0;
1668 
1669 	if (skb_linearize(skb))
1670 		return 0;
1671 
1672 	msg = (struct nd_msg *)skb_transport_header(skb);
1673 
1674 	__skb_push(skb, skb->data - skb_transport_header(skb));
1675 
1676 	if (ipv6_hdr(skb)->hop_limit != 255) {
1677 		ND_PRINTK(2, warn, "NDISC: invalid hop-limit: %d\n",
1678 			  ipv6_hdr(skb)->hop_limit);
1679 		return 0;
1680 	}
1681 
1682 	if (msg->icmph.icmp6_code != 0) {
1683 		ND_PRINTK(2, warn, "NDISC: invalid ICMPv6 code: %d\n",
1684 			  msg->icmph.icmp6_code);
1685 		return 0;
1686 	}
1687 
1688 	memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1689 
1690 	switch (msg->icmph.icmp6_type) {
1691 	case NDISC_NEIGHBOUR_SOLICITATION:
1692 		ndisc_recv_ns(skb);
1693 		break;
1694 
1695 	case NDISC_NEIGHBOUR_ADVERTISEMENT:
1696 		ndisc_recv_na(skb);
1697 		break;
1698 
1699 	case NDISC_ROUTER_SOLICITATION:
1700 		ndisc_recv_rs(skb);
1701 		break;
1702 
1703 	case NDISC_ROUTER_ADVERTISEMENT:
1704 		ndisc_router_discovery(skb);
1705 		break;
1706 
1707 	case NDISC_REDIRECT:
1708 		ndisc_redirect_rcv(skb);
1709 		break;
1710 	}
1711 
1712 	return 0;
1713 }
1714 
1715 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1716 {
1717 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1718 	struct netdev_notifier_change_info *change_info;
1719 	struct net *net = dev_net(dev);
1720 	struct inet6_dev *idev;
1721 
1722 	switch (event) {
1723 	case NETDEV_CHANGEADDR:
1724 		neigh_changeaddr(&nd_tbl, dev);
1725 		fib6_run_gc(0, net, false);
1726 		idev = in6_dev_get(dev);
1727 		if (!idev)
1728 			break;
1729 		if (idev->cnf.ndisc_notify)
1730 			ndisc_send_unsol_na(dev);
1731 		in6_dev_put(idev);
1732 		break;
1733 	case NETDEV_CHANGE:
1734 		change_info = ptr;
1735 		if (change_info->flags_changed & IFF_NOARP)
1736 			neigh_changeaddr(&nd_tbl, dev);
1737 		break;
1738 	case NETDEV_DOWN:
1739 		neigh_ifdown(&nd_tbl, dev);
1740 		fib6_run_gc(0, net, false);
1741 		break;
1742 	case NETDEV_NOTIFY_PEERS:
1743 		ndisc_send_unsol_na(dev);
1744 		break;
1745 	default:
1746 		break;
1747 	}
1748 
1749 	return NOTIFY_DONE;
1750 }
1751 
1752 static struct notifier_block ndisc_netdev_notifier = {
1753 	.notifier_call = ndisc_netdev_event,
1754 };
1755 
1756 #ifdef CONFIG_SYSCTL
1757 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1758 					 const char *func, const char *dev_name)
1759 {
1760 	static char warncomm[TASK_COMM_LEN];
1761 	static int warned;
1762 	if (strcmp(warncomm, current->comm) && warned < 5) {
1763 		strcpy(warncomm, current->comm);
1764 		pr_warn("process `%s' is using deprecated sysctl (%s) net.ipv6.neigh.%s.%s - use net.ipv6.neigh.%s.%s_ms instead\n",
1765 			warncomm, func,
1766 			dev_name, ctl->procname,
1767 			dev_name, ctl->procname);
1768 		warned++;
1769 	}
1770 }
1771 
1772 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos)
1773 {
1774 	struct net_device *dev = ctl->extra1;
1775 	struct inet6_dev *idev;
1776 	int ret;
1777 
1778 	if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1779 	    (strcmp(ctl->procname, "base_reachable_time") == 0))
1780 		ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1781 
1782 	if (strcmp(ctl->procname, "retrans_time") == 0)
1783 		ret = neigh_proc_dointvec(ctl, write, buffer, lenp, ppos);
1784 
1785 	else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1786 		ret = neigh_proc_dointvec_jiffies(ctl, write,
1787 						  buffer, lenp, ppos);
1788 
1789 	else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1790 		 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1791 		ret = neigh_proc_dointvec_ms_jiffies(ctl, write,
1792 						     buffer, lenp, ppos);
1793 	else
1794 		ret = -1;
1795 
1796 	if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1797 		if (ctl->data == &NEIGH_VAR(idev->nd_parms, BASE_REACHABLE_TIME))
1798 			idev->nd_parms->reachable_time =
1799 					neigh_rand_reach_time(NEIGH_VAR(idev->nd_parms, BASE_REACHABLE_TIME));
1800 		idev->tstamp = jiffies;
1801 		inet6_ifinfo_notify(RTM_NEWLINK, idev);
1802 		in6_dev_put(idev);
1803 	}
1804 	return ret;
1805 }
1806 
1807 
1808 #endif
1809 
1810 static int __net_init ndisc_net_init(struct net *net)
1811 {
1812 	struct ipv6_pinfo *np;
1813 	struct sock *sk;
1814 	int err;
1815 
1816 	err = inet_ctl_sock_create(&sk, PF_INET6,
1817 				   SOCK_RAW, IPPROTO_ICMPV6, net);
1818 	if (err < 0) {
1819 		ND_PRINTK(0, err,
1820 			  "NDISC: Failed to initialize the control socket (err %d)\n",
1821 			  err);
1822 		return err;
1823 	}
1824 
1825 	net->ipv6.ndisc_sk = sk;
1826 
1827 	np = inet6_sk(sk);
1828 	np->hop_limit = 255;
1829 	/* Do not loopback ndisc messages */
1830 	np->mc_loop = 0;
1831 
1832 	return 0;
1833 }
1834 
1835 static void __net_exit ndisc_net_exit(struct net *net)
1836 {
1837 	inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1838 }
1839 
1840 static struct pernet_operations ndisc_net_ops = {
1841 	.init = ndisc_net_init,
1842 	.exit = ndisc_net_exit,
1843 };
1844 
1845 int __init ndisc_init(void)
1846 {
1847 	int err;
1848 
1849 	err = register_pernet_subsys(&ndisc_net_ops);
1850 	if (err)
1851 		return err;
1852 	/*
1853 	 * Initialize the neighbour table
1854 	 */
1855 	neigh_table_init(NEIGH_ND_TABLE, &nd_tbl);
1856 
1857 #ifdef CONFIG_SYSCTL
1858 	err = neigh_sysctl_register(NULL, &nd_tbl.parms,
1859 				    ndisc_ifinfo_sysctl_change);
1860 	if (err)
1861 		goto out_unregister_pernet;
1862 out:
1863 #endif
1864 	return err;
1865 
1866 #ifdef CONFIG_SYSCTL
1867 out_unregister_pernet:
1868 	unregister_pernet_subsys(&ndisc_net_ops);
1869 	goto out;
1870 #endif
1871 }
1872 
1873 int __init ndisc_late_init(void)
1874 {
1875 	return register_netdevice_notifier(&ndisc_netdev_notifier);
1876 }
1877 
1878 void ndisc_late_cleanup(void)
1879 {
1880 	unregister_netdevice_notifier(&ndisc_netdev_notifier);
1881 }
1882 
1883 void ndisc_cleanup(void)
1884 {
1885 #ifdef CONFIG_SYSCTL
1886 	neigh_sysctl_unregister(&nd_tbl.parms);
1887 #endif
1888 	neigh_table_clear(NEIGH_ND_TABLE, &nd_tbl);
1889 	unregister_pernet_subsys(&ndisc_net_ops);
1890 }
1891