[apple/xnu.git] / bsd / netinet / mp_pcb.c

/*
 * Copyright (c) 2012-2017 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@
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/mbuf.h>
#include <sys/mcache.h>
#include <sys/syslog.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/protosw.h>
#include <sys/proc_internal.h>

#include <mach/boolean.h>
#include <kern/zalloc.h>
#include <kern/locks.h>

#include <netinet/mp_pcb.h>
#include <netinet/mptcp_var.h>
#include <netinet6/in6_pcb.h>

static lck_grp_t	*mp_lock_grp;
static lck_attr_t	*mp_lock_attr;
static lck_grp_attr_t	*mp_lock_grp_attr;
decl_lck_mtx_data(static, mp_lock);		/* global MULTIPATH lock */
decl_lck_mtx_data(static, mp_timeout_lock);

static TAILQ_HEAD(, mppcbinfo) mppi_head = TAILQ_HEAD_INITIALIZER(mppi_head);

static boolean_t mp_timeout_run;	/* MP timer is scheduled to run */
static boolean_t mp_garbage_collecting;
static boolean_t mp_ticking;
static void mp_sched_timeout(void);
static void mp_timeout(void *);

void
mp_pcbinit(void)
{
	static int mp_initialized = 0;

	VERIFY(!mp_initialized);
	mp_initialized = 1;

	mp_lock_grp_attr = lck_grp_attr_alloc_init();
	mp_lock_grp = lck_grp_alloc_init("multipath", mp_lock_grp_attr);
	mp_lock_attr = lck_attr_alloc_init();
	lck_mtx_init(&mp_lock, mp_lock_grp, mp_lock_attr);
	lck_mtx_init(&mp_timeout_lock, mp_lock_grp, mp_lock_attr);
}

static void
mp_timeout(void *arg)
{
#pragma unused(arg)
	struct mppcbinfo *mppi;
	boolean_t t, gc;
	uint32_t t_act = 0;
	uint32_t gc_act = 0;

	/*
	 * Update coarse-grained networking timestamp (in sec.); the idea
	 * is to piggy-back on the timeout callout to update the counter
	 * returnable via net_uptime().
	 */
	net_update_uptime();

	lck_mtx_lock_spin(&mp_timeout_lock);
	gc = mp_garbage_collecting;
	mp_garbage_collecting = FALSE;

	t = mp_ticking;
	mp_ticking = FALSE;

	if (gc || t) {
		lck_mtx_unlock(&mp_timeout_lock);

		lck_mtx_lock(&mp_lock);
		TAILQ_FOREACH(mppi, &mppi_head, mppi_entry) {
			if ((gc && mppi->mppi_gc != NULL) ||
			    (t && mppi->mppi_timer != NULL)) {
				lck_mtx_lock(&mppi->mppi_lock);
				if (gc && mppi->mppi_gc != NULL)
					gc_act += mppi->mppi_gc(mppi);
				if (t && mppi->mppi_timer != NULL)
					t_act += mppi->mppi_timer(mppi);
				lck_mtx_unlock(&mppi->mppi_lock);
			}
		}
		lck_mtx_unlock(&mp_lock);

		lck_mtx_lock_spin(&mp_timeout_lock);
	}

	/* lock was dropped above, so check first before overriding */
	if (!mp_garbage_collecting)
		mp_garbage_collecting = (gc_act != 0);
	if (!mp_ticking)
		mp_ticking = (t_act != 0);

	/* re-arm the timer if there's work to do */
	mp_timeout_run = FALSE;
	mp_sched_timeout();
	lck_mtx_unlock(&mp_timeout_lock);
}

static void
mp_sched_timeout(void)
{
	LCK_MTX_ASSERT(&mp_timeout_lock, LCK_MTX_ASSERT_OWNED);

	if (!mp_timeout_run && (mp_garbage_collecting || mp_ticking)) {
		lck_mtx_convert_spin(&mp_timeout_lock);
		mp_timeout_run = TRUE;
		timeout(mp_timeout, NULL, hz);
	}
}

void
mp_gc_sched(void)
{
	lck_mtx_lock_spin(&mp_timeout_lock);
	mp_garbage_collecting = TRUE;
	mp_sched_timeout();
	lck_mtx_unlock(&mp_timeout_lock);
}

