/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (the "License").  You may not use this file except in compliance

 * with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/types.h>

#include <sys/t_lock.h>

#include <sys/param.h>

#include <sys/systm.h>

#include <sys/buf.h>

#include <sys/conf.h>

#include <sys/cred.h>

#include <sys/kmem.h>

#include <sys/sysmacros.h>

#include <sys/vfs.h>

#include <sys/vnode.h>

#include <sys/debug.h>

#include <sys/errno.h>

#include <sys/time.h>

#include <sys/file.h>

#include <sys/open.h>

#include <sys/user.h>

#include <sys/termios.h>

#include <sys/stream.h>

#include <sys/strsubr.h>

#include <sys/strsun.h>

#include <sys/ddi.h>

#include <sys/esunddi.h>

#include <sys/flock.h>

#include <sys/modctl.h>

#include <sys/vtrace.h>

#include <sys/cmn_err.h>

#include <sys/pathname.h>

#include <sys/socket.h>

#include <sys/socketvar.h>

#include <sys/sockio.h>

#include <netinet/in.h>

#include <sys/un.h>

#include <sys/strsun.h>

#include <sys/tiuser.h>

#define	_SUN_TPI_VERSION	2

#include <sys/tihdr.h>

#include <sys/timod.h>		/* TI_GETMYNAME, TI_GETPEERNAME */

#include <c2/audit.h>

#include <inet/common.h>

#include <inet/ip.h>

#include <inet/ip6.h>

#include <inet/tcp.h>

#include <inet/udp_impl.h>

#include <fs/sockfs/nl7c.h>

#include <sys/zone.h>

/*

 * Possible failures when memory can't be allocated. The documented behavior:

 *

 * 		5.5:			4.X:		XNET:

 * accept:	ENOMEM/ENOSR/EINTR	- (EINTR)	ENOMEM/ENOBUFS/ENOSR/

 *							EINTR

 *	(4.X does not document EINTR but returns it)

 * bind:	ENOSR			-		ENOBUFS/ENOSR

 * connect: 	EINTR			EINTR		ENOBUFS/ENOSR/EINTR

 * getpeername:	ENOMEM/ENOSR		ENOBUFS (-)	ENOBUFS/ENOSR

 * getsockname:	ENOMEM/ENOSR		ENOBUFS (-)	ENOBUFS/ENOSR

 *	(4.X getpeername and getsockname do not fail in practice)

 * getsockopt:	ENOMEM/ENOSR		-		ENOBUFS/ENOSR

 * listen:	-			-		ENOBUFS

 * recv:	ENOMEM/ENOSR/EINTR	EINTR		ENOBUFS/ENOMEM/ENOSR/

 *							EINTR

 * send:	ENOMEM/ENOSR/EINTR	ENOBUFS/EINTR	ENOBUFS/ENOMEM/ENOSR/

 *							EINTR

 * setsockopt:	ENOMEM/ENOSR		-		ENOBUFS/ENOMEM/ENOSR

 * shutdown:	ENOMEM/ENOSR		-		ENOBUFS/ENOSR

 * socket:	ENOMEM/ENOSR		ENOBUFS		ENOBUFS/ENOMEM/ENOSR

 * socketpair:	ENOMEM/ENOSR		-		ENOBUFS/ENOMEM/ENOSR

 *

 * Resolution. When allocation fails:

 *	recv: return EINTR

 *	send: return EINTR

 *	connect, accept: EINTR

 *	bind, listen, shutdown (unbind, unix_close, disconnect): sleep

 *	socket, socketpair: ENOBUFS

 *	getpeername, getsockname: sleep

 *	getsockopt, setsockopt: sleep

 */

#ifdef SOCK_TEST

/*

 * Variables that make sockfs do something other than the standard TPI

 * for the AF_INET transports.

 *

 * solisten_tpi_tcp:

 *	TCP can handle a O_T_BIND_REQ with an increased backlog even though

 *	the transport is already bound. This is needed to avoid loosing the

 *	port number should listen() do a T_UNBIND_REQ followed by a

 *	O_T_BIND_REQ.

 *

 * soconnect_tpi_udp:

 *	UDP and ICMP can handle a T_CONN_REQ.

 *	This is needed to make the sequence of connect(), getsockname()

 *	return the local IP address used to send packets to the connected to

 *	destination.

 *

 * soconnect_tpi_tcp:

 *	TCP can handle a T_CONN_REQ without seeing a O_T_BIND_REQ.

 *	Set this to non-zero to send TPI conformant messages to TCP in this

 *	respect. This is a performance optimization.

 *

 * soaccept_tpi_tcp:

 *	TCP can handle a T_CONN_REQ without the acceptor being bound.

 *	This is a performance optimization that has been picked up in XTI.

 *

 * soaccept_tpi_multioptions:

 *	When inheriting SOL_SOCKET options from the listener to the accepting

 *	socket send them as a single message for AF_INET{,6}.

 */

