[apple/xnu.git] / bsd / netinet6 / scope6.c

/*
 * Copyright (c) 2009-2013 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */

/*
 * Copyright (C) 2000 WIDE Project.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the project nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/param.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/systm.h>
#include <sys/queue.h>
#include <sys/syslog.h>
#include <sys/mcache.h>

#include <net/route.h>
#include <net/if.h>

#include <netinet/in.h>

#include <netinet6/in6_var.h>
#include <netinet6/scope6_var.h>

#ifdef ENABLE_DEFAULT_SCOPE
int ip6_use_defzone = 1;
#else
int ip6_use_defzone = 0;
#endif

decl_lck_mtx_data(static, scope6_lock);
static struct scope6_id sid_default;

#define SID(ifp) &IN6_IFEXTRA(ifp)->scope6_id

void
scope6_init(lck_grp_t *grp, lck_attr_t *attr)
{
	bzero(&sid_default, sizeof(sid_default));
	lck_mtx_init(&scope6_lock, grp, attr);
}

void
scope6_ifattach(struct ifnet *ifp)
{
	struct scope6_id *sid;

	VERIFY(IN6_IFEXTRA(ifp) != NULL);
	if_inet6data_lock_exclusive(ifp);
	sid = SID(ifp);
	/* N.B.: the structure is already zero'ed */
	/*
	 * XXX: IPV6_ADDR_SCOPE_xxx macros are not standard.
	 * Should we rather hardcode here?
	 */
	sid->s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL] = ifp->if_index;
	sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] = ifp->if_index;
#if MULTI_SCOPE
	/* by default, we don't care about scope boundary for these scopes. */
	sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL] = 1;
	sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL] = 1;
#endif
	if_inet6data_lock_done(ifp);
}

/*
 * Get a scope of the address. Node-local, link-local, site-local or global.
 */
int
in6_addrscope(struct in6_addr *addr)
{
	int scope;

	if (addr->s6_addr8[0] == 0xfe) {
		scope = addr->s6_addr8[1] & 0xc0;

		switch (scope) {
		case 0x80:
			return (IPV6_ADDR_SCOPE_LINKLOCAL);
		case 0xc0:
			return (IPV6_ADDR_SCOPE_SITELOCAL);
		default:
			return (IPV6_ADDR_SCOPE_GLOBAL); /* just in case */
		}
	}

	if (addr->s6_addr8[0] == 0xff) {
		scope = addr->s6_addr8[1] & 0x0f;

		/*
		 * due to other scope such as reserved,
		 * return scope doesn't work.
		 */
		switch (scope) {
		case IPV6_ADDR_SCOPE_INTFACELOCAL:
			return (IPV6_ADDR_SCOPE_INTFACELOCAL);
		case IPV6_ADDR_SCOPE_LINKLOCAL:
			return (IPV6_ADDR_SCOPE_LINKLOCAL);
		case IPV6_ADDR_SCOPE_SITELOCAL:
			return (IPV6_ADDR_SCOPE_SITELOCAL);
		default:
			return (IPV6_ADDR_SCOPE_GLOBAL);
		}
	}

	/*
	 * Regard loopback and unspecified addresses as global, since
	 * they have no ambiguity.
	 */
	if (bcmp(&in6addr_loopback, addr, sizeof (*addr) - 1) == 0) {
		if (addr->s6_addr8[15] == 1) /* loopback */
			return (IPV6_ADDR_SCOPE_LINKLOCAL);
		if (addr->s6_addr8[15] == 0) /* unspecified */
			return (IPV6_ADDR_SCOPE_GLOBAL); /* XXX: correct? */
	}

	return (IPV6_ADDR_SCOPE_GLOBAL);
}

int
in6_addr2scopeid(struct ifnet *ifp, struct in6_addr *addr)
{
	int scope = in6_addrscope(addr);
	int retid = 0;
	struct scope6_id *sid;

	if_inet6data_lock_shared(ifp);
	if (IN6_IFEXTRA(ifp) == NULL)
		goto err;
	sid = SID(ifp);
	switch (scope) {
	case IPV6_ADDR_SCOPE_NODELOCAL:
		retid = -1;	/* XXX: is this an appropriate value? */
		break;
	case IPV6_ADDR_SCOPE_LINKLOCAL:
		retid = sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL];
		break;
	case IPV6_ADDR_SCOPE_SITELOCAL:
		retid = sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL];
		break;
	case IPV6_ADDR_SCOPE_ORGLOCAL:
		retid = sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL];
		break;
	default:
		break;	/* XXX: value 0, treat as global. */
	}