void
mptcp_timer_sched(void)
{
	lck_mtx_lock_spin(&mp_timeout_lock);
	mp_ticking = TRUE;
	mp_sched_timeout();
	lck_mtx_unlock(&mp_timeout_lock);
}

void
mp_pcbinfo_attach(struct mppcbinfo *mppi)
{
	struct mppcbinfo *mppi0;

	lck_mtx_lock(&mp_lock);
	TAILQ_FOREACH(mppi0, &mppi_head, mppi_entry) {
		if (mppi0 == mppi) {
			panic("%s: mppi %p already in the list\n",
			    __func__, mppi);
			/* NOTREACHED */
		}
	}
	TAILQ_INSERT_TAIL(&mppi_head, mppi, mppi_entry);
	lck_mtx_unlock(&mp_lock);
}

int
mp_pcbinfo_detach(struct mppcbinfo *mppi)
{
	struct mppcbinfo *mppi0;
	int error = 0;

	lck_mtx_lock(&mp_lock);
	TAILQ_FOREACH(mppi0, &mppi_head, mppi_entry) {
		if (mppi0 == mppi)
			break;
	}
	if (mppi0 != NULL)
		TAILQ_REMOVE(&mppi_head, mppi0, mppi_entry);
	else
		error = ENXIO;
	lck_mtx_unlock(&mp_lock);

	return (error);
}

int
mp_pcballoc(struct socket *so, struct mppcbinfo *mppi)
{
	struct mppcb *mpp = NULL;
	int error;

	VERIFY(mpsotomppcb(so) == NULL);

	mpp = zalloc(mppi->mppi_zone);
	if (mpp == NULL) {
		return (ENOBUFS);
	}

	bzero(mpp, mppi->mppi_size);
	lck_mtx_init(&mpp->mpp_lock, mppi->mppi_lock_grp, mppi->mppi_lock_attr);
	mpp->mpp_pcbinfo = mppi;
	mpp->mpp_state = MPPCB_STATE_INUSE;
	mpp->mpp_socket = so;
	so->so_pcb = mpp;

	error = mptcp_sescreate(mpp);
	if (error) {
		lck_mtx_destroy(&mpp->mpp_lock, mppi->mppi_lock_grp);
		zfree(mppi->mppi_zone, mpp);
		return (error);
	}

	lck_mtx_lock(&mppi->mppi_lock);
	mpp->mpp_flags |= MPP_ATTACHED;
	TAILQ_INSERT_TAIL(&mppi->mppi_pcbs, mpp, mpp_entry);
	mppi->mppi_count++;
	lck_mtx_unlock(&mppi->mppi_lock);

	return (0);
}

void
mp_pcbdetach(struct socket *mp_so)
{
	struct mppcb *mpp = mpsotomppcb(mp_so);

	mpp->mpp_state = MPPCB_STATE_DEAD;
	if (!(mp_so->so_flags & SOF_PCBCLEARING))
		mp_so->so_flags |= SOF_PCBCLEARING;

	mp_gc_sched();
}

void
mp_pcbdispose(struct mppcb *mpp)
{
	struct mppcbinfo *mppi = mpp->mpp_pcbinfo;

	VERIFY(mppi != NULL);

	LCK_MTX_ASSERT(&mppi->mppi_lock, LCK_MTX_ASSERT_OWNED);
	mpp_lock_assert_held(mpp);

	VERIFY(mpp->mpp_state == MPPCB_STATE_DEAD);
	VERIFY(mpp->mpp_flags & MPP_ATTACHED);

	mpp->mpp_flags &= ~MPP_ATTACHED;
	TAILQ_REMOVE(&mppi->mppi_pcbs, mpp, mpp_entry);
	VERIFY(mppi->mppi_count != 0);
	mppi->mppi_count--;

	mpp_unlock(mpp);

#if NECP
	necp_mppcb_dispose(mpp);
#endif /* NECP */

	lck_mtx_destroy(&mpp->mpp_lock, mppi->mppi_lock_grp);

	VERIFY(mpp->mpp_socket != NULL);
	VERIFY(mpp->mpp_socket->so_usecount == 0);
	mpp->mpp_socket->so_pcb = NULL;
	mpp->mpp_socket = NULL;

	zfree(mppi->mppi_zone, mpp);
}