int solisten_tpi_tcp = 0;

int soconnect_tpi_udp = 0;

int soconnect_tpi_tcp = 0;

int soaccept_tpi_tcp = 0;

int soaccept_tpi_multioptions = 1;

#else /* SOCK_TEST */

#define	soconnect_tpi_tcp	0

#define	soconnect_tpi_udp	0

#define	solisten_tpi_tcp	0

#define	soaccept_tpi_tcp	0

#define	soaccept_tpi_multioptions	1

#endif /* SOCK_TEST */

#ifdef SOCK_TEST

extern int do_useracc;

extern clock_t sock_test_timelimit;

#endif /* SOCK_TEST */

/*

 * Some X/Open added checks might have to be backed out to keep SunOS 4.X

 * applications working. Turn on this flag to disable these checks.

 */

int xnet_skip_checks = 0;

int xnet_check_print = 0;

int xnet_truncate_print = 0;

extern	void sigintr(k_sigset_t *, int);

extern	void sigunintr(k_sigset_t *);

extern	void *nl7c_lookup_addr(void *, t_uscalar_t);

extern	void *nl7c_add_addr(void *, t_uscalar_t);

extern	void nl7c_listener_addr(void *, queue_t *);

static int	sotpi_unbind(struct sonode *, int);

/* TPI sockfs sonode operations */

static int	sotpi_accept(struct sonode *, int, struct sonode **);

static int	sotpi_bind(struct sonode *, struct sockaddr *, socklen_t,

		    int);

static int	sotpi_connect(struct sonode *, const struct sockaddr *,

		    socklen_t, int, int);

static int	sotpi_listen(struct sonode *, int);

static int	sotpi_sendmsg(struct sonode *, struct nmsghdr *,

		    struct uio *);

static int	sotpi_shutdown(struct sonode *, int);

static int	sotpi_getsockname(struct sonode *);

static int	sosend_dgramcmsg(struct sonode *, struct sockaddr *, socklen_t,

		    struct uio *, void *, t_uscalar_t, int);

static int	sodgram_direct(struct sonode *, struct sockaddr *,

		    socklen_t, struct uio *, int);

sonodeops_t sotpi_sonodeops = {

	sotpi_accept,		/* sop_accept		*/

	sotpi_bind,		/* sop_bind		*/

	sotpi_listen,		/* sop_listen		*/

	sotpi_connect,		/* sop_connect		*/

	sotpi_recvmsg,		/* sop_recvmsg		*/

	sotpi_sendmsg,		/* sop_sendmsg		*/

	sotpi_getpeername,	/* sop_getpeername	*/

	sotpi_getsockname,	/* sop_getsockname	*/

	sotpi_shutdown,		/* sop_shutdown		*/

	sotpi_getsockopt,	/* sop_getsockopt	*/

	sotpi_setsockopt	/* sop_setsockopt	*/

};

/*

 * Common create code for socket and accept. If tso is set the values

 * from that node is used instead of issuing a T_INFO_REQ.

 *

 * Assumes that the caller has a VN_HOLD on accessvp.

 * The VN_RELE will occur either when sotpi_create() fails or when

 * the returned sonode is freed.

 */

struct sonode *

sotpi_create(vnode_t *accessvp, int domain, int type, int protocol, int version,

    struct sonode *tso, int *errorp)

{

	struct sonode	*so;

	vnode_t		*vp;

	int		flags, error;

	ASSERT(accessvp != NULL);

	vp = makesockvp(accessvp, domain, type, protocol);

	ASSERT(vp != NULL);

	so = VTOSO(vp);

	flags = FREAD|FWRITE;

	if ((type == SOCK_STREAM || type == SOCK_DGRAM) &&

	    (domain == AF_INET || domain == AF_INET6) &&

	    (protocol == IPPROTO_TCP || protocol == IPPROTO_UDP ||

	    protocol == IPPROTO_IP)) {

		/* Tell tcp or udp that it's talking to sockets */

		flags |= SO_SOCKSTR;

		/*

		 * Here we indicate to socktpi_open() our attempt to

		 * make direct calls between sockfs and transport.

		 * The final decision is left to socktpi_open().

		 */

		so->so_state |= SS_DIRECT;

		ASSERT(so->so_type != SOCK_DGRAM || tso == NULL);