err:
	if_inet6data_lock_done(ifp);

	return (retid);
}

/*
 * Validate the specified scope zone ID in the sin6_scope_id field.  If the ID
 * is unspecified (=0), needs to be specified, and the default zone ID can be
 * used, the default value will be used.
 * This routine then generates the kernel-internal form: if the address scope
 * of is interface-local or link-local, embed the interface index in the
 * address.
 */
int
sa6_embedscope(struct sockaddr_in6 *sin6, int defaultok)
{
	struct ifnet *ifp;
	u_int32_t zoneid;

	if ((zoneid = sin6->sin6_scope_id) == 0 && defaultok)
		zoneid = scope6_addr2default(&sin6->sin6_addr);

	if (zoneid != 0 &&
	    (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr) ||
	    IN6_IS_ADDR_MC_INTFACELOCAL(&sin6->sin6_addr))) {
		/*
		 * At this moment, we only check interface-local and
		 * link-local scope IDs, and use interface indices as the
		 * zone IDs assuming a one-to-one mapping between interfaces
		 * and links.
		 */
		if (if_index < zoneid)
			return (ENXIO);
		ifnet_head_lock_shared();
		ifp = ifindex2ifnet[zoneid];
		if (ifp == NULL) {	/* XXX: this can happen for some OS */
			ifnet_head_done();
			return (ENXIO);
		}
		ifnet_head_done();
		/* XXX assignment to 16bit from 32bit variable */
		sin6->sin6_addr.s6_addr16[1] = htons(zoneid & 0xffff);

		sin6->sin6_scope_id = 0;
	}

	return (0);
}

void
rtkey_to_sa6(struct rtentry *rt, struct sockaddr_in6 *sin6)
{
	VERIFY(rt_key(rt)->sa_family == AF_INET6);

	*sin6 = *((struct sockaddr_in6 *)(void *)rt_key(rt));
	sin6->sin6_scope_id = 0;
}

void
rtgw_to_sa6(struct rtentry *rt, struct sockaddr_in6 *sin6)
{
	VERIFY(rt->rt_flags & RTF_GATEWAY);

	*sin6 = *((struct sockaddr_in6 *)(void *)rt->rt_gateway);
	sin6->sin6_scope_id = 0;
}

/*
 * generate standard sockaddr_in6 from embedded form.
 */
int
sa6_recoverscope(struct sockaddr_in6 *sin6, boolean_t attachcheck)
{
	u_int32_t zoneid;

	if (sin6->sin6_scope_id != 0) {
		log(LOG_NOTICE,
		    "sa6_recoverscope: assumption failure (non 0 ID): %s%%%d\n",
		    ip6_sprintf(&sin6->sin6_addr), sin6->sin6_scope_id);
		/* XXX: proceed anyway... */
	}
	if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr) ||
	    IN6_IS_ADDR_MC_INTFACELOCAL(&sin6->sin6_addr)) {
		/*
		 * KAME assumption: link id == interface id
		 */
		zoneid = ntohs(sin6->sin6_addr.s6_addr16[1]);
		if (zoneid) {
			/* sanity check */
			if (if_index < zoneid)
				return (ENXIO);
			/*
			 * We use the attachcheck parameter to skip the
			 * interface attachment check.
			 * Some callers might hold the ifnet_head lock in
			 * exclusive mode. This means that:
			 * 1) the interface can't go away -- hence we don't
			 *    need to perform this check
			 * 2) we can't perform this check because the lock is
			 *    in exclusive mode and trying to lock it in shared
			 *    mode would cause a deadlock.
			 */
			if (attachcheck) {
				ifnet_head_lock_shared();
				if (ifindex2ifnet[zoneid] == NULL) {
					ifnet_head_done();
					return (ENXIO);
				}
				ifnet_head_done();
			}
			sin6->sin6_addr.s6_addr16[1] = 0;
			sin6->sin6_scope_id = zoneid;
		}
	}

	return (0);
}

