NetBSD/sys/compat/darwin/darwin_socket.c

/*	$NetBSD: darwin_socket.c,v 1.5 2004/07/28 22:24:06 manu Exp $ */

/*-
 * Copyright (c) 2004 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Emmanuel Dreyfus
 *
 * 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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *        This product includes software developed by the NetBSD
 *        Foundation, Inc. and its contributors.
 * 4. Neither the name of The NetBSD Foundation 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: darwin_socket.c,v 1.5 2004/07/28 22:24:06 manu Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/socket.h>
#include <sys/signal.h>
#include <sys/lwp.h>
#include <sys/sa.h>
#include <sys/socketvar.h>
#include <sys/un.h>
#include <sys/ucred.h>
#include <sys/mount.h>
#include <sys/syscallargs.h>

#include <compat/common/compat_util.h>
#include <compat/common/compat_file.h>

#include <compat/mach/mach_vm.h>

#include <compat/darwin/darwin_audit.h>
#include <compat/darwin/darwin_socket.h>
#include <compat/darwin/darwin_syscallargs.h>

unsigned char native_to_darwin_af[] = {
	0,
	DARWIN_AF_LOCAL,
	DARWIN_AF_INET,
	DARWIN_AF_IMPLINK,
	DARWIN_AF_PUP,
	DARWIN_AF_CHAOS,	/* 5 */
	DARWIN_AF_NS,
	DARWIN_AF_ISO,
	DARWIN_AF_ECMA,
	DARWIN_AF_DATAKIT,
	DARWIN_AF_CCITT,	/* 10 */
	DARWIN_AF_SNA,
	DARWIN_AF_DECnet,
	DARWIN_AF_DLI,
	DARWIN_AF_LAT,
	DARWIN_AF_HYLINK,	/* 15 */
	DARWIN_AF_APPLETALK,
	DARWIN_AF_ROUTE,
	DARWIN_AF_LINK,	
	DARWIN_AF_XTP,
	DARWIN_AF_COIP,		/* 20 */
	DARWIN_AF_CNT,
	DARWIN_AF_RTIP,
	DARWIN_AF_IPX,
	DARWIN_AF_INET6,
	DARWIN_AF_PIP,		/* 25 */
	DARWIN_AF_ISDN,
	DARWIN_AF_NATM,
	0,
	DARWIN_AF_KEY,
	DARWIN_AF_HDRCMPLT,	/* 30 */
	0,
	0,
	0,
	0,
	0,			/* 35 */
	0,
};

unsigned char darwin_to_native_af[] = {
	0,
	AF_LOCAL,
	AF_INET,
	AF_IMPLINK,
	AF_PUP,
	AF_CHAOS,	/* 5 */
	AF_NS,
	AF_ISO,
	AF_ECMA,
	AF_DATAKIT,
	AF_CCITT,	/* 10 */
	AF_SNA,
	AF_DECnet,
	AF_DLI,
	AF_LAT,
	AF_HYLINK,	/* 15 */
	AF_APPLETALK,
	AF_ROUTE,
	AF_LINK,	
	0,
	AF_COIP,	/* 20 */
	AF_CNT,
	0,
	AF_IPX,
	0,
	0,		/* 25 */
	0,
	0,
	AF_ISDN,
	pseudo_AF_KEY,
	AF_INET6,	/* 30 */
	AF_NATM,
	0,
	0,
	0,
	pseudo_AF_HDRCMPLT,	/* 35 */
	0,
};

void
native_to_darwin_sockaddr(nsa, dsa)
	struct sockaddr *nsa;
	struct sockaddr_storage *dsa;
{
	size_t len;

	if ((len = nsa->sa_len) > _SS_MAXSIZE) {
		printf("native_to_darwin_sockaddr: sa_len too big");
		return;
	}

	memcpy(dsa, nsa, len);
	dsa->ss_family = native_to_darwin_af[nsa->sa_family];

	return;
}

void
darwin_to_native_sockaddr(dsa, nsa)
	struct sockaddr *dsa;
	struct sockaddr_storage *nsa;
{
	size_t len;

	if ((len = dsa->sa_len) > _SS_MAXSIZE) {
		printf("darwin_to_native_sockaddr: sa_len too big");
		return;
	}

