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