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

/*
 * Copyright (c) 2000-2011 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);

/* TODO: these should be in header file */
extern int soo_ioctl(struct fileproc *, u_long, caddr_t, vfs_context_t ctx);
extern int soo_stat(struct socket *, void *, int);
extern int soo_select(struct fileproc *, int, void *, vfs_context_t ctx);
extern int soo_kqfilter(struct fileproc *, struct knote *, vfs_context_t ctx);

struct fileops socketops = {
	soo_read, soo_write, soo_ioctl, soo_select, soo_close,
	soo_kqfilter, 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 */

//###LD will have to change
	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 dropsockref = -1;

	socket_lock(so, 1);

	/* Call the socket filter's ioctl handler for most ioctls */
	if (IOCGROUP(cmd) != 'i' && IOCGROUP(cmd) != 'r') {
		error = sflt_ioctl(so, cmd, data);
		if (error != 0)
			goto out;
	}

	switch (cmd) {

	case FIONBIO:
		if (*(int *)data)
			so->so_state |= SS_NBIO;
		else
			so->so_state &= ~SS_NBIO;

		goto out;

	case FIOASYNC:
		if (*(int *)data) {
			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 *)data = so->so_rcv.sb_cc;
		goto out;

	case SIOCSPGRP:
		so->so_pgid = *(int *)data;
		goto out;

	case SIOCGPGRP:
		*(int *)data = so->so_pgid;
		goto out;

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

	case SIOCSETOT: {
		/*
		 * Set socket level options here and then call protocol
		 * specific routine.
		 */
		struct socket *cloned_so = NULL;
		int cloned_fd = *(int *)data;

		/* let's make sure it's either -1 or a valid file descriptor */
		if (cloned_fd != -1) {
			error = file_socket(cloned_fd, &cloned_so);
			if (error) {
				goto out;
			}
			dropsockref = cloned_fd;
		}

		/* Always set socket non-blocking for OT */
		so->so_state |= SS_NBIO;
		so->so_options |= SO_DONTTRUNC | SO_WANTMORE;
		so->so_flags |= SOF_NOSIGPIPE | SOF_NPX_SETOPTSHUT;

		if (cloned_so && so != cloned_so) {
			/* Flags options */
			so->so_options |=
			    cloned_so->so_options & ~SO_ACCEPTCONN;

			/* SO_LINGER */
			if (so->so_options & SO_LINGER)
				so->so_linger = cloned_so->so_linger;

			/* SO_SNDBUF, SO_RCVBUF */
			if (cloned_so->so_snd.sb_hiwat > 0) {
				if (sbreserve(&so->so_snd,
				    cloned_so->so_snd.sb_hiwat) == 0) {
					error = ENOBUFS;
					goto out;
				}
			}
			if (cloned_so->so_rcv.sb_hiwat > 0) {
				if (sbreserve(&so->so_rcv,
				    cloned_so->so_rcv.sb_hiwat) == 0) {
					error = ENOBUFS;
					goto out;
				}
			}

			/* SO_SNDLOWAT, SO_RCVLOWAT */
			so->so_snd.sb_lowat =
			    (cloned_so->so_snd.sb_lowat > so->so_snd.sb_hiwat) ?
			    so->so_snd.sb_hiwat : cloned_so->so_snd.sb_lowat;
			so->so_rcv.sb_lowat =
			    (cloned_so->so_rcv.sb_lowat > so->so_rcv.sb_hiwat) ?
			    so->so_rcv.sb_hiwat : cloned_so->so_rcv.sb_lowat;

			/* SO_SNDTIMEO, SO_RCVTIMEO */
			so->so_snd.sb_timeo = cloned_so->so_snd.sb_timeo;
			so->so_rcv.sb_timeo = cloned_so->so_rcv.sb_timeo;
		}

		error = (*so->so_proto->pr_usrreqs->pru_control)(so, cmd,
		    data, 0, p);
		/* Just ignore protocols that do not understand it */
		if (error == EOPNOTSUPP)
			error = 0;

		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, 0, p);
	}

out:
	if (dropsockref != -1)
		file_drop(dropsockref);
	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;
	int error;
	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);
	}

	error = soioctl(so, cmd, data, procp);

	if (error == 0 && cmd == SIOCSETOT)
		fp->f_fglob->fg_flag |= FNONBLOCK;

	return (error);
}

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
	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 = so->so_uid;
		sb64->st_gid = so->so_gid;
	} 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 = so->so_uid;
		sb->st_gid = so->so_gid;
	}

	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);

		socket_unlock(so, 1);
	}

	return (error);
}
Commit	Line	Data
1c79356b	1	/*
6d2010ae	2	* Copyright (c) 2000-2011 Apple Inc. All rights reserved.
5d5c5d0d	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	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.
8f6c56a5	14	*
2d21ac55 A	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
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.
8f6c56a5	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
	100	/* TODO: these should be in header file */
	101	extern int soo_ioctl(struct fileproc *, u_long, caddr_t, vfs_context_t ctx);
	102	extern int soo_stat(struct socket , void , int);
	103	extern int soo_select(struct fileproc , int, void , vfs_context_t ctx);
	104	extern int soo_kqfilter(struct fileproc , struct knote , vfs_context_t ctx);
	105
	106	struct fileops socketops = {
	107	soo_read, soo_write, soo_ioctl, soo_select, soo_close,
	108	soo_kqfilter, soo_drain
	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
91447636	140	//###LD will have to change
1c79356b	141	fsoreceive = so->so_proto->pr_usrreqs->pru_soreceive;
2d21ac55	142
1c79356b	143	stat = (*fsoreceive)(so, 0, uio, 0, 0, 0);
2d21ac55	144	return (stat);
1c79356b A	145	}
	146
	147	/* ARGSUSED */