static int
mp_getaddr_v4(struct socket *mp_so, struct sockaddr **nam, boolean_t peer)
{
	struct mptses *mpte = mpsotompte(mp_so);
	struct sockaddr_in *sin;

	/*
	 * Do the malloc first in case it blocks.
	 */
	MALLOC(sin, struct sockaddr_in *, sizeof (*sin), M_SONAME, M_WAITOK);
	if (sin == NULL)
		return (ENOBUFS);
	bzero(sin, sizeof (*sin));
	sin->sin_family = AF_INET;
	sin->sin_len = sizeof (*sin);

	if (!peer) {
		sin->sin_port = mpte->__mpte_src_v4.sin_port;
		sin->sin_addr = mpte->__mpte_src_v4.sin_addr;
	} else {
		sin->sin_port = mpte->__mpte_dst_v4.sin_port;
		sin->sin_addr = mpte->__mpte_dst_v4.sin_addr;
	}

	*nam = (struct sockaddr *)sin;
	return (0);
}

static int
mp_getaddr_v6(struct socket *mp_so, struct sockaddr **nam, boolean_t peer)
{
	struct mptses *mpte = mpsotompte(mp_so);
	struct in6_addr addr;
	in_port_t port;

	if (!peer) {
		port = mpte->__mpte_src_v6.sin6_port;
		addr = mpte->__mpte_src_v6.sin6_addr;
	} else {
		port = mpte->__mpte_dst_v6.sin6_port;
		addr = mpte->__mpte_dst_v6.sin6_addr;
	}

	*nam = in6_sockaddr(port, &addr);
	if (*nam == NULL)
		return (ENOBUFS);

	return (0);
}

int
mp_getsockaddr(struct socket *mp_so, struct sockaddr **nam)
{
	struct mptses *mpte = mpsotompte(mp_so);

	if (mpte->mpte_src.sa_family == AF_INET || mpte->mpte_src.sa_family == 0)
		return mp_getaddr_v4(mp_so, nam, false);
	else if (mpte->mpte_src.sa_family == AF_INET6)
		return mp_getaddr_v6(mp_so, nam, false);
	else
		return (EINVAL);
}