	if (len == 0) {
		/* 	
		 * It happens for AF_LOCAL sockets, where the
		 * size must be computed by hand...
		 */
		switch (dsa->sa_family) {
		case DARWIN_AF_LOCAL: {
			struct sockaddr_un *sun = (struct sockaddr_un *)dsa;

			len = sizeof(*sun) 
			    - sizeof(sun->sun_path) 
			    + strlen(sun->sun_path)
			    + 1; /* For trailing \0 */
			if (len > _SS_MAXSIZE) {
				printf("darwin_to_native_sockaddr: "
				    "sa_len too big");
				return;
			}
			break;
		}

		default:
			printf("darwin_to_native_sockaddr: sa_len not set");
			return;
			break;
		}
	}

	memcpy(nsa, dsa, len);
	nsa->ss_family = darwin_to_native_af[dsa->sa_family];

	return;
}

int
darwin_sys_socket(l, v, retval)
	struct lwp *l;
	void *v;
	register_t *retval;
{
	struct darwin_sys_socket_args /* {
		syscallarg(int) domain;
		syscallarg(int) type;
		syscallarg(int) protocol;
	} */ *uap = v;
	struct sys_socket_args cup;

	SCARG(&cup, domain) = darwin_to_native_af[SCARG(uap, domain)];
	SCARG(&cup, type) = SCARG(uap, type);
	SCARG(&cup, protocol) = SCARG(uap, protocol);

	return sys_socket(l, &cup, retval);
}

int
darwin_sys_recvfrom(l, v, retval)
	struct lwp *l;
	void *v;
	register_t *retval;
{
	struct darwin_sys_recvfrom_args /* {
		syscallarg(int) s;
		syscallarg(void *) buf;
		syscallarg(size_t) len;
		syscallarg(int) flags;
		syscallarg(struct sockaddr *) from;
		syscallarg(unsigned int *) fromlenaddr;
	} */ *uap = v;
	struct proc *p = l->l_proc;
	struct sys_recvfrom_args cup;
	caddr_t sg = stackgap_init(p, 0);
	struct sockaddr_storage nss;
	struct sockaddr_storage dss;
	struct sockaddr_storage *nssp;
	size_t len;
	int error;

	if (SCARG(uap, from) != NULL)
		nssp = stackgap_alloc(p, &sg, sizeof(*nssp));
	else
		nssp = NULL;

	SCARG(&cup, s) = SCARG(uap, s);
	SCARG(&cup, buf) = SCARG(uap, buf);
	SCARG(&cup, len) = SCARG(uap, len);
	SCARG(&cup, flags) = SCARG(uap, flags);
	SCARG(&cup, from) = (struct sockaddr *)nssp;
	SCARG(&cup, fromlenaddr) = SCARG(uap, fromlenaddr);

	if ((error = sys_recvfrom(l, &cup, retval)) != 0)
		return error;

	if ((error = copyin(nssp, &nss, sizeof(nss))) != 0)
		return error;

	native_to_darwin_sockaddr((struct sockaddr *)&nss, &dss);

	if ((error = copyin(SCARG(uap, fromlenaddr), &len, sizeof(len))) != 0)
		return error;

	if (len > _SS_MAXSIZE)
		len = _SS_MAXSIZE;
	if (dss.ss_len < len)
		len = dss.ss_len;

	if ((error = copyout(&dss, SCARG(uap, from), len)) != 0)
		return error;

	if ((error = copyout(&len, SCARG(uap, fromlenaddr), sizeof(len))) != 0)
		return error;
	
	return 0;
}

