xref: /freebsd/sys/netinet6/nd6.c (revision d5b0e70f7e04d971691517ce1304d86a1e367e2e)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. Neither the name of the project nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  *
31  *	$KAME: nd6.c,v 1.144 2001/05/24 07:44:00 itojun Exp $
32  */
33 
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD$");
36 
37 #include "opt_inet.h"
38 #include "opt_inet6.h"
39 #include "opt_route.h"
40 
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/eventhandler.h>
44 #include <sys/callout.h>
45 #include <sys/lock.h>
46 #include <sys/malloc.h>
47 #include <sys/mbuf.h>
48 #include <sys/mutex.h>
49 #include <sys/socket.h>
50 #include <sys/sockio.h>
51 #include <sys/time.h>
52 #include <sys/kernel.h>
53 #include <sys/protosw.h>
54 #include <sys/errno.h>
55 #include <sys/syslog.h>
56 #include <sys/rwlock.h>
57 #include <sys/queue.h>
58 #include <sys/sdt.h>
59 #include <sys/sysctl.h>
60 
61 #include <net/if.h>
62 #include <net/if_var.h>
63 #include <net/if_dl.h>
64 #include <net/if_types.h>
65 #include <net/route.h>
66 #include <net/route/route_ctl.h>
67 #include <net/route/nhop.h>
68 #include <net/vnet.h>
69 
70 #include <netinet/in.h>
71 #include <netinet/in_kdtrace.h>
72 #include <net/if_llatbl.h>
73 #include <netinet/if_ether.h>
74 #include <netinet6/in6_fib.h>
75 #include <netinet6/in6_var.h>
76 #include <netinet/ip6.h>
77 #include <netinet6/ip6_var.h>
78 #include <netinet6/scope6_var.h>
79 #include <netinet6/nd6.h>
80 #include <netinet6/in6_ifattach.h>
81 #include <netinet/icmp6.h>
82 #include <netinet6/send.h>
83 
84 #include <sys/limits.h>
85 
86 #include <security/mac/mac_framework.h>
87 
88 #define ND6_SLOWTIMER_INTERVAL (60 * 60) /* 1 hour */
89 #define ND6_RECALC_REACHTM_INTERVAL (60 * 120) /* 2 hours */
90 
91 #define SIN6(s) ((const struct sockaddr_in6 *)(s))
92 
93 MALLOC_DEFINE(M_IP6NDP, "ip6ndp", "IPv6 Neighbor Discovery");
94 
95 /* timer values */
96 VNET_DEFINE(int, nd6_prune)	= 1;	/* walk list every 1 seconds */
97 VNET_DEFINE(int, nd6_delay)	= 5;	/* delay first probe time 5 second */
98 VNET_DEFINE(int, nd6_umaxtries)	= 3;	/* maximum unicast query */
99 VNET_DEFINE(int, nd6_mmaxtries)	= 3;	/* maximum multicast query */
100 VNET_DEFINE(int, nd6_useloopback) = 1;	/* use loopback interface for
101 					 * local traffic */
102 VNET_DEFINE(int, nd6_gctimer)	= (60 * 60 * 24); /* 1 day: garbage
103 					 * collection timer */
104 
105 /* preventing too many loops in ND option parsing */
106 VNET_DEFINE_STATIC(int, nd6_maxndopt) = 10; /* max # of ND options allowed */
107 
108 VNET_DEFINE(int, nd6_maxnudhint) = 0;	/* max # of subsequent upper
109 					 * layer hints */
110 VNET_DEFINE_STATIC(int, nd6_maxqueuelen) = 16; /* max pkts cached in unresolved
111 					 * ND entries */
112 #define	V_nd6_maxndopt			VNET(nd6_maxndopt)
113 #define	V_nd6_maxqueuelen		VNET(nd6_maxqueuelen)
114 
115 #ifdef ND6_DEBUG
116 VNET_DEFINE(int, nd6_debug) = 1;
117 #else
118 VNET_DEFINE(int, nd6_debug) = 0;
119 #endif
120 
121 static eventhandler_tag lle_event_eh, iflladdr_event_eh, ifnet_link_event_eh;
122 
123 VNET_DEFINE(struct nd_prhead, nd_prefix);
124 VNET_DEFINE(struct rwlock, nd6_lock);
125 VNET_DEFINE(uint64_t, nd6_list_genid);
126 VNET_DEFINE(struct mtx, nd6_onlink_mtx);
127 
128 VNET_DEFINE(int, nd6_recalc_reachtm_interval) = ND6_RECALC_REACHTM_INTERVAL;
129 #define	V_nd6_recalc_reachtm_interval	VNET(nd6_recalc_reachtm_interval)
130 
131 int	(*send_sendso_input_hook)(struct mbuf *, struct ifnet *, int, int);
132 
133 static bool nd6_is_new_addr_neighbor(const struct sockaddr_in6 *,
134 	struct ifnet *);
135 static void nd6_setmtu0(struct ifnet *, struct nd_ifinfo *);
136 static void nd6_slowtimo(void *);
137 static int regen_tmpaddr(struct in6_ifaddr *);
138 static void nd6_free(struct llentry **, int);
139 static void nd6_free_redirect(const struct llentry *);
140 static void nd6_llinfo_timer(void *);
141 static void nd6_llinfo_settimer_locked(struct llentry *, long);
142 static int nd6_resolve_slow(struct ifnet *, int, int, struct mbuf *,
143     const struct sockaddr_in6 *, u_char *, uint32_t *, struct llentry **);
144 static int nd6_need_cache(struct ifnet *);
145 
146 VNET_DEFINE_STATIC(struct callout, nd6_slowtimo_ch);
147 #define	V_nd6_slowtimo_ch		VNET(nd6_slowtimo_ch)
148 
149 VNET_DEFINE_STATIC(struct callout, nd6_timer_ch);
150 #define	V_nd6_timer_ch			VNET(nd6_timer_ch)
151 
152 SYSCTL_DECL(_net_inet6_icmp6);
153 
154 static void
155 nd6_lle_event(void *arg __unused, struct llentry *lle, int evt)
156 {
157 	struct rt_addrinfo rtinfo;
158 	struct sockaddr_in6 dst;
159 	struct sockaddr_dl gw;
160 	struct ifnet *ifp;
161 	int type;
162 	int fibnum;
163 
164 	LLE_WLOCK_ASSERT(lle);
165 
166 	if (lltable_get_af(lle->lle_tbl) != AF_INET6)
167 		return;
168 
169 	switch (evt) {
170 	case LLENTRY_RESOLVED:
171 		type = RTM_ADD;
172 		KASSERT(lle->la_flags & LLE_VALID,
173 		    ("%s: %p resolved but not valid?", __func__, lle));
174 		break;
175 	case LLENTRY_EXPIRED:
176 		type = RTM_DELETE;
177 		break;
178 	default:
179 		return;
180 	}
181 
182 	ifp = lltable_get_ifp(lle->lle_tbl);
183 
184 	bzero(&dst, sizeof(dst));
185 	bzero(&gw, sizeof(gw));
186 	bzero(&rtinfo, sizeof(rtinfo));
187 	lltable_fill_sa_entry(lle, (struct sockaddr *)&dst);
188 	dst.sin6_scope_id = in6_getscopezone(ifp,
189 	    in6_addrscope(&dst.sin6_addr));
190 	gw.sdl_len = sizeof(struct sockaddr_dl);
191 	gw.sdl_family = AF_LINK;
192 	gw.sdl_alen = ifp->if_addrlen;
193 	gw.sdl_index = ifp->if_index;
194 	gw.sdl_type = ifp->if_type;
195 	if (evt == LLENTRY_RESOLVED)
196 		bcopy(lle->ll_addr, gw.sdl_data, ifp->if_addrlen);
197 	rtinfo.rti_info[RTAX_DST] = (struct sockaddr *)&dst;
198 	rtinfo.rti_info[RTAX_GATEWAY] = (struct sockaddr *)&gw;
199 	rtinfo.rti_addrs = RTA_DST | RTA_GATEWAY;
200 	fibnum = V_rt_add_addr_allfibs ? RT_ALL_FIBS : ifp->if_fib;
201 	rt_missmsg_fib(type, &rtinfo, RTF_HOST | RTF_LLDATA | (
202 	    type == RTM_ADD ? RTF_UP: 0), 0, fibnum);
203 }
204 
205 /*
206  * A handler for interface link layer address change event.
207  */
208 static void
209 nd6_iflladdr(void *arg __unused, struct ifnet *ifp)
210 {
211 	if (ifp->if_afdata[AF_INET6] == NULL)
212 		return;
213 
214 	lltable_update_ifaddr(LLTABLE6(ifp));
215 }
216 
217 void
218 nd6_init(void)
219 {
220 
221 	mtx_init(&V_nd6_onlink_mtx, "nd6 onlink", NULL, MTX_DEF);
222 	rw_init(&V_nd6_lock, "nd6 list");
223 
224 	LIST_INIT(&V_nd_prefix);
225 	nd6_defrouter_init();
226 
227 	/* Start timers. */
228 	callout_init(&V_nd6_slowtimo_ch, 1);
229 	callout_reset(&V_nd6_slowtimo_ch, ND6_SLOWTIMER_INTERVAL * hz,
230 	    nd6_slowtimo, curvnet);
231 
232 	callout_init(&V_nd6_timer_ch, 1);
233 	callout_reset(&V_nd6_timer_ch, hz, nd6_timer, curvnet);
234 
235 	nd6_dad_init();
236 	if (IS_DEFAULT_VNET(curvnet)) {
237 		lle_event_eh = EVENTHANDLER_REGISTER(lle_event, nd6_lle_event,
238 		    NULL, EVENTHANDLER_PRI_ANY);
239 		iflladdr_event_eh = EVENTHANDLER_REGISTER(iflladdr_event,
240 		    nd6_iflladdr, NULL, EVENTHANDLER_PRI_ANY);
241 		ifnet_link_event_eh = EVENTHANDLER_REGISTER(ifnet_link_event,
242 		    nd6_ifnet_link_event, NULL, EVENTHANDLER_PRI_ANY);
243 	}
244 }
245 
246 #ifdef VIMAGE
247 void
248 nd6_destroy(void)
249 {
250 
251 	callout_drain(&V_nd6_slowtimo_ch);
252 	callout_drain(&V_nd6_timer_ch);
253 	if (IS_DEFAULT_VNET(curvnet)) {
254 		EVENTHANDLER_DEREGISTER(ifnet_link_event, ifnet_link_event_eh);
255 		EVENTHANDLER_DEREGISTER(lle_event, lle_event_eh);
256 		EVENTHANDLER_DEREGISTER(iflladdr_event, iflladdr_event_eh);
257 	}
258 	rw_destroy(&V_nd6_lock);
259 	mtx_destroy(&V_nd6_onlink_mtx);
260 }
261 #endif
262 
263 struct nd_ifinfo *
264 nd6_ifattach(struct ifnet *ifp)
265 {
266 	struct nd_ifinfo *nd;
267 
268 	nd = malloc(sizeof(*nd), M_IP6NDP, M_WAITOK | M_ZERO);
269 	nd->initialized = 1;
270 
271 	nd->chlim = IPV6_DEFHLIM;
272 	nd->basereachable = REACHABLE_TIME;
273 	nd->reachable = ND_COMPUTE_RTIME(nd->basereachable);
274 	nd->retrans = RETRANS_TIMER;
275 
276 	nd->flags = ND6_IFF_PERFORMNUD;
277 
278 	/* Set IPv6 disabled on all interfaces but loopback by default. */
279 	if ((ifp->if_flags & IFF_LOOPBACK) == 0)
280 		nd->flags |= ND6_IFF_IFDISABLED;
281 
282 	/* A loopback interface always has ND6_IFF_AUTO_LINKLOCAL.
283 	 * XXXHRS: Clear ND6_IFF_AUTO_LINKLOCAL on an IFT_BRIDGE interface by
284 	 * default regardless of the V_ip6_auto_linklocal configuration to
285 	 * give a reasonable default behavior.
286 	 */
287 	if ((V_ip6_auto_linklocal && ifp->if_type != IFT_BRIDGE &&
288 	    ifp->if_type != IFT_WIREGUARD) || (ifp->if_flags & IFF_LOOPBACK))
289 		nd->flags |= ND6_IFF_AUTO_LINKLOCAL;
290 	/*
291 	 * A loopback interface does not need to accept RTADV.
292 	 * XXXHRS: Clear ND6_IFF_ACCEPT_RTADV on an IFT_BRIDGE interface by
293 	 * default regardless of the V_ip6_accept_rtadv configuration to
294 	 * prevent the interface from accepting RA messages arrived
295 	 * on one of the member interfaces with ND6_IFF_ACCEPT_RTADV.
296 	 */
297 	if (V_ip6_accept_rtadv &&
298 	    !(ifp->if_flags & IFF_LOOPBACK) &&
299 	    (ifp->if_type != IFT_BRIDGE)) {
300 			nd->flags |= ND6_IFF_ACCEPT_RTADV;
301 			/* If we globally accept rtadv, assume IPv6 on. */
302 			nd->flags &= ~ND6_IFF_IFDISABLED;
303 	}
304 	if (V_ip6_no_radr && !(ifp->if_flags & IFF_LOOPBACK))
305 		nd->flags |= ND6_IFF_NO_RADR;
306 
307 	/* XXX: we cannot call nd6_setmtu since ifp is not fully initialized */
308 	nd6_setmtu0(ifp, nd);
309 
310 	return nd;
311 }
312 
313 void
314 nd6_ifdetach(struct ifnet *ifp, struct nd_ifinfo *nd)
315 {
316 	struct epoch_tracker et;
317 	struct ifaddr *ifa, *next;
318 
319 	NET_EPOCH_ENTER(et);
320 	CK_STAILQ_FOREACH_SAFE(ifa, &ifp->if_addrhead, ifa_link, next) {
321 		if (ifa->ifa_addr->sa_family != AF_INET6)
322 			continue;
323 
324 		/* stop DAD processing */
325 		nd6_dad_stop(ifa);
326 	}
327 	NET_EPOCH_EXIT(et);
328 
329 	free(nd, M_IP6NDP);
330 }
331 
332 /*
333  * Reset ND level link MTU. This function is called when the physical MTU
334  * changes, which means we might have to adjust the ND level MTU.
335  */
336 void
337 nd6_setmtu(struct ifnet *ifp)
338 {
339 	if (ifp->if_afdata[AF_INET6] == NULL)
340 		return;
341 
342 	nd6_setmtu0(ifp, ND_IFINFO(ifp));
343 }
344 
345 /* XXX todo: do not maintain copy of ifp->if_mtu in ndi->maxmtu */
346 void
347 nd6_setmtu0(struct ifnet *ifp, struct nd_ifinfo *ndi)
348 {
349 	u_int32_t omaxmtu;
350 
351 	omaxmtu = ndi->maxmtu;
352 	ndi->maxmtu = ifp->if_mtu;
353 
354 	/*
355 	 * Decreasing the interface MTU under IPV6 minimum MTU may cause
356 	 * undesirable situation.  We thus notify the operator of the change
357 	 * explicitly.  The check for omaxmtu is necessary to restrict the
358 	 * log to the case of changing the MTU, not initializing it.
359 	 */
360 	if (omaxmtu >= IPV6_MMTU && ndi->maxmtu < IPV6_MMTU) {
361 		log(LOG_NOTICE, "nd6_setmtu0: "
362 		    "new link MTU on %s (%lu) is too small for IPv6\n",
363 		    if_name(ifp), (unsigned long)ndi->maxmtu);
364 	}
365 
366 	if (ndi->maxmtu > V_in6_maxmtu)
367 		in6_setmaxmtu(); /* check all interfaces just in case */
368 
369 }
370 
371 void
372 nd6_option_init(void *opt, int icmp6len, union nd_opts *ndopts)
373 {
374 
375 	bzero(ndopts, sizeof(*ndopts));
376 	ndopts->nd_opts_search = (struct nd_opt_hdr *)opt;
377 	ndopts->nd_opts_last
378 		= (struct nd_opt_hdr *)(((u_char *)opt) + icmp6len);
379 
380 	if (icmp6len == 0) {
381 		ndopts->nd_opts_done = 1;
382 		ndopts->nd_opts_search = NULL;
383 	}
384 }
385 
386 /*
387  * Take one ND option.
388  */
389 struct nd_opt_hdr *
390 nd6_option(union nd_opts *ndopts)
391 {
392 	struct nd_opt_hdr *nd_opt;
393 	int olen;
394 
395 	KASSERT(ndopts != NULL, ("%s: ndopts == NULL", __func__));
396 	KASSERT(ndopts->nd_opts_last != NULL, ("%s: uninitialized ndopts",
397 	    __func__));
398 	if (ndopts->nd_opts_search == NULL)
399 		return NULL;
400 	if (ndopts->nd_opts_done)
401 		return NULL;
402 
403 	nd_opt = ndopts->nd_opts_search;
404 
405 	/* make sure nd_opt_len is inside the buffer */
406 	if ((caddr_t)&nd_opt->nd_opt_len >= (caddr_t)ndopts->nd_opts_last) {
407 		bzero(ndopts, sizeof(*ndopts));
408 		return NULL;
409 	}
410 
411 	olen = nd_opt->nd_opt_len << 3;
412 	if (olen == 0) {
413 		/*
414 		 * Message validation requires that all included
415 		 * options have a length that is greater than zero.
416 		 */
417 		bzero(ndopts, sizeof(*ndopts));
418 		return NULL;
419 	}
420 
421 	ndopts->nd_opts_search = (struct nd_opt_hdr *)((caddr_t)nd_opt + olen);
422 	if (ndopts->nd_opts_search > ndopts->nd_opts_last) {
423 		/* option overruns the end of buffer, invalid */
424 		bzero(ndopts, sizeof(*ndopts));
425 		return NULL;
426 	} else if (ndopts->nd_opts_search == ndopts->nd_opts_last) {
427 		/* reached the end of options chain */
428 		ndopts->nd_opts_done = 1;
429 		ndopts->nd_opts_search = NULL;
430 	}
431 	return nd_opt;
432 }
433 
434 /*
435  * Parse multiple ND options.
436  * This function is much easier to use, for ND routines that do not need
437  * multiple options of the same type.
438  */
439 int
440 nd6_options(union nd_opts *ndopts)
441 {
442 	struct nd_opt_hdr *nd_opt;
443 	int i = 0;
444 
445 	KASSERT(ndopts != NULL, ("%s: ndopts == NULL", __func__));
446 	KASSERT(ndopts->nd_opts_last != NULL, ("%s: uninitialized ndopts",
447 	    __func__));
448 	if (ndopts->nd_opts_search == NULL)
449 		return 0;
450 
451 	while (1) {
452 		nd_opt = nd6_option(ndopts);
453 		if (nd_opt == NULL && ndopts->nd_opts_last == NULL) {
454 			/*
455 			 * Message validation requires that all included
456 			 * options have a length that is greater than zero.
457 			 */
458 			ICMP6STAT_INC(icp6s_nd_badopt);
459 			bzero(ndopts, sizeof(*ndopts));
460 			return -1;
461 		}
462 
463 		if (nd_opt == NULL)
464 			goto skip1;
465 
466 		switch (nd_opt->nd_opt_type) {
467 		case ND_OPT_SOURCE_LINKADDR:
468 		case ND_OPT_TARGET_LINKADDR:
469 		case ND_OPT_MTU:
470 		case ND_OPT_REDIRECTED_HEADER:
471 		case ND_OPT_NONCE:
472 			if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
473 				nd6log((LOG_INFO,
474 				    "duplicated ND6 option found (type=%d)\n",
475 				    nd_opt->nd_opt_type));
476 				/* XXX bark? */
477 			} else {
478 				ndopts->nd_opt_array[nd_opt->nd_opt_type]
479 					= nd_opt;
480 			}
481 			break;
482 		case ND_OPT_PREFIX_INFORMATION:
483 			if (ndopts->nd_opt_array[nd_opt->nd_opt_type] == 0) {
484 				ndopts->nd_opt_array[nd_opt->nd_opt_type]
485 					= nd_opt;
486 			}
487 			ndopts->nd_opts_pi_end =
488 				(struct nd_opt_prefix_info *)nd_opt;
489 			break;
490 		/* What about ND_OPT_ROUTE_INFO? RFC 4191 */
491 		case ND_OPT_RDNSS:	/* RFC 6106 */
492 		case ND_OPT_DNSSL:	/* RFC 6106 */
493 			/*
494 			 * Silently ignore options we know and do not care about
495 			 * in the kernel.
496 			 */
497 			break;
498 		default:
499 			/*
500 			 * Unknown options must be silently ignored,
501 			 * to accommodate future extension to the protocol.
502 			 */
503 			nd6log((LOG_DEBUG,
504 			    "nd6_options: unsupported option %d - "
505 			    "option ignored\n", nd_opt->nd_opt_type));
506 		}
507 
508 skip1:
509 		i++;
510 		if (i > V_nd6_maxndopt) {
511 			ICMP6STAT_INC(icp6s_nd_toomanyopt);
512 			nd6log((LOG_INFO, "too many loop in nd opt\n"));
513 			break;
514 		}
515 
516 		if (ndopts->nd_opts_done)
517 			break;
518 	}
519 
520 	return 0;
521 }
522 
523 /*
524  * ND6 timer routine to handle ND6 entries
525  */
526 static void
527 nd6_llinfo_settimer_locked(struct llentry *ln, long tick)
528 {
529 	int canceled;
530 
531 	LLE_WLOCK_ASSERT(ln);
532 
533 	/* Do not schedule timers for child LLEs. */
534 	if (ln->la_flags & LLE_CHILD)
535 		return;
536 
537 	if (tick < 0) {
538 		ln->la_expire = 0;
539 		ln->ln_ntick = 0;
540 		canceled = callout_stop(&ln->lle_timer);
541 	} else {
542 		ln->la_expire = time_uptime + tick / hz;
543 		LLE_ADDREF(ln);
544 		if (tick > INT_MAX) {
545 			ln->ln_ntick = tick - INT_MAX;
546 			canceled = callout_reset(&ln->lle_timer, INT_MAX,
547 			    nd6_llinfo_timer, ln);
548 		} else {
549 			ln->ln_ntick = 0;
550 			canceled = callout_reset(&ln->lle_timer, tick,
551 			    nd6_llinfo_timer, ln);
552 		}
553 	}
554 	if (canceled > 0)
555 		LLE_REMREF(ln);
556 }
557 
558 /*
559  * Gets source address of the first packet in hold queue
560  * and stores it in @src.
561  * Returns pointer to @src (if hold queue is not empty) or NULL.
562  *
563  * Set noinline to be dtrace-friendly
564  */
565 static __noinline struct in6_addr *
566 nd6_llinfo_get_holdsrc(struct llentry *ln, struct in6_addr *src)
567 {
568 	struct ip6_hdr hdr;
569 	struct mbuf *m;
570 
571 	if (ln->la_hold == NULL)
572 		return (NULL);
573 
574 	/*
575 	 * assume every packet in la_hold has the same IP header
576 	 */
577 	m = ln->la_hold;
578 	if (sizeof(hdr) > m->m_len)
579 		return (NULL);
580 
581 	m_copydata(m, 0, sizeof(hdr), (caddr_t)&hdr);
582 	*src = hdr.ip6_src;
583 
584 	return (src);
585 }
586 
587 /*
588  * Checks if we need to switch from STALE state.
589  *
590  * RFC 4861 requires switching from STALE to DELAY state
591  * on first packet matching entry, waiting V_nd6_delay and
592  * transition to PROBE state (if upper layer confirmation was
593  * not received).
594  *
595  * This code performs a bit differently:
596  * On packet hit we don't change state (but desired state
597  * can be guessed by control plane). However, after V_nd6_delay
598  * seconds code will transition to PROBE state (so DELAY state
599  * is kinda skipped in most situations).
600  *
601  * Typically, V_nd6_gctimer is bigger than V_nd6_delay, so
602  * we perform the following upon entering STALE state:
603  *
604  * 1) Arm timer to run each V_nd6_delay seconds to make sure that
605  * if packet was transmitted at the start of given interval, we
606  * would be able to switch to PROBE state in V_nd6_delay seconds
607  * as user expects.
608  *
609  * 2) Reschedule timer until original V_nd6_gctimer expires keeping
610  * lle in STALE state (remaining timer value stored in lle_remtime).
611  *
612  * 3) Reschedule timer if packet was transmitted less that V_nd6_delay
613  * seconds ago.
614  *
615  * Returns non-zero value if the entry is still STALE (storing
616  * the next timer interval in @pdelay).
617  *
618  * Returns zero value if original timer expired or we need to switch to
619  * PROBE (store that in @do_switch variable).
620  */
621 static int
622 nd6_is_stale(struct llentry *lle, long *pdelay, int *do_switch)
623 {
624 	int nd_delay, nd_gctimer;
625 	time_t lle_hittime;
626 	long delay;
627 
628 	*do_switch = 0;
629 	nd_gctimer = V_nd6_gctimer;
630 	nd_delay = V_nd6_delay;
631 
632 	lle_hittime = llentry_get_hittime(lle);
633 
634 	if (lle_hittime == 0) {
635 		/*
636 		 * Datapath feedback has been requested upon entering
637 		 * STALE state. No packets has been passed using this lle.
638 		 * Ask for the timer reschedule and keep STALE state.
639 		 */
640 		delay = (long)(MIN(nd_gctimer, nd_delay));
641 		delay *= hz;
642 		if (lle->lle_remtime > delay)
643 			lle->lle_remtime -= delay;
644 		else {
645 			delay = lle->lle_remtime;
646 			lle->lle_remtime = 0;
647 		}
648 
649 		if (delay == 0) {
650 			/*
651 			 * The original ng6_gctime timeout ended,
652 			 * no more rescheduling.
653 			 */
654 			return (0);
655 		}
656 
657 		*pdelay = delay;
658 		return (1);
659 	}
660 
661 	/*
662 	 * Packet received. Verify timestamp
663 	 */
664 	delay = (long)(time_uptime - lle_hittime);
665 	if (delay < nd_delay) {
666 		/*
667 		 * V_nd6_delay still not passed since the first
668 		 * hit in STALE state.
669 		 * Reschedule timer and return.
670 		 */
671 		*pdelay = (long)(nd_delay - delay) * hz;
672 		return (1);
673 	}
674 
675 	/* Request switching to probe */
676 	*do_switch = 1;
677 	return (0);
678 }
679 
680 /*
681  * Switch @lle state to new state optionally arming timers.
682  *
683  * Set noinline to be dtrace-friendly
684  */
685 __noinline void
686 nd6_llinfo_setstate(struct llentry *lle, int newstate)
687 {
688 	struct ifnet *ifp;
689 	int nd_gctimer, nd_delay;
690 	long delay, remtime;
691 
692 	delay = 0;
693 	remtime = 0;
694 
695 	switch (newstate) {
696 	case ND6_LLINFO_INCOMPLETE:
697 		ifp = lle->lle_tbl->llt_ifp;
698 		delay = (long)ND_IFINFO(ifp)->retrans * hz / 1000;
699 		break;
700 	case ND6_LLINFO_REACHABLE:
701 		if (!ND6_LLINFO_PERMANENT(lle)) {
702 			ifp = lle->lle_tbl->llt_ifp;
703 			delay = (long)ND_IFINFO(ifp)->reachable * hz;
704 		}
705 		break;
706 	case ND6_LLINFO_STALE:
707 
708 		llentry_request_feedback(lle);
709 		nd_delay = V_nd6_delay;
710 		nd_gctimer = V_nd6_gctimer;
711 
712 		delay = (long)(MIN(nd_gctimer, nd_delay)) * hz;
713 		remtime = (long)nd_gctimer * hz - delay;
714 		break;
715 	case ND6_LLINFO_DELAY:
716 		lle->la_asked = 0;
717 		delay = (long)V_nd6_delay * hz;
718 		break;
719 	}
720 
721 	if (delay > 0)
722 		nd6_llinfo_settimer_locked(lle, delay);
723 
724 	lle->lle_remtime = remtime;
725 	lle->ln_state = newstate;
726 }
727 
728 /*
729  * Timer-dependent part of nd state machine.
730  *
731  * Set noinline to be dtrace-friendly
732  */
733 static __noinline void
734 nd6_llinfo_timer(void *arg)
735 {
736 	struct epoch_tracker et;
737 	struct llentry *ln;
738 	struct in6_addr *dst, *pdst, *psrc, src;
739 	struct ifnet *ifp;
740 	struct nd_ifinfo *ndi;
741 	int do_switch, send_ns;
742 	long delay;
743 
744 	KASSERT(arg != NULL, ("%s: arg NULL", __func__));
745 	ln = (struct llentry *)arg;
746 	ifp = lltable_get_ifp(ln->lle_tbl);
747 	CURVNET_SET(ifp->if_vnet);
748 
749 	ND6_RLOCK();
750 	LLE_WLOCK(ln);
751 	if (callout_pending(&ln->lle_timer)) {
752 		/*
753 		 * Here we are a bit odd here in the treatment of
754 		 * active/pending. If the pending bit is set, it got
755 		 * rescheduled before I ran. The active
756 		 * bit we ignore, since if it was stopped
757 		 * in ll_tablefree() and was currently running
758 		 * it would have return 0 so the code would
759 		 * not have deleted it since the callout could
760 		 * not be stopped so we want to go through
761 		 * with the delete here now. If the callout
762 		 * was restarted, the pending bit will be back on and
763 		 * we just want to bail since the callout_reset would
764 		 * return 1 and our reference would have been removed
765 		 * by nd6_llinfo_settimer_locked above since canceled
766 		 * would have been 1.
767 		 */
768 		LLE_WUNLOCK(ln);
769 		ND6_RUNLOCK();
770 		CURVNET_RESTORE();
771 		return;
772 	}
773 	NET_EPOCH_ENTER(et);
774 	ndi = ND_IFINFO(ifp);
775 	send_ns = 0;
776 	dst = &ln->r_l3addr.addr6;
777 	pdst = dst;
778 
779 	if (ln->ln_ntick > 0) {
780 		if (ln->ln_ntick > INT_MAX) {
781 			ln->ln_ntick -= INT_MAX;
782 			nd6_llinfo_settimer_locked(ln, INT_MAX);
783 		} else {
784 			ln->ln_ntick = 0;
785 			nd6_llinfo_settimer_locked(ln, ln->ln_ntick);
786 		}
787 		goto done;
788 	}
789 
790 	if (ln->la_flags & LLE_STATIC) {
791 		goto done;
792 	}
793 
794 	if (ln->la_flags & LLE_DELETED) {
795 		nd6_free(&ln, 0);
796 		goto done;
797 	}
798 
799 	switch (ln->ln_state) {
800 	case ND6_LLINFO_INCOMPLETE:
801 		if (ln->la_asked < V_nd6_mmaxtries) {
802 			ln->la_asked++;
803 			send_ns = 1;
804 			/* Send NS to multicast address */
805 			pdst = NULL;
806 		} else {
807 			struct mbuf *m;
808 
809 			ICMP6STAT_ADD(icp6s_dropped, ln->la_numheld);
810 
811 			m = ln->la_hold;
812 			if (m != NULL) {
813 				/*
814 				 * assuming every packet in la_hold has the
815 				 * same IP header.  Send error after unlock.
816 				 */
817 				ln->la_hold = m->m_nextpkt;
818 				m->m_nextpkt = NULL;
819 				ln->la_numheld--;
820 			}
821 			nd6_free(&ln, 0);
822 			if (m != NULL) {
823 				struct mbuf *n = m;
824 
825 				/*
826 				 * if there are any ummapped mbufs, we
827 				 * must free them, rather than using
828 				 * them for an ICMP, as they cannot be
829 				 * checksummed.
830 				 */
831 				while ((n = n->m_next) != NULL) {
832 					if (n->m_flags & M_EXTPG)
833 						break;
834 				}
835 				if (n != NULL) {
836 					m_freem(m);
837 					m = NULL;
838 				} else {
839 					icmp6_error2(m, ICMP6_DST_UNREACH,
840 					    ICMP6_DST_UNREACH_ADDR, 0, ifp);
841 				}
842 			}
843 		}
844 		break;
845 	case ND6_LLINFO_REACHABLE:
846 		if (!ND6_LLINFO_PERMANENT(ln))
847 			nd6_llinfo_setstate(ln, ND6_LLINFO_STALE);
848 		break;
849 
850 	case ND6_LLINFO_STALE:
851 		if (nd6_is_stale(ln, &delay, &do_switch) != 0) {
852 			/*
853 			 * No packet has used this entry and GC timeout
854 			 * has not been passed. Reschedule timer and
855 			 * return.
856 			 */
857 			nd6_llinfo_settimer_locked(ln, delay);
858 			break;
859 		}
860 
861 		if (do_switch == 0) {
862 			/*
863 			 * GC timer has ended and entry hasn't been used.
864 			 * Run Garbage collector (RFC 4861, 5.3)
865 			 */
866 			if (!ND6_LLINFO_PERMANENT(ln))
867 				nd6_free(&ln, 1);
868 			break;
869 		}
870 
871 		/* Entry has been used AND delay timer has ended. */
872 
873 		/* FALLTHROUGH */
874 
875 	case ND6_LLINFO_DELAY:
876 		if (ndi && (ndi->flags & ND6_IFF_PERFORMNUD) != 0) {
877 			/* We need NUD */
878 			ln->la_asked = 1;
879 			nd6_llinfo_setstate(ln, ND6_LLINFO_PROBE);
880 			send_ns = 1;
881 		} else
882 			nd6_llinfo_setstate(ln, ND6_LLINFO_STALE); /* XXX */
883 		break;
884 	case ND6_LLINFO_PROBE:
885 		if (ln->la_asked < V_nd6_umaxtries) {
886 			ln->la_asked++;
887 			send_ns = 1;
888 		} else {
889 			nd6_free(&ln, 0);
890 		}
891 		break;
892 	default:
893 		panic("%s: paths in a dark night can be confusing: %d",
894 		    __func__, ln->ln_state);
895 	}
896 done:
897 	if (ln != NULL)
898 		ND6_RUNLOCK();
899 	if (send_ns != 0) {
900 		nd6_llinfo_settimer_locked(ln, (long)ndi->retrans * hz / 1000);
901 		psrc = nd6_llinfo_get_holdsrc(ln, &src);
902 		LLE_FREE_LOCKED(ln);
903 		ln = NULL;
904 		nd6_ns_output(ifp, psrc, pdst, dst, NULL);
905 	}
906 
907 	if (ln != NULL)
908 		LLE_FREE_LOCKED(ln);
909 	NET_EPOCH_EXIT(et);
910 	CURVNET_RESTORE();
911 }
912 
913 /*
914  * ND6 timer routine to expire default route list and prefix list
915  */
916 void
917 nd6_timer(void *arg)
918 {
919 	CURVNET_SET((struct vnet *) arg);
920 	struct epoch_tracker et;
921 	struct nd_prhead prl;
922 	struct nd_prefix *pr, *npr;
923 	struct ifnet *ifp;
924 	struct in6_ifaddr *ia6, *nia6;
925 	uint64_t genid;
926 
927 	LIST_INIT(&prl);
928 
929 	NET_EPOCH_ENTER(et);
930 	nd6_defrouter_timer();
931 
932 	/*
933 	 * expire interface addresses.
934 	 * in the past the loop was inside prefix expiry processing.
935 	 * However, from a stricter speci-confrmance standpoint, we should
936 	 * rather separate address lifetimes and prefix lifetimes.
937 	 *
938 	 * XXXRW: in6_ifaddrhead locking.
939 	 */
940   addrloop:
941 	CK_STAILQ_FOREACH_SAFE(ia6, &V_in6_ifaddrhead, ia_link, nia6) {
942 		/* check address lifetime */
943 		if (IFA6_IS_INVALID(ia6)) {
944 			int regen = 0;
945 
946 			/*
947 			 * If the expiring address is temporary, try
948 			 * regenerating a new one.  This would be useful when
949 			 * we suspended a laptop PC, then turned it on after a
950 			 * period that could invalidate all temporary
951 			 * addresses.  Although we may have to restart the
952 			 * loop (see below), it must be after purging the
953 			 * address.  Otherwise, we'd see an infinite loop of
954 			 * regeneration.
955 			 */
956 			if (V_ip6_use_tempaddr &&
957 			    (ia6->ia6_flags & IN6_IFF_TEMPORARY) != 0) {
958 				if (regen_tmpaddr(ia6) == 0)
959 					regen = 1;
960 			}
961 
962 			in6_purgeaddr(&ia6->ia_ifa);
963 
964 			if (regen)
965 				goto addrloop; /* XXX: see below */
966 		} else if (IFA6_IS_DEPRECATED(ia6)) {
967 			int oldflags = ia6->ia6_flags;
968 
969 			ia6->ia6_flags |= IN6_IFF_DEPRECATED;
970 
971 			/*
972 			 * If a temporary address has just become deprecated,
973 			 * regenerate a new one if possible.
974 			 */
975 			if (V_ip6_use_tempaddr &&
976 			    (ia6->ia6_flags & IN6_IFF_TEMPORARY) != 0 &&
977 			    (oldflags & IN6_IFF_DEPRECATED) == 0) {
978 				if (regen_tmpaddr(ia6) == 0) {
979 					/*
980 					 * A new temporary address is
981 					 * generated.
982 					 * XXX: this means the address chain
983 					 * has changed while we are still in
984 					 * the loop.  Although the change
985 					 * would not cause disaster (because
986 					 * it's not a deletion, but an
987 					 * addition,) we'd rather restart the
988 					 * loop just for safety.  Or does this
989 					 * significantly reduce performance??
990 					 */
991 					goto addrloop;
992 				}
993 			}
994 		} else if ((ia6->ia6_flags & IN6_IFF_TENTATIVE) != 0) {
995 			/*
996 			 * Schedule DAD for a tentative address.  This happens
997 			 * if the interface was down or not running
998 			 * when the address was configured.
999 			 */
1000 			int delay;
1001 
1002 			delay = arc4random() %
1003 			    (MAX_RTR_SOLICITATION_DELAY * hz);
1004 			nd6_dad_start((struct ifaddr *)ia6, delay);
1005 		} else {
1006 			/*
1007 			 * Check status of the interface.  If it is down,
1008 			 * mark the address as tentative for future DAD.
1009 			 */
1010 			ifp = ia6->ia_ifp;
1011 			if ((ND_IFINFO(ifp)->flags & ND6_IFF_NO_DAD) == 0 &&
1012 			    ((ifp->if_flags & IFF_UP) == 0 ||
1013 			    (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 ||
1014 			    (ND_IFINFO(ifp)->flags & ND6_IFF_IFDISABLED) != 0)){
1015 				ia6->ia6_flags &= ~IN6_IFF_DUPLICATED;
1016 				ia6->ia6_flags |= IN6_IFF_TENTATIVE;
1017 			}
1018 
1019 			/*
1020 			 * A new RA might have made a deprecated address
1021 			 * preferred.
1022 			 */
1023 			ia6->ia6_flags &= ~IN6_IFF_DEPRECATED;
1024 		}
1025 	}
1026 	NET_EPOCH_EXIT(et);
1027 
1028 	ND6_WLOCK();
1029 restart:
1030 	LIST_FOREACH_SAFE(pr, &V_nd_prefix, ndpr_entry, npr) {
1031 		/*
1032 		 * Expire prefixes. Since the pltime is only used for
1033 		 * autoconfigured addresses, pltime processing for prefixes is
1034 		 * not necessary.
1035 		 *
1036 		 * Only unlink after all derived addresses have expired. This
1037 		 * may not occur until two hours after the prefix has expired
1038 		 * per RFC 4862. If the prefix expires before its derived
1039 		 * addresses, mark it off-link. This will be done automatically
1040 		 * after unlinking if no address references remain.
1041 		 */
1042 		if (pr->ndpr_vltime == ND6_INFINITE_LIFETIME ||
1043 		    time_uptime - pr->ndpr_lastupdate <= pr->ndpr_vltime)
1044 			continue;
1045 
1046 		if (pr->ndpr_addrcnt == 0) {
1047 			nd6_prefix_unlink(pr, &prl);
1048 			continue;
1049 		}
1050 		if ((pr->ndpr_stateflags & NDPRF_ONLINK) != 0) {
1051 			genid = V_nd6_list_genid;
1052 			nd6_prefix_ref(pr);
1053 			ND6_WUNLOCK();
1054 			ND6_ONLINK_LOCK();
1055 			(void)nd6_prefix_offlink(pr);
1056 			ND6_ONLINK_UNLOCK();
1057 			ND6_WLOCK();
1058 			nd6_prefix_rele(pr);
1059 			if (genid != V_nd6_list_genid)
1060 				goto restart;
1061 		}
1062 	}
1063 	ND6_WUNLOCK();
1064 
1065 	while ((pr = LIST_FIRST(&prl)) != NULL) {
1066 		LIST_REMOVE(pr, ndpr_entry);
1067 		nd6_prefix_del(pr);
1068 	}
1069 
1070 	callout_reset(&V_nd6_timer_ch, V_nd6_prune * hz,
1071 	    nd6_timer, curvnet);
1072 
1073 	CURVNET_RESTORE();
1074 }
1075 
1076 /*
1077  * ia6 - deprecated/invalidated temporary address
1078  */
1079 static int
1080 regen_tmpaddr(struct in6_ifaddr *ia6)
1081 {
1082 	struct ifaddr *ifa;
1083 	struct ifnet *ifp;
1084 	struct in6_ifaddr *public_ifa6 = NULL;
1085 
1086 	NET_EPOCH_ASSERT();
1087 
1088 	ifp = ia6->ia_ifa.ifa_ifp;
1089 	CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1090 		struct in6_ifaddr *it6;
1091 
1092 		if (ifa->ifa_addr->sa_family != AF_INET6)
1093 			continue;
1094 
1095 		it6 = (struct in6_ifaddr *)ifa;
1096 
1097 		/* ignore no autoconf addresses. */
1098 		if ((it6->ia6_flags & IN6_IFF_AUTOCONF) == 0)
1099 			continue;
1100 
1101 		/* ignore autoconf addresses with different prefixes. */
1102 		if (it6->ia6_ndpr == NULL || it6->ia6_ndpr != ia6->ia6_ndpr)
1103 			continue;
1104 
1105 		/*
1106 		 * Now we are looking at an autoconf address with the same
1107 		 * prefix as ours.  If the address is temporary and is still
1108 		 * preferred, do not create another one.  It would be rare, but
1109 		 * could happen, for example, when we resume a laptop PC after
1110 		 * a long period.
1111 		 */
1112 		if ((it6->ia6_flags & IN6_IFF_TEMPORARY) != 0 &&
1113 		    !IFA6_IS_DEPRECATED(it6)) {
1114 			public_ifa6 = NULL;
1115 			break;
1116 		}
1117 
1118 		/*
1119 		 * This is a public autoconf address that has the same prefix
1120 		 * as ours.  If it is preferred, keep it.  We can't break the
1121 		 * loop here, because there may be a still-preferred temporary
1122 		 * address with the prefix.
1123 		 */
1124 		if (!IFA6_IS_DEPRECATED(it6))
1125 			public_ifa6 = it6;
1126 	}
1127 	if (public_ifa6 != NULL)
1128 		ifa_ref(&public_ifa6->ia_ifa);
1129 
1130 	if (public_ifa6 != NULL) {
1131 		int e;
1132 
1133 		if ((e = in6_tmpifadd(public_ifa6, 0, 0)) != 0) {
1134 			ifa_free(&public_ifa6->ia_ifa);
1135 			log(LOG_NOTICE, "regen_tmpaddr: failed to create a new"
1136 			    " tmp addr,errno=%d\n", e);
1137 			return (-1);
1138 		}
1139 		ifa_free(&public_ifa6->ia_ifa);
1140 		return (0);
1141 	}
1142 
1143 	return (-1);
1144 }
1145 
1146 /*
1147  * Remove prefix and default router list entries corresponding to ifp. Neighbor
1148  * cache entries are freed in in6_domifdetach().
1149  */
1150 void
1151 nd6_purge(struct ifnet *ifp)
1152 {
1153 	struct nd_prhead prl;
1154 	struct nd_prefix *pr, *npr;
1155 
1156 	LIST_INIT(&prl);
1157 
1158 	/* Purge default router list entries toward ifp. */
1159 	nd6_defrouter_purge(ifp);
1160 
1161 	ND6_WLOCK();
1162 	/*
1163 	 * Remove prefixes on ifp. We should have already removed addresses on
1164 	 * this interface, so no addresses should be referencing these prefixes.
1165 	 */
1166 	LIST_FOREACH_SAFE(pr, &V_nd_prefix, ndpr_entry, npr) {
1167 		if (pr->ndpr_ifp == ifp)
1168 			nd6_prefix_unlink(pr, &prl);
1169 	}
1170 	ND6_WUNLOCK();
1171 
1172 	/* Delete the unlinked prefix objects. */
1173 	while ((pr = LIST_FIRST(&prl)) != NULL) {
1174 		LIST_REMOVE(pr, ndpr_entry);
1175 		nd6_prefix_del(pr);
1176 	}
1177 
1178 	/* cancel default outgoing interface setting */
1179 	if (V_nd6_defifindex == ifp->if_index)
1180 		nd6_setdefaultiface(0);
1181 
1182 	if (ND_IFINFO(ifp)->flags & ND6_IFF_ACCEPT_RTADV) {
1183 		/* Refresh default router list. */
1184 		defrouter_select_fib(ifp->if_fib);
1185 	}
1186 }
1187 
1188 /*
1189  * the caller acquires and releases the lock on the lltbls
1190  * Returns the llentry locked
1191  */
1192 struct llentry *
1193 nd6_lookup(const struct in6_addr *addr6, int flags, struct ifnet *ifp)
1194 {
1195 	struct sockaddr_in6 sin6;
1196 	struct llentry *ln;
1197 
1198 	bzero(&sin6, sizeof(sin6));
1199 	sin6.sin6_len = sizeof(struct sockaddr_in6);
1200 	sin6.sin6_family = AF_INET6;
1201 	sin6.sin6_addr = *addr6;
1202 
1203 	IF_AFDATA_LOCK_ASSERT(ifp);
1204 
1205 	ln = lla_lookup(LLTABLE6(ifp), flags, (struct sockaddr *)&sin6);
1206 
1207 	return (ln);
1208 }
1209 
1210 static struct llentry *
1211 nd6_alloc(const struct in6_addr *addr6, int flags, struct ifnet *ifp)
1212 {
1213 	struct sockaddr_in6 sin6;
1214 	struct llentry *ln;
1215 
1216 	bzero(&sin6, sizeof(sin6));
1217 	sin6.sin6_len = sizeof(struct sockaddr_in6);
1218 	sin6.sin6_family = AF_INET6;
1219 	sin6.sin6_addr = *addr6;
1220 
1221 	ln = lltable_alloc_entry(LLTABLE6(ifp), 0, (struct sockaddr *)&sin6);
1222 	if (ln != NULL)
1223 		ln->ln_state = ND6_LLINFO_NOSTATE;
1224 
1225 	return (ln);
1226 }
1227 
1228 /*
1229  * Test whether a given IPv6 address can be a neighbor.
1230  */
1231 static bool
1232 nd6_is_new_addr_neighbor(const struct sockaddr_in6 *addr, struct ifnet *ifp)
1233 {
1234 
1235 	/*
1236 	 * A link-local address is always a neighbor.
1237 	 * XXX: a link does not necessarily specify a single interface.
1238 	 */
1239 	if (IN6_IS_ADDR_LINKLOCAL(&addr->sin6_addr)) {
1240 		struct sockaddr_in6 sin6_copy;
1241 		u_int32_t zone;
1242 
1243 		/*
1244 		 * We need sin6_copy since sa6_recoverscope() may modify the
1245 		 * content (XXX).
1246 		 */
1247 		sin6_copy = *addr;
1248 		if (sa6_recoverscope(&sin6_copy))
1249 			return (0); /* XXX: should be impossible */
1250 		if (in6_setscope(&sin6_copy.sin6_addr, ifp, &zone))
1251 			return (0);
1252 		if (sin6_copy.sin6_scope_id == zone)
1253 			return (1);
1254 		else
1255 			return (0);
1256 	}
1257 	/* Checking global unicast */
1258 
1259 	/* If an address is directly reachable, it is a neigbor */
1260 	struct nhop_object *nh;
1261 	nh = fib6_lookup(ifp->if_fib, &addr->sin6_addr, 0, NHR_NONE, 0);
1262 	if (nh != NULL && nh->nh_aifp == ifp && (nh->nh_flags & NHF_GATEWAY) == 0)
1263 		return (true);
1264 
1265 	/*
1266 	 * Check prefixes with desired on-link state, as some may be not
1267 	 * installed in the routing table.
1268 	 */
1269 	bool matched = false;
1270 	struct nd_prefix *pr;
1271 	ND6_RLOCK();
1272 	LIST_FOREACH(pr, &V_nd_prefix, ndpr_entry) {
1273 		if (pr->ndpr_ifp != ifp)
1274 			continue;
1275 		if ((pr->ndpr_stateflags & NDPRF_ONLINK) == 0)
1276 			continue;
1277 		if (IN6_ARE_MASKED_ADDR_EQUAL(&pr->ndpr_prefix.sin6_addr,
1278 		    &addr->sin6_addr, &pr->ndpr_mask)) {
1279 			matched = true;
1280 			break;
1281 		}
1282 	}
1283 	ND6_RUNLOCK();
1284 	if (matched)
1285 		return (true);
1286 
1287 	/*
1288 	 * If the address is assigned on the node of the other side of
1289 	 * a p2p interface, the address should be a neighbor.
1290 	 */
1291 	if (ifp->if_flags & IFF_POINTOPOINT) {
1292 		struct ifaddr *ifa;
1293 
1294 		CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1295 			if (ifa->ifa_addr->sa_family != addr->sin6_family)
1296 				continue;
1297 			if (ifa->ifa_dstaddr != NULL &&
1298 			    sa_equal(addr, ifa->ifa_dstaddr)) {
1299 				return (true);
1300 			}
1301 		}
1302 	}
1303 
1304 	/*
1305 	 * If the default router list is empty, all addresses are regarded
1306 	 * as on-link, and thus, as a neighbor.
1307 	 */
1308 	if (ND_IFINFO(ifp)->flags & ND6_IFF_ACCEPT_RTADV &&
1309 	    nd6_defrouter_list_empty() &&
1310 	    V_nd6_defifindex == ifp->if_index) {
1311 		return (1);
1312 	}
1313 
1314 	return (0);
1315 }
1316 
1317 /*
1318  * Detect if a given IPv6 address identifies a neighbor on a given link.
1319  * XXX: should take care of the destination of a p2p link?
1320  */
1321 int
1322 nd6_is_addr_neighbor(const struct sockaddr_in6 *addr, struct ifnet *ifp)
1323 {
1324 	struct llentry *lle;
1325 	int rc = 0;
1326 
1327 	NET_EPOCH_ASSERT();
1328 	IF_AFDATA_UNLOCK_ASSERT(ifp);
1329 	if (nd6_is_new_addr_neighbor(addr, ifp))
1330 		return (1);
1331 
1332 	/*
1333 	 * Even if the address matches none of our addresses, it might be
1334 	 * in the neighbor cache.
1335 	 */
1336 	if ((lle = nd6_lookup(&addr->sin6_addr, LLE_SF(AF_INET6, 0), ifp)) != NULL) {
1337 		LLE_RUNLOCK(lle);
1338 		rc = 1;
1339 	}
1340 	return (rc);
1341 }
1342 
1343 static __noinline void
1344 nd6_free_children(struct llentry *lle)
1345 {
1346 	struct llentry *child_lle;
1347 
1348 	NET_EPOCH_ASSERT();
1349 	LLE_WLOCK_ASSERT(lle);
1350 
1351 	while ((child_lle = CK_SLIST_FIRST(&lle->lle_children)) != NULL) {
1352 		LLE_WLOCK(child_lle);
1353 		lltable_unlink_child_entry(child_lle);
1354 		llentry_free(child_lle);
1355 	}
1356 }
1357 
1358 /*
1359  * Tries to update @lle address/prepend data with new @lladdr.
1360  *
1361  * Returns true on success.
1362  * In any case, @lle is returned wlocked.
1363  */
1364 static __noinline bool
1365 nd6_try_set_entry_addr_locked(struct ifnet *ifp, struct llentry *lle, char *lladdr)
1366 {
1367 	u_char buf[LLE_MAX_LINKHDR];
1368 	int fam, off;
1369 	size_t sz;
1370 
1371 	sz = sizeof(buf);
1372 	if (lltable_calc_llheader(ifp, AF_INET6, lladdr, buf, &sz, &off) != 0)
1373 		return (false);
1374 
1375 	/* Update data */
1376 	lltable_set_entry_addr(ifp, lle, buf, sz, off);
1377 
1378 	struct llentry *child_lle;
1379 	CK_SLIST_FOREACH(child_lle, &lle->lle_children, lle_child_next) {
1380 		LLE_WLOCK(child_lle);
1381 		fam = child_lle->r_family;
1382 		sz = sizeof(buf);
1383 		if (lltable_calc_llheader(ifp, fam, lladdr, buf, &sz, &off) == 0) {
1384 			/* success */
1385 			lltable_set_entry_addr(ifp, child_lle, buf, sz, off);
1386 			child_lle->ln_state = ND6_LLINFO_REACHABLE;
1387 		}
1388 		LLE_WUNLOCK(child_lle);
1389 	}
1390 
1391 	return (true);
1392 }
1393 
1394 bool
1395 nd6_try_set_entry_addr(struct ifnet *ifp, struct llentry *lle, char *lladdr)
1396 {
1397 	NET_EPOCH_ASSERT();
1398 	LLE_WLOCK_ASSERT(lle);
1399 
1400 	if (!lltable_acquire_wlock(ifp, lle))
1401 		return (false);
1402 	bool ret = nd6_try_set_entry_addr_locked(ifp, lle, lladdr);
1403 	IF_AFDATA_WUNLOCK(ifp);
1404 
1405 	return (ret);
1406 }
1407 
1408 /*
1409  * Free an nd6 llinfo entry.
1410  * Since the function would cause significant changes in the kernel, DO NOT
1411  * make it global, unless you have a strong reason for the change, and are sure
1412  * that the change is safe.
1413  *
1414  * Set noinline to be dtrace-friendly
1415  */
1416 static __noinline void
1417 nd6_free(struct llentry **lnp, int gc)
1418 {
1419 	struct ifnet *ifp;
1420 	struct llentry *ln;
1421 	struct nd_defrouter *dr;
1422 
1423 	ln = *lnp;
1424 	*lnp = NULL;
1425 
1426 	LLE_WLOCK_ASSERT(ln);
1427 	ND6_RLOCK_ASSERT();
1428 
1429 	KASSERT((ln->la_flags & LLE_CHILD) == 0, ("child lle"));
1430 
1431 	ifp = lltable_get_ifp(ln->lle_tbl);
1432 	if ((ND_IFINFO(ifp)->flags & ND6_IFF_ACCEPT_RTADV) != 0)
1433 		dr = defrouter_lookup_locked(&ln->r_l3addr.addr6, ifp);
1434 	else
1435 		dr = NULL;
1436 	ND6_RUNLOCK();
1437 
1438 	if ((ln->la_flags & LLE_DELETED) == 0)
1439 		EVENTHANDLER_INVOKE(lle_event, ln, LLENTRY_EXPIRED);
1440 
1441 	/*
1442 	 * we used to have pfctlinput(PRC_HOSTDEAD) here.
1443 	 * even though it is not harmful, it was not really necessary.
1444 	 */
1445 
1446 	/* cancel timer */
1447 	nd6_llinfo_settimer_locked(ln, -1);
1448 
1449 	if (ND_IFINFO(ifp)->flags & ND6_IFF_ACCEPT_RTADV) {
1450 		if (dr != NULL && dr->expire &&
1451 		    ln->ln_state == ND6_LLINFO_STALE && gc) {
1452 			/*
1453 			 * If the reason for the deletion is just garbage
1454 			 * collection, and the neighbor is an active default
1455 			 * router, do not delete it.  Instead, reset the GC
1456 			 * timer using the router's lifetime.
1457 			 * Simply deleting the entry would affect default
1458 			 * router selection, which is not necessarily a good
1459 			 * thing, especially when we're using router preference
1460 			 * values.
1461 			 * XXX: the check for ln_state would be redundant,
1462 			 *      but we intentionally keep it just in case.
1463 			 */
1464 			if (dr->expire > time_uptime)
1465 				nd6_llinfo_settimer_locked(ln,
1466 				    (dr->expire - time_uptime) * hz);
1467 			else
1468 				nd6_llinfo_settimer_locked(ln,
1469 				    (long)V_nd6_gctimer * hz);
1470 
1471 			LLE_REMREF(ln);
1472 			LLE_WUNLOCK(ln);
1473 			defrouter_rele(dr);
1474 			return;
1475 		}
1476 
1477 		if (dr) {
1478 			/*
1479 			 * Unreachability of a router might affect the default
1480 			 * router selection and on-link detection of advertised
1481 			 * prefixes.
1482 			 */
1483 
1484 			/*
1485 			 * Temporarily fake the state to choose a new default
1486 			 * router and to perform on-link determination of
1487 			 * prefixes correctly.
1488 			 * Below the state will be set correctly,
1489 			 * or the entry itself will be deleted.
1490 			 */
1491 			ln->ln_state = ND6_LLINFO_INCOMPLETE;
1492 		}
1493 
1494 		if (ln->ln_router || dr) {
1495 			/*
1496 			 * We need to unlock to avoid a LOR with rt6_flush() with the
1497 			 * rnh and for the calls to pfxlist_onlink_check() and
1498 			 * defrouter_select_fib() in the block further down for calls
1499 			 * into nd6_lookup().  We still hold a ref.
1500 			 */
1501 			LLE_WUNLOCK(ln);
1502 
1503 			/*
1504 			 * rt6_flush must be called whether or not the neighbor
1505 			 * is in the Default Router List.
1506 			 * See a corresponding comment in nd6_na_input().
1507 			 */
1508 			rt6_flush(&ln->r_l3addr.addr6, ifp);
1509 		}
1510 
1511 		if (dr) {
1512 			/*
1513 			 * Since defrouter_select_fib() does not affect the
1514 			 * on-link determination and MIP6 needs the check
1515 			 * before the default router selection, we perform
1516 			 * the check now.
1517 			 */
1518 			pfxlist_onlink_check();
1519 
1520 			/*
1521 			 * Refresh default router list.
1522 			 */
1523 			defrouter_select_fib(dr->ifp->if_fib);
1524 		}
1525 
1526 		/*
1527 		 * If this entry was added by an on-link redirect, remove the
1528 		 * corresponding host route.
1529 		 */
1530 		if (ln->la_flags & LLE_REDIRECT)
1531 			nd6_free_redirect(ln);
1532 
1533 		if (ln->ln_router || dr)
1534 			LLE_WLOCK(ln);
1535 	}
1536 
1537 	/*
1538 	 * Save to unlock. We still hold an extra reference and will not
1539 	 * free(9) in llentry_free() if someone else holds one as well.
1540 	 */
1541 	LLE_WUNLOCK(ln);
1542 	IF_AFDATA_LOCK(ifp);
1543 	LLE_WLOCK(ln);
1544 	/* Guard against race with other llentry_free(). */
1545 	if (ln->la_flags & LLE_LINKED) {
1546 		/* Remove callout reference */
1547 		LLE_REMREF(ln);
1548 		lltable_unlink_entry(ln->lle_tbl, ln);
1549 	}
1550 	IF_AFDATA_UNLOCK(ifp);
1551 
1552 	nd6_free_children(ln);
1553 
1554 	llentry_free(ln);
1555 	if (dr != NULL)
1556 		defrouter_rele(dr);
1557 }
1558 
1559 static int
1560 nd6_isdynrte(const struct rtentry *rt, const struct nhop_object *nh, void *xap)
1561 {
1562 
1563 	if (nh->nh_flags & NHF_REDIRECT)
1564 		return (1);
1565 
1566 	return (0);
1567 }
1568 
1569 /*
1570  * Remove the rtentry for the given llentry,
1571  * both of which were installed by a redirect.
1572  */
1573 static void
1574 nd6_free_redirect(const struct llentry *ln)
1575 {
1576 	int fibnum;
1577 	struct sockaddr_in6 sin6;
1578 	struct rib_cmd_info rc;
1579 	struct epoch_tracker et;
1580 
1581 	lltable_fill_sa_entry(ln, (struct sockaddr *)&sin6);
1582 
1583 	NET_EPOCH_ENTER(et);
1584 	for (fibnum = 0; fibnum < rt_numfibs; fibnum++)
1585 		rib_del_route_px(fibnum, (struct sockaddr *)&sin6, 128,
1586 		    nd6_isdynrte, NULL, 0, &rc);
1587 	NET_EPOCH_EXIT(et);
1588 }
1589 
1590 /*
1591  * Updates status of the default router route.
1592  */
1593 static void
1594 check_release_defrouter(const struct rib_cmd_info *rc, void *_cbdata)
1595 {
1596 	struct nd_defrouter *dr;
1597 	struct nhop_object *nh;
1598 
1599 	nh = rc->rc_nh_old;
1600 
1601 	if ((nh != NULL) && (nh->nh_flags & NHF_DEFAULT)) {
1602 		dr = defrouter_lookup(&nh->gw6_sa.sin6_addr, nh->nh_ifp);
1603 		if (dr != NULL) {
1604 			dr->installed = 0;
1605 			defrouter_rele(dr);
1606 		}
1607 	}
1608 }
1609 
1610 void
1611 nd6_subscription_cb(struct rib_head *rnh, struct rib_cmd_info *rc, void *arg)
1612 {
1613 
1614 #ifdef ROUTE_MPATH
1615 	rib_decompose_notification(rc, check_release_defrouter, NULL);
1616 #else
1617 	check_release_defrouter(rc, NULL);
1618 #endif
1619 }
1620 
1621 int
1622 nd6_ioctl(u_long cmd, caddr_t data, struct ifnet *ifp)
1623 {
1624 	struct in6_ndireq *ndi = (struct in6_ndireq *)data;
1625 	struct in6_nbrinfo *nbi = (struct in6_nbrinfo *)data;
1626 	struct in6_ndifreq *ndif = (struct in6_ndifreq *)data;
1627 	struct epoch_tracker et;
1628 	int error = 0;
1629 
1630 	if (ifp->if_afdata[AF_INET6] == NULL)
1631 		return (EPFNOSUPPORT);
1632 	switch (cmd) {
1633 	case OSIOCGIFINFO_IN6:
1634 #define ND	ndi->ndi
1635 		/* XXX: old ndp(8) assumes a positive value for linkmtu. */
1636 		bzero(&ND, sizeof(ND));
1637 		ND.linkmtu = IN6_LINKMTU(ifp);
1638 		ND.maxmtu = ND_IFINFO(ifp)->maxmtu;
1639 		ND.basereachable = ND_IFINFO(ifp)->basereachable;
1640 		ND.reachable = ND_IFINFO(ifp)->reachable;
1641 		ND.retrans = ND_IFINFO(ifp)->retrans;
1642 		ND.flags = ND_IFINFO(ifp)->flags;
1643 		ND.recalctm = ND_IFINFO(ifp)->recalctm;
1644 		ND.chlim = ND_IFINFO(ifp)->chlim;
1645 		break;
1646 	case SIOCGIFINFO_IN6:
1647 		ND = *ND_IFINFO(ifp);
1648 		break;
1649 	case SIOCSIFINFO_IN6:
1650 		/*
1651 		 * used to change host variables from userland.
1652 		 * intended for a use on router to reflect RA configurations.
1653 		 */
1654 		/* 0 means 'unspecified' */
1655 		if (ND.linkmtu != 0) {
1656 			if (ND.linkmtu < IPV6_MMTU ||
1657 			    ND.linkmtu > IN6_LINKMTU(ifp)) {
1658 				error = EINVAL;
1659 				break;
1660 			}
1661 			ND_IFINFO(ifp)->linkmtu = ND.linkmtu;
1662 		}
1663 
1664 		if (ND.basereachable != 0) {
1665 			int obasereachable = ND_IFINFO(ifp)->basereachable;
1666 
1667 			ND_IFINFO(ifp)->basereachable = ND.basereachable;
1668 			if (ND.basereachable != obasereachable)
1669 				ND_IFINFO(ifp)->reachable =
1670 				    ND_COMPUTE_RTIME(ND.basereachable);
1671 		}
1672 		if (ND.retrans != 0)
1673 			ND_IFINFO(ifp)->retrans = ND.retrans;
1674 		if (ND.chlim != 0)
1675 			ND_IFINFO(ifp)->chlim = ND.chlim;
1676 		/* FALLTHROUGH */
1677 	case SIOCSIFINFO_FLAGS:
1678 	{
1679 		struct ifaddr *ifa;
1680 		struct in6_ifaddr *ia;
1681 
1682 		if ((ND_IFINFO(ifp)->flags & ND6_IFF_IFDISABLED) &&
1683 		    !(ND.flags & ND6_IFF_IFDISABLED)) {
1684 			/* ifdisabled 1->0 transision */
1685 
1686 			/*
1687 			 * If the interface is marked as ND6_IFF_IFDISABLED and
1688 			 * has an link-local address with IN6_IFF_DUPLICATED,
1689 			 * do not clear ND6_IFF_IFDISABLED.
1690 			 * See RFC 4862, Section 5.4.5.
1691 			 */
1692 			NET_EPOCH_ENTER(et);
1693 			CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1694 				if (ifa->ifa_addr->sa_family != AF_INET6)
1695 					continue;
1696 				ia = (struct in6_ifaddr *)ifa;
1697 				if ((ia->ia6_flags & IN6_IFF_DUPLICATED) &&
1698 				    IN6_IS_ADDR_LINKLOCAL(IA6_IN6(ia)))
1699 					break;
1700 			}
1701 			NET_EPOCH_EXIT(et);
1702 
1703 			if (ifa != NULL) {
1704 				/* LLA is duplicated. */
1705 				ND.flags |= ND6_IFF_IFDISABLED;
1706 				log(LOG_ERR, "Cannot enable an interface"
1707 				    " with a link-local address marked"
1708 				    " duplicate.\n");
1709 			} else {
1710 				ND_IFINFO(ifp)->flags &= ~ND6_IFF_IFDISABLED;
1711 				if (ifp->if_flags & IFF_UP)
1712 					in6_if_up(ifp);
1713 			}
1714 		} else if (!(ND_IFINFO(ifp)->flags & ND6_IFF_IFDISABLED) &&
1715 			    (ND.flags & ND6_IFF_IFDISABLED)) {
1716 			/* ifdisabled 0->1 transision */
1717 			/* Mark all IPv6 address as tentative. */
1718 
1719 			ND_IFINFO(ifp)->flags |= ND6_IFF_IFDISABLED;
1720 			if (V_ip6_dad_count > 0 &&
1721 			    (ND_IFINFO(ifp)->flags & ND6_IFF_NO_DAD) == 0) {
1722 				NET_EPOCH_ENTER(et);
1723 				CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead,
1724 				    ifa_link) {
1725 					if (ifa->ifa_addr->sa_family !=
1726 					    AF_INET6)
1727 						continue;
1728 					ia = (struct in6_ifaddr *)ifa;
1729 					ia->ia6_flags |= IN6_IFF_TENTATIVE;
1730 				}
1731 				NET_EPOCH_EXIT(et);
1732 			}
1733 		}
1734 
1735 		if (ND.flags & ND6_IFF_AUTO_LINKLOCAL) {
1736 			if (!(ND_IFINFO(ifp)->flags & ND6_IFF_AUTO_LINKLOCAL)) {
1737 				/* auto_linklocal 0->1 transision */
1738 
1739 				/* If no link-local address on ifp, configure */
1740 				ND_IFINFO(ifp)->flags |= ND6_IFF_AUTO_LINKLOCAL;
1741 				in6_ifattach(ifp, NULL);
1742 			} else if (!(ND.flags & ND6_IFF_IFDISABLED) &&
1743 			    ifp->if_flags & IFF_UP) {
1744 				/*
1745 				 * When the IF already has
1746 				 * ND6_IFF_AUTO_LINKLOCAL, no link-local
1747 				 * address is assigned, and IFF_UP, try to
1748 				 * assign one.
1749 				 */
1750 				NET_EPOCH_ENTER(et);
1751 				CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead,
1752 				    ifa_link) {
1753 					if (ifa->ifa_addr->sa_family !=
1754 					    AF_INET6)
1755 						continue;
1756 					ia = (struct in6_ifaddr *)ifa;
1757 					if (IN6_IS_ADDR_LINKLOCAL(IA6_IN6(ia)))
1758 						break;
1759 				}
1760 				NET_EPOCH_EXIT(et);
1761 				if (ifa != NULL)
1762 					/* No LLA is configured. */
1763 					in6_ifattach(ifp, NULL);
1764 			}
1765 		}
1766 		ND_IFINFO(ifp)->flags = ND.flags;
1767 		break;
1768 	}
1769 #undef ND
1770 	case SIOCSNDFLUSH_IN6:	/* XXX: the ioctl name is confusing... */
1771 		/* sync kernel routing table with the default router list */
1772 		defrouter_reset();
1773 		defrouter_select_fib(RT_ALL_FIBS);
1774 		break;
1775 	case SIOCSPFXFLUSH_IN6:
1776 	{
1777 		/* flush all the prefix advertised by routers */
1778 		struct in6_ifaddr *ia, *ia_next;
1779 		struct nd_prefix *pr, *next;
1780 		struct nd_prhead prl;
1781 
1782 		LIST_INIT(&prl);
1783 
1784 		ND6_WLOCK();
1785 		LIST_FOREACH_SAFE(pr, &V_nd_prefix, ndpr_entry, next) {
1786 			if (pr->ndpr_raf_ra_derived)
1787 				nd6_prefix_unlink(pr, &prl);
1788 		}
1789 		ND6_WUNLOCK();
1790 
1791 		while ((pr = LIST_FIRST(&prl)) != NULL) {
1792 			LIST_REMOVE(pr, ndpr_entry);
1793 			/* XXXRW: in6_ifaddrhead locking. */
1794 			CK_STAILQ_FOREACH_SAFE(ia, &V_in6_ifaddrhead, ia_link,
1795 			    ia_next) {
1796 				if ((ia->ia6_flags & IN6_IFF_AUTOCONF) == 0)
1797 					continue;
1798 
1799 				if (ia->ia6_ndpr == pr)
1800 					in6_purgeaddr(&ia->ia_ifa);
1801 			}
1802 			nd6_prefix_del(pr);
1803 		}
1804 		break;
1805 	}
1806 	case SIOCSRTRFLUSH_IN6:
1807 	{
1808 		/* flush all the default routers */
1809 
1810 		defrouter_reset();
1811 		nd6_defrouter_flush_all();
1812 		defrouter_select_fib(RT_ALL_FIBS);
1813 		break;
1814 	}
1815 	case SIOCGNBRINFO_IN6:
1816 	{
1817 		struct llentry *ln;
1818 		struct in6_addr nb_addr = nbi->addr; /* make local for safety */
1819 
1820 		if ((error = in6_setscope(&nb_addr, ifp, NULL)) != 0)
1821 			return (error);
1822 
1823 		NET_EPOCH_ENTER(et);
1824 		ln = nd6_lookup(&nb_addr, LLE_SF(AF_INET6, 0), ifp);
1825 		NET_EPOCH_EXIT(et);
1826 
1827 		if (ln == NULL) {
1828 			error = EINVAL;
1829 			break;
1830 		}
1831 		nbi->state = ln->ln_state;
1832 		nbi->asked = ln->la_asked;
1833 		nbi->isrouter = ln->ln_router;
1834 		if (ln->la_expire == 0)
1835 			nbi->expire = 0;
1836 		else
1837 			nbi->expire = ln->la_expire + ln->lle_remtime / hz +
1838 			    (time_second - time_uptime);
1839 		LLE_RUNLOCK(ln);
1840 		break;
1841 	}
1842 	case SIOCGDEFIFACE_IN6:	/* XXX: should be implemented as a sysctl? */
1843 		ndif->ifindex = V_nd6_defifindex;
1844 		break;
1845 	case SIOCSDEFIFACE_IN6:	/* XXX: should be implemented as a sysctl? */
1846 		return (nd6_setdefaultiface(ndif->ifindex));
1847 	}
1848 	return (error);
1849 }
1850 
1851 /*
1852  * Calculates new isRouter value based on provided parameters and
1853  * returns it.
1854  */
1855 static int
1856 nd6_is_router(int type, int code, int is_new, int old_addr, int new_addr,
1857     int ln_router)
1858 {
1859 
1860 	/*
1861 	 * ICMP6 type dependent behavior.
1862 	 *
1863 	 * NS: clear IsRouter if new entry
1864 	 * RS: clear IsRouter
1865 	 * RA: set IsRouter if there's lladdr
1866 	 * redir: clear IsRouter if new entry
1867 	 *
1868 	 * RA case, (1):
1869 	 * The spec says that we must set IsRouter in the following cases:
1870 	 * - If lladdr exist, set IsRouter.  This means (1-5).
1871 	 * - If it is old entry (!newentry), set IsRouter.  This means (7).
1872 	 * So, based on the spec, in (1-5) and (7) cases we must set IsRouter.
1873 	 * A quetion arises for (1) case.  (1) case has no lladdr in the
1874 	 * neighbor cache, this is similar to (6).
1875 	 * This case is rare but we figured that we MUST NOT set IsRouter.
1876 	 *
1877 	 *   is_new  old_addr new_addr 	    NS  RS  RA	redir
1878 	 *							D R
1879 	 *	0	n	n	(1)	c   ?     s
1880 	 *	0	y	n	(2)	c   s     s
1881 	 *	0	n	y	(3)	c   s     s
1882 	 *	0	y	y	(4)	c   s     s
1883 	 *	0	y	y	(5)	c   s     s
1884 	 *	1	--	n	(6) c	c	c s
1885 	 *	1	--	y	(7) c	c   s	c s
1886 	 *
1887 	 *					(c=clear s=set)
1888 	 */
1889 	switch (type & 0xff) {
1890 	case ND_NEIGHBOR_SOLICIT:
1891 		/*
1892 		 * New entry must have is_router flag cleared.
1893 		 */
1894 		if (is_new)					/* (6-7) */
1895 			ln_router = 0;
1896 		break;
1897 	case ND_REDIRECT:
1898 		/*
1899 		 * If the icmp is a redirect to a better router, always set the
1900 		 * is_router flag.  Otherwise, if the entry is newly created,
1901 		 * clear the flag.  [RFC 2461, sec 8.3]
1902 		 */
1903 		if (code == ND_REDIRECT_ROUTER)
1904 			ln_router = 1;
1905 		else {
1906 			if (is_new)				/* (6-7) */
1907 				ln_router = 0;
1908 		}
1909 		break;
1910 	case ND_ROUTER_SOLICIT:
1911 		/*
1912 		 * is_router flag must always be cleared.
1913 		 */
1914 		ln_router = 0;
1915 		break;
1916 	case ND_ROUTER_ADVERT:
1917 		/*
1918 		 * Mark an entry with lladdr as a router.
1919 		 */
1920 		if ((!is_new && (old_addr || new_addr)) ||	/* (2-5) */
1921 		    (is_new && new_addr)) {			/* (7) */
1922 			ln_router = 1;
1923 		}
1924 		break;
1925 	}
1926 
1927 	return (ln_router);
1928 }
1929 
1930 /*
1931  * Create neighbor cache entry and cache link-layer address,
1932  * on reception of inbound ND6 packets.  (RS/RA/NS/redirect)
1933  *
1934  * type - ICMP6 type
1935  * code - type dependent information
1936  *
1937  */
1938 void
1939 nd6_cache_lladdr(struct ifnet *ifp, struct in6_addr *from, char *lladdr,
1940     int lladdrlen, int type, int code)
1941 {
1942 	struct llentry *ln = NULL, *ln_tmp;
1943 	int is_newentry;
1944 	int do_update;
1945 	int olladdr;
1946 	int llchange;
1947 	int flags;
1948 	uint16_t router = 0;
1949 	struct mbuf *chain = NULL;
1950 	u_char linkhdr[LLE_MAX_LINKHDR];
1951 	size_t linkhdrsize;
1952 	int lladdr_off;
1953 
1954 	NET_EPOCH_ASSERT();
1955 	IF_AFDATA_UNLOCK_ASSERT(ifp);
1956 
1957 	KASSERT(ifp != NULL, ("%s: ifp == NULL", __func__));
1958 	KASSERT(from != NULL, ("%s: from == NULL", __func__));
1959 
1960 	/* nothing must be updated for unspecified address */
1961 	if (IN6_IS_ADDR_UNSPECIFIED(from))
1962 		return;
1963 
1964 	/*
1965 	 * Validation about ifp->if_addrlen and lladdrlen must be done in
1966 	 * the caller.
1967 	 *
1968 	 * XXX If the link does not have link-layer adderss, what should
1969 	 * we do? (ifp->if_addrlen == 0)
1970 	 * Spec says nothing in sections for RA, RS and NA.  There's small
1971 	 * description on it in NS section (RFC 2461 7.2.3).
1972 	 */
1973 	flags = lladdr ? LLE_EXCLUSIVE : 0;
1974 	ln = nd6_lookup(from, LLE_SF(AF_INET6, flags), ifp);
1975 	is_newentry = 0;
1976 	if (ln == NULL) {
1977 		flags |= LLE_EXCLUSIVE;
1978 		ln = nd6_alloc(from, 0, ifp);
1979 		if (ln == NULL)
1980 			return;
1981 
1982 		/*
1983 		 * Since we already know all the data for the new entry,
1984 		 * fill it before insertion.
1985 		 */
1986 		if (lladdr != NULL) {
1987 			linkhdrsize = sizeof(linkhdr);
1988 			if (lltable_calc_llheader(ifp, AF_INET6, lladdr,
1989 			    linkhdr, &linkhdrsize, &lladdr_off) != 0) {
1990 				lltable_free_entry(LLTABLE6(ifp), ln);
1991 				return;
1992 			}
1993 			lltable_set_entry_addr(ifp, ln, linkhdr, linkhdrsize,
1994 			    lladdr_off);
1995 		}
1996 
1997 		IF_AFDATA_WLOCK(ifp);
1998 		LLE_WLOCK(ln);
1999 		/* Prefer any existing lle over newly-created one */
2000 		ln_tmp = nd6_lookup(from, LLE_SF(AF_INET6, LLE_EXCLUSIVE), ifp);
2001 		if (ln_tmp == NULL)
2002 			lltable_link_entry(LLTABLE6(ifp), ln);
2003 		IF_AFDATA_WUNLOCK(ifp);
2004 		if (ln_tmp == NULL) {
2005 			/* No existing lle, mark as new entry (6,7) */
2006 			is_newentry = 1;
2007 			if (lladdr != NULL) {	/* (7) */
2008 				nd6_llinfo_setstate(ln, ND6_LLINFO_STALE);
2009 				EVENTHANDLER_INVOKE(lle_event, ln,
2010 				    LLENTRY_RESOLVED);
2011 			}
2012 		} else {
2013 			lltable_free_entry(LLTABLE6(ifp), ln);
2014 			ln = ln_tmp;
2015 			ln_tmp = NULL;
2016 		}
2017 	}
2018 	/* do nothing if static ndp is set */
2019 	if ((ln->la_flags & LLE_STATIC)) {
2020 		if (flags & LLE_EXCLUSIVE)
2021 			LLE_WUNLOCK(ln);
2022 		else
2023 			LLE_RUNLOCK(ln);
2024 		return;
2025 	}
2026 
2027 	olladdr = (ln->la_flags & LLE_VALID) ? 1 : 0;
2028 	if (olladdr && lladdr) {
2029 		llchange = bcmp(lladdr, ln->ll_addr,
2030 		    ifp->if_addrlen);
2031 	} else if (!olladdr && lladdr)
2032 		llchange = 1;
2033 	else
2034 		llchange = 0;
2035 
2036 	/*
2037 	 * newentry olladdr  lladdr  llchange	(*=record)
2038 	 *	0	n	n	--	(1)
2039 	 *	0	y	n	--	(2)
2040 	 *	0	n	y	y	(3) * STALE
2041 	 *	0	y	y	n	(4) *
2042 	 *	0	y	y	y	(5) * STALE
2043 	 *	1	--	n	--	(6)   NOSTATE(= PASSIVE)
2044 	 *	1	--	y	--	(7) * STALE
2045 	 */
2046 
2047 	do_update = 0;
2048 	if (is_newentry == 0 && llchange != 0) {
2049 		do_update = 1;	/* (3,5) */
2050 
2051 		/*
2052 		 * Record source link-layer address
2053 		 * XXX is it dependent to ifp->if_type?
2054 		 */
2055 		if (!nd6_try_set_entry_addr(ifp, ln, lladdr)) {
2056 			/* Entry was deleted */
2057 			LLE_WUNLOCK(ln);
2058 			return;
2059 		}
2060 
2061 		nd6_llinfo_setstate(ln, ND6_LLINFO_STALE);
2062 
2063 		EVENTHANDLER_INVOKE(lle_event, ln, LLENTRY_RESOLVED);
2064 
2065 		if (ln->la_hold != NULL)
2066 			chain = nd6_grab_holdchain(ln);
2067 	}
2068 
2069 	/* Calculates new router status */
2070 	router = nd6_is_router(type, code, is_newentry, olladdr,
2071 	    lladdr != NULL ? 1 : 0, ln->ln_router);
2072 
2073 	ln->ln_router = router;
2074 	/* Mark non-router redirects with special flag */
2075 	if ((type & 0xFF) == ND_REDIRECT && code != ND_REDIRECT_ROUTER)
2076 		ln->la_flags |= LLE_REDIRECT;
2077 
2078 	if (flags & LLE_EXCLUSIVE)
2079 		LLE_WUNLOCK(ln);
2080 	else
2081 		LLE_RUNLOCK(ln);
2082 
2083 	if (chain != NULL)
2084 		nd6_flush_holdchain(ifp, ln, chain);
2085 	if (do_update)
2086 		nd6_flush_children_holdchain(ifp, ln);
2087 
2088 	/*
2089 	 * When the link-layer address of a router changes, select the
2090 	 * best router again.  In particular, when the neighbor entry is newly
2091 	 * created, it might affect the selection policy.
2092 	 * Question: can we restrict the first condition to the "is_newentry"
2093 	 * case?
2094 	 * XXX: when we hear an RA from a new router with the link-layer
2095 	 * address option, defrouter_select_fib() is called twice, since
2096 	 * defrtrlist_update called the function as well.  However, I believe
2097 	 * we can compromise the overhead, since it only happens the first
2098 	 * time.
2099 	 * XXX: although defrouter_select_fib() should not have a bad effect
2100 	 * for those are not autoconfigured hosts, we explicitly avoid such
2101 	 * cases for safety.
2102 	 */
2103 	if ((do_update || is_newentry) && router &&
2104 	    ND_IFINFO(ifp)->flags & ND6_IFF_ACCEPT_RTADV) {
2105 		/*
2106 		 * guaranteed recursion
2107 		 */
2108 		defrouter_select_fib(ifp->if_fib);
2109 	}
2110 }
2111 
2112 static void
2113 nd6_slowtimo(void *arg)
2114 {
2115 	struct epoch_tracker et;
2116 	CURVNET_SET((struct vnet *) arg);
2117 	struct nd_ifinfo *nd6if;
2118 	struct ifnet *ifp;
2119 
2120 	callout_reset(&V_nd6_slowtimo_ch, ND6_SLOWTIMER_INTERVAL * hz,
2121 	    nd6_slowtimo, curvnet);
2122 	NET_EPOCH_ENTER(et);
2123 	CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) {
2124 		if (ifp->if_afdata[AF_INET6] == NULL)
2125 			continue;
2126 		nd6if = ND_IFINFO(ifp);
2127 		if (nd6if->basereachable && /* already initialized */
2128 		    (nd6if->recalctm -= ND6_SLOWTIMER_INTERVAL) <= 0) {
2129 			/*
2130 			 * Since reachable time rarely changes by router
2131 			 * advertisements, we SHOULD insure that a new random
2132 			 * value gets recomputed at least once every few hours.
2133 			 * (RFC 2461, 6.3.4)
2134 			 */
2135 			nd6if->recalctm = V_nd6_recalc_reachtm_interval;
2136 			nd6if->reachable = ND_COMPUTE_RTIME(nd6if->basereachable);
2137 		}
2138 	}
2139 	NET_EPOCH_EXIT(et);
2140 	CURVNET_RESTORE();
2141 }
2142 
2143 struct mbuf *
2144 nd6_grab_holdchain(struct llentry *ln)
2145 {
2146 	struct mbuf *chain;
2147 
2148 	LLE_WLOCK_ASSERT(ln);
2149 
2150 	chain = ln->la_hold;
2151 	ln->la_hold = NULL;
2152 	ln->la_numheld = 0;
2153 
2154 	if (ln->ln_state == ND6_LLINFO_STALE) {
2155 		/*
2156 		 * The first time we send a packet to a
2157 		 * neighbor whose entry is STALE, we have
2158 		 * to change the state to DELAY and a sets
2159 		 * a timer to expire in DELAY_FIRST_PROBE_TIME
2160 		 * seconds to ensure do neighbor unreachability
2161 		 * detection on expiration.
2162 		 * (RFC 2461 7.3.3)
2163 		 */
2164 		nd6_llinfo_setstate(ln, ND6_LLINFO_DELAY);
2165 	}
2166 
2167 	return (chain);
2168 }
2169 
2170 int
2171 nd6_output_ifp(struct ifnet *ifp, struct ifnet *origifp, struct mbuf *m,
2172     struct sockaddr_in6 *dst, struct route *ro)
2173 {
2174 	int error;
2175 	int ip6len;
2176 	struct ip6_hdr *ip6;
2177 	struct m_tag *mtag;
2178 
2179 #ifdef MAC
2180 	mac_netinet6_nd6_send(ifp, m);
2181 #endif
2182 
2183 	/*
2184 	 * If called from nd6_ns_output() (NS), nd6_na_output() (NA),
2185 	 * icmp6_redirect_output() (REDIRECT) or from rip6_output() (RS, RA
2186 	 * as handled by rtsol and rtadvd), mbufs will be tagged for SeND
2187 	 * to be diverted to user space.  When re-injected into the kernel,
2188 	 * send_output() will directly dispatch them to the outgoing interface.
2189 	 */
2190 	if (send_sendso_input_hook != NULL) {
2191 		mtag = m_tag_find(m, PACKET_TAG_ND_OUTGOING, NULL);
2192 		if (mtag != NULL) {
2193 			ip6 = mtod(m, struct ip6_hdr *);
2194 			ip6len = sizeof(struct ip6_hdr) + ntohs(ip6->ip6_plen);
2195 			/* Use the SEND socket */
2196 			error = send_sendso_input_hook(m, ifp, SND_OUT,
2197 			    ip6len);
2198 			/* -1 == no app on SEND socket */
2199 			if (error == 0 || error != -1)
2200 			    return (error);
2201 		}
2202 	}
2203 
2204 	m_clrprotoflags(m);	/* Avoid confusing lower layers. */
2205 	IP_PROBE(send, NULL, NULL, mtod(m, struct ip6_hdr *), ifp, NULL,
2206 	    mtod(m, struct ip6_hdr *));
2207 
2208 	if ((ifp->if_flags & IFF_LOOPBACK) == 0)
2209 		origifp = ifp;
2210 
2211 	error = (*ifp->if_output)(origifp, m, (struct sockaddr *)dst, ro);
2212 	return (error);
2213 }
2214 
2215 /*
2216  * Lookup link headerfor @sa_dst address. Stores found
2217  * data in @desten buffer. Copy of lle ln_flags can be also
2218  * saved in @pflags if @pflags is non-NULL.
2219  *
2220  * If destination LLE does not exists or lle state modification
2221  * is required, call "slow" version.
2222  *
2223  * Return values:
2224  * - 0 on success (address copied to buffer).
2225  * - EWOULDBLOCK (no local error, but address is still unresolved)
2226  * - other errors (alloc failure, etc)
2227  */
2228 int
2229 nd6_resolve(struct ifnet *ifp, int gw_flags, struct mbuf *m,
2230     const struct sockaddr *sa_dst, u_char *desten, uint32_t *pflags,
2231     struct llentry **plle)
2232 {
2233 	struct llentry *ln = NULL;
2234 	const struct sockaddr_in6 *dst6;
2235 
2236 	NET_EPOCH_ASSERT();
2237 
2238 	if (pflags != NULL)
2239 		*pflags = 0;
2240 
2241 	dst6 = (const struct sockaddr_in6 *)sa_dst;
2242 
2243 	/* discard the packet if IPv6 operation is disabled on the interface */
2244 	if ((ND_IFINFO(ifp)->flags & ND6_IFF_IFDISABLED)) {
2245 		m_freem(m);
2246 		return (ENETDOWN); /* better error? */
2247 	}
2248 
2249 	if (m != NULL && m->m_flags & M_MCAST) {
2250 		switch (ifp->if_type) {
2251 		case IFT_ETHER:
2252 		case IFT_L2VLAN:
2253 		case IFT_BRIDGE:
2254 			ETHER_MAP_IPV6_MULTICAST(&dst6->sin6_addr,
2255 						 desten);
2256 			return (0);
2257 		default:
2258 			m_freem(m);
2259 			return (EAFNOSUPPORT);
2260 		}
2261 	}
2262 
2263 	int family = gw_flags >> 16;
2264 	int lookup_flags = plle ? LLE_EXCLUSIVE : LLE_UNLOCKED;
2265 	ln = nd6_lookup(&dst6->sin6_addr, LLE_SF(family, lookup_flags), ifp);
2266 	if (ln != NULL && (ln->r_flags & RLLE_VALID) != 0) {
2267 		/* Entry found, let's copy lle info */
2268 		bcopy(ln->r_linkdata, desten, ln->r_hdrlen);
2269 		if (pflags != NULL)
2270 			*pflags = LLE_VALID | (ln->r_flags & RLLE_IFADDR);
2271 		llentry_provide_feedback(ln);
2272 		if (plle) {
2273 			LLE_ADDREF(ln);
2274 			*plle = ln;
2275 			LLE_WUNLOCK(ln);
2276 		}
2277 		return (0);
2278 	} else if (plle && ln)
2279 		LLE_WUNLOCK(ln);
2280 
2281 	return (nd6_resolve_slow(ifp, family, 0, m, dst6, desten, pflags, plle));
2282 }
2283 
2284 /*
2285  * Finds or creates a new llentry for @addr and @family.
2286  * Returns wlocked llentry or NULL.
2287  *
2288  *
2289  * Child LLEs.
2290  *
2291  * Do not have their own state machine (gets marked as static)
2292  *  settimer bails out for child LLEs just in case.
2293  *
2294  * Locking order: parent lle gets locked first, chen goes the child.
2295  */
2296 static __noinline struct llentry *
2297 nd6_get_llentry(struct ifnet *ifp, const struct in6_addr *addr, int family)
2298 {
2299 	struct llentry *child_lle = NULL;
2300 	struct llentry *lle, *lle_tmp;
2301 
2302 	lle = nd6_alloc(addr, 0, ifp);
2303 	if (lle != NULL && family != AF_INET6) {
2304 		child_lle = nd6_alloc(addr, 0, ifp);
2305 		if (child_lle == NULL) {
2306 			lltable_free_entry(LLTABLE6(ifp), lle);
2307 			return (NULL);
2308 		}
2309 		child_lle->r_family = family;
2310 		child_lle->la_flags |= LLE_CHILD | LLE_STATIC;
2311 		child_lle->ln_state = ND6_LLINFO_INCOMPLETE;
2312 	}
2313 
2314 	if (lle == NULL) {
2315 		char ip6buf[INET6_ADDRSTRLEN];
2316 		log(LOG_DEBUG,
2317 		    "nd6_get_llentry: can't allocate llinfo for %s "
2318 		    "(ln=%p)\n",
2319 		    ip6_sprintf(ip6buf, addr), lle);
2320 		return (NULL);
2321 	}
2322 
2323 	IF_AFDATA_WLOCK(ifp);
2324 	LLE_WLOCK(lle);
2325 	/* Prefer any existing entry over newly-created one */
2326 	lle_tmp = nd6_lookup(addr, LLE_SF(AF_INET6, LLE_EXCLUSIVE), ifp);
2327 	if (lle_tmp == NULL)
2328 		lltable_link_entry(LLTABLE6(ifp), lle);
2329 	else {
2330 		lltable_free_entry(LLTABLE6(ifp), lle);
2331 		lle = lle_tmp;
2332 	}
2333 	if (child_lle != NULL) {
2334 		/* Check if child lle for the same family exists */
2335 		lle_tmp = llentry_lookup_family(lle, child_lle->r_family);
2336 		LLE_WLOCK(child_lle);
2337 		if (lle_tmp == NULL) {
2338 			/* Attach */
2339 			lltable_link_child_entry(lle, child_lle);
2340 		} else {
2341 			/* child lle already exists, free newly-created one */
2342 			lltable_free_entry(LLTABLE6(ifp), child_lle);
2343 			child_lle = lle_tmp;
2344 		}
2345 		LLE_WUNLOCK(lle);
2346 		lle = child_lle;
2347 	}
2348 	IF_AFDATA_WUNLOCK(ifp);
2349 	return (lle);
2350 }
2351 
2352 /*
2353  * Do L2 address resolution for @sa_dst address. Stores found
2354  * address in @desten buffer. Copy of lle ln_flags can be also
2355  * saved in @pflags if @pflags is non-NULL.
2356  *
2357  * Heavy version.
2358  * Function assume that destination LLE does not exist,
2359  * is invalid or stale, so LLE_EXCLUSIVE lock needs to be acquired.
2360  *
2361  * Set noinline to be dtrace-friendly
2362  */
2363 static __noinline int
2364 nd6_resolve_slow(struct ifnet *ifp, int family, int flags, struct mbuf *m,
2365     const struct sockaddr_in6 *dst, u_char *desten, uint32_t *pflags,
2366     struct llentry **plle)
2367 {
2368 	struct llentry *lle = NULL;
2369 	struct in6_addr *psrc, src;
2370 	int send_ns, ll_len;
2371 	char *lladdr;
2372 	size_t dropped;
2373 
2374 	NET_EPOCH_ASSERT();
2375 
2376 	/*
2377 	 * Address resolution or Neighbor Unreachability Detection
2378 	 * for the next hop.
2379 	 * At this point, the destination of the packet must be a unicast
2380 	 * or an anycast address(i.e. not a multicast).
2381 	 */
2382 	lle = nd6_lookup(&dst->sin6_addr, LLE_SF(family, LLE_EXCLUSIVE), ifp);
2383 	if ((lle == NULL) && nd6_is_addr_neighbor(dst, ifp))  {
2384 		/*
2385 		 * Since nd6_is_addr_neighbor() internally calls nd6_lookup(),
2386 		 * the condition below is not very efficient.  But we believe
2387 		 * it is tolerable, because this should be a rare case.
2388 		 */
2389 		lle = nd6_get_llentry(ifp, &dst->sin6_addr, family);
2390 	}
2391 
2392 	if (lle == NULL) {
2393 		m_freem(m);
2394 		return (ENOBUFS);
2395 	}
2396 
2397 	LLE_WLOCK_ASSERT(lle);
2398 
2399 	/*
2400 	 * The first time we send a packet to a neighbor whose entry is
2401 	 * STALE, we have to change the state to DELAY and a sets a timer to
2402 	 * expire in DELAY_FIRST_PROBE_TIME seconds to ensure do
2403 	 * neighbor unreachability detection on expiration.
2404 	 * (RFC 2461 7.3.3)
2405 	 */
2406 	if ((!(lle->la_flags & LLE_CHILD)) && (lle->ln_state == ND6_LLINFO_STALE))
2407 		nd6_llinfo_setstate(lle, ND6_LLINFO_DELAY);
2408 
2409 	/*
2410 	 * If the neighbor cache entry has a state other than INCOMPLETE
2411 	 * (i.e. its link-layer address is already resolved), just
2412 	 * send the packet.
2413 	 */
2414 	if (lle->ln_state > ND6_LLINFO_INCOMPLETE) {
2415 		if (flags & LLE_ADDRONLY) {
2416 			lladdr = lle->ll_addr;
2417 			ll_len = ifp->if_addrlen;
2418 		} else {
2419 			lladdr = lle->r_linkdata;
2420 			ll_len = lle->r_hdrlen;
2421 		}
2422 		bcopy(lladdr, desten, ll_len);
2423 		if (pflags != NULL)
2424 			*pflags = lle->la_flags;
2425 		if (plle) {
2426 			LLE_ADDREF(lle);
2427 			*plle = lle;
2428 		}
2429 		LLE_WUNLOCK(lle);
2430 		return (0);
2431 	}
2432 
2433 	/*
2434 	 * There is a neighbor cache entry, but no ethernet address
2435 	 * response yet.  Append this latest packet to the end of the
2436 	 * packet queue in the mbuf.  When it exceeds nd6_maxqueuelen,
2437 	 * the oldest packet in the queue will be removed.
2438 	 */
2439 	dropped = lltable_append_entry_queue(lle, m, V_nd6_maxqueuelen);
2440 	ICMP6STAT_ADD(icp6s_dropped, dropped);
2441 
2442 	/*
2443 	 * If there has been no NS for the neighbor after entering the
2444 	 * INCOMPLETE state, send the first solicitation.
2445 	 * Note that for newly-created lle la_asked will be 0,
2446 	 * so we will transition from ND6_LLINFO_NOSTATE to
2447 	 * ND6_LLINFO_INCOMPLETE state here.
2448 	 */
2449 	psrc = NULL;
2450 	send_ns = 0;
2451 
2452 	/* If we have child lle, switch to the parent to send NS */
2453 	if (lle->la_flags & LLE_CHILD) {
2454 		struct llentry *lle_parent = lle->lle_parent;
2455 		LLE_WUNLOCK(lle);
2456 		lle = lle_parent;
2457 		LLE_WLOCK(lle);
2458 	}
2459 	if (lle->la_asked == 0) {
2460 		lle->la_asked++;
2461 		send_ns = 1;
2462 		psrc = nd6_llinfo_get_holdsrc(lle, &src);
2463 
2464 		nd6_llinfo_setstate(lle, ND6_LLINFO_INCOMPLETE);
2465 	}
2466 	LLE_WUNLOCK(lle);
2467 	if (send_ns != 0)
2468 		nd6_ns_output(ifp, psrc, NULL, &dst->sin6_addr, NULL);
2469 
2470 	return (EWOULDBLOCK);
2471 }
2472 
2473 /*
2474  * Do L2 address resolution for @sa_dst address. Stores found
2475  * address in @desten buffer. Copy of lle ln_flags can be also
2476  * saved in @pflags if @pflags is non-NULL.
2477  *
2478  * Return values:
2479  * - 0 on success (address copied to buffer).
2480  * - EWOULDBLOCK (no local error, but address is still unresolved)
2481  * - other errors (alloc failure, etc)
2482  */
2483 int
2484 nd6_resolve_addr(struct ifnet *ifp, int flags, const struct sockaddr *dst,
2485     char *desten, uint32_t *pflags)
2486 {
2487 	int error;
2488 
2489 	flags |= LLE_ADDRONLY;
2490 	error = nd6_resolve_slow(ifp, AF_INET6, flags, NULL,
2491 	    (const struct sockaddr_in6 *)dst, desten, pflags, NULL);
2492 	return (error);
2493 }
2494 
2495 int
2496 nd6_flush_holdchain(struct ifnet *ifp, struct llentry *lle, struct mbuf *chain)
2497 {
2498 	struct mbuf *m, *m_head;
2499 	struct sockaddr_in6 dst6;
2500 	int error = 0;
2501 
2502 	NET_EPOCH_ASSERT();
2503 
2504 	struct route_in6 ro = {
2505 		.ro_prepend = lle->r_linkdata,
2506 		.ro_plen = lle->r_hdrlen,
2507 	};
2508 
2509 	lltable_fill_sa_entry(lle, (struct sockaddr *)&dst6);
2510 	m_head = chain;
2511 
2512 	while (m_head) {
2513 		m = m_head;
2514 		m_head = m_head->m_nextpkt;
2515 		m->m_nextpkt = NULL;
2516 		error = nd6_output_ifp(ifp, ifp, m, &dst6, (struct route *)&ro);
2517 	}
2518 
2519 	/*
2520 	 * XXX
2521 	 * note that intermediate errors are blindly ignored
2522 	 */
2523 	return (error);
2524 }
2525 
2526 __noinline void
2527 nd6_flush_children_holdchain(struct ifnet *ifp, struct llentry *lle)
2528 {
2529 	struct llentry *child_lle;
2530 	struct mbuf *chain;
2531 
2532 	NET_EPOCH_ASSERT();
2533 
2534 	CK_SLIST_FOREACH(child_lle, &lle->lle_children, lle_child_next) {
2535 		LLE_WLOCK(child_lle);
2536 		chain = nd6_grab_holdchain(child_lle);
2537 		LLE_WUNLOCK(child_lle);
2538 		nd6_flush_holdchain(ifp, child_lle, chain);
2539 	}
2540 }
2541 
2542 static int
2543 nd6_need_cache(struct ifnet *ifp)
2544 {
2545 	/*
2546 	 * XXX: we currently do not make neighbor cache on any interface
2547 	 * other than Ethernet and GIF.
2548 	 *
2549 	 * RFC2893 says:
2550 	 * - unidirectional tunnels needs no ND
2551 	 */
2552 	switch (ifp->if_type) {
2553 	case IFT_ETHER:
2554 	case IFT_IEEE1394:
2555 	case IFT_L2VLAN:
2556 	case IFT_INFINIBAND:
2557 	case IFT_BRIDGE:
2558 	case IFT_PROPVIRTUAL:
2559 		return (1);
2560 	default:
2561 		return (0);
2562 	}
2563 }
2564 
2565 /*
2566  * Add pernament ND6 link-layer record for given
2567  * interface address.
2568  *
2569  * Very similar to IPv4 arp_ifinit(), but:
2570  * 1) IPv6 DAD is performed in different place
2571  * 2) It is called by IPv6 protocol stack in contrast to
2572  * arp_ifinit() which is typically called in SIOCSIFADDR
2573  * driver ioctl handler.
2574  *
2575  */
2576 int
2577 nd6_add_ifa_lle(struct in6_ifaddr *ia)
2578 {
2579 	struct ifnet *ifp;
2580 	struct llentry *ln, *ln_tmp;
2581 	struct sockaddr *dst;
2582 
2583 	ifp = ia->ia_ifa.ifa_ifp;
2584 	if (nd6_need_cache(ifp) == 0)
2585 		return (0);
2586 
2587 	dst = (struct sockaddr *)&ia->ia_addr;
2588 	ln = lltable_alloc_entry(LLTABLE6(ifp), LLE_IFADDR, dst);
2589 	if (ln == NULL)
2590 		return (ENOBUFS);
2591 
2592 	IF_AFDATA_WLOCK(ifp);
2593 	LLE_WLOCK(ln);
2594 	/* Unlink any entry if exists */
2595 	ln_tmp = lla_lookup(LLTABLE6(ifp), LLE_SF(AF_INET6, LLE_EXCLUSIVE), dst);
2596 	if (ln_tmp != NULL)
2597 		lltable_unlink_entry(LLTABLE6(ifp), ln_tmp);
2598 	lltable_link_entry(LLTABLE6(ifp), ln);
2599 	IF_AFDATA_WUNLOCK(ifp);
2600 
2601 	if (ln_tmp != NULL)
2602 		EVENTHANDLER_INVOKE(lle_event, ln_tmp, LLENTRY_EXPIRED);
2603 	EVENTHANDLER_INVOKE(lle_event, ln, LLENTRY_RESOLVED);
2604 
2605 	LLE_WUNLOCK(ln);
2606 	if (ln_tmp != NULL)
2607 		llentry_free(ln_tmp);
2608 
2609 	return (0);
2610 }
2611 
2612 /*
2613  * Removes either all lle entries for given @ia, or lle
2614  * corresponding to @ia address.
2615  */
2616 void
2617 nd6_rem_ifa_lle(struct in6_ifaddr *ia, int all)
2618 {
2619 	struct sockaddr_in6 mask, addr;
2620 	struct sockaddr *saddr, *smask;
2621 	struct ifnet *ifp;
2622 
2623 	ifp = ia->ia_ifa.ifa_ifp;
2624 	memcpy(&addr, &ia->ia_addr, sizeof(ia->ia_addr));
2625 	memcpy(&mask, &ia->ia_prefixmask, sizeof(ia->ia_prefixmask));
2626 	saddr = (struct sockaddr *)&addr;
2627 	smask = (struct sockaddr *)&mask;
2628 
2629 	if (all != 0)
2630 		lltable_prefix_free(AF_INET6, saddr, smask, LLE_STATIC);
2631 	else
2632 		lltable_delete_addr(LLTABLE6(ifp), LLE_IFADDR, saddr);
2633 }
2634 
2635 static int
2636 nd6_sysctl_prlist(SYSCTL_HANDLER_ARGS)
2637 {
2638 	struct in6_prefix p;
2639 	struct sockaddr_in6 s6;
2640 	struct nd_prefix *pr;
2641 	struct nd_pfxrouter *pfr;
2642 	time_t maxexpire;
2643 	int error;
2644 	char ip6buf[INET6_ADDRSTRLEN];
2645 
2646 	if (req->newptr)
2647 		return (EPERM);
2648 
2649 	error = sysctl_wire_old_buffer(req, 0);
2650 	if (error != 0)
2651 		return (error);
2652 
2653 	bzero(&p, sizeof(p));
2654 	p.origin = PR_ORIG_RA;
2655 	bzero(&s6, sizeof(s6));
2656 	s6.sin6_family = AF_INET6;
2657 	s6.sin6_len = sizeof(s6);
2658 
2659 	ND6_RLOCK();
2660 	LIST_FOREACH(pr, &V_nd_prefix, ndpr_entry) {
2661 		if (!pr->ndpr_raf_ra_derived)
2662 			continue;
2663 		p.prefix = pr->ndpr_prefix;
2664 		if (sa6_recoverscope(&p.prefix)) {
2665 			log(LOG_ERR, "scope error in prefix list (%s)\n",
2666 			    ip6_sprintf(ip6buf, &p.prefix.sin6_addr));
2667 			/* XXX: press on... */
2668 		}
2669 		p.raflags = pr->ndpr_raf;
2670 		p.prefixlen = pr->ndpr_plen;
2671 		p.vltime = pr->ndpr_vltime;
2672 		p.pltime = pr->ndpr_pltime;
2673 		p.if_index = pr->ndpr_ifp->if_index;
2674 		if (pr->ndpr_vltime == ND6_INFINITE_LIFETIME)
2675 			p.expire = 0;
2676 		else {
2677 			/* XXX: we assume time_t is signed. */
2678 			maxexpire = (-1) &
2679 			    ~((time_t)1 << ((sizeof(maxexpire) * 8) - 1));
2680 			if (pr->ndpr_vltime < maxexpire - pr->ndpr_lastupdate)
2681 				p.expire = pr->ndpr_lastupdate +
2682 				    pr->ndpr_vltime +
2683 				    (time_second - time_uptime);
2684 			else
2685 				p.expire = maxexpire;
2686 		}
2687 		p.refcnt = pr->ndpr_addrcnt;
2688 		p.flags = pr->ndpr_stateflags;
2689 		p.advrtrs = 0;
2690 		LIST_FOREACH(pfr, &pr->ndpr_advrtrs, pfr_entry)
2691 			p.advrtrs++;
2692 		error = SYSCTL_OUT(req, &p, sizeof(p));
2693 		if (error != 0)
2694 			break;
2695 		LIST_FOREACH(pfr, &pr->ndpr_advrtrs, pfr_entry) {
2696 			s6.sin6_addr = pfr->router->rtaddr;
2697 			if (sa6_recoverscope(&s6))
2698 				log(LOG_ERR,
2699 				    "scope error in prefix list (%s)\n",
2700 				    ip6_sprintf(ip6buf, &pfr->router->rtaddr));
2701 			error = SYSCTL_OUT(req, &s6, sizeof(s6));
2702 			if (error != 0)
2703 				goto out;
2704 		}
2705 	}
2706 out:
2707 	ND6_RUNLOCK();
2708 	return (error);
2709 }
2710 SYSCTL_PROC(_net_inet6_icmp6, ICMPV6CTL_ND6_PRLIST, nd6_prlist,
2711 	CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_MPSAFE,
2712 	NULL, 0, nd6_sysctl_prlist, "S,in6_prefix",
2713 	"NDP prefix list");
2714 SYSCTL_INT(_net_inet6_icmp6, ICMPV6CTL_ND6_MAXQLEN, nd6_maxqueuelen,
2715 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(nd6_maxqueuelen), 1, "");
2716 SYSCTL_INT(_net_inet6_icmp6, OID_AUTO, nd6_gctimer,
2717 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(nd6_gctimer), (60 * 60 * 24), "");
2718