[apple/xnu.git] / bsd / kern / sys_socket.c

/*
 * Copyright (c) 2000-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) 1982, 1986, 1990, 1993
 *	The Regents of the University of California.  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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.
 *
 *	@(#)sys_socket.c	8.1 (Berkeley) 6/10/93
 */
/*
 * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
 * support for mandatory and extensible security protections.  This notice
 * is included in support of clause 2.2 (b) of the Apple Public License,
 * Version 2.0.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/file_internal.h>
#include <sys/event.h>
#include <sys/protosw.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/filio.h>			/* XXX */
#include <sys/sockio.h>
#include <sys/stat.h>
#include <sys/uio.h>
#include <sys/filedesc.h>
#include <sys/kauth.h>
#include <sys/signalvar.h>
#include <sys/vnode.h>

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

#if CONFIG_MACF
#include <security/mac_framework.h>
#endif

/*
 * File operations on sockets.
 */
static int soo_read(struct fileproc *, struct uio *, int, vfs_context_t ctx);
static int soo_write(struct fileproc *, struct uio *, int, vfs_context_t ctx);
static int soo_close(struct fileglob *, vfs_context_t ctx);
static int soo_drain(struct fileproc *, vfs_context_t ctx);

const struct fileops socketops = {
	.fo_type = DTYPE_SOCKET,
	.fo_read = soo_read,
	.fo_write = soo_write,
	.fo_ioctl = soo_ioctl,
	.fo_select = soo_select,
	.fo_close = soo_close,
	.fo_kqfilter = soo_kqfilter,
	.fo_drain = soo_drain,
};

/* ARGSUSED */
static int
soo_read(struct fileproc *fp, struct uio *uio, __unused int flags,
#if !CONFIG_MACF_SOCKET
	__unused
#endif
	vfs_context_t ctx)
{
	struct socket *so;
	int stat;
#if CONFIG_MACF_SOCKET
	int error;
#endif

	int (*fsoreceive)(struct socket *so2, struct sockaddr **paddr,
	    struct uio *uio2, struct mbuf **mp0, struct mbuf **controlp,
	    int *flagsp);

	if ((so = (struct socket *)fp->f_fglob->fg_data) == NULL) {
		/* This is not a valid open file descriptor */
		return (EBADF);
	}

#if CONFIG_MACF_SOCKET
	error = mac_socket_check_receive(vfs_context_ucred(ctx), so);
	if (error)
		return (error);
#endif /* CONFIG_MACF_SOCKET */

	fsoreceive = so->so_proto->pr_usrreqs->pru_soreceive;

	stat = (*fsoreceive)(so, 0, uio, 0, 0, 0);
	return (stat);
}

/* ARGSUSED */
static int
soo_write(struct fileproc *fp, struct uio *uio, __unused int flags,
	vfs_context_t ctx)
{
	struct socket *so;
	int stat;
	int (*fsosend)(struct socket *so2, struct sockaddr *addr,
	    struct uio *uio2, struct mbuf *top, struct mbuf *control,
	    int flags2);
	proc_t procp;

#if CONFIG_MACF_SOCKET
	int error;
#endif

	if ((so = (struct socket *)fp->f_fglob->fg_data) == NULL) {
		/* This is not a valid open file descriptor */
		return (EBADF);
	}

#if CONFIG_MACF_SOCKET
	/* JMM - have to fetch the socket's remote addr */
	error = mac_socket_check_send(vfs_context_ucred(ctx), so, NULL);
	if (error)
		return (error);
#endif /* CONFIG_MACF_SOCKET */

	fsosend = so->so_proto->pr_usrreqs->pru_sosend;

	stat = (*fsosend)(so, 0, uio, 0, 0, 0);

	/* Generation of SIGPIPE can be controlled per socket */
	procp = vfs_context_proc(ctx);
	if (stat == EPIPE && !(so->so_flags & SOF_NOSIGPIPE))
		psignal(procp, SIGPIPE);

	return (stat);
}

__private_extern__ int
soioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p)
{
	int error = 0;
	int int_arg;

#if CONFIG_MACF_SOCKET_SUBSET
	error = mac_socket_check_ioctl(kauth_cred_get(), so, cmd);
	if (error)
		return (error);
#endif

	socket_lock(so, 1);

	/* call the socket filter's ioctl handler anything but ours */
	if (IOCGROUP(cmd) != 'i' && IOCGROUP(cmd) != 'r') {
		switch (cmd) {
		case SIOCGASSOCIDS32:
		case SIOCGASSOCIDS64:
		case SIOCGCONNIDS32:
		case SIOCGCONNIDS64:
		case SIOCGCONNINFO32:
		case SIOCGCONNINFO64:
		case SIOCSCONNORDER:
		case SIOCGCONNORDER:
			/* don't pass to filter */
			break;

		default:
			error = sflt_ioctl(so, cmd, data);
			if (error != 0)
				goto out;
			break;
		}
	}

	switch (cmd) {
	case FIONBIO:			/* int */
		bcopy(data, &int_arg, sizeof (int_arg));
		if (int_arg)
			so->so_state |= SS_NBIO;
		else
			so->so_state &= ~SS_NBIO;

		goto out;

	case FIOASYNC:			/* int */
		bcopy(data, &int_arg, sizeof (int_arg));
		if (int_arg) {
			so->so_state |= SS_ASYNC;
			so->so_rcv.sb_flags |= SB_ASYNC;
			so->so_snd.sb_flags |= SB_ASYNC;
		} else {
			so->so_state &= ~SS_ASYNC;
			so->so_rcv.sb_flags &= ~SB_ASYNC;
			so->so_snd.sb_flags &= ~SB_ASYNC;
		}
		goto out;

	case FIONREAD:			/* int */
		bcopy(&so->so_rcv.sb_cc, data, sizeof (u_int32_t));
		goto out;

	case SIOCSPGRP:			/* int */
		bcopy(data, &so->so_pgid, sizeof (pid_t));
		goto out;

	case SIOCGPGRP:			/* int */
		bcopy(&so->so_pgid, data, sizeof (pid_t));
		goto out;

	case SIOCATMARK:		/* int */
		int_arg = (so->so_state & SS_RCVATMARK) != 0;
		bcopy(&int_arg, data, sizeof (int_arg));
		goto out;

	case SIOCSETOT:			/* int; deprecated */
		error = EOPNOTSUPP;
		goto out;

	case SIOCGASSOCIDS32:		/* so_aidreq32 */
	case SIOCGASSOCIDS64:		/* so_aidreq64 */
	case SIOCGCONNIDS32:		/* so_cidreq32 */
	case SIOCGCONNIDS64:		/* so_cidreq64 */
	case SIOCGCONNINFO32:		/* so_cinforeq32 */
	case SIOCGCONNINFO64:		/* so_cinforeq64 */
	case SIOCSCONNORDER:		/* so_cordreq */
	case SIOCGCONNORDER:		/* so_cordreq */
		error = (*so->so_proto->pr_usrreqs->pru_control)(so,
		    cmd, data, NULL, p);
		goto out;
	}

	/*
	 * Interface/routing/protocol specific ioctls:
	 * interface and routing ioctls should have a
	 * different entry since a socket's unnecessary
	 */
	if (IOCGROUP(cmd) == 'i') {
		error = ifioctllocked(so, cmd, data, p);
	} else {
		if (IOCGROUP(cmd) == 'r')
			error = rtioctl(cmd, data, p);
		else
			error = (*so->so_proto->pr_usrreqs->pru_control)(so,
			    cmd, data, NULL, p);
	}

out:
	socket_unlock(so, 1);

	if (error == EJUSTRETURN)
		error = 0;

	return (error);
}

int
soo_ioctl(struct fileproc *fp, u_long cmd, caddr_t data, vfs_context_t ctx)
{
	struct socket *so;
	proc_t procp = vfs_context_proc(ctx);

	if ((so = (struct socket *)fp->f_fglob->fg_data) == NULL) {
		/* This is not a valid open file descriptor */
		return (EBADF);
	}

	return (soioctl(so, cmd, data, procp));
}

int
soo_select(struct fileproc *fp, int which, void *wql, vfs_context_t ctx)
{
	struct socket *so = (struct socket *)fp->f_fglob->fg_data;
	int retnum = 0;
	proc_t procp;

	if (so == NULL || so == (struct socket *)-1)
		return (0);

	procp = vfs_context_proc(ctx);

#if CONFIG_MACF_SOCKET
	if (mac_socket_check_select(vfs_context_ucred(ctx), so, which) != 0)
		return (0);
#endif /* CONFIG_MACF_SOCKET */


	socket_lock(so, 1);
	switch (which) {

	case FREAD:
		so->so_rcv.sb_flags |= SB_SEL;
		if (soreadable(so)) {
			retnum = 1;
			so->so_rcv.sb_flags &= ~SB_SEL;
			goto done;
		}
		selrecord(procp, &so->so_rcv.sb_sel, wql);
		break;

	case FWRITE:
		so->so_snd.sb_flags |= SB_SEL;
		if (sowriteable(so)) {
			retnum = 1;
			so->so_snd.sb_flags &= ~SB_SEL;
			goto done;
		}
		selrecord(procp, &so->so_snd.sb_sel, wql);
		break;

	case 0:
		so->so_rcv.sb_flags |= SB_SEL;
		if (so->so_oobmark || (so->so_state & SS_RCVATMARK)) {
			retnum = 1;
			so->so_rcv.sb_flags &= ~SB_SEL;
			goto done;
		}
		selrecord(procp, &so->so_rcv.sb_sel, wql);
		break;
	}

done:
	socket_unlock(so, 1);
	return (retnum);
}

int
soo_stat(struct socket *so, void *ub, int isstat64)
{
	int ret;
	/* warning avoidance ; protected by isstat64 */
	struct stat *sb = (struct stat *)0;
	/* warning avoidance ; protected by isstat64 */
	struct stat64 *sb64 = (struct stat64 *)0;

#if CONFIG_MACF_SOCKET_SUBSET
	ret = mac_socket_check_stat(kauth_cred_get(), so);
	if (ret)
		return (ret);
#endif

	if (isstat64 != 0) {
		sb64 = (struct stat64 *)ub;
		bzero((caddr_t)sb64, sizeof (*sb64));
	} else {
		sb = (struct stat *)ub;
		bzero((caddr_t)sb, sizeof (*sb));
	}

	socket_lock(so, 1);
	if (isstat64 != 0) {
		sb64->st_mode = S_IFSOCK;
		if ((so->so_state & SS_CANTRCVMORE) == 0 ||
		    so->so_rcv.sb_cc != 0)
			sb64->st_mode |= S_IRUSR | S_IRGRP | S_IROTH;
		if ((so->so_state & SS_CANTSENDMORE) == 0)
			sb64->st_mode |= S_IWUSR | S_IWGRP | S_IWOTH;
		sb64->st_size = so->so_rcv.sb_cc - so->so_rcv.sb_ctl;
		sb64->st_uid = kauth_cred_getuid(so->so_cred);
		sb64->st_gid = kauth_cred_getgid(so->so_cred);
	} else {
		sb->st_mode = S_IFSOCK;
		if ((so->so_state & SS_CANTRCVMORE) == 0 ||
		    so->so_rcv.sb_cc != 0)
			sb->st_mode |= S_IRUSR | S_IRGRP | S_IROTH;
		if ((so->so_state & SS_CANTSENDMORE) == 0)
			sb->st_mode |= S_IWUSR | S_IWGRP | S_IWOTH;
		sb->st_size = so->so_rcv.sb_cc - so->so_rcv.sb_ctl;
		sb->st_uid = kauth_cred_getuid(so->so_cred);
		sb->st_gid = kauth_cred_getgid(so->so_cred);
	}

	ret = (*so->so_proto->pr_usrreqs->pru_sense)(so, ub, isstat64);
	socket_unlock(so, 1);
	return (ret);
}

/* ARGSUSED */
static int
soo_close(struct fileglob *fg, __unused vfs_context_t ctx)
{
	int error = 0;
	struct socket *sp;

	sp = (struct socket *)fg->fg_data;
	fg->fg_data = NULL;

	if (sp)
		error = soclose(sp);

	return (error);
}

static int
soo_drain(struct fileproc *fp, __unused vfs_context_t ctx)
{
	int error = 0;
	struct socket *so = (struct socket *)fp->f_fglob->fg_data;

	if (so) {
		socket_lock(so, 1);
		so->so_state |= SS_DRAINING;

		wakeup((caddr_t)&so->so_timeo);
		sorwakeup(so);
		sowwakeup(so);
		soevent(so, SO_FILT_HINT_LOCKED);

		socket_unlock(so, 1);
	}

	return (error);
}

/*
 * 's' group ioctls.
 *
 * The switch statement below does nothing at runtime, as it serves as a
 * compile time check to ensure that all of the socket 's' ioctls (those
 * in the 's' group going thru soo_ioctl) that are made available by the
 * networking stack is unique.  This works as long as this routine gets
 * updated each time a new interface ioctl gets added.
 *
 * Any failures at compile time indicates duplicated ioctl values.
 */
static __attribute__((unused)) void
soioctl_cassert(void)
{
	/*
	 * This is equivalent to _CASSERT() and the compiler wouldn't
	 * generate any instructions, thus for compile time only.
	 */
	switch ((u_long)0) {
	case 0:

	/* bsd/sys/sockio.h */
	case SIOCSHIWAT:
	case SIOCGHIWAT:
	case SIOCSLOWAT:
	case SIOCGLOWAT:
	case SIOCATMARK:
	case SIOCSPGRP:
	case SIOCGPGRP:
	case SIOCSETOT:
	case SIOCGASSOCIDS32:
	case SIOCGASSOCIDS64:
	case SIOCGCONNIDS32:
	case SIOCGCONNIDS64:
	case SIOCGCONNINFO32:
	case SIOCGCONNINFO64:
	case SIOCSCONNORDER:
	case SIOCGCONNORDER:
		;
	}
}
Commit	Line	Data
1c79356b	1	/*
39236c6e	2	* Copyright (c) 2000-2013 Apple Inc. All rights reserved.
5d5c5d0d	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
39236c6e	5	*
2d21ac55 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	*
2d21ac55 A	15	* Please obtain a copy of the License at
2d21ac55 A	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
39236c6e	17	*
2d21ac55 A	18	* The Original Code and all software distributed under the License are
2d21ac55 A	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	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	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/*
	29	* Copyright (c) 1982, 1986, 1990, 1993
	30	* The Regents of the University of California. All rights reserved.
	31	*
	32	* Redistribution and use in source and binary forms, with or without
	33	* modification, are permitted provided that the following conditions
	34	* are met:
	35	* 1. Redistributions of source code must retain the above copyright
	36	* notice, this list of conditions and the following disclaimer.
	37	* 2. Redistributions in binary form must reproduce the above copyright
	38	* notice, this list of conditions and the following disclaimer in the
	39	* documentation and/or other materials provided with the distribution.
	40	* 3. All advertising materials mentioning features or use of this software
	41	* must display the following acknowledgement:
	42	* This product includes software developed by the University of
	43	* California, Berkeley and its contributors.
	44	* 4. Neither the name of the University nor the names of its contributors
	45	* may be used to endorse or promote products derived from this software
	46	* without specific prior written permission.
	47	*
	48	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	49	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	50	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	51	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	52	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	53	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	54	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	55	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	56	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	57	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	58	* SUCH DAMAGE.
	59	*
	60	* @(#)sys_socket.c 8.1 (Berkeley) 6/10/93
	61	*/
2d21ac55 A	62	/*
	63	* NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
	64	* support for mandatory and extensible security protections. This notice
	65	* is included in support of clause 2.2 (b) of the Apple Public License,
	66	* Version 2.0.
	67	*/
1c79356b A	68
	69	#include <sys/param.h>
	70	#include <sys/systm.h>
91447636	71	#include <sys/file_internal.h>
55e303ae	72	#include <sys/event.h>
1c79356b A	73	#include <sys/protosw.h>
	74	#include <sys/socket.h>
	75	#include <sys/socketvar.h>
	76	#include <sys/filio.h> /* XXX */
	77	#include <sys/sockio.h>
	78	#include <sys/stat.h>
	79	#include <sys/uio.h>
	80	#include <sys/filedesc.h>
91447636 A	81	#include <sys/kauth.h>
91447636 A	82	#include <sys/signalvar.h>
2d21ac55	83	#include <sys/vnode.h>
1c79356b A	84
	85	#include <net/if.h>
	86	#include <net/route.h>
	87
2d21ac55 A	88	#if CONFIG_MACF
	89	#include <security/mac_framework.h>
	90	#endif
	91
91447636 A	92	/*
	93	* File operations on sockets.
	94	*/
2d21ac55 A	95	static int soo_read(struct fileproc , struct uio , int, vfs_context_t ctx);
	96	static int soo_write(struct fileproc , struct uio , int, vfs_context_t ctx);
	97	static int soo_close(struct fileglob *, vfs_context_t ctx);
	98	static int soo_drain(struct fileproc *, vfs_context_t ctx);
	99
39236c6e	100	const struct fileops socketops = {
39037602 A	101	.fo_type = DTYPE_SOCKET,
	102	.fo_read = soo_read,
	103	.fo_write = soo_write,
	104	.fo_ioctl = soo_ioctl,
	105	.fo_select = soo_select,
	106	.fo_close = soo_close,
	107	.fo_kqfilter = soo_kqfilter,
	108	.fo_drain = soo_drain,
2d21ac55	109	};
1c79356b A	110
1c79356b A	111	/* ARGSUSED */
2d21ac55 A	112	static int
	113	soo_read(struct fileproc fp, struct uio uio, __unused int flags,
	114	#if !CONFIG_MACF_SOCKET
	115	__unused
	116	#endif
	117	vfs_context_t ctx)
1c79356b	118	{
9bccf70c	119	struct socket *so;
1c79356b	120	int stat;
2d21ac55 A	121	#if CONFIG_MACF_SOCKET
	122	int error;
	123	#endif
1c79356b	124
2d21ac55 A	125	int (fsoreceive)(struct socket so2, struct sockaddr **paddr,
	126	struct uio uio2, struct mbuf mp0, struct mbuf *controlp,
	127	int *flagsp);
0b4e3aa0	128
2d21ac55 A	129	if ((so = (struct socket *)fp->f_fglob->fg_data) == NULL) {
	130	/* This is not a valid open file descriptor */
	131	return (EBADF);
	132	}
	133
	134	#if CONFIG_MACF_SOCKET
	135	error = mac_socket_check_receive(vfs_context_ucred(ctx), so);
	136	if (error)
	137	return (error);
	138	#endif /* CONFIG_MACF_SOCKET */
0b4e3aa0	139
1c79356b	140	fsoreceive = so->so_proto->pr_usrreqs->pru_soreceive;
2d21ac55	141
1c79356b	142	stat = (*fsoreceive)(so, 0, uio, 0, 0, 0);
2d21ac55	143	return (stat);
1c79356b A	144	}
	145
	146	/* ARGSUSED */
2d21ac55 A	147	static int
	148	soo_write(struct fileproc fp, struct uio uio, __unused int flags,
	149	vfs_context_t ctx)
1c79356b	150	{
9bccf70c	151	struct socket *so;
2d21ac55 A	152	int stat;
	153	int (fsosend)(struct socket so2, struct sockaddr *addr,
	154	struct uio uio2, struct mbuf top, struct mbuf *control,
	155	int flags2);
	156	proc_t procp;
	157
	158	#if CONFIG_MACF_SOCKET
	159	int error;
	160	#endif
1c79356b	161
91447636 A	162	if ((so = (struct socket *)fp->f_fglob->fg_data) == NULL) {
	163	/* This is not a valid open file descriptor */
	164	return (EBADF);
	165	}
9bccf70c	166
2d21ac55 A	167	#if CONFIG_MACF_SOCKET
	168	/* JMM - have to fetch the socket's remote addr */
	169	error = mac_socket_check_send(vfs_context_ucred(ctx), so, NULL);
	170	if (error)
	171	return (error);
	172	#endif /* CONFIG_MACF_SOCKET */
	173
1c79356b	174	fsosend = so->so_proto->pr_usrreqs->pru_sosend;
1c79356b A	175
1c79356b A	176	stat = (*fsosend)(so, 0, uio, 0, 0, 0);
9bccf70c	177
91447636	178	/* Generation of SIGPIPE can be controlled per socket */
2d21ac55	179	procp = vfs_context_proc(ctx);
b0d623f7	180	if (stat == EPIPE && !(so->so_flags & SOF_NOSIGPIPE))
91447636	181	psignal(procp, SIGPIPE);
9bccf70c	182
2d21ac55	183	return (stat);
1c79356b A	184	}
1c79356b A	185
91447636	186	__private_extern__ int
2d21ac55	187	soioctl(struct socket so, u_long cmd, caddr_t data, struct proc p)
1c79356b	188	{
2d21ac55	189	int error = 0;
316670eb	190	int int_arg;
9bccf70c	191
5ba3f43e A	192	#if CONFIG_MACF_SOCKET_SUBSET
	193	error = mac_socket_check_ioctl(kauth_cred_get(), so, cmd);
	194	if (error)
	195	return (error);
	196	#endif
	197
b0d623f7	198	socket_lock(so, 1);
1c79356b	199
39236c6e	200	/* call the socket filter's ioctl handler anything but ours */
2d21ac55	201	if (IOCGROUP(cmd) != 'i' && IOCGROUP(cmd) != 'r') {
39236c6e A	202	switch (cmd) {
	203	case SIOCGASSOCIDS32:
	204	case SIOCGASSOCIDS64:
	205	case SIOCGCONNIDS32:
	206	case SIOCGCONNIDS64:
	207	case SIOCGCONNINFO32:
	208	case SIOCGCONNINFO64:
	209	case SIOCSCONNORDER:
	210	case SIOCGCONNORDER:
	211	/* don't pass to filter */
	212	break;
	213
	214	default:
	215	error = sflt_ioctl(so, cmd, data);
	216	if (error != 0)
	217	goto out;
	218	break;
	219	}
2d21ac55 A	220	}
2d21ac55 A	221
1c79356b	222	switch (cmd) {
316670eb A	223	case FIONBIO: /* int */
	224	bcopy(data, &int_arg, sizeof (int_arg));
	225	if (int_arg)
1c79356b A	226	so->so_state \|= SS_NBIO;
	227	else
	228	so->so_state &= ~SS_NBIO;
	229
91447636	230	goto out;
1c79356b	231
316670eb A	232	case FIOASYNC: /* int */
	233	bcopy(data, &int_arg, sizeof (int_arg));
	234	if (int_arg) {
1c79356b A	235	so->so_state \|= SS_ASYNC;
	236	so->so_rcv.sb_flags \|= SB_ASYNC;
	237	so->so_snd.sb_flags \|= SB_ASYNC;
	238	} else {
	239	so->so_state &= ~SS_ASYNC;
	240	so->so_rcv.sb_flags &= ~SB_ASYNC;
	241	so->so_snd.sb_flags &= ~SB_ASYNC;
	242	}
91447636	243	goto out;
1c79356b	244
316670eb A	245	case FIONREAD: /* int */
316670eb A	246	bcopy(&so->so_rcv.sb_cc, data, sizeof (u_int32_t));
91447636	247	goto out;
1c79356b	248
316670eb A	249	case SIOCSPGRP: /* int */
316670eb A	250	bcopy(data, &so->so_pgid, sizeof (pid_t));
91447636	251	goto out;
1c79356b	252
316670eb A	253	case SIOCGPGRP: /* int */
316670eb A	254	bcopy(&so->so_pgid, data, sizeof (pid_t));
91447636	255	goto out;
1c79356b	256
316670eb A	257	case SIOCATMARK: /* int */
	258	int_arg = (so->so_state & SS_RCVATMARK) != 0;
	259	bcopy(&int_arg, data, sizeof (int_arg));
91447636	260	goto out;
1c79356b	261
39236c6e A	262	case SIOCSETOT: /* int; deprecated */
	263	error = EOPNOTSUPP;
	264	goto out;
1c79356b	265
39236c6e A	266	case SIOCGASSOCIDS32: /* so_aidreq32 */
	267	case SIOCGASSOCIDS64: /* so_aidreq64 */
	268	case SIOCGCONNIDS32: /* so_cidreq32 */
	269	case SIOCGCONNIDS64: /* so_cidreq64 */
	270	case SIOCGCONNINFO32: /* so_cinforeq32 */
	271	case SIOCGCONNINFO64: /* so_cinforeq64 */
	272	case SIOCSCONNORDER: /* so_cordreq */
	273	case SIOCGCONNORDER: /* so_cordreq */
	274	error = (*so->so_proto->pr_usrreqs->pru_control)(so,
	275	cmd, data, NULL, p);
91447636	276	goto out;
2d21ac55	277	}
39236c6e	278
1c79356b A	279	/*
	280	* Interface/routing/protocol specific ioctls:
	281	* interface and routing ioctls should have a
	282	* different entry since a socket's unnecessary
	283	*/
2d21ac55 A	284	if (IOCGROUP(cmd) == 'i') {
	285	error = ifioctllocked(so, cmd, data, p);
	286	} else {
	287	if (IOCGROUP(cmd) == 'r')
	288	error = rtioctl(cmd, data, p);
	289	else
	290	error = (*so->so_proto->pr_usrreqs->pru_control)(so,
39236c6e	291	cmd, data, NULL, p);
2d21ac55	292	}
1c79356b	293
91447636	294	out:
91447636 A	295	socket_unlock(so, 1);
91447636 A	296
2d21ac55 A	297	if (error == EJUSTRETURN)
	298	error = 0;
	299
	300	return (error);
91447636 A	301	}
	302
	303	int
2d21ac55	304	soo_ioctl(struct fileproc *fp, u_long cmd, caddr_t data, vfs_context_t ctx)
91447636	305	{
2d21ac55	306	struct socket *so;
2d21ac55	307	proc_t procp = vfs_context_proc(ctx);
91447636 A	308
	309	if ((so = (struct socket *)fp->f_fglob->fg_data) == NULL) {
	310	/* This is not a valid open file descriptor */
	311	return (EBADF);
	312	}
2d21ac55	313
39236c6e	314	return (soioctl(so, cmd, data, procp));
1c79356b A	315	}
	316
	317	int
2d21ac55	318	soo_select(struct fileproc fp, int which, void wql, vfs_context_t ctx)
1c79356b	319	{
2d21ac55 A	320	struct socket so = (struct socket )fp->f_fglob->fg_data;
	321	int retnum = 0;
	322	proc_t procp;
	323
	324	if (so == NULL \|\| so == (struct socket *)-1)
	325	return (0);
39236c6e	326
2d21ac55	327	procp = vfs_context_proc(ctx);
1c79356b	328
2d21ac55	329	#if CONFIG_MACF_SOCKET
39236c6e	330	if (mac_socket_check_select(vfs_context_ucred(ctx), so, which) != 0)
91447636	331	return (0);
2d21ac55 A	332	#endif /* CONFIG_MACF_SOCKET */
2d21ac55 A	333
1c79356b	334
91447636	335	socket_lock(so, 1);
1c79356b A	336	switch (which) {
	337
	338	case FREAD:
0b4e3aa0	339	so->so_rcv.sb_flags \|= SB_SEL;
1c79356b	340	if (soreadable(so)) {
1c79356b	341	retnum = 1;
0b4e3aa0	342	so->so_rcv.sb_flags &= ~SB_SEL;
1c79356b A	343	goto done;
1c79356b A	344	}
2d21ac55	345	selrecord(procp, &so->so_rcv.sb_sel, wql);
1c79356b A	346	break;
	347
	348	case FWRITE:
0b4e3aa0	349	so->so_snd.sb_flags \|= SB_SEL;
1c79356b	350	if (sowriteable(so)) {
1c79356b	351	retnum = 1;
0b4e3aa0	352	so->so_snd.sb_flags &= ~SB_SEL;
1c79356b A	353	goto done;
1c79356b A	354	}
2d21ac55	355	selrecord(procp, &so->so_snd.sb_sel, wql);
1c79356b A	356	break;
	357
	358	case 0:
0b4e3aa0	359	so->so_rcv.sb_flags \|= SB_SEL;
1c79356b	360	if (so->so_oobmark \|\| (so->so_state & SS_RCVATMARK)) {
1c79356b	361	retnum = 1;
0b4e3aa0	362	so->so_rcv.sb_flags &= ~SB_SEL;
1c79356b A	363	goto done;
1c79356b A	364	}
2d21ac55	365	selrecord(procp, &so->so_rcv.sb_sel, wql);
1c79356b A	366	break;
1c79356b A	367	}
2d21ac55	368
1c79356b	369	done:
91447636	370	socket_unlock(so, 1);
1c79356b A	371	return (retnum);
	372	}
	373
1c79356b	374	int
2d21ac55	375	soo_stat(struct socket so, void ub, int isstat64)
1c79356b	376	{
2d21ac55 A	377	int ret;
	378	/* warning avoidance ; protected by isstat64 */
	379	struct stat sb = (struct stat )0;
	380	/* warning avoidance ; protected by isstat64 */
	381	struct stat64 sb64 = (struct stat64 )0;
	382
5ba3f43e	383	#if CONFIG_MACF_SOCKET_SUBSET
2d21ac55 A	384	ret = mac_socket_check_stat(kauth_cred_get(), so);
	385	if (ret)
	386	return (ret);
	387	#endif
	388
	389	if (isstat64 != 0) {
	390	sb64 = (struct stat64 *)ub;
	391	bzero((caddr_t)sb64, sizeof (*sb64));
	392	} else {
	393	sb = (struct stat *)ub;
	394	bzero((caddr_t)sb, sizeof (*sb));
	395	}
1c79356b	396
91447636	397	socket_lock(so, 1);
2d21ac55 A	398	if (isstat64 != 0) {
	399	sb64->st_mode = S_IFSOCK;
	400	if ((so->so_state & SS_CANTRCVMORE) == 0 \|\|
	401	so->so_rcv.sb_cc != 0)
	402	sb64->st_mode \|= S_IRUSR \| S_IRGRP \| S_IROTH;
	403	if ((so->so_state & SS_CANTSENDMORE) == 0)
	404	sb64->st_mode \|= S_IWUSR \| S_IWGRP \| S_IWOTH;
	405	sb64->st_size = so->so_rcv.sb_cc - so->so_rcv.sb_ctl;
316670eb A	406	sb64->st_uid = kauth_cred_getuid(so->so_cred);
316670eb A	407	sb64->st_gid = kauth_cred_getgid(so->so_cred);
2d21ac55 A	408	} else {
	409	sb->st_mode = S_IFSOCK;
	410	if ((so->so_state & SS_CANTRCVMORE) == 0 \|\|
	411	so->so_rcv.sb_cc != 0)
	412	sb->st_mode \|= S_IRUSR \| S_IRGRP \| S_IROTH;
	413	if ((so->so_state & SS_CANTSENDMORE) == 0)
	414	sb->st_mode \|= S_IWUSR \| S_IWGRP \| S_IWOTH;
	415	sb->st_size = so->so_rcv.sb_cc - so->so_rcv.sb_ctl;
316670eb A	416	sb->st_uid = kauth_cred_getuid(so->so_cred);
316670eb A	417	sb->st_gid = kauth_cred_getgid(so->so_cred);
2d21ac55 A	418	}
	419
	420	ret = (*so->so_proto->pr_usrreqs->pru_sense)(so, ub, isstat64);
91447636	421	socket_unlock(so, 1);
2d21ac55	422	return (ret);
1c79356b A	423	}
	424
	425	/* ARGSUSED */
2d21ac55 A	426	static int
2d21ac55 A	427	soo_close(struct fileglob *fg, __unused vfs_context_t ctx)
1c79356b A	428	{
1c79356b A	429	int error = 0;
55e303ae A	430	struct socket *sp;
55e303ae A	431
91447636 A	432	sp = (struct socket *)fg->fg_data;
91447636 A	433	fg->fg_data = NULL;
1c79356b	434
55e303ae	435	if (sp)
2d21ac55	436	error = soclose(sp);
1c79356b	437
1c79356b A	438	return (error);
1c79356b A	439	}
91447636	440
2d21ac55 A	441	static int
2d21ac55 A	442	soo_drain(struct fileproc *fp, __unused vfs_context_t ctx)
91447636 A	443	{
	444	int error = 0;
	445	struct socket so = (struct socket )fp->f_fglob->fg_data;
	446
	447	if (so) {
	448	socket_lock(so, 1);
	449	so->so_state \|= SS_DRAINING;
	450
	451	wakeup((caddr_t)&so->so_timeo);
	452	sorwakeup(so);
	453	sowwakeup(so);
316670eb	454	soevent(so, SO_FILT_HINT_LOCKED);
2d21ac55	455
91447636 A	456	socket_unlock(so, 1);
	457	}
	458
2d21ac55	459	return (error);
91447636	460	}
39236c6e A	461
	462	/*
	463	* 's' group ioctls.
	464	*
	465	* The switch statement below does nothing at runtime, as it serves as a
	466	* compile time check to ensure that all of the socket 's' ioctls (those
	467	* in the 's' group going thru soo_ioctl) that are made available by the
	468	* networking stack is unique. This works as long as this routine gets
	469	* updated each time a new interface ioctl gets added.
	470	*
	471	* Any failures at compile time indicates duplicated ioctl values.
	472	*/
	473	static __attribute__((unused)) void
	474	soioctl_cassert(void)
	475	{
	476	/*
	477	* This is equivalent to _CASSERT() and the compiler wouldn't
	478	* generate any instructions, thus for compile time only.
	479	*/
	480	switch ((u_long)0) {
	481	case 0:
	482
	483	/* bsd/sys/sockio.h */
	484	case SIOCSHIWAT:
	485	case SIOCGHIWAT:
	486	case SIOCSLOWAT:
	487	case SIOCGLOWAT:
	488	case SIOCATMARK:
	489	case SIOCSPGRP:
	490	case SIOCGPGRP:
	491	case SIOCSETOT:
	492	case SIOCGASSOCIDS32:
	493	case SIOCGASSOCIDS64:
	494	case SIOCGCONNIDS32:
	495	case SIOCGCONNIDS64:
	496	case SIOCGCONNINFO32:
	497	case SIOCGCONNINFO64:
	498	case SIOCSCONNORDER:
	499	case SIOCGCONNORDER:
	500	;
	501	}
	502	}