int
darwin_sys_accept(l, v, retval)
	struct lwp *l;
	void *v;
	register_t *retval;
{
	struct darwin_sys_accept_args /* {
		syscallarg(int) s;
		syscallarg(struct sockaddr *) name;
		syscallarg(unsigned int *) anamelen;
	} */ *uap = v;
	struct sys_accept_args cup;
	struct proc *p = l->l_proc;
	caddr_t sg = stackgap_init(p, 0);
	struct sockaddr_storage nss;
	struct sockaddr_storage dss;
	struct sockaddr_storage *nssp;
	size_t len;
	int error;

	nssp = stackgap_alloc(p, &sg, sizeof(*nssp));

	SCARG(&cup, s) = SCARG(uap, s);
	SCARG(&cup, name) = (struct sockaddr *)nssp;
	SCARG(&cup, anamelen) = SCARG(uap, anamelen);

	if ((error = sys_accept(l, &cup, retval)) != 0)
		return error;

	if ((error = copyin(nssp, &nss, sizeof(nss))) != 0)
		return error;

	native_to_darwin_sockaddr((struct sockaddr *)&nss, &dss);

	if ((error = copyin(SCARG(uap, anamelen), &len, sizeof(len))) != 0)
		return error;

	if (len > _SS_MAXSIZE)
		len = _SS_MAXSIZE;
	if (dss.ss_len < len)
		len = dss.ss_len;

	if ((error = copyout(&dss, SCARG(uap, name), len)) != 0)
		return error;

	if ((error = copyout(&len, SCARG(uap, anamelen), sizeof(len))) != 0)
		return error;

	return 0;
}

int
darwin_sys_getpeername(l, v, retval)
	struct lwp *l;
	void *v;
	register_t *retval;
{
	struct darwin_sys_getpeername_args /* {
		syscallarg(int) fdes;
		syscallarg(struct sockaddr *) asa;
		syscallarg(unsigned int *) alen;
	} */ *uap = v;
	struct sys_getpeername_args cup;
	struct proc *p = l->l_proc;
	caddr_t sg = stackgap_init(p, 0);
	struct sockaddr_storage nss;
	struct sockaddr_storage dss;
	struct sockaddr_storage *nssp;
	size_t len;
	int error;

	nssp = stackgap_alloc(p, &sg, sizeof(*nssp));

	SCARG(&cup, fdes) = SCARG(uap, fdes);
	SCARG(&cup, asa) = (struct sockaddr *)nssp;
	SCARG(&cup, alen) = SCARG(uap, alen);

	if ((error = sys_getpeername(l, &cup, retval)) != 0)
		return error;

	if ((error = copyin(nssp, &nss, sizeof(nss))) != 0)
		return error;

	native_to_darwin_sockaddr((struct sockaddr *)&nss, &dss);

	if ((error = copyin(SCARG(uap, alen), &len, sizeof(len))) != 0)
		return error;

	if (len > _SS_MAXSIZE)
		len = _SS_MAXSIZE;
	if (dss.ss_len < len)
		len = dss.ss_len;

	if ((error = copyout(&dss, SCARG(uap, asa), len)) != 0)
		return error;

	if ((error = copyout(&len, SCARG(uap, alen), sizeof(len))) != 0)
		return error;
	
	return 0;
}

int
darwin_sys_getsockname(l, v, retval)
	struct lwp *l;
	void *v;
	register_t *retval;
{
	struct darwin_sys_getsockname_args /* {
		syscallarg(int) fdes;
		syscallarg(struct sockaddr *) asa;
		syscallarg(unsigned int *) alen;
	} */ *uap = v;
	struct sys_getsockname_args cup;
	struct proc *p = l->l_proc;
	caddr_t sg = stackgap_init(p, 0);
	struct sockaddr_storage nss;
	struct sockaddr_storage dss;
	struct sockaddr_storage *nssp;
	size_t len;
	int error;

	nssp = stackgap_alloc(p, &sg, sizeof(*nssp));

	SCARG(&cup, fdes) = SCARG(uap, fdes);
	SCARG(&cup, asa) = (struct sockaddr *)nssp;
	SCARG(&cup, alen) = SCARG(uap, alen);

	if ((error = sys_getsockname(l, &cup, retval)) != 0)
		return error;

	if ((error = copyin(nssp, &nss, sizeof(nss))) != 0)
		return error;

	native_to_darwin_sockaddr((struct sockaddr *)&nss, &dss);

	if ((error = copyin(SCARG(uap, alen), &len, sizeof(len))) != 0)
		return error;

	if (len > _SS_MAXSIZE)
		len = _SS_MAXSIZE;
	if (dss.ss_len < len)
		len = dss.ss_len;

	if ((error = copyout(&dss, SCARG(uap, asa), len)) != 0)
		return error;

	if ((error = copyout(&len, SCARG(uap, alen), sizeof(len))) != 0)
		return error;
	
	return 0;
}