int
mp_getpeeraddr(struct socket *mp_so, struct sockaddr **nam)
{
	struct mptses *mpte = mpsotompte(mp_so);

	if (mpte->mpte_src.sa_family == AF_INET || mpte->mpte_src.sa_family == 0)
		return mp_getaddr_v4(mp_so, nam, true);
	else if (mpte->mpte_src.sa_family == AF_INET6)
		return mp_getaddr_v6(mp_so, nam, true);
	else
		return (EINVAL);
}
Commit	Line	Data
39236c6e	1	/*
5ba3f43e	2	* Copyright (c) 2012-2017 Apple Inc. All rights reserved.
39236c6e A	3	*
	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
	5	*
	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.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	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.
	25	*
	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
	28
	29	#include <sys/param.h>
	30	#include <sys/systm.h>
	31	#include <sys/kernel.h>
	32	#include <sys/mbuf.h>
	33	#include <sys/mcache.h>
	34	#include <sys/syslog.h>
	35	#include <sys/socket.h>
	36	#include <sys/socketvar.h>
	37	#include <sys/protosw.h>
	38	#include <sys/proc_internal.h>
	39
	40	#include <mach/boolean.h>
	41	#include <kern/zalloc.h>
	42	#include <kern/locks.h>
	43
	44	#include <netinet/mp_pcb.h>
	45	#include <netinet/mptcp_var.h>
5ba3f43e	46	#include <netinet6/in6_pcb.h>
39236c6e A	47
	48	static lck_grp_t *mp_lock_grp;
	49	static lck_attr_t *mp_lock_attr;
	50	static lck_grp_attr_t *mp_lock_grp_attr;
	51	decl_lck_mtx_data(static, mp_lock); /* global MULTIPATH lock */
	52	decl_lck_mtx_data(static, mp_timeout_lock);
	53
	54	static TAILQ_HEAD(, mppcbinfo) mppi_head = TAILQ_HEAD_INITIALIZER(mppi_head);
	55
	56	static boolean_t mp_timeout_run; /* MP timer is scheduled to run */
	57	static boolean_t mp_garbage_collecting;
	58	static boolean_t mp_ticking;
	59	static void mp_sched_timeout(void);
	60	static void mp_timeout(void *);
	61
	62	void
	63	mp_pcbinit(void)
	64	{
	65	static int mp_initialized = 0;
	66
	67	VERIFY(!mp_initialized);
	68	mp_initialized = 1;
	69
	70	mp_lock_grp_attr = lck_grp_attr_alloc_init();
	71	mp_lock_grp = lck_grp_alloc_init("multipath", mp_lock_grp_attr);
	72	mp_lock_attr = lck_attr_alloc_init();
	73	lck_mtx_init(&mp_lock, mp_lock_grp, mp_lock_attr);
	74	lck_mtx_init(&mp_timeout_lock, mp_lock_grp, mp_lock_attr);
	75	}
	76
	77	static void
	78	mp_timeout(void *arg)
	79	{
	80	#pragma unused(arg)
	81	struct mppcbinfo *mppi;
	82	boolean_t t, gc;
	83	uint32_t t_act = 0;
	84	uint32_t gc_act = 0;
	85
	86	/*
	87	* Update coarse-grained networking timestamp (in sec.); the idea
	88	* is to piggy-back on the timeout callout to update the counter
	89	* returnable via net_uptime().
	90	*/
	91	net_update_uptime();
	92
	93	lck_mtx_lock_spin(&mp_timeout_lock);
	94	gc = mp_garbage_collecting;
	95	mp_garbage_collecting = FALSE;
	96
	97	t = mp_ticking;
	98	mp_ticking = FALSE;
	99
	100	if (gc \|\| t) {
	101	lck_mtx_unlock(&mp_timeout_lock);
	102
	103	lck_mtx_lock(&mp_lock);
	104	TAILQ_FOREACH(mppi, &mppi_head, mppi_entry) {
	105	if ((gc && mppi->mppi_gc != NULL) \|\|
	106	(t && mppi->mppi_timer != NULL)) {
	107	lck_mtx_lock(&mppi->mppi_lock);
	108	if (gc && mppi->mppi_gc != NULL)
	109	gc_act += mppi->mppi_gc(mppi);
	110	if (t && mppi->mppi_timer != NULL)
111	t_act += mppi->mppi_timer(mppi);
112	lck_mtx_unlock(&mppi->mppi_lock);
113	}
114	}
115	lck_mtx_unlock(&mp_lock);
116
117	lck_mtx_lock_spin(&mp_timeout_lock);
118	}
119
120	/* lock was dropped above, so check first before overriding */
121	if (!mp_garbage_collecting)
122	mp_garbage_collecting = (gc_act != 0);
123	if (!mp_ticking)
124	mp_ticking = (t_act != 0);
125
126	/* re-arm the timer if there's work to do */
127	mp_timeout_run = FALSE;
128	mp_sched_timeout();
129	lck_mtx_unlock(&mp_timeout_lock);
130	}
131
132	static void
133	mp_sched_timeout(void)
134	{
5ba3f43e	135	LCK_MTX_ASSERT(&mp_timeout_lock, LCK_MTX_ASSERT_OWNED);
39236c6e A	136
	137	if (!mp_timeout_run && (mp_garbage_collecting \|\| mp_ticking)) {
	138	lck_mtx_convert_spin(&mp_timeout_lock);
	139	mp_timeout_run = TRUE;
	140	timeout(mp_timeout, NULL, hz);
	141	}
	142	}
	143
	144	void
	145	mp_gc_sched(void)
	146	{
	147	lck_mtx_lock_spin(&mp_timeout_lock);
	148	mp_garbage_collecting = TRUE;
	149	mp_sched_timeout();
	150	lck_mtx_unlock(&mp_timeout_lock);
	151	}
	152
	153	void
	154	mptcp_timer_sched(void)
	155	{
	156	lck_mtx_lock_spin(&mp_timeout_lock);
	157	mp_ticking = TRUE;
	158	mp_sched_timeout();
	159	lck_mtx_unlock(&mp_timeout_lock);
	160	}
	161
	162	void
	163	mp_pcbinfo_attach(struct mppcbinfo *mppi)
	164	{
	165	struct mppcbinfo *mppi0;
	166
	167	lck_mtx_lock(&mp_lock);
	168	TAILQ_FOREACH(mppi0, &mppi_head, mppi_entry) {
	169	if (mppi0 == mppi) {
	170	panic("%s: mppi %p already in the list\n",
	171	__func__, mppi);
	172	/* NOTREACHED */
	173	}
	174	}
	175	TAILQ_INSERT_TAIL(&mppi_head, mppi, mppi_entry);
	176	lck_mtx_unlock(&mp_lock);
	177	}
	178
	179	int
	180	mp_pcbinfo_detach(struct mppcbinfo *mppi)
	181	{
	182	struct mppcbinfo *mppi0;
	183	int error = 0;
	184
	185	lck_mtx_lock(&mp_lock);
	186	TAILQ_FOREACH(mppi0, &mppi_head, mppi_entry) {
	187	if (mppi0 == mppi)
	188	break;
	189	}
	190	if (mppi0 != NULL)
	191	TAILQ_REMOVE(&mppi_head, mppi0, mppi_entry);
	192	else
	193	error = ENXIO;
	194	lck_mtx_unlock(&mp_lock);
	195
	196	return (error);
	197	}
	198
	199	int