void
scope6_setdefault(struct ifnet *ifp)
{
	/*
	 * Currently, this function just set the default "link" according to
	 * the given interface.
	 * We might eventually have to separate the notion of "link" from
	 * "interface" and provide a user interface to set the default.
	 */
	lck_mtx_lock(&scope6_lock);
	if (ifp != NULL) {
		sid_default.s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL] =
		    ifp->if_index;
		sid_default.s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] =
		    ifp->if_index;
	} else {
		sid_default.s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL] = 0;
		sid_default.s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] = 0;
	}
	lck_mtx_unlock(&scope6_lock);
}


u_int32_t
scope6_addr2default(struct in6_addr *addr)
{
	u_int32_t id = 0;
	int index = in6_addrscope(addr);

	/*
	 * special case: The loopback address should be considered as
	 * link-local, but there's no ambiguity in the syntax.
	 */
	if (IN6_IS_ADDR_LOOPBACK(addr))
		return (0);

	lck_mtx_lock(&scope6_lock);
	id = sid_default.s6id_list[index];
	lck_mtx_unlock(&scope6_lock);

	return (id);
}

/*
 * Determine the appropriate scope zone ID for in6 and ifp.  If ret_id is
 * non NULL, it is set to the zone ID.  If the zone ID needs to be embedded
 * in the in6_addr structure, in6 will be modified.
 *
 * ret_id - unnecessary?
 */
int
in6_setscope(struct in6_addr *in6, struct ifnet *ifp, u_int32_t *ret_id)
{
	int scope;
	u_int32_t zoneid = 0;
	struct scope6_id *sid;

	/*
	 * special case: the loopback address can only belong to a loopback
	 * interface.
	 */
	if (IN6_IS_ADDR_LOOPBACK(in6)) {
		if (!(ifp->if_flags & IFF_LOOPBACK)) {
			return (EINVAL);
		} else {
			if (ret_id != NULL)
				*ret_id = 0; /* there's no ambiguity */
			return (0);
		}
	}

	scope = in6_addrscope(in6);

	if_inet6data_lock_shared(ifp);
	if (IN6_IFEXTRA(ifp) == NULL) {
		if_inet6data_lock_done(ifp);
		if (ret_id)
			*ret_id = 0;
		return (EINVAL);
	}
	sid = SID(ifp);
	switch (scope) {
	case IPV6_ADDR_SCOPE_INTFACELOCAL: /* should be interface index */
		zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL];
		break;

	case IPV6_ADDR_SCOPE_LINKLOCAL:
		zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL];
		break;

	case IPV6_ADDR_SCOPE_SITELOCAL:
		zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL];
		break;

	case IPV6_ADDR_SCOPE_ORGLOCAL:
		zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL];
		break;
	default:
		zoneid = 0;	/* XXX: treat as global. */
		break;
	}
	if_inet6data_lock_done(ifp);

	if (ret_id != NULL)
		*ret_id = zoneid;

	if (IN6_IS_SCOPE_LINKLOCAL(in6) || IN6_IS_ADDR_MC_INTFACELOCAL(in6))
		in6->s6_addr16[1] = htons(zoneid & 0xffff); /* XXX */

	return (0);
}

/*
 * Just clear the embedded scope identifier.  Return 0 if the original address
 * is intact; return non 0 if the address is modified.
 */
int
in6_clearscope(struct in6_addr *in6)
{
	int modified = 0;

	if (IN6_IS_SCOPE_LINKLOCAL(in6) || IN6_IS_ADDR_MC_INTFACELOCAL(in6)) {
		if (in6->s6_addr16[1] != 0)
			modified = 1;
		in6->s6_addr16[1] = 0;
	}

	return (modified);
}
Commit	Line	Data
6d2010ae	1	/*
39236c6e	2	* Copyright (c) 2009-2013 Apple Inc. All rights reserved.
6d2010ae A	3	*
6d2010ae A	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
39236c6e	5	*
6d2010ae A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
39236c6e	14	*
6d2010ae A	15	* Please obtain a copy of the License at
6d2010ae A	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
39236c6e	17	*
6d2010ae A	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
39236c6e	25	*
6d2010ae A	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
	28
9bccf70c A	29	/*
	30	* Copyright (C) 2000 WIDE Project.
	31	* All rights reserved.
39236c6e	32	*
9bccf70c A	33	* Redistribution and use in source and binary forms, with or without
	34	* modification, are permitted provided that the following conditions
	35	* are met:
	36	* 1. Redistributions of source code must retain the above copyright
	37	* notice, this list of conditions and the following disclaimer.
	38	* 2. Redistributions in binary form must reproduce the above copyright
	39	* notice, this list of conditions and the following disclaimer in the
	40	* documentation and/or other materials provided with the distribution.
	41	* 3. Neither the name of the project nor the names of its contributors
	42	* may be used to endorse or promote products derived from this software
	43	* without specific prior written permission.
39236c6e	44	*
9bccf70c A	45	* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
	46	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	47	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	48	* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
	49	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	50	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	51	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	52	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	53	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	54	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	55	* SUCH DAMAGE.
	56	*/
	57
	58	#include <sys/param.h>
	59	#include <sys/malloc.h>
	60	#include <sys/mbuf.h>
	61	#include <sys/socket.h>
	62	#include <sys/systm.h>
	63	#include <sys/queue.h>