2d21ac55 A	148	static int
	149	soo_write(struct fileproc fp, struct uio uio, __unused int flags,
	150	vfs_context_t ctx)
1c79356b	151	{
9bccf70c	152	struct socket *so;
2d21ac55 A	153	int stat;
	154	int (fsosend)(struct socket so2, struct sockaddr *addr,
	155	struct uio uio2, struct mbuf top, struct mbuf *control,
	156	int flags2);
	157	proc_t procp;
	158
	159	#if CONFIG_MACF_SOCKET
	160	int error;
	161	#endif
1c79356b	162
91447636 A	163	if ((so = (struct socket *)fp->f_fglob->fg_data) == NULL) {
	164	/* This is not a valid open file descriptor */
	165	return (EBADF);
	166	}
9bccf70c	167
2d21ac55 A	168	#if CONFIG_MACF_SOCKET
	169	/* JMM - have to fetch the socket's remote addr */
	170	error = mac_socket_check_send(vfs_context_ucred(ctx), so, NULL);
	171	if (error)
	172	return (error);
	173	#endif /* CONFIG_MACF_SOCKET */
	174
1c79356b	175	fsosend = so->so_proto->pr_usrreqs->pru_sosend;
1c79356b A	176
1c79356b A	177	stat = (*fsosend)(so, 0, uio, 0, 0, 0);
9bccf70c	178
91447636	179	/* Generation of SIGPIPE can be controlled per socket */
2d21ac55	180	procp = vfs_context_proc(ctx);
b0d623f7	181	if (stat == EPIPE && !(so->so_flags & SOF_NOSIGPIPE))
91447636	182	psignal(procp, SIGPIPE);
9bccf70c	183
2d21ac55	184	return (stat);
1c79356b A	185	}
1c79356b A	186
91447636	187	__private_extern__ int
2d21ac55	188	soioctl(struct socket so, u_long cmd, caddr_t data, struct proc p)
1c79356b	189	{
2d21ac55	190	int error = 0;
91447636	191	int dropsockref = -1;
9bccf70c	192
b0d623f7	193	socket_lock(so, 1);
1c79356b	194
2d21ac55 A	195	/* Call the socket filter's ioctl handler for most ioctls */
2d21ac55 A	196	if (IOCGROUP(cmd) != 'i' && IOCGROUP(cmd) != 'r') {
6d2010ae	197	error = sflt_ioctl(so, cmd, data);
2d21ac55 A	198	if (error != 0)
	199	goto out;
	200	}
	201
1c79356b A	202	switch (cmd) {
	203
	204	case FIONBIO:
	205	if ((int )data)
	206	so->so_state \|= SS_NBIO;
	207	else
	208	so->so_state &= ~SS_NBIO;
	209
91447636	210	goto out;
1c79356b A	211
	212	case FIOASYNC:
	213	if ((int )data) {
	214	so->so_state \|= SS_ASYNC;
	215	so->so_rcv.sb_flags \|= SB_ASYNC;
	216	so->so_snd.sb_flags \|= SB_ASYNC;
	217	} else {
	218	so->so_state &= ~SS_ASYNC;
	219	so->so_rcv.sb_flags &= ~SB_ASYNC;
	220	so->so_snd.sb_flags &= ~SB_ASYNC;
	221	}
91447636	222	goto out;
1c79356b A	223
	224	case FIONREAD:
	225	(int )data = so->so_rcv.sb_cc;
91447636	226	goto out;
1c79356b A	227
	228	case SIOCSPGRP:
	229	so->so_pgid = (int )data;
91447636	230	goto out;
1c79356b A	231
	232	case SIOCGPGRP:
	233	(int )data = so->so_pgid;
91447636	234	goto out;
1c79356b A	235
1c79356b A	236	case SIOCATMARK:
2d21ac55	237	(int )data = (so->so_state&SS_RCVATMARK) != 0;
91447636	238	goto out;
1c79356b A	239
1c79356b A	240	case SIOCSETOT: {
2d21ac55 A	241	/*
	242	* Set socket level options here and then call protocol
	243	* specific routine.
	244	*/
	245	struct socket *cloned_so = NULL;
	246	int cloned_fd = (int )data;
	247
	248	/* let's make sure it's either -1 or a valid file descriptor */
	249	if (cloned_fd != -1) {
	250	error = file_socket(cloned_fd, &cloned_so);
	251	if (error) {
	252	goto out;
	253	}
	254	dropsockref = cloned_fd;
	255	}
	256
	257	/* Always set socket non-blocking for OT */
	258	so->so_state \|= SS_NBIO;
	259	so->so_options \|= SO_DONTTRUNC \| SO_WANTMORE;
b0d623f7	260	so->so_flags \|= SOF_NOSIGPIPE \| SOF_NPX_SETOPTSHUT;
2d21ac55 A	261
	262	if (cloned_so && so != cloned_so) {
	263	/* Flags options */
	264	so->so_options \|=
	265	cloned_so->so_options & ~SO_ACCEPTCONN;
	266
	267	/* SO_LINGER */
	268	if (so->so_options & SO_LINGER)
	269	so->so_linger = cloned_so->so_linger;
	270
	271	/* SO_SNDBUF, SO_RCVBUF */
	272	if (cloned_so->so_snd.sb_hiwat > 0) {
	273	if (sbreserve(&so->so_snd,
	274	cloned_so->so_snd.sb_hiwat) == 0) {
	275	error = ENOBUFS;
	276	goto out;
	277	}
	278	}
	279	if (cloned_so->so_rcv.sb_hiwat > 0) {
	280	if (sbreserve(&so->so_rcv,
	281	cloned_so->so_rcv.sb_hiwat) == 0) {
	282	error = ENOBUFS;
	283	goto out;
	284	}
	285	}
	286
	287	/* SO_SNDLOWAT, SO_RCVLOWAT */
	288	so->so_snd.sb_lowat =
	289	(cloned_so->so_snd.sb_lowat > so->so_snd.sb_hiwat) ?
	290	so->so_snd.sb_hiwat : cloned_so->so_snd.sb_lowat;
	291	so->so_rcv.sb_lowat =
	292	(cloned_so->so_rcv.sb_lowat > so->so_rcv.sb_hiwat) ?
	293	so->so_rcv.sb_hiwat : cloned_so->so_rcv.sb_lowat;
	294
	295	/* SO_SNDTIMEO, SO_RCVTIMEO */
	296	so->so_snd.sb_timeo = cloned_so->so_snd.sb_timeo;
	297	so->so_rcv.sb_timeo = cloned_so->so_rcv.sb_timeo;
	298	}
	299
	300	error = (*so->so_proto->pr_usrreqs->pru_control)(so, cmd,
	301	data, 0, p);
	302	/* Just ignore protocols that do not understand it */
	303	if (error == EOPNOTSUPP)
	304	error = 0;
1c79356b	305
91447636	306	goto out;
2d21ac55	307	}
1c79356b A	308	}
	309	/*
	310	* Interface/routing/protocol specific ioctls:
	311	* interface and routing ioctls should have a
	312	* different entry since a socket's unnecessary
	313	*/
2d21ac55 A	314	if (IOCGROUP(cmd) == 'i') {
	315	error = ifioctllocked(so, cmd, data, p);
	316	} else {
	317	if (IOCGROUP(cmd) == 'r')
	318	error = rtioctl(cmd, data, p);
	319	else
	320	error = (*so->so_proto->pr_usrreqs->pru_control)(so,
	321	cmd, data, 0, p);
	322	}
1c79356b	323
91447636 A	324	out:
	325	if (dropsockref != -1)
	326	file_drop(dropsockref);
	327	socket_unlock(so, 1);
	328
2d21ac55 A	329	if (error == EJUSTRETURN)
	330	error = 0;
	331
	332	return (error);
91447636 A	333	}
	334
	335	int