		if (so->so_type == SOCK_STREAM && tso != NULL) {

			if (tso->so_state & SS_DIRECT) {

				/*

				 * Inherit SS_DIRECT from listener and pass

				 * SO_ACCEPTOR open flag to tcp, indicating

				 * that this is an accept fast-path instance.

				 */

				flags |= SO_ACCEPTOR;

			} else {

				/*

				 * SS_DIRECT is not set on listener, meaning

				 * that the listener has been converted from

				 * a socket to a stream.  Ensure that the

				 * acceptor inherits these settings.

				 */

				so->so_state &= ~SS_DIRECT;

				flags &= ~SO_SOCKSTR;

			}

		}

	}

	/*

	 * Tell local transport that it is talking to sockets.

	 */

	if (so->so_family == AF_UNIX) {

		flags |= SO_SOCKSTR;

	}

	if (error = socktpi_open(&vp, flags, CRED())) {

		VN_RELE(vp);

		*errorp = error;

		return (NULL);

	}

	if (error = so_strinit(so, tso)) {

		(void) VOP_CLOSE(vp, 0, 1, 0, CRED());

		VN_RELE(vp);

		*errorp = error;

		return (NULL);

	}

	if (version == SOV_DEFAULT)

		version = so_default_version;

	so->so_version = (short)version;

	return (so);

}

/*

 * Bind the socket to an unspecified address in sockfs only.

 * Used for TCP/UDP transports where we know that the O_T_BIND_REQ isn't

 * required in all cases.

 */

static void

so_automatic_bind(struct sonode *so)

{

	ASSERT(so->so_family == AF_INET || so->so_family == AF_INET6);

	ASSERT(MUTEX_HELD(&so->so_lock));

	ASSERT(!(so->so_state & SS_ISBOUND));

	ASSERT(so->so_unbind_mp);

	ASSERT(so->so_laddr_len <= so->so_laddr_maxlen);

	bzero(so->so_laddr_sa, so->so_laddr_len);

	so->so_laddr_sa->sa_family = so->so_family;

	so->so_state |= SS_ISBOUND;

}

/*

 * bind the socket.

 *

 * If the socket is already bound and none of _SOBIND_SOCKBSD or _SOBIND_XPG4_2

 * are passed in we allow rebinding. Note that for backwards compatibility

 * even "svr4" sockets pass in _SOBIND_SOCKBSD/SOV_SOCKBSD to sobind/bind.

 * Thus the rebinding code is currently not executed.

 *

 * The constraints for rebinding are:

 * - it is a SOCK_DGRAM, or

 * - it is a SOCK_STREAM/SOCK_SEQPACKET that has not been connected

 *   and no listen() has been done.

 * This rebinding code was added based on some language in the XNET book

 * about not returning EINVAL it the protocol allows rebinding. However,

 * this language is not present in the Posix socket draft. Thus maybe the

 * rebinding logic should be deleted from the source.

 *

 * A null "name" can be used to unbind the socket if:

 * - it is a SOCK_DGRAM, or

 * - it is a SOCK_STREAM/SOCK_SEQPACKET that has not been connected

 *   and no listen() has been done.

 */

static int

sotpi_bindlisten(struct sonode *so, struct sockaddr *name,

    socklen_t namelen, int backlog, int flags)