6d2010ae A	64	#include <sys/syslog.h>
6d2010ae A	65	#include <sys/mcache.h>
9bccf70c A	66
	67	#include <net/route.h>
	68	#include <net/if.h>
	69
	70	#include <netinet/in.h>
	71
	72	#include <netinet6/in6_var.h>
	73	#include <netinet6/scope6_var.h>
	74
6d2010ae A	75	#ifdef ENABLE_DEFAULT_SCOPE
	76	int ip6_use_defzone = 1;
	77	#else
	78	int ip6_use_defzone = 0;
	79	#endif
	80
39236c6e A	81	decl_lck_mtx_data(static, scope6_lock);
39236c6e A	82	static struct scope6_id sid_default;
9bccf70c	83
39236c6e	84	#define SID(ifp) &IN6_IFEXTRA(ifp)->scope6_id
9bccf70c	85
39236c6e A	86	void
	87	scope6_init(lck_grp_t grp, lck_attr_t attr)
	88	{
	89	bzero(&sid_default, sizeof(sid_default));
	90	lck_mtx_init(&scope6_lock, grp, attr);
	91	}
9bccf70c	92
39236c6e A	93	void
	94	scope6_ifattach(struct ifnet *ifp)
	95	{
	96	struct scope6_id *sid;
9bccf70c	97
39236c6e A	98	VERIFY(IN6_IFEXTRA(ifp) != NULL);
	99	if_inet6data_lock_exclusive(ifp);
	100	sid = SID(ifp);
	101	/* N.B.: the structure is already zero'ed */
9bccf70c A	102	/*
	103	* XXX: IPV6_ADDR_SCOPE_xxx macros are not standard.
	104	* Should we rather hardcode here?
	105	*/
39236c6e A	106	sid->s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL] = ifp->if_index;
39236c6e A	107	sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] = ifp->if_index;
9bccf70c A	108	#if MULTI_SCOPE
9bccf70c A	109	/* by default, we don't care about scope boundary for these scopes. */
39236c6e A	110	sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL] = 1;
39236c6e A	111	sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL] = 1;
9bccf70c	112	#endif
39236c6e	113	if_inet6data_lock_done(ifp);
9bccf70c A	114	}
9bccf70c A	115
9bccf70c A	116	/*
	117	* Get a scope of the address. Node-local, link-local, site-local or global.
	118	*/
	119	int