int
darwin_sys_connect(l, v, retval)
	struct lwp *l;
	void *v;
	register_t *retval;
{
	struct darwin_sys_connect_args /* {
		syscallarg(int) s;
		syscallarg(struct sockaddr *) name;
		syscallarg(unsigned int *) namelen;
	} */ *uap = v;
	struct sys_connect_args cup;
	struct proc *p = l->l_proc;
	caddr_t sg = stackgap_init(p, 0);
	struct sockaddr_storage nss;
	struct sockaddr_storage dss;
	struct sockaddr_storage *nssp;
	size_t len;
	int error;

	nssp = stackgap_alloc(p, &sg, sizeof(*nssp));

	if ((error = copyin(SCARG(uap, name), &dss, sizeof(dss))) != 0)
		return error;

	darwin_to_native_sockaddr((struct sockaddr *)&dss, &nss);

	len = SCARG(uap, namelen);
	if (nss.ss_len < len)
		len = nss.ss_len;	

	if ((error = copyout(&nss, nssp, sizeof(nss))) != 0)
		return error;

	SCARG(&cup, s) = SCARG(uap, s);
	SCARG(&cup, name) = (struct sockaddr *)nssp;
	SCARG(&cup, namelen) = len;

	return bsd_sys_connect(l, &cup, retval);
}

int
darwin_sys_bind(l, v, retval)
	struct lwp *l;
	void *v;
	register_t *retval;
{
	struct darwin_sys_bind_args /* {
		syscallarg(int) s;
		syscallarg(struct sockaddr *) name;
		syscallarg(unsigned int *) namelen;
	} */ *uap = v;
	struct sys_bind_args cup;
	struct proc *p = l->l_proc;
	caddr_t sg = stackgap_init(p, 0);
	struct sockaddr_storage nss;
	struct sockaddr_storage dss;
	struct sockaddr_storage *nssp;
	size_t len;
	int error;

	nssp = stackgap_alloc(p, &sg, sizeof(*nssp));

	if ((error = copyin(SCARG(uap, name), &dss, sizeof(dss))) != 0)
		return error;

	darwin_to_native_sockaddr((struct sockaddr *)&dss, &nss);

	len = SCARG(uap, namelen);
	if (nss.ss_len < len)
		len = nss.ss_len;	

	if ((error = copyout(&nss, nssp, sizeof(nss))) != 0)
		return error;

	SCARG(&cup, s) = SCARG(uap, s);
	SCARG(&cup, name) = (struct sockaddr *)nssp;
	SCARG(&cup, namelen) = len;

	return bsd_sys_bind(l, &cup, retval);
}

int
darwin_sys_sendto(l, v, retval)
	struct lwp *l;
	void *v;
	register_t *retval;
{
	struct darwin_sys_sendto_args /* {
		syscallarg(int) s;
		syscallarg(const void *) buf;
		syscallarg(size_t) len;
		syscallarg(int) flags;
		syscallarg(struct sockaddr *) to;
		syscallarg(unsigned int) tolen;
	} */ *uap = v;
	struct sys_sendto_args cup;
	struct proc *p = l->l_proc;
	caddr_t sg = stackgap_init(p, 0);
	struct sockaddr_storage nss;
	struct sockaddr_storage dss;
	struct sockaddr_storage *nssp;
	size_t len;
	int error;

	nssp = stackgap_alloc(p, &sg, sizeof(*nssp));

	if ((error = copyin(SCARG(uap, to), &dss, sizeof(dss))) != 0)
		return error;

	darwin_to_native_sockaddr((struct sockaddr *)&dss, &nss);

	len = SCARG(uap, tolen);
	if (nss.ss_len < len)
		len = nss.ss_len;	

	if ((error = copyout(&nss, nssp, sizeof(nss))) != 0)
		return error;

	SCARG(&cup, s) = SCARG(uap, s);
	SCARG(&cup, buf) = SCARG(uap, buf);
	SCARG(&cup, len) = SCARG(uap, len);
	SCARG(&cup, flags) = SCARG(uap, flags);
	SCARG(&cup, to) = (struct sockaddr *)nssp;
	SCARG(&cup, tolen) = len;

	return sys_sendto(l, &cup, retval);
}