{

	struct T_bind_req	bind_req;

	struct T_bind_ack	*bind_ack;

	int			error = 0;

	mblk_t			*mp;

	void			*addr;

	t_uscalar_t		addrlen;

	int			unbind_on_err = 1;

	boolean_t		clear_acceptconn_on_err = B_FALSE;

	boolean_t		restore_backlog_on_err = B_FALSE;

	int			save_so_backlog;

	t_scalar_t		PRIM_type = O_T_BIND_REQ;

	boolean_t		tcp_udp_xport;

	void			*nl7c = NULL;

	dprintso(so, 1, ("sotpi_bindlisten(%p, %p, %d, %d, 0x%x) %s\n",

		so, name, namelen, backlog, flags,

		pr_state(so->so_state, so->so_mode)));

	tcp_udp_xport = so->so_type == SOCK_STREAM || so->so_type == SOCK_DGRAM;

	if (!(flags & _SOBIND_LOCK_HELD)) {

		mutex_enter(&so->so_lock);

		so_lock_single(so);	/* Set SOLOCKED */

	} else {

		ASSERT(MUTEX_HELD(&so->so_lock));

		ASSERT(so->so_flag & SOLOCKED);

	}

	/*

	 * Make sure that there is a preallocated unbind_req message

	 * before binding. This message allocated when the socket is

	 * created  but it might be have been consumed.

	 */

	if (so->so_unbind_mp == NULL) {

		dprintso(so, 1, ("sobind: allocating unbind_req\n"));

		/* NOTE: holding so_lock while sleeping */

		so->so_unbind_mp =

		    soallocproto(sizeof (struct T_unbind_req), _ALLOC_SLEEP);

	}

	if (flags & _SOBIND_REBIND) {

		/*

		 * Called from solisten after doing an sotpi_unbind() or

		 * potentially without the unbind (latter for AF_INET{,6}).

		 */

		ASSERT(name == NULL && namelen == 0);

		if (so->so_family == AF_UNIX) {

			ASSERT(so->so_ux_bound_vp);

			addr = &so->so_ux_laddr;

			addrlen = (t_uscalar_t)sizeof (so->so_ux_laddr);

			dprintso(so, 1,

			("sobind rebind UNIX: addrlen %d, addr 0x%p, vp %p\n",

			    addrlen,

			    ((struct so_ux_addr *)addr)->soua_vp,

			    so->so_ux_bound_vp));

		} else {

			addr = so->so_laddr_sa;

			addrlen = (t_uscalar_t)so->so_laddr_len;

		}

	} else if (flags & _SOBIND_UNSPEC) {

		ASSERT(name == NULL && namelen == 0);

		/*

		 * The caller checked SS_ISBOUND but not necessarily

		 * under so_lock

		 */

		if (so->so_state & SS_ISBOUND) {

			/* No error */

			goto done;

		}

		/* Set an initial local address */

		switch (so->so_family) {

		case AF_UNIX:

			/*

			 * Use an address with same size as struct sockaddr

			 * just like BSD.

			 */

			so->so_laddr_len =

				(socklen_t)sizeof (struct sockaddr);

			ASSERT(so->so_laddr_len <= so->so_laddr_maxlen);

			bzero(so->so_laddr_sa, so->so_laddr_len);

			so->so_laddr_sa->sa_family = so->so_family;

			/*

			 * Pass down an address with the implicit bind

			 * magic number and the rest all zeros.

			 * The transport will return a unique address.

			 */

			so->so_ux_laddr.soua_vp = NULL;

			so->so_ux_laddr.soua_magic = SOU_MAGIC_IMPLICIT;

			addr = &so->so_ux_laddr;

			addrlen = (t_uscalar_t)sizeof (so->so_ux_laddr);

			break;

		case AF_INET:

		case AF_INET6:

			/*

			 * An unspecified bind in TPI has a NULL address.

			 * Set the address in sockfs to have the sa_family.

			 */

			so->so_laddr_len = (so->so_family == AF_INET) ?

			    (socklen_t)sizeof (sin_t) :

			    (socklen_t)sizeof (sin6_t);

			ASSERT(so->so_laddr_len <= so->so_laddr_maxlen);

			bzero(so->so_laddr_sa, so->so_laddr_len);

			so->so_laddr_sa->sa_family = so->so_family;

			addr = NULL;

			addrlen = 0;

			break;

		default:

			/*

			 * An unspecified bind in TPI has a NULL address.

			 * Set the address in sockfs to be zero length.

			 *

			 * Can not assume there is a sa_family for all

			 * protocol families. For example, AF_X25 does not

			 * have a family field.

			 */

			so->so_laddr_len = 0;	/* XXX correct? */

			bzero(so->so_laddr_sa, so->so_laddr_len);

			addr = NULL;

			addrlen = 0;

			break;

		}

	} else {

		if (so->so_state & SS_ISBOUND) {

			/*

			 * If it is ok to rebind the socket, first unbind

			 * with the transport. A rebind to the NULL address

			 * is interpreted as an unbind.

			 * Note that a bind to NULL in BSD does unbind the

			 * socket but it fails with EINVAL.

			 * Note that regular sockets set SOV_SOCKBSD i.e.

			 * _SOBIND_SOCKBSD gets set here hence no type of

			 * socket does currently allow rebinding.

			 *

			 * If the name is NULL just do an unbind.

			 */

			if (flags & (_SOBIND_SOCKBSD|_SOBIND_XPG4_2) &&

			    name != NULL) {

				error = EINVAL;

				unbind_on_err = 0;

				eprintsoline(so, error);

				goto done;

			}

			if ((so->so_mode & SM_CONNREQUIRED) &&

			    (so->so_state & SS_CANTREBIND)) {

				error = EINVAL;

				unbind_on_err = 0;

				eprintsoline(so, error);

				goto done;

			}

			error = sotpi_unbind(so, 0);

			if (error) {

				eprintsoline(so, error);

				goto done;

			}

			ASSERT(!(so->so_state & SS_ISBOUND));

			if (name == NULL) {

				so->so_state &=

					~(SS_ISCONNECTED|SS_ISCONNECTING);

				goto done;

			}

		}

		/* X/Open requires this check */