39236c6e	120	in6_addrscope(struct in6_addr *addr)
9bccf70c A	121	{
	122	int scope;
	123
	124	if (addr->s6_addr8[0] == 0xfe) {
	125	scope = addr->s6_addr8[1] & 0xc0;
	126
	127	switch (scope) {
	128	case 0x80:
39236c6e	129	return (IPV6_ADDR_SCOPE_LINKLOCAL);
9bccf70c	130	case 0xc0:
39236c6e	131	return (IPV6_ADDR_SCOPE_SITELOCAL);
9bccf70c	132	default:
39236c6e	133	return (IPV6_ADDR_SCOPE_GLOBAL); /* just in case */
9bccf70c A	134	}
	135	}
	136
9bccf70c A	137	if (addr->s6_addr8[0] == 0xff) {
	138	scope = addr->s6_addr8[1] & 0x0f;
	139
	140	/*
	141	* due to other scope such as reserved,
	142	* return scope doesn't work.
	143	*/
	144	switch (scope) {
6d2010ae	145	case IPV6_ADDR_SCOPE_INTFACELOCAL:
39236c6e	146	return (IPV6_ADDR_SCOPE_INTFACELOCAL);
9bccf70c	147	case IPV6_ADDR_SCOPE_LINKLOCAL:
39236c6e	148	return (IPV6_ADDR_SCOPE_LINKLOCAL);
9bccf70c	149	case IPV6_ADDR_SCOPE_SITELOCAL:
39236c6e	150	return (IPV6_ADDR_SCOPE_SITELOCAL);
9bccf70c	151	default:
39236c6e	152	return (IPV6_ADDR_SCOPE_GLOBAL);
9bccf70c A	153	}
	154	}
	155
6d2010ae A	156	/*
	157	* Regard loopback and unspecified addresses as global, since
	158	* they have no ambiguity.
	159	*/
39236c6e	160	if (bcmp(&in6addr_loopback, addr, sizeof (*addr) - 1) == 0) {
9bccf70c	161	if (addr->s6_addr8[15] == 1) /* loopback */
39236c6e	162	return (IPV6_ADDR_SCOPE_LINKLOCAL);
6d2010ae	163	if (addr->s6_addr8[15] == 0) /* unspecified */
39236c6e	164	return (IPV6_ADDR_SCOPE_GLOBAL); /* XXX: correct? */
9bccf70c A	165	}
9bccf70c A	166
39236c6e	167	return (IPV6_ADDR_SCOPE_GLOBAL);
9bccf70c A	168	}
	169
	170	int
39236c6e	171	in6_addr2scopeid(struct ifnet ifp, struct in6_addr addr)
9bccf70c A	172	{
9bccf70c A	173	int scope = in6_addrscope(addr);
b0d623f7	174	int retid = 0;
39236c6e	175	struct scope6_id *sid;
9bccf70c	176
39236c6e A	177	if_inet6data_lock_shared(ifp);
	178	if (IN6_IFEXTRA(ifp) == NULL)
	179	goto err;
	180	sid = SID(ifp);
	181	switch (scope) {
9bccf70c	182	case IPV6_ADDR_SCOPE_NODELOCAL:
b0d623f7 A	183	retid = -1; /* XXX: is this an appropriate value? */
b0d623f7 A	184	break;
9bccf70c	185	case IPV6_ADDR_SCOPE_LINKLOCAL:
39236c6e	186	retid = sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL];
b0d623f7	187	break;
9bccf70c	188	case IPV6_ADDR_SCOPE_SITELOCAL:
39236c6e	189	retid = sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL];
b0d623f7	190	break;
9bccf70c	191	case IPV6_ADDR_SCOPE_ORGLOCAL:
39236c6e	192	retid = sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL];
b0d623f7	193	break;
9bccf70c	194	default:
b0d623f7	195	break; /* XXX: value 0, treat as global. */
9bccf70c	196	}
39236c6e A	197	err:
39236c6e A	198	if_inet6data_lock_done(ifp);
b0d623f7	199
39236c6e	200	return (retid);
9bccf70c A	201	}
9bccf70c A	202
6d2010ae A	203	/*
	204	* Validate the specified scope zone ID in the sin6_scope_id field. If the ID
	205	* is unspecified (=0), needs to be specified, and the default zone ID can be
	206	* used, the default value will be used.
	207	* This routine then generates the kernel-internal form: if the address scope
	208	* of is interface-local or link-local, embed the interface index in the
	209	* address.
	210	*/
	211	int
	212	sa6_embedscope(struct sockaddr_in6 *sin6, int defaultok)
	213	{
	214	struct ifnet *ifp;
	215	u_int32_t zoneid;
	216
	217	if ((zoneid = sin6->sin6_scope_id) == 0 && defaultok)
	218	zoneid = scope6_addr2default(&sin6->sin6_addr);
	219
	220	if (zoneid != 0 &&
	221	(IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr) \|\|
	222	IN6_IS_ADDR_MC_INTFACELOCAL(&sin6->sin6_addr))) {
	223	/*
	224	* At this moment, we only check interface-local and
	225	* link-local scope IDs, and use interface indices as the
	226	* zone IDs assuming a one-to-one mapping between interfaces
	227	* and links.
	228	*/
	229	if (if_index < zoneid)
	230	return (ENXIO);
	231	ifnet_head_lock_shared();
	232	ifp = ifindex2ifnet[zoneid];
39236c6e	233	if (ifp == NULL) { /* XXX: this can happen for some OS */
6d2010ae A	234	ifnet_head_done();
	235	return (ENXIO);
	236	}
	237	ifnet_head_done();
	238	/* XXX assignment to 16bit from 32bit variable */
	239	sin6->sin6_addr.s6_addr16[1] = htons(zoneid & 0xffff);
	240
	241	sin6->sin6_scope_id = 0;
	242	}
	243