200	mp_pcballoc(struct socket so, struct mppcbinfo mppi)
201	{
3e170ce0	202	struct mppcb *mpp = NULL;
5ba3f43e	203	int error;
39236c6e	204
5ba3f43e	205	VERIFY(mpsotomppcb(so) == NULL);
39236c6e A	206
39236c6e A	207	mpp = zalloc(mppi->mppi_zone);
3e170ce0	208	if (mpp == NULL) {
39236c6e	209	return (ENOBUFS);
3e170ce0	210	}
39236c6e A	211
	212	bzero(mpp, mppi->mppi_size);
	213	lck_mtx_init(&mpp->mpp_lock, mppi->mppi_lock_grp, mppi->mppi_lock_attr);
	214	mpp->mpp_pcbinfo = mppi;
	215	mpp->mpp_state = MPPCB_STATE_INUSE;
	216	mpp->mpp_socket = so;
	217	so->so_pcb = mpp;
	218
5ba3f43e A	219	error = mptcp_sescreate(mpp);
5ba3f43e A	220	if (error) {
3e170ce0 A	221	lck_mtx_destroy(&mpp->mpp_lock, mppi->mppi_lock_grp);
3e170ce0 A	222	zfree(mppi->mppi_zone, mpp);
5ba3f43e	223	return (error);
3e170ce0 A	224	}
3e170ce0 A	225
39236c6e A	226	lck_mtx_lock(&mppi->mppi_lock);
	227	mpp->mpp_flags \|= MPP_ATTACHED;
	228	TAILQ_INSERT_TAIL(&mppi->mppi_pcbs, mpp, mpp_entry);
	229	mppi->mppi_count++;
	230	lck_mtx_unlock(&mppi->mppi_lock);
	231
	232	return (0);
	233	}
	234
	235	void
5ba3f43e	236	mp_pcbdetach(struct socket *mp_so)
39236c6e	237	{
5ba3f43e	238	struct mppcb *mpp = mpsotomppcb(mp_so);
39236c6e A	239
39236c6e A	240	mpp->mpp_state = MPPCB_STATE_DEAD;
5ba3f43e A	241	if (!(mp_so->so_flags & SOF_PCBCLEARING))
5ba3f43e A	242	mp_so->so_flags \|= SOF_PCBCLEARING;
39236c6e A	243
	244	mp_gc_sched();
	245	}
	246
	247	void
	248	mp_pcbdispose(struct mppcb *mpp)
	249	{
	250	struct mppcbinfo *mppi = mpp->mpp_pcbinfo;
	251
	252	VERIFY(mppi != NULL);
	253
5ba3f43e A	254	LCK_MTX_ASSERT(&mppi->mppi_lock, LCK_MTX_ASSERT_OWNED);
5ba3f43e A	255	mpp_lock_assert_held(mpp);
39236c6e A	256
39236c6e A	257	VERIFY(mpp->mpp_state == MPPCB_STATE_DEAD);
39236c6e	258	VERIFY(mpp->mpp_flags & MPP_ATTACHED);
5ba3f43e	259
39236c6e A	260	mpp->mpp_flags &= ~MPP_ATTACHED;
	261	TAILQ_REMOVE(&mppi->mppi_pcbs, mpp, mpp_entry);
	262	VERIFY(mppi->mppi_count != 0);
	263	mppi->mppi_count--;
	264
5ba3f43e A	265	mpp_unlock(mpp);
	266
	267	#if NECP
	268	necp_mppcb_dispose(mpp);
	269	#endif /* NECP */
	270
	271	lck_mtx_destroy(&mpp->mpp_lock, mppi->mppi_lock_grp);
	272
39236c6e A	273	VERIFY(mpp->mpp_socket != NULL);
	274	VERIFY(mpp->mpp_socket->so_usecount == 0);
	275	mpp->mpp_socket->so_pcb = NULL;
	276	mpp->mpp_socket = NULL;
	277
39236c6e A	278	zfree(mppi->mppi_zone, mpp);
39236c6e A	279	}
5ba3f43e A	280
	281	static int
	282	mp_getaddr_v4(struct socket mp_so, struct sockaddr *nam, boolean_t peer)
	283	{
	284	struct mptses *mpte = mpsotompte(mp_so);
	285	struct sockaddr_in *sin;
	286
	287	/*
	288	* Do the malloc first in case it blocks.
	289	*/
	290	MALLOC(sin, struct sockaddr_in , sizeof (sin), M_SONAME, M_WAITOK);
	291	if (sin == NULL)
	292	return (ENOBUFS);
	293	bzero(sin, sizeof (*sin));
	294	sin->sin_family = AF_INET;
	295	sin->sin_len = sizeof (*sin);
	296
	297	if (!peer) {
	298	sin->sin_port = mpte->__mpte_src_v4.sin_port;
	299	sin->sin_addr = mpte->__mpte_src_v4.sin_addr;
	300	} else {
	301	sin->sin_port = mpte->__mpte_dst_v4.sin_port;
	302	sin->sin_addr = mpte->__mpte_dst_v4.sin_addr;
	303	}
	304
	305	nam = (struct sockaddr )sin;
	306	return (0);
	307	}
	308
	309	static int
	310	mp_getaddr_v6(struct socket mp_so, struct sockaddr *nam, boolean_t peer)
	311	{
	312	struct mptses *mpte = mpsotompte(mp_so);
	313	struct in6_addr addr;
	314	in_port_t port;
	315
	316	if (!peer) {
	317	port = mpte->__mpte_src_v6.sin6_port;
	318	addr = mpte->__mpte_src_v6.sin6_addr;
	319	} else {
	320	port = mpte->__mpte_dst_v6.sin6_port;
	321	addr = mpte->__mpte_dst_v6.sin6_addr;
	322	}
	323
	324	*nam = in6_sockaddr(port, &addr);
	325	if (*nam == NULL)
	326	return (ENOBUFS);
	327
	328	return (0);
	329	}
	330
	331	int
	332	mp_getsockaddr(struct socket mp_so, struct sockaddr *nam)
	333	{
	334	struct mptses *mpte = mpsotompte(mp_so);
	335
	336	if (mpte->mpte_src.sa_family == AF_INET \|\| mpte->mpte_src.sa_family == 0)
	337	return mp_getaddr_v4(mp_so, nam, false);
a39ff7e2	338	else if (mpte->mpte_src.sa_family == AF_INET6)
5ba3f43e A	339	return mp_getaddr_v6(mp_so, nam, false);
	340	else
	341	return (EINVAL);
	342	}
	343
	344	int
	345	mp_getpeeraddr(struct socket mp_so, struct sockaddr *nam)
	346	{
	347	struct mptses *mpte = mpsotompte(mp_so);
	348
	349	if (mpte->mpte_src.sa_family == AF_INET \|\| mpte->mpte_src.sa_family == 0)
	350	return mp_getaddr_v4(mp_so, nam, true);
a39ff7e2	351	else if (mpte->mpte_src.sa_family == AF_INET6)
5ba3f43e A	352	return mp_getaddr_v6(mp_so, nam, true);
	353	else
	354	return (EINVAL);
	355	}