2d21ac55	336	soo_ioctl(struct fileproc *fp, u_long cmd, caddr_t data, vfs_context_t ctx)
91447636	337	{
2d21ac55	338	struct socket *so;
91447636	339	int error;
2d21ac55	340	proc_t procp = vfs_context_proc(ctx);
91447636 A	341
	342	if ((so = (struct socket *)fp->f_fglob->fg_data) == NULL) {
	343	/* This is not a valid open file descriptor */
	344	return (EBADF);
	345	}
2d21ac55 A	346
	347	error = soioctl(so, cmd, data, procp);
	348
91447636 A	349	if (error == 0 && cmd == SIOCSETOT)
	350	fp->f_fglob->fg_flag \|= FNONBLOCK;
	351
2d21ac55	352	return (error);
1c79356b A	353	}
	354
	355	int
2d21ac55	356	soo_select(struct fileproc fp, int which, void wql, vfs_context_t ctx)
1c79356b	357	{
2d21ac55 A	358	struct socket so = (struct socket )fp->f_fglob->fg_data;
	359	int retnum = 0;
	360	proc_t procp;
	361
	362	if (so == NULL \|\| so == (struct socket *)-1)
	363	return (0);
	364
	365	procp = vfs_context_proc(ctx);
1c79356b	366
2d21ac55 A	367	#if CONFIG_MACF_SOCKET
2d21ac55 A	368	if (mac_socket_check_select(vfs_context_ucred(ctx), so, which) != 0);
91447636	369	return (0);
2d21ac55 A	370	#endif /* CONFIG_MACF_SOCKET */
2d21ac55 A	371
1c79356b	372
91447636	373	socket_lock(so, 1);
1c79356b A	374	switch (which) {
	375
	376	case FREAD:
0b4e3aa0	377	so->so_rcv.sb_flags \|= SB_SEL;
1c79356b	378	if (soreadable(so)) {
1c79356b	379	retnum = 1;
0b4e3aa0	380	so->so_rcv.sb_flags &= ~SB_SEL;
1c79356b A	381	goto done;
1c79356b A	382	}
2d21ac55	383	selrecord(procp, &so->so_rcv.sb_sel, wql);
1c79356b A	384	break;
	385
	386	case FWRITE:
0b4e3aa0	387	so->so_snd.sb_flags \|= SB_SEL;
1c79356b	388	if (sowriteable(so)) {
1c79356b	389	retnum = 1;
0b4e3aa0	390	so->so_snd.sb_flags &= ~SB_SEL;
1c79356b A	391	goto done;
1c79356b A	392	}
2d21ac55	393	selrecord(procp, &so->so_snd.sb_sel, wql);
1c79356b A	394	break;
	395
	396	case 0:
0b4e3aa0	397	so->so_rcv.sb_flags \|= SB_SEL;
1c79356b	398	if (so->so_oobmark \|\| (so->so_state & SS_RCVATMARK)) {
1c79356b	399	retnum = 1;
0b4e3aa0	400	so->so_rcv.sb_flags &= ~SB_SEL;
1c79356b A	401	goto done;
1c79356b A	402	}
2d21ac55	403	selrecord(procp, &so->so_rcv.sb_sel, wql);
1c79356b A	404	break;
1c79356b A	405	}
2d21ac55	406
1c79356b	407	done:
91447636	408	socket_unlock(so, 1);
1c79356b A	409	return (retnum);
	410	}
	411
1c79356b	412	int
2d21ac55	413	soo_stat(struct socket so, void ub, int isstat64)
1c79356b	414	{
2d21ac55 A	415	int ret;
	416	/* warning avoidance ; protected by isstat64 */
	417	struct stat sb = (struct stat )0;
	418	/* warning avoidance ; protected by isstat64 */
	419	struct stat64 sb64 = (struct stat64 )0;
	420
	421	#if CONFIG_MACF_SOCKET
	422	ret = mac_socket_check_stat(kauth_cred_get(), so);
	423	if (ret)
	424	return (ret);
	425	#endif
	426
	427	if (isstat64 != 0) {
	428	sb64 = (struct stat64 *)ub;
	429	bzero((caddr_t)sb64, sizeof (*sb64));
	430	} else {
	431	sb = (struct stat *)ub;
	432	bzero((caddr_t)sb, sizeof (*sb));
	433	}
1c79356b	434
91447636	435	socket_lock(so, 1);
2d21ac55 A	436	if (isstat64 != 0) {
	437	sb64->st_mode = S_IFSOCK;
	438	if ((so->so_state & SS_CANTRCVMORE) == 0 \|\|
	439	so->so_rcv.sb_cc != 0)
	440	sb64->st_mode \|= S_IRUSR \| S_IRGRP \| S_IROTH;
	441	if ((so->so_state & SS_CANTSENDMORE) == 0)
	442	sb64->st_mode \|= S_IWUSR \| S_IWGRP \| S_IWOTH;
	443	sb64->st_size = so->so_rcv.sb_cc - so->so_rcv.sb_ctl;
	444	sb64->st_uid = so->so_uid;
6d2010ae	445	sb64->st_gid = so->so_gid;
2d21ac55 A	446	} else {
	447	sb->st_mode = S_IFSOCK;
	448	if ((so->so_state & SS_CANTRCVMORE) == 0 \|\|
	449	so->so_rcv.sb_cc != 0)
	450	sb->st_mode \|= S_IRUSR \| S_IRGRP \| S_IROTH;
	451	if ((so->so_state & SS_CANTSENDMORE) == 0)
	452	sb->st_mode \|= S_IWUSR \| S_IWGRP \| S_IWOTH;
	453	sb->st_size = so->so_rcv.sb_cc - so->so_rcv.sb_ctl;
	454	sb->st_uid = so->so_uid;
6d2010ae	455	sb->st_gid = so->so_gid;
2d21ac55 A	456	}
	457
	458	ret = (*so->so_proto->pr_usrreqs->pru_sense)(so, ub, isstat64);
91447636	459	socket_unlock(so, 1);
2d21ac55	460	return (ret);
1c79356b A	461	}
	462
	463	/* ARGSUSED */
2d21ac55 A	464	static int
2d21ac55 A	465	soo_close(struct fileglob *fg, __unused vfs_context_t ctx)
1c79356b A	466	{
1c79356b A	467	int error = 0;
55e303ae A	468	struct socket *sp;
55e303ae A	469
91447636 A	470	sp = (struct socket *)fg->fg_data;
91447636 A	471	fg->fg_data = NULL;
1c79356b	472
55e303ae	473	if (sp)
2d21ac55	474	error = soclose(sp);
1c79356b	475
1c79356b A	476	return (error);
1c79356b A	477	}
91447636	478
2d21ac55 A	479	static int
2d21ac55 A	480	soo_drain(struct fileproc *fp, __unused vfs_context_t ctx)
91447636 A	481	{
	482	int error = 0;
	483	struct socket so = (struct socket )fp->f_fglob->fg_data;
	484
	485	if (so) {
	486	socket_lock(so, 1);
	487	so->so_state \|= SS_DRAINING;
	488
	489	wakeup((caddr_t)&so->so_timeo);
	490	sorwakeup(so);
	491	sowwakeup(so);
2d21ac55	492
91447636 A	493	socket_unlock(so, 1);
	494	}
	495
2d21ac55	496	return (error);
91447636	497	}