39236c6e	244	return (0);
6d2010ae A	245	}
	246
	247	void
	248	rtkey_to_sa6(struct rtentry rt, struct sockaddr_in6 sin6)
	249	{
	250	VERIFY(rt_key(rt)->sa_family == AF_INET6);
	251
316670eb	252	sin6 = ((struct sockaddr_in6 )(void )rt_key(rt));
6d2010ae A	253	sin6->sin6_scope_id = 0;
	254	}
	255
	256	void
	257	rtgw_to_sa6(struct rtentry rt, struct sockaddr_in6 sin6)
	258	{
	259	VERIFY(rt->rt_flags & RTF_GATEWAY);
	260
316670eb	261	sin6 = ((struct sockaddr_in6 )(void )rt->rt_gateway);
6d2010ae A	262	sin6->sin6_scope_id = 0;
	263	}
	264
	265	/*
	266	* generate standard sockaddr_in6 from embedded form.
	267	*/
	268	int
316670eb	269	sa6_recoverscope(struct sockaddr_in6 *sin6, boolean_t attachcheck)
6d2010ae A	270	{
	271	u_int32_t zoneid;
	272
	273	if (sin6->sin6_scope_id != 0) {
	274	log(LOG_NOTICE,
	275	"sa6_recoverscope: assumption failure (non 0 ID): %s%%%d\n",
	276	ip6_sprintf(&sin6->sin6_addr), sin6->sin6_scope_id);
	277	/* XXX: proceed anyway... */
	278	}
	279	if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr) \|\|
	280	IN6_IS_ADDR_MC_INTFACELOCAL(&sin6->sin6_addr)) {
	281	/*
	282	* KAME assumption: link id == interface id
	283	*/
	284	zoneid = ntohs(sin6->sin6_addr.s6_addr16[1]);
	285	if (zoneid) {
	286	/* sanity check */
	287	if (if_index < zoneid)
	288	return (ENXIO);
316670eb A	289	/*
	290	* We use the attachcheck parameter to skip the
	291	* interface attachment check.
	292	* Some callers might hold the ifnet_head lock in
	293	* exclusive mode. This means that:
	294	* 1) the interface can't go away -- hence we don't
	295	* need to perform this check
	296	* 2) we can't perform this check because the lock is
	297	* in exclusive mode and trying to lock it in shared
	298	* mode would cause a deadlock.
	299	*/
	300	if (attachcheck) {
	301	ifnet_head_lock_shared();
	302	if (ifindex2ifnet[zoneid] == NULL) {
	303	ifnet_head_done();
	304	return (ENXIO);
	305	}
6d2010ae	306	ifnet_head_done();
6d2010ae	307	}
6d2010ae A	308	sin6->sin6_addr.s6_addr16[1] = 0;
	309	sin6->sin6_scope_id = zoneid;
	310	}
	311	}
	312
39236c6e	313	return (0);
6d2010ae A	314	}
6d2010ae A	315
9bccf70c	316	void
39236c6e	317	scope6_setdefault(struct ifnet *ifp)
9bccf70c A	318	{
	319	/*
	320	* Currently, this function just set the default "link" according to
	321	* the given interface.
	322	* We might eventually have to separate the notion of "link" from
	323	* "interface" and provide a user interface to set the default.
	324	*/
39236c6e A	325	lck_mtx_lock(&scope6_lock);
	326	if (ifp != NULL) {
	327	sid_default.s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL] =
	328	ifp->if_index;
	329	sid_default.s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] =
	330	ifp->if_index;
6d2010ae	331	} else {
39236c6e A	332	sid_default.s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL] = 0;
39236c6e A	333	sid_default.s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] = 0;
6d2010ae	334	}
39236c6e	335	lck_mtx_unlock(&scope6_lock);
9bccf70c A	336	}
9bccf70c A	337
9bccf70c A	338
9bccf70c A	339	u_int32_t
39236c6e	340	scope6_addr2default(struct in6_addr *addr)
9bccf70c	341	{
b0d623f7 A	342	u_int32_t id = 0;
b0d623f7 A	343	int index = in6_addrscope(addr);
39236c6e A	344
	345	/*
	346	* special case: The loopback address should be considered as
	347	* link-local, but there's no ambiguity in the syntax.
	348	*/
	349	if (IN6_IS_ADDR_LOOPBACK(addr))
	350	return (0);
	351
	352	lck_mtx_lock(&scope6_lock);
	353	id = sid_default.s6id_list[index];
	354	lck_mtx_unlock(&scope6_lock);
	355
b0d623f7	356	return (id);
9bccf70c	357	}
6d2010ae A	358
	359	/*
	360	* Determine the appropriate scope zone ID for in6 and ifp. If ret_id is
	361	* non NULL, it is set to the zone ID. If the zone ID needs to be embedded
	362	* in the in6_addr structure, in6 will be modified.
	363	*
	364	* ret_id - unnecessary?
	365	*/
	366	int
	367	in6_setscope(struct in6_addr in6, struct ifnet ifp, u_int32_t *ret_id)
	368	{
	369	int scope;
	370	u_int32_t zoneid = 0;
39236c6e	371	struct scope6_id *sid;
6d2010ae A	372
	373	/*
	374	* special case: the loopback address can only belong to a loopback
	375	* interface.
	376	*/
	377	if (IN6_IS_ADDR_LOOPBACK(in6)) {
	378	if (!(ifp->if_flags & IFF_LOOPBACK)) {
	379	return (EINVAL);
	380	} else {
	381	if (ret_id != NULL)
	382	ret_id = 0; / there's no ambiguity */
	383	return (0);
	384	}
	385	}
	386
	387	scope = in6_addrscope(in6);
	388
39236c6e A	389	if_inet6data_lock_shared(ifp);
	390	if (IN6_IFEXTRA(ifp) == NULL) {
	391	if_inet6data_lock_done(ifp);
	392	if (ret_id)
316670eb A	393	*ret_id = 0;
	394	return (EINVAL);
	395	}
39236c6e	396	sid = SID(ifp);
6d2010ae A	397	switch (scope) {
6d2010ae A	398	case IPV6_ADDR_SCOPE_INTFACELOCAL: /* should be interface index */
39236c6e	399	zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL];
6d2010ae A	400	break;
	401
	402	case IPV6_ADDR_SCOPE_LINKLOCAL:
39236c6e	403	zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL];
6d2010ae A	404	break;
	405
	406	case IPV6_ADDR_SCOPE_SITELOCAL:
39236c6e	407	zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL];
6d2010ae A	408	break;
	409
	410	case IPV6_ADDR_SCOPE_ORGLOCAL:
39236c6e	411	zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL];
6d2010ae	412	break;
6d2010ae A	413	default:
	414	zoneid = 0; /* XXX: treat as global. */
	415	break;
	416	}
39236c6e	417	if_inet6data_lock_done(ifp);
6d2010ae A	418
	419	if (ret_id != NULL)
	420	*ret_id = zoneid;
	421
	422	if (IN6_IS_SCOPE_LINKLOCAL(in6) \|\| IN6_IS_ADDR_MC_INTFACELOCAL(in6))
	423	in6->s6_addr16[1] = htons(zoneid & 0xffff); /* XXX */
	424
	425	return (0);
	426	}
	427
	428	/*
	429	* Just clear the embedded scope identifier. Return 0 if the original address
	430	* is intact; return non 0 if the address is modified.
	431	*/
	432	int
	433	in6_clearscope(struct in6_addr *in6)
	434	{
	435	int modified = 0;
	436
	437	if (IN6_IS_SCOPE_LINKLOCAL(in6) \|\| IN6_IS_ADDR_MC_INTFACELOCAL(in6)) {
	438	if (in6->s6_addr16[1] != 0)
	439	modified = 1;
	440	in6->s6_addr16[1] = 0;
	441	}
	442
	443	return (modified);
	444	}