xref: /freebsd/sys/netinet6/in6.c (revision 4ec234c813eed05c166859bba82c882e40826eb9)
1 /*-
2  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the project nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  *	$KAME: in6.c,v 1.259 2002/01/21 11:37:50 keiichi Exp $
30  */
31 
32 /*-
33  * Copyright (c) 1982, 1986, 1991, 1993
34  *	The Regents of the University of California.  All rights reserved.
35  *
36  * Redistribution and use in source and binary forms, with or without
37  * modification, are permitted provided that the following conditions
38  * are met:
39  * 1. Redistributions of source code must retain the above copyright
40  *    notice, this list of conditions and the following disclaimer.
41  * 2. Redistributions in binary form must reproduce the above copyright
42  *    notice, this list of conditions and the following disclaimer in the
43  *    documentation and/or other materials provided with the distribution.
44  * 4. Neither the name of the University nor the names of its contributors
45  *    may be used to endorse or promote products derived from this software
46  *    without specific prior written permission.
47  *
48  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58  * SUCH DAMAGE.
59  *
60  *	@(#)in.c	8.2 (Berkeley) 11/15/93
61  */
62 
63 #include <sys/cdefs.h>
64 __FBSDID("$FreeBSD$");
65 
66 #include "opt_compat.h"
67 #include "opt_inet.h"
68 #include "opt_inet6.h"
69 
70 #include <sys/param.h>
71 #include <sys/eventhandler.h>
72 #include <sys/errno.h>
73 #include <sys/jail.h>
74 #include <sys/malloc.h>
75 #include <sys/socket.h>
76 #include <sys/socketvar.h>
77 #include <sys/sockio.h>
78 #include <sys/systm.h>
79 #include <sys/priv.h>
80 #include <sys/proc.h>
81 #include <sys/time.h>
82 #include <sys/kernel.h>
83 #include <sys/syslog.h>
84 
85 #include <net/if.h>
86 #include <net/if_var.h>
87 #include <net/if_types.h>
88 #include <net/route.h>
89 #include <net/if_dl.h>
90 #include <net/vnet.h>
91 
92 #include <netinet/in.h>
93 #include <netinet/in_var.h>
94 #include <net/if_llatbl.h>
95 #include <netinet/if_ether.h>
96 #include <netinet/in_systm.h>
97 #include <netinet/ip.h>
98 #include <netinet/in_pcb.h>
99 #include <netinet/ip_carp.h>
100 
101 #include <netinet/ip6.h>
102 #include <netinet6/ip6_var.h>
103 #include <netinet6/nd6.h>
104 #include <netinet6/mld6_var.h>
105 #include <netinet6/ip6_mroute.h>
106 #include <netinet6/in6_ifattach.h>
107 #include <netinet6/scope6_var.h>
108 #include <netinet6/in6_pcb.h>
109 
110 VNET_DECLARE(int, icmp6_nodeinfo_oldmcprefix);
111 #define V_icmp6_nodeinfo_oldmcprefix	VNET(icmp6_nodeinfo_oldmcprefix)
112 
113 /*
114  * Definitions of some costant IP6 addresses.
115  */
116 const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT;
117 const struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT;
118 const struct in6_addr in6addr_nodelocal_allnodes =
119 	IN6ADDR_NODELOCAL_ALLNODES_INIT;
120 const struct in6_addr in6addr_linklocal_allnodes =
121 	IN6ADDR_LINKLOCAL_ALLNODES_INIT;
122 const struct in6_addr in6addr_linklocal_allrouters =
123 	IN6ADDR_LINKLOCAL_ALLROUTERS_INIT;
124 const struct in6_addr in6addr_linklocal_allv2routers =
125 	IN6ADDR_LINKLOCAL_ALLV2ROUTERS_INIT;
126 
127 const struct in6_addr in6mask0 = IN6MASK0;
128 const struct in6_addr in6mask32 = IN6MASK32;
129 const struct in6_addr in6mask64 = IN6MASK64;
130 const struct in6_addr in6mask96 = IN6MASK96;
131 const struct in6_addr in6mask128 = IN6MASK128;
132 
133 const struct sockaddr_in6 sa6_any =
134 	{ sizeof(sa6_any), AF_INET6, 0, 0, IN6ADDR_ANY_INIT, 0 };
135 
136 static int in6_ifinit(struct ifnet *, struct in6_ifaddr *,
137 	struct sockaddr_in6 *, int);
138 static void in6_unlink_ifa(struct in6_ifaddr *, struct ifnet *);
139 
140 int	(*faithprefix_p)(struct in6_addr *);
141 
142 #define ifa2ia6(ifa)	((struct in6_ifaddr *)(ifa))
143 #define ia62ifa(ia6)	(&((ia6)->ia_ifa))
144 
145 void
146 in6_ifaddloop(struct ifaddr *ifa)
147 {
148 	struct sockaddr_dl gateway;
149 	struct sockaddr_in6 mask, addr;
150 	struct rtentry rt;
151 	struct in6_ifaddr *ia;
152 	struct ifnet *ifp;
153 	struct llentry *ln;
154 
155 	ia = ifa2ia6(ifa);
156 	ifp = ifa->ifa_ifp;
157 	IF_AFDATA_LOCK(ifp);
158 	ifa->ifa_rtrequest = nd6_rtrequest;
159 	ln = lla_lookup(LLTABLE6(ifp), (LLE_CREATE | LLE_IFADDR |
160 	    LLE_EXCLUSIVE), (struct sockaddr *)&ia->ia_addr);
161 	IF_AFDATA_UNLOCK(ifp);
162 	if (ln != NULL) {
163 		ln->la_expire = 0;  /* for IPv6 this means permanent */
164 		ln->ln_state = ND6_LLINFO_REACHABLE;
165 		/*
166 		 * initialize for rtmsg generation
167 		 */
168 		bzero(&gateway, sizeof(gateway));
169 		gateway.sdl_len = sizeof(gateway);
170 		gateway.sdl_family = AF_LINK;
171 		gateway.sdl_nlen = 0;
172 		gateway.sdl_alen = 6;
173 		memcpy(gateway.sdl_data, &ln->ll_addr.mac_aligned,
174 		    sizeof(ln->ll_addr));
175 		LLE_WUNLOCK(ln);
176 	}
177 
178 	bzero(&rt, sizeof(rt));
179 	rt.rt_gateway = (struct sockaddr *)&gateway;
180 	memcpy(&mask, &ia->ia_prefixmask, sizeof(ia->ia_prefixmask));
181 	memcpy(&addr, &ia->ia_addr, sizeof(ia->ia_addr));
182 	rt_mask(&rt) = (struct sockaddr *)&mask;
183 	rt_key(&rt) = (struct sockaddr *)&addr;
184 	rt.rt_flags = RTF_UP | RTF_HOST | RTF_STATIC;
185 	/* Announce arrival of local address to all FIBs. */
186 	rt_newaddrmsg(RTM_ADD, ifa, 0, &rt);
187 }
188 
189 void
190 in6_ifremloop(struct ifaddr *ifa)
191 {
192 	struct sockaddr_dl gateway;
193 	struct sockaddr_in6 mask, addr;
194 	struct rtentry rt0;
195 	struct in6_ifaddr *ia;
196 	struct ifnet *ifp;
197 
198 	ia = ifa2ia6(ifa);
199 	ifp = ifa->ifa_ifp;
200 	memcpy(&addr, &ia->ia_addr, sizeof(ia->ia_addr));
201 	memcpy(&mask, &ia->ia_prefixmask, sizeof(ia->ia_prefixmask));
202 	lltable_prefix_free(AF_INET6, (struct sockaddr *)&addr,
203 	            (struct sockaddr *)&mask, LLE_STATIC);
204 
205 	/*
206 	 * initialize for rtmsg generation
207 	 */
208 	bzero(&gateway, sizeof(gateway));
209 	gateway.sdl_len = sizeof(gateway);
210 	gateway.sdl_family = AF_LINK;
211 	gateway.sdl_nlen = 0;
212 	gateway.sdl_alen = ifp->if_addrlen;
213 	bzero(&rt0, sizeof(rt0));
214 	rt0.rt_gateway = (struct sockaddr *)&gateway;
215 	rt_mask(&rt0) = (struct sockaddr *)&mask;
216 	rt_key(&rt0) = (struct sockaddr *)&addr;
217 	rt0.rt_flags = RTF_HOST | RTF_STATIC;
218 	/* Announce removal of local address to all FIBs. */
219 	rt_newaddrmsg(RTM_DELETE, ifa, 0, &rt0);
220 }
221 
222 int
223 in6_mask2len(struct in6_addr *mask, u_char *lim0)
224 {
225 	int x = 0, y;
226 	u_char *lim = lim0, *p;
227 
228 	/* ignore the scope_id part */
229 	if (lim0 == NULL || lim0 - (u_char *)mask > sizeof(*mask))
230 		lim = (u_char *)mask + sizeof(*mask);
231 	for (p = (u_char *)mask; p < lim; x++, p++) {
232 		if (*p != 0xff)
233 			break;
234 	}
235 	y = 0;
236 	if (p < lim) {
237 		for (y = 0; y < 8; y++) {
238 			if ((*p & (0x80 >> y)) == 0)
239 				break;
240 		}
241 	}
242 
243 	/*
244 	 * when the limit pointer is given, do a stricter check on the
245 	 * remaining bits.
246 	 */
247 	if (p < lim) {
248 		if (y != 0 && (*p & (0x00ff >> y)) != 0)
249 			return (-1);
250 		for (p = p + 1; p < lim; p++)
251 			if (*p != 0)
252 				return (-1);
253 	}
254 
255 	return x * 8 + y;
256 }
257 
258 #ifdef COMPAT_FREEBSD32
259 struct in6_ndifreq32 {
260 	char ifname[IFNAMSIZ];
261 	uint32_t ifindex;
262 };
263 #define	SIOCGDEFIFACE32_IN6	_IOWR('i', 86, struct in6_ndifreq32)
264 #endif
265 
266 int
267 in6_control(struct socket *so, u_long cmd, caddr_t data,
268     struct ifnet *ifp, struct thread *td)
269 {
270 	struct	in6_ifreq *ifr = (struct in6_ifreq *)data;
271 	struct	in6_ifaddr *ia = NULL;
272 	struct	in6_aliasreq *ifra = (struct in6_aliasreq *)data;
273 	struct sockaddr_in6 *sa6;
274 	int carp_attached = 0;
275 	int error;
276 	u_long ocmd = cmd;
277 
278 	/*
279 	 * Compat to make pre-10.x ifconfig(8) operable.
280 	 */
281 	if (cmd == OSIOCAIFADDR_IN6)
282 		cmd = SIOCAIFADDR_IN6;
283 
284 	switch (cmd) {
285 	case SIOCGETSGCNT_IN6:
286 	case SIOCGETMIFCNT_IN6:
287 		/*
288 		 * XXX mrt_ioctl has a 3rd, unused, FIB argument in route.c.
289 		 * We cannot see how that would be needed, so do not adjust the
290 		 * KPI blindly; more likely should clean up the IPv4 variant.
291 		 */
292 		return (mrt6_ioctl ? mrt6_ioctl(cmd, data) : EOPNOTSUPP);
293 	}
294 
295 	switch(cmd) {
296 	case SIOCAADDRCTL_POLICY:
297 	case SIOCDADDRCTL_POLICY:
298 		if (td != NULL) {
299 			error = priv_check(td, PRIV_NETINET_ADDRCTRL6);
300 			if (error)
301 				return (error);
302 		}
303 		return (in6_src_ioctl(cmd, data));
304 	}
305 
306 	if (ifp == NULL)
307 		return (EOPNOTSUPP);
308 
309 	switch (cmd) {
310 	case SIOCSNDFLUSH_IN6:
311 	case SIOCSPFXFLUSH_IN6:
312 	case SIOCSRTRFLUSH_IN6:
313 	case SIOCSDEFIFACE_IN6:
314 	case SIOCSIFINFO_FLAGS:
315 	case SIOCSIFINFO_IN6:
316 		if (td != NULL) {
317 			error = priv_check(td, PRIV_NETINET_ND6);
318 			if (error)
319 				return (error);
320 		}
321 		/* FALLTHROUGH */
322 	case OSIOCGIFINFO_IN6:
323 	case SIOCGIFINFO_IN6:
324 	case SIOCGDRLST_IN6:
325 	case SIOCGPRLST_IN6:
326 	case SIOCGNBRINFO_IN6:
327 	case SIOCGDEFIFACE_IN6:
328 		return (nd6_ioctl(cmd, data, ifp));
329 
330 #ifdef COMPAT_FREEBSD32
331 	case SIOCGDEFIFACE32_IN6:
332 		{
333 			struct in6_ndifreq ndif;
334 			struct in6_ndifreq32 *ndif32;
335 
336 			error = nd6_ioctl(SIOCGDEFIFACE_IN6, (caddr_t)&ndif,
337 			    ifp);
338 			if (error)
339 				return (error);
340 			ndif32 = (struct in6_ndifreq32 *)data;
341 			ndif32->ifindex = ndif.ifindex;
342 			return (0);
343 		}
344 #endif
345 	}
346 
347 	switch (cmd) {
348 	case SIOCSIFPREFIX_IN6:
349 	case SIOCDIFPREFIX_IN6:
350 	case SIOCAIFPREFIX_IN6:
351 	case SIOCCIFPREFIX_IN6:
352 	case SIOCSGIFPREFIX_IN6:
353 	case SIOCGIFPREFIX_IN6:
354 		log(LOG_NOTICE,
355 		    "prefix ioctls are now invalidated. "
356 		    "please use ifconfig.\n");
357 		return (EOPNOTSUPP);
358 	}
359 
360 	switch (cmd) {
361 	case SIOCSSCOPE6:
362 		if (td != NULL) {
363 			error = priv_check(td, PRIV_NETINET_SCOPE6);
364 			if (error)
365 				return (error);
366 		}
367 		return (scope6_set(ifp,
368 		    (struct scope6_id *)ifr->ifr_ifru.ifru_scope_id));
369 	case SIOCGSCOPE6:
370 		return (scope6_get(ifp,
371 		    (struct scope6_id *)ifr->ifr_ifru.ifru_scope_id));
372 	case SIOCGSCOPE6DEF:
373 		return (scope6_get_default((struct scope6_id *)
374 		    ifr->ifr_ifru.ifru_scope_id));
375 	}
376 
377 	/*
378 	 * Find address for this interface, if it exists.
379 	 *
380 	 * In netinet code, we have checked ifra_addr in SIOCSIF*ADDR operation
381 	 * only, and used the first interface address as the target of other
382 	 * operations (without checking ifra_addr).  This was because netinet
383 	 * code/API assumed at most 1 interface address per interface.
384 	 * Since IPv6 allows a node to assign multiple addresses
385 	 * on a single interface, we almost always look and check the
386 	 * presence of ifra_addr, and reject invalid ones here.
387 	 * It also decreases duplicated code among SIOC*_IN6 operations.
388 	 */
389 	switch (cmd) {
390 	case SIOCAIFADDR_IN6:
391 	case SIOCSIFPHYADDR_IN6:
392 		sa6 = &ifra->ifra_addr;
393 		break;
394 	case SIOCSIFADDR_IN6:
395 	case SIOCGIFADDR_IN6:
396 	case SIOCSIFDSTADDR_IN6:
397 	case SIOCSIFNETMASK_IN6:
398 	case SIOCGIFDSTADDR_IN6:
399 	case SIOCGIFNETMASK_IN6:
400 	case SIOCDIFADDR_IN6:
401 	case SIOCGIFPSRCADDR_IN6:
402 	case SIOCGIFPDSTADDR_IN6:
403 	case SIOCGIFAFLAG_IN6:
404 	case SIOCSNDFLUSH_IN6:
405 	case SIOCSPFXFLUSH_IN6:
406 	case SIOCSRTRFLUSH_IN6:
407 	case SIOCGIFALIFETIME_IN6:
408 	case SIOCSIFALIFETIME_IN6:
409 	case SIOCGIFSTAT_IN6:
410 	case SIOCGIFSTAT_ICMP6:
411 		sa6 = &ifr->ifr_addr;
412 		break;
413 	case SIOCSIFADDR:
414 	case SIOCSIFBRDADDR:
415 	case SIOCSIFDSTADDR:
416 	case SIOCSIFNETMASK:
417 		/*
418 		 * Although we should pass any non-INET6 ioctl requests
419 		 * down to driver, we filter some legacy INET requests.
420 		 * Drivers trust SIOCSIFADDR et al to come from an already
421 		 * privileged layer, and do not perform any credentials
422 		 * checks or input validation.
423 		 */
424 		return (EINVAL);
425 	default:
426 		sa6 = NULL;
427 		break;
428 	}
429 	if (sa6 && sa6->sin6_family == AF_INET6) {
430 		if (sa6->sin6_scope_id != 0)
431 			error = sa6_embedscope(sa6, 0);
432 		else
433 			error = in6_setscope(&sa6->sin6_addr, ifp, NULL);
434 		if (error != 0)
435 			return (error);
436 		if (td != NULL && (error = prison_check_ip6(td->td_ucred,
437 		    &sa6->sin6_addr)) != 0)
438 			return (error);
439 		ia = in6ifa_ifpwithaddr(ifp, &sa6->sin6_addr);
440 	} else
441 		ia = NULL;
442 
443 	switch (cmd) {
444 	case SIOCSIFADDR_IN6:
445 	case SIOCSIFDSTADDR_IN6:
446 	case SIOCSIFNETMASK_IN6:
447 		/*
448 		 * Since IPv6 allows a node to assign multiple addresses
449 		 * on a single interface, SIOCSIFxxx ioctls are deprecated.
450 		 */
451 		/* we decided to obsolete this command (20000704) */
452 		error = EINVAL;
453 		goto out;
454 
455 	case SIOCDIFADDR_IN6:
456 		/*
457 		 * for IPv4, we look for existing in_ifaddr here to allow
458 		 * "ifconfig if0 delete" to remove the first IPv4 address on
459 		 * the interface.  For IPv6, as the spec allows multiple
460 		 * interface address from the day one, we consider "remove the
461 		 * first one" semantics to be not preferable.
462 		 */
463 		if (ia == NULL) {
464 			error = EADDRNOTAVAIL;
465 			goto out;
466 		}
467 		/* FALLTHROUGH */
468 	case SIOCAIFADDR_IN6:
469 		/*
470 		 * We always require users to specify a valid IPv6 address for
471 		 * the corresponding operation.
472 		 */
473 		if (ifra->ifra_addr.sin6_family != AF_INET6 ||
474 		    ifra->ifra_addr.sin6_len != sizeof(struct sockaddr_in6)) {
475 			error = EAFNOSUPPORT;
476 			goto out;
477 		}
478 
479 		if (td != NULL) {
480 			error = priv_check(td, (cmd == SIOCDIFADDR_IN6) ?
481 			    PRIV_NET_DELIFADDR : PRIV_NET_ADDIFADDR);
482 			if (error)
483 				goto out;
484 		}
485 		break;
486 
487 	case SIOCGIFADDR_IN6:
488 		/* This interface is basically deprecated. use SIOCGIFCONF. */
489 		/* FALLTHROUGH */
490 	case SIOCGIFAFLAG_IN6:
491 	case SIOCGIFNETMASK_IN6:
492 	case SIOCGIFDSTADDR_IN6:
493 	case SIOCGIFALIFETIME_IN6:
494 		/* must think again about its semantics */
495 		if (ia == NULL) {
496 			error = EADDRNOTAVAIL;
497 			goto out;
498 		}
499 		break;
500 
501 	case SIOCSIFALIFETIME_IN6:
502 	    {
503 		struct in6_addrlifetime *lt;
504 
505 		if (td != NULL) {
506 			error = priv_check(td, PRIV_NETINET_ALIFETIME6);
507 			if (error)
508 				goto out;
509 		}
510 		if (ia == NULL) {
511 			error = EADDRNOTAVAIL;
512 			goto out;
513 		}
514 		/* sanity for overflow - beware unsigned */
515 		lt = &ifr->ifr_ifru.ifru_lifetime;
516 		if (lt->ia6t_vltime != ND6_INFINITE_LIFETIME &&
517 		    lt->ia6t_vltime + time_uptime < time_uptime) {
518 			error = EINVAL;
519 			goto out;
520 		}
521 		if (lt->ia6t_pltime != ND6_INFINITE_LIFETIME &&
522 		    lt->ia6t_pltime + time_uptime < time_uptime) {
523 			error = EINVAL;
524 			goto out;
525 		}
526 		break;
527 	    }
528 	}
529 
530 	switch (cmd) {
531 	case SIOCGIFADDR_IN6:
532 		ifr->ifr_addr = ia->ia_addr;
533 		if ((error = sa6_recoverscope(&ifr->ifr_addr)) != 0)
534 			goto out;
535 		break;
536 
537 	case SIOCGIFDSTADDR_IN6:
538 		if ((ifp->if_flags & IFF_POINTOPOINT) == 0) {
539 			error = EINVAL;
540 			goto out;
541 		}
542 		/*
543 		 * XXX: should we check if ifa_dstaddr is NULL and return
544 		 * an error?
545 		 */
546 		ifr->ifr_dstaddr = ia->ia_dstaddr;
547 		if ((error = sa6_recoverscope(&ifr->ifr_dstaddr)) != 0)
548 			goto out;
549 		break;
550 
551 	case SIOCGIFNETMASK_IN6:
552 		ifr->ifr_addr = ia->ia_prefixmask;
553 		break;
554 
555 	case SIOCGIFAFLAG_IN6:
556 		ifr->ifr_ifru.ifru_flags6 = ia->ia6_flags;
557 		break;
558 
559 	case SIOCGIFSTAT_IN6:
560 		if (ifp == NULL) {
561 			error = EINVAL;
562 			goto out;
563 		}
564 		COUNTER_ARRAY_COPY(((struct in6_ifextra *)
565 		    ifp->if_afdata[AF_INET6])->in6_ifstat,
566 		    &ifr->ifr_ifru.ifru_stat,
567 		    sizeof(struct in6_ifstat) / sizeof(uint64_t));
568 		break;
569 
570 	case SIOCGIFSTAT_ICMP6:
571 		if (ifp == NULL) {
572 			error = EINVAL;
573 			goto out;
574 		}
575 		COUNTER_ARRAY_COPY(((struct in6_ifextra *)
576 		    ifp->if_afdata[AF_INET6])->icmp6_ifstat,
577 		    &ifr->ifr_ifru.ifru_icmp6stat,
578 		    sizeof(struct icmp6_ifstat) / sizeof(uint64_t));
579 		break;
580 
581 	case SIOCGIFALIFETIME_IN6:
582 		ifr->ifr_ifru.ifru_lifetime = ia->ia6_lifetime;
583 		if (ia->ia6_lifetime.ia6t_vltime != ND6_INFINITE_LIFETIME) {
584 			time_t maxexpire;
585 			struct in6_addrlifetime *retlt =
586 			    &ifr->ifr_ifru.ifru_lifetime;
587 
588 			/*
589 			 * XXX: adjust expiration time assuming time_t is
590 			 * signed.
591 			 */
592 			maxexpire = (-1) &
593 			    ~((time_t)1 << ((sizeof(maxexpire) * 8) - 1));
594 			if (ia->ia6_lifetime.ia6t_vltime <
595 			    maxexpire - ia->ia6_updatetime) {
596 				retlt->ia6t_expire = ia->ia6_updatetime +
597 				    ia->ia6_lifetime.ia6t_vltime;
598 			} else
599 				retlt->ia6t_expire = maxexpire;
600 		}
601 		if (ia->ia6_lifetime.ia6t_pltime != ND6_INFINITE_LIFETIME) {
602 			time_t maxexpire;
603 			struct in6_addrlifetime *retlt =
604 			    &ifr->ifr_ifru.ifru_lifetime;
605 
606 			/*
607 			 * XXX: adjust expiration time assuming time_t is
608 			 * signed.
609 			 */
610 			maxexpire = (-1) &
611 			    ~((time_t)1 << ((sizeof(maxexpire) * 8) - 1));
612 			if (ia->ia6_lifetime.ia6t_pltime <
613 			    maxexpire - ia->ia6_updatetime) {
614 				retlt->ia6t_preferred = ia->ia6_updatetime +
615 				    ia->ia6_lifetime.ia6t_pltime;
616 			} else
617 				retlt->ia6t_preferred = maxexpire;
618 		}
619 		break;
620 
621 	case SIOCSIFALIFETIME_IN6:
622 		ia->ia6_lifetime = ifr->ifr_ifru.ifru_lifetime;
623 		/* for sanity */
624 		if (ia->ia6_lifetime.ia6t_vltime != ND6_INFINITE_LIFETIME) {
625 			ia->ia6_lifetime.ia6t_expire =
626 				time_uptime + ia->ia6_lifetime.ia6t_vltime;
627 		} else
628 			ia->ia6_lifetime.ia6t_expire = 0;
629 		if (ia->ia6_lifetime.ia6t_pltime != ND6_INFINITE_LIFETIME) {
630 			ia->ia6_lifetime.ia6t_preferred =
631 				time_uptime + ia->ia6_lifetime.ia6t_pltime;
632 		} else
633 			ia->ia6_lifetime.ia6t_preferred = 0;
634 		break;
635 
636 	case SIOCAIFADDR_IN6:
637 	{
638 		struct nd_prefixctl pr0;
639 		struct nd_prefix *pr;
640 
641 		/*
642 		 * first, make or update the interface address structure,
643 		 * and link it to the list.
644 		 */
645 		if ((error = in6_update_ifa(ifp, ifra, ia, 0)) != 0)
646 			goto out;
647 		if (ia != NULL)
648 			ifa_free(&ia->ia_ifa);
649 		if ((ia = in6ifa_ifpwithaddr(ifp, &ifra->ifra_addr.sin6_addr))
650 		    == NULL) {
651 			/*
652 			 * this can happen when the user specify the 0 valid
653 			 * lifetime.
654 			 */
655 			break;
656 		}
657 
658 		if (cmd == ocmd && ifra->ifra_vhid > 0) {
659 			if (carp_attach_p != NULL)
660 				error = (*carp_attach_p)(&ia->ia_ifa,
661 				    ifra->ifra_vhid);
662 			else
663 				error = EPROTONOSUPPORT;
664 			if (error)
665 				goto out;
666 			else
667 				carp_attached = 1;
668 		}
669 
670 		/*
671 		 * then, make the prefix on-link on the interface.
672 		 * XXX: we'd rather create the prefix before the address, but
673 		 * we need at least one address to install the corresponding
674 		 * interface route, so we configure the address first.
675 		 */
676 
677 		/*
678 		 * convert mask to prefix length (prefixmask has already
679 		 * been validated in in6_update_ifa().
680 		 */
681 		bzero(&pr0, sizeof(pr0));
682 		pr0.ndpr_ifp = ifp;
683 		pr0.ndpr_plen = in6_mask2len(&ifra->ifra_prefixmask.sin6_addr,
684 		    NULL);
685 		if (pr0.ndpr_plen == 128) {
686 			break;	/* we don't need to install a host route. */
687 		}
688 		pr0.ndpr_prefix = ifra->ifra_addr;
689 		/* apply the mask for safety. */
690 		IN6_MASK_ADDR(&pr0.ndpr_prefix.sin6_addr,
691 		    &ifra->ifra_prefixmask.sin6_addr);
692 
693 		/*
694 		 * XXX: since we don't have an API to set prefix (not address)
695 		 * lifetimes, we just use the same lifetimes as addresses.
696 		 * The (temporarily) installed lifetimes can be overridden by
697 		 * later advertised RAs (when accept_rtadv is non 0), which is
698 		 * an intended behavior.
699 		 */
700 		pr0.ndpr_raf_onlink = 1; /* should be configurable? */
701 		pr0.ndpr_raf_auto =
702 		    ((ifra->ifra_flags & IN6_IFF_AUTOCONF) != 0);
703 		pr0.ndpr_vltime = ifra->ifra_lifetime.ia6t_vltime;
704 		pr0.ndpr_pltime = ifra->ifra_lifetime.ia6t_pltime;
705 
706 		/* add the prefix if not yet. */
707 		if ((pr = nd6_prefix_lookup(&pr0)) == NULL) {
708 			/*
709 			 * nd6_prelist_add will install the corresponding
710 			 * interface route.
711 			 */
712 			if ((error = nd6_prelist_add(&pr0, NULL, &pr)) != 0) {
713 				if (carp_attached)
714 					(*carp_detach_p)(&ia->ia_ifa);
715 				goto out;
716 			}
717 			if (pr == NULL) {
718 				if (carp_attached)
719 					(*carp_detach_p)(&ia->ia_ifa);
720 				log(LOG_ERR, "nd6_prelist_add succeeded but "
721 				    "no prefix\n");
722 				error = EINVAL;
723 				goto out;
724 			}
725 		}
726 
727 		/* relate the address to the prefix */
728 		if (ia->ia6_ndpr == NULL) {
729 			ia->ia6_ndpr = pr;
730 			pr->ndpr_refcnt++;
731 
732 			/*
733 			 * If this is the first autoconf address from the
734 			 * prefix, create a temporary address as well
735 			 * (when required).
736 			 */
737 			if ((ia->ia6_flags & IN6_IFF_AUTOCONF) &&
738 			    V_ip6_use_tempaddr && pr->ndpr_refcnt == 1) {
739 				int e;
740 				if ((e = in6_tmpifadd(ia, 1, 0)) != 0) {
741 					log(LOG_NOTICE, "in6_control: failed "
742 					    "to create a temporary address, "
743 					    "errno=%d\n", e);
744 				}
745 			}
746 		}
747 
748 		/*
749 		 * this might affect the status of autoconfigured addresses,
750 		 * that is, this address might make other addresses detached.
751 		 */
752 		pfxlist_onlink_check();
753 		if (error == 0 && ia) {
754 			if (ND_IFINFO(ifp)->flags & ND6_IFF_IFDISABLED) {
755 				/*
756 				 * Try to clear the flag when a new
757 				 * IPv6 address is added onto an
758 				 * IFDISABLED interface and it
759 				 * succeeds.
760 				 */
761 				struct in6_ndireq nd;
762 
763 				memset(&nd, 0, sizeof(nd));
764 				nd.ndi.flags = ND_IFINFO(ifp)->flags;
765 				nd.ndi.flags &= ~ND6_IFF_IFDISABLED;
766 				if (nd6_ioctl(SIOCSIFINFO_FLAGS,
767 				    (caddr_t)&nd, ifp) < 0)
768 					log(LOG_NOTICE, "SIOCAIFADDR_IN6: "
769 					    "SIOCSIFINFO_FLAGS for -ifdisabled "
770 					    "failed.");
771 				/*
772 				 * Ignore failure of clearing the flag
773 				 * intentionally.  The failure means
774 				 * address duplication was detected.
775 				 */
776 			}
777 			EVENTHANDLER_INVOKE(ifaddr_event, ifp);
778 		}
779 		break;
780 	}
781 
782 	case SIOCDIFADDR_IN6:
783 	{
784 		struct nd_prefix *pr;
785 
786 		/*
787 		 * If the address being deleted is the only one that owns
788 		 * the corresponding prefix, expire the prefix as well.
789 		 * XXX: theoretically, we don't have to worry about such
790 		 * relationship, since we separate the address management
791 		 * and the prefix management.  We do this, however, to provide
792 		 * as much backward compatibility as possible in terms of
793 		 * the ioctl operation.
794 		 * Note that in6_purgeaddr() will decrement ndpr_refcnt.
795 		 */
796 		pr = ia->ia6_ndpr;
797 		in6_purgeaddr(&ia->ia_ifa);
798 		if (pr && pr->ndpr_refcnt == 0)
799 			prelist_remove(pr);
800 		EVENTHANDLER_INVOKE(ifaddr_event, ifp);
801 		break;
802 	}
803 
804 	default:
805 		if (ifp == NULL || ifp->if_ioctl == 0) {
806 			error = EOPNOTSUPP;
807 			goto out;
808 		}
809 		error = (*ifp->if_ioctl)(ifp, cmd, data);
810 		goto out;
811 	}
812 
813 	error = 0;
814 out:
815 	if (ia != NULL)
816 		ifa_free(&ia->ia_ifa);
817 	return (error);
818 }
819 
820 
821 /*
822  * Join necessary multicast groups.  Factored out from in6_update_ifa().
823  * This entire work should only be done once, for the default FIB.
824  */
825 static int
826 in6_update_ifa_join_mc(struct ifnet *ifp, struct in6_aliasreq *ifra,
827     struct in6_ifaddr *ia, int flags, struct in6_multi **in6m_sol)
828 {
829 	char ip6buf[INET6_ADDRSTRLEN];
830 	struct sockaddr_in6 mltaddr, mltmask;
831 	struct in6_addr llsol;
832 	struct in6_multi_mship *imm;
833 	struct rtentry *rt;
834 	int delay, error;
835 
836 	KASSERT(in6m_sol != NULL, ("%s: in6m_sol is NULL", __func__));
837 
838 	/* Join solicited multicast addr for new host id. */
839 	bzero(&llsol, sizeof(struct in6_addr));
840 	llsol.s6_addr32[0] = IPV6_ADDR_INT32_MLL;
841 	llsol.s6_addr32[1] = 0;
842 	llsol.s6_addr32[2] = htonl(1);
843 	llsol.s6_addr32[3] = ifra->ifra_addr.sin6_addr.s6_addr32[3];
844 	llsol.s6_addr8[12] = 0xff;
845 	if ((error = in6_setscope(&llsol, ifp, NULL)) != 0) {
846 		/* XXX: should not happen */
847 		log(LOG_ERR, "%s: in6_setscope failed\n", __func__);
848 		goto cleanup;
849 	}
850 	delay = 0;
851 	if ((flags & IN6_IFAUPDATE_DADDELAY)) {
852 		/*
853 		 * We need a random delay for DAD on the address being
854 		 * configured.  It also means delaying transmission of the
855 		 * corresponding MLD report to avoid report collision.
856 		 * [RFC 4861, Section 6.3.7]
857 		 */
858 		delay = arc4random() % (MAX_RTR_SOLICITATION_DELAY * hz);
859 	}
860 	imm = in6_joingroup(ifp, &llsol, &error, delay);
861 	if (imm == NULL) {
862 		nd6log((LOG_WARNING, "%s: addmulti failed for %s on %s "
863 		    "(errno=%d)\n", __func__, ip6_sprintf(ip6buf, &llsol),
864 		    if_name(ifp), error));
865 		goto cleanup;
866 	}
867 	LIST_INSERT_HEAD(&ia->ia6_memberships, imm, i6mm_chain);
868 	*in6m_sol = imm->i6mm_maddr;
869 
870 	bzero(&mltmask, sizeof(mltmask));
871 	mltmask.sin6_len = sizeof(struct sockaddr_in6);
872 	mltmask.sin6_family = AF_INET6;
873 	mltmask.sin6_addr = in6mask32;
874 #define	MLTMASK_LEN  4	/* mltmask's masklen (=32bit=4octet) */
875 
876 	/*
877 	 * Join link-local all-nodes address.
878 	 */
879 	bzero(&mltaddr, sizeof(mltaddr));
880 	mltaddr.sin6_len = sizeof(struct sockaddr_in6);
881 	mltaddr.sin6_family = AF_INET6;
882 	mltaddr.sin6_addr = in6addr_linklocal_allnodes;
883 	if ((error = in6_setscope(&mltaddr.sin6_addr, ifp, NULL)) != 0)
884 		goto cleanup; /* XXX: should not fail */
885 
886 	/*
887 	 * XXX: do we really need this automatic routes?  We should probably
888 	 * reconsider this stuff.  Most applications actually do not need the
889 	 * routes, since they usually specify the outgoing interface.
890 	 */
891 	rt = in6_rtalloc1((struct sockaddr *)&mltaddr, 0, 0UL, RT_DEFAULT_FIB);
892 	if (rt != NULL) {
893 		/* XXX: only works in !SCOPEDROUTING case. */
894 		if (memcmp(&mltaddr.sin6_addr,
895 		    &((struct sockaddr_in6 *)rt_key(rt))->sin6_addr,
896 		    MLTMASK_LEN)) {
897 			RTFREE_LOCKED(rt);
898 			rt = NULL;
899 		}
900 	}
901 	if (rt == NULL) {
902 		error = in6_rtrequest(RTM_ADD, (struct sockaddr *)&mltaddr,
903 		    (struct sockaddr *)&ia->ia_addr,
904 		    (struct sockaddr *)&mltmask, RTF_UP,
905 		    (struct rtentry **)0, RT_DEFAULT_FIB);
906 		if (error)
907 			goto cleanup;
908 	} else
909 		RTFREE_LOCKED(rt);
910 
911 	imm = in6_joingroup(ifp, &mltaddr.sin6_addr, &error, 0);
912 	if (imm == NULL) {
913 		nd6log((LOG_WARNING, "%s: addmulti failed for %s on %s "
914 		    "(errno=%d)\n", __func__, ip6_sprintf(ip6buf,
915 		    &mltaddr.sin6_addr), if_name(ifp), error));
916 		goto cleanup;
917 	}
918 	LIST_INSERT_HEAD(&ia->ia6_memberships, imm, i6mm_chain);
919 
920 	/*
921 	 * Join node information group address.
922 	 */
923 	delay = 0;
924 	if ((flags & IN6_IFAUPDATE_DADDELAY)) {
925 		/*
926 		 * The spec does not say anything about delay for this group,
927 		 * but the same logic should apply.
928 		 */
929 		delay = arc4random() % (MAX_RTR_SOLICITATION_DELAY * hz);
930 	}
931 	if (in6_nigroup(ifp, NULL, -1, &mltaddr.sin6_addr) == 0) {
932 		/* XXX jinmei */
933 		imm = in6_joingroup(ifp, &mltaddr.sin6_addr, &error, delay);
934 		if (imm == NULL)
935 			nd6log((LOG_WARNING, "%s: addmulti failed for %s on %s "
936 			    "(errno=%d)\n", __func__, ip6_sprintf(ip6buf,
937 			    &mltaddr.sin6_addr), if_name(ifp), error));
938 			/* XXX not very fatal, go on... */
939 		else
940 			LIST_INSERT_HEAD(&ia->ia6_memberships, imm, i6mm_chain);
941 	}
942 	if (V_icmp6_nodeinfo_oldmcprefix &&
943 	     in6_nigroup_oldmcprefix(ifp, NULL, -1, &mltaddr.sin6_addr) == 0) {
944 		imm = in6_joingroup(ifp, &mltaddr.sin6_addr, &error, delay);
945 		if (imm == NULL)
946 			nd6log((LOG_WARNING, "%s: addmulti failed for %s on %s "
947 			    "(errno=%d)\n", __func__, ip6_sprintf(ip6buf,
948 			    &mltaddr.sin6_addr), if_name(ifp), error));
949 			/* XXX not very fatal, go on... */
950 		else
951 			LIST_INSERT_HEAD(&ia->ia6_memberships, imm, i6mm_chain);
952 	}
953 
954 	/*
955 	 * Join interface-local all-nodes address.
956 	 * (ff01::1%ifN, and ff01::%ifN/32)
957 	 */
958 	mltaddr.sin6_addr = in6addr_nodelocal_allnodes;
959 	if ((error = in6_setscope(&mltaddr.sin6_addr, ifp, NULL)) != 0)
960 		goto cleanup; /* XXX: should not fail */
961 	/* XXX: again, do we really need the route? */
962 	rt = in6_rtalloc1((struct sockaddr *)&mltaddr, 0, 0UL, RT_DEFAULT_FIB);
963 	if (rt != NULL) {
964 		if (memcmp(&mltaddr.sin6_addr,
965 		    &((struct sockaddr_in6 *)rt_key(rt))->sin6_addr,
966 		    MLTMASK_LEN)) {
967 			RTFREE_LOCKED(rt);
968 			rt = NULL;
969 		}
970 	}
971 	if (rt == NULL) {
972 		error = in6_rtrequest(RTM_ADD, (struct sockaddr *)&mltaddr,
973 		    (struct sockaddr *)&ia->ia_addr,
974 		    (struct sockaddr *)&mltmask, RTF_UP,
975 		    (struct rtentry **)0, RT_DEFAULT_FIB);
976 		if (error)
977 			goto cleanup;
978 	} else
979 		RTFREE_LOCKED(rt);
980 
981 	imm = in6_joingroup(ifp, &mltaddr.sin6_addr, &error, 0);
982 	if (imm == NULL) {
983 		nd6log((LOG_WARNING, "%s: addmulti failed for %s on %s "
984 		    "(errno=%d)\n", __func__, ip6_sprintf(ip6buf,
985 		    &mltaddr.sin6_addr), if_name(ifp), error));
986 		goto cleanup;
987 	}
988 	LIST_INSERT_HEAD(&ia->ia6_memberships, imm, i6mm_chain);
989 #undef	MLTMASK_LEN
990 
991 cleanup:
992 	return (error);
993 }
994 
995 /*
996  * Update parameters of an IPv6 interface address.
997  * If necessary, a new entry is created and linked into address chains.
998  * This function is separated from in6_control().
999  */
1000 int
1001 in6_update_ifa(struct ifnet *ifp, struct in6_aliasreq *ifra,
1002     struct in6_ifaddr *ia, int flags)
1003 {
1004 	int error = 0, hostIsNew = 0, plen = -1;
1005 	struct sockaddr_in6 dst6;
1006 	struct in6_addrlifetime *lt;
1007 	struct in6_multi *in6m_sol;
1008 	int delay;
1009 	char ip6buf[INET6_ADDRSTRLEN];
1010 
1011 	/* Validate parameters */
1012 	if (ifp == NULL || ifra == NULL) /* this maybe redundant */
1013 		return (EINVAL);
1014 
1015 	/*
1016 	 * The destination address for a p2p link must have a family
1017 	 * of AF_UNSPEC or AF_INET6.
1018 	 */
1019 	if ((ifp->if_flags & IFF_POINTOPOINT) != 0 &&
1020 	    ifra->ifra_dstaddr.sin6_family != AF_INET6 &&
1021 	    ifra->ifra_dstaddr.sin6_family != AF_UNSPEC)
1022 		return (EAFNOSUPPORT);
1023 	/*
1024 	 * validate ifra_prefixmask.  don't check sin6_family, netmask
1025 	 * does not carry fields other than sin6_len.
1026 	 */
1027 	if (ifra->ifra_prefixmask.sin6_len > sizeof(struct sockaddr_in6))
1028 		return (EINVAL);
1029 	/*
1030 	 * Because the IPv6 address architecture is classless, we require
1031 	 * users to specify a (non 0) prefix length (mask) for a new address.
1032 	 * We also require the prefix (when specified) mask is valid, and thus
1033 	 * reject a non-consecutive mask.
1034 	 */
1035 	if (ia == NULL && ifra->ifra_prefixmask.sin6_len == 0)
1036 		return (EINVAL);
1037 	if (ifra->ifra_prefixmask.sin6_len != 0) {
1038 		plen = in6_mask2len(&ifra->ifra_prefixmask.sin6_addr,
1039 		    (u_char *)&ifra->ifra_prefixmask +
1040 		    ifra->ifra_prefixmask.sin6_len);
1041 		if (plen <= 0)
1042 			return (EINVAL);
1043 	} else {
1044 		/*
1045 		 * In this case, ia must not be NULL.  We just use its prefix
1046 		 * length.
1047 		 */
1048 		plen = in6_mask2len(&ia->ia_prefixmask.sin6_addr, NULL);
1049 	}
1050 	/*
1051 	 * If the destination address on a p2p interface is specified,
1052 	 * and the address is a scoped one, validate/set the scope
1053 	 * zone identifier.
1054 	 */
1055 	dst6 = ifra->ifra_dstaddr;
1056 	if ((ifp->if_flags & (IFF_POINTOPOINT|IFF_LOOPBACK)) != 0 &&
1057 	    (dst6.sin6_family == AF_INET6)) {
1058 		struct in6_addr in6_tmp;
1059 		u_int32_t zoneid;
1060 
1061 		in6_tmp = dst6.sin6_addr;
1062 		if (in6_setscope(&in6_tmp, ifp, &zoneid))
1063 			return (EINVAL); /* XXX: should be impossible */
1064 
1065 		if (dst6.sin6_scope_id != 0) {
1066 			if (dst6.sin6_scope_id != zoneid)
1067 				return (EINVAL);
1068 		} else		/* user omit to specify the ID. */
1069 			dst6.sin6_scope_id = zoneid;
1070 
1071 		/* convert into the internal form */
1072 		if (sa6_embedscope(&dst6, 0))
1073 			return (EINVAL); /* XXX: should be impossible */
1074 	}
1075 	/*
1076 	 * The destination address can be specified only for a p2p or a
1077 	 * loopback interface.  If specified, the corresponding prefix length
1078 	 * must be 128.
1079 	 */
1080 	if (ifra->ifra_dstaddr.sin6_family == AF_INET6) {
1081 		if ((ifp->if_flags & (IFF_POINTOPOINT|IFF_LOOPBACK)) == 0) {
1082 			/* XXX: noisy message */
1083 			nd6log((LOG_INFO, "in6_update_ifa: a destination can "
1084 			    "be specified for a p2p or a loopback IF only\n"));
1085 			return (EINVAL);
1086 		}
1087 		if (plen != 128) {
1088 			nd6log((LOG_INFO, "in6_update_ifa: prefixlen should "
1089 			    "be 128 when dstaddr is specified\n"));
1090 			return (EINVAL);
1091 		}
1092 	}
1093 	/* lifetime consistency check */
1094 	lt = &ifra->ifra_lifetime;
1095 	if (lt->ia6t_pltime > lt->ia6t_vltime)
1096 		return (EINVAL);
1097 	if (lt->ia6t_vltime == 0) {
1098 		/*
1099 		 * the following log might be noisy, but this is a typical
1100 		 * configuration mistake or a tool's bug.
1101 		 */
1102 		nd6log((LOG_INFO,
1103 		    "in6_update_ifa: valid lifetime is 0 for %s\n",
1104 		    ip6_sprintf(ip6buf, &ifra->ifra_addr.sin6_addr)));
1105 
1106 		if (ia == NULL)
1107 			return (0); /* there's nothing to do */
1108 	}
1109 
1110 	/*
1111 	 * If this is a new address, allocate a new ifaddr and link it
1112 	 * into chains.
1113 	 */
1114 	if (ia == NULL) {
1115 		hostIsNew = 1;
1116 		/*
1117 		 * When in6_update_ifa() is called in a process of a received
1118 		 * RA, it is called under an interrupt context.  So, we should
1119 		 * call malloc with M_NOWAIT.
1120 		 */
1121 		ia = (struct in6_ifaddr *)ifa_alloc(sizeof(*ia), M_NOWAIT);
1122 		if (ia == NULL)
1123 			return (ENOBUFS);
1124 		LIST_INIT(&ia->ia6_memberships);
1125 		/* Initialize the address and masks, and put time stamp */
1126 		ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr;
1127 		ia->ia_addr.sin6_family = AF_INET6;
1128 		ia->ia_addr.sin6_len = sizeof(ia->ia_addr);
1129 		ia->ia6_createtime = time_uptime;
1130 		if ((ifp->if_flags & (IFF_POINTOPOINT | IFF_LOOPBACK)) != 0) {
1131 			/*
1132 			 * XXX: some functions expect that ifa_dstaddr is not
1133 			 * NULL for p2p interfaces.
1134 			 */
1135 			ia->ia_ifa.ifa_dstaddr =
1136 			    (struct sockaddr *)&ia->ia_dstaddr;
1137 		} else {
1138 			ia->ia_ifa.ifa_dstaddr = NULL;
1139 		}
1140 		ia->ia_ifa.ifa_netmask = (struct sockaddr *)&ia->ia_prefixmask;
1141 		ia->ia_ifp = ifp;
1142 		ifa_ref(&ia->ia_ifa);			/* if_addrhead */
1143 		IF_ADDR_WLOCK(ifp);
1144 		TAILQ_INSERT_TAIL(&ifp->if_addrhead, &ia->ia_ifa, ifa_link);
1145 		IF_ADDR_WUNLOCK(ifp);
1146 
1147 		ifa_ref(&ia->ia_ifa);			/* in6_ifaddrhead */
1148 		IN6_IFADDR_WLOCK();
1149 		TAILQ_INSERT_TAIL(&V_in6_ifaddrhead, ia, ia_link);
1150 		LIST_INSERT_HEAD(IN6ADDR_HASH(&ifra->ifra_addr.sin6_addr),
1151 		    ia, ia6_hash);
1152 		IN6_IFADDR_WUNLOCK();
1153 	}
1154 
1155 	/* update timestamp */
1156 	ia->ia6_updatetime = time_uptime;
1157 
1158 	/* set prefix mask */
1159 	if (ifra->ifra_prefixmask.sin6_len) {
1160 		/*
1161 		 * We prohibit changing the prefix length of an existing
1162 		 * address, because
1163 		 * + such an operation should be rare in IPv6, and
1164 		 * + the operation would confuse prefix management.
1165 		 */
1166 		if (ia->ia_prefixmask.sin6_len &&
1167 		    in6_mask2len(&ia->ia_prefixmask.sin6_addr, NULL) != plen) {
1168 			nd6log((LOG_INFO, "in6_update_ifa: the prefix length of an"
1169 			    " existing (%s) address should not be changed\n",
1170 			    ip6_sprintf(ip6buf, &ia->ia_addr.sin6_addr)));
1171 			error = EINVAL;
1172 			goto unlink;
1173 		}
1174 		ia->ia_prefixmask = ifra->ifra_prefixmask;
1175 		ia->ia_prefixmask.sin6_family = AF_INET6;
1176 	}
1177 
1178 	/*
1179 	 * If a new destination address is specified, scrub the old one and
1180 	 * install the new destination.  Note that the interface must be
1181 	 * p2p or loopback (see the check above.)
1182 	 */
1183 	if (dst6.sin6_family == AF_INET6 &&
1184 	    !IN6_ARE_ADDR_EQUAL(&dst6.sin6_addr, &ia->ia_dstaddr.sin6_addr)) {
1185 		int e;
1186 
1187 		if ((ia->ia_flags & IFA_ROUTE) != 0 &&
1188 		    (e = rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST)) != 0) {
1189 			nd6log((LOG_ERR, "in6_update_ifa: failed to remove "
1190 			    "a route to the old destination: %s\n",
1191 			    ip6_sprintf(ip6buf, &ia->ia_addr.sin6_addr)));
1192 			/* proceed anyway... */
1193 		} else
1194 			ia->ia_flags &= ~IFA_ROUTE;
1195 		ia->ia_dstaddr = dst6;
1196 	}
1197 
1198 	/*
1199 	 * Set lifetimes.  We do not refer to ia6t_expire and ia6t_preferred
1200 	 * to see if the address is deprecated or invalidated, but initialize
1201 	 * these members for applications.
1202 	 */
1203 	ia->ia6_lifetime = ifra->ifra_lifetime;
1204 	if (ia->ia6_lifetime.ia6t_vltime != ND6_INFINITE_LIFETIME) {
1205 		ia->ia6_lifetime.ia6t_expire =
1206 		    time_uptime + ia->ia6_lifetime.ia6t_vltime;
1207 	} else
1208 		ia->ia6_lifetime.ia6t_expire = 0;
1209 	if (ia->ia6_lifetime.ia6t_pltime != ND6_INFINITE_LIFETIME) {
1210 		ia->ia6_lifetime.ia6t_preferred =
1211 		    time_uptime + ia->ia6_lifetime.ia6t_pltime;
1212 	} else
1213 		ia->ia6_lifetime.ia6t_preferred = 0;
1214 
1215 	/* reset the interface and routing table appropriately. */
1216 	if ((error = in6_ifinit(ifp, ia, &ifra->ifra_addr, hostIsNew)) != 0)
1217 		goto unlink;
1218 
1219 	/*
1220 	 * configure address flags.
1221 	 */
1222 	ia->ia6_flags = ifra->ifra_flags;
1223 	/*
1224 	 * backward compatibility - if IN6_IFF_DEPRECATED is set from the
1225 	 * userland, make it deprecated.
1226 	 */
1227 	if ((ifra->ifra_flags & IN6_IFF_DEPRECATED) != 0) {
1228 		ia->ia6_lifetime.ia6t_pltime = 0;
1229 		ia->ia6_lifetime.ia6t_preferred = time_uptime;
1230 	}
1231 	/*
1232 	 * Make the address tentative before joining multicast addresses,
1233 	 * so that corresponding MLD responses would not have a tentative
1234 	 * source address.
1235 	 */
1236 	ia->ia6_flags &= ~IN6_IFF_DUPLICATED;	/* safety */
1237 	if (hostIsNew && in6if_do_dad(ifp))
1238 		ia->ia6_flags |= IN6_IFF_TENTATIVE;
1239 
1240 	/* DAD should be performed after ND6_IFF_IFDISABLED is cleared. */
1241 	if (ND_IFINFO(ifp)->flags & ND6_IFF_IFDISABLED)
1242 		ia->ia6_flags |= IN6_IFF_TENTATIVE;
1243 
1244 	/*
1245 	 * We are done if we have simply modified an existing address.
1246 	 */
1247 	if (!hostIsNew)
1248 		return (error);
1249 
1250 	/*
1251 	 * Beyond this point, we should call in6_purgeaddr upon an error,
1252 	 * not just go to unlink.
1253 	 */
1254 
1255 	/* Join necessary multicast groups. */
1256 	in6m_sol = NULL;
1257 	if ((ifp->if_flags & IFF_MULTICAST) != 0) {
1258 		error = in6_update_ifa_join_mc(ifp, ifra, ia, flags, &in6m_sol);
1259 		if (error)
1260 			goto cleanup;
1261 	}
1262 
1263 	/*
1264 	 * Perform DAD, if needed.
1265 	 * XXX It may be of use, if we can administratively disable DAD.
1266 	 */
1267 	if (in6if_do_dad(ifp) && ((ifra->ifra_flags & IN6_IFF_NODAD) == 0) &&
1268 	    (ia->ia6_flags & IN6_IFF_TENTATIVE))
1269 	{
1270 		int mindelay, maxdelay;
1271 
1272 		delay = 0;
1273 		if ((flags & IN6_IFAUPDATE_DADDELAY)) {
1274 			/*
1275 			 * We need to impose a delay before sending an NS
1276 			 * for DAD.  Check if we also needed a delay for the
1277 			 * corresponding MLD message.  If we did, the delay
1278 			 * should be larger than the MLD delay (this could be
1279 			 * relaxed a bit, but this simple logic is at least
1280 			 * safe).
1281 			 * XXX: Break data hiding guidelines and look at
1282 			 * state for the solicited multicast group.
1283 			 */
1284 			mindelay = 0;
1285 			if (in6m_sol != NULL &&
1286 			    in6m_sol->in6m_state == MLD_REPORTING_MEMBER) {
1287 				mindelay = in6m_sol->in6m_timer;
1288 			}
1289 			maxdelay = MAX_RTR_SOLICITATION_DELAY * hz;
1290 			if (maxdelay - mindelay == 0)
1291 				delay = 0;
1292 			else {
1293 				delay =
1294 				    (arc4random() % (maxdelay - mindelay)) +
1295 				    mindelay;
1296 			}
1297 		}
1298 		nd6_dad_start((struct ifaddr *)ia, delay);
1299 	}
1300 
1301 	KASSERT(hostIsNew, ("in6_update_ifa: !hostIsNew"));
1302 	ifa_free(&ia->ia_ifa);
1303 	return (error);
1304 
1305   unlink:
1306 	/*
1307 	 * XXX: if a change of an existing address failed, keep the entry
1308 	 * anyway.
1309 	 */
1310 	if (hostIsNew) {
1311 		in6_unlink_ifa(ia, ifp);
1312 		ifa_free(&ia->ia_ifa);
1313 	}
1314 	return (error);
1315 
1316   cleanup:
1317 	KASSERT(hostIsNew, ("in6_update_ifa: cleanup: !hostIsNew"));
1318 	ifa_free(&ia->ia_ifa);
1319 	in6_purgeaddr(&ia->ia_ifa);
1320 	return error;
1321 }
1322 
1323 /*
1324  * Leave multicast groups.  Factored out from in6_purgeaddr().
1325  * This entire work should only be done once, for the default FIB.
1326  */
1327 static int
1328 in6_purgeaddr_mc(struct ifnet *ifp, struct in6_ifaddr *ia, struct ifaddr *ifa0)
1329 {
1330 	struct sockaddr_in6 mltaddr, mltmask;
1331 	struct in6_multi_mship *imm;
1332 	struct rtentry *rt;
1333 	struct sockaddr_in6 sin6;
1334 	int error;
1335 
1336 	/*
1337 	 * Leave from multicast groups we have joined for the interface.
1338 	 */
1339 	while ((imm = LIST_FIRST(&ia->ia6_memberships)) != NULL) {
1340 		LIST_REMOVE(imm, i6mm_chain);
1341 		in6_leavegroup(imm);
1342 	}
1343 
1344 	/*
1345 	 * Remove the link-local all-nodes address.
1346 	 */
1347 	bzero(&mltmask, sizeof(mltmask));
1348 	mltmask.sin6_len = sizeof(struct sockaddr_in6);
1349 	mltmask.sin6_family = AF_INET6;
1350 	mltmask.sin6_addr = in6mask32;
1351 
1352 	bzero(&mltaddr, sizeof(mltaddr));
1353 	mltaddr.sin6_len = sizeof(struct sockaddr_in6);
1354 	mltaddr.sin6_family = AF_INET6;
1355 	mltaddr.sin6_addr = in6addr_linklocal_allnodes;
1356 
1357 	if ((error = in6_setscope(&mltaddr.sin6_addr, ifp, NULL)) != 0)
1358 		return (error);
1359 
1360 	/*
1361 	 * As for the mltaddr above, proactively prepare the sin6 to avoid
1362 	 * rtentry un- and re-locking.
1363 	 */
1364 	if (ifa0 != NULL) {
1365 		bzero(&sin6, sizeof(sin6));
1366 		sin6.sin6_len = sizeof(sin6);
1367 		sin6.sin6_family = AF_INET6;
1368 		memcpy(&sin6.sin6_addr, &satosin6(ifa0->ifa_addr)->sin6_addr,
1369 		    sizeof(sin6.sin6_addr));
1370 		error = in6_setscope(&sin6.sin6_addr, ifa0->ifa_ifp, NULL);
1371 		if (error != 0)
1372 			return (error);
1373 	}
1374 
1375 	rt = in6_rtalloc1((struct sockaddr *)&mltaddr, 0, 0UL, RT_DEFAULT_FIB);
1376 	if (rt != NULL && rt->rt_gateway != NULL &&
1377 	    (memcmp(&satosin6(rt->rt_gateway)->sin6_addr,
1378 		    &ia->ia_addr.sin6_addr,
1379 		    sizeof(ia->ia_addr.sin6_addr)) == 0)) {
1380 		/*
1381 		 * If no more IPv6 address exists on this interface then
1382 		 * remove the multicast address route.
1383 		 */
1384 		if (ifa0 == NULL) {
1385 			memcpy(&mltaddr.sin6_addr,
1386 			    &satosin6(rt_key(rt))->sin6_addr,
1387 			    sizeof(mltaddr.sin6_addr));
1388 			RTFREE_LOCKED(rt);
1389 			error = in6_rtrequest(RTM_DELETE,
1390 			    (struct sockaddr *)&mltaddr,
1391 			    (struct sockaddr *)&ia->ia_addr,
1392 			    (struct sockaddr *)&mltmask, RTF_UP,
1393 			    (struct rtentry **)0, RT_DEFAULT_FIB);
1394 			if (error)
1395 				log(LOG_INFO, "%s: link-local all-nodes "
1396 				    "multicast address deletion error\n",
1397 				    __func__);
1398 		} else {
1399 			/*
1400 			 * Replace the gateway of the route.
1401 			 */
1402 			memcpy(rt->rt_gateway, &sin6, sizeof(sin6));
1403 			RTFREE_LOCKED(rt);
1404 		}
1405 	} else {
1406 		if (rt != NULL)
1407 			RTFREE_LOCKED(rt);
1408 	}
1409 
1410 	/*
1411 	 * Remove the node-local all-nodes address.
1412 	 */
1413 	mltaddr.sin6_addr = in6addr_nodelocal_allnodes;
1414 	if ((error = in6_setscope(&mltaddr.sin6_addr, ifp, NULL)) != 0)
1415 		return (error);
1416 
1417 	rt = in6_rtalloc1((struct sockaddr *)&mltaddr, 0, 0UL, RT_DEFAULT_FIB);
1418 	if (rt != NULL && rt->rt_gateway != NULL &&
1419 	    (memcmp(&satosin6(rt->rt_gateway)->sin6_addr,
1420 		    &ia->ia_addr.sin6_addr,
1421 		    sizeof(ia->ia_addr.sin6_addr)) == 0)) {
1422 		/*
1423 		 * If no more IPv6 address exists on this interface then
1424 		 * remove the multicast address route.
1425 		 */
1426 		if (ifa0 == NULL) {
1427 			memcpy(&mltaddr.sin6_addr,
1428 			    &satosin6(rt_key(rt))->sin6_addr,
1429 			    sizeof(mltaddr.sin6_addr));
1430 
1431 			RTFREE_LOCKED(rt);
1432 			error = in6_rtrequest(RTM_DELETE,
1433 			    (struct sockaddr *)&mltaddr,
1434 			    (struct sockaddr *)&ia->ia_addr,
1435 			    (struct sockaddr *)&mltmask, RTF_UP,
1436 			    (struct rtentry **)0, RT_DEFAULT_FIB);
1437 			if (error)
1438 				log(LOG_INFO, "%s: node-local all-nodes"
1439 				    "multicast address deletion error\n",
1440 				    __func__);
1441 		} else {
1442 			/*
1443 			 * Replace the gateway of the route.
1444 			 */
1445 			memcpy(rt->rt_gateway, &sin6, sizeof(sin6));
1446 			RTFREE_LOCKED(rt);
1447 		}
1448 	} else {
1449 		if (rt != NULL)
1450 			RTFREE_LOCKED(rt);
1451 	}
1452 
1453 	return (0);
1454 }
1455 
1456 void
1457 in6_purgeaddr(struct ifaddr *ifa)
1458 {
1459 	struct ifnet *ifp = ifa->ifa_ifp;
1460 	struct in6_ifaddr *ia = (struct in6_ifaddr *) ifa;
1461 	int plen, error;
1462 	struct ifaddr *ifa0;
1463 
1464 	if (ifa->ifa_carp)
1465 		(*carp_detach_p)(ifa);
1466 
1467 	/*
1468 	 * find another IPv6 address as the gateway for the
1469 	 * link-local and node-local all-nodes multicast
1470 	 * address routes
1471 	 */
1472 	IF_ADDR_RLOCK(ifp);
1473 	TAILQ_FOREACH(ifa0, &ifp->if_addrhead, ifa_link) {
1474 		if ((ifa0->ifa_addr->sa_family != AF_INET6) ||
1475 		    memcmp(&satosin6(ifa0->ifa_addr)->sin6_addr,
1476 		    &ia->ia_addr.sin6_addr, sizeof(struct in6_addr)) == 0)
1477 			continue;
1478 		else
1479 			break;
1480 	}
1481 	if (ifa0 != NULL)
1482 		ifa_ref(ifa0);
1483 	IF_ADDR_RUNLOCK(ifp);
1484 
1485 	/*
1486 	 * Remove the loopback route to the interface address.
1487 	 * The check for the current setting of "nd6_useloopback"
1488 	 * is not needed.
1489 	 */
1490 	if (ia->ia_flags & IFA_RTSELF) {
1491 		error = ifa_del_loopback_route((struct ifaddr *)ia,
1492 		    (struct sockaddr *)&ia->ia_addr);
1493 		if (error == 0)
1494 			ia->ia_flags &= ~IFA_RTSELF;
1495 	}
1496 
1497 	/* stop DAD processing */
1498 	nd6_dad_stop(ifa);
1499 
1500 	/* Remove local address entry from lltable. */
1501 	in6_ifremloop(ifa);
1502 
1503 	/* Leave multicast groups. */
1504 	error = in6_purgeaddr_mc(ifp, ia, ifa0);
1505 
1506 	if (ifa0 != NULL)
1507 		ifa_free(ifa0);
1508 
1509 	plen = in6_mask2len(&ia->ia_prefixmask.sin6_addr, NULL); /* XXX */
1510 	if ((ia->ia_flags & IFA_ROUTE) && plen == 128) {
1511 		error = rtinit(&(ia->ia_ifa), RTM_DELETE, ia->ia_flags |
1512 		    (ia->ia_dstaddr.sin6_family == AF_INET6) ? RTF_HOST : 0);
1513 		if (error != 0)
1514 			log(LOG_INFO, "%s: err=%d, destination address delete "
1515 			    "failed\n", __func__, error);
1516 		ia->ia_flags &= ~IFA_ROUTE;
1517 	}
1518 
1519 	in6_unlink_ifa(ia, ifp);
1520 }
1521 
1522 static void
1523 in6_unlink_ifa(struct in6_ifaddr *ia, struct ifnet *ifp)
1524 {
1525 
1526 	IF_ADDR_WLOCK(ifp);
1527 	TAILQ_REMOVE(&ifp->if_addrhead, &ia->ia_ifa, ifa_link);
1528 	IF_ADDR_WUNLOCK(ifp);
1529 	ifa_free(&ia->ia_ifa);			/* if_addrhead */
1530 
1531 	/*
1532 	 * Defer the release of what might be the last reference to the
1533 	 * in6_ifaddr so that it can't be freed before the remainder of the
1534 	 * cleanup.
1535 	 */
1536 	IN6_IFADDR_WLOCK();
1537 	TAILQ_REMOVE(&V_in6_ifaddrhead, ia, ia_link);
1538 	LIST_REMOVE(ia, ia6_hash);
1539 	IN6_IFADDR_WUNLOCK();
1540 
1541 	/*
1542 	 * Release the reference to the base prefix.  There should be a
1543 	 * positive reference.
1544 	 */
1545 	if (ia->ia6_ndpr == NULL) {
1546 		nd6log((LOG_NOTICE,
1547 		    "in6_unlink_ifa: autoconf'ed address "
1548 		    "%p has no prefix\n", ia));
1549 	} else {
1550 		ia->ia6_ndpr->ndpr_refcnt--;
1551 		ia->ia6_ndpr = NULL;
1552 	}
1553 
1554 	/*
1555 	 * Also, if the address being removed is autoconf'ed, call
1556 	 * pfxlist_onlink_check() since the release might affect the status of
1557 	 * other (detached) addresses.
1558 	 */
1559 	if ((ia->ia6_flags & IN6_IFF_AUTOCONF)) {
1560 		pfxlist_onlink_check();
1561 	}
1562 	ifa_free(&ia->ia_ifa);			/* in6_ifaddrhead */
1563 }
1564 
1565 void
1566 in6_purgeif(struct ifnet *ifp)
1567 {
1568 	struct ifaddr *ifa, *nifa;
1569 
1570 	TAILQ_FOREACH_SAFE(ifa, &ifp->if_addrhead, ifa_link, nifa) {
1571 		if (ifa->ifa_addr->sa_family != AF_INET6)
1572 			continue;
1573 		in6_purgeaddr(ifa);
1574 	}
1575 
1576 	in6_ifdetach(ifp);
1577 }
1578 
1579 /*
1580  * Initialize an interface's IPv6 address and routing table entry.
1581  */
1582 static int
1583 in6_ifinit(struct ifnet *ifp, struct in6_ifaddr *ia,
1584     struct sockaddr_in6 *sin6, int newhost)
1585 {
1586 	int	error = 0, plen, ifacount = 0;
1587 	struct ifaddr *ifa;
1588 
1589 	/*
1590 	 * Give the interface a chance to initialize
1591 	 * if this is its first address,
1592 	 * and to validate the address if necessary.
1593 	 */
1594 	IF_ADDR_RLOCK(ifp);
1595 	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1596 		if (ifa->ifa_addr->sa_family != AF_INET6)
1597 			continue;
1598 		ifacount++;
1599 	}
1600 	IF_ADDR_RUNLOCK(ifp);
1601 
1602 	ia->ia_addr = *sin6;
1603 
1604 	if (ifacount <= 1 && ifp->if_ioctl) {
1605 		error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)ia);
1606 		if (error)
1607 			return (error);
1608 	}
1609 
1610 	ia->ia_ifa.ifa_metric = ifp->if_metric;
1611 
1612 	/* we could do in(6)_socktrim here, but just omit it at this moment. */
1613 
1614 	/*
1615 	 * Special case:
1616 	 * If a new destination address is specified for a point-to-point
1617 	 * interface, install a route to the destination as an interface
1618 	 * direct route.
1619 	 * XXX: the logic below rejects assigning multiple addresses on a p2p
1620 	 * interface that share the same destination.
1621 	 */
1622 	plen = in6_mask2len(&ia->ia_prefixmask.sin6_addr, NULL); /* XXX */
1623 	if (!(ia->ia_flags & IFA_ROUTE) && plen == 128 &&
1624 	    ia->ia_dstaddr.sin6_family == AF_INET6) {
1625 		int rtflags = RTF_UP | RTF_HOST;
1626 		error = rtinit(&ia->ia_ifa, RTM_ADD, ia->ia_flags | rtflags);
1627 		if (error)
1628 			return (error);
1629 		ia->ia_flags |= IFA_ROUTE;
1630 		/*
1631 		 * Handle the case for ::1 .
1632 		 */
1633 		if (ifp->if_flags & IFF_LOOPBACK)
1634 			ia->ia_flags |= IFA_RTSELF;
1635 	}
1636 
1637 	/*
1638 	 * add a loopback route to self
1639 	 */
1640 	if (!(ia->ia_flags & IFA_RTSELF) && V_nd6_useloopback) {
1641 		error = ifa_add_loopback_route((struct ifaddr *)ia,
1642 		    (struct sockaddr *)&ia->ia_addr);
1643 		if (error == 0)
1644 			ia->ia_flags |= IFA_RTSELF;
1645 	}
1646 
1647 	/* Add local address to lltable, if necessary (ex. on p2p link). */
1648 	if (newhost)
1649 		in6_ifaddloop(&(ia->ia_ifa));
1650 
1651 	return (error);
1652 }
1653 
1654 /*
1655  * Find an IPv6 interface link-local address specific to an interface.
1656  * ifaddr is returned referenced.
1657  */
1658 struct in6_ifaddr *
1659 in6ifa_ifpforlinklocal(struct ifnet *ifp, int ignoreflags)
1660 {
1661 	struct ifaddr *ifa;
1662 
1663 	IF_ADDR_RLOCK(ifp);
1664 	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1665 		if (ifa->ifa_addr->sa_family != AF_INET6)
1666 			continue;
1667 		if (IN6_IS_ADDR_LINKLOCAL(IFA_IN6(ifa))) {
1668 			if ((((struct in6_ifaddr *)ifa)->ia6_flags &
1669 			    ignoreflags) != 0)
1670 				continue;
1671 			ifa_ref(ifa);
1672 			break;
1673 		}
1674 	}
1675 	IF_ADDR_RUNLOCK(ifp);
1676 
1677 	return ((struct in6_ifaddr *)ifa);
1678 }
1679 
1680 
1681 /*
1682  * find the internet address corresponding to a given interface and address.
1683  * ifaddr is returned referenced.
1684  */
1685 struct in6_ifaddr *
1686 in6ifa_ifpwithaddr(struct ifnet *ifp, struct in6_addr *addr)
1687 {
1688 	struct ifaddr *ifa;
1689 
1690 	IF_ADDR_RLOCK(ifp);
1691 	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1692 		if (ifa->ifa_addr->sa_family != AF_INET6)
1693 			continue;
1694 		if (IN6_ARE_ADDR_EQUAL(addr, IFA_IN6(ifa))) {
1695 			ifa_ref(ifa);
1696 			break;
1697 		}
1698 	}
1699 	IF_ADDR_RUNLOCK(ifp);
1700 
1701 	return ((struct in6_ifaddr *)ifa);
1702 }
1703 
1704 /*
1705  * Find a link-local scoped address on ifp and return it if any.
1706  */
1707 struct in6_ifaddr *
1708 in6ifa_llaonifp(struct ifnet *ifp)
1709 {
1710 	struct sockaddr_in6 *sin6;
1711 	struct ifaddr *ifa;
1712 
1713 	if (ND_IFINFO(ifp)->flags & ND6_IFF_IFDISABLED)
1714 		return (NULL);
1715 	if_addr_rlock(ifp);
1716 	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1717 		if (ifa->ifa_addr->sa_family != AF_INET6)
1718 			continue;
1719 		sin6 = (struct sockaddr_in6 *)ifa->ifa_addr;
1720 		if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr) ||
1721 		    IN6_IS_ADDR_MC_INTFACELOCAL(&sin6->sin6_addr) ||
1722 		    IN6_IS_ADDR_MC_NODELOCAL(&sin6->sin6_addr))
1723 			break;
1724 	}
1725 	if_addr_runlock(ifp);
1726 
1727 	return ((struct in6_ifaddr *)ifa);
1728 }
1729 
1730 /*
1731  * Convert IP6 address to printable (loggable) representation. Caller
1732  * has to make sure that ip6buf is at least INET6_ADDRSTRLEN long.
1733  */
1734 static char digits[] = "0123456789abcdef";
1735 char *
1736 ip6_sprintf(char *ip6buf, const struct in6_addr *addr)
1737 {
1738 	int i, cnt = 0, maxcnt = 0, idx = 0, index = 0;
1739 	char *cp;
1740 	const u_int16_t *a = (const u_int16_t *)addr;
1741 	const u_int8_t *d;
1742 	int dcolon = 0, zero = 0;
1743 
1744 	cp = ip6buf;
1745 
1746 	for (i = 0; i < 8; i++) {
1747 		if (*(a + i) == 0) {
1748 			cnt++;
1749 			if (cnt == 1)
1750 				idx = i;
1751 		}
1752 		else if (maxcnt < cnt) {
1753 			maxcnt = cnt;
1754 			index = idx;
1755 			cnt = 0;
1756 		}
1757 	}
1758 	if (maxcnt < cnt) {
1759 		maxcnt = cnt;
1760 		index = idx;
1761 	}
1762 
1763 	for (i = 0; i < 8; i++) {
1764 		if (dcolon == 1) {
1765 			if (*a == 0) {
1766 				if (i == 7)
1767 					*cp++ = ':';
1768 				a++;
1769 				continue;
1770 			} else
1771 				dcolon = 2;
1772 		}
1773 		if (*a == 0) {
1774 			if (dcolon == 0 && *(a + 1) == 0 && i == index) {
1775 				if (i == 0)
1776 					*cp++ = ':';
1777 				*cp++ = ':';
1778 				dcolon = 1;
1779 			} else {
1780 				*cp++ = '0';
1781 				*cp++ = ':';
1782 			}
1783 			a++;
1784 			continue;
1785 		}
1786 		d = (const u_char *)a;
1787 		/* Try to eliminate leading zeros in printout like in :0001. */
1788 		zero = 1;
1789 		*cp = digits[*d >> 4];
1790 		if (*cp != '0') {
1791 			zero = 0;
1792 			cp++;
1793 		}
1794 		*cp = digits[*d++ & 0xf];
1795 		if (zero == 0 || (*cp != '0')) {
1796 			zero = 0;
1797 			cp++;
1798 		}
1799 		*cp = digits[*d >> 4];
1800 		if (zero == 0 || (*cp != '0')) {
1801 			zero = 0;
1802 			cp++;
1803 		}
1804 		*cp++ = digits[*d & 0xf];
1805 		*cp++ = ':';
1806 		a++;
1807 	}
1808 	*--cp = '\0';
1809 	return (ip6buf);
1810 }
1811 
1812 int
1813 in6_localaddr(struct in6_addr *in6)
1814 {
1815 	struct in6_ifaddr *ia;
1816 
1817 	if (IN6_IS_ADDR_LOOPBACK(in6) || IN6_IS_ADDR_LINKLOCAL(in6))
1818 		return 1;
1819 
1820 	IN6_IFADDR_RLOCK();
1821 	TAILQ_FOREACH(ia, &V_in6_ifaddrhead, ia_link) {
1822 		if (IN6_ARE_MASKED_ADDR_EQUAL(in6, &ia->ia_addr.sin6_addr,
1823 		    &ia->ia_prefixmask.sin6_addr)) {
1824 			IN6_IFADDR_RUNLOCK();
1825 			return 1;
1826 		}
1827 	}
1828 	IN6_IFADDR_RUNLOCK();
1829 
1830 	return (0);
1831 }
1832 
1833 /*
1834  * Return 1 if an internet address is for the local host and configured
1835  * on one of its interfaces.
1836  */
1837 int
1838 in6_localip(struct in6_addr *in6)
1839 {
1840 	struct in6_ifaddr *ia;
1841 
1842 	IN6_IFADDR_RLOCK();
1843 	LIST_FOREACH(ia, IN6ADDR_HASH(in6), ia6_hash) {
1844 		if (IN6_ARE_ADDR_EQUAL(in6, &ia->ia_addr.sin6_addr)) {
1845 			IN6_IFADDR_RUNLOCK();
1846 			return (1);
1847 		}
1848 	}
1849 	IN6_IFADDR_RUNLOCK();
1850 	return (0);
1851 }
1852 
1853 int
1854 in6_is_addr_deprecated(struct sockaddr_in6 *sa6)
1855 {
1856 	struct in6_ifaddr *ia;
1857 
1858 	IN6_IFADDR_RLOCK();
1859 	LIST_FOREACH(ia, IN6ADDR_HASH(&sa6->sin6_addr), ia6_hash) {
1860 		if (IN6_ARE_ADDR_EQUAL(IA6_IN6(ia), &sa6->sin6_addr)) {
1861 			if (ia->ia6_flags & IN6_IFF_DEPRECATED) {
1862 				IN6_IFADDR_RUNLOCK();
1863 				return (1); /* true */
1864 			}
1865 			break;
1866 		}
1867 	}
1868 	IN6_IFADDR_RUNLOCK();
1869 
1870 	return (0);		/* false */
1871 }
1872 
1873 /*
1874  * return length of part which dst and src are equal
1875  * hard coding...
1876  */
1877 int
1878 in6_matchlen(struct in6_addr *src, struct in6_addr *dst)
1879 {
1880 	int match = 0;
1881 	u_char *s = (u_char *)src, *d = (u_char *)dst;
1882 	u_char *lim = s + 16, r;
1883 
1884 	while (s < lim)
1885 		if ((r = (*d++ ^ *s++)) != 0) {
1886 			while (r < 128) {
1887 				match++;
1888 				r <<= 1;
1889 			}
1890 			break;
1891 		} else
1892 			match += 8;
1893 	return match;
1894 }
1895 
1896 /* XXX: to be scope conscious */
1897 int
1898 in6_are_prefix_equal(struct in6_addr *p1, struct in6_addr *p2, int len)
1899 {
1900 	int bytelen, bitlen;
1901 
1902 	/* sanity check */
1903 	if (0 > len || len > 128) {
1904 		log(LOG_ERR, "in6_are_prefix_equal: invalid prefix length(%d)\n",
1905 		    len);
1906 		return (0);
1907 	}
1908 
1909 	bytelen = len / 8;
1910 	bitlen = len % 8;
1911 
1912 	if (bcmp(&p1->s6_addr, &p2->s6_addr, bytelen))
1913 		return (0);
1914 	if (bitlen != 0 &&
1915 	    p1->s6_addr[bytelen] >> (8 - bitlen) !=
1916 	    p2->s6_addr[bytelen] >> (8 - bitlen))
1917 		return (0);
1918 
1919 	return (1);
1920 }
1921 
1922 void
1923 in6_prefixlen2mask(struct in6_addr *maskp, int len)
1924 {
1925 	u_char maskarray[8] = {0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff};
1926 	int bytelen, bitlen, i;
1927 
1928 	/* sanity check */
1929 	if (0 > len || len > 128) {
1930 		log(LOG_ERR, "in6_prefixlen2mask: invalid prefix length(%d)\n",
1931 		    len);
1932 		return;
1933 	}
1934 
1935 	bzero(maskp, sizeof(*maskp));
1936 	bytelen = len / 8;
1937 	bitlen = len % 8;
1938 	for (i = 0; i < bytelen; i++)
1939 		maskp->s6_addr[i] = 0xff;
1940 	if (bitlen)
1941 		maskp->s6_addr[bytelen] = maskarray[bitlen - 1];
1942 }
1943 
1944 /*
1945  * return the best address out of the same scope. if no address was
1946  * found, return the first valid address from designated IF.
1947  */
1948 struct in6_ifaddr *
1949 in6_ifawithifp(struct ifnet *ifp, struct in6_addr *dst)
1950 {
1951 	int dst_scope =	in6_addrscope(dst), blen = -1, tlen;
1952 	struct ifaddr *ifa;
1953 	struct in6_ifaddr *besta = 0;
1954 	struct in6_ifaddr *dep[2];	/* last-resort: deprecated */
1955 
1956 	dep[0] = dep[1] = NULL;
1957 
1958 	/*
1959 	 * We first look for addresses in the same scope.
1960 	 * If there is one, return it.
1961 	 * If two or more, return one which matches the dst longest.
1962 	 * If none, return one of global addresses assigned other ifs.
1963 	 */
1964 	IF_ADDR_RLOCK(ifp);
1965 	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1966 		if (ifa->ifa_addr->sa_family != AF_INET6)
1967 			continue;
1968 		if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_ANYCAST)
1969 			continue; /* XXX: is there any case to allow anycast? */
1970 		if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_NOTREADY)
1971 			continue; /* don't use this interface */
1972 		if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_DETACHED)
1973 			continue;
1974 		if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_DEPRECATED) {
1975 			if (V_ip6_use_deprecated)
1976 				dep[0] = (struct in6_ifaddr *)ifa;
1977 			continue;
1978 		}
1979 
1980 		if (dst_scope == in6_addrscope(IFA_IN6(ifa))) {
1981 			/*
1982 			 * call in6_matchlen() as few as possible
1983 			 */
1984 			if (besta) {
1985 				if (blen == -1)
1986 					blen = in6_matchlen(&besta->ia_addr.sin6_addr, dst);
1987 				tlen = in6_matchlen(IFA_IN6(ifa), dst);
1988 				if (tlen > blen) {
1989 					blen = tlen;
1990 					besta = (struct in6_ifaddr *)ifa;
1991 				}
1992 			} else
1993 				besta = (struct in6_ifaddr *)ifa;
1994 		}
1995 	}
1996 	if (besta) {
1997 		ifa_ref(&besta->ia_ifa);
1998 		IF_ADDR_RUNLOCK(ifp);
1999 		return (besta);
2000 	}
2001 
2002 	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
2003 		if (ifa->ifa_addr->sa_family != AF_INET6)
2004 			continue;
2005 		if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_ANYCAST)
2006 			continue; /* XXX: is there any case to allow anycast? */
2007 		if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_NOTREADY)
2008 			continue; /* don't use this interface */
2009 		if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_DETACHED)
2010 			continue;
2011 		if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_DEPRECATED) {
2012 			if (V_ip6_use_deprecated)
2013 				dep[1] = (struct in6_ifaddr *)ifa;
2014 			continue;
2015 		}
2016 
2017 		if (ifa != NULL)
2018 			ifa_ref(ifa);
2019 		IF_ADDR_RUNLOCK(ifp);
2020 		return (struct in6_ifaddr *)ifa;
2021 	}
2022 
2023 	/* use the last-resort values, that are, deprecated addresses */
2024 	if (dep[0]) {
2025 		ifa_ref((struct ifaddr *)dep[0]);
2026 		IF_ADDR_RUNLOCK(ifp);
2027 		return dep[0];
2028 	}
2029 	if (dep[1]) {
2030 		ifa_ref((struct ifaddr *)dep[1]);
2031 		IF_ADDR_RUNLOCK(ifp);
2032 		return dep[1];
2033 	}
2034 
2035 	IF_ADDR_RUNLOCK(ifp);
2036 	return NULL;
2037 }
2038 
2039 /*
2040  * perform DAD when interface becomes IFF_UP.
2041  */
2042 void
2043 in6_if_up(struct ifnet *ifp)
2044 {
2045 	struct ifaddr *ifa;
2046 	struct in6_ifaddr *ia;
2047 
2048 	IF_ADDR_RLOCK(ifp);
2049 	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
2050 		if (ifa->ifa_addr->sa_family != AF_INET6)
2051 			continue;
2052 		ia = (struct in6_ifaddr *)ifa;
2053 		if (ia->ia6_flags & IN6_IFF_TENTATIVE) {
2054 			/*
2055 			 * The TENTATIVE flag was likely set by hand
2056 			 * beforehand, implicitly indicating the need for DAD.
2057 			 * We may be able to skip the random delay in this
2058 			 * case, but we impose delays just in case.
2059 			 */
2060 			nd6_dad_start(ifa,
2061 			    arc4random() % (MAX_RTR_SOLICITATION_DELAY * hz));
2062 		}
2063 	}
2064 	IF_ADDR_RUNLOCK(ifp);
2065 
2066 	/*
2067 	 * special cases, like 6to4, are handled in in6_ifattach
2068 	 */
2069 	in6_ifattach(ifp, NULL);
2070 }
2071 
2072 int
2073 in6if_do_dad(struct ifnet *ifp)
2074 {
2075 	if ((ifp->if_flags & IFF_LOOPBACK) != 0)
2076 		return (0);
2077 
2078 	if (ND_IFINFO(ifp)->flags & ND6_IFF_IFDISABLED)
2079 		return (0);
2080 
2081 	switch (ifp->if_type) {
2082 #ifdef IFT_DUMMY
2083 	case IFT_DUMMY:
2084 #endif
2085 	case IFT_FAITH:
2086 		/*
2087 		 * These interfaces do not have the IFF_LOOPBACK flag,
2088 		 * but loop packets back.  We do not have to do DAD on such
2089 		 * interfaces.  We should even omit it, because loop-backed
2090 		 * NS would confuse the DAD procedure.
2091 		 */
2092 		return (0);
2093 	default:
2094 		/*
2095 		 * Our DAD routine requires the interface up and running.
2096 		 * However, some interfaces can be up before the RUNNING
2097 		 * status.  Additionaly, users may try to assign addresses
2098 		 * before the interface becomes up (or running).
2099 		 * We simply skip DAD in such a case as a work around.
2100 		 * XXX: we should rather mark "tentative" on such addresses,
2101 		 * and do DAD after the interface becomes ready.
2102 		 */
2103 		if (!((ifp->if_flags & IFF_UP) &&
2104 		    (ifp->if_drv_flags & IFF_DRV_RUNNING)))
2105 			return (0);
2106 
2107 		return (1);
2108 	}
2109 }
2110 
2111 /*
2112  * Calculate max IPv6 MTU through all the interfaces and store it
2113  * to in6_maxmtu.
2114  */
2115 void
2116 in6_setmaxmtu(void)
2117 {
2118 	unsigned long maxmtu = 0;
2119 	struct ifnet *ifp;
2120 
2121 	IFNET_RLOCK_NOSLEEP();
2122 	TAILQ_FOREACH(ifp, &V_ifnet, if_list) {
2123 		/* this function can be called during ifnet initialization */
2124 		if (!ifp->if_afdata[AF_INET6])
2125 			continue;
2126 		if ((ifp->if_flags & IFF_LOOPBACK) == 0 &&
2127 		    IN6_LINKMTU(ifp) > maxmtu)
2128 			maxmtu = IN6_LINKMTU(ifp);
2129 	}
2130 	IFNET_RUNLOCK_NOSLEEP();
2131 	if (maxmtu)	/* update only when maxmtu is positive */
2132 		V_in6_maxmtu = maxmtu;
2133 }
2134 
2135 /*
2136  * Provide the length of interface identifiers to be used for the link attached
2137  * to the given interface.  The length should be defined in "IPv6 over
2138  * xxx-link" document.  Note that address architecture might also define
2139  * the length for a particular set of address prefixes, regardless of the
2140  * link type.  As clarified in rfc2462bis, those two definitions should be
2141  * consistent, and those really are as of August 2004.
2142  */
2143 int
2144 in6_if2idlen(struct ifnet *ifp)
2145 {
2146 	switch (ifp->if_type) {
2147 	case IFT_ETHER:		/* RFC2464 */
2148 #ifdef IFT_PROPVIRTUAL
2149 	case IFT_PROPVIRTUAL:	/* XXX: no RFC. treat it as ether */
2150 #endif
2151 #ifdef IFT_L2VLAN
2152 	case IFT_L2VLAN:	/* ditto */
2153 #endif
2154 #ifdef IFT_IEEE80211
2155 	case IFT_IEEE80211:	/* ditto */
2156 #endif
2157 #ifdef IFT_MIP
2158 	case IFT_MIP:	/* ditto */
2159 #endif
2160 	case IFT_INFINIBAND:
2161 		return (64);
2162 	case IFT_FDDI:		/* RFC2467 */
2163 		return (64);
2164 	case IFT_ISO88025:	/* RFC2470 (IPv6 over Token Ring) */
2165 		return (64);
2166 	case IFT_PPP:		/* RFC2472 */
2167 		return (64);
2168 	case IFT_ARCNET:	/* RFC2497 */
2169 		return (64);
2170 	case IFT_FRELAY:	/* RFC2590 */
2171 		return (64);
2172 	case IFT_IEEE1394:	/* RFC3146 */
2173 		return (64);
2174 	case IFT_GIF:
2175 		return (64);	/* draft-ietf-v6ops-mech-v2-07 */
2176 	case IFT_LOOP:
2177 		return (64);	/* XXX: is this really correct? */
2178 	default:
2179 		/*
2180 		 * Unknown link type:
2181 		 * It might be controversial to use the today's common constant
2182 		 * of 64 for these cases unconditionally.  For full compliance,
2183 		 * we should return an error in this case.  On the other hand,
2184 		 * if we simply miss the standard for the link type or a new
2185 		 * standard is defined for a new link type, the IFID length
2186 		 * is very likely to be the common constant.  As a compromise,
2187 		 * we always use the constant, but make an explicit notice
2188 		 * indicating the "unknown" case.
2189 		 */
2190 		printf("in6_if2idlen: unknown link type (%d)\n", ifp->if_type);
2191 		return (64);
2192 	}
2193 }
2194 
2195 #include <sys/sysctl.h>
2196 
2197 struct in6_llentry {
2198 	struct llentry		base;
2199 	struct sockaddr_in6	l3_addr6;
2200 };
2201 
2202 /*
2203  * Deletes an address from the address table.
2204  * This function is called by the timer functions
2205  * such as arptimer() and nd6_llinfo_timer(), and
2206  * the caller does the locking.
2207  */
2208 static void
2209 in6_lltable_free(struct lltable *llt, struct llentry *lle)
2210 {
2211 	LLE_WUNLOCK(lle);
2212 	LLE_LOCK_DESTROY(lle);
2213 	free(lle, M_LLTABLE);
2214 }
2215 
2216 static struct llentry *
2217 in6_lltable_new(const struct sockaddr *l3addr, u_int flags)
2218 {
2219 	struct in6_llentry *lle;
2220 
2221 	lle = malloc(sizeof(struct in6_llentry), M_LLTABLE, M_NOWAIT | M_ZERO);
2222 	if (lle == NULL)		/* NB: caller generates msg */
2223 		return NULL;
2224 
2225 	lle->l3_addr6 = *(const struct sockaddr_in6 *)l3addr;
2226 	lle->base.lle_refcnt = 1;
2227 	lle->base.lle_free = in6_lltable_free;
2228 	LLE_LOCK_INIT(&lle->base);
2229 	callout_init_rw(&lle->base.ln_timer_ch, &lle->base.lle_lock,
2230 	    CALLOUT_RETURNUNLOCKED);
2231 
2232 	return (&lle->base);
2233 }
2234 
2235 static void
2236 in6_lltable_prefix_free(struct lltable *llt, const struct sockaddr *prefix,
2237     const struct sockaddr *mask, u_int flags)
2238 {
2239 	const struct sockaddr_in6 *pfx = (const struct sockaddr_in6 *)prefix;
2240 	const struct sockaddr_in6 *msk = (const struct sockaddr_in6 *)mask;
2241 	struct llentry *lle, *next;
2242 	int i;
2243 
2244 	/*
2245 	 * (flags & LLE_STATIC) means deleting all entries
2246 	 * including static ND6 entries.
2247 	 */
2248 	IF_AFDATA_WLOCK(llt->llt_ifp);
2249 	for (i = 0; i < LLTBL_HASHTBL_SIZE; i++) {
2250 		LIST_FOREACH_SAFE(lle, &llt->lle_head[i], lle_next, next) {
2251 			if (IN6_ARE_MASKED_ADDR_EQUAL(
2252 			    &satosin6(L3_ADDR(lle))->sin6_addr,
2253 			    &pfx->sin6_addr, &msk->sin6_addr) &&
2254 			    ((flags & LLE_STATIC) ||
2255 			    !(lle->la_flags & LLE_STATIC))) {
2256 				LLE_WLOCK(lle);
2257 				if (callout_stop(&lle->la_timer))
2258 					LLE_REMREF(lle);
2259 				llentry_free(lle);
2260 			}
2261 		}
2262 	}
2263 	IF_AFDATA_WUNLOCK(llt->llt_ifp);
2264 }
2265 
2266 static int
2267 in6_lltable_rtcheck(struct ifnet *ifp,
2268 		    u_int flags,
2269 		    const struct sockaddr *l3addr)
2270 {
2271 	struct rtentry *rt;
2272 	char ip6buf[INET6_ADDRSTRLEN];
2273 
2274 	KASSERT(l3addr->sa_family == AF_INET6,
2275 	    ("sin_family %d", l3addr->sa_family));
2276 
2277 	/* Our local addresses are always only installed on the default FIB. */
2278 	/* XXX rtalloc1 should take a const param */
2279 	rt = in6_rtalloc1(__DECONST(struct sockaddr *, l3addr), 0, 0,
2280 	    RT_DEFAULT_FIB);
2281 	if (rt == NULL || (rt->rt_flags & RTF_GATEWAY) || rt->rt_ifp != ifp) {
2282 		struct ifaddr *ifa;
2283 		/*
2284 		 * Create an ND6 cache for an IPv6 neighbor
2285 		 * that is not covered by our own prefix.
2286 		 */
2287 		/* XXX ifaof_ifpforaddr should take a const param */
2288 		ifa = ifaof_ifpforaddr(__DECONST(struct sockaddr *, l3addr), ifp);
2289 		if (ifa != NULL) {
2290 			ifa_free(ifa);
2291 			if (rt != NULL)
2292 				RTFREE_LOCKED(rt);
2293 			return 0;
2294 		}
2295 		log(LOG_INFO, "IPv6 address: \"%s\" is not on the network\n",
2296 		    ip6_sprintf(ip6buf, &((const struct sockaddr_in6 *)l3addr)->sin6_addr));
2297 		if (rt != NULL)
2298 			RTFREE_LOCKED(rt);
2299 		return EINVAL;
2300 	}
2301 	RTFREE_LOCKED(rt);
2302 	return 0;
2303 }
2304 
2305 static struct llentry *
2306 in6_lltable_lookup(struct lltable *llt, u_int flags,
2307 	const struct sockaddr *l3addr)
2308 {
2309 	const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)l3addr;
2310 	struct ifnet *ifp = llt->llt_ifp;
2311 	struct llentry *lle;
2312 	struct llentries *lleh;
2313 	u_int hashkey;
2314 
2315 	IF_AFDATA_LOCK_ASSERT(ifp);
2316 	KASSERT(l3addr->sa_family == AF_INET6,
2317 	    ("sin_family %d", l3addr->sa_family));
2318 
2319 	hashkey = sin6->sin6_addr.s6_addr32[3];
2320 	lleh = &llt->lle_head[LLATBL_HASH(hashkey, LLTBL_HASHMASK)];
2321 	LIST_FOREACH(lle, lleh, lle_next) {
2322 		struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)L3_ADDR(lle);
2323 		if (lle->la_flags & LLE_DELETED)
2324 			continue;
2325 		if (bcmp(&sa6->sin6_addr, &sin6->sin6_addr,
2326 		    sizeof(struct in6_addr)) == 0)
2327 			break;
2328 	}
2329 
2330 	if (lle == NULL) {
2331 		if (!(flags & LLE_CREATE))
2332 			return (NULL);
2333 		IF_AFDATA_WLOCK_ASSERT(ifp);
2334 		/*
2335 		 * A route that covers the given address must have
2336 		 * been installed 1st because we are doing a resolution,
2337 		 * verify this.
2338 		 */
2339 		if (!(flags & LLE_IFADDR) &&
2340 		    in6_lltable_rtcheck(ifp, flags, l3addr) != 0)
2341 			return NULL;
2342 
2343 		lle = in6_lltable_new(l3addr, flags);
2344 		if (lle == NULL) {
2345 			log(LOG_INFO, "lla_lookup: new lle malloc failed\n");
2346 			return NULL;
2347 		}
2348 		lle->la_flags = flags & ~LLE_CREATE;
2349 		if ((flags & (LLE_CREATE | LLE_IFADDR)) == (LLE_CREATE | LLE_IFADDR)) {
2350 			bcopy(IF_LLADDR(ifp), &lle->ll_addr, ifp->if_addrlen);
2351 			lle->la_flags |= (LLE_VALID | LLE_STATIC);
2352 		}
2353 
2354 		lle->lle_tbl  = llt;
2355 		lle->lle_head = lleh;
2356 		lle->la_flags |= LLE_LINKED;
2357 		LIST_INSERT_HEAD(lleh, lle, lle_next);
2358 	} else if (flags & LLE_DELETE) {
2359 		if (!(lle->la_flags & LLE_IFADDR) || (flags & LLE_IFADDR)) {
2360 			LLE_WLOCK(lle);
2361 			lle->la_flags |= LLE_DELETED;
2362 #ifdef DIAGNOSTIC
2363 			log(LOG_INFO, "ifaddr cache = %p is deleted\n", lle);
2364 #endif
2365 			if ((lle->la_flags &
2366 			    (LLE_STATIC | LLE_IFADDR)) == LLE_STATIC)
2367 				llentry_free(lle);
2368 			else
2369 				LLE_WUNLOCK(lle);
2370 		}
2371 		lle = (void *)-1;
2372 	}
2373 	if (LLE_IS_VALID(lle)) {
2374 		if (flags & LLE_EXCLUSIVE)
2375 			LLE_WLOCK(lle);
2376 		else
2377 			LLE_RLOCK(lle);
2378 	}
2379 	return (lle);
2380 }
2381 
2382 static int
2383 in6_lltable_dump(struct lltable *llt, struct sysctl_req *wr)
2384 {
2385 	struct ifnet *ifp = llt->llt_ifp;
2386 	struct llentry *lle;
2387 	/* XXX stack use */
2388 	struct {
2389 		struct rt_msghdr	rtm;
2390 		struct sockaddr_in6	sin6;
2391 		/*
2392 		 * ndp.c assumes that sdl is word aligned
2393 		 */
2394 #ifdef __LP64__
2395 		uint32_t		pad;
2396 #endif
2397 		struct sockaddr_dl	sdl;
2398 	} ndpc;
2399 	int i, error;
2400 
2401 	if (ifp->if_flags & IFF_LOOPBACK)
2402 		return 0;
2403 
2404 	LLTABLE_LOCK_ASSERT();
2405 
2406 	error = 0;
2407 	for (i = 0; i < LLTBL_HASHTBL_SIZE; i++) {
2408 		LIST_FOREACH(lle, &llt->lle_head[i], lle_next) {
2409 			struct sockaddr_dl *sdl;
2410 
2411 			/* skip deleted or invalid entries */
2412 			if ((lle->la_flags & (LLE_DELETED|LLE_VALID)) != LLE_VALID)
2413 				continue;
2414 			/* Skip if jailed and not a valid IP of the prison. */
2415 			if (prison_if(wr->td->td_ucred, L3_ADDR(lle)) != 0)
2416 				continue;
2417 			/*
2418 			 * produce a msg made of:
2419 			 *  struct rt_msghdr;
2420 			 *  struct sockaddr_in6 (IPv6)
2421 			 *  struct sockaddr_dl;
2422 			 */
2423 			bzero(&ndpc, sizeof(ndpc));
2424 			ndpc.rtm.rtm_msglen = sizeof(ndpc);
2425 			ndpc.rtm.rtm_version = RTM_VERSION;
2426 			ndpc.rtm.rtm_type = RTM_GET;
2427 			ndpc.rtm.rtm_flags = RTF_UP;
2428 			ndpc.rtm.rtm_addrs = RTA_DST | RTA_GATEWAY;
2429 			ndpc.sin6.sin6_family = AF_INET6;
2430 			ndpc.sin6.sin6_len = sizeof(ndpc.sin6);
2431 			bcopy(L3_ADDR(lle), &ndpc.sin6, L3_ADDR_LEN(lle));
2432 			if (V_deembed_scopeid)
2433 				sa6_recoverscope(&ndpc.sin6);
2434 
2435 			/* publish */
2436 			if (lle->la_flags & LLE_PUB)
2437 				ndpc.rtm.rtm_flags |= RTF_ANNOUNCE;
2438 
2439 			sdl = &ndpc.sdl;
2440 			sdl->sdl_family = AF_LINK;
2441 			sdl->sdl_len = sizeof(*sdl);
2442 			sdl->sdl_alen = ifp->if_addrlen;
2443 			sdl->sdl_index = ifp->if_index;
2444 			sdl->sdl_type = ifp->if_type;
2445 			bcopy(&lle->ll_addr, LLADDR(sdl), ifp->if_addrlen);
2446 			ndpc.rtm.rtm_rmx.rmx_expire =
2447 			    lle->la_flags & LLE_STATIC ? 0 : lle->la_expire;
2448 			ndpc.rtm.rtm_flags |= (RTF_HOST | RTF_LLDATA);
2449 			if (lle->la_flags & LLE_STATIC)
2450 				ndpc.rtm.rtm_flags |= RTF_STATIC;
2451 			ndpc.rtm.rtm_index = ifp->if_index;
2452 			error = SYSCTL_OUT(wr, &ndpc, sizeof(ndpc));
2453 			if (error)
2454 				break;
2455 		}
2456 	}
2457 	return error;
2458 }
2459 
2460 void *
2461 in6_domifattach(struct ifnet *ifp)
2462 {
2463 	struct in6_ifextra *ext;
2464 
2465 	/* There are not IPv6-capable interfaces. */
2466 	switch (ifp->if_type) {
2467 	case IFT_PFLOG:
2468 	case IFT_PFSYNC:
2469 	case IFT_USB:
2470 		return (NULL);
2471 	}
2472 	ext = (struct in6_ifextra *)malloc(sizeof(*ext), M_IFADDR, M_WAITOK);
2473 	bzero(ext, sizeof(*ext));
2474 
2475 	ext->in6_ifstat = malloc(sizeof(counter_u64_t) *
2476 	    sizeof(struct in6_ifstat) / sizeof(uint64_t), M_IFADDR, M_WAITOK);
2477 	COUNTER_ARRAY_ALLOC(ext->in6_ifstat,
2478 	    sizeof(struct in6_ifstat) / sizeof(uint64_t), M_WAITOK);
2479 
2480 	ext->icmp6_ifstat = malloc(sizeof(counter_u64_t) *
2481 	    sizeof(struct icmp6_ifstat) / sizeof(uint64_t), M_IFADDR,
2482 	    M_WAITOK);
2483 	COUNTER_ARRAY_ALLOC(ext->icmp6_ifstat,
2484 	    sizeof(struct icmp6_ifstat) / sizeof(uint64_t), M_WAITOK);
2485 
2486 	ext->nd_ifinfo = nd6_ifattach(ifp);
2487 	ext->scope6_id = scope6_ifattach(ifp);
2488 	ext->lltable = lltable_init(ifp, AF_INET6);
2489 	if (ext->lltable != NULL) {
2490 		ext->lltable->llt_prefix_free = in6_lltable_prefix_free;
2491 		ext->lltable->llt_lookup = in6_lltable_lookup;
2492 		ext->lltable->llt_dump = in6_lltable_dump;
2493 	}
2494 
2495 	ext->mld_ifinfo = mld_domifattach(ifp);
2496 
2497 	return ext;
2498 }
2499 
2500 void
2501 in6_domifdetach(struct ifnet *ifp, void *aux)
2502 {
2503 	struct in6_ifextra *ext = (struct in6_ifextra *)aux;
2504 
2505 	mld_domifdetach(ifp);
2506 	scope6_ifdetach(ext->scope6_id);
2507 	nd6_ifdetach(ext->nd_ifinfo);
2508 	lltable_free(ext->lltable);
2509 	COUNTER_ARRAY_FREE(ext->in6_ifstat,
2510 	    sizeof(struct in6_ifstat) / sizeof(uint64_t));
2511 	free(ext->in6_ifstat, M_IFADDR);
2512 	COUNTER_ARRAY_FREE(ext->icmp6_ifstat,
2513 	    sizeof(struct icmp6_ifstat) / sizeof(uint64_t));
2514 	free(ext->icmp6_ifstat, M_IFADDR);
2515 	free(ext, M_IFADDR);
2516 }
2517 
2518 /*
2519  * Convert sockaddr_in6 to sockaddr_in.  Original sockaddr_in6 must be
2520  * v4 mapped addr or v4 compat addr
2521  */
2522 void
2523 in6_sin6_2_sin(struct sockaddr_in *sin, struct sockaddr_in6 *sin6)
2524 {
2525 
2526 	bzero(sin, sizeof(*sin));
2527 	sin->sin_len = sizeof(struct sockaddr_in);
2528 	sin->sin_family = AF_INET;
2529 	sin->sin_port = sin6->sin6_port;
2530 	sin->sin_addr.s_addr = sin6->sin6_addr.s6_addr32[3];
2531 }
2532 
2533 /* Convert sockaddr_in to sockaddr_in6 in v4 mapped addr format. */
2534 void
2535 in6_sin_2_v4mapsin6(struct sockaddr_in *sin, struct sockaddr_in6 *sin6)
2536 {
2537 	bzero(sin6, sizeof(*sin6));
2538 	sin6->sin6_len = sizeof(struct sockaddr_in6);
2539 	sin6->sin6_family = AF_INET6;
2540 	sin6->sin6_port = sin->sin_port;
2541 	sin6->sin6_addr.s6_addr32[0] = 0;
2542 	sin6->sin6_addr.s6_addr32[1] = 0;
2543 	sin6->sin6_addr.s6_addr32[2] = IPV6_ADDR_INT32_SMP;
2544 	sin6->sin6_addr.s6_addr32[3] = sin->sin_addr.s_addr;
2545 }
2546 
2547 /* Convert sockaddr_in6 into sockaddr_in. */
2548 void
2549 in6_sin6_2_sin_in_sock(struct sockaddr *nam)
2550 {
2551 	struct sockaddr_in *sin_p;
2552 	struct sockaddr_in6 sin6;
2553 
2554 	/*
2555 	 * Save original sockaddr_in6 addr and convert it
2556 	 * to sockaddr_in.
2557 	 */
2558 	sin6 = *(struct sockaddr_in6 *)nam;
2559 	sin_p = (struct sockaddr_in *)nam;
2560 	in6_sin6_2_sin(sin_p, &sin6);
2561 }
2562 
2563 /* Convert sockaddr_in into sockaddr_in6 in v4 mapped addr format. */
2564 void
2565 in6_sin_2_v4mapsin6_in_sock(struct sockaddr **nam)
2566 {
2567 	struct sockaddr_in *sin_p;
2568 	struct sockaddr_in6 *sin6_p;
2569 
2570 	sin6_p = malloc(sizeof *sin6_p, M_SONAME, M_WAITOK);
2571 	sin_p = (struct sockaddr_in *)*nam;
2572 	in6_sin_2_v4mapsin6(sin_p, sin6_p);
2573 	free(*nam, M_SONAME);
2574 	*nam = (struct sockaddr *)sin6_p;
2575 }
2576