xref: /onnv-gate/usr/src/uts/common/fs/sockfs/socktpi.c (revision 1156:48c9e18c7127)
10Sstevel@tonic-gate /*
20Sstevel@tonic-gate  * CDDL HEADER START
30Sstevel@tonic-gate  *
40Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
50Sstevel@tonic-gate  * Common Development and Distribution License, Version 1.0 only
60Sstevel@tonic-gate  * (the "License").  You may not use this file except in compliance
70Sstevel@tonic-gate  * with the License.
80Sstevel@tonic-gate  *
90Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
100Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
110Sstevel@tonic-gate  * See the License for the specific language governing permissions
120Sstevel@tonic-gate  * and limitations under the License.
130Sstevel@tonic-gate  *
140Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
150Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
160Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
170Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
180Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
190Sstevel@tonic-gate  *
200Sstevel@tonic-gate  * CDDL HEADER END
210Sstevel@tonic-gate  */
220Sstevel@tonic-gate /*
230Sstevel@tonic-gate  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
240Sstevel@tonic-gate  * Use is subject to license terms.
250Sstevel@tonic-gate  */
260Sstevel@tonic-gate 
270Sstevel@tonic-gate #pragma ident	"%Z%%M%	%I%	%E% SMI"
280Sstevel@tonic-gate 
290Sstevel@tonic-gate #include <sys/types.h>
300Sstevel@tonic-gate #include <sys/t_lock.h>
310Sstevel@tonic-gate #include <sys/param.h>
320Sstevel@tonic-gate #include <sys/systm.h>
330Sstevel@tonic-gate #include <sys/buf.h>
340Sstevel@tonic-gate #include <sys/conf.h>
350Sstevel@tonic-gate #include <sys/cred.h>
360Sstevel@tonic-gate #include <sys/kmem.h>
370Sstevel@tonic-gate #include <sys/sysmacros.h>
380Sstevel@tonic-gate #include <sys/vfs.h>
390Sstevel@tonic-gate #include <sys/vnode.h>
400Sstevel@tonic-gate #include <sys/debug.h>
410Sstevel@tonic-gate #include <sys/errno.h>
420Sstevel@tonic-gate #include <sys/time.h>
430Sstevel@tonic-gate #include <sys/file.h>
440Sstevel@tonic-gate #include <sys/open.h>
450Sstevel@tonic-gate #include <sys/user.h>
460Sstevel@tonic-gate #include <sys/termios.h>
470Sstevel@tonic-gate #include <sys/stream.h>
480Sstevel@tonic-gate #include <sys/strsubr.h>
490Sstevel@tonic-gate #include <sys/strsun.h>
500Sstevel@tonic-gate #include <sys/ddi.h>
510Sstevel@tonic-gate #include <sys/esunddi.h>
520Sstevel@tonic-gate #include <sys/flock.h>
530Sstevel@tonic-gate #include <sys/modctl.h>
540Sstevel@tonic-gate #include <sys/vtrace.h>
550Sstevel@tonic-gate #include <sys/cmn_err.h>
560Sstevel@tonic-gate #include <sys/pathname.h>
570Sstevel@tonic-gate 
580Sstevel@tonic-gate #include <sys/socket.h>
590Sstevel@tonic-gate #include <sys/socketvar.h>
60741Smasputra #include <sys/sockio.h>
610Sstevel@tonic-gate #include <netinet/in.h>
620Sstevel@tonic-gate #include <sys/un.h>
630Sstevel@tonic-gate #include <sys/strsun.h>
640Sstevel@tonic-gate 
650Sstevel@tonic-gate #include <sys/tiuser.h>
660Sstevel@tonic-gate #define	_SUN_TPI_VERSION	2
670Sstevel@tonic-gate #include <sys/tihdr.h>
680Sstevel@tonic-gate #include <sys/timod.h>		/* TI_GETMYNAME, TI_GETPEERNAME */
690Sstevel@tonic-gate 
700Sstevel@tonic-gate #include <c2/audit.h>
710Sstevel@tonic-gate 
720Sstevel@tonic-gate #include <inet/common.h>
730Sstevel@tonic-gate #include <inet/ip.h>
740Sstevel@tonic-gate #include <inet/ip6.h>
750Sstevel@tonic-gate #include <inet/tcp.h>
76741Smasputra #include <inet/udp_impl.h>
770Sstevel@tonic-gate 
780Sstevel@tonic-gate #include <fs/sockfs/nl7c.h>
790Sstevel@tonic-gate #include <sys/zone.h>
800Sstevel@tonic-gate 
81898Skais #include <inet/kssl/ksslapi.h>
82898Skais 
830Sstevel@tonic-gate /*
840Sstevel@tonic-gate  * Possible failures when memory can't be allocated. The documented behavior:
850Sstevel@tonic-gate  *
860Sstevel@tonic-gate  * 		5.5:			4.X:		XNET:
870Sstevel@tonic-gate  * accept:	ENOMEM/ENOSR/EINTR	- (EINTR)	ENOMEM/ENOBUFS/ENOSR/
880Sstevel@tonic-gate  *							EINTR
890Sstevel@tonic-gate  *	(4.X does not document EINTR but returns it)
900Sstevel@tonic-gate  * bind:	ENOSR			-		ENOBUFS/ENOSR
910Sstevel@tonic-gate  * connect: 	EINTR			EINTR		ENOBUFS/ENOSR/EINTR
920Sstevel@tonic-gate  * getpeername:	ENOMEM/ENOSR		ENOBUFS (-)	ENOBUFS/ENOSR
930Sstevel@tonic-gate  * getsockname:	ENOMEM/ENOSR		ENOBUFS (-)	ENOBUFS/ENOSR
940Sstevel@tonic-gate  *	(4.X getpeername and getsockname do not fail in practice)
950Sstevel@tonic-gate  * getsockopt:	ENOMEM/ENOSR		-		ENOBUFS/ENOSR
960Sstevel@tonic-gate  * listen:	-			-		ENOBUFS
970Sstevel@tonic-gate  * recv:	ENOMEM/ENOSR/EINTR	EINTR		ENOBUFS/ENOMEM/ENOSR/
980Sstevel@tonic-gate  *							EINTR
990Sstevel@tonic-gate  * send:	ENOMEM/ENOSR/EINTR	ENOBUFS/EINTR	ENOBUFS/ENOMEM/ENOSR/
1000Sstevel@tonic-gate  *							EINTR
1010Sstevel@tonic-gate  * setsockopt:	ENOMEM/ENOSR		-		ENOBUFS/ENOMEM/ENOSR
1020Sstevel@tonic-gate  * shutdown:	ENOMEM/ENOSR		-		ENOBUFS/ENOSR
1030Sstevel@tonic-gate  * socket:	ENOMEM/ENOSR		ENOBUFS		ENOBUFS/ENOMEM/ENOSR
1040Sstevel@tonic-gate  * socketpair:	ENOMEM/ENOSR		-		ENOBUFS/ENOMEM/ENOSR
1050Sstevel@tonic-gate  *
1060Sstevel@tonic-gate  * Resolution. When allocation fails:
1070Sstevel@tonic-gate  *	recv: return EINTR
1080Sstevel@tonic-gate  *	send: return EINTR
1090Sstevel@tonic-gate  *	connect, accept: EINTR
1100Sstevel@tonic-gate  *	bind, listen, shutdown (unbind, unix_close, disconnect): sleep
1110Sstevel@tonic-gate  *	socket, socketpair: ENOBUFS
1120Sstevel@tonic-gate  *	getpeername, getsockname: sleep
1130Sstevel@tonic-gate  *	getsockopt, setsockopt: sleep
1140Sstevel@tonic-gate  */
1150Sstevel@tonic-gate 
1160Sstevel@tonic-gate #ifdef SOCK_TEST
1170Sstevel@tonic-gate /*
1180Sstevel@tonic-gate  * Variables that make sockfs do something other than the standard TPI
1190Sstevel@tonic-gate  * for the AF_INET transports.
1200Sstevel@tonic-gate  *
1210Sstevel@tonic-gate  * solisten_tpi_tcp:
1220Sstevel@tonic-gate  *	TCP can handle a O_T_BIND_REQ with an increased backlog even though
1230Sstevel@tonic-gate  *	the transport is already bound. This is needed to avoid loosing the
1240Sstevel@tonic-gate  *	port number should listen() do a T_UNBIND_REQ followed by a
1250Sstevel@tonic-gate  *	O_T_BIND_REQ.
1260Sstevel@tonic-gate  *
1270Sstevel@tonic-gate  * soconnect_tpi_udp:
1280Sstevel@tonic-gate  *	UDP and ICMP can handle a T_CONN_REQ.
1290Sstevel@tonic-gate  *	This is needed to make the sequence of connect(), getsockname()
1300Sstevel@tonic-gate  *	return the local IP address used to send packets to the connected to
1310Sstevel@tonic-gate  *	destination.
1320Sstevel@tonic-gate  *
1330Sstevel@tonic-gate  * soconnect_tpi_tcp:
1340Sstevel@tonic-gate  *	TCP can handle a T_CONN_REQ without seeing a O_T_BIND_REQ.
1350Sstevel@tonic-gate  *	Set this to non-zero to send TPI conformant messages to TCP in this
1360Sstevel@tonic-gate  *	respect. This is a performance optimization.
1370Sstevel@tonic-gate  *
1380Sstevel@tonic-gate  * soaccept_tpi_tcp:
1390Sstevel@tonic-gate  *	TCP can handle a T_CONN_REQ without the acceptor being bound.
1400Sstevel@tonic-gate  *	This is a performance optimization that has been picked up in XTI.
1410Sstevel@tonic-gate  *
1420Sstevel@tonic-gate  * soaccept_tpi_multioptions:
1430Sstevel@tonic-gate  *	When inheriting SOL_SOCKET options from the listener to the accepting
1440Sstevel@tonic-gate  *	socket send them as a single message for AF_INET{,6}.
1450Sstevel@tonic-gate  */
1460Sstevel@tonic-gate int solisten_tpi_tcp = 0;
1470Sstevel@tonic-gate int soconnect_tpi_udp = 0;
1480Sstevel@tonic-gate int soconnect_tpi_tcp = 0;
1490Sstevel@tonic-gate int soaccept_tpi_tcp = 0;
1500Sstevel@tonic-gate int soaccept_tpi_multioptions = 1;
1510Sstevel@tonic-gate #else /* SOCK_TEST */
1520Sstevel@tonic-gate #define	soconnect_tpi_tcp	0
1530Sstevel@tonic-gate #define	soconnect_tpi_udp	0
1540Sstevel@tonic-gate #define	solisten_tpi_tcp	0
1550Sstevel@tonic-gate #define	soaccept_tpi_tcp	0
1560Sstevel@tonic-gate #define	soaccept_tpi_multioptions	1
1570Sstevel@tonic-gate #endif /* SOCK_TEST */
1580Sstevel@tonic-gate 
1590Sstevel@tonic-gate #ifdef SOCK_TEST
1600Sstevel@tonic-gate extern int do_useracc;
1610Sstevel@tonic-gate extern clock_t sock_test_timelimit;
1620Sstevel@tonic-gate #endif /* SOCK_TEST */
1630Sstevel@tonic-gate 
1640Sstevel@tonic-gate /*
1650Sstevel@tonic-gate  * Some X/Open added checks might have to be backed out to keep SunOS 4.X
1660Sstevel@tonic-gate  * applications working. Turn on this flag to disable these checks.
1670Sstevel@tonic-gate  */
1680Sstevel@tonic-gate int xnet_skip_checks = 0;
1690Sstevel@tonic-gate int xnet_check_print = 0;
1700Sstevel@tonic-gate int xnet_truncate_print = 0;
1710Sstevel@tonic-gate 
1720Sstevel@tonic-gate extern	void sigintr(k_sigset_t *, int);
1730Sstevel@tonic-gate extern	void sigunintr(k_sigset_t *);
1740Sstevel@tonic-gate 
1750Sstevel@tonic-gate extern	void *nl7c_lookup_addr(void *, t_uscalar_t);
1760Sstevel@tonic-gate extern	void *nl7c_add_addr(void *, t_uscalar_t);
1770Sstevel@tonic-gate extern	void nl7c_listener_addr(void *, queue_t *);
1780Sstevel@tonic-gate 
179898Skais /* Sockets acting as an in-kernel SSL proxy */
180898Skais extern mblk_t	*strsock_kssl_input(vnode_t *, mblk_t *, strwakeup_t *,
181898Skais 		    strsigset_t *, strsigset_t *, strpollset_t *);
182898Skais extern mblk_t	*strsock_kssl_output(vnode_t *, mblk_t *, strwakeup_t *,
183898Skais 		    strsigset_t *, strsigset_t *, strpollset_t *);
184898Skais 
1850Sstevel@tonic-gate static int	sotpi_unbind(struct sonode *, int);
1860Sstevel@tonic-gate 
1870Sstevel@tonic-gate /* TPI sockfs sonode operations */
1880Sstevel@tonic-gate static int	sotpi_accept(struct sonode *, int, struct sonode **);
1890Sstevel@tonic-gate static int	sotpi_bind(struct sonode *, struct sockaddr *, socklen_t,
1900Sstevel@tonic-gate 		    int);
1910Sstevel@tonic-gate static int	sotpi_connect(struct sonode *, const struct sockaddr *,
1920Sstevel@tonic-gate 		    socklen_t, int, int);
1930Sstevel@tonic-gate static int	sotpi_listen(struct sonode *, int);
1940Sstevel@tonic-gate static int	sotpi_sendmsg(struct sonode *, struct nmsghdr *,
1950Sstevel@tonic-gate 		    struct uio *);
1960Sstevel@tonic-gate static int	sotpi_shutdown(struct sonode *, int);
1970Sstevel@tonic-gate static int	sotpi_getsockname(struct sonode *);
198741Smasputra static int	sosend_dgramcmsg(struct sonode *, struct sockaddr *, socklen_t,
199741Smasputra 		    struct uio *, void *, t_uscalar_t, int);
200741Smasputra static int	sodgram_direct(struct sonode *, struct sockaddr *,
201741Smasputra 		    socklen_t, struct uio *, int);
2020Sstevel@tonic-gate 
2030Sstevel@tonic-gate sonodeops_t sotpi_sonodeops = {
2040Sstevel@tonic-gate 	sotpi_accept,		/* sop_accept		*/
2050Sstevel@tonic-gate 	sotpi_bind,		/* sop_bind		*/
2060Sstevel@tonic-gate 	sotpi_listen,		/* sop_listen		*/
2070Sstevel@tonic-gate 	sotpi_connect,		/* sop_connect		*/
2080Sstevel@tonic-gate 	sotpi_recvmsg,		/* sop_recvmsg		*/
2090Sstevel@tonic-gate 	sotpi_sendmsg,		/* sop_sendmsg		*/
2100Sstevel@tonic-gate 	sotpi_getpeername,	/* sop_getpeername	*/
2110Sstevel@tonic-gate 	sotpi_getsockname,	/* sop_getsockname	*/
2120Sstevel@tonic-gate 	sotpi_shutdown,		/* sop_shutdown		*/
2130Sstevel@tonic-gate 	sotpi_getsockopt,	/* sop_getsockopt	*/
2140Sstevel@tonic-gate 	sotpi_setsockopt	/* sop_setsockopt	*/
2150Sstevel@tonic-gate };
2160Sstevel@tonic-gate 
2170Sstevel@tonic-gate /*
2180Sstevel@tonic-gate  * Common create code for socket and accept. If tso is set the values
2190Sstevel@tonic-gate  * from that node is used instead of issuing a T_INFO_REQ.
2200Sstevel@tonic-gate  *
2210Sstevel@tonic-gate  * Assumes that the caller has a VN_HOLD on accessvp.
2220Sstevel@tonic-gate  * The VN_RELE will occur either when sotpi_create() fails or when
2230Sstevel@tonic-gate  * the returned sonode is freed.
2240Sstevel@tonic-gate  */
2250Sstevel@tonic-gate struct sonode *
2260Sstevel@tonic-gate sotpi_create(vnode_t *accessvp, int domain, int type, int protocol, int version,
2270Sstevel@tonic-gate     struct sonode *tso, int *errorp)
2280Sstevel@tonic-gate {
2290Sstevel@tonic-gate 	struct sonode	*so;
2300Sstevel@tonic-gate 	vnode_t		*vp;
2310Sstevel@tonic-gate 	int		flags, error;
2320Sstevel@tonic-gate 
2330Sstevel@tonic-gate 	ASSERT(accessvp != NULL);
2340Sstevel@tonic-gate 	vp = makesockvp(accessvp, domain, type, protocol);
2350Sstevel@tonic-gate 	ASSERT(vp != NULL);
2360Sstevel@tonic-gate 	so = VTOSO(vp);
2370Sstevel@tonic-gate 
2380Sstevel@tonic-gate 	flags = FREAD|FWRITE;
239741Smasputra 
240741Smasputra 	if ((type == SOCK_STREAM || type == SOCK_DGRAM) &&
241741Smasputra 	    (domain == AF_INET || domain == AF_INET6) &&
242741Smasputra 	    (protocol == IPPROTO_TCP || protocol == IPPROTO_UDP ||
243741Smasputra 	    protocol == IPPROTO_IP)) {
244741Smasputra 		/* Tell tcp or udp that it's talking to sockets */
245741Smasputra 		flags |= SO_SOCKSTR;
246741Smasputra 
247741Smasputra 		/*
248741Smasputra 		 * Here we indicate to socktpi_open() our attempt to
249741Smasputra 		 * make direct calls between sockfs and transport.
250741Smasputra 		 * The final decision is left to socktpi_open().
251741Smasputra 		 */
252741Smasputra 		so->so_state |= SS_DIRECT;
253741Smasputra 
254741Smasputra 		ASSERT(so->so_type != SOCK_DGRAM || tso == NULL);
255741Smasputra 		if (so->so_type == SOCK_STREAM && tso != NULL) {
256741Smasputra 			if (tso->so_state & SS_DIRECT) {
257741Smasputra 				/*
258741Smasputra 				 * Inherit SS_DIRECT from listener and pass
259741Smasputra 				 * SO_ACCEPTOR open flag to tcp, indicating
260741Smasputra 				 * that this is an accept fast-path instance.
261741Smasputra 				 */
262741Smasputra 				flags |= SO_ACCEPTOR;
263741Smasputra 			} else {
264741Smasputra 				/*
265741Smasputra 				 * SS_DIRECT is not set on listener, meaning
266741Smasputra 				 * that the listener has been converted from
267741Smasputra 				 * a socket to a stream.  Ensure that the
268741Smasputra 				 * acceptor inherits these settings.
269741Smasputra 				 */
270741Smasputra 				so->so_state &= ~SS_DIRECT;
271741Smasputra 				flags &= ~SO_SOCKSTR;
272741Smasputra 			}
2730Sstevel@tonic-gate 		}
2740Sstevel@tonic-gate 	}
2750Sstevel@tonic-gate 
2760Sstevel@tonic-gate 	/*
2770Sstevel@tonic-gate 	 * Tell local transport that it is talking to sockets.
2780Sstevel@tonic-gate 	 */
2790Sstevel@tonic-gate 	if (so->so_family == AF_UNIX) {
2800Sstevel@tonic-gate 		flags |= SO_SOCKSTR;
2810Sstevel@tonic-gate 	}
2820Sstevel@tonic-gate 
2831092Skais 	/* Initialize the kernel SSL proxy fields */
2841092Skais 	so->so_kssl_type = KSSL_NO_PROXY;
2851092Skais 	so->so_kssl_ent = NULL;
2861092Skais 	so->so_kssl_ctx = NULL;
2871092Skais 
2880Sstevel@tonic-gate 	if (error = socktpi_open(&vp, flags, CRED())) {
2890Sstevel@tonic-gate 		VN_RELE(vp);
2900Sstevel@tonic-gate 		*errorp = error;
2910Sstevel@tonic-gate 		return (NULL);
2920Sstevel@tonic-gate 	}
2930Sstevel@tonic-gate 
2940Sstevel@tonic-gate 	if (error = so_strinit(so, tso)) {
2950Sstevel@tonic-gate 		(void) VOP_CLOSE(vp, 0, 1, 0, CRED());
2960Sstevel@tonic-gate 		VN_RELE(vp);
2970Sstevel@tonic-gate 		*errorp = error;
2980Sstevel@tonic-gate 		return (NULL);
2990Sstevel@tonic-gate 	}
3000Sstevel@tonic-gate 
3010Sstevel@tonic-gate 	if (version == SOV_DEFAULT)
3020Sstevel@tonic-gate 		version = so_default_version;
3030Sstevel@tonic-gate 
3040Sstevel@tonic-gate 	so->so_version = (short)version;
305898Skais 
3060Sstevel@tonic-gate 	return (so);
3070Sstevel@tonic-gate }
3080Sstevel@tonic-gate 
3090Sstevel@tonic-gate /*
3100Sstevel@tonic-gate  * Bind the socket to an unspecified address in sockfs only.
3110Sstevel@tonic-gate  * Used for TCP/UDP transports where we know that the O_T_BIND_REQ isn't
3120Sstevel@tonic-gate  * required in all cases.
3130Sstevel@tonic-gate  */
3140Sstevel@tonic-gate static void
3150Sstevel@tonic-gate so_automatic_bind(struct sonode *so)
3160Sstevel@tonic-gate {
3170Sstevel@tonic-gate 	ASSERT(so->so_family == AF_INET || so->so_family == AF_INET6);
3180Sstevel@tonic-gate 
3190Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
3200Sstevel@tonic-gate 	ASSERT(!(so->so_state & SS_ISBOUND));
3210Sstevel@tonic-gate 	ASSERT(so->so_unbind_mp);
3220Sstevel@tonic-gate 
3230Sstevel@tonic-gate 	ASSERT(so->so_laddr_len <= so->so_laddr_maxlen);
3240Sstevel@tonic-gate 	bzero(so->so_laddr_sa, so->so_laddr_len);
3250Sstevel@tonic-gate 	so->so_laddr_sa->sa_family = so->so_family;
3260Sstevel@tonic-gate 	so->so_state |= SS_ISBOUND;
3270Sstevel@tonic-gate }
3280Sstevel@tonic-gate 
3290Sstevel@tonic-gate 
3300Sstevel@tonic-gate /*
3310Sstevel@tonic-gate  * bind the socket.
3320Sstevel@tonic-gate  *
3330Sstevel@tonic-gate  * If the socket is already bound and none of _SOBIND_SOCKBSD or _SOBIND_XPG4_2
3340Sstevel@tonic-gate  * are passed in we allow rebinding. Note that for backwards compatibility
3350Sstevel@tonic-gate  * even "svr4" sockets pass in _SOBIND_SOCKBSD/SOV_SOCKBSD to sobind/bind.
3360Sstevel@tonic-gate  * Thus the rebinding code is currently not executed.
3370Sstevel@tonic-gate  *
3380Sstevel@tonic-gate  * The constraints for rebinding are:
3390Sstevel@tonic-gate  * - it is a SOCK_DGRAM, or
3400Sstevel@tonic-gate  * - it is a SOCK_STREAM/SOCK_SEQPACKET that has not been connected
3410Sstevel@tonic-gate  *   and no listen() has been done.
3420Sstevel@tonic-gate  * This rebinding code was added based on some language in the XNET book
3430Sstevel@tonic-gate  * about not returning EINVAL it the protocol allows rebinding. However,
3440Sstevel@tonic-gate  * this language is not present in the Posix socket draft. Thus maybe the
3450Sstevel@tonic-gate  * rebinding logic should be deleted from the source.
3460Sstevel@tonic-gate  *
3470Sstevel@tonic-gate  * A null "name" can be used to unbind the socket if:
3480Sstevel@tonic-gate  * - it is a SOCK_DGRAM, or
3490Sstevel@tonic-gate  * - it is a SOCK_STREAM/SOCK_SEQPACKET that has not been connected
3500Sstevel@tonic-gate  *   and no listen() has been done.
3510Sstevel@tonic-gate  */
3520Sstevel@tonic-gate static int
3530Sstevel@tonic-gate sotpi_bindlisten(struct sonode *so, struct sockaddr *name,
3540Sstevel@tonic-gate     socklen_t namelen, int backlog, int flags)
3550Sstevel@tonic-gate {
3560Sstevel@tonic-gate 	struct T_bind_req	bind_req;
3570Sstevel@tonic-gate 	struct T_bind_ack	*bind_ack;
3580Sstevel@tonic-gate 	int			error = 0;
3590Sstevel@tonic-gate 	mblk_t			*mp;
3600Sstevel@tonic-gate 	void			*addr;
3610Sstevel@tonic-gate 	t_uscalar_t		addrlen;
3620Sstevel@tonic-gate 	int			unbind_on_err = 1;
3630Sstevel@tonic-gate 	boolean_t		clear_acceptconn_on_err = B_FALSE;
3640Sstevel@tonic-gate 	boolean_t		restore_backlog_on_err = B_FALSE;
3650Sstevel@tonic-gate 	int			save_so_backlog;
3660Sstevel@tonic-gate 	t_scalar_t		PRIM_type = O_T_BIND_REQ;
3670Sstevel@tonic-gate 	boolean_t		tcp_udp_xport;
3680Sstevel@tonic-gate 	void			*nl7c = NULL;
3690Sstevel@tonic-gate 
3700Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_bindlisten(%p, %p, %d, %d, 0x%x) %s\n",
3710Sstevel@tonic-gate 		so, name, namelen, backlog, flags,
3720Sstevel@tonic-gate 		pr_state(so->so_state, so->so_mode)));
3730Sstevel@tonic-gate 
3740Sstevel@tonic-gate 	tcp_udp_xport = so->so_type == SOCK_STREAM || so->so_type == SOCK_DGRAM;
3750Sstevel@tonic-gate 
3760Sstevel@tonic-gate 	if (!(flags & _SOBIND_LOCK_HELD)) {
3770Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
3780Sstevel@tonic-gate 		so_lock_single(so);	/* Set SOLOCKED */
3790Sstevel@tonic-gate 	} else {
3800Sstevel@tonic-gate 		ASSERT(MUTEX_HELD(&so->so_lock));
3810Sstevel@tonic-gate 		ASSERT(so->so_flag & SOLOCKED);
3820Sstevel@tonic-gate 	}
3830Sstevel@tonic-gate 
3840Sstevel@tonic-gate 	/*
3850Sstevel@tonic-gate 	 * Make sure that there is a preallocated unbind_req message
3860Sstevel@tonic-gate 	 * before binding. This message allocated when the socket is
3870Sstevel@tonic-gate 	 * created  but it might be have been consumed.
3880Sstevel@tonic-gate 	 */
3890Sstevel@tonic-gate 	if (so->so_unbind_mp == NULL) {
3900Sstevel@tonic-gate 		dprintso(so, 1, ("sobind: allocating unbind_req\n"));
3910Sstevel@tonic-gate 		/* NOTE: holding so_lock while sleeping */
3920Sstevel@tonic-gate 		so->so_unbind_mp =
3930Sstevel@tonic-gate 		    soallocproto(sizeof (struct T_unbind_req), _ALLOC_SLEEP);
3940Sstevel@tonic-gate 	}
3950Sstevel@tonic-gate 
3960Sstevel@tonic-gate 	if (flags & _SOBIND_REBIND) {
3970Sstevel@tonic-gate 		/*
3980Sstevel@tonic-gate 		 * Called from solisten after doing an sotpi_unbind() or
3990Sstevel@tonic-gate 		 * potentially without the unbind (latter for AF_INET{,6}).
4000Sstevel@tonic-gate 		 */
4010Sstevel@tonic-gate 		ASSERT(name == NULL && namelen == 0);
4020Sstevel@tonic-gate 
4030Sstevel@tonic-gate 		if (so->so_family == AF_UNIX) {
4040Sstevel@tonic-gate 			ASSERT(so->so_ux_bound_vp);
4050Sstevel@tonic-gate 			addr = &so->so_ux_laddr;
4060Sstevel@tonic-gate 			addrlen = (t_uscalar_t)sizeof (so->so_ux_laddr);
4070Sstevel@tonic-gate 			dprintso(so, 1,
4080Sstevel@tonic-gate 			("sobind rebind UNIX: addrlen %d, addr 0x%p, vp %p\n",
4090Sstevel@tonic-gate 			    addrlen,
4100Sstevel@tonic-gate 			    ((struct so_ux_addr *)addr)->soua_vp,
4110Sstevel@tonic-gate 			    so->so_ux_bound_vp));
4120Sstevel@tonic-gate 		} else {
4130Sstevel@tonic-gate 			addr = so->so_laddr_sa;
4140Sstevel@tonic-gate 			addrlen = (t_uscalar_t)so->so_laddr_len;
4150Sstevel@tonic-gate 		}
4160Sstevel@tonic-gate 	} else if (flags & _SOBIND_UNSPEC) {
4170Sstevel@tonic-gate 		ASSERT(name == NULL && namelen == 0);
4180Sstevel@tonic-gate 
4190Sstevel@tonic-gate 		/*
4200Sstevel@tonic-gate 		 * The caller checked SS_ISBOUND but not necessarily
4210Sstevel@tonic-gate 		 * under so_lock
4220Sstevel@tonic-gate 		 */
4230Sstevel@tonic-gate 		if (so->so_state & SS_ISBOUND) {
4240Sstevel@tonic-gate 			/* No error */
4250Sstevel@tonic-gate 			goto done;
4260Sstevel@tonic-gate 		}
4270Sstevel@tonic-gate 
4280Sstevel@tonic-gate 		/* Set an initial local address */
4290Sstevel@tonic-gate 		switch (so->so_family) {
4300Sstevel@tonic-gate 		case AF_UNIX:
4310Sstevel@tonic-gate 			/*
4320Sstevel@tonic-gate 			 * Use an address with same size as struct sockaddr
4330Sstevel@tonic-gate 			 * just like BSD.
4340Sstevel@tonic-gate 			 */
4350Sstevel@tonic-gate 			so->so_laddr_len =
4360Sstevel@tonic-gate 				(socklen_t)sizeof (struct sockaddr);
4370Sstevel@tonic-gate 			ASSERT(so->so_laddr_len <= so->so_laddr_maxlen);
4380Sstevel@tonic-gate 			bzero(so->so_laddr_sa, so->so_laddr_len);
4390Sstevel@tonic-gate 			so->so_laddr_sa->sa_family = so->so_family;
4400Sstevel@tonic-gate 
4410Sstevel@tonic-gate 			/*
4420Sstevel@tonic-gate 			 * Pass down an address with the implicit bind
4430Sstevel@tonic-gate 			 * magic number and the rest all zeros.
4440Sstevel@tonic-gate 			 * The transport will return a unique address.
4450Sstevel@tonic-gate 			 */
4460Sstevel@tonic-gate 			so->so_ux_laddr.soua_vp = NULL;
4470Sstevel@tonic-gate 			so->so_ux_laddr.soua_magic = SOU_MAGIC_IMPLICIT;
4480Sstevel@tonic-gate 			addr = &so->so_ux_laddr;
4490Sstevel@tonic-gate 			addrlen = (t_uscalar_t)sizeof (so->so_ux_laddr);
4500Sstevel@tonic-gate 			break;
4510Sstevel@tonic-gate 
4520Sstevel@tonic-gate 		case AF_INET:
4530Sstevel@tonic-gate 		case AF_INET6:
4540Sstevel@tonic-gate 			/*
4550Sstevel@tonic-gate 			 * An unspecified bind in TPI has a NULL address.
4560Sstevel@tonic-gate 			 * Set the address in sockfs to have the sa_family.
4570Sstevel@tonic-gate 			 */
4580Sstevel@tonic-gate 			so->so_laddr_len = (so->so_family == AF_INET) ?
4590Sstevel@tonic-gate 			    (socklen_t)sizeof (sin_t) :
4600Sstevel@tonic-gate 			    (socklen_t)sizeof (sin6_t);
4610Sstevel@tonic-gate 			ASSERT(so->so_laddr_len <= so->so_laddr_maxlen);
4620Sstevel@tonic-gate 			bzero(so->so_laddr_sa, so->so_laddr_len);
4630Sstevel@tonic-gate 			so->so_laddr_sa->sa_family = so->so_family;
4640Sstevel@tonic-gate 			addr = NULL;
4650Sstevel@tonic-gate 			addrlen = 0;
4660Sstevel@tonic-gate 			break;
4670Sstevel@tonic-gate 
4680Sstevel@tonic-gate 		default:
4690Sstevel@tonic-gate 			/*
4700Sstevel@tonic-gate 			 * An unspecified bind in TPI has a NULL address.
4710Sstevel@tonic-gate 			 * Set the address in sockfs to be zero length.
4720Sstevel@tonic-gate 			 *
4730Sstevel@tonic-gate 			 * Can not assume there is a sa_family for all
4740Sstevel@tonic-gate 			 * protocol families. For example, AF_X25 does not
4750Sstevel@tonic-gate 			 * have a family field.
4760Sstevel@tonic-gate 			 */
4770Sstevel@tonic-gate 			so->so_laddr_len = 0;	/* XXX correct? */
4780Sstevel@tonic-gate 			bzero(so->so_laddr_sa, so->so_laddr_len);
4790Sstevel@tonic-gate 			addr = NULL;
4800Sstevel@tonic-gate 			addrlen = 0;
4810Sstevel@tonic-gate 			break;
4820Sstevel@tonic-gate 		}
4830Sstevel@tonic-gate 
4840Sstevel@tonic-gate 	} else {
4850Sstevel@tonic-gate 		if (so->so_state & SS_ISBOUND) {
4860Sstevel@tonic-gate 			/*
4870Sstevel@tonic-gate 			 * If it is ok to rebind the socket, first unbind
4880Sstevel@tonic-gate 			 * with the transport. A rebind to the NULL address
4890Sstevel@tonic-gate 			 * is interpreted as an unbind.
4900Sstevel@tonic-gate 			 * Note that a bind to NULL in BSD does unbind the
4910Sstevel@tonic-gate 			 * socket but it fails with EINVAL.
4920Sstevel@tonic-gate 			 * Note that regular sockets set SOV_SOCKBSD i.e.
4930Sstevel@tonic-gate 			 * _SOBIND_SOCKBSD gets set here hence no type of
4940Sstevel@tonic-gate 			 * socket does currently allow rebinding.
4950Sstevel@tonic-gate 			 *
4960Sstevel@tonic-gate 			 * If the name is NULL just do an unbind.
4970Sstevel@tonic-gate 			 */
4980Sstevel@tonic-gate 			if (flags & (_SOBIND_SOCKBSD|_SOBIND_XPG4_2) &&
4990Sstevel@tonic-gate 			    name != NULL) {
5000Sstevel@tonic-gate 				error = EINVAL;
5010Sstevel@tonic-gate 				unbind_on_err = 0;
5020Sstevel@tonic-gate 				eprintsoline(so, error);
5030Sstevel@tonic-gate 				goto done;
5040Sstevel@tonic-gate 			}
5050Sstevel@tonic-gate 			if ((so->so_mode & SM_CONNREQUIRED) &&
5060Sstevel@tonic-gate 			    (so->so_state & SS_CANTREBIND)) {
5070Sstevel@tonic-gate 				error = EINVAL;
5080Sstevel@tonic-gate 				unbind_on_err = 0;
5090Sstevel@tonic-gate 				eprintsoline(so, error);
5100Sstevel@tonic-gate 				goto done;
5110Sstevel@tonic-gate 			}
5120Sstevel@tonic-gate 			error = sotpi_unbind(so, 0);
5130Sstevel@tonic-gate 			if (error) {
5140Sstevel@tonic-gate 				eprintsoline(so, error);
5150Sstevel@tonic-gate 				goto done;
5160Sstevel@tonic-gate 			}
5170Sstevel@tonic-gate 			ASSERT(!(so->so_state & SS_ISBOUND));
5180Sstevel@tonic-gate 			if (name == NULL) {
5190Sstevel@tonic-gate 				so->so_state &=
5200Sstevel@tonic-gate 					~(SS_ISCONNECTED|SS_ISCONNECTING);
5210Sstevel@tonic-gate 				goto done;
5220Sstevel@tonic-gate 			}
5230Sstevel@tonic-gate 		}
5240Sstevel@tonic-gate 		/* X/Open requires this check */
5250Sstevel@tonic-gate 		if ((so->so_state & SS_CANTSENDMORE) && !xnet_skip_checks) {
5260Sstevel@tonic-gate 			if (xnet_check_print) {
5270Sstevel@tonic-gate 				printf("sockfs: X/Open bind state check "
5280Sstevel@tonic-gate 				    "caused EINVAL\n");
5290Sstevel@tonic-gate 			}
5300Sstevel@tonic-gate 			error = EINVAL;
5310Sstevel@tonic-gate 			goto done;
5320Sstevel@tonic-gate 		}
5330Sstevel@tonic-gate 
5340Sstevel@tonic-gate 		switch (so->so_family) {
5350Sstevel@tonic-gate 		case AF_UNIX:
5360Sstevel@tonic-gate 			/*
5370Sstevel@tonic-gate 			 * All AF_UNIX addresses are nul terminated
5380Sstevel@tonic-gate 			 * when copied (copyin_name) in so the minimum
5390Sstevel@tonic-gate 			 * length is 3 bytes.
5400Sstevel@tonic-gate 			 */
5410Sstevel@tonic-gate 			if (name == NULL ||
5420Sstevel@tonic-gate 			    (ssize_t)namelen <= sizeof (short) + 1) {
5430Sstevel@tonic-gate 				error = EISDIR;
5440Sstevel@tonic-gate 				eprintsoline(so, error);
5450Sstevel@tonic-gate 				goto done;
5460Sstevel@tonic-gate 			}
5470Sstevel@tonic-gate 			/*
5480Sstevel@tonic-gate 			 * Verify so_family matches the bound family.
5490Sstevel@tonic-gate 			 * BSD does not check this for AF_UNIX resulting
5500Sstevel@tonic-gate 			 * in funny mknods.
5510Sstevel@tonic-gate 			 */
5520Sstevel@tonic-gate 			if (name->sa_family != so->so_family) {
5530Sstevel@tonic-gate 				error = EAFNOSUPPORT;
5540Sstevel@tonic-gate 				goto done;
5550Sstevel@tonic-gate 			}
5560Sstevel@tonic-gate 			break;
5570Sstevel@tonic-gate 		case AF_INET:
5580Sstevel@tonic-gate 			if (name == NULL) {
5590Sstevel@tonic-gate 				error = EINVAL;
5600Sstevel@tonic-gate 				eprintsoline(so, error);
5610Sstevel@tonic-gate 				goto done;
5620Sstevel@tonic-gate 			}
5630Sstevel@tonic-gate 			if ((size_t)namelen != sizeof (sin_t)) {
5640Sstevel@tonic-gate 				error = name->sa_family != so->so_family ?
5650Sstevel@tonic-gate 				    EAFNOSUPPORT : EINVAL;
5660Sstevel@tonic-gate 				eprintsoline(so, error);
5670Sstevel@tonic-gate 				goto done;
5680Sstevel@tonic-gate 			}
5690Sstevel@tonic-gate 			if ((flags & _SOBIND_XPG4_2) &&
5700Sstevel@tonic-gate 			    (name->sa_family != so->so_family)) {
5710Sstevel@tonic-gate 				/*
5720Sstevel@tonic-gate 				 * This check has to be made for X/Open
5730Sstevel@tonic-gate 				 * sockets however application failures have
5740Sstevel@tonic-gate 				 * been observed when it is applied to
5750Sstevel@tonic-gate 				 * all sockets.
5760Sstevel@tonic-gate 				 */
5770Sstevel@tonic-gate 				error = EAFNOSUPPORT;
5780Sstevel@tonic-gate 				eprintsoline(so, error);
5790Sstevel@tonic-gate 				goto done;
5800Sstevel@tonic-gate 			}
5810Sstevel@tonic-gate 			/*
5820Sstevel@tonic-gate 			 * Force a zero sa_family to match so_family.
5830Sstevel@tonic-gate 			 *
5840Sstevel@tonic-gate 			 * Some programs like inetd(1M) don't set the
5850Sstevel@tonic-gate 			 * family field. Other programs leave
5860Sstevel@tonic-gate 			 * sin_family set to garbage - SunOS 4.X does
5870Sstevel@tonic-gate 			 * not check the family field on a bind.
5880Sstevel@tonic-gate 			 * We use the family field that
5890Sstevel@tonic-gate 			 * was passed in to the socket() call.
5900Sstevel@tonic-gate 			 */
5910Sstevel@tonic-gate 			name->sa_family = so->so_family;
5920Sstevel@tonic-gate 			break;
5930Sstevel@tonic-gate 
5940Sstevel@tonic-gate 		case AF_INET6: {
5950Sstevel@tonic-gate #ifdef DEBUG
5960Sstevel@tonic-gate 			sin6_t *sin6 = (sin6_t *)name;
5970Sstevel@tonic-gate #endif /* DEBUG */
5980Sstevel@tonic-gate 
5990Sstevel@tonic-gate 			if (name == NULL) {
6000Sstevel@tonic-gate 				error = EINVAL;
6010Sstevel@tonic-gate 				eprintsoline(so, error);
6020Sstevel@tonic-gate 				goto done;
6030Sstevel@tonic-gate 			}
6040Sstevel@tonic-gate 			if ((size_t)namelen != sizeof (sin6_t)) {
6050Sstevel@tonic-gate 				error = name->sa_family != so->so_family ?
6060Sstevel@tonic-gate 				    EAFNOSUPPORT : EINVAL;
6070Sstevel@tonic-gate 				eprintsoline(so, error);
6080Sstevel@tonic-gate 				goto done;
6090Sstevel@tonic-gate 			}
6100Sstevel@tonic-gate 			if (name->sa_family != so->so_family) {
6110Sstevel@tonic-gate 				/*
6120Sstevel@tonic-gate 				 * With IPv6 we require the family to match
6130Sstevel@tonic-gate 				 * unlike in IPv4.
6140Sstevel@tonic-gate 				 */
6150Sstevel@tonic-gate 				error = EAFNOSUPPORT;
6160Sstevel@tonic-gate 				eprintsoline(so, error);
6170Sstevel@tonic-gate 				goto done;
6180Sstevel@tonic-gate 			}
6190Sstevel@tonic-gate #ifdef DEBUG
6200Sstevel@tonic-gate 			/*
6210Sstevel@tonic-gate 			 * Verify that apps don't forget to clear
6220Sstevel@tonic-gate 			 * sin6_scope_id etc
6230Sstevel@tonic-gate 			 */
6240Sstevel@tonic-gate 			if (sin6->sin6_scope_id != 0 &&
6250Sstevel@tonic-gate 			    !IN6_IS_ADDR_LINKSCOPE(&sin6->sin6_addr)) {
6260Sstevel@tonic-gate 				cmn_err(CE_WARN,
6270Sstevel@tonic-gate 				    "bind with uninitialized sin6_scope_id "
6280Sstevel@tonic-gate 				    "(%d) on socket. Pid = %d\n",
6290Sstevel@tonic-gate 				    (int)sin6->sin6_scope_id,
6300Sstevel@tonic-gate 				    (int)curproc->p_pid);
6310Sstevel@tonic-gate 			}
6320Sstevel@tonic-gate 			if (sin6->__sin6_src_id != 0) {
6330Sstevel@tonic-gate 				cmn_err(CE_WARN,
6340Sstevel@tonic-gate 				    "bind with uninitialized __sin6_src_id "
6350Sstevel@tonic-gate 				    "(%d) on socket. Pid = %d\n",
6360Sstevel@tonic-gate 				    (int)sin6->__sin6_src_id,
6370Sstevel@tonic-gate 				    (int)curproc->p_pid);
6380Sstevel@tonic-gate 			}
6390Sstevel@tonic-gate #endif /* DEBUG */
6400Sstevel@tonic-gate 			break;
6410Sstevel@tonic-gate 		}
6420Sstevel@tonic-gate 		default:
6430Sstevel@tonic-gate 			/*
6440Sstevel@tonic-gate 			 * Don't do any length or sa_family check to allow
6450Sstevel@tonic-gate 			 * non-sockaddr style addresses.
6460Sstevel@tonic-gate 			 */
6470Sstevel@tonic-gate 			if (name == NULL) {
6480Sstevel@tonic-gate 				error = EINVAL;
6490Sstevel@tonic-gate 				eprintsoline(so, error);
6500Sstevel@tonic-gate 				goto done;
6510Sstevel@tonic-gate 			}
6520Sstevel@tonic-gate 			break;
6530Sstevel@tonic-gate 		}
6540Sstevel@tonic-gate 
6550Sstevel@tonic-gate 		if (namelen > (t_uscalar_t)so->so_laddr_maxlen) {
6560Sstevel@tonic-gate 			error = ENAMETOOLONG;
6570Sstevel@tonic-gate 			eprintsoline(so, error);
6580Sstevel@tonic-gate 			goto done;
6590Sstevel@tonic-gate 		}
6600Sstevel@tonic-gate 		/*
6610Sstevel@tonic-gate 		 * Save local address.
6620Sstevel@tonic-gate 		 */
6630Sstevel@tonic-gate 		so->so_laddr_len = (socklen_t)namelen;
6640Sstevel@tonic-gate 		ASSERT(so->so_laddr_len <= so->so_laddr_maxlen);
6650Sstevel@tonic-gate 		bcopy(name, so->so_laddr_sa, namelen);
6660Sstevel@tonic-gate 
6670Sstevel@tonic-gate 		addr = so->so_laddr_sa;
6680Sstevel@tonic-gate 		addrlen = (t_uscalar_t)so->so_laddr_len;
6690Sstevel@tonic-gate 		switch (so->so_family) {
6700Sstevel@tonic-gate 		case AF_INET6:
6710Sstevel@tonic-gate 		case AF_INET:
6720Sstevel@tonic-gate 			break;
6730Sstevel@tonic-gate 		case AF_UNIX: {
6740Sstevel@tonic-gate 			struct sockaddr_un *soun =
6750Sstevel@tonic-gate 				(struct sockaddr_un *)so->so_laddr_sa;
6760Sstevel@tonic-gate 			struct vnode *vp;
6770Sstevel@tonic-gate 			struct vattr vattr;
6780Sstevel@tonic-gate 
6790Sstevel@tonic-gate 			ASSERT(so->so_ux_bound_vp == NULL);
6800Sstevel@tonic-gate 			/*
6810Sstevel@tonic-gate 			 * Create vnode for the specified path name.
6820Sstevel@tonic-gate 			 * Keep vnode held with a reference in so_ux_bound_vp.
6830Sstevel@tonic-gate 			 * Use the vnode pointer as the address used in the
6840Sstevel@tonic-gate 			 * bind with the transport.
6850Sstevel@tonic-gate 			 *
6860Sstevel@tonic-gate 			 * Use the same mode as in BSD. In particular this does
6870Sstevel@tonic-gate 			 * not observe the umask.
6880Sstevel@tonic-gate 			 */
6890Sstevel@tonic-gate 			/* MAXPATHLEN + soun_family + nul termination */
6900Sstevel@tonic-gate 			if (so->so_laddr_len >
6910Sstevel@tonic-gate 			    (socklen_t)(MAXPATHLEN + sizeof (short) + 1)) {
6920Sstevel@tonic-gate 				error = ENAMETOOLONG;
6930Sstevel@tonic-gate 				eprintsoline(so, error);
6940Sstevel@tonic-gate 				goto done;
6950Sstevel@tonic-gate 			}
6960Sstevel@tonic-gate 			vattr.va_type = VSOCK;
6970Sstevel@tonic-gate 			vattr.va_mode = 0777 & ~u.u_cmask;
6980Sstevel@tonic-gate 			vattr.va_mask = AT_TYPE|AT_MODE;
6990Sstevel@tonic-gate 			/* NOTE: holding so_lock */
7000Sstevel@tonic-gate 			error = vn_create(soun->sun_path, UIO_SYSSPACE, &vattr,
7010Sstevel@tonic-gate 						EXCL, 0, &vp, CRMKNOD, 0, 0);
7020Sstevel@tonic-gate 			if (error) {
7030Sstevel@tonic-gate 				if (error == EEXIST)
7040Sstevel@tonic-gate 					error = EADDRINUSE;
7050Sstevel@tonic-gate 				eprintsoline(so, error);
7060Sstevel@tonic-gate 				goto done;
7070Sstevel@tonic-gate 			}
7080Sstevel@tonic-gate 			/*
7090Sstevel@tonic-gate 			 * Establish pointer from the underlying filesystem
7100Sstevel@tonic-gate 			 * vnode to the socket node.
7110Sstevel@tonic-gate 			 * so_ux_bound_vp and v_stream->sd_vnode form the
7120Sstevel@tonic-gate 			 * cross-linkage between the underlying filesystem
7130Sstevel@tonic-gate 			 * node and the socket node.
7140Sstevel@tonic-gate 			 */
7150Sstevel@tonic-gate 			ASSERT(SOTOV(so)->v_stream);
7160Sstevel@tonic-gate 			mutex_enter(&vp->v_lock);
7170Sstevel@tonic-gate 			vp->v_stream = SOTOV(so)->v_stream;
7180Sstevel@tonic-gate 			so->so_ux_bound_vp = vp;
7190Sstevel@tonic-gate 			mutex_exit(&vp->v_lock);
7200Sstevel@tonic-gate 
7210Sstevel@tonic-gate 			/*
7220Sstevel@tonic-gate 			 * Use the vnode pointer value as a unique address
7230Sstevel@tonic-gate 			 * (together with the magic number to avoid conflicts
7240Sstevel@tonic-gate 			 * with implicit binds) in the transport provider.
7250Sstevel@tonic-gate 			 */
7260Sstevel@tonic-gate 			so->so_ux_laddr.soua_vp = (void *)so->so_ux_bound_vp;
7270Sstevel@tonic-gate 			so->so_ux_laddr.soua_magic = SOU_MAGIC_EXPLICIT;
7280Sstevel@tonic-gate 			addr = &so->so_ux_laddr;
7290Sstevel@tonic-gate 			addrlen = (t_uscalar_t)sizeof (so->so_ux_laddr);
7300Sstevel@tonic-gate 			dprintso(so, 1, ("sobind UNIX: addrlen %d, addr %p\n",
7310Sstevel@tonic-gate 			    addrlen,
7320Sstevel@tonic-gate 			    ((struct so_ux_addr *)addr)->soua_vp));
7330Sstevel@tonic-gate 			break;
7340Sstevel@tonic-gate 		}
7350Sstevel@tonic-gate 		} /* end switch (so->so_family) */
7360Sstevel@tonic-gate 	}
7370Sstevel@tonic-gate 
7380Sstevel@tonic-gate 	/*
7390Sstevel@tonic-gate 	 * set SS_ACCEPTCONN before sending down O_T_BIND_REQ since
7400Sstevel@tonic-gate 	 * the transport can start passing up T_CONN_IND messages
7410Sstevel@tonic-gate 	 * as soon as it receives the bind req and strsock_proto()
7420Sstevel@tonic-gate 	 * insists that SS_ACCEPTCONN is set when processing T_CONN_INDs.
7430Sstevel@tonic-gate 	 */
7440Sstevel@tonic-gate 	if (flags & _SOBIND_LISTEN) {
7450Sstevel@tonic-gate 		if ((so->so_state & SS_ACCEPTCONN) == 0)
7460Sstevel@tonic-gate 			clear_acceptconn_on_err = B_TRUE;
7470Sstevel@tonic-gate 		save_so_backlog = so->so_backlog;
7480Sstevel@tonic-gate 		restore_backlog_on_err = B_TRUE;
7490Sstevel@tonic-gate 		so->so_state |= SS_ACCEPTCONN;
7500Sstevel@tonic-gate 		so->so_backlog = backlog;
7510Sstevel@tonic-gate 	}
7520Sstevel@tonic-gate 
7530Sstevel@tonic-gate 	/*
7540Sstevel@tonic-gate 	 * If NL7C addr(s) have been configured check for addr/port match,
7550Sstevel@tonic-gate 	 * or if an implicit NL7C socket via AF_NCA mark socket as NL7C.
7560Sstevel@tonic-gate 	 *
7570Sstevel@tonic-gate 	 * NL7C supports the TCP transport only so check AF_INET and AF_INET6
7580Sstevel@tonic-gate 	 * family sockets only. If match mark as such.
7590Sstevel@tonic-gate 	 */
7600Sstevel@tonic-gate 	if ((nl7c_enabled && addr != NULL &&
7610Sstevel@tonic-gate 	    (so->so_family == AF_INET || so->so_family == AF_INET6) &&
7620Sstevel@tonic-gate 	    (nl7c = nl7c_lookup_addr(addr, addrlen))) ||
7630Sstevel@tonic-gate 	    so->so_nl7c_flags == NL7C_AF_NCA) {
7640Sstevel@tonic-gate 		/*
7650Sstevel@tonic-gate 		 * NL7C is not supported in non-global zones,
7660Sstevel@tonic-gate 		 * we enforce this restriction here.
7670Sstevel@tonic-gate 		 */
7680Sstevel@tonic-gate 		if (so->so_zoneid == GLOBAL_ZONEID) {
7690Sstevel@tonic-gate 			/* An NL7C socket, mark it */
7700Sstevel@tonic-gate 			so->so_nl7c_flags |= NL7C_ENABLED;
7710Sstevel@tonic-gate 		} else
7720Sstevel@tonic-gate 			nl7c = NULL;
7730Sstevel@tonic-gate 	}
7740Sstevel@tonic-gate 	/*
7750Sstevel@tonic-gate 	 * We send a T_BIND_REQ for TCP/UDP since we know it supports it,
7760Sstevel@tonic-gate 	 * for other transports we will send in a O_T_BIND_REQ.
7770Sstevel@tonic-gate 	 */
7780Sstevel@tonic-gate 	if (tcp_udp_xport &&
7790Sstevel@tonic-gate 	    (so->so_family == AF_INET || so->so_family == AF_INET6))
7800Sstevel@tonic-gate 		PRIM_type = T_BIND_REQ;
7810Sstevel@tonic-gate 
7820Sstevel@tonic-gate 	bind_req.PRIM_type = PRIM_type;
7830Sstevel@tonic-gate 	bind_req.ADDR_length = addrlen;
7840Sstevel@tonic-gate 	bind_req.ADDR_offset = (t_scalar_t)sizeof (bind_req);
7850Sstevel@tonic-gate 	bind_req.CONIND_number = backlog;
7860Sstevel@tonic-gate 	/* NOTE: holding so_lock while sleeping */
7870Sstevel@tonic-gate 	mp = soallocproto2(&bind_req, sizeof (bind_req),
7880Sstevel@tonic-gate 				addr, addrlen, 0, _ALLOC_SLEEP);
7890Sstevel@tonic-gate 	so->so_state &= ~SS_LADDR_VALID;
790898Skais 
7910Sstevel@tonic-gate 	/* Done using so_laddr_sa - can drop the lock */
7920Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
7930Sstevel@tonic-gate 
794898Skais 	/*
795898Skais 	 * Intercept the bind_req message here to check if this <address/port>
796898Skais 	 * was configured as an SSL proxy server, or if another endpoint was
797898Skais 	 * already configured to act as a proxy for us.
798898Skais 	 */
799898Skais 	if ((so->so_family == AF_INET || so->so_family == AF_INET6) &&
800898Skais 	    so->so_type == SOCK_STREAM) {
801898Skais 
802898Skais 		if (so->so_kssl_ent != NULL) {
803898Skais 			kssl_release_ent(so->so_kssl_ent, so, so->so_kssl_type);
804898Skais 			so->so_kssl_ent = NULL;
805898Skais 		}
806898Skais 
807898Skais 		so->so_kssl_type = kssl_check_proxy(mp, so, &so->so_kssl_ent);
808898Skais 		switch (so->so_kssl_type) {
809898Skais 		case KSSL_NO_PROXY:
810898Skais 			break;
811898Skais 
812898Skais 		case KSSL_HAS_PROXY:
813898Skais 			mutex_enter(&so->so_lock);
814898Skais 			goto skip_transport;
815898Skais 
816898Skais 		case KSSL_IS_PROXY:
817898Skais 			break;
818898Skais 		}
819898Skais 	}
820898Skais 
8210Sstevel@tonic-gate 	error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
8220Sstevel@tonic-gate 			MSG_BAND|MSG_HOLDSIG|MSG_IGNERROR, 0);
8230Sstevel@tonic-gate 	if (error) {
8240Sstevel@tonic-gate 		eprintsoline(so, error);
8250Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
8260Sstevel@tonic-gate 		goto done;
8270Sstevel@tonic-gate 	}
8280Sstevel@tonic-gate 
8290Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
8300Sstevel@tonic-gate 	error = sowaitprim(so, PRIM_type, T_BIND_ACK,
8310Sstevel@tonic-gate 	    (t_uscalar_t)sizeof (*bind_ack), &mp, 0);
8320Sstevel@tonic-gate 	if (error) {
8330Sstevel@tonic-gate 		eprintsoline(so, error);
8340Sstevel@tonic-gate 		goto done;
8350Sstevel@tonic-gate 	}
836898Skais skip_transport:
8370Sstevel@tonic-gate 	ASSERT(mp);
8380Sstevel@tonic-gate 	/*
8390Sstevel@tonic-gate 	 * Even if some TPI message (e.g. T_DISCON_IND) was received in
8400Sstevel@tonic-gate 	 * strsock_proto while the lock was dropped above, the bind
8410Sstevel@tonic-gate 	 * is allowed to complete.
8420Sstevel@tonic-gate 	 */
8430Sstevel@tonic-gate 
8440Sstevel@tonic-gate 	/* Mark as bound. This will be undone if we detect errors below. */
8450Sstevel@tonic-gate 	if (flags & _SOBIND_NOXLATE) {
8460Sstevel@tonic-gate 		ASSERT(so->so_family == AF_UNIX);
8470Sstevel@tonic-gate 		so->so_state |= SS_FADDR_NOXLATE;
8480Sstevel@tonic-gate 	}
8490Sstevel@tonic-gate 	ASSERT(!(so->so_state & SS_ISBOUND) || (flags & _SOBIND_REBIND));
8500Sstevel@tonic-gate 	so->so_state |= SS_ISBOUND;
8510Sstevel@tonic-gate 	ASSERT(so->so_unbind_mp);
8520Sstevel@tonic-gate 
8530Sstevel@tonic-gate 	/* note that we've already set SS_ACCEPTCONN above */
8540Sstevel@tonic-gate 
8550Sstevel@tonic-gate 	/*
8560Sstevel@tonic-gate 	 * Recompute addrlen - an unspecied bind sent down an
8570Sstevel@tonic-gate 	 * address of length zero but we expect the appropriate length
8580Sstevel@tonic-gate 	 * in return.
8590Sstevel@tonic-gate 	 */
8600Sstevel@tonic-gate 	addrlen = (t_uscalar_t)(so->so_family == AF_UNIX ?
8610Sstevel@tonic-gate 	    sizeof (so->so_ux_laddr) : so->so_laddr_len);
8620Sstevel@tonic-gate 
8630Sstevel@tonic-gate 	bind_ack = (struct T_bind_ack *)mp->b_rptr;
8640Sstevel@tonic-gate 	/*
8650Sstevel@tonic-gate 	 * The alignment restriction is really too strict but
8660Sstevel@tonic-gate 	 * we want enough alignment to inspect the fields of
8670Sstevel@tonic-gate 	 * a sockaddr_in.
8680Sstevel@tonic-gate 	 */
8690Sstevel@tonic-gate 	addr = sogetoff(mp, bind_ack->ADDR_offset,
8700Sstevel@tonic-gate 			bind_ack->ADDR_length,
8710Sstevel@tonic-gate 			__TPI_ALIGN_SIZE);
8720Sstevel@tonic-gate 	if (addr == NULL) {
8730Sstevel@tonic-gate 		freemsg(mp);
8740Sstevel@tonic-gate 		error = EPROTO;
8750Sstevel@tonic-gate 		eprintsoline(so, error);
8760Sstevel@tonic-gate 		goto done;
8770Sstevel@tonic-gate 	}
8780Sstevel@tonic-gate 	if (!(flags & _SOBIND_UNSPEC)) {
8790Sstevel@tonic-gate 		/*
8800Sstevel@tonic-gate 		 * Verify that the transport didn't return something we
8810Sstevel@tonic-gate 		 * did not want e.g. an address other than what we asked for.
8820Sstevel@tonic-gate 		 *
8830Sstevel@tonic-gate 		 * NOTE: These checks would go away if/when we switch to
8840Sstevel@tonic-gate 		 * using the new TPI (in which the transport would fail
8850Sstevel@tonic-gate 		 * the request instead of assigning a different address).
8860Sstevel@tonic-gate 		 *
8870Sstevel@tonic-gate 		 * NOTE2: For protocols that we don't know (i.e. any
8880Sstevel@tonic-gate 		 * other than AF_INET6, AF_INET and AF_UNIX), we
8890Sstevel@tonic-gate 		 * cannot know if the transport should be expected to
8900Sstevel@tonic-gate 		 * return the same address as that requested.
8910Sstevel@tonic-gate 		 *
8920Sstevel@tonic-gate 		 * NOTE3: For AF_INET and AF_INET6, TCP/UDP, we send
8930Sstevel@tonic-gate 		 * down a T_BIND_REQ. We use O_T_BIND_REQ for others.
8940Sstevel@tonic-gate 		 *
8950Sstevel@tonic-gate 		 * For example, in the case of netatalk it may be
8960Sstevel@tonic-gate 		 * inappropriate for the transport to return the
8970Sstevel@tonic-gate 		 * requested address (as it may have allocated a local
8980Sstevel@tonic-gate 		 * port number in behaviour similar to that of an
8990Sstevel@tonic-gate 		 * AF_INET bind request with a port number of zero).
9000Sstevel@tonic-gate 		 *
9010Sstevel@tonic-gate 		 * Given the definition of O_T_BIND_REQ, where the
9020Sstevel@tonic-gate 		 * transport may bind to an address other than the
9030Sstevel@tonic-gate 		 * requested address, it's not possible to determine
9040Sstevel@tonic-gate 		 * whether a returned address that differs from the
9050Sstevel@tonic-gate 		 * requested address is a reason to fail (because the
9060Sstevel@tonic-gate 		 * requested address was not available) or succeed
9070Sstevel@tonic-gate 		 * (because the transport allocated an appropriate
9080Sstevel@tonic-gate 		 * address and/or port).
9090Sstevel@tonic-gate 		 *
9100Sstevel@tonic-gate 		 * sockfs currently requires that the transport return
9110Sstevel@tonic-gate 		 * the requested address in the T_BIND_ACK, unless
9120Sstevel@tonic-gate 		 * there is code here to allow for any discrepancy.
9130Sstevel@tonic-gate 		 * Such code exists for AF_INET and AF_INET6.
9140Sstevel@tonic-gate 		 *
9150Sstevel@tonic-gate 		 * Netatalk chooses to return the requested address
9160Sstevel@tonic-gate 		 * rather than the (correct) allocated address.  This
9170Sstevel@tonic-gate 		 * means that netatalk violates the TPI specification
9180Sstevel@tonic-gate 		 * (and would not function correctly if used from a
9190Sstevel@tonic-gate 		 * TLI application), but it does mean that it works
9200Sstevel@tonic-gate 		 * with sockfs.
9210Sstevel@tonic-gate 		 *
9220Sstevel@tonic-gate 		 * As noted above, using the newer XTI bind primitive
9230Sstevel@tonic-gate 		 * (T_BIND_REQ) in preference to O_T_BIND_REQ would
9240Sstevel@tonic-gate 		 * allow sockfs to be more sure about whether or not
9250Sstevel@tonic-gate 		 * the bind request had succeeded (as transports are
9260Sstevel@tonic-gate 		 * not permitted to bind to a different address than
9270Sstevel@tonic-gate 		 * that requested - they must return failure).
9280Sstevel@tonic-gate 		 * Unfortunately, support for T_BIND_REQ may not be
9290Sstevel@tonic-gate 		 * present in all transport implementations (netatalk,
9300Sstevel@tonic-gate 		 * for example, doesn't have it), making the
9310Sstevel@tonic-gate 		 * transition difficult.
9320Sstevel@tonic-gate 		 */
9330Sstevel@tonic-gate 		if (bind_ack->ADDR_length != addrlen) {
9340Sstevel@tonic-gate 			/* Assumes that the requested address was in use */
9350Sstevel@tonic-gate 			freemsg(mp);
9360Sstevel@tonic-gate 			error = EADDRINUSE;
9370Sstevel@tonic-gate 			eprintsoline(so, error);
9380Sstevel@tonic-gate 			goto done;
9390Sstevel@tonic-gate 		}
9400Sstevel@tonic-gate 
9410Sstevel@tonic-gate 		switch (so->so_family) {
9420Sstevel@tonic-gate 		case AF_INET6:
9430Sstevel@tonic-gate 		case AF_INET: {
9440Sstevel@tonic-gate 			sin_t *rname, *aname;
9450Sstevel@tonic-gate 
9460Sstevel@tonic-gate 			rname = (sin_t *)addr;
9470Sstevel@tonic-gate 			aname = (sin_t *)so->so_laddr_sa;
9480Sstevel@tonic-gate 
9490Sstevel@tonic-gate 			/*
9500Sstevel@tonic-gate 			 * Take advantage of the alignment
9510Sstevel@tonic-gate 			 * of sin_port and sin6_port which fall
9520Sstevel@tonic-gate 			 * in the same place in their data structures.
9530Sstevel@tonic-gate 			 * Just use sin_port for either address family.
9540Sstevel@tonic-gate 			 *
9550Sstevel@tonic-gate 			 * This may become a problem if (heaven forbid)
9560Sstevel@tonic-gate 			 * there's a separate ipv6port_reserved... :-P
9570Sstevel@tonic-gate 			 *
9580Sstevel@tonic-gate 			 * Binding to port 0 has the semantics of letting
9590Sstevel@tonic-gate 			 * the transport bind to any port.
9600Sstevel@tonic-gate 			 *
9610Sstevel@tonic-gate 			 * If the transport is TCP or UDP since we had sent
9620Sstevel@tonic-gate 			 * a T_BIND_REQ we would not get a port other than
9630Sstevel@tonic-gate 			 * what we asked for.
9640Sstevel@tonic-gate 			 */
9650Sstevel@tonic-gate 			if (tcp_udp_xport) {
9660Sstevel@tonic-gate 				/*
9670Sstevel@tonic-gate 				 * Pick up the new port number if we bound to
9680Sstevel@tonic-gate 				 * port 0.
9690Sstevel@tonic-gate 				 */
9700Sstevel@tonic-gate 				if (aname->sin_port == 0)
9710Sstevel@tonic-gate 					aname->sin_port = rname->sin_port;
9720Sstevel@tonic-gate 				so->so_state |= SS_LADDR_VALID;
9730Sstevel@tonic-gate 				break;
9740Sstevel@tonic-gate 			}
9750Sstevel@tonic-gate 			if (aname->sin_port != 0 &&
9760Sstevel@tonic-gate 			    aname->sin_port != rname->sin_port) {
9770Sstevel@tonic-gate 				freemsg(mp);
9780Sstevel@tonic-gate 				error = EADDRINUSE;
9790Sstevel@tonic-gate 				eprintsoline(so, error);
9800Sstevel@tonic-gate 				goto done;
9810Sstevel@tonic-gate 			}
9820Sstevel@tonic-gate 			/*
9830Sstevel@tonic-gate 			 * Pick up the new port number if we bound to port 0.
9840Sstevel@tonic-gate 			 */
9850Sstevel@tonic-gate 			aname->sin_port = rname->sin_port;
9860Sstevel@tonic-gate 
9870Sstevel@tonic-gate 			/*
9880Sstevel@tonic-gate 			 * Unfortunately, addresses aren't _quite_ the same.
9890Sstevel@tonic-gate 			 */
9900Sstevel@tonic-gate 			if (so->so_family == AF_INET) {
9910Sstevel@tonic-gate 				if (aname->sin_addr.s_addr !=
9920Sstevel@tonic-gate 				    rname->sin_addr.s_addr) {
9930Sstevel@tonic-gate 					freemsg(mp);
9940Sstevel@tonic-gate 					error = EADDRNOTAVAIL;
9950Sstevel@tonic-gate 					eprintsoline(so, error);
9960Sstevel@tonic-gate 					goto done;
9970Sstevel@tonic-gate 				}
9980Sstevel@tonic-gate 			} else {
9990Sstevel@tonic-gate 				sin6_t *rname6 = (sin6_t *)rname;
10000Sstevel@tonic-gate 				sin6_t *aname6 = (sin6_t *)aname;
10010Sstevel@tonic-gate 
10020Sstevel@tonic-gate 				if (!IN6_ARE_ADDR_EQUAL(&aname6->sin6_addr,
10030Sstevel@tonic-gate 				    &rname6->sin6_addr)) {
10040Sstevel@tonic-gate 					freemsg(mp);
10050Sstevel@tonic-gate 					error = EADDRNOTAVAIL;
10060Sstevel@tonic-gate 					eprintsoline(so, error);
10070Sstevel@tonic-gate 					goto done;
10080Sstevel@tonic-gate 				}
10090Sstevel@tonic-gate 			}
10100Sstevel@tonic-gate 			break;
10110Sstevel@tonic-gate 		}
10120Sstevel@tonic-gate 		case AF_UNIX:
10130Sstevel@tonic-gate 			if (bcmp(addr, &so->so_ux_laddr, addrlen) != 0) {
10140Sstevel@tonic-gate 				freemsg(mp);
10150Sstevel@tonic-gate 				error = EADDRINUSE;
10160Sstevel@tonic-gate 				eprintsoline(so, error);
10170Sstevel@tonic-gate 				eprintso(so,
10180Sstevel@tonic-gate 					("addrlen %d, addr 0x%x, vp %p\n",
10190Sstevel@tonic-gate 					addrlen, *((int *)addr),
10200Sstevel@tonic-gate 					so->so_ux_bound_vp));
10210Sstevel@tonic-gate 				goto done;
10220Sstevel@tonic-gate 			}
10230Sstevel@tonic-gate 			so->so_state |= SS_LADDR_VALID;
10240Sstevel@tonic-gate 			break;
10250Sstevel@tonic-gate 		default:
10260Sstevel@tonic-gate 			/*
10270Sstevel@tonic-gate 			 * NOTE: This assumes that addresses can be
10280Sstevel@tonic-gate 			 * byte-compared for equivalence.
10290Sstevel@tonic-gate 			 */
10300Sstevel@tonic-gate 			if (bcmp(addr, so->so_laddr_sa, addrlen) != 0) {
10310Sstevel@tonic-gate 				freemsg(mp);
10320Sstevel@tonic-gate 				error = EADDRINUSE;
10330Sstevel@tonic-gate 				eprintsoline(so, error);
10340Sstevel@tonic-gate 				goto done;
10350Sstevel@tonic-gate 			}
10360Sstevel@tonic-gate 			/*
10370Sstevel@tonic-gate 			 * Don't mark SS_LADDR_VALID, as we cannot be
10380Sstevel@tonic-gate 			 * sure that the returned address is the real
10390Sstevel@tonic-gate 			 * bound address when talking to an unknown
10400Sstevel@tonic-gate 			 * transport.
10410Sstevel@tonic-gate 			 */
10420Sstevel@tonic-gate 			break;
10430Sstevel@tonic-gate 		}
10440Sstevel@tonic-gate 	} else {
10450Sstevel@tonic-gate 		/*
10460Sstevel@tonic-gate 		 * Save for returned address for getsockname.
10470Sstevel@tonic-gate 		 * Needed for unspecific bind unless transport supports
10480Sstevel@tonic-gate 		 * the TI_GETMYNAME ioctl.
10490Sstevel@tonic-gate 		 * Do this for AF_INET{,6} even though they do, as
10500Sstevel@tonic-gate 		 * caching info here is much better performance than
10510Sstevel@tonic-gate 		 * a TPI/STREAMS trip to the transport for getsockname.
10520Sstevel@tonic-gate 		 * Any which can't for some reason _must_ _not_ set
10530Sstevel@tonic-gate 		 * LADDR_VALID here for the caching version of getsockname
10540Sstevel@tonic-gate 		 * to not break;
10550Sstevel@tonic-gate 		 */
10560Sstevel@tonic-gate 		switch (so->so_family) {
10570Sstevel@tonic-gate 		case AF_UNIX:
10580Sstevel@tonic-gate 			/*
10590Sstevel@tonic-gate 			 * Record the address bound with the transport
10600Sstevel@tonic-gate 			 * for use by socketpair.
10610Sstevel@tonic-gate 			 */
10620Sstevel@tonic-gate 			bcopy(addr, &so->so_ux_laddr, addrlen);
10630Sstevel@tonic-gate 			so->so_state |= SS_LADDR_VALID;
10640Sstevel@tonic-gate 			break;
10650Sstevel@tonic-gate 		case AF_INET:
10660Sstevel@tonic-gate 		case AF_INET6:
10670Sstevel@tonic-gate 			ASSERT(so->so_laddr_len <= so->so_laddr_maxlen);
10680Sstevel@tonic-gate 			bcopy(addr, so->so_laddr_sa, so->so_laddr_len);
10690Sstevel@tonic-gate 			so->so_state |= SS_LADDR_VALID;
10700Sstevel@tonic-gate 			break;
10710Sstevel@tonic-gate 		default:
10720Sstevel@tonic-gate 			/*
10730Sstevel@tonic-gate 			 * Don't mark SS_LADDR_VALID, as we cannot be
10740Sstevel@tonic-gate 			 * sure that the returned address is the real
10750Sstevel@tonic-gate 			 * bound address when talking to an unknown
10760Sstevel@tonic-gate 			 * transport.
10770Sstevel@tonic-gate 			 */
10780Sstevel@tonic-gate 			break;
10790Sstevel@tonic-gate 		}
10800Sstevel@tonic-gate 	}
10810Sstevel@tonic-gate 
10820Sstevel@tonic-gate 	if (nl7c == NULL && (so->so_nl7c_flags & NL7C_AF_NCA) &&
10830Sstevel@tonic-gate 	    (so->so_nl7c_flags & NL7C_ENABLED)) {
10840Sstevel@tonic-gate 		/*
10850Sstevel@tonic-gate 		 * Was an AF_NCA bind() so add it to the addr list for
10860Sstevel@tonic-gate 		 * reporting purposes.
10870Sstevel@tonic-gate 		 */
10880Sstevel@tonic-gate 		nl7c = nl7c_add_addr(addr, addrlen);
10890Sstevel@tonic-gate 	}
10900Sstevel@tonic-gate 	if (nl7c != NULL) {
10910Sstevel@tonic-gate 		nl7c_listener_addr(nl7c, strvp2wq(SOTOV(so)));
10920Sstevel@tonic-gate 	}
10930Sstevel@tonic-gate 
10940Sstevel@tonic-gate 	freemsg(mp);
10950Sstevel@tonic-gate 
10960Sstevel@tonic-gate done:
10970Sstevel@tonic-gate 	if (error) {
10980Sstevel@tonic-gate 		/* reset state & backlog to values held on entry */
10990Sstevel@tonic-gate 		if (clear_acceptconn_on_err == B_TRUE)
11000Sstevel@tonic-gate 			so->so_state &= ~SS_ACCEPTCONN;
11010Sstevel@tonic-gate 		if (restore_backlog_on_err == B_TRUE)
11020Sstevel@tonic-gate 			so->so_backlog = save_so_backlog;
11030Sstevel@tonic-gate 
11040Sstevel@tonic-gate 		if (unbind_on_err && so->so_state & SS_ISBOUND) {
11050Sstevel@tonic-gate 			int err;
11060Sstevel@tonic-gate 
11070Sstevel@tonic-gate 			err = sotpi_unbind(so, 0);
11080Sstevel@tonic-gate 			/* LINTED - statement has no consequent: if */
11090Sstevel@tonic-gate 			if (err) {
11100Sstevel@tonic-gate 				eprintsoline(so, error);
11110Sstevel@tonic-gate 			} else {
11120Sstevel@tonic-gate 				ASSERT(!(so->so_state & SS_ISBOUND));
11130Sstevel@tonic-gate 			}
11140Sstevel@tonic-gate 		}
11150Sstevel@tonic-gate 	}
11160Sstevel@tonic-gate 	if (!(flags & _SOBIND_LOCK_HELD)) {
11170Sstevel@tonic-gate 		so_unlock_single(so, SOLOCKED);
11180Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
11190Sstevel@tonic-gate 	} else {
11200Sstevel@tonic-gate 		/* If the caller held the lock don't release it here */
11210Sstevel@tonic-gate 		ASSERT(MUTEX_HELD(&so->so_lock));
11220Sstevel@tonic-gate 		ASSERT(so->so_flag & SOLOCKED);
11230Sstevel@tonic-gate 	}
11240Sstevel@tonic-gate 	return (error);
11250Sstevel@tonic-gate }
11260Sstevel@tonic-gate 
11270Sstevel@tonic-gate /* bind the socket */
1128741Smasputra static int
11290Sstevel@tonic-gate sotpi_bind(struct sonode *so, struct sockaddr *name, socklen_t namelen,
11300Sstevel@tonic-gate     int flags)
11310Sstevel@tonic-gate {
11320Sstevel@tonic-gate 	if ((flags & _SOBIND_SOCKETPAIR) == 0)
11330Sstevel@tonic-gate 		return (sotpi_bindlisten(so, name, namelen, 0, flags));
11340Sstevel@tonic-gate 
11350Sstevel@tonic-gate 	flags &= ~_SOBIND_SOCKETPAIR;
11360Sstevel@tonic-gate 	return (sotpi_bindlisten(so, name, namelen, 1, flags));
11370Sstevel@tonic-gate }
11380Sstevel@tonic-gate 
11390Sstevel@tonic-gate /*
11400Sstevel@tonic-gate  * Unbind a socket - used when bind() fails, when bind() specifies a NULL
11410Sstevel@tonic-gate  * address, or when listen needs to unbind and bind.
11420Sstevel@tonic-gate  * If the _SOUNBIND_REBIND flag is specified the addresses are retained
11430Sstevel@tonic-gate  * so that a sobind can pick them up.
11440Sstevel@tonic-gate  */
11450Sstevel@tonic-gate static int
11460Sstevel@tonic-gate sotpi_unbind(struct sonode *so, int flags)
11470Sstevel@tonic-gate {
11480Sstevel@tonic-gate 	struct T_unbind_req	unbind_req;
11490Sstevel@tonic-gate 	int			error = 0;
11500Sstevel@tonic-gate 	mblk_t			*mp;
11510Sstevel@tonic-gate 
11520Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_unbind(%p, 0x%x) %s\n",
11530Sstevel@tonic-gate 			so, flags, pr_state(so->so_state, so->so_mode)));
11540Sstevel@tonic-gate 
11550Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
11560Sstevel@tonic-gate 	ASSERT(so->so_flag & SOLOCKED);
11570Sstevel@tonic-gate 
11580Sstevel@tonic-gate 	if (!(so->so_state & SS_ISBOUND)) {
11590Sstevel@tonic-gate 		error = EINVAL;
11600Sstevel@tonic-gate 		eprintsoline(so, error);
11610Sstevel@tonic-gate 		goto done;
11620Sstevel@tonic-gate 	}
11630Sstevel@tonic-gate 
11640Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
11650Sstevel@tonic-gate 
11660Sstevel@tonic-gate 	/*
11670Sstevel@tonic-gate 	 * Flush the read and write side (except stream head read queue)
11680Sstevel@tonic-gate 	 * and send down T_UNBIND_REQ.
11690Sstevel@tonic-gate 	 */
11700Sstevel@tonic-gate 	(void) putnextctl1(strvp2wq(SOTOV(so)), M_FLUSH, FLUSHRW);
11710Sstevel@tonic-gate 
11720Sstevel@tonic-gate 	unbind_req.PRIM_type = T_UNBIND_REQ;
11730Sstevel@tonic-gate 	mp = soallocproto1(&unbind_req, sizeof (unbind_req),
11740Sstevel@tonic-gate 	    0, _ALLOC_SLEEP);
11750Sstevel@tonic-gate 	error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
11760Sstevel@tonic-gate 			MSG_BAND|MSG_HOLDSIG|MSG_IGNERROR, 0);
11770Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
11780Sstevel@tonic-gate 	if (error) {
11790Sstevel@tonic-gate 		eprintsoline(so, error);
11800Sstevel@tonic-gate 		goto done;
11810Sstevel@tonic-gate 	}
11820Sstevel@tonic-gate 
11830Sstevel@tonic-gate 	error = sowaitokack(so, T_UNBIND_REQ);
11840Sstevel@tonic-gate 	if (error) {
11850Sstevel@tonic-gate 		eprintsoline(so, error);
11860Sstevel@tonic-gate 		goto done;
11870Sstevel@tonic-gate 	}
11880Sstevel@tonic-gate 
11890Sstevel@tonic-gate 	/*
11900Sstevel@tonic-gate 	 * Even if some TPI message (e.g. T_DISCON_IND) was received in
11910Sstevel@tonic-gate 	 * strsock_proto while the lock was dropped above, the unbind
11920Sstevel@tonic-gate 	 * is allowed to complete.
11930Sstevel@tonic-gate 	 */
11940Sstevel@tonic-gate 	if (!(flags & _SOUNBIND_REBIND)) {
11950Sstevel@tonic-gate 		/*
11960Sstevel@tonic-gate 		 * Clear out bound address.
11970Sstevel@tonic-gate 		 */
11980Sstevel@tonic-gate 		vnode_t *vp;
11990Sstevel@tonic-gate 
12000Sstevel@tonic-gate 		if ((vp = so->so_ux_bound_vp) != NULL) {
1201898Skais 
1202898Skais 			/* Undo any SSL proxy setup */
1203898Skais 			if ((so->so_family == AF_INET ||
1204898Skais 			    so->so_family == AF_INET6) &&
1205898Skais 			    (so->so_type == SOCK_STREAM) &&
1206898Skais 			    (so->so_kssl_ent != NULL)) {
1207898Skais 				kssl_release_ent(so->so_kssl_ent, so,
1208898Skais 				    so->so_kssl_type);
1209898Skais 				so->so_kssl_ent = NULL;
1210898Skais 				so->so_kssl_type = KSSL_NO_PROXY;
1211898Skais 			}
1212898Skais 
12130Sstevel@tonic-gate 			so->so_ux_bound_vp = NULL;
12140Sstevel@tonic-gate 			vn_rele_stream(vp);
12150Sstevel@tonic-gate 		}
12160Sstevel@tonic-gate 		/* Clear out address */
12170Sstevel@tonic-gate 		so->so_laddr_len = 0;
12180Sstevel@tonic-gate 	}
12190Sstevel@tonic-gate 	so->so_state &= ~(SS_ISBOUND|SS_ACCEPTCONN|SS_LADDR_VALID);
12200Sstevel@tonic-gate done:
1221898Skais 
12220Sstevel@tonic-gate 	/* If the caller held the lock don't release it here */
12230Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
12240Sstevel@tonic-gate 	ASSERT(so->so_flag & SOLOCKED);
12250Sstevel@tonic-gate 
12260Sstevel@tonic-gate 	return (error);
12270Sstevel@tonic-gate }
12280Sstevel@tonic-gate 
12290Sstevel@tonic-gate /*
12300Sstevel@tonic-gate  * listen on the socket.
12310Sstevel@tonic-gate  * For TPI conforming transports this has to first unbind with the transport
12320Sstevel@tonic-gate  * and then bind again using the new backlog.
12330Sstevel@tonic-gate  */
12340Sstevel@tonic-gate int
12350Sstevel@tonic-gate sotpi_listen(struct sonode *so, int backlog)
12360Sstevel@tonic-gate {
12370Sstevel@tonic-gate 	int		error = 0;
12380Sstevel@tonic-gate 
12390Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_listen(%p, %d) %s\n",
12400Sstevel@tonic-gate 		so, backlog, pr_state(so->so_state, so->so_mode)));
12410Sstevel@tonic-gate 
12420Sstevel@tonic-gate 	if (so->so_serv_type == T_CLTS)
12430Sstevel@tonic-gate 		return (EOPNOTSUPP);
12440Sstevel@tonic-gate 
12450Sstevel@tonic-gate 	/*
12460Sstevel@tonic-gate 	 * If the socket is ready to accept connections already, then
12470Sstevel@tonic-gate 	 * return without doing anything.  This avoids a problem where
12480Sstevel@tonic-gate 	 * a second listen() call fails if a connection is pending and
12490Sstevel@tonic-gate 	 * leaves the socket unbound. Only when we are not unbinding
12500Sstevel@tonic-gate 	 * with the transport can we safely increase the backlog.
12510Sstevel@tonic-gate 	 */
12520Sstevel@tonic-gate 	if (so->so_state & SS_ACCEPTCONN &&
12530Sstevel@tonic-gate 	    !((so->so_family == AF_INET || so->so_family == AF_INET6) &&
12540Sstevel@tonic-gate 		/*CONSTCOND*/
12550Sstevel@tonic-gate 		!solisten_tpi_tcp))
12560Sstevel@tonic-gate 		return (0);
12570Sstevel@tonic-gate 
12580Sstevel@tonic-gate 	if (so->so_state & SS_ISCONNECTED)
12590Sstevel@tonic-gate 		return (EINVAL);
12600Sstevel@tonic-gate 
12610Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
12620Sstevel@tonic-gate 	so_lock_single(so);	/* Set SOLOCKED */
12630Sstevel@tonic-gate 
12640Sstevel@tonic-gate 	if (backlog < 0)
12650Sstevel@tonic-gate 		backlog = 0;
12660Sstevel@tonic-gate 	/*
12670Sstevel@tonic-gate 	 * Use the same qlimit as in BSD. BSD checks the qlimit
12680Sstevel@tonic-gate 	 * before queuing the next connection implying that a
12690Sstevel@tonic-gate 	 * listen(sock, 0) allows one connection to be queued.
12700Sstevel@tonic-gate 	 * BSD also uses 1.5 times the requested backlog.
12710Sstevel@tonic-gate 	 *
12720Sstevel@tonic-gate 	 * XNS Issue 4 required a strict interpretation of the backlog.
12730Sstevel@tonic-gate 	 * This has been waived subsequently for Issue 4 and the change
12740Sstevel@tonic-gate 	 * incorporated in XNS Issue 5. So we aren't required to do
12750Sstevel@tonic-gate 	 * anything special for XPG apps.
12760Sstevel@tonic-gate 	 */
12770Sstevel@tonic-gate 	if (backlog >= (INT_MAX - 1) / 3)
12780Sstevel@tonic-gate 		backlog = INT_MAX;
12790Sstevel@tonic-gate 	else
12800Sstevel@tonic-gate 		backlog = backlog * 3 / 2 + 1;
12810Sstevel@tonic-gate 
12820Sstevel@tonic-gate 	/*
12830Sstevel@tonic-gate 	 * If the listen doesn't change the backlog we do nothing.
12840Sstevel@tonic-gate 	 * This avoids an EPROTO error from the transport.
12850Sstevel@tonic-gate 	 */
12860Sstevel@tonic-gate 	if ((so->so_state & SS_ACCEPTCONN) &&
12870Sstevel@tonic-gate 	    so->so_backlog == backlog)
12880Sstevel@tonic-gate 		goto done;
12890Sstevel@tonic-gate 
12900Sstevel@tonic-gate 	if (!(so->so_state & SS_ISBOUND)) {
12910Sstevel@tonic-gate 		/*
12920Sstevel@tonic-gate 		 * Must have been explicitly bound in the UNIX domain.
12930Sstevel@tonic-gate 		 */
12940Sstevel@tonic-gate 		if (so->so_family == AF_UNIX) {
12950Sstevel@tonic-gate 			error = EINVAL;
12960Sstevel@tonic-gate 			goto done;
12970Sstevel@tonic-gate 		}
12980Sstevel@tonic-gate 		error = sotpi_bindlisten(so, NULL, 0, backlog,
12990Sstevel@tonic-gate 			    _SOBIND_UNSPEC|_SOBIND_LOCK_HELD|_SOBIND_LISTEN);
13000Sstevel@tonic-gate 	} else if (backlog > 0) {
13010Sstevel@tonic-gate 		/*
13020Sstevel@tonic-gate 		 * AF_INET{,6} hack to avoid losing the port.
13030Sstevel@tonic-gate 		 * Assumes that all AF_INET{,6} transports can handle a
13040Sstevel@tonic-gate 		 * O_T_BIND_REQ with a non-zero CONIND_number when the TPI
13050Sstevel@tonic-gate 		 * has already bound thus it is possible to avoid the unbind.
13060Sstevel@tonic-gate 		 */
13070Sstevel@tonic-gate 		if (!((so->so_family == AF_INET || so->so_family == AF_INET6) &&
13080Sstevel@tonic-gate 		    /*CONSTCOND*/
13090Sstevel@tonic-gate 		    !solisten_tpi_tcp)) {
13100Sstevel@tonic-gate 			error = sotpi_unbind(so, _SOUNBIND_REBIND);
13110Sstevel@tonic-gate 			if (error)
13120Sstevel@tonic-gate 				goto done;
13130Sstevel@tonic-gate 		}
13140Sstevel@tonic-gate 		error = sotpi_bindlisten(so, NULL, 0, backlog,
13150Sstevel@tonic-gate 			    _SOBIND_REBIND|_SOBIND_LOCK_HELD|_SOBIND_LISTEN);
13160Sstevel@tonic-gate 	} else {
13170Sstevel@tonic-gate 		so->so_state |= SS_ACCEPTCONN;
13180Sstevel@tonic-gate 		so->so_backlog = backlog;
13190Sstevel@tonic-gate 	}
13200Sstevel@tonic-gate 	if (error)
13210Sstevel@tonic-gate 		goto done;
13220Sstevel@tonic-gate 	ASSERT(so->so_state & SS_ACCEPTCONN);
13230Sstevel@tonic-gate done:
13240Sstevel@tonic-gate 	so_unlock_single(so, SOLOCKED);
13250Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
13260Sstevel@tonic-gate 	return (error);
13270Sstevel@tonic-gate }
13280Sstevel@tonic-gate 
13290Sstevel@tonic-gate /*
13300Sstevel@tonic-gate  * Disconnect either a specified seqno or all (-1).
13310Sstevel@tonic-gate  * The former is used on listening sockets only.
13320Sstevel@tonic-gate  *
13330Sstevel@tonic-gate  * When seqno == -1 sodisconnect could call sotpi_unbind. However,
13340Sstevel@tonic-gate  * the current use of sodisconnect(seqno == -1) is only for shutdown
13350Sstevel@tonic-gate  * so there is no point (and potentially incorrect) to unbind.
13360Sstevel@tonic-gate  */
13370Sstevel@tonic-gate int
13380Sstevel@tonic-gate sodisconnect(struct sonode *so, t_scalar_t seqno, int flags)
13390Sstevel@tonic-gate {
13400Sstevel@tonic-gate 	struct T_discon_req	discon_req;
13410Sstevel@tonic-gate 	int			error = 0;
13420Sstevel@tonic-gate 	mblk_t			*mp;
13430Sstevel@tonic-gate 
13440Sstevel@tonic-gate 	dprintso(so, 1, ("sodisconnect(%p, %d, 0x%x) %s\n",
13450Sstevel@tonic-gate 			so, seqno, flags, pr_state(so->so_state, so->so_mode)));
13460Sstevel@tonic-gate 
13470Sstevel@tonic-gate 	if (!(flags & _SODISCONNECT_LOCK_HELD)) {
13480Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
13490Sstevel@tonic-gate 		so_lock_single(so);	/* Set SOLOCKED */
13500Sstevel@tonic-gate 	} else {
13510Sstevel@tonic-gate 		ASSERT(MUTEX_HELD(&so->so_lock));
13520Sstevel@tonic-gate 		ASSERT(so->so_flag & SOLOCKED);
13530Sstevel@tonic-gate 	}
13540Sstevel@tonic-gate 
13550Sstevel@tonic-gate 	if (!(so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING|SS_ACCEPTCONN))) {
13560Sstevel@tonic-gate 		error = EINVAL;
13570Sstevel@tonic-gate 		eprintsoline(so, error);
13580Sstevel@tonic-gate 		goto done;
13590Sstevel@tonic-gate 	}
13600Sstevel@tonic-gate 
13610Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
13620Sstevel@tonic-gate 	/*
13630Sstevel@tonic-gate 	 * Flush the write side (unless this is a listener)
13640Sstevel@tonic-gate 	 * and then send down a T_DISCON_REQ.
13650Sstevel@tonic-gate 	 * (Don't flush on listener since it could flush {O_}T_CONN_RES
13660Sstevel@tonic-gate 	 * and other messages.)
13670Sstevel@tonic-gate 	 */
13680Sstevel@tonic-gate 	if (!(so->so_state & SS_ACCEPTCONN))
13690Sstevel@tonic-gate 		(void) putnextctl1(strvp2wq(SOTOV(so)), M_FLUSH, FLUSHW);
13700Sstevel@tonic-gate 
13710Sstevel@tonic-gate 	discon_req.PRIM_type = T_DISCON_REQ;
13720Sstevel@tonic-gate 	discon_req.SEQ_number = seqno;
13730Sstevel@tonic-gate 	mp = soallocproto1(&discon_req, sizeof (discon_req),
13740Sstevel@tonic-gate 	    0, _ALLOC_SLEEP);
13750Sstevel@tonic-gate 	error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
13760Sstevel@tonic-gate 			MSG_BAND|MSG_HOLDSIG|MSG_IGNERROR, 0);
13770Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
13780Sstevel@tonic-gate 	if (error) {
13790Sstevel@tonic-gate 		eprintsoline(so, error);
13800Sstevel@tonic-gate 		goto done;
13810Sstevel@tonic-gate 	}
13820Sstevel@tonic-gate 
13830Sstevel@tonic-gate 	error = sowaitokack(so, T_DISCON_REQ);
13840Sstevel@tonic-gate 	if (error) {
13850Sstevel@tonic-gate 		eprintsoline(so, error);
13860Sstevel@tonic-gate 		goto done;
13870Sstevel@tonic-gate 	}
13880Sstevel@tonic-gate 	/*
13890Sstevel@tonic-gate 	 * Even if some TPI message (e.g. T_DISCON_IND) was received in
13900Sstevel@tonic-gate 	 * strsock_proto while the lock was dropped above, the disconnect
13910Sstevel@tonic-gate 	 * is allowed to complete. However, it is not possible to
13920Sstevel@tonic-gate 	 * assert that SS_ISCONNECTED|SS_ISCONNECTING are set.
13930Sstevel@tonic-gate 	 */
13940Sstevel@tonic-gate 	so->so_state &=
13950Sstevel@tonic-gate 	    ~(SS_ISCONNECTED|SS_ISCONNECTING|SS_LADDR_VALID|SS_FADDR_VALID);
13960Sstevel@tonic-gate done:
13970Sstevel@tonic-gate 	if (!(flags & _SODISCONNECT_LOCK_HELD)) {
13980Sstevel@tonic-gate 		so_unlock_single(so, SOLOCKED);
13990Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
14000Sstevel@tonic-gate 	} else {
14010Sstevel@tonic-gate 		/* If the caller held the lock don't release it here */
14020Sstevel@tonic-gate 		ASSERT(MUTEX_HELD(&so->so_lock));
14030Sstevel@tonic-gate 		ASSERT(so->so_flag & SOLOCKED);
14040Sstevel@tonic-gate 	}
14050Sstevel@tonic-gate 	return (error);
14060Sstevel@tonic-gate }
14070Sstevel@tonic-gate 
14080Sstevel@tonic-gate int
14090Sstevel@tonic-gate sotpi_accept(struct sonode *so, int fflag, struct sonode **nsop)
14100Sstevel@tonic-gate {
14110Sstevel@tonic-gate 	struct T_conn_ind	*conn_ind;
14120Sstevel@tonic-gate 	struct T_conn_res	*conn_res;
14130Sstevel@tonic-gate 	int			error = 0;
1414898Skais 	mblk_t			*mp, *ctxmp;
14150Sstevel@tonic-gate 	struct sonode		*nso;
14160Sstevel@tonic-gate 	vnode_t			*nvp;
14170Sstevel@tonic-gate 	void			*src;
14180Sstevel@tonic-gate 	t_uscalar_t		srclen;
14190Sstevel@tonic-gate 	void			*opt;
14200Sstevel@tonic-gate 	t_uscalar_t		optlen;
14210Sstevel@tonic-gate 	t_scalar_t		PRIM_type;
14220Sstevel@tonic-gate 	t_scalar_t		SEQ_number;
14230Sstevel@tonic-gate 
14240Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_accept(%p, 0x%x, %p) %s\n",
14250Sstevel@tonic-gate 		so, fflag, nsop, pr_state(so->so_state, so->so_mode)));
14260Sstevel@tonic-gate 
14270Sstevel@tonic-gate 	/*
14280Sstevel@tonic-gate 	 * Defer single-threading the accepting socket until
14290Sstevel@tonic-gate 	 * the T_CONN_IND has been received and parsed and the
14300Sstevel@tonic-gate 	 * new sonode has been opened.
14310Sstevel@tonic-gate 	 */
14320Sstevel@tonic-gate 
14330Sstevel@tonic-gate 	/* Check that we are not already connected */
14340Sstevel@tonic-gate 	if ((so->so_state & SS_ACCEPTCONN) == 0)
14350Sstevel@tonic-gate 		goto conn_bad;
14360Sstevel@tonic-gate again:
14370Sstevel@tonic-gate 	if ((error = sowaitconnind(so, fflag, &mp)) != 0)
14380Sstevel@tonic-gate 		goto e_bad;
14390Sstevel@tonic-gate 
14400Sstevel@tonic-gate 	ASSERT(mp);
14410Sstevel@tonic-gate 	conn_ind = (struct T_conn_ind *)mp->b_rptr;
1442898Skais 	ctxmp = mp->b_cont;
1443898Skais 
14440Sstevel@tonic-gate 	/*
14450Sstevel@tonic-gate 	 * Save SEQ_number for error paths.
14460Sstevel@tonic-gate 	 */
14470Sstevel@tonic-gate 	SEQ_number = conn_ind->SEQ_number;
14480Sstevel@tonic-gate 
14490Sstevel@tonic-gate 	srclen = conn_ind->SRC_length;
14500Sstevel@tonic-gate 	src = sogetoff(mp, conn_ind->SRC_offset, srclen, 1);
14510Sstevel@tonic-gate 	if (src == NULL) {
14520Sstevel@tonic-gate 		error = EPROTO;
14530Sstevel@tonic-gate 		freemsg(mp);
14540Sstevel@tonic-gate 		eprintsoline(so, error);
14550Sstevel@tonic-gate 		goto disconnect_unlocked;
14560Sstevel@tonic-gate 	}
14570Sstevel@tonic-gate 	optlen = conn_ind->OPT_length;
14580Sstevel@tonic-gate 	switch (so->so_family) {
14590Sstevel@tonic-gate 	case AF_INET:
14600Sstevel@tonic-gate 	case AF_INET6:
14610Sstevel@tonic-gate 		if ((optlen == sizeof (intptr_t)) &&
1462741Smasputra 		    ((so->so_state & SS_DIRECT) != 0)) {
14630Sstevel@tonic-gate 			bcopy(mp->b_rptr + conn_ind->OPT_offset,
14640Sstevel@tonic-gate 			    &opt, conn_ind->OPT_length);
14650Sstevel@tonic-gate 		} else {
14660Sstevel@tonic-gate 			/*
14670Sstevel@tonic-gate 			 * The transport (in this case TCP) hasn't sent up
14680Sstevel@tonic-gate 			 * a pointer to an instance for the accept fast-path.
14690Sstevel@tonic-gate 			 * Disable fast-path completely because the call to
14700Sstevel@tonic-gate 			 * sotpi_create() below would otherwise create an
14710Sstevel@tonic-gate 			 * incomplete TCP instance, which would lead to
14720Sstevel@tonic-gate 			 * problems when sockfs sends a normal T_CONN_RES
14730Sstevel@tonic-gate 			 * message down the new stream.
14740Sstevel@tonic-gate 			 */
1475741Smasputra 			if (so->so_state & SS_DIRECT) {
1476741Smasputra 				int rval;
1477741Smasputra 				/*
1478741Smasputra 				 * For consistency we inform tcp to disable
1479741Smasputra 				 * direct interface on the listener, though
1480741Smasputra 				 * we can certainly live without doing this
1481741Smasputra 				 * because no data will ever travel upstream
1482741Smasputra 				 * on the listening socket.
1483741Smasputra 				 */
1484741Smasputra 				so->so_state &= ~SS_DIRECT;
1485741Smasputra 				(void) strioctl(SOTOV(so), _SIOCSOCKFALLBACK,
1486741Smasputra 				    0, 0, K_TO_K, CRED(), &rval);
1487741Smasputra 			}
14880Sstevel@tonic-gate 			opt = NULL;
14890Sstevel@tonic-gate 			optlen = 0;
14900Sstevel@tonic-gate 		}
14910Sstevel@tonic-gate 		break;
14920Sstevel@tonic-gate 	case AF_UNIX:
14930Sstevel@tonic-gate 	default:
14940Sstevel@tonic-gate 		if (optlen != 0) {
14950Sstevel@tonic-gate 			opt = sogetoff(mp, conn_ind->OPT_offset, optlen,
14960Sstevel@tonic-gate 			    __TPI_ALIGN_SIZE);
14970Sstevel@tonic-gate 			if (opt == NULL) {
14980Sstevel@tonic-gate 				error = EPROTO;
14990Sstevel@tonic-gate 				freemsg(mp);
15000Sstevel@tonic-gate 				eprintsoline(so, error);
15010Sstevel@tonic-gate 				goto disconnect_unlocked;
15020Sstevel@tonic-gate 			}
15030Sstevel@tonic-gate 		}
15040Sstevel@tonic-gate 		if (so->so_family == AF_UNIX) {
15050Sstevel@tonic-gate 			if (!(so->so_state & SS_FADDR_NOXLATE)) {
15060Sstevel@tonic-gate 				src = NULL;
15070Sstevel@tonic-gate 				srclen = 0;
15080Sstevel@tonic-gate 			}
15090Sstevel@tonic-gate 			/* Extract src address from options */
15100Sstevel@tonic-gate 			if (optlen != 0)
15110Sstevel@tonic-gate 				so_getopt_srcaddr(opt, optlen, &src, &srclen);
15120Sstevel@tonic-gate 		}
15130Sstevel@tonic-gate 		break;
15140Sstevel@tonic-gate 	}
15150Sstevel@tonic-gate 
15160Sstevel@tonic-gate 	/*
15170Sstevel@tonic-gate 	 * Create the new socket.
15180Sstevel@tonic-gate 	 */
15190Sstevel@tonic-gate 	VN_HOLD(so->so_accessvp);
15200Sstevel@tonic-gate 	nso = sotpi_create(so->so_accessvp, so->so_family, so->so_type,
15210Sstevel@tonic-gate 			so->so_protocol, so->so_version, so, &error);
15220Sstevel@tonic-gate 	if (nso == NULL) {
15230Sstevel@tonic-gate 		ASSERT(error != 0);
15240Sstevel@tonic-gate 		/*
15250Sstevel@tonic-gate 		 * Accept can not fail with ENOBUFS. sotpi_create
15260Sstevel@tonic-gate 		 * sleeps waiting for memory until a signal is caught
15270Sstevel@tonic-gate 		 * so return EINTR.
15280Sstevel@tonic-gate 		 */
15290Sstevel@tonic-gate 		freemsg(mp);
15300Sstevel@tonic-gate 		if (error == ENOBUFS)
15310Sstevel@tonic-gate 			error = EINTR;
15320Sstevel@tonic-gate 		goto e_disc_unl;
15330Sstevel@tonic-gate 	}
15340Sstevel@tonic-gate 	nvp = SOTOV(nso);
15350Sstevel@tonic-gate 
1536898Skais 	/*
1537898Skais 	 * If the transport sent up an SSL connection context, then attach
1538898Skais 	 * it the new socket, and set the (sd_wputdatafunc)() and
1539898Skais 	 * (sd_rputdatafunc)() stream head hooks to intercept and process
1540898Skais 	 * SSL records.
1541898Skais 	 */
1542898Skais 	if (ctxmp != NULL) {
1543898Skais 		/*
1544898Skais 		 * This kssl_ctx_t is already held for us by the transport.
1545898Skais 		 * So, we don't need to do a kssl_hold_ctx() here.
1546898Skais 		 */
1547898Skais 		nso->so_kssl_ctx = *((kssl_ctx_t *)ctxmp->b_rptr);
1548898Skais 		freemsg(ctxmp);
1549898Skais 		mp->b_cont = NULL;
1550898Skais 		strsetrwputdatahooks(nvp, strsock_kssl_input,
1551898Skais 		    strsock_kssl_output);
1552898Skais 	}
15530Sstevel@tonic-gate #ifdef DEBUG
15540Sstevel@tonic-gate 	/*
15550Sstevel@tonic-gate 	 * SO_DEBUG is used to trigger the dprint* and eprint* macros thus
15560Sstevel@tonic-gate 	 * it's inherited early to allow debugging of the accept code itself.
15570Sstevel@tonic-gate 	 */
15580Sstevel@tonic-gate 	nso->so_options |= so->so_options & SO_DEBUG;
15590Sstevel@tonic-gate #endif /* DEBUG */
15600Sstevel@tonic-gate 
15610Sstevel@tonic-gate 	/*
15620Sstevel@tonic-gate 	 * Save the SRC address from the T_CONN_IND
15630Sstevel@tonic-gate 	 * for getpeername to work on AF_UNIX and on transports that do not
15640Sstevel@tonic-gate 	 * support TI_GETPEERNAME.
15650Sstevel@tonic-gate 	 *
15660Sstevel@tonic-gate 	 * NOTE: AF_UNIX NUL termination is ensured by the sender's
15670Sstevel@tonic-gate 	 * copyin_name().
15680Sstevel@tonic-gate 	 */
15690Sstevel@tonic-gate 	if (srclen > (t_uscalar_t)nso->so_faddr_maxlen) {
15700Sstevel@tonic-gate 		error = EINVAL;
15710Sstevel@tonic-gate 		freemsg(mp);
15720Sstevel@tonic-gate 		eprintsoline(so, error);
15730Sstevel@tonic-gate 		goto disconnect_vp_unlocked;
15740Sstevel@tonic-gate 	}
15750Sstevel@tonic-gate 	nso->so_faddr_len = (socklen_t)srclen;
15760Sstevel@tonic-gate 	ASSERT(so->so_faddr_len <= so->so_faddr_maxlen);
15770Sstevel@tonic-gate 	bcopy(src, nso->so_faddr_sa, srclen);
15780Sstevel@tonic-gate 	nso->so_state |= SS_FADDR_VALID;
15790Sstevel@tonic-gate 
15800Sstevel@tonic-gate 	if ((DB_REF(mp) > 1) || MBLKSIZE(mp) <
15810Sstevel@tonic-gate 	    (sizeof (struct T_conn_res) + sizeof (intptr_t))) {
15820Sstevel@tonic-gate 		cred_t *cr;
15830Sstevel@tonic-gate 
15840Sstevel@tonic-gate 		if ((cr = DB_CRED(mp)) != NULL) {
15850Sstevel@tonic-gate 			crhold(cr);
15860Sstevel@tonic-gate 			nso->so_peercred = cr;
15870Sstevel@tonic-gate 			nso->so_cpid = DB_CPID(mp);
15880Sstevel@tonic-gate 		}
15890Sstevel@tonic-gate 		freemsg(mp);
15900Sstevel@tonic-gate 
15910Sstevel@tonic-gate 		mp = soallocproto1(NULL, sizeof (struct T_conn_res) +
15920Sstevel@tonic-gate 		    sizeof (intptr_t), 0, _ALLOC_INTR);
15930Sstevel@tonic-gate 		if (mp == NULL) {
15940Sstevel@tonic-gate 			/*
15950Sstevel@tonic-gate 			 * Accept can not fail with ENOBUFS.
15960Sstevel@tonic-gate 			 * A signal was caught so return EINTR.
15970Sstevel@tonic-gate 			 */
15980Sstevel@tonic-gate 			error = EINTR;
15990Sstevel@tonic-gate 			eprintsoline(so, error);
16000Sstevel@tonic-gate 			goto disconnect_vp_unlocked;
16010Sstevel@tonic-gate 		}
16020Sstevel@tonic-gate 		conn_res = (struct T_conn_res *)mp->b_rptr;
16030Sstevel@tonic-gate 	} else {
16040Sstevel@tonic-gate 		nso->so_peercred = DB_CRED(mp);
16050Sstevel@tonic-gate 		nso->so_cpid = DB_CPID(mp);
16060Sstevel@tonic-gate 		DB_CRED(mp) = NULL;
16070Sstevel@tonic-gate 
16080Sstevel@tonic-gate 		mp->b_rptr = DB_BASE(mp);
16090Sstevel@tonic-gate 		conn_res = (struct T_conn_res *)mp->b_rptr;
16100Sstevel@tonic-gate 		mp->b_wptr = mp->b_rptr + sizeof (struct T_conn_res);
16110Sstevel@tonic-gate 	}
16120Sstevel@tonic-gate 
16130Sstevel@tonic-gate 	/*
16140Sstevel@tonic-gate 	 * New socket must be bound at least in sockfs and, except for AF_INET,
16150Sstevel@tonic-gate 	 * (or AF_INET6) it also has to be bound in the transport provider.
16160Sstevel@tonic-gate 	 * After accepting the connection on nso so_laddr_sa will be set to
16170Sstevel@tonic-gate 	 * contain the same address as the listener's local address
16180Sstevel@tonic-gate 	 * so the address we bind to isn't important.
16190Sstevel@tonic-gate 	 */
16200Sstevel@tonic-gate 	if ((nso->so_family == AF_INET || nso->so_family == AF_INET6) &&
16210Sstevel@tonic-gate 	    /*CONSTCOND*/
16220Sstevel@tonic-gate 	    nso->so_type == SOCK_STREAM && !soaccept_tpi_tcp) {
16230Sstevel@tonic-gate 		/*
16240Sstevel@tonic-gate 		 * Optimization for AF_INET{,6} transports
16250Sstevel@tonic-gate 		 * that can handle a T_CONN_RES without being bound.
16260Sstevel@tonic-gate 		 */
16270Sstevel@tonic-gate 		mutex_enter(&nso->so_lock);
16280Sstevel@tonic-gate 		so_automatic_bind(nso);
16290Sstevel@tonic-gate 		mutex_exit(&nso->so_lock);
16300Sstevel@tonic-gate 	} else {
16310Sstevel@tonic-gate 		/* Perform NULL bind with the transport provider. */
16320Sstevel@tonic-gate 		if ((error = sotpi_bind(nso, NULL, 0, _SOBIND_UNSPEC)) != 0) {
16330Sstevel@tonic-gate 			ASSERT(error != ENOBUFS);
16340Sstevel@tonic-gate 			freemsg(mp);
16350Sstevel@tonic-gate 			eprintsoline(nso, error);
16360Sstevel@tonic-gate 			goto disconnect_vp_unlocked;
16370Sstevel@tonic-gate 		}
16380Sstevel@tonic-gate 	}
16390Sstevel@tonic-gate 
16400Sstevel@tonic-gate 	/*
16410Sstevel@tonic-gate 	 * Inherit SIOCSPGRP, SS_ASYNC before we send the {O_}T_CONN_RES
16420Sstevel@tonic-gate 	 * so that any data arriving on the new socket will cause the
16430Sstevel@tonic-gate 	 * appropriate signals to be delivered for the new socket.
16440Sstevel@tonic-gate 	 *
16450Sstevel@tonic-gate 	 * No other thread (except strsock_proto and strsock_misc)
16460Sstevel@tonic-gate 	 * can access the new socket thus we relax the locking.
16470Sstevel@tonic-gate 	 */
16480Sstevel@tonic-gate 	nso->so_pgrp = so->so_pgrp;
16490Sstevel@tonic-gate 	nso->so_state |= so->so_state & (SS_ASYNC|SS_FADDR_NOXLATE);
16500Sstevel@tonic-gate 
16510Sstevel@tonic-gate 	if (nso->so_pgrp != 0) {
16520Sstevel@tonic-gate 		if ((error = so_set_events(nso, nvp, CRED())) != 0) {
16530Sstevel@tonic-gate 			eprintsoline(nso, error);
16540Sstevel@tonic-gate 			error = 0;
16550Sstevel@tonic-gate 			nso->so_pgrp = 0;
16560Sstevel@tonic-gate 		}
16570Sstevel@tonic-gate 	}
16580Sstevel@tonic-gate 
16590Sstevel@tonic-gate 	/*
16600Sstevel@tonic-gate 	 * Make note of the socket level options. TCP and IP level options
16610Sstevel@tonic-gate 	 * are already inherited. We could do all this after accept is
16620Sstevel@tonic-gate 	 * successful but doing it here simplifies code and no harm done
16630Sstevel@tonic-gate 	 * for error case.
16640Sstevel@tonic-gate 	 */
16650Sstevel@tonic-gate 	nso->so_options = so->so_options & (SO_DEBUG|SO_REUSEADDR|SO_KEEPALIVE|
16660Sstevel@tonic-gate 	    SO_DONTROUTE|SO_BROADCAST|SO_USELOOPBACK|
16670Sstevel@tonic-gate 	    SO_OOBINLINE|SO_DGRAM_ERRIND|SO_LINGER);
16680Sstevel@tonic-gate 	nso->so_sndbuf = so->so_sndbuf;
16690Sstevel@tonic-gate 	nso->so_rcvbuf = so->so_rcvbuf;
16700Sstevel@tonic-gate 	if (nso->so_options & SO_LINGER)
16710Sstevel@tonic-gate 		nso->so_linger = so->so_linger;
16720Sstevel@tonic-gate 
1673741Smasputra 	if ((so->so_state & SS_DIRECT) != 0) {
16740Sstevel@tonic-gate 		mblk_t *ack_mp;
16750Sstevel@tonic-gate 
1676741Smasputra 		ASSERT(nso->so_state & SS_DIRECT);
16770Sstevel@tonic-gate 		ASSERT(opt != NULL);
16780Sstevel@tonic-gate 
16790Sstevel@tonic-gate 		conn_res->OPT_length = optlen;
16800Sstevel@tonic-gate 		conn_res->OPT_offset = MBLKL(mp);
16810Sstevel@tonic-gate 		bcopy(&opt, mp->b_wptr, optlen);
16820Sstevel@tonic-gate 		mp->b_wptr += optlen;
16830Sstevel@tonic-gate 		conn_res->PRIM_type = T_CONN_RES;
16840Sstevel@tonic-gate 		conn_res->ACCEPTOR_id = 0;
16850Sstevel@tonic-gate 		PRIM_type = T_CONN_RES;
16860Sstevel@tonic-gate 
16870Sstevel@tonic-gate 		/* Send down the T_CONN_RES on acceptor STREAM */
16880Sstevel@tonic-gate 		error = kstrputmsg(SOTOV(nso), mp, NULL,
16890Sstevel@tonic-gate 		    0, 0, MSG_BAND|MSG_HOLDSIG|MSG_IGNERROR, 0);
16900Sstevel@tonic-gate 		if (error) {
16910Sstevel@tonic-gate 			mutex_enter(&so->so_lock);
16920Sstevel@tonic-gate 			so_lock_single(so);
16930Sstevel@tonic-gate 			eprintsoline(so, error);
16940Sstevel@tonic-gate 			goto disconnect_vp;
16950Sstevel@tonic-gate 		}
16960Sstevel@tonic-gate 		mutex_enter(&nso->so_lock);
16970Sstevel@tonic-gate 		error = sowaitprim(nso, T_CONN_RES, T_OK_ACK,
16980Sstevel@tonic-gate 		    (t_uscalar_t)sizeof (struct T_ok_ack), &ack_mp, 0);
16990Sstevel@tonic-gate 		if (error) {
17000Sstevel@tonic-gate 			mutex_exit(&nso->so_lock);
17010Sstevel@tonic-gate 			mutex_enter(&so->so_lock);
17020Sstevel@tonic-gate 			so_lock_single(so);
17030Sstevel@tonic-gate 			eprintsoline(so, error);
17040Sstevel@tonic-gate 			goto disconnect_vp;
17050Sstevel@tonic-gate 		}
17060Sstevel@tonic-gate 		if (nso->so_family == AF_INET) {
17070Sstevel@tonic-gate 			sin_t *sin;
17080Sstevel@tonic-gate 
17090Sstevel@tonic-gate 			sin = (sin_t *)(ack_mp->b_rptr +
17100Sstevel@tonic-gate 			    sizeof (struct T_ok_ack));
17110Sstevel@tonic-gate 			bcopy(sin, nso->so_laddr_sa, sizeof (sin_t));
17120Sstevel@tonic-gate 			nso->so_laddr_len = sizeof (sin_t);
17130Sstevel@tonic-gate 		} else {
17140Sstevel@tonic-gate 			sin6_t *sin6;
17150Sstevel@tonic-gate 
17160Sstevel@tonic-gate 			sin6 = (sin6_t *)(ack_mp->b_rptr +
17170Sstevel@tonic-gate 			    sizeof (struct T_ok_ack));
17180Sstevel@tonic-gate 			bcopy(sin6, nso->so_laddr_sa, sizeof (sin6_t));
17190Sstevel@tonic-gate 			nso->so_laddr_len = sizeof (sin6_t);
17200Sstevel@tonic-gate 		}
17210Sstevel@tonic-gate 		freemsg(ack_mp);
17220Sstevel@tonic-gate 
17230Sstevel@tonic-gate 		nso->so_state |= SS_ISCONNECTED | SS_LADDR_VALID;
17240Sstevel@tonic-gate 		nso->so_priv = opt;
17250Sstevel@tonic-gate 
17260Sstevel@tonic-gate 		if (so->so_nl7c_flags & NL7C_ENABLED) {
17270Sstevel@tonic-gate 			/*
17280Sstevel@tonic-gate 			 * An NL7C marked listen()er so the new socket
17290Sstevel@tonic-gate 			 * inherits the listen()er's NL7C state.
17300Sstevel@tonic-gate 			 *
17310Sstevel@tonic-gate 			 * When calling NL7C to process the new socket
17320Sstevel@tonic-gate 			 * pass the nonblocking i/o state of the listen
17330Sstevel@tonic-gate 			 * socket as this is the context we are in.
17340Sstevel@tonic-gate 			 */
17350Sstevel@tonic-gate 			nso->so_nl7c_flags = so->so_nl7c_flags;
17360Sstevel@tonic-gate 			if (nl7c_process(nso,
17370Sstevel@tonic-gate 			    (nso->so_state & (SS_NONBLOCK|SS_NDELAY)),
17380Sstevel@tonic-gate 			    (int)((tcp_t *)nso->so_priv)->tcp_mss)) {
17390Sstevel@tonic-gate 				/*
17400Sstevel@tonic-gate 				 * NL7C has completed processing on the
17410Sstevel@tonic-gate 				 * socket, close the socket and back to
17420Sstevel@tonic-gate 				 * the top to await the next T_CONN_IND.
17430Sstevel@tonic-gate 				 */
17440Sstevel@tonic-gate 				mutex_exit(&nso->so_lock);
17450Sstevel@tonic-gate 				(void) VOP_CLOSE(nvp, 0, 1, (offset_t)0,
17460Sstevel@tonic-gate 						CRED());
17470Sstevel@tonic-gate 				VN_RELE(nvp);
17480Sstevel@tonic-gate 				goto again;
17490Sstevel@tonic-gate 			}
17500Sstevel@tonic-gate 			/* Pass the new socket out */
17510Sstevel@tonic-gate 		}
17520Sstevel@tonic-gate 
17530Sstevel@tonic-gate 		mutex_exit(&nso->so_lock);
17540Sstevel@tonic-gate 
17550Sstevel@tonic-gate 		/*
17560Sstevel@tonic-gate 		 * Pass out new socket.
17570Sstevel@tonic-gate 		 */
17580Sstevel@tonic-gate 		if (nsop != NULL)
17590Sstevel@tonic-gate 			*nsop = nso;
17600Sstevel@tonic-gate 
17610Sstevel@tonic-gate 		return (0);
17620Sstevel@tonic-gate 	}
17630Sstevel@tonic-gate 
17640Sstevel@tonic-gate 	/*
17650Sstevel@tonic-gate 	 * Copy local address from listener.
17660Sstevel@tonic-gate 	 */
17670Sstevel@tonic-gate 	nso->so_laddr_len = so->so_laddr_len;
17680Sstevel@tonic-gate 	ASSERT(nso->so_laddr_len <= nso->so_laddr_maxlen);
17690Sstevel@tonic-gate 	bcopy(so->so_laddr_sa, nso->so_laddr_sa, nso->so_laddr_len);
17700Sstevel@tonic-gate 	nso->so_state |= SS_LADDR_VALID;
17710Sstevel@tonic-gate 
17720Sstevel@tonic-gate 	/*
17730Sstevel@tonic-gate 	 * This is the non-performance case for sockets (e.g. AF_UNIX sockets)
17740Sstevel@tonic-gate 	 * which don't support the FireEngine accept fast-path. It is also
17750Sstevel@tonic-gate 	 * used when the virtual "sockmod" has been I_POP'd and I_PUSH'd
17760Sstevel@tonic-gate 	 * again. Neither sockfs nor TCP attempt to find out if some other
17770Sstevel@tonic-gate 	 * random module has been inserted in between (in which case we
17780Sstevel@tonic-gate 	 * should follow TLI accept behaviour). We blindly assume the worst
17790Sstevel@tonic-gate 	 * case and revert back to old behaviour i.e. TCP will not send us
17800Sstevel@tonic-gate 	 * any option (eager) and the accept should happen on the listener
17810Sstevel@tonic-gate 	 * queue. Any queued T_conn_ind have already got their options removed
17820Sstevel@tonic-gate 	 * by so_sock2_stream() when "sockmod" was I_POP'd.
17830Sstevel@tonic-gate 	 */
17840Sstevel@tonic-gate 	/*
17850Sstevel@tonic-gate 	 * Fill in the {O_}T_CONN_RES before getting SOLOCKED.
17860Sstevel@tonic-gate 	 */
17870Sstevel@tonic-gate 	if ((nso->so_mode & SM_ACCEPTOR_ID) == 0) {
17880Sstevel@tonic-gate #ifdef	_ILP32
17890Sstevel@tonic-gate 		queue_t	*q;
17900Sstevel@tonic-gate 
17910Sstevel@tonic-gate 		/*
17920Sstevel@tonic-gate 		 * Find read queue in driver
17930Sstevel@tonic-gate 		 * Can safely do this since we "own" nso/nvp.
17940Sstevel@tonic-gate 		 */
17950Sstevel@tonic-gate 		q = strvp2wq(nvp)->q_next;
17960Sstevel@tonic-gate 		while (SAMESTR(q))
17970Sstevel@tonic-gate 			q = q->q_next;
17980Sstevel@tonic-gate 		q = RD(q);
17990Sstevel@tonic-gate 		conn_res->ACCEPTOR_id = (t_uscalar_t)q;
18000Sstevel@tonic-gate #else
18010Sstevel@tonic-gate 		conn_res->ACCEPTOR_id = (t_uscalar_t)getminor(nvp->v_rdev);
18020Sstevel@tonic-gate #endif	/* _ILP32 */
18030Sstevel@tonic-gate 		conn_res->PRIM_type = O_T_CONN_RES;
18040Sstevel@tonic-gate 		PRIM_type = O_T_CONN_RES;
18050Sstevel@tonic-gate 	} else {
18060Sstevel@tonic-gate 		conn_res->ACCEPTOR_id = nso->so_acceptor_id;
18070Sstevel@tonic-gate 		conn_res->PRIM_type = T_CONN_RES;
18080Sstevel@tonic-gate 		PRIM_type = T_CONN_RES;
18090Sstevel@tonic-gate 	}
18100Sstevel@tonic-gate 	conn_res->SEQ_number = SEQ_number;
18110Sstevel@tonic-gate 	conn_res->OPT_length = 0;
18120Sstevel@tonic-gate 	conn_res->OPT_offset = 0;
18130Sstevel@tonic-gate 
18140Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
18150Sstevel@tonic-gate 	so_lock_single(so);	/* Set SOLOCKED */
18160Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
18170Sstevel@tonic-gate 
18180Sstevel@tonic-gate 	error = kstrputmsg(SOTOV(so), mp, NULL,
18190Sstevel@tonic-gate 	    0, 0, MSG_BAND|MSG_HOLDSIG|MSG_IGNERROR, 0);
18200Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
18210Sstevel@tonic-gate 	if (error) {
18220Sstevel@tonic-gate 		eprintsoline(so, error);
18230Sstevel@tonic-gate 		goto disconnect_vp;
18240Sstevel@tonic-gate 	}
18250Sstevel@tonic-gate 	error = sowaitokack(so, PRIM_type);
18260Sstevel@tonic-gate 	if (error) {
18270Sstevel@tonic-gate 		eprintsoline(so, error);
18280Sstevel@tonic-gate 		goto disconnect_vp;
18290Sstevel@tonic-gate 	}
18300Sstevel@tonic-gate 	so_unlock_single(so, SOLOCKED);
18310Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
18320Sstevel@tonic-gate 
18330Sstevel@tonic-gate 	nso->so_state |= SS_ISCONNECTED;
18340Sstevel@tonic-gate 
18350Sstevel@tonic-gate 	/*
18360Sstevel@tonic-gate 	 * Pass out new socket.
18370Sstevel@tonic-gate 	 */
18380Sstevel@tonic-gate 	if (nsop != NULL)
18390Sstevel@tonic-gate 		*nsop = nso;
18400Sstevel@tonic-gate 
18410Sstevel@tonic-gate 	return (0);
18420Sstevel@tonic-gate 
18430Sstevel@tonic-gate 
18440Sstevel@tonic-gate eproto_disc_unl:
18450Sstevel@tonic-gate 	error = EPROTO;
18460Sstevel@tonic-gate e_disc_unl:
18470Sstevel@tonic-gate 	eprintsoline(so, error);
18480Sstevel@tonic-gate 	goto disconnect_unlocked;
18490Sstevel@tonic-gate 
18500Sstevel@tonic-gate pr_disc_vp_unl:
18510Sstevel@tonic-gate 	eprintsoline(so, error);
18520Sstevel@tonic-gate disconnect_vp_unlocked:
18530Sstevel@tonic-gate 	(void) VOP_CLOSE(nvp, 0, 1, 0, CRED());
18540Sstevel@tonic-gate 	VN_RELE(nvp);
18550Sstevel@tonic-gate disconnect_unlocked:
18560Sstevel@tonic-gate 	(void) sodisconnect(so, SEQ_number, 0);
18570Sstevel@tonic-gate 	return (error);
18580Sstevel@tonic-gate 
18590Sstevel@tonic-gate pr_disc_vp:
18600Sstevel@tonic-gate 	eprintsoline(so, error);
18610Sstevel@tonic-gate disconnect_vp:
18620Sstevel@tonic-gate 	(void) sodisconnect(so, SEQ_number, _SODISCONNECT_LOCK_HELD);
18630Sstevel@tonic-gate 	so_unlock_single(so, SOLOCKED);
18640Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
18650Sstevel@tonic-gate 	(void) VOP_CLOSE(nvp, 0, 1, 0, CRED());
18660Sstevel@tonic-gate 	VN_RELE(nvp);
18670Sstevel@tonic-gate 	return (error);
18680Sstevel@tonic-gate 
18690Sstevel@tonic-gate conn_bad:	/* Note: SunOS 4/BSD unconditionally returns EINVAL here */
18700Sstevel@tonic-gate 	error = (so->so_type == SOCK_DGRAM || so->so_type == SOCK_RAW)
18710Sstevel@tonic-gate 	    ? EOPNOTSUPP : EINVAL;
18720Sstevel@tonic-gate e_bad:
18730Sstevel@tonic-gate 	eprintsoline(so, error);
18740Sstevel@tonic-gate 	return (error);
18750Sstevel@tonic-gate }
18760Sstevel@tonic-gate 
18770Sstevel@tonic-gate /*
18780Sstevel@tonic-gate  * connect a socket.
18790Sstevel@tonic-gate  *
18800Sstevel@tonic-gate  * Allow SOCK_DGRAM sockets to reconnect (by specifying a new address) and to
18810Sstevel@tonic-gate  * unconnect (by specifying a null address).
18820Sstevel@tonic-gate  */
18830Sstevel@tonic-gate int
18840Sstevel@tonic-gate sotpi_connect(struct sonode *so,
18850Sstevel@tonic-gate 	const struct sockaddr *name,
18860Sstevel@tonic-gate 	socklen_t namelen,
18870Sstevel@tonic-gate 	int fflag,
18880Sstevel@tonic-gate 	int flags)
18890Sstevel@tonic-gate {
18900Sstevel@tonic-gate 	struct T_conn_req	conn_req;
18910Sstevel@tonic-gate 	int			error = 0;
18920Sstevel@tonic-gate 	mblk_t			*mp;
18930Sstevel@tonic-gate 	void			*src;
18940Sstevel@tonic-gate 	socklen_t		srclen;
18950Sstevel@tonic-gate 	void			*addr;
18960Sstevel@tonic-gate 	socklen_t		addrlen;
18970Sstevel@tonic-gate 	boolean_t		need_unlock;
18980Sstevel@tonic-gate 
18990Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_connect(%p, %p, %d, 0x%x, 0x%x) %s\n",
19000Sstevel@tonic-gate 		so, name, namelen, fflag, flags,
19010Sstevel@tonic-gate 		pr_state(so->so_state, so->so_mode)));
19020Sstevel@tonic-gate 
19030Sstevel@tonic-gate 	/*
19040Sstevel@tonic-gate 	 * Preallocate the T_CONN_REQ mblk before grabbing SOLOCKED to
19050Sstevel@tonic-gate 	 * avoid sleeping for memory with SOLOCKED held.
19060Sstevel@tonic-gate 	 * We know that the T_CONN_REQ can't be larger than 2 * so_faddr_maxlen
19070Sstevel@tonic-gate 	 * + sizeof (struct T_opthdr).
19080Sstevel@tonic-gate 	 * (the AF_UNIX so_ux_addr_xlate() does not make the address
19090Sstevel@tonic-gate 	 * exceed so_faddr_maxlen).
19100Sstevel@tonic-gate 	 */
19110Sstevel@tonic-gate 	mp = soallocproto(sizeof (struct T_conn_req) +
19120Sstevel@tonic-gate 	    2 * so->so_faddr_maxlen + sizeof (struct T_opthdr), _ALLOC_INTR);
19130Sstevel@tonic-gate 	if (mp == NULL) {
19140Sstevel@tonic-gate 		/*
19150Sstevel@tonic-gate 		 * Connect can not fail with ENOBUFS. A signal was
19160Sstevel@tonic-gate 		 * caught so return EINTR.
19170Sstevel@tonic-gate 		 */
19180Sstevel@tonic-gate 		error = EINTR;
19190Sstevel@tonic-gate 		eprintsoline(so, error);
19200Sstevel@tonic-gate 		return (error);
19210Sstevel@tonic-gate 	}
19220Sstevel@tonic-gate 
19230Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
19240Sstevel@tonic-gate 	/*
19250Sstevel@tonic-gate 	 * Make sure that there is a preallocated unbind_req
19260Sstevel@tonic-gate 	 * message before any binding. This message allocated when
19270Sstevel@tonic-gate 	 * the socket is created  but it might be have been
19280Sstevel@tonic-gate 	 * consumed.
19290Sstevel@tonic-gate 	 */
19300Sstevel@tonic-gate 	if (so->so_unbind_mp == NULL) {
19310Sstevel@tonic-gate 		dprintso(so, 1, ("sotpi_connect: allocating unbind_req\n"));
19320Sstevel@tonic-gate 		/* NOTE: holding so_lock while sleeping */
19330Sstevel@tonic-gate 		so->so_unbind_mp =
19340Sstevel@tonic-gate 		    soallocproto(sizeof (struct T_unbind_req), _ALLOC_INTR);
19350Sstevel@tonic-gate 		if (so->so_unbind_mp == NULL) {
19360Sstevel@tonic-gate 			error = EINTR;
19370Sstevel@tonic-gate 			need_unlock = B_FALSE;
19380Sstevel@tonic-gate 			goto done;
19390Sstevel@tonic-gate 		}
19400Sstevel@tonic-gate 	}
19410Sstevel@tonic-gate 
19420Sstevel@tonic-gate 	so_lock_single(so);	/* Set SOLOCKED */
19430Sstevel@tonic-gate 	need_unlock = B_TRUE;
19440Sstevel@tonic-gate 
19450Sstevel@tonic-gate 	/*
19460Sstevel@tonic-gate 	 * Can't have done a listen before connecting.
19470Sstevel@tonic-gate 	 */
19480Sstevel@tonic-gate 	if (so->so_state & SS_ACCEPTCONN) {
19490Sstevel@tonic-gate 		error = EOPNOTSUPP;
19500Sstevel@tonic-gate 		goto done;
19510Sstevel@tonic-gate 	}
19520Sstevel@tonic-gate 
19530Sstevel@tonic-gate 	/*
19540Sstevel@tonic-gate 	 * Must be bound with the transport
19550Sstevel@tonic-gate 	 */
19560Sstevel@tonic-gate 	if (!(so->so_state & SS_ISBOUND)) {
19570Sstevel@tonic-gate 		if ((so->so_family == AF_INET || so->so_family == AF_INET6) &&
19580Sstevel@tonic-gate 		    /*CONSTCOND*/
19590Sstevel@tonic-gate 		    so->so_type == SOCK_STREAM && !soconnect_tpi_tcp) {
19600Sstevel@tonic-gate 			/*
19610Sstevel@tonic-gate 			 * Optimization for AF_INET{,6} transports
19620Sstevel@tonic-gate 			 * that can handle a T_CONN_REQ without being bound.
19630Sstevel@tonic-gate 			 */
19640Sstevel@tonic-gate 			so_automatic_bind(so);
19650Sstevel@tonic-gate 		} else {
19660Sstevel@tonic-gate 			error = sotpi_bind(so, NULL, 0,
19670Sstevel@tonic-gate 			    _SOBIND_UNSPEC|_SOBIND_LOCK_HELD);
19680Sstevel@tonic-gate 			if (error)
19690Sstevel@tonic-gate 				goto done;
19700Sstevel@tonic-gate 		}
19710Sstevel@tonic-gate 		ASSERT(so->so_state & SS_ISBOUND);
19720Sstevel@tonic-gate 		flags |= _SOCONNECT_DID_BIND;
19730Sstevel@tonic-gate 	}
19740Sstevel@tonic-gate 
19750Sstevel@tonic-gate 	/*
19760Sstevel@tonic-gate 	 * Handle a connect to a name parameter of type AF_UNSPEC like a
19770Sstevel@tonic-gate 	 * connect to a null address. This is the portable method to
19780Sstevel@tonic-gate 	 * unconnect a socket.
19790Sstevel@tonic-gate 	 */
19800Sstevel@tonic-gate 	if ((namelen >= sizeof (sa_family_t)) &&
19810Sstevel@tonic-gate 	    (name->sa_family == AF_UNSPEC)) {
19820Sstevel@tonic-gate 		name = NULL;
19830Sstevel@tonic-gate 		namelen = 0;
19840Sstevel@tonic-gate 	}
19850Sstevel@tonic-gate 
19860Sstevel@tonic-gate 	/*
19870Sstevel@tonic-gate 	 * Check that we are not already connected.
19880Sstevel@tonic-gate 	 * A connection-oriented socket cannot be reconnected.
19890Sstevel@tonic-gate 	 * A connected connection-less socket can be
19900Sstevel@tonic-gate 	 * - connected to a different address by a subsequent connect
19910Sstevel@tonic-gate 	 * - "unconnected" by a connect to the NULL address
19920Sstevel@tonic-gate 	 */
19930Sstevel@tonic-gate 	if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) {
19940Sstevel@tonic-gate 		ASSERT(!(flags & _SOCONNECT_DID_BIND));
19950Sstevel@tonic-gate 		if (so->so_mode & SM_CONNREQUIRED) {
19960Sstevel@tonic-gate 			/* Connection-oriented socket */
19970Sstevel@tonic-gate 			error = so->so_state & SS_ISCONNECTED ?
19980Sstevel@tonic-gate 			    EISCONN : EALREADY;
19990Sstevel@tonic-gate 			goto done;
20000Sstevel@tonic-gate 		}
20010Sstevel@tonic-gate 		/* Connection-less socket */
20020Sstevel@tonic-gate 		if (name == NULL) {
20030Sstevel@tonic-gate 			/*
20040Sstevel@tonic-gate 			 * Remove the connected state and clear SO_DGRAM_ERRIND
20050Sstevel@tonic-gate 			 * since it was set when the socket was connected.
20060Sstevel@tonic-gate 			 * If this is UDP also send down a T_DISCON_REQ.
20070Sstevel@tonic-gate 			 */
20080Sstevel@tonic-gate 			int val;
20090Sstevel@tonic-gate 
20100Sstevel@tonic-gate 			if ((so->so_family == AF_INET ||
20110Sstevel@tonic-gate 				so->so_family == AF_INET6) &&
20120Sstevel@tonic-gate 			    (so->so_type == SOCK_DGRAM ||
20130Sstevel@tonic-gate 				so->so_type == SOCK_RAW) &&
20140Sstevel@tonic-gate 			    /*CONSTCOND*/
20150Sstevel@tonic-gate 			    !soconnect_tpi_udp) {
20160Sstevel@tonic-gate 				/* XXX What about implicitly unbinding here? */
20170Sstevel@tonic-gate 				error = sodisconnect(so, -1,
20180Sstevel@tonic-gate 						_SODISCONNECT_LOCK_HELD);
20190Sstevel@tonic-gate 			} else {
20200Sstevel@tonic-gate 				so->so_state &=
20210Sstevel@tonic-gate 				    ~(SS_ISCONNECTED | SS_ISCONNECTING |
20220Sstevel@tonic-gate 				    SS_FADDR_VALID);
20230Sstevel@tonic-gate 				so->so_faddr_len = 0;
20240Sstevel@tonic-gate 			}
20250Sstevel@tonic-gate 
20260Sstevel@tonic-gate 			so_unlock_single(so, SOLOCKED);
20270Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
20280Sstevel@tonic-gate 
20290Sstevel@tonic-gate 			val = 0;
20300Sstevel@tonic-gate 			(void) sotpi_setsockopt(so, SOL_SOCKET, SO_DGRAM_ERRIND,
20310Sstevel@tonic-gate 					&val, (t_uscalar_t)sizeof (val));
20320Sstevel@tonic-gate 
20330Sstevel@tonic-gate 			mutex_enter(&so->so_lock);
20340Sstevel@tonic-gate 			so_lock_single(so);	/* Set SOLOCKED */
20350Sstevel@tonic-gate 			goto done;
20360Sstevel@tonic-gate 		}
20370Sstevel@tonic-gate 	}
20380Sstevel@tonic-gate 	ASSERT(so->so_state & SS_ISBOUND);
20390Sstevel@tonic-gate 
20400Sstevel@tonic-gate 	if (name == NULL || namelen == 0) {
20410Sstevel@tonic-gate 		error = EINVAL;
20420Sstevel@tonic-gate 		goto done;
20430Sstevel@tonic-gate 	}
20440Sstevel@tonic-gate 	/*
20450Sstevel@tonic-gate 	 * Mark the socket if so_faddr_sa represents the transport level
20460Sstevel@tonic-gate 	 * address.
20470Sstevel@tonic-gate 	 */
20480Sstevel@tonic-gate 	if (flags & _SOCONNECT_NOXLATE) {
20490Sstevel@tonic-gate 		struct sockaddr_ux	*soaddr_ux;
20500Sstevel@tonic-gate 
20510Sstevel@tonic-gate 		ASSERT(so->so_family == AF_UNIX);
20520Sstevel@tonic-gate 		if (namelen != sizeof (struct sockaddr_ux)) {
20530Sstevel@tonic-gate 			error = EINVAL;
20540Sstevel@tonic-gate 			goto done;
20550Sstevel@tonic-gate 		}
20560Sstevel@tonic-gate 		soaddr_ux = (struct sockaddr_ux *)name;
20570Sstevel@tonic-gate 		name = (struct sockaddr *)&soaddr_ux->sou_addr;
20580Sstevel@tonic-gate 		namelen = sizeof (soaddr_ux->sou_addr);
20590Sstevel@tonic-gate 		so->so_state |= SS_FADDR_NOXLATE;
20600Sstevel@tonic-gate 	}
20610Sstevel@tonic-gate 
20620Sstevel@tonic-gate 	/*
20630Sstevel@tonic-gate 	 * Length and family checks.
20640Sstevel@tonic-gate 	 */
20650Sstevel@tonic-gate 	error = so_addr_verify(so, name, namelen);
20660Sstevel@tonic-gate 	if (error)
20670Sstevel@tonic-gate 		goto bad;
20680Sstevel@tonic-gate 
20690Sstevel@tonic-gate 	/*
20700Sstevel@tonic-gate 	 * Save foreign address. Needed for AF_UNIX as well as
20710Sstevel@tonic-gate 	 * transport providers that do not support TI_GETPEERNAME.
20720Sstevel@tonic-gate 	 * Also used for cached foreign address for TCP and UDP.
20730Sstevel@tonic-gate 	 */
20740Sstevel@tonic-gate 	if (namelen > (t_uscalar_t)so->so_faddr_maxlen) {
20750Sstevel@tonic-gate 		error = EINVAL;
20760Sstevel@tonic-gate 		goto done;
20770Sstevel@tonic-gate 	}
20780Sstevel@tonic-gate 	so->so_faddr_len = (socklen_t)namelen;
20790Sstevel@tonic-gate 	ASSERT(so->so_faddr_len <= so->so_faddr_maxlen);
20800Sstevel@tonic-gate 	bcopy(name, so->so_faddr_sa, namelen);
20810Sstevel@tonic-gate 	so->so_state |= SS_FADDR_VALID;
20820Sstevel@tonic-gate 
20830Sstevel@tonic-gate 	if (so->so_family == AF_UNIX) {
20840Sstevel@tonic-gate 		if (so->so_state & SS_FADDR_NOXLATE) {
20850Sstevel@tonic-gate 			/*
20860Sstevel@tonic-gate 			 * Already have a transport internal address. Do not
20870Sstevel@tonic-gate 			 * pass any (transport internal) source address.
20880Sstevel@tonic-gate 			 */
20890Sstevel@tonic-gate 			addr = so->so_faddr_sa;
20900Sstevel@tonic-gate 			addrlen = (t_uscalar_t)so->so_faddr_len;
20910Sstevel@tonic-gate 			src = NULL;
20920Sstevel@tonic-gate 			srclen = 0;
20930Sstevel@tonic-gate 		} else {
20940Sstevel@tonic-gate 			/*
20950Sstevel@tonic-gate 			 * Pass the sockaddr_un source address as an option
20960Sstevel@tonic-gate 			 * and translate the remote address.
20970Sstevel@tonic-gate 			 * Holding so_lock thus so_laddr_sa can not change.
20980Sstevel@tonic-gate 			 */
20990Sstevel@tonic-gate 			src = so->so_laddr_sa;
21000Sstevel@tonic-gate 			srclen = (t_uscalar_t)so->so_laddr_len;
21010Sstevel@tonic-gate 			dprintso(so, 1,
21020Sstevel@tonic-gate 				("sotpi_connect UNIX: srclen %d, src %p\n",
21030Sstevel@tonic-gate 				srclen, src));
21040Sstevel@tonic-gate 			error = so_ux_addr_xlate(so,
21050Sstevel@tonic-gate 				so->so_faddr_sa, (socklen_t)so->so_faddr_len,
21060Sstevel@tonic-gate 				(flags & _SOCONNECT_XPG4_2),
21070Sstevel@tonic-gate 				&addr, &addrlen);
21080Sstevel@tonic-gate 			if (error)
21090Sstevel@tonic-gate 				goto bad;
21100Sstevel@tonic-gate 		}
21110Sstevel@tonic-gate 	} else {
21120Sstevel@tonic-gate 		addr = so->so_faddr_sa;
21130Sstevel@tonic-gate 		addrlen = (t_uscalar_t)so->so_faddr_len;
21140Sstevel@tonic-gate 		src = NULL;
21150Sstevel@tonic-gate 		srclen = 0;
21160Sstevel@tonic-gate 	}
21170Sstevel@tonic-gate 	/*
21180Sstevel@tonic-gate 	 * When connecting a datagram socket we issue the SO_DGRAM_ERRIND
21190Sstevel@tonic-gate 	 * option which asks the transport provider to send T_UDERR_IND
21200Sstevel@tonic-gate 	 * messages. These T_UDERR_IND messages are used to return connected
21210Sstevel@tonic-gate 	 * style errors (e.g. ECONNRESET) for connected datagram sockets.
21220Sstevel@tonic-gate 	 *
21230Sstevel@tonic-gate 	 * In addition, for UDP (and SOCK_RAW AF_INET{,6} sockets)
21240Sstevel@tonic-gate 	 * we send down a T_CONN_REQ. This is needed to let the
21250Sstevel@tonic-gate 	 * transport assign a local address that is consistent with
21260Sstevel@tonic-gate 	 * the remote address. Applications depend on a getsockname()
21270Sstevel@tonic-gate 	 * after a connect() to retrieve the "source" IP address for
21280Sstevel@tonic-gate 	 * the connected socket.  Invalidate the cached local address
21290Sstevel@tonic-gate 	 * to force getsockname() to enquire of the transport.
21300Sstevel@tonic-gate 	 */
21310Sstevel@tonic-gate 	if (!(so->so_mode & SM_CONNREQUIRED)) {
21320Sstevel@tonic-gate 		/*
21330Sstevel@tonic-gate 		 * Datagram socket.
21340Sstevel@tonic-gate 		 */
21350Sstevel@tonic-gate 		int32_t val;
21360Sstevel@tonic-gate 
21370Sstevel@tonic-gate 		so_unlock_single(so, SOLOCKED);
21380Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
21390Sstevel@tonic-gate 
21400Sstevel@tonic-gate 		val = 1;
21410Sstevel@tonic-gate 		(void) sotpi_setsockopt(so, SOL_SOCKET, SO_DGRAM_ERRIND,
21420Sstevel@tonic-gate 					&val, (t_uscalar_t)sizeof (val));
21430Sstevel@tonic-gate 
21440Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
21450Sstevel@tonic-gate 		so_lock_single(so);	/* Set SOLOCKED */
21460Sstevel@tonic-gate 		if ((so->so_family != AF_INET && so->so_family != AF_INET6) ||
21470Sstevel@tonic-gate 		    (so->so_type != SOCK_DGRAM && so->so_type != SOCK_RAW) ||
21480Sstevel@tonic-gate 		    soconnect_tpi_udp) {
21490Sstevel@tonic-gate 			soisconnected(so);
21500Sstevel@tonic-gate 			goto done;
21510Sstevel@tonic-gate 		}
21520Sstevel@tonic-gate 		/*
21530Sstevel@tonic-gate 		 * Send down T_CONN_REQ etc.
21540Sstevel@tonic-gate 		 * Clear fflag to avoid returning EWOULDBLOCK.
21550Sstevel@tonic-gate 		 */
21560Sstevel@tonic-gate 		fflag = 0;
21570Sstevel@tonic-gate 		ASSERT(so->so_family != AF_UNIX);
21580Sstevel@tonic-gate 		so->so_state &= ~SS_LADDR_VALID;
21590Sstevel@tonic-gate 	} else if (so->so_laddr_len != 0) {
21600Sstevel@tonic-gate 		/*
21610Sstevel@tonic-gate 		 * If the local address or port was "any" then it may be
21620Sstevel@tonic-gate 		 * changed by the transport as a result of the
21630Sstevel@tonic-gate 		 * connect.  Invalidate the cached version if we have one.
21640Sstevel@tonic-gate 		 */
21650Sstevel@tonic-gate 		switch (so->so_family) {
21660Sstevel@tonic-gate 		case AF_INET:
21670Sstevel@tonic-gate 			ASSERT(so->so_laddr_len == (socklen_t)sizeof (sin_t));
21680Sstevel@tonic-gate 			if (((sin_t *)so->so_laddr_sa)->sin_addr.s_addr ==
21690Sstevel@tonic-gate 			    INADDR_ANY ||
21700Sstevel@tonic-gate 			    ((sin_t *)so->so_laddr_sa)->sin_port == 0)
21710Sstevel@tonic-gate 				so->so_state &= ~SS_LADDR_VALID;
21720Sstevel@tonic-gate 			break;
21730Sstevel@tonic-gate 
21740Sstevel@tonic-gate 		case AF_INET6:
21750Sstevel@tonic-gate 			ASSERT(so->so_laddr_len == (socklen_t)sizeof (sin6_t));
21760Sstevel@tonic-gate 			if (IN6_IS_ADDR_UNSPECIFIED(
21770Sstevel@tonic-gate 			    &((sin6_t *)so->so_laddr_sa) ->sin6_addr) ||
21780Sstevel@tonic-gate 			    IN6_IS_ADDR_V4MAPPED_ANY(
21790Sstevel@tonic-gate 			    &((sin6_t *)so->so_laddr_sa)->sin6_addr) ||
21800Sstevel@tonic-gate 			    ((sin6_t *)so->so_laddr_sa)->sin6_port == 0)
21810Sstevel@tonic-gate 				    so->so_state &= ~SS_LADDR_VALID;
21820Sstevel@tonic-gate 			break;
21830Sstevel@tonic-gate 
21840Sstevel@tonic-gate 		default:
21850Sstevel@tonic-gate 			break;
21860Sstevel@tonic-gate 		}
21870Sstevel@tonic-gate 	}
21880Sstevel@tonic-gate 
21890Sstevel@tonic-gate 	/*
21900Sstevel@tonic-gate 	 * Check for failure of an earlier call
21910Sstevel@tonic-gate 	 */
21920Sstevel@tonic-gate 	if (so->so_error != 0)
21930Sstevel@tonic-gate 		goto so_bad;
21940Sstevel@tonic-gate 
21950Sstevel@tonic-gate 	/*
21960Sstevel@tonic-gate 	 * Send down T_CONN_REQ. Message was allocated above.
21970Sstevel@tonic-gate 	 */
21980Sstevel@tonic-gate 	conn_req.PRIM_type = T_CONN_REQ;
21990Sstevel@tonic-gate 	conn_req.DEST_length = addrlen;
22000Sstevel@tonic-gate 	conn_req.DEST_offset = (t_scalar_t)sizeof (conn_req);
22010Sstevel@tonic-gate 	if (srclen == 0) {
22020Sstevel@tonic-gate 		conn_req.OPT_length = 0;
22030Sstevel@tonic-gate 		conn_req.OPT_offset = 0;
22040Sstevel@tonic-gate 		soappendmsg(mp, &conn_req, sizeof (conn_req));
22050Sstevel@tonic-gate 		soappendmsg(mp, addr, addrlen);
22060Sstevel@tonic-gate 	} else {
22070Sstevel@tonic-gate 		/*
22080Sstevel@tonic-gate 		 * There is a AF_UNIX sockaddr_un to include as a source
22090Sstevel@tonic-gate 		 * address option.
22100Sstevel@tonic-gate 		 */
22110Sstevel@tonic-gate 		struct T_opthdr toh;
22120Sstevel@tonic-gate 
22130Sstevel@tonic-gate 		toh.level = SOL_SOCKET;
22140Sstevel@tonic-gate 		toh.name = SO_SRCADDR;
22150Sstevel@tonic-gate 		toh.len = (t_uscalar_t)(srclen + sizeof (struct T_opthdr));
22160Sstevel@tonic-gate 		toh.status = 0;
22170Sstevel@tonic-gate 		conn_req.OPT_length =
22180Sstevel@tonic-gate 			(t_scalar_t)(sizeof (toh) + _TPI_ALIGN_TOPT(srclen));
22190Sstevel@tonic-gate 		conn_req.OPT_offset = (t_scalar_t)(sizeof (conn_req) +
22200Sstevel@tonic-gate 			_TPI_ALIGN_TOPT(addrlen));
22210Sstevel@tonic-gate 
22220Sstevel@tonic-gate 		soappendmsg(mp, &conn_req, sizeof (conn_req));
22230Sstevel@tonic-gate 		soappendmsg(mp, addr, addrlen);
22240Sstevel@tonic-gate 		mp->b_wptr += _TPI_ALIGN_TOPT(addrlen) - addrlen;
22250Sstevel@tonic-gate 		soappendmsg(mp, &toh, sizeof (toh));
22260Sstevel@tonic-gate 		soappendmsg(mp, src, srclen);
22270Sstevel@tonic-gate 		mp->b_wptr += _TPI_ALIGN_TOPT(srclen) - srclen;
22280Sstevel@tonic-gate 		ASSERT(mp->b_wptr <= mp->b_datap->db_lim);
22290Sstevel@tonic-gate 	}
22300Sstevel@tonic-gate 	/*
22310Sstevel@tonic-gate 	 * Set SS_ISCONNECTING before sending down the T_CONN_REQ
22320Sstevel@tonic-gate 	 * in order to have the right state when the T_CONN_CON shows up.
22330Sstevel@tonic-gate 	 */
22340Sstevel@tonic-gate 	soisconnecting(so);
22350Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
22360Sstevel@tonic-gate 
22370Sstevel@tonic-gate #ifdef C2_AUDIT
22380Sstevel@tonic-gate 	if (audit_active)
22390Sstevel@tonic-gate 		audit_sock(T_CONN_REQ, strvp2wq(SOTOV(so)), mp, 0);
22400Sstevel@tonic-gate #endif /* C2_AUDIT */
22410Sstevel@tonic-gate 
22420Sstevel@tonic-gate 	error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
22430Sstevel@tonic-gate 			MSG_BAND|MSG_HOLDSIG|MSG_IGNERROR, 0);
22440Sstevel@tonic-gate 	mp = NULL;
22450Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
22460Sstevel@tonic-gate 	if (error != 0)
22470Sstevel@tonic-gate 		goto bad;
22480Sstevel@tonic-gate 
22490Sstevel@tonic-gate 	if ((error = sowaitokack(so, T_CONN_REQ)) != 0)
22500Sstevel@tonic-gate 		goto bad;
22510Sstevel@tonic-gate 
22520Sstevel@tonic-gate 	/* Allow other threads to access the socket */
22530Sstevel@tonic-gate 	so_unlock_single(so, SOLOCKED);
22540Sstevel@tonic-gate 	need_unlock = B_FALSE;
22550Sstevel@tonic-gate 
22560Sstevel@tonic-gate 	/*
22570Sstevel@tonic-gate 	 * Wait until we get a T_CONN_CON or an error
22580Sstevel@tonic-gate 	 */
22590Sstevel@tonic-gate 	if ((error = sowaitconnected(so, fflag, 0)) != 0) {
22600Sstevel@tonic-gate 		so_lock_single(so);	/* Set SOLOCKED */
22610Sstevel@tonic-gate 		need_unlock = B_TRUE;
22620Sstevel@tonic-gate 	}
22630Sstevel@tonic-gate 
22640Sstevel@tonic-gate done:
22650Sstevel@tonic-gate 	freemsg(mp);
22660Sstevel@tonic-gate 	switch (error) {
22670Sstevel@tonic-gate 	case EINPROGRESS:
22680Sstevel@tonic-gate 	case EALREADY:
22690Sstevel@tonic-gate 	case EISCONN:
22700Sstevel@tonic-gate 	case EINTR:
22710Sstevel@tonic-gate 		/* Non-fatal errors */
22720Sstevel@tonic-gate 		so->so_state &= ~SS_LADDR_VALID;
22730Sstevel@tonic-gate 		/* FALLTHRU */
22740Sstevel@tonic-gate 	case 0:
22750Sstevel@tonic-gate 		break;
22760Sstevel@tonic-gate 
22770Sstevel@tonic-gate 	case EHOSTUNREACH:
22780Sstevel@tonic-gate 		if (flags & _SOCONNECT_XPG4_2) {
22790Sstevel@tonic-gate 			/*
22800Sstevel@tonic-gate 			 * X/Open specification contains a requirement that
22810Sstevel@tonic-gate 			 * ENETUNREACH be returned but does not require
22820Sstevel@tonic-gate 			 * EHOSTUNREACH. In order to keep the test suite
22830Sstevel@tonic-gate 			 * happy we mess with the errno here.
22840Sstevel@tonic-gate 			 */
22850Sstevel@tonic-gate 			error = ENETUNREACH;
22860Sstevel@tonic-gate 		}
22870Sstevel@tonic-gate 		/* FALLTHRU */
22880Sstevel@tonic-gate 
22890Sstevel@tonic-gate 	default:
22900Sstevel@tonic-gate 		ASSERT(need_unlock);
22910Sstevel@tonic-gate 		/*
22920Sstevel@tonic-gate 		 * Fatal errors: clear SS_ISCONNECTING in case it was set,
22930Sstevel@tonic-gate 		 * and invalidate local-address cache
22940Sstevel@tonic-gate 		 */
22950Sstevel@tonic-gate 		so->so_state &= ~(SS_ISCONNECTING | SS_LADDR_VALID);
22960Sstevel@tonic-gate 		/* A discon_ind might have already unbound us */
22970Sstevel@tonic-gate 		if ((flags & _SOCONNECT_DID_BIND) &&
22980Sstevel@tonic-gate 		    (so->so_state & SS_ISBOUND)) {
22990Sstevel@tonic-gate 			int err;
23000Sstevel@tonic-gate 
23010Sstevel@tonic-gate 			err = sotpi_unbind(so, 0);
23020Sstevel@tonic-gate 			/* LINTED - statement has no conseq */
23030Sstevel@tonic-gate 			if (err) {
23040Sstevel@tonic-gate 				eprintsoline(so, err);
23050Sstevel@tonic-gate 			}
23060Sstevel@tonic-gate 		}
23070Sstevel@tonic-gate 		break;
23080Sstevel@tonic-gate 	}
23090Sstevel@tonic-gate 	if (need_unlock)
23100Sstevel@tonic-gate 		so_unlock_single(so, SOLOCKED);
23110Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
23120Sstevel@tonic-gate 	return (error);
23130Sstevel@tonic-gate 
23140Sstevel@tonic-gate so_bad:	error = sogeterr(so);
23150Sstevel@tonic-gate bad:	eprintsoline(so, error);
23160Sstevel@tonic-gate 	goto done;
23170Sstevel@tonic-gate }
23180Sstevel@tonic-gate 
23190Sstevel@tonic-gate int
23200Sstevel@tonic-gate sotpi_shutdown(struct sonode *so, int how)
23210Sstevel@tonic-gate {
23220Sstevel@tonic-gate 	struct T_ordrel_req	ordrel_req;
23230Sstevel@tonic-gate 	mblk_t			*mp;
23240Sstevel@tonic-gate 	uint_t			old_state, state_change;
23250Sstevel@tonic-gate 	int			error = 0;
23260Sstevel@tonic-gate 
23270Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_shutdown(%p, %d) %s\n",
23280Sstevel@tonic-gate 		so, how, pr_state(so->so_state, so->so_mode)));
23290Sstevel@tonic-gate 
23300Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
23310Sstevel@tonic-gate 	so_lock_single(so);	/* Set SOLOCKED */
23320Sstevel@tonic-gate 
23330Sstevel@tonic-gate 	/*
23340Sstevel@tonic-gate 	 * SunOS 4.X has no check for datagram sockets.
23350Sstevel@tonic-gate 	 * 5.X checks that it is connected (ENOTCONN)
23360Sstevel@tonic-gate 	 * X/Open requires that we check the connected state.
23370Sstevel@tonic-gate 	 */
23380Sstevel@tonic-gate 	if (!(so->so_state & SS_ISCONNECTED)) {
23390Sstevel@tonic-gate 		if (!xnet_skip_checks) {
23400Sstevel@tonic-gate 			error = ENOTCONN;
23410Sstevel@tonic-gate 			if (xnet_check_print) {
23420Sstevel@tonic-gate 				printf("sockfs: X/Open shutdown check "
23430Sstevel@tonic-gate 					"caused ENOTCONN\n");
23440Sstevel@tonic-gate 			}
23450Sstevel@tonic-gate 		}
23460Sstevel@tonic-gate 		goto done;
23470Sstevel@tonic-gate 	}
23480Sstevel@tonic-gate 	/*
23490Sstevel@tonic-gate 	 * Record the current state and then perform any state changes.
23500Sstevel@tonic-gate 	 * Then use the difference between the old and new states to
23510Sstevel@tonic-gate 	 * determine which messages need to be sent.
23520Sstevel@tonic-gate 	 * This prevents e.g. duplicate T_ORDREL_REQ when there are
23530Sstevel@tonic-gate 	 * duplicate calls to shutdown().
23540Sstevel@tonic-gate 	 */
23550Sstevel@tonic-gate 	old_state = so->so_state;
23560Sstevel@tonic-gate 
23570Sstevel@tonic-gate 	switch (how) {
23580Sstevel@tonic-gate 	case 0:
23590Sstevel@tonic-gate 		socantrcvmore(so);
23600Sstevel@tonic-gate 		break;
23610Sstevel@tonic-gate 	case 1:
23620Sstevel@tonic-gate 		socantsendmore(so);
23630Sstevel@tonic-gate 		break;
23640Sstevel@tonic-gate 	case 2:
23650Sstevel@tonic-gate 		socantsendmore(so);
23660Sstevel@tonic-gate 		socantrcvmore(so);
23670Sstevel@tonic-gate 		break;
23680Sstevel@tonic-gate 	default:
23690Sstevel@tonic-gate 		error = EINVAL;
23700Sstevel@tonic-gate 		goto done;
23710Sstevel@tonic-gate 	}
23720Sstevel@tonic-gate 
23730Sstevel@tonic-gate 	/*
23740Sstevel@tonic-gate 	 * Assumes that the SS_CANT* flags are never cleared in the above code.
23750Sstevel@tonic-gate 	 */
23760Sstevel@tonic-gate 	state_change = (so->so_state & (SS_CANTRCVMORE|SS_CANTSENDMORE)) -
23770Sstevel@tonic-gate 		(old_state & (SS_CANTRCVMORE|SS_CANTSENDMORE));
23780Sstevel@tonic-gate 	ASSERT((state_change & ~(SS_CANTRCVMORE|SS_CANTSENDMORE)) == 0);
23790Sstevel@tonic-gate 
23800Sstevel@tonic-gate 	switch (state_change) {
23810Sstevel@tonic-gate 	case 0:
23820Sstevel@tonic-gate 		dprintso(so, 1,
23830Sstevel@tonic-gate 		    ("sotpi_shutdown: nothing to send in state 0x%x\n",
23840Sstevel@tonic-gate 		    so->so_state));
23850Sstevel@tonic-gate 		goto done;
23860Sstevel@tonic-gate 
23870Sstevel@tonic-gate 	case SS_CANTRCVMORE:
23880Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
23890Sstevel@tonic-gate 		strseteof(SOTOV(so), 1);
23900Sstevel@tonic-gate 		/*
23910Sstevel@tonic-gate 		 * strseteof takes care of read side wakeups,
23920Sstevel@tonic-gate 		 * pollwakeups, and signals.
23930Sstevel@tonic-gate 		 */
23940Sstevel@tonic-gate 		/*
23950Sstevel@tonic-gate 		 * Get the read lock before flushing data to avoid problems
23960Sstevel@tonic-gate 		 * with the T_EXDATA_IND MSG_PEEK code in sotpi_recvmsg.
23970Sstevel@tonic-gate 		 */
23980Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
23990Sstevel@tonic-gate 		(void) so_lock_read(so, 0);	/* Set SOREADLOCKED */
24000Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
24010Sstevel@tonic-gate 
24020Sstevel@tonic-gate 		/* Flush read side queue */
24030Sstevel@tonic-gate 		strflushrq(SOTOV(so), FLUSHALL);
24040Sstevel@tonic-gate 
24050Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
24060Sstevel@tonic-gate 		so_unlock_read(so);		/* Clear SOREADLOCKED */
24070Sstevel@tonic-gate 		break;
24080Sstevel@tonic-gate 
24090Sstevel@tonic-gate 	case SS_CANTSENDMORE:
24100Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
24110Sstevel@tonic-gate 		strsetwerror(SOTOV(so), 0, 0, sogetwrerr);
24120Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
24130Sstevel@tonic-gate 		break;
24140Sstevel@tonic-gate 
24150Sstevel@tonic-gate 	case SS_CANTSENDMORE|SS_CANTRCVMORE:
24160Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
24170Sstevel@tonic-gate 		strsetwerror(SOTOV(so), 0, 0, sogetwrerr);
24180Sstevel@tonic-gate 		strseteof(SOTOV(so), 1);
24190Sstevel@tonic-gate 		/*
24200Sstevel@tonic-gate 		 * strseteof takes care of read side wakeups,
24210Sstevel@tonic-gate 		 * pollwakeups, and signals.
24220Sstevel@tonic-gate 		 */
24230Sstevel@tonic-gate 		/*
24240Sstevel@tonic-gate 		 * Get the read lock before flushing data to avoid problems
24250Sstevel@tonic-gate 		 * with the T_EXDATA_IND MSG_PEEK code in sotpi_recvmsg.
24260Sstevel@tonic-gate 		 */
24270Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
24280Sstevel@tonic-gate 		(void) so_lock_read(so, 0);	/* Set SOREADLOCKED */
24290Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
24300Sstevel@tonic-gate 
24310Sstevel@tonic-gate 		/* Flush read side queue */
24320Sstevel@tonic-gate 		strflushrq(SOTOV(so), FLUSHALL);
24330Sstevel@tonic-gate 
24340Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
24350Sstevel@tonic-gate 		so_unlock_read(so);		/* Clear SOREADLOCKED */
24360Sstevel@tonic-gate 		break;
24370Sstevel@tonic-gate 	}
24380Sstevel@tonic-gate 
24390Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
24400Sstevel@tonic-gate 
24410Sstevel@tonic-gate 	/*
24420Sstevel@tonic-gate 	 * If either SS_CANTSENDMORE or SS_CANTRCVMORE or both of them
24430Sstevel@tonic-gate 	 * was set due to this call and the new state has both of them set:
24440Sstevel@tonic-gate 	 *	Send the AF_UNIX close indication
24450Sstevel@tonic-gate 	 *	For T_COTS send a discon_ind
24460Sstevel@tonic-gate 	 *
24470Sstevel@tonic-gate 	 * If cantsend was set due to this call:
24480Sstevel@tonic-gate 	 *	For T_COTSORD send an ordrel_ind
24490Sstevel@tonic-gate 	 *
24500Sstevel@tonic-gate 	 * Note that for T_CLTS there is no message sent here.
24510Sstevel@tonic-gate 	 */
24520Sstevel@tonic-gate 	if ((so->so_state & (SS_CANTRCVMORE|SS_CANTSENDMORE)) ==
24530Sstevel@tonic-gate 	    (SS_CANTRCVMORE|SS_CANTSENDMORE)) {
24540Sstevel@tonic-gate 		/*
24550Sstevel@tonic-gate 		 * For SunOS 4.X compatibility we tell the other end
24560Sstevel@tonic-gate 		 * that we are unable to receive at this point.
24570Sstevel@tonic-gate 		 */
24580Sstevel@tonic-gate 		if (so->so_family == AF_UNIX && so->so_serv_type != T_CLTS)
24590Sstevel@tonic-gate 			so_unix_close(so);
24600Sstevel@tonic-gate 
24610Sstevel@tonic-gate 		if (so->so_serv_type == T_COTS)
24620Sstevel@tonic-gate 			error = sodisconnect(so, -1, _SODISCONNECT_LOCK_HELD);
24630Sstevel@tonic-gate 	}
24640Sstevel@tonic-gate 	if ((state_change & SS_CANTSENDMORE) &&
24650Sstevel@tonic-gate 	    (so->so_serv_type == T_COTS_ORD)) {
24660Sstevel@tonic-gate 		/* Send an orderly release */
24670Sstevel@tonic-gate 		ordrel_req.PRIM_type = T_ORDREL_REQ;
24680Sstevel@tonic-gate 
24690Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
24700Sstevel@tonic-gate 		mp = soallocproto1(&ordrel_req, sizeof (ordrel_req),
24710Sstevel@tonic-gate 		    0, _ALLOC_SLEEP);
24720Sstevel@tonic-gate 		/*
24730Sstevel@tonic-gate 		 * Send down the T_ORDREL_REQ even if there is flow control.
24740Sstevel@tonic-gate 		 * This prevents shutdown from blocking.
24750Sstevel@tonic-gate 		 * Note that there is no T_OK_ACK for ordrel_req.
24760Sstevel@tonic-gate 		 */
24770Sstevel@tonic-gate 		error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
24780Sstevel@tonic-gate 			MSG_BAND|MSG_HOLDSIG|MSG_IGNERROR|MSG_IGNFLOW, 0);
24790Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
24800Sstevel@tonic-gate 		if (error) {
24810Sstevel@tonic-gate 			eprintsoline(so, error);
24820Sstevel@tonic-gate 			goto done;
24830Sstevel@tonic-gate 		}
24840Sstevel@tonic-gate 	}
24850Sstevel@tonic-gate 
24860Sstevel@tonic-gate done:
24870Sstevel@tonic-gate 	so_unlock_single(so, SOLOCKED);
24880Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
24890Sstevel@tonic-gate 	return (error);
24900Sstevel@tonic-gate }
24910Sstevel@tonic-gate 
24920Sstevel@tonic-gate /*
24930Sstevel@tonic-gate  * For any connected SOCK_STREAM/SOCK_SEQPACKET AF_UNIX socket we send
24940Sstevel@tonic-gate  * a zero-length T_OPTDATA_REQ with the SO_UNIX_CLOSE option to inform the peer
24950Sstevel@tonic-gate  * that we have closed.
24960Sstevel@tonic-gate  * Also, for connected AF_UNIX SOCK_DGRAM sockets we send a zero-length
24970Sstevel@tonic-gate  * T_UNITDATA_REQ containing the same option.
24980Sstevel@tonic-gate  *
24990Sstevel@tonic-gate  * For SOCK_DGRAM half-connections (somebody connected to this end
25000Sstevel@tonic-gate  * but this end is not connect) we don't know where to send any
25010Sstevel@tonic-gate  * SO_UNIX_CLOSE.
25020Sstevel@tonic-gate  *
25030Sstevel@tonic-gate  * We have to ignore stream head errors just in case there has been
25040Sstevel@tonic-gate  * a shutdown(output).
25050Sstevel@tonic-gate  * Ignore any flow control to try to get the message more quickly to the peer.
25060Sstevel@tonic-gate  * While locally ignoring flow control solves the problem when there
25070Sstevel@tonic-gate  * is only the loopback transport on the stream it would not provide
25080Sstevel@tonic-gate  * the correct AF_UNIX socket semantics when one or more modules have
25090Sstevel@tonic-gate  * been pushed.
25100Sstevel@tonic-gate  */
25110Sstevel@tonic-gate void
25120Sstevel@tonic-gate so_unix_close(struct sonode *so)
25130Sstevel@tonic-gate {
25140Sstevel@tonic-gate 	int		error;
25150Sstevel@tonic-gate 	struct T_opthdr	toh;
25160Sstevel@tonic-gate 	mblk_t		*mp;
25170Sstevel@tonic-gate 
25180Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
25190Sstevel@tonic-gate 
25200Sstevel@tonic-gate 	ASSERT(so->so_family == AF_UNIX);
25210Sstevel@tonic-gate 
25220Sstevel@tonic-gate 	if ((so->so_state & (SS_ISCONNECTED|SS_ISBOUND)) !=
25230Sstevel@tonic-gate 	    (SS_ISCONNECTED|SS_ISBOUND))
25240Sstevel@tonic-gate 		return;
25250Sstevel@tonic-gate 
25260Sstevel@tonic-gate 	dprintso(so, 1, ("so_unix_close(%p) %s\n",
25270Sstevel@tonic-gate 		so, pr_state(so->so_state, so->so_mode)));
25280Sstevel@tonic-gate 
25290Sstevel@tonic-gate 	toh.level = SOL_SOCKET;
25300Sstevel@tonic-gate 	toh.name = SO_UNIX_CLOSE;
25310Sstevel@tonic-gate 
25320Sstevel@tonic-gate 	/* zero length + header */
25330Sstevel@tonic-gate 	toh.len = (t_uscalar_t)sizeof (struct T_opthdr);
25340Sstevel@tonic-gate 	toh.status = 0;
25350Sstevel@tonic-gate 
25360Sstevel@tonic-gate 	if (so->so_type == SOCK_STREAM || so->so_type == SOCK_SEQPACKET) {
25370Sstevel@tonic-gate 		struct T_optdata_req tdr;
25380Sstevel@tonic-gate 
25390Sstevel@tonic-gate 		tdr.PRIM_type = T_OPTDATA_REQ;
25400Sstevel@tonic-gate 		tdr.DATA_flag = 0;
25410Sstevel@tonic-gate 
25420Sstevel@tonic-gate 		tdr.OPT_length = (t_scalar_t)sizeof (toh);
25430Sstevel@tonic-gate 		tdr.OPT_offset = (t_scalar_t)sizeof (tdr);
25440Sstevel@tonic-gate 
25450Sstevel@tonic-gate 		/* NOTE: holding so_lock while sleeping */
25460Sstevel@tonic-gate 		mp = soallocproto2(&tdr, sizeof (tdr),
25470Sstevel@tonic-gate 		    &toh, sizeof (toh), 0, _ALLOC_SLEEP);
25480Sstevel@tonic-gate 	} else {
25490Sstevel@tonic-gate 		struct T_unitdata_req	tudr;
25500Sstevel@tonic-gate 		void			*addr;
25510Sstevel@tonic-gate 		socklen_t		addrlen;
25520Sstevel@tonic-gate 		void			*src;
25530Sstevel@tonic-gate 		socklen_t		srclen;
25540Sstevel@tonic-gate 		struct T_opthdr		toh2;
25550Sstevel@tonic-gate 		t_scalar_t		size;
25560Sstevel@tonic-gate 
25570Sstevel@tonic-gate 		/* Connecteded DGRAM socket */
25580Sstevel@tonic-gate 
25590Sstevel@tonic-gate 		/*
25600Sstevel@tonic-gate 		 * For AF_UNIX the destination address is translated to
25610Sstevel@tonic-gate 		 * an internal name and the source address is passed as
25620Sstevel@tonic-gate 		 * an option.
25630Sstevel@tonic-gate 		 */
25640Sstevel@tonic-gate 		/*
25650Sstevel@tonic-gate 		 * Length and family checks.
25660Sstevel@tonic-gate 		 */
25670Sstevel@tonic-gate 		error = so_addr_verify(so, so->so_faddr_sa,
25680Sstevel@tonic-gate 					(t_uscalar_t)so->so_faddr_len);
25690Sstevel@tonic-gate 		if (error) {
25700Sstevel@tonic-gate 			eprintsoline(so, error);
25710Sstevel@tonic-gate 			return;
25720Sstevel@tonic-gate 		}
25730Sstevel@tonic-gate 		if (so->so_state & SS_FADDR_NOXLATE) {
25740Sstevel@tonic-gate 			/*
25750Sstevel@tonic-gate 			 * Already have a transport internal address. Do not
25760Sstevel@tonic-gate 			 * pass any (transport internal) source address.
25770Sstevel@tonic-gate 			 */
25780Sstevel@tonic-gate 			addr = so->so_faddr_sa;
25790Sstevel@tonic-gate 			addrlen = (t_uscalar_t)so->so_faddr_len;
25800Sstevel@tonic-gate 			src = NULL;
25810Sstevel@tonic-gate 			srclen = 0;
25820Sstevel@tonic-gate 		} else {
25830Sstevel@tonic-gate 			/*
25840Sstevel@tonic-gate 			 * Pass the sockaddr_un source address as an option
25850Sstevel@tonic-gate 			 * and translate the remote address.
25860Sstevel@tonic-gate 			 * Holding so_lock thus so_laddr_sa can not change.
25870Sstevel@tonic-gate 			 */
25880Sstevel@tonic-gate 			src = so->so_laddr_sa;
25890Sstevel@tonic-gate 			srclen = (socklen_t)so->so_laddr_len;
25900Sstevel@tonic-gate 			dprintso(so, 1,
25910Sstevel@tonic-gate 				("so_ux_close: srclen %d, src %p\n",
25920Sstevel@tonic-gate 				srclen, src));
25930Sstevel@tonic-gate 			error = so_ux_addr_xlate(so,
25940Sstevel@tonic-gate 				so->so_faddr_sa,
25950Sstevel@tonic-gate 				(socklen_t)so->so_faddr_len, 0,
25960Sstevel@tonic-gate 				&addr, &addrlen);
25970Sstevel@tonic-gate 			if (error) {
25980Sstevel@tonic-gate 				eprintsoline(so, error);
25990Sstevel@tonic-gate 				return;
26000Sstevel@tonic-gate 			}
26010Sstevel@tonic-gate 		}
26020Sstevel@tonic-gate 		tudr.PRIM_type = T_UNITDATA_REQ;
26030Sstevel@tonic-gate 		tudr.DEST_length = addrlen;
26040Sstevel@tonic-gate 		tudr.DEST_offset = (t_scalar_t)sizeof (tudr);
26050Sstevel@tonic-gate 		if (srclen == 0) {
26060Sstevel@tonic-gate 			tudr.OPT_length = (t_scalar_t)sizeof (toh);
26070Sstevel@tonic-gate 			tudr.OPT_offset = (t_scalar_t)(sizeof (tudr) +
26080Sstevel@tonic-gate 				_TPI_ALIGN_TOPT(addrlen));
26090Sstevel@tonic-gate 
26100Sstevel@tonic-gate 			size = tudr.OPT_offset + tudr.OPT_length;
26110Sstevel@tonic-gate 			/* NOTE: holding so_lock while sleeping */
26120Sstevel@tonic-gate 			mp = soallocproto2(&tudr, sizeof (tudr),
26130Sstevel@tonic-gate 			    addr, addrlen, size, _ALLOC_SLEEP);
26140Sstevel@tonic-gate 			mp->b_wptr += (_TPI_ALIGN_TOPT(addrlen) - addrlen);
26150Sstevel@tonic-gate 			soappendmsg(mp, &toh, sizeof (toh));
26160Sstevel@tonic-gate 		} else {
26170Sstevel@tonic-gate 			/*
26180Sstevel@tonic-gate 			 * There is a AF_UNIX sockaddr_un to include as a
26190Sstevel@tonic-gate 			 * source address option.
26200Sstevel@tonic-gate 			 */
26210Sstevel@tonic-gate 			tudr.OPT_length = (t_scalar_t)(2 * sizeof (toh) +
26220Sstevel@tonic-gate 			    _TPI_ALIGN_TOPT(srclen));
26230Sstevel@tonic-gate 			tudr.OPT_offset = (t_scalar_t)(sizeof (tudr) +
26240Sstevel@tonic-gate 			    _TPI_ALIGN_TOPT(addrlen));
26250Sstevel@tonic-gate 
26260Sstevel@tonic-gate 			toh2.level = SOL_SOCKET;
26270Sstevel@tonic-gate 			toh2.name = SO_SRCADDR;
26280Sstevel@tonic-gate 			toh2.len = (t_uscalar_t)(srclen +
26290Sstevel@tonic-gate 					sizeof (struct T_opthdr));
26300Sstevel@tonic-gate 			toh2.status = 0;
26310Sstevel@tonic-gate 
26320Sstevel@tonic-gate 			size = tudr.OPT_offset + tudr.OPT_length;
26330Sstevel@tonic-gate 
26340Sstevel@tonic-gate 			/* NOTE: holding so_lock while sleeping */
26350Sstevel@tonic-gate 			mp = soallocproto2(&tudr, sizeof (tudr),
26360Sstevel@tonic-gate 			    addr, addrlen, size, _ALLOC_SLEEP);
26370Sstevel@tonic-gate 			mp->b_wptr += _TPI_ALIGN_TOPT(addrlen) - addrlen;
26380Sstevel@tonic-gate 			soappendmsg(mp, &toh, sizeof (toh));
26390Sstevel@tonic-gate 			soappendmsg(mp, &toh2, sizeof (toh2));
26400Sstevel@tonic-gate 			soappendmsg(mp, src, srclen);
26410Sstevel@tonic-gate 			mp->b_wptr += _TPI_ALIGN_TOPT(srclen) - srclen;
26420Sstevel@tonic-gate 		}
26430Sstevel@tonic-gate 		ASSERT(mp->b_wptr <= mp->b_datap->db_lim);
26440Sstevel@tonic-gate 	}
26450Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
26460Sstevel@tonic-gate 	error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
26470Sstevel@tonic-gate 			MSG_BAND|MSG_HOLDSIG|MSG_IGNERROR|MSG_IGNFLOW, 0);
26480Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
26490Sstevel@tonic-gate }
26500Sstevel@tonic-gate 
26510Sstevel@tonic-gate /*
26520Sstevel@tonic-gate  * Handle recv* calls that set MSG_OOB or MSG_OOB together with MSG_PEEK.
26530Sstevel@tonic-gate  */
26540Sstevel@tonic-gate int
26550Sstevel@tonic-gate sorecvoob(struct sonode *so, struct nmsghdr *msg, struct uio *uiop, int flags)
26560Sstevel@tonic-gate {
26570Sstevel@tonic-gate 	mblk_t		*mp, *nmp;
26580Sstevel@tonic-gate 	int		error;
26590Sstevel@tonic-gate 
26600Sstevel@tonic-gate 	dprintso(so, 1, ("sorecvoob(%p, %p, 0x%x)\n", so, msg, flags));
26610Sstevel@tonic-gate 
26620Sstevel@tonic-gate 	/*
26630Sstevel@tonic-gate 	 * There is never any oob data with addresses or control since
26640Sstevel@tonic-gate 	 * the T_EXDATA_IND does not carry any options.
26650Sstevel@tonic-gate 	 */
26660Sstevel@tonic-gate 	msg->msg_controllen = 0;
26670Sstevel@tonic-gate 	msg->msg_namelen = 0;
26680Sstevel@tonic-gate 
26690Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
26700Sstevel@tonic-gate 	ASSERT(so_verify_oobstate(so));
26710Sstevel@tonic-gate 	if ((so->so_options & SO_OOBINLINE) ||
26720Sstevel@tonic-gate 	    (so->so_state & (SS_OOBPEND|SS_HADOOBDATA)) != SS_OOBPEND) {
26730Sstevel@tonic-gate 		dprintso(so, 1, ("sorecvoob: inline or data consumed\n"));
26740Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
26750Sstevel@tonic-gate 		return (EINVAL);
26760Sstevel@tonic-gate 	}
26770Sstevel@tonic-gate 	if (!(so->so_state & SS_HAVEOOBDATA)) {
26780Sstevel@tonic-gate 		dprintso(so, 1, ("sorecvoob: no data yet\n"));
26790Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
26800Sstevel@tonic-gate 		return (EWOULDBLOCK);
26810Sstevel@tonic-gate 	}
26820Sstevel@tonic-gate 	ASSERT(so->so_oobmsg != NULL);
26830Sstevel@tonic-gate 	mp = so->so_oobmsg;
26840Sstevel@tonic-gate 	if (flags & MSG_PEEK) {
26850Sstevel@tonic-gate 		/*
26860Sstevel@tonic-gate 		 * Since recv* can not return ENOBUFS we can not use dupmsg.
26870Sstevel@tonic-gate 		 * Instead we revert to the consolidation private
26880Sstevel@tonic-gate 		 * allocb_wait plus bcopy.
26890Sstevel@tonic-gate 		 */
26900Sstevel@tonic-gate 		mblk_t *mp1;
26910Sstevel@tonic-gate 
26920Sstevel@tonic-gate 		mp1 = allocb_wait(msgdsize(mp), BPRI_MED, STR_NOSIG, NULL);
26930Sstevel@tonic-gate 		ASSERT(mp1);
26940Sstevel@tonic-gate 
26950Sstevel@tonic-gate 		while (mp != NULL) {
26960Sstevel@tonic-gate 			ssize_t size;
26970Sstevel@tonic-gate 
26980Sstevel@tonic-gate 			size = MBLKL(mp);
26990Sstevel@tonic-gate 			bcopy(mp->b_rptr, mp1->b_wptr, size);
27000Sstevel@tonic-gate 			mp1->b_wptr += size;
27010Sstevel@tonic-gate 			ASSERT(mp1->b_wptr <= mp1->b_datap->db_lim);
27020Sstevel@tonic-gate 			mp = mp->b_cont;
27030Sstevel@tonic-gate 		}
27040Sstevel@tonic-gate 		mp = mp1;
27050Sstevel@tonic-gate 	} else {
27060Sstevel@tonic-gate 		/*
27070Sstevel@tonic-gate 		 * Update the state indicating that the data has been consumed.
27080Sstevel@tonic-gate 		 * Keep SS_OOBPEND set until data is consumed past the mark.
27090Sstevel@tonic-gate 		 */
27100Sstevel@tonic-gate 		so->so_oobmsg = NULL;
27110Sstevel@tonic-gate 		so->so_state ^= SS_HAVEOOBDATA|SS_HADOOBDATA;
27120Sstevel@tonic-gate 	}
27130Sstevel@tonic-gate 	dprintso(so, 1,
27140Sstevel@tonic-gate 		("after recvoob(%p): counts %d/%d state %s\n",
27150Sstevel@tonic-gate 		so, so->so_oobsigcnt,
27160Sstevel@tonic-gate 		so->so_oobcnt, pr_state(so->so_state, so->so_mode)));
27170Sstevel@tonic-gate 	ASSERT(so_verify_oobstate(so));
27180Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
27190Sstevel@tonic-gate 
27200Sstevel@tonic-gate 	error = 0;
27210Sstevel@tonic-gate 	nmp = mp;
27220Sstevel@tonic-gate 	while (nmp != NULL && uiop->uio_resid > 0) {
27230Sstevel@tonic-gate 		ssize_t n = MBLKL(nmp);
27240Sstevel@tonic-gate 
27250Sstevel@tonic-gate 		n = MIN(n, uiop->uio_resid);
27260Sstevel@tonic-gate 		if (n > 0)
27270Sstevel@tonic-gate 			error = uiomove(nmp->b_rptr, n,
27280Sstevel@tonic-gate 					UIO_READ, uiop);
27290Sstevel@tonic-gate 		if (error)
27300Sstevel@tonic-gate 			break;
27310Sstevel@tonic-gate 		nmp = nmp->b_cont;
27320Sstevel@tonic-gate 	}
27330Sstevel@tonic-gate 	freemsg(mp);
27340Sstevel@tonic-gate 	return (error);
27350Sstevel@tonic-gate }
27360Sstevel@tonic-gate 
27370Sstevel@tonic-gate /*
27380Sstevel@tonic-gate  * Called by sotpi_recvmsg when reading a non-zero amount of data.
27390Sstevel@tonic-gate  * In addition, the caller typically verifies that there is some
27400Sstevel@tonic-gate  * potential state to clear by checking
27410Sstevel@tonic-gate  *	if (so->so_state & (SS_OOBPEND|SS_HAVEOOBDATA|SS_RCVATMARK))
27420Sstevel@tonic-gate  * before calling this routine.
27430Sstevel@tonic-gate  * Note that such a check can be made without holding so_lock since
27440Sstevel@tonic-gate  * sotpi_recvmsg is single-threaded (using SOREADLOCKED) and only sotpi_recvmsg
27450Sstevel@tonic-gate  * decrements so_oobsigcnt.
27460Sstevel@tonic-gate  *
27470Sstevel@tonic-gate  * When data is read *after* the point that all pending
27480Sstevel@tonic-gate  * oob data has been consumed the oob indication is cleared.
27490Sstevel@tonic-gate  *
27500Sstevel@tonic-gate  * This logic keeps select/poll returning POLLRDBAND and
27510Sstevel@tonic-gate  * SIOCATMARK returning true until we have read past
27520Sstevel@tonic-gate  * the mark.
27530Sstevel@tonic-gate  */
27540Sstevel@tonic-gate static void
27550Sstevel@tonic-gate sorecv_update_oobstate(struct sonode *so)
27560Sstevel@tonic-gate {
27570Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
27580Sstevel@tonic-gate 	ASSERT(so_verify_oobstate(so));
27590Sstevel@tonic-gate 	dprintso(so, 1,
27600Sstevel@tonic-gate 		("sorecv_update_oobstate: counts %d/%d state %s\n",
27610Sstevel@tonic-gate 		so->so_oobsigcnt,
27620Sstevel@tonic-gate 		so->so_oobcnt, pr_state(so->so_state, so->so_mode)));
27630Sstevel@tonic-gate 	if (so->so_oobsigcnt == 0) {
27640Sstevel@tonic-gate 		/* No more pending oob indications */
27650Sstevel@tonic-gate 		so->so_state &= ~(SS_OOBPEND|SS_HAVEOOBDATA|SS_RCVATMARK);
27660Sstevel@tonic-gate 		freemsg(so->so_oobmsg);
27670Sstevel@tonic-gate 		so->so_oobmsg = NULL;
27680Sstevel@tonic-gate 	}
27690Sstevel@tonic-gate 	ASSERT(so_verify_oobstate(so));
27700Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
27710Sstevel@tonic-gate }
27720Sstevel@tonic-gate 
27730Sstevel@tonic-gate /*
27740Sstevel@tonic-gate  * Handle recv* calls for an so which has NL7C saved recv mblk_t(s).
27750Sstevel@tonic-gate  */
27760Sstevel@tonic-gate static int
27770Sstevel@tonic-gate nl7c_sorecv(struct sonode *so, mblk_t **rmp, uio_t *uiop, rval_t *rp)
27780Sstevel@tonic-gate {
27790Sstevel@tonic-gate 	int	error = 0;
27800Sstevel@tonic-gate 	mblk_t *tmp = NULL;
27810Sstevel@tonic-gate 	mblk_t *pmp = NULL;
27820Sstevel@tonic-gate 	mblk_t *nmp = so->so_nl7c_rcv_mp;
27830Sstevel@tonic-gate 
27840Sstevel@tonic-gate 	ASSERT(nmp != NULL);
27850Sstevel@tonic-gate 
27860Sstevel@tonic-gate 	while (nmp != NULL && uiop->uio_resid > 0) {
27870Sstevel@tonic-gate 		ssize_t n;
27880Sstevel@tonic-gate 
27890Sstevel@tonic-gate 		if (DB_TYPE(nmp) == M_DATA) {
27900Sstevel@tonic-gate 			/*
27910Sstevel@tonic-gate 			 * We have some data, uiomove up to resid bytes.
27920Sstevel@tonic-gate 			 */
27930Sstevel@tonic-gate 			n = MIN(MBLKL(nmp), uiop->uio_resid);
27940Sstevel@tonic-gate 			if (n > 0)
27950Sstevel@tonic-gate 				error = uiomove(nmp->b_rptr, n, UIO_READ, uiop);
27960Sstevel@tonic-gate 			if (error)
27970Sstevel@tonic-gate 				break;
27980Sstevel@tonic-gate 			nmp->b_rptr += n;
27990Sstevel@tonic-gate 			if (nmp->b_rptr == nmp->b_wptr) {
28000Sstevel@tonic-gate 				pmp = nmp;
28010Sstevel@tonic-gate 				nmp = nmp->b_cont;
28020Sstevel@tonic-gate 			}
28030Sstevel@tonic-gate 		} else {
28040Sstevel@tonic-gate 			/*
28050Sstevel@tonic-gate 			 * We only handle data, save for caller to handle.
28060Sstevel@tonic-gate 			 */
28070Sstevel@tonic-gate 			if (pmp != NULL) {
28080Sstevel@tonic-gate 				pmp->b_cont = nmp->b_cont;
28090Sstevel@tonic-gate 			}
28100Sstevel@tonic-gate 			nmp->b_cont = NULL;
28110Sstevel@tonic-gate 			if (*rmp == NULL) {
28120Sstevel@tonic-gate 				*rmp = nmp;
28130Sstevel@tonic-gate 			} else {
28140Sstevel@tonic-gate 				tmp->b_next = nmp;
28150Sstevel@tonic-gate 			}
28160Sstevel@tonic-gate 			nmp = nmp->b_cont;
28170Sstevel@tonic-gate 			tmp = nmp;
28180Sstevel@tonic-gate 		}
28190Sstevel@tonic-gate 	}
28200Sstevel@tonic-gate 	if (pmp != NULL) {
28210Sstevel@tonic-gate 		/* Free any mblk_t(s) which we have consumed */
28220Sstevel@tonic-gate 		pmp->b_cont = NULL;
28230Sstevel@tonic-gate 		freemsg(so->so_nl7c_rcv_mp);
28240Sstevel@tonic-gate 	}
28250Sstevel@tonic-gate 	if ((so->so_nl7c_rcv_mp = nmp) == NULL) {
28260Sstevel@tonic-gate 		/* Last mblk_t so return the saved rval from kstrgetmsg() */
28270Sstevel@tonic-gate 		rp->r_vals = so->so_nl7c_rcv_rval;
28280Sstevel@tonic-gate 		so->so_nl7c_rcv_rval = 0;
28290Sstevel@tonic-gate 	} else {
28300Sstevel@tonic-gate 		/* More mblk_t(s) to process so no rval to return */
28310Sstevel@tonic-gate 		rp->r_vals = 0;
28320Sstevel@tonic-gate 	}
28330Sstevel@tonic-gate 	return (error);
28340Sstevel@tonic-gate }
28350Sstevel@tonic-gate 
28360Sstevel@tonic-gate /*
28370Sstevel@tonic-gate  * Receive the next message on the queue.
28380Sstevel@tonic-gate  * If msg_controllen is non-zero when called the caller is interested in
28390Sstevel@tonic-gate  * any received control info (options).
28400Sstevel@tonic-gate  * If msg_namelen is non-zero when called the caller is interested in
28410Sstevel@tonic-gate  * any received source address.
28420Sstevel@tonic-gate  * The routine returns with msg_control and msg_name pointing to
28430Sstevel@tonic-gate  * kmem_alloc'ed memory which the caller has to free.
28440Sstevel@tonic-gate  */
28450Sstevel@tonic-gate int
28460Sstevel@tonic-gate sotpi_recvmsg(struct sonode *so, struct nmsghdr *msg, struct uio *uiop)
28470Sstevel@tonic-gate {
28480Sstevel@tonic-gate 	union T_primitives	*tpr;
28490Sstevel@tonic-gate 	mblk_t			*mp;
28500Sstevel@tonic-gate 	uchar_t			pri;
28510Sstevel@tonic-gate 	int			pflag, opflag;
28520Sstevel@tonic-gate 	void			*control;
28530Sstevel@tonic-gate 	t_uscalar_t		controllen;
28540Sstevel@tonic-gate 	t_uscalar_t		namelen;
28550Sstevel@tonic-gate 	int			so_state = so->so_state; /* Snapshot */
28560Sstevel@tonic-gate 	ssize_t			saved_resid;
28570Sstevel@tonic-gate 	int			error;
28580Sstevel@tonic-gate 	rval_t			rval;
28590Sstevel@tonic-gate 	int			flags;
28600Sstevel@tonic-gate 	clock_t			timout;
28610Sstevel@tonic-gate 	int			first;
28620Sstevel@tonic-gate 
28630Sstevel@tonic-gate 	flags = msg->msg_flags;
28640Sstevel@tonic-gate 	msg->msg_flags = 0;
28650Sstevel@tonic-gate 
28660Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_recvmsg(%p, %p, 0x%x) state %s err %d\n",
28670Sstevel@tonic-gate 		so, msg, flags,
28680Sstevel@tonic-gate 		pr_state(so->so_state, so->so_mode), so->so_error));
28690Sstevel@tonic-gate 
28700Sstevel@tonic-gate 	/*
28710Sstevel@tonic-gate 	 * If we are not connected because we have never been connected
28720Sstevel@tonic-gate 	 * we return ENOTCONN. If we have been connected (but are no longer
28730Sstevel@tonic-gate 	 * connected) then SS_CANTRCVMORE is set and we let kstrgetmsg return
28740Sstevel@tonic-gate 	 * the EOF.
28750Sstevel@tonic-gate 	 *
28760Sstevel@tonic-gate 	 * An alternative would be to post an ENOTCONN error in stream head
28770Sstevel@tonic-gate 	 * (read+write) and clear it when we're connected. However, that error
28780Sstevel@tonic-gate 	 * would cause incorrect poll/select behavior!
28790Sstevel@tonic-gate 	 */
28800Sstevel@tonic-gate 	if ((so_state & (SS_ISCONNECTED|SS_CANTRCVMORE)) == 0 &&
28810Sstevel@tonic-gate 	    (so->so_mode & SM_CONNREQUIRED)) {
28820Sstevel@tonic-gate 		return (ENOTCONN);
28830Sstevel@tonic-gate 	}
28840Sstevel@tonic-gate 
28850Sstevel@tonic-gate 	/*
28860Sstevel@tonic-gate 	 * Note: SunOS 4.X checks uio_resid == 0 before going to sleep (but
28870Sstevel@tonic-gate 	 * after checking that the read queue is empty) and returns zero.
28880Sstevel@tonic-gate 	 * This implementation will sleep (in kstrgetmsg) even if uio_resid
28890Sstevel@tonic-gate 	 * is zero.
28900Sstevel@tonic-gate 	 */
28910Sstevel@tonic-gate 
28920Sstevel@tonic-gate 	if (flags & MSG_OOB) {
28930Sstevel@tonic-gate 		/* Check that the transport supports OOB */
28940Sstevel@tonic-gate 		if (!(so->so_mode & SM_EXDATA))
28950Sstevel@tonic-gate 			return (EOPNOTSUPP);
28960Sstevel@tonic-gate 		return (sorecvoob(so, msg, uiop, flags));
28970Sstevel@tonic-gate 	}
28980Sstevel@tonic-gate 
28990Sstevel@tonic-gate 	/*
29000Sstevel@tonic-gate 	 * Set msg_controllen and msg_namelen to zero here to make it
29010Sstevel@tonic-gate 	 * simpler in the cases that no control or name is returned.
29020Sstevel@tonic-gate 	 */
29030Sstevel@tonic-gate 	controllen = msg->msg_controllen;
29040Sstevel@tonic-gate 	namelen = msg->msg_namelen;
29050Sstevel@tonic-gate 	msg->msg_controllen = 0;
29060Sstevel@tonic-gate 	msg->msg_namelen = 0;
29070Sstevel@tonic-gate 
29080Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_recvmsg: namelen %d controllen %d\n",
29090Sstevel@tonic-gate 		namelen, controllen));
29100Sstevel@tonic-gate 
29110Sstevel@tonic-gate 	/*
29120Sstevel@tonic-gate 	 * If an NL7C enabled socket and not waiting for write data.
29130Sstevel@tonic-gate 	 */
29140Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
29150Sstevel@tonic-gate 	if ((so->so_nl7c_flags & (NL7C_ENABLED|NL7C_WAITWRITE)) ==
29160Sstevel@tonic-gate 	    NL7C_ENABLED) {
29170Sstevel@tonic-gate 		if (so->so_nl7c_uri) {
29180Sstevel@tonic-gate 			/*
29190Sstevel@tonic-gate 			 * Close uri processing for a previous request.
29200Sstevel@tonic-gate 			 */
29210Sstevel@tonic-gate 			nl7c_close(so);
29220Sstevel@tonic-gate 		}
29230Sstevel@tonic-gate 		if (nl7c_process(so,
29240Sstevel@tonic-gate 		    (so->so_state & (SS_NONBLOCK|SS_NDELAY)),
29250Sstevel@tonic-gate 		    (int)((tcp_t *)so->so_priv)->tcp_mss)) {
29260Sstevel@tonic-gate 			/*
29270Sstevel@tonic-gate 			 * NL7C has completed processing on the socket,
29280Sstevel@tonic-gate 			 * clear the enabled bit as no further NL7C
29290Sstevel@tonic-gate 			 * processing will be needed.
29300Sstevel@tonic-gate 			 */
29310Sstevel@tonic-gate 			so->so_nl7c_flags = 0;
29320Sstevel@tonic-gate 		}
29330Sstevel@tonic-gate 	}
29340Sstevel@tonic-gate 
29350Sstevel@tonic-gate 	/*
29360Sstevel@tonic-gate 	 * Only one reader is allowed at any given time. This is needed
29370Sstevel@tonic-gate 	 * for T_EXDATA handling and, in the future, MSG_WAITALL.
29380Sstevel@tonic-gate 	 *
29390Sstevel@tonic-gate 	 * This is slightly different that BSD behavior in that it fails with
29400Sstevel@tonic-gate 	 * EWOULDBLOCK when using nonblocking io. In BSD the read queue access
29410Sstevel@tonic-gate 	 * is single-threaded using sblock(), which is dropped while waiting
29420Sstevel@tonic-gate 	 * for data to appear. The difference shows up e.g. if one
29430Sstevel@tonic-gate 	 * file descriptor does not have O_NONBLOCK but a dup'ed file descriptor
29440Sstevel@tonic-gate 	 * does use nonblocking io and different threads are reading each
29450Sstevel@tonic-gate 	 * file descriptor. In BSD there would never be an EWOULDBLOCK error
29460Sstevel@tonic-gate 	 * in this case as long as the read queue doesn't get empty.
29470Sstevel@tonic-gate 	 * In this implementation the thread using nonblocking io can
29480Sstevel@tonic-gate 	 * get an EWOULDBLOCK error due to the blocking thread executing
29490Sstevel@tonic-gate 	 * e.g. in the uiomove in kstrgetmsg.
29500Sstevel@tonic-gate 	 * This difference is not believed to be significant.
29510Sstevel@tonic-gate 	 */
29520Sstevel@tonic-gate 	error = so_lock_read_intr(so, uiop->uio_fmode);	/* Set SOREADLOCKED */
29530Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
29540Sstevel@tonic-gate 	if (error)
29550Sstevel@tonic-gate 		return (error);
29560Sstevel@tonic-gate 
29570Sstevel@tonic-gate 	/*
29580Sstevel@tonic-gate 	 * Tell kstrgetmsg to not inspect the stream head errors until all
29590Sstevel@tonic-gate 	 * queued data has been consumed.
29600Sstevel@tonic-gate 	 * Use a timeout=-1 to wait forever unless MSG_DONTWAIT is set.
29610Sstevel@tonic-gate 	 * Also, If uio_fmode indicates nonblocking kstrgetmsg will not block.
29620Sstevel@tonic-gate 	 *
29630Sstevel@tonic-gate 	 * MSG_WAITALL only applies to M_DATA and T_DATA_IND messages and
29640Sstevel@tonic-gate 	 * to T_OPTDATA_IND that do not contain any user-visible control msg.
29650Sstevel@tonic-gate 	 * Note that MSG_WAITALL set with MSG_PEEK is a noop.
29660Sstevel@tonic-gate 	 */
29670Sstevel@tonic-gate 	pflag = MSG_ANY | MSG_DELAYERROR;
29680Sstevel@tonic-gate 	if (flags & MSG_PEEK) {
29690Sstevel@tonic-gate 		pflag |= MSG_IPEEK;
29700Sstevel@tonic-gate 		flags &= ~MSG_WAITALL;
29710Sstevel@tonic-gate 	}
29720Sstevel@tonic-gate 	if (so->so_mode & SM_ATOMIC)
29730Sstevel@tonic-gate 		pflag |= MSG_DISCARDTAIL;
29740Sstevel@tonic-gate 
29750Sstevel@tonic-gate 	if (flags & MSG_DONTWAIT)
29760Sstevel@tonic-gate 		timout = 0;
29770Sstevel@tonic-gate 	else
29780Sstevel@tonic-gate 		timout = -1;
29790Sstevel@tonic-gate 	opflag = pflag;
29800Sstevel@tonic-gate 	first = 1;
29810Sstevel@tonic-gate 
29820Sstevel@tonic-gate 	/*
29830Sstevel@tonic-gate 	 * If so saved NL7C rcv mblk_t(s) uiomove them first
29840Sstevel@tonic-gate 	 * else get'm from the streamhead.
29850Sstevel@tonic-gate 	 */
29860Sstevel@tonic-gate retry:
29870Sstevel@tonic-gate 	saved_resid = uiop->uio_resid;
29880Sstevel@tonic-gate 	pri = 0;
29890Sstevel@tonic-gate 	mp = NULL;
29900Sstevel@tonic-gate 	if (so->so_nl7c_rcv_mp != NULL) {
29910Sstevel@tonic-gate 		error = nl7c_sorecv(so, &mp, uiop, &rval);
29920Sstevel@tonic-gate 	} else {
29930Sstevel@tonic-gate 		error = kstrgetmsg(SOTOV(so), &mp, uiop, &pri, &pflag,
29940Sstevel@tonic-gate 		    timout, &rval);
29950Sstevel@tonic-gate 	}
29960Sstevel@tonic-gate 	if (error) {
29970Sstevel@tonic-gate 		switch (error) {
29980Sstevel@tonic-gate 		case EINTR:
29990Sstevel@tonic-gate 		case EWOULDBLOCK:
30000Sstevel@tonic-gate 			if (!first)
30010Sstevel@tonic-gate 				error = 0;
30020Sstevel@tonic-gate 			break;
30030Sstevel@tonic-gate 		case ETIME:
30040Sstevel@tonic-gate 			/* Returned from kstrgetmsg when timeout expires */
30050Sstevel@tonic-gate 			if (!first)
30060Sstevel@tonic-gate 				error = 0;
30070Sstevel@tonic-gate 			else
30080Sstevel@tonic-gate 				error = EWOULDBLOCK;
30090Sstevel@tonic-gate 			break;
30100Sstevel@tonic-gate 		default:
30110Sstevel@tonic-gate 			eprintsoline(so, error);
30120Sstevel@tonic-gate 			break;
30130Sstevel@tonic-gate 		}
30140Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
30150Sstevel@tonic-gate 		so_unlock_read(so);	/* Clear SOREADLOCKED */
30160Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
30170Sstevel@tonic-gate 		return (error);
30180Sstevel@tonic-gate 	}
30190Sstevel@tonic-gate 	/*
30200Sstevel@tonic-gate 	 * For datagrams the MOREDATA flag is used to set MSG_TRUNC.
30210Sstevel@tonic-gate 	 * For non-datagrams MOREDATA is used to set MSG_EOR.
30220Sstevel@tonic-gate 	 */
30230Sstevel@tonic-gate 	ASSERT(!(rval.r_val1 & MORECTL));
30240Sstevel@tonic-gate 	if ((rval.r_val1 & MOREDATA) && (so->so_mode & SM_ATOMIC))
30250Sstevel@tonic-gate 		msg->msg_flags |= MSG_TRUNC;
30260Sstevel@tonic-gate 
30270Sstevel@tonic-gate 	if (mp == NULL) {
30280Sstevel@tonic-gate 		dprintso(so, 1, ("sotpi_recvmsg: got M_DATA\n"));
30290Sstevel@tonic-gate 		/*
30300Sstevel@tonic-gate 		 * 4.3BSD and 4.4BSD clears the mark when peeking across it.
30310Sstevel@tonic-gate 		 * The draft Posix socket spec states that the mark should
30320Sstevel@tonic-gate 		 * not be cleared when peeking. We follow the latter.
30330Sstevel@tonic-gate 		 */
30340Sstevel@tonic-gate 		if ((so->so_state &
30350Sstevel@tonic-gate 		    (SS_OOBPEND|SS_HAVEOOBDATA|SS_RCVATMARK)) &&
30360Sstevel@tonic-gate 		    (uiop->uio_resid != saved_resid) &&
30370Sstevel@tonic-gate 		    !(flags & MSG_PEEK)) {
30380Sstevel@tonic-gate 			sorecv_update_oobstate(so);
30390Sstevel@tonic-gate 		}
30400Sstevel@tonic-gate 
30410Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
30420Sstevel@tonic-gate 		/* Set MSG_EOR based on MOREDATA */
30430Sstevel@tonic-gate 		if (!(rval.r_val1 & MOREDATA)) {
30440Sstevel@tonic-gate 			if (so->so_state & SS_SAVEDEOR) {
30450Sstevel@tonic-gate 				msg->msg_flags |= MSG_EOR;
30460Sstevel@tonic-gate 				so->so_state &= ~SS_SAVEDEOR;
30470Sstevel@tonic-gate 			}
30480Sstevel@tonic-gate 		}
30490Sstevel@tonic-gate 		/*
30500Sstevel@tonic-gate 		 * If some data was received (i.e. not EOF) and the
30510Sstevel@tonic-gate 		 * read/recv* has not been satisfied wait for some more.
30520Sstevel@tonic-gate 		 */
30530Sstevel@tonic-gate 		if ((flags & MSG_WAITALL) && !(msg->msg_flags & MSG_EOR) &&
30540Sstevel@tonic-gate 		    uiop->uio_resid != saved_resid && uiop->uio_resid > 0) {
30550Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
30560Sstevel@tonic-gate 			first = 0;
30570Sstevel@tonic-gate 			pflag = opflag | MSG_NOMARK;
30580Sstevel@tonic-gate 			goto retry;
30590Sstevel@tonic-gate 		}
30600Sstevel@tonic-gate 		so_unlock_read(so);	/* Clear SOREADLOCKED */
30610Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
30620Sstevel@tonic-gate 		return (0);
30630Sstevel@tonic-gate 	}
30640Sstevel@tonic-gate 
30650Sstevel@tonic-gate 	/* strsock_proto has already verified length and alignment */
30660Sstevel@tonic-gate 	tpr = (union T_primitives *)mp->b_rptr;
30670Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_recvmsg: type %d\n", tpr->type));
30680Sstevel@tonic-gate 
30690Sstevel@tonic-gate 	switch (tpr->type) {
30700Sstevel@tonic-gate 	case T_DATA_IND: {
30710Sstevel@tonic-gate 		if ((so->so_state &
30720Sstevel@tonic-gate 		    (SS_OOBPEND|SS_HAVEOOBDATA|SS_RCVATMARK)) &&
30730Sstevel@tonic-gate 		    (uiop->uio_resid != saved_resid) &&
30740Sstevel@tonic-gate 		    !(flags & MSG_PEEK)) {
30750Sstevel@tonic-gate 			sorecv_update_oobstate(so);
30760Sstevel@tonic-gate 		}
30770Sstevel@tonic-gate 
30780Sstevel@tonic-gate 		/*
30790Sstevel@tonic-gate 		 * Set msg_flags to MSG_EOR based on
30800Sstevel@tonic-gate 		 * MORE_flag and MOREDATA.
30810Sstevel@tonic-gate 		 */
30820Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
30830Sstevel@tonic-gate 		so->so_state &= ~SS_SAVEDEOR;
30840Sstevel@tonic-gate 		if (!(tpr->data_ind.MORE_flag & 1)) {
30850Sstevel@tonic-gate 			if (!(rval.r_val1 & MOREDATA))
30860Sstevel@tonic-gate 				msg->msg_flags |= MSG_EOR;
30870Sstevel@tonic-gate 			else
30880Sstevel@tonic-gate 				so->so_state |= SS_SAVEDEOR;
30890Sstevel@tonic-gate 		}
30900Sstevel@tonic-gate 		freemsg(mp);
30910Sstevel@tonic-gate 		/*
30920Sstevel@tonic-gate 		 * If some data was received (i.e. not EOF) and the
30930Sstevel@tonic-gate 		 * read/recv* has not been satisfied wait for some more.
30940Sstevel@tonic-gate 		 */
30950Sstevel@tonic-gate 		if ((flags & MSG_WAITALL) && !(msg->msg_flags & MSG_EOR) &&
30960Sstevel@tonic-gate 		    uiop->uio_resid != saved_resid && uiop->uio_resid > 0) {
30970Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
30980Sstevel@tonic-gate 			first = 0;
30990Sstevel@tonic-gate 			pflag = opflag | MSG_NOMARK;
31000Sstevel@tonic-gate 			goto retry;
31010Sstevel@tonic-gate 		}
31020Sstevel@tonic-gate 		so_unlock_read(so);	/* Clear SOREADLOCKED */
31030Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
31040Sstevel@tonic-gate 		return (0);
31050Sstevel@tonic-gate 	}
31060Sstevel@tonic-gate 	case T_UNITDATA_IND: {
31070Sstevel@tonic-gate 		void *addr;
31080Sstevel@tonic-gate 		t_uscalar_t addrlen;
31090Sstevel@tonic-gate 		void *abuf;
31100Sstevel@tonic-gate 		t_uscalar_t optlen;
31110Sstevel@tonic-gate 		void *opt;
31120Sstevel@tonic-gate 
31130Sstevel@tonic-gate 		if ((so->so_state &
31140Sstevel@tonic-gate 		    (SS_OOBPEND|SS_HAVEOOBDATA|SS_RCVATMARK)) &&
31150Sstevel@tonic-gate 		    (uiop->uio_resid != saved_resid) &&
31160Sstevel@tonic-gate 		    !(flags & MSG_PEEK)) {
31170Sstevel@tonic-gate 			sorecv_update_oobstate(so);
31180Sstevel@tonic-gate 		}
31190Sstevel@tonic-gate 
31200Sstevel@tonic-gate 		if (namelen != 0) {
31210Sstevel@tonic-gate 			/* Caller wants source address */
31220Sstevel@tonic-gate 			addrlen = tpr->unitdata_ind.SRC_length;
31230Sstevel@tonic-gate 			addr = sogetoff(mp,
31240Sstevel@tonic-gate 				tpr->unitdata_ind.SRC_offset,
31250Sstevel@tonic-gate 				addrlen, 1);
31260Sstevel@tonic-gate 			if (addr == NULL) {
31270Sstevel@tonic-gate 				freemsg(mp);
31280Sstevel@tonic-gate 				error = EPROTO;
31290Sstevel@tonic-gate 				eprintsoline(so, error);
31300Sstevel@tonic-gate 				goto err;
31310Sstevel@tonic-gate 			}
31320Sstevel@tonic-gate 			if (so->so_family == AF_UNIX) {
31330Sstevel@tonic-gate 				/*
31340Sstevel@tonic-gate 				 * Can not use the transport level address.
31350Sstevel@tonic-gate 				 * If there is a SO_SRCADDR option carrying
31360Sstevel@tonic-gate 				 * the socket level address it will be
31370Sstevel@tonic-gate 				 * extracted below.
31380Sstevel@tonic-gate 				 */
31390Sstevel@tonic-gate 				addr = NULL;
31400Sstevel@tonic-gate 				addrlen = 0;
31410Sstevel@tonic-gate 			}
31420Sstevel@tonic-gate 		}
31430Sstevel@tonic-gate 		optlen = tpr->unitdata_ind.OPT_length;
31440Sstevel@tonic-gate 		if (optlen != 0) {
31450Sstevel@tonic-gate 			t_uscalar_t ncontrollen;
31460Sstevel@tonic-gate 
31470Sstevel@tonic-gate 			/*
31480Sstevel@tonic-gate 			 * Extract any source address option.
31490Sstevel@tonic-gate 			 * Determine how large cmsg buffer is needed.
31500Sstevel@tonic-gate 			 */
31510Sstevel@tonic-gate 			opt = sogetoff(mp,
31520Sstevel@tonic-gate 				tpr->unitdata_ind.OPT_offset,
31530Sstevel@tonic-gate 				optlen, __TPI_ALIGN_SIZE);
31540Sstevel@tonic-gate 
31550Sstevel@tonic-gate 			if (opt == NULL) {
31560Sstevel@tonic-gate 				freemsg(mp);
31570Sstevel@tonic-gate 				error = EPROTO;
31580Sstevel@tonic-gate 				eprintsoline(so, error);
31590Sstevel@tonic-gate 				goto err;
31600Sstevel@tonic-gate 			}
31610Sstevel@tonic-gate 			if (so->so_family == AF_UNIX)
31620Sstevel@tonic-gate 				so_getopt_srcaddr(opt, optlen, &addr, &addrlen);
31630Sstevel@tonic-gate 			ncontrollen = so_cmsglen(mp, opt, optlen,
31640Sstevel@tonic-gate 						!(flags & MSG_XPG4_2));
31650Sstevel@tonic-gate 			if (controllen != 0)
31660Sstevel@tonic-gate 				controllen = ncontrollen;
31670Sstevel@tonic-gate 			else if (ncontrollen != 0)
31680Sstevel@tonic-gate 				msg->msg_flags |= MSG_CTRUNC;
31690Sstevel@tonic-gate 		} else {
31700Sstevel@tonic-gate 			controllen = 0;
31710Sstevel@tonic-gate 		}
31720Sstevel@tonic-gate 
31730Sstevel@tonic-gate 		if (namelen != 0) {
31740Sstevel@tonic-gate 			/*
31750Sstevel@tonic-gate 			 * Return address to caller.
31760Sstevel@tonic-gate 			 * Caller handles truncation if length
31770Sstevel@tonic-gate 			 * exceeds msg_namelen.
31780Sstevel@tonic-gate 			 * NOTE: AF_UNIX NUL termination is ensured by
31790Sstevel@tonic-gate 			 * the sender's copyin_name().
31800Sstevel@tonic-gate 			 */
31810Sstevel@tonic-gate 			abuf = kmem_alloc(addrlen, KM_SLEEP);
31820Sstevel@tonic-gate 
31830Sstevel@tonic-gate 			bcopy(addr, abuf, addrlen);
31840Sstevel@tonic-gate 			msg->msg_name = abuf;
31850Sstevel@tonic-gate 			msg->msg_namelen = addrlen;
31860Sstevel@tonic-gate 		}
31870Sstevel@tonic-gate 
31880Sstevel@tonic-gate 		if (controllen != 0) {
31890Sstevel@tonic-gate 			/*
31900Sstevel@tonic-gate 			 * Return control msg to caller.
31910Sstevel@tonic-gate 			 * Caller handles truncation if length
31920Sstevel@tonic-gate 			 * exceeds msg_controllen.
31930Sstevel@tonic-gate 			 */
31940Sstevel@tonic-gate 			control = kmem_alloc(controllen, KM_SLEEP);
31950Sstevel@tonic-gate 
31960Sstevel@tonic-gate 			error = so_opt2cmsg(mp, opt, optlen,
31970Sstevel@tonic-gate 					!(flags & MSG_XPG4_2),
31980Sstevel@tonic-gate 					control, controllen);
31990Sstevel@tonic-gate 			if (error) {
32000Sstevel@tonic-gate 				freemsg(mp);
32010Sstevel@tonic-gate 				if (msg->msg_namelen != 0)
32020Sstevel@tonic-gate 					kmem_free(msg->msg_name,
32030Sstevel@tonic-gate 						msg->msg_namelen);
32040Sstevel@tonic-gate 				kmem_free(control, controllen);
32050Sstevel@tonic-gate 				eprintsoline(so, error);
32060Sstevel@tonic-gate 				goto err;
32070Sstevel@tonic-gate 			}
32080Sstevel@tonic-gate 			msg->msg_control = control;
32090Sstevel@tonic-gate 			msg->msg_controllen = controllen;
32100Sstevel@tonic-gate 		}
32110Sstevel@tonic-gate 
32120Sstevel@tonic-gate 		freemsg(mp);
32130Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
32140Sstevel@tonic-gate 		so_unlock_read(so);	/* Clear SOREADLOCKED */
32150Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
32160Sstevel@tonic-gate 		return (0);
32170Sstevel@tonic-gate 	}
32180Sstevel@tonic-gate 	case T_OPTDATA_IND: {
32190Sstevel@tonic-gate 		struct T_optdata_req *tdr;
32200Sstevel@tonic-gate 		void *opt;
32210Sstevel@tonic-gate 		t_uscalar_t optlen;
32220Sstevel@tonic-gate 
32230Sstevel@tonic-gate 		if ((so->so_state &
32240Sstevel@tonic-gate 		    (SS_OOBPEND|SS_HAVEOOBDATA|SS_RCVATMARK)) &&
32250Sstevel@tonic-gate 		    (uiop->uio_resid != saved_resid) &&
32260Sstevel@tonic-gate 		    !(flags & MSG_PEEK)) {
32270Sstevel@tonic-gate 			sorecv_update_oobstate(so);
32280Sstevel@tonic-gate 		}
32290Sstevel@tonic-gate 
32300Sstevel@tonic-gate 		tdr = (struct T_optdata_req *)mp->b_rptr;
32310Sstevel@tonic-gate 		optlen = tdr->OPT_length;
32320Sstevel@tonic-gate 		if (optlen != 0) {
32330Sstevel@tonic-gate 			t_uscalar_t ncontrollen;
32340Sstevel@tonic-gate 			/*
32350Sstevel@tonic-gate 			 * Determine how large cmsg buffer is needed.
32360Sstevel@tonic-gate 			 */
32370Sstevel@tonic-gate 			opt = sogetoff(mp,
32380Sstevel@tonic-gate 					tpr->optdata_ind.OPT_offset,
32390Sstevel@tonic-gate 					optlen, __TPI_ALIGN_SIZE);
32400Sstevel@tonic-gate 
32410Sstevel@tonic-gate 			if (opt == NULL) {
32420Sstevel@tonic-gate 				freemsg(mp);
32430Sstevel@tonic-gate 				error = EPROTO;
32440Sstevel@tonic-gate 				eprintsoline(so, error);
32450Sstevel@tonic-gate 				goto err;
32460Sstevel@tonic-gate 			}
32470Sstevel@tonic-gate 
32480Sstevel@tonic-gate 			ncontrollen = so_cmsglen(mp, opt, optlen,
32490Sstevel@tonic-gate 						!(flags & MSG_XPG4_2));
32500Sstevel@tonic-gate 			if (controllen != 0)
32510Sstevel@tonic-gate 				controllen = ncontrollen;
32520Sstevel@tonic-gate 			else if (ncontrollen != 0)
32530Sstevel@tonic-gate 				msg->msg_flags |= MSG_CTRUNC;
32540Sstevel@tonic-gate 		} else {
32550Sstevel@tonic-gate 			controllen = 0;
32560Sstevel@tonic-gate 		}
32570Sstevel@tonic-gate 
32580Sstevel@tonic-gate 		if (controllen != 0) {
32590Sstevel@tonic-gate 			/*
32600Sstevel@tonic-gate 			 * Return control msg to caller.
32610Sstevel@tonic-gate 			 * Caller handles truncation if length
32620Sstevel@tonic-gate 			 * exceeds msg_controllen.
32630Sstevel@tonic-gate 			 */
32640Sstevel@tonic-gate 			control = kmem_alloc(controllen, KM_SLEEP);
32650Sstevel@tonic-gate 
32660Sstevel@tonic-gate 			error = so_opt2cmsg(mp, opt, optlen,
32670Sstevel@tonic-gate 					!(flags & MSG_XPG4_2),
32680Sstevel@tonic-gate 					control, controllen);
32690Sstevel@tonic-gate 			if (error) {
32700Sstevel@tonic-gate 				freemsg(mp);
32710Sstevel@tonic-gate 				kmem_free(control, controllen);
32720Sstevel@tonic-gate 				eprintsoline(so, error);
32730Sstevel@tonic-gate 				goto err;
32740Sstevel@tonic-gate 			}
32750Sstevel@tonic-gate 			msg->msg_control = control;
32760Sstevel@tonic-gate 			msg->msg_controllen = controllen;
32770Sstevel@tonic-gate 		}
32780Sstevel@tonic-gate 
32790Sstevel@tonic-gate 		/*
32800Sstevel@tonic-gate 		 * Set msg_flags to MSG_EOR based on
32810Sstevel@tonic-gate 		 * DATA_flag and MOREDATA.
32820Sstevel@tonic-gate 		 */
32830Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
32840Sstevel@tonic-gate 		so->so_state &= ~SS_SAVEDEOR;
32850Sstevel@tonic-gate 		if (!(tpr->data_ind.MORE_flag & 1)) {
32860Sstevel@tonic-gate 			if (!(rval.r_val1 & MOREDATA))
32870Sstevel@tonic-gate 				msg->msg_flags |= MSG_EOR;
32880Sstevel@tonic-gate 			else
32890Sstevel@tonic-gate 				so->so_state |= SS_SAVEDEOR;
32900Sstevel@tonic-gate 		}
32910Sstevel@tonic-gate 		freemsg(mp);
32920Sstevel@tonic-gate 		/*
32930Sstevel@tonic-gate 		 * If some data was received (i.e. not EOF) and the
32940Sstevel@tonic-gate 		 * read/recv* has not been satisfied wait for some more.
32950Sstevel@tonic-gate 		 * Not possible to wait if control info was received.
32960Sstevel@tonic-gate 		 */
32970Sstevel@tonic-gate 		if ((flags & MSG_WAITALL) && !(msg->msg_flags & MSG_EOR) &&
32980Sstevel@tonic-gate 		    controllen == 0 &&
32990Sstevel@tonic-gate 		    uiop->uio_resid != saved_resid && uiop->uio_resid > 0) {
33000Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
33010Sstevel@tonic-gate 			first = 0;
33020Sstevel@tonic-gate 			pflag = opflag | MSG_NOMARK;
33030Sstevel@tonic-gate 			goto retry;
33040Sstevel@tonic-gate 		}
33050Sstevel@tonic-gate 		so_unlock_read(so);	/* Clear SOREADLOCKED */
33060Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
33070Sstevel@tonic-gate 		return (0);
33080Sstevel@tonic-gate 	}
33090Sstevel@tonic-gate 	case T_EXDATA_IND: {
33100Sstevel@tonic-gate 		dprintso(so, 1,
33110Sstevel@tonic-gate 			("sotpi_recvmsg: EXDATA_IND counts %d/%d consumed %ld "
33120Sstevel@tonic-gate 			"state %s\n",
33130Sstevel@tonic-gate 			so->so_oobsigcnt, so->so_oobcnt,
33140Sstevel@tonic-gate 			saved_resid - uiop->uio_resid,
33150Sstevel@tonic-gate 			pr_state(so->so_state, so->so_mode)));
33160Sstevel@tonic-gate 		/*
33170Sstevel@tonic-gate 		 * kstrgetmsg handles MSGMARK so there is nothing to
33180Sstevel@tonic-gate 		 * inspect in the T_EXDATA_IND.
33190Sstevel@tonic-gate 		 * strsock_proto makes the stream head queue the T_EXDATA_IND
33200Sstevel@tonic-gate 		 * as a separate message with no M_DATA component. Furthermore,
33210Sstevel@tonic-gate 		 * the stream head does not consolidate M_DATA messages onto
33220Sstevel@tonic-gate 		 * an MSGMARK'ed message ensuring that the T_EXDATA_IND
33230Sstevel@tonic-gate 		 * remains a message by itself. This is needed since MSGMARK
33240Sstevel@tonic-gate 		 * marks both the whole message as well as the last byte
33250Sstevel@tonic-gate 		 * of the message.
33260Sstevel@tonic-gate 		 */
33270Sstevel@tonic-gate 		freemsg(mp);
33280Sstevel@tonic-gate 		ASSERT(uiop->uio_resid == saved_resid);	/* No data */
33290Sstevel@tonic-gate 		if (flags & MSG_PEEK) {
33300Sstevel@tonic-gate 			/*
33310Sstevel@tonic-gate 			 * Even though we are peeking we consume the
33320Sstevel@tonic-gate 			 * T_EXDATA_IND thereby moving the mark information
33330Sstevel@tonic-gate 			 * to SS_RCVATMARK. Then the oob code below will
33340Sstevel@tonic-gate 			 * retry the peeking kstrgetmsg.
33350Sstevel@tonic-gate 			 * Note that the stream head read queue is
33360Sstevel@tonic-gate 			 * never flushed without holding SOREADLOCKED
33370Sstevel@tonic-gate 			 * thus the T_EXDATA_IND can not disappear
33380Sstevel@tonic-gate 			 * underneath us.
33390Sstevel@tonic-gate 			 */
33400Sstevel@tonic-gate 			dprintso(so, 1,
33410Sstevel@tonic-gate 				("sotpi_recvmsg: consume EXDATA_IND "
33420Sstevel@tonic-gate 				"counts %d/%d state %s\n",
33430Sstevel@tonic-gate 				so->so_oobsigcnt,
33440Sstevel@tonic-gate 				so->so_oobcnt,
33450Sstevel@tonic-gate 				pr_state(so->so_state, so->so_mode)));
33460Sstevel@tonic-gate 
33470Sstevel@tonic-gate 			pflag = MSG_ANY | MSG_DELAYERROR;
33480Sstevel@tonic-gate 			if (so->so_mode & SM_ATOMIC)
33490Sstevel@tonic-gate 				pflag |= MSG_DISCARDTAIL;
33500Sstevel@tonic-gate 
33510Sstevel@tonic-gate 			pri = 0;
33520Sstevel@tonic-gate 			mp = NULL;
33530Sstevel@tonic-gate 
33540Sstevel@tonic-gate 			error = kstrgetmsg(SOTOV(so), &mp, uiop,
33550Sstevel@tonic-gate 				&pri, &pflag, (clock_t)-1, &rval);
33560Sstevel@tonic-gate 			ASSERT(uiop->uio_resid == saved_resid);
33570Sstevel@tonic-gate 
33580Sstevel@tonic-gate 			if (error) {
33590Sstevel@tonic-gate #ifdef SOCK_DEBUG
33600Sstevel@tonic-gate 				if (error != EWOULDBLOCK && error != EINTR) {
33610Sstevel@tonic-gate 					eprintsoline(so, error);
33620Sstevel@tonic-gate 				}
33630Sstevel@tonic-gate #endif /* SOCK_DEBUG */
33640Sstevel@tonic-gate 				mutex_enter(&so->so_lock);
33650Sstevel@tonic-gate 				so_unlock_read(so);	/* Clear SOREADLOCKED */
33660Sstevel@tonic-gate 				mutex_exit(&so->so_lock);
33670Sstevel@tonic-gate 				return (error);
33680Sstevel@tonic-gate 			}
33690Sstevel@tonic-gate 			ASSERT(mp);
33700Sstevel@tonic-gate 			tpr = (union T_primitives *)mp->b_rptr;
33710Sstevel@tonic-gate 			ASSERT(tpr->type == T_EXDATA_IND);
33720Sstevel@tonic-gate 			freemsg(mp);
33730Sstevel@tonic-gate 		} /* end "if (flags & MSG_PEEK)" */
33740Sstevel@tonic-gate 
33750Sstevel@tonic-gate 		/*
33760Sstevel@tonic-gate 		 * Decrement the number of queued and pending oob.
33770Sstevel@tonic-gate 		 *
33780Sstevel@tonic-gate 		 * SS_RCVATMARK is cleared when we read past a mark.
33790Sstevel@tonic-gate 		 * SS_HAVEOOBDATA is cleared when we've read past the
33800Sstevel@tonic-gate 		 * last mark.
33810Sstevel@tonic-gate 		 * SS_OOBPEND is cleared if we've read past the last
33820Sstevel@tonic-gate 		 * mark and no (new) SIGURG has been posted.
33830Sstevel@tonic-gate 		 */
33840Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
33850Sstevel@tonic-gate 		ASSERT(so_verify_oobstate(so));
33860Sstevel@tonic-gate 		ASSERT(so->so_oobsigcnt >= so->so_oobcnt);
33870Sstevel@tonic-gate 		ASSERT(so->so_oobsigcnt > 0);
33880Sstevel@tonic-gate 		so->so_oobsigcnt--;
33890Sstevel@tonic-gate 		ASSERT(so->so_oobcnt > 0);
33900Sstevel@tonic-gate 		so->so_oobcnt--;
33910Sstevel@tonic-gate 		/*
33920Sstevel@tonic-gate 		 * Since the T_EXDATA_IND has been removed from the stream
33930Sstevel@tonic-gate 		 * head, but we have not read data past the mark,
33940Sstevel@tonic-gate 		 * sockfs needs to track that the socket is still at the mark.
33950Sstevel@tonic-gate 		 *
33960Sstevel@tonic-gate 		 * Since no data was received call kstrgetmsg again to wait
33970Sstevel@tonic-gate 		 * for data.
33980Sstevel@tonic-gate 		 */
33990Sstevel@tonic-gate 		so->so_state |= SS_RCVATMARK;
34000Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
34010Sstevel@tonic-gate 		dprintso(so, 1,
34020Sstevel@tonic-gate 		    ("sotpi_recvmsg: retry EXDATA_IND counts %d/%d state %s\n",
34030Sstevel@tonic-gate 		    so->so_oobsigcnt, so->so_oobcnt,
34040Sstevel@tonic-gate 		    pr_state(so->so_state, so->so_mode)));
34050Sstevel@tonic-gate 		pflag = opflag;
34060Sstevel@tonic-gate 		goto retry;
34070Sstevel@tonic-gate 	}
34080Sstevel@tonic-gate 	default:
34090Sstevel@tonic-gate 		ASSERT(0);
34100Sstevel@tonic-gate 		freemsg(mp);
34110Sstevel@tonic-gate 		error = EPROTO;
34120Sstevel@tonic-gate 		eprintsoline(so, error);
34130Sstevel@tonic-gate 		goto err;
34140Sstevel@tonic-gate 	}
34150Sstevel@tonic-gate 	/* NOTREACHED */
34160Sstevel@tonic-gate err:
34170Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
34180Sstevel@tonic-gate 	so_unlock_read(so);	/* Clear SOREADLOCKED */
34190Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
34200Sstevel@tonic-gate 	return (error);
34210Sstevel@tonic-gate }
34220Sstevel@tonic-gate 
34230Sstevel@tonic-gate /*
34240Sstevel@tonic-gate  * Sending data with options on a datagram socket.
34250Sstevel@tonic-gate  * Assumes caller has verified that SS_ISBOUND etc. are set.
34260Sstevel@tonic-gate  */
34270Sstevel@tonic-gate static int
3428741Smasputra sosend_dgramcmsg(struct sonode *so, struct sockaddr *name, socklen_t namelen,
3429741Smasputra     struct uio *uiop, void *control, t_uscalar_t controllen, int flags)
34300Sstevel@tonic-gate {
34310Sstevel@tonic-gate 	struct T_unitdata_req	tudr;
34320Sstevel@tonic-gate 	mblk_t			*mp;
34330Sstevel@tonic-gate 	int			error;
34340Sstevel@tonic-gate 	void			*addr;
34350Sstevel@tonic-gate 	socklen_t		addrlen;
34360Sstevel@tonic-gate 	void			*src;
34370Sstevel@tonic-gate 	socklen_t		srclen;
34380Sstevel@tonic-gate 	ssize_t			len;
34390Sstevel@tonic-gate 	int			size;
34400Sstevel@tonic-gate 	struct T_opthdr		toh;
34410Sstevel@tonic-gate 	struct fdbuf		*fdbuf;
34420Sstevel@tonic-gate 	t_uscalar_t		optlen;
34430Sstevel@tonic-gate 	void			*fds;
34440Sstevel@tonic-gate 	int			fdlen;
34450Sstevel@tonic-gate 
34460Sstevel@tonic-gate 	ASSERT(name && namelen);
34470Sstevel@tonic-gate 	ASSERT(control && controllen);
34480Sstevel@tonic-gate 
34490Sstevel@tonic-gate 	len = uiop->uio_resid;
34500Sstevel@tonic-gate 	if (len > (ssize_t)so->so_tidu_size) {
34510Sstevel@tonic-gate 		return (EMSGSIZE);
34520Sstevel@tonic-gate 	}
34530Sstevel@tonic-gate 
34540Sstevel@tonic-gate 	/*
34550Sstevel@tonic-gate 	 * For AF_UNIX the destination address is translated to an internal
34560Sstevel@tonic-gate 	 * name and the source address is passed as an option.
34570Sstevel@tonic-gate 	 * Also, file descriptors are passed as file pointers in an
34580Sstevel@tonic-gate 	 * option.
34590Sstevel@tonic-gate 	 */
34600Sstevel@tonic-gate 
34610Sstevel@tonic-gate 	/*
34620Sstevel@tonic-gate 	 * Length and family checks.
34630Sstevel@tonic-gate 	 */
34640Sstevel@tonic-gate 	error = so_addr_verify(so, name, namelen);
34650Sstevel@tonic-gate 	if (error) {
34660Sstevel@tonic-gate 		eprintsoline(so, error);
34670Sstevel@tonic-gate 		return (error);
34680Sstevel@tonic-gate 	}
34690Sstevel@tonic-gate 	if (so->so_family == AF_UNIX) {
34700Sstevel@tonic-gate 		if (so->so_state & SS_FADDR_NOXLATE) {
34710Sstevel@tonic-gate 			/*
34720Sstevel@tonic-gate 			 * Already have a transport internal address. Do not
34730Sstevel@tonic-gate 			 * pass any (transport internal) source address.
34740Sstevel@tonic-gate 			 */
34750Sstevel@tonic-gate 			addr = name;
34760Sstevel@tonic-gate 			addrlen = namelen;
34770Sstevel@tonic-gate 			src = NULL;
34780Sstevel@tonic-gate 			srclen = 0;
34790Sstevel@tonic-gate 		} else {
34800Sstevel@tonic-gate 			/*
34810Sstevel@tonic-gate 			 * Pass the sockaddr_un source address as an option
34820Sstevel@tonic-gate 			 * and translate the remote address.
34830Sstevel@tonic-gate 			 *
34840Sstevel@tonic-gate 			 * Note that this code does not prevent so_laddr_sa
34850Sstevel@tonic-gate 			 * from changing while it is being used. Thus
34860Sstevel@tonic-gate 			 * if an unbind+bind occurs concurrently with this
34870Sstevel@tonic-gate 			 * send the peer might see a partially new and a
34880Sstevel@tonic-gate 			 * partially old "from" address.
34890Sstevel@tonic-gate 			 */
34900Sstevel@tonic-gate 			src = so->so_laddr_sa;
34910Sstevel@tonic-gate 			srclen = (t_uscalar_t)so->so_laddr_len;
34920Sstevel@tonic-gate 			dprintso(so, 1,
34930Sstevel@tonic-gate 			    ("sosend_dgramcmsg UNIX: srclen %d, src %p\n",
34940Sstevel@tonic-gate 			    srclen, src));
34950Sstevel@tonic-gate 			error = so_ux_addr_xlate(so, name, namelen,
34960Sstevel@tonic-gate 				(flags & MSG_XPG4_2),
34970Sstevel@tonic-gate 				&addr, &addrlen);
34980Sstevel@tonic-gate 			if (error) {
34990Sstevel@tonic-gate 				eprintsoline(so, error);
35000Sstevel@tonic-gate 				return (error);
35010Sstevel@tonic-gate 			}
35020Sstevel@tonic-gate 		}
35030Sstevel@tonic-gate 	} else {
35040Sstevel@tonic-gate 		addr = name;
35050Sstevel@tonic-gate 		addrlen = namelen;
35060Sstevel@tonic-gate 		src = NULL;
35070Sstevel@tonic-gate 		srclen = 0;
35080Sstevel@tonic-gate 	}
35090Sstevel@tonic-gate 	optlen = so_optlen(control, controllen,
35100Sstevel@tonic-gate 					!(flags & MSG_XPG4_2));
35110Sstevel@tonic-gate 	tudr.PRIM_type = T_UNITDATA_REQ;
35120Sstevel@tonic-gate 	tudr.DEST_length = addrlen;
35130Sstevel@tonic-gate 	tudr.DEST_offset = (t_scalar_t)sizeof (tudr);
35140Sstevel@tonic-gate 	if (srclen != 0)
35150Sstevel@tonic-gate 		tudr.OPT_length = (t_scalar_t)(optlen + sizeof (toh) +
35160Sstevel@tonic-gate 		    _TPI_ALIGN_TOPT(srclen));
35170Sstevel@tonic-gate 	else
35180Sstevel@tonic-gate 		tudr.OPT_length = optlen;
35190Sstevel@tonic-gate 	tudr.OPT_offset = (t_scalar_t)(sizeof (tudr) +
35200Sstevel@tonic-gate 				_TPI_ALIGN_TOPT(addrlen));
35210Sstevel@tonic-gate 
35220Sstevel@tonic-gate 	size = tudr.OPT_offset + tudr.OPT_length;
35230Sstevel@tonic-gate 
35240Sstevel@tonic-gate 	/*
35250Sstevel@tonic-gate 	 * File descriptors only when SM_FDPASSING set.
35260Sstevel@tonic-gate 	 */
35270Sstevel@tonic-gate 	error = so_getfdopt(control, controllen,
35280Sstevel@tonic-gate 			!(flags & MSG_XPG4_2), &fds, &fdlen);
35290Sstevel@tonic-gate 	if (error)
35300Sstevel@tonic-gate 		return (error);
35310Sstevel@tonic-gate 	if (fdlen != -1) {
35320Sstevel@tonic-gate 		if (!(so->so_mode & SM_FDPASSING))
35330Sstevel@tonic-gate 			return (EOPNOTSUPP);
35340Sstevel@tonic-gate 
35350Sstevel@tonic-gate 		error = fdbuf_create(fds, fdlen, &fdbuf);
35360Sstevel@tonic-gate 		if (error)
35370Sstevel@tonic-gate 			return (error);
35380Sstevel@tonic-gate 		mp = fdbuf_allocmsg(size, fdbuf);
35390Sstevel@tonic-gate 	} else {
35400Sstevel@tonic-gate 		mp = soallocproto(size, _ALLOC_INTR);
3541455Smeem 		if (mp == NULL) {
3542455Smeem 			/*
3543455Smeem 			 * Caught a signal waiting for memory.
3544455Smeem 			 * Let send* return EINTR.
3545455Smeem 			 */
3546455Smeem 			return (EINTR);
3547455Smeem 		}
35480Sstevel@tonic-gate 	}
35490Sstevel@tonic-gate 	soappendmsg(mp, &tudr, sizeof (tudr));
35500Sstevel@tonic-gate 	soappendmsg(mp, addr, addrlen);
35510Sstevel@tonic-gate 	mp->b_wptr += _TPI_ALIGN_TOPT(addrlen) - addrlen;
35520Sstevel@tonic-gate 
35530Sstevel@tonic-gate 	if (fdlen != -1) {
35540Sstevel@tonic-gate 		ASSERT(fdbuf != NULL);
35550Sstevel@tonic-gate 		toh.level = SOL_SOCKET;
35560Sstevel@tonic-gate 		toh.name = SO_FILEP;
35570Sstevel@tonic-gate 		toh.len = fdbuf->fd_size +
35580Sstevel@tonic-gate 				(t_uscalar_t)sizeof (struct T_opthdr);
35590Sstevel@tonic-gate 		toh.status = 0;
35600Sstevel@tonic-gate 		soappendmsg(mp, &toh, sizeof (toh));
35610Sstevel@tonic-gate 		soappendmsg(mp, fdbuf, fdbuf->fd_size);
35620Sstevel@tonic-gate 		ASSERT(__TPI_TOPT_ISALIGNED(mp->b_wptr));
35630Sstevel@tonic-gate 	}
35640Sstevel@tonic-gate 	if (srclen != 0) {
35650Sstevel@tonic-gate 		/*
35660Sstevel@tonic-gate 		 * There is a AF_UNIX sockaddr_un to include as a source
35670Sstevel@tonic-gate 		 * address option.
35680Sstevel@tonic-gate 		 */
35690Sstevel@tonic-gate 		toh.level = SOL_SOCKET;
35700Sstevel@tonic-gate 		toh.name = SO_SRCADDR;
35710Sstevel@tonic-gate 		toh.len = (t_uscalar_t)(srclen + sizeof (struct T_opthdr));
35720Sstevel@tonic-gate 		toh.status = 0;
35730Sstevel@tonic-gate 		soappendmsg(mp, &toh, sizeof (toh));
35740Sstevel@tonic-gate 		soappendmsg(mp, src, srclen);
35750Sstevel@tonic-gate 		mp->b_wptr += _TPI_ALIGN_TOPT(srclen) - srclen;
35760Sstevel@tonic-gate 		ASSERT(__TPI_TOPT_ISALIGNED(mp->b_wptr));
35770Sstevel@tonic-gate 	}
35780Sstevel@tonic-gate 	ASSERT(mp->b_wptr <= mp->b_datap->db_lim);
35790Sstevel@tonic-gate 	so_cmsg2opt(control, controllen, !(flags & MSG_XPG4_2), mp);
35800Sstevel@tonic-gate 	/* At most 3 bytes left in the message */
35810Sstevel@tonic-gate 	ASSERT(MBLKL(mp) > (ssize_t)(size - __TPI_ALIGN_SIZE));
35820Sstevel@tonic-gate 	ASSERT(MBLKL(mp) <= (ssize_t)size);
35830Sstevel@tonic-gate 
35840Sstevel@tonic-gate 	ASSERT(mp->b_wptr <= mp->b_datap->db_lim);
35850Sstevel@tonic-gate #ifdef C2_AUDIT
35860Sstevel@tonic-gate 	if (audit_active)
35870Sstevel@tonic-gate 		audit_sock(T_UNITDATA_REQ, strvp2wq(SOTOV(so)), mp, 0);
35880Sstevel@tonic-gate #endif /* C2_AUDIT */
35890Sstevel@tonic-gate 
35900Sstevel@tonic-gate 	error = kstrputmsg(SOTOV(so), mp, uiop, len, 0, MSG_BAND, 0);
35910Sstevel@tonic-gate #ifdef SOCK_DEBUG
35920Sstevel@tonic-gate 	if (error) {
35930Sstevel@tonic-gate 		eprintsoline(so, error);
35940Sstevel@tonic-gate 	}
35950Sstevel@tonic-gate #endif /* SOCK_DEBUG */
35960Sstevel@tonic-gate 	return (error);
35970Sstevel@tonic-gate }
35980Sstevel@tonic-gate 
35990Sstevel@tonic-gate /*
36000Sstevel@tonic-gate  * Sending data with options on a connected stream socket.
36010Sstevel@tonic-gate  * Assumes caller has verified that SS_ISCONNECTED is set.
36020Sstevel@tonic-gate  */
36030Sstevel@tonic-gate static int
36040Sstevel@tonic-gate sosend_svccmsg(struct sonode *so,
36050Sstevel@tonic-gate 		struct uio *uiop,
36060Sstevel@tonic-gate 		int more,
36070Sstevel@tonic-gate 		void *control,
36080Sstevel@tonic-gate 		t_uscalar_t controllen,
36090Sstevel@tonic-gate 		int flags)
36100Sstevel@tonic-gate {
36110Sstevel@tonic-gate 	struct T_optdata_req	tdr;
36120Sstevel@tonic-gate 	mblk_t			*mp;
36130Sstevel@tonic-gate 	int			error;
36140Sstevel@tonic-gate 	ssize_t			iosize;
36150Sstevel@tonic-gate 	int			first = 1;
36160Sstevel@tonic-gate 	int			size;
36170Sstevel@tonic-gate 	struct fdbuf		*fdbuf;
36180Sstevel@tonic-gate 	t_uscalar_t		optlen;
36190Sstevel@tonic-gate 	void			*fds;
36200Sstevel@tonic-gate 	int			fdlen;
36210Sstevel@tonic-gate 	struct T_opthdr		toh;
36220Sstevel@tonic-gate 
36230Sstevel@tonic-gate 	dprintso(so, 1,
36240Sstevel@tonic-gate 		("sosend_svccmsg: resid %ld bytes\n", uiop->uio_resid));
36250Sstevel@tonic-gate 
36260Sstevel@tonic-gate 	/*
36270Sstevel@tonic-gate 	 * Has to be bound and connected. However, since no locks are
36280Sstevel@tonic-gate 	 * held the state could have changed after sotpi_sendmsg checked it
36290Sstevel@tonic-gate 	 * thus it is not possible to ASSERT on the state.
36300Sstevel@tonic-gate 	 */
36310Sstevel@tonic-gate 
36320Sstevel@tonic-gate 	/* Options on connection-oriented only when SM_OPTDATA set. */
36330Sstevel@tonic-gate 	if (!(so->so_mode & SM_OPTDATA))
36340Sstevel@tonic-gate 		return (EOPNOTSUPP);
36350Sstevel@tonic-gate 
36360Sstevel@tonic-gate 	do {
36370Sstevel@tonic-gate 		/*
36380Sstevel@tonic-gate 		 * Set the MORE flag if uio_resid does not fit in this
36390Sstevel@tonic-gate 		 * message or if the caller passed in "more".
36400Sstevel@tonic-gate 		 * Error for transports with zero tidu_size.
36410Sstevel@tonic-gate 		 */
36420Sstevel@tonic-gate 		tdr.PRIM_type = T_OPTDATA_REQ;
36430Sstevel@tonic-gate 		iosize = so->so_tidu_size;
36440Sstevel@tonic-gate 		if (iosize <= 0)
36450Sstevel@tonic-gate 			return (EMSGSIZE);
36460Sstevel@tonic-gate 		if (uiop->uio_resid > iosize) {
36470Sstevel@tonic-gate 			tdr.DATA_flag = 1;
36480Sstevel@tonic-gate 		} else {
36490Sstevel@tonic-gate 			if (more)
36500Sstevel@tonic-gate 				tdr.DATA_flag = 1;
36510Sstevel@tonic-gate 			else
36520Sstevel@tonic-gate 				tdr.DATA_flag = 0;
36530Sstevel@tonic-gate 			iosize = uiop->uio_resid;
36540Sstevel@tonic-gate 		}
36550Sstevel@tonic-gate 		dprintso(so, 1, ("sosend_svccmsg: sending %d, %ld bytes\n",
36560Sstevel@tonic-gate 			tdr.DATA_flag, iosize));
36570Sstevel@tonic-gate 
36580Sstevel@tonic-gate 		optlen = so_optlen(control, controllen, !(flags & MSG_XPG4_2));
36590Sstevel@tonic-gate 		tdr.OPT_length = optlen;
36600Sstevel@tonic-gate 		tdr.OPT_offset = (t_scalar_t)sizeof (tdr);
36610Sstevel@tonic-gate 
36620Sstevel@tonic-gate 		size = (int)sizeof (tdr) + optlen;
36630Sstevel@tonic-gate 		/*
36640Sstevel@tonic-gate 		 * File descriptors only when SM_FDPASSING set.
36650Sstevel@tonic-gate 		 */
36660Sstevel@tonic-gate 		error = so_getfdopt(control, controllen,
36670Sstevel@tonic-gate 				!(flags & MSG_XPG4_2), &fds, &fdlen);
36680Sstevel@tonic-gate 		if (error)
36690Sstevel@tonic-gate 			return (error);
36700Sstevel@tonic-gate 		if (fdlen != -1) {
36710Sstevel@tonic-gate 			if (!(so->so_mode & SM_FDPASSING))
36720Sstevel@tonic-gate 				return (EOPNOTSUPP);
36730Sstevel@tonic-gate 
36740Sstevel@tonic-gate 			error = fdbuf_create(fds, fdlen, &fdbuf);
36750Sstevel@tonic-gate 			if (error)
36760Sstevel@tonic-gate 				return (error);
36770Sstevel@tonic-gate 			mp = fdbuf_allocmsg(size, fdbuf);
36780Sstevel@tonic-gate 		} else {
36790Sstevel@tonic-gate 			mp = soallocproto(size, _ALLOC_INTR);
3680455Smeem 			if (mp == NULL) {
3681455Smeem 				/*
3682455Smeem 				 * Caught a signal waiting for memory.
3683455Smeem 				 * Let send* return EINTR.
3684455Smeem 				 */
3685455Smeem 				return (first ? EINTR : 0);
3686455Smeem 			}
36870Sstevel@tonic-gate 		}
36880Sstevel@tonic-gate 		soappendmsg(mp, &tdr, sizeof (tdr));
36890Sstevel@tonic-gate 
36900Sstevel@tonic-gate 		if (fdlen != -1) {
36910Sstevel@tonic-gate 			ASSERT(fdbuf != NULL);
36920Sstevel@tonic-gate 			toh.level = SOL_SOCKET;
36930Sstevel@tonic-gate 			toh.name = SO_FILEP;
36940Sstevel@tonic-gate 			toh.len = fdbuf->fd_size +
36950Sstevel@tonic-gate 				(t_uscalar_t)sizeof (struct T_opthdr);
36960Sstevel@tonic-gate 			toh.status = 0;
36970Sstevel@tonic-gate 			soappendmsg(mp, &toh, sizeof (toh));
36980Sstevel@tonic-gate 			soappendmsg(mp, fdbuf, fdbuf->fd_size);
36990Sstevel@tonic-gate 			ASSERT(__TPI_TOPT_ISALIGNED(mp->b_wptr));
37000Sstevel@tonic-gate 		}
37010Sstevel@tonic-gate 		so_cmsg2opt(control, controllen, !(flags & MSG_XPG4_2), mp);
37020Sstevel@tonic-gate 		/* At most 3 bytes left in the message */
37030Sstevel@tonic-gate 		ASSERT(MBLKL(mp) > (ssize_t)(size - __TPI_ALIGN_SIZE));
37040Sstevel@tonic-gate 		ASSERT(MBLKL(mp) <= (ssize_t)size);
37050Sstevel@tonic-gate 
37060Sstevel@tonic-gate 		ASSERT(mp->b_wptr <= mp->b_datap->db_lim);
37070Sstevel@tonic-gate 
37080Sstevel@tonic-gate 		error = kstrputmsg(SOTOV(so), mp, uiop, iosize,
37090Sstevel@tonic-gate 					0, MSG_BAND, 0);
37100Sstevel@tonic-gate 		if (error) {
37110Sstevel@tonic-gate 			if (!first && error == EWOULDBLOCK)
37120Sstevel@tonic-gate 				return (0);
37130Sstevel@tonic-gate 			eprintsoline(so, error);
37140Sstevel@tonic-gate 			return (error);
37150Sstevel@tonic-gate 		}
37160Sstevel@tonic-gate 		control = NULL;
37170Sstevel@tonic-gate 		first = 0;
37180Sstevel@tonic-gate 		if (uiop->uio_resid > 0) {
37190Sstevel@tonic-gate 			/*
37200Sstevel@tonic-gate 			 * Recheck for fatal errors. Fail write even though
37210Sstevel@tonic-gate 			 * some data have been written. This is consistent
37220Sstevel@tonic-gate 			 * with strwrite semantics and BSD sockets semantics.
37230Sstevel@tonic-gate 			 */
37240Sstevel@tonic-gate 			if (so->so_state & SS_CANTSENDMORE) {
37250Sstevel@tonic-gate 				tsignal(curthread, SIGPIPE);
37260Sstevel@tonic-gate 				eprintsoline(so, error);
37270Sstevel@tonic-gate 				return (EPIPE);
37280Sstevel@tonic-gate 			}
37290Sstevel@tonic-gate 			if (so->so_error != 0) {
37300Sstevel@tonic-gate 				mutex_enter(&so->so_lock);
37310Sstevel@tonic-gate 				error = sogeterr(so);
37320Sstevel@tonic-gate 				mutex_exit(&so->so_lock);
37330Sstevel@tonic-gate 				if (error != 0) {
37340Sstevel@tonic-gate 					eprintsoline(so, error);
37350Sstevel@tonic-gate 					return (error);
37360Sstevel@tonic-gate 				}
37370Sstevel@tonic-gate 			}
37380Sstevel@tonic-gate 		}
37390Sstevel@tonic-gate 	} while (uiop->uio_resid > 0);
37400Sstevel@tonic-gate 	return (0);
37410Sstevel@tonic-gate }
37420Sstevel@tonic-gate 
37430Sstevel@tonic-gate /*
37440Sstevel@tonic-gate  * Sending data on a datagram socket.
37450Sstevel@tonic-gate  * Assumes caller has verified that SS_ISBOUND etc. are set.
37460Sstevel@tonic-gate  *
37470Sstevel@tonic-gate  * For AF_UNIX the destination address is translated to an internal
37480Sstevel@tonic-gate  * name and the source address is passed as an option.
37490Sstevel@tonic-gate  */
37500Sstevel@tonic-gate int
3751741Smasputra sosend_dgram(struct sonode *so, struct sockaddr	*name, socklen_t namelen,
3752741Smasputra     struct uio *uiop, int flags)
37530Sstevel@tonic-gate {
37540Sstevel@tonic-gate 	struct T_unitdata_req	tudr;
37550Sstevel@tonic-gate 	mblk_t			*mp;
37560Sstevel@tonic-gate 	int			error;
37570Sstevel@tonic-gate 	void			*addr;
37580Sstevel@tonic-gate 	socklen_t		addrlen;
37590Sstevel@tonic-gate 	void			*src;
37600Sstevel@tonic-gate 	socklen_t		srclen;
37610Sstevel@tonic-gate 	ssize_t			len;
37620Sstevel@tonic-gate 
3763741Smasputra 	ASSERT(name != NULL && namelen != 0);
37640Sstevel@tonic-gate 
37650Sstevel@tonic-gate 	len = uiop->uio_resid;
37660Sstevel@tonic-gate 	if (len > so->so_tidu_size) {
37670Sstevel@tonic-gate 		error = EMSGSIZE;
37680Sstevel@tonic-gate 		goto done;
37690Sstevel@tonic-gate 	}
37700Sstevel@tonic-gate 
3771741Smasputra 	/* Length and family checks */
37720Sstevel@tonic-gate 	error = so_addr_verify(so, name, namelen);
3773741Smasputra 	if (error != 0)
37740Sstevel@tonic-gate 		goto done;
3775741Smasputra 
3776741Smasputra 	if (so->so_state & SS_DIRECT)
3777741Smasputra 		return (sodgram_direct(so, name, namelen, uiop, flags));
3778741Smasputra 
37790Sstevel@tonic-gate 	if (so->so_family == AF_UNIX) {
37800Sstevel@tonic-gate 		if (so->so_state & SS_FADDR_NOXLATE) {
37810Sstevel@tonic-gate 			/*
37820Sstevel@tonic-gate 			 * Already have a transport internal address. Do not
37830Sstevel@tonic-gate 			 * pass any (transport internal) source address.
37840Sstevel@tonic-gate 			 */
37850Sstevel@tonic-gate 			addr = name;
37860Sstevel@tonic-gate 			addrlen = namelen;
37870Sstevel@tonic-gate 			src = NULL;
37880Sstevel@tonic-gate 			srclen = 0;
37890Sstevel@tonic-gate 		} else {
37900Sstevel@tonic-gate 			/*
37910Sstevel@tonic-gate 			 * Pass the sockaddr_un source address as an option
37920Sstevel@tonic-gate 			 * and translate the remote address.
37930Sstevel@tonic-gate 			 *
37940Sstevel@tonic-gate 			 * Note that this code does not prevent so_laddr_sa
37950Sstevel@tonic-gate 			 * from changing while it is being used. Thus
37960Sstevel@tonic-gate 			 * if an unbind+bind occurs concurrently with this
37970Sstevel@tonic-gate 			 * send the peer might see a partially new and a
37980Sstevel@tonic-gate 			 * partially old "from" address.
37990Sstevel@tonic-gate 			 */
38000Sstevel@tonic-gate 			src = so->so_laddr_sa;
38010Sstevel@tonic-gate 			srclen = (socklen_t)so->so_laddr_len;
38020Sstevel@tonic-gate 			dprintso(so, 1,
38030Sstevel@tonic-gate 				("sosend_dgram UNIX: srclen %d, src %p\n",
38040Sstevel@tonic-gate 				srclen, src));
38050Sstevel@tonic-gate 			error = so_ux_addr_xlate(so, name, namelen,
38060Sstevel@tonic-gate 				(flags & MSG_XPG4_2),
38070Sstevel@tonic-gate 				&addr, &addrlen);
38080Sstevel@tonic-gate 			if (error) {
38090Sstevel@tonic-gate 				eprintsoline(so, error);
38100Sstevel@tonic-gate 				goto done;
38110Sstevel@tonic-gate 			}
38120Sstevel@tonic-gate 		}
38130Sstevel@tonic-gate 	} else {
38140Sstevel@tonic-gate 		addr = name;
38150Sstevel@tonic-gate 		addrlen = namelen;
38160Sstevel@tonic-gate 		src = NULL;
38170Sstevel@tonic-gate 		srclen = 0;
38180Sstevel@tonic-gate 	}
38190Sstevel@tonic-gate 	tudr.PRIM_type = T_UNITDATA_REQ;
38200Sstevel@tonic-gate 	tudr.DEST_length = addrlen;
38210Sstevel@tonic-gate 	tudr.DEST_offset = (t_scalar_t)sizeof (tudr);
38220Sstevel@tonic-gate 	if (srclen == 0) {
38230Sstevel@tonic-gate 		tudr.OPT_length = 0;
38240Sstevel@tonic-gate 		tudr.OPT_offset = 0;
38250Sstevel@tonic-gate 
38260Sstevel@tonic-gate 		mp = soallocproto2(&tudr, sizeof (tudr),
38270Sstevel@tonic-gate 		    addr, addrlen, 0, _ALLOC_INTR);
38280Sstevel@tonic-gate 		if (mp == NULL) {
38290Sstevel@tonic-gate 			/*
38300Sstevel@tonic-gate 			 * Caught a signal waiting for memory.
38310Sstevel@tonic-gate 			 * Let send* return EINTR.
38320Sstevel@tonic-gate 			 */
38330Sstevel@tonic-gate 			error = EINTR;
38340Sstevel@tonic-gate 			goto done;
38350Sstevel@tonic-gate 		}
38360Sstevel@tonic-gate 	} else {
38370Sstevel@tonic-gate 		/*
38380Sstevel@tonic-gate 		 * There is a AF_UNIX sockaddr_un to include as a source
38390Sstevel@tonic-gate 		 * address option.
38400Sstevel@tonic-gate 		 */
38410Sstevel@tonic-gate 		struct T_opthdr toh;
38420Sstevel@tonic-gate 		ssize_t size;
38430Sstevel@tonic-gate 
38440Sstevel@tonic-gate 		tudr.OPT_length = (t_scalar_t)(sizeof (toh) +
38450Sstevel@tonic-gate 					_TPI_ALIGN_TOPT(srclen));
38460Sstevel@tonic-gate 		tudr.OPT_offset = (t_scalar_t)(sizeof (tudr) +
38470Sstevel@tonic-gate 					_TPI_ALIGN_TOPT(addrlen));
38480Sstevel@tonic-gate 
38490Sstevel@tonic-gate 		toh.level = SOL_SOCKET;
38500Sstevel@tonic-gate 		toh.name = SO_SRCADDR;
38510Sstevel@tonic-gate 		toh.len = (t_uscalar_t)(srclen + sizeof (struct T_opthdr));
38520Sstevel@tonic-gate 		toh.status = 0;
38530Sstevel@tonic-gate 
38540Sstevel@tonic-gate 		size = tudr.OPT_offset + tudr.OPT_length;
38550Sstevel@tonic-gate 		mp = soallocproto2(&tudr, sizeof (tudr),
38560Sstevel@tonic-gate 		    addr, addrlen, size, _ALLOC_INTR);
38570Sstevel@tonic-gate 		if (mp == NULL) {
38580Sstevel@tonic-gate 			/*
38590Sstevel@tonic-gate 			 * Caught a signal waiting for memory.
38600Sstevel@tonic-gate 			 * Let send* return EINTR.
38610Sstevel@tonic-gate 			 */
38620Sstevel@tonic-gate 			error = EINTR;
38630Sstevel@tonic-gate 			goto done;
38640Sstevel@tonic-gate 		}
38650Sstevel@tonic-gate 		mp->b_wptr += _TPI_ALIGN_TOPT(addrlen) - addrlen;
38660Sstevel@tonic-gate 		soappendmsg(mp, &toh, sizeof (toh));
38670Sstevel@tonic-gate 		soappendmsg(mp, src, srclen);
38680Sstevel@tonic-gate 		mp->b_wptr += _TPI_ALIGN_TOPT(srclen) - srclen;
38690Sstevel@tonic-gate 		ASSERT(mp->b_wptr <= mp->b_datap->db_lim);
38700Sstevel@tonic-gate 	}
38710Sstevel@tonic-gate 
38720Sstevel@tonic-gate #ifdef C2_AUDIT
38730Sstevel@tonic-gate 	if (audit_active)
38740Sstevel@tonic-gate 		audit_sock(T_UNITDATA_REQ, strvp2wq(SOTOV(so)), mp, 0);
38750Sstevel@tonic-gate #endif /* C2_AUDIT */
38760Sstevel@tonic-gate 
38770Sstevel@tonic-gate 	error = kstrputmsg(SOTOV(so), mp, uiop, len, 0, MSG_BAND, 0);
38780Sstevel@tonic-gate done:
38790Sstevel@tonic-gate #ifdef SOCK_DEBUG
38800Sstevel@tonic-gate 	if (error) {
38810Sstevel@tonic-gate 		eprintsoline(so, error);
38820Sstevel@tonic-gate 	}
38830Sstevel@tonic-gate #endif /* SOCK_DEBUG */
38840Sstevel@tonic-gate 	return (error);
38850Sstevel@tonic-gate }
38860Sstevel@tonic-gate 
38870Sstevel@tonic-gate /*
38880Sstevel@tonic-gate  * Sending data on a connected stream socket.
38890Sstevel@tonic-gate  * Assumes caller has verified that SS_ISCONNECTED is set.
38900Sstevel@tonic-gate  */
38910Sstevel@tonic-gate int
38920Sstevel@tonic-gate sosend_svc(struct sonode *so,
38930Sstevel@tonic-gate 	struct uio *uiop,
38940Sstevel@tonic-gate 	t_scalar_t prim,
38950Sstevel@tonic-gate 	int more,
38960Sstevel@tonic-gate 	int sflag)
38970Sstevel@tonic-gate {
38980Sstevel@tonic-gate 	struct T_data_req	tdr;
38990Sstevel@tonic-gate 	mblk_t			*mp;
39000Sstevel@tonic-gate 	int			error;
39010Sstevel@tonic-gate 	ssize_t			iosize;
39020Sstevel@tonic-gate 	int			first = 1;
39030Sstevel@tonic-gate 
39040Sstevel@tonic-gate 	dprintso(so, 1,
39050Sstevel@tonic-gate 		("sosend_svc: %p, resid %ld bytes, prim %d, sflag 0x%x\n",
39060Sstevel@tonic-gate 		so, uiop->uio_resid, prim, sflag));
39070Sstevel@tonic-gate 
39080Sstevel@tonic-gate 	/*
39090Sstevel@tonic-gate 	 * Has to be bound and connected. However, since no locks are
39100Sstevel@tonic-gate 	 * held the state could have changed after sotpi_sendmsg checked it
39110Sstevel@tonic-gate 	 * thus it is not possible to ASSERT on the state.
39120Sstevel@tonic-gate 	 */
39130Sstevel@tonic-gate 
39140Sstevel@tonic-gate 	do {
39150Sstevel@tonic-gate 		/*
39160Sstevel@tonic-gate 		 * Set the MORE flag if uio_resid does not fit in this
39170Sstevel@tonic-gate 		 * message or if the caller passed in "more".
39180Sstevel@tonic-gate 		 * Error for transports with zero tidu_size.
39190Sstevel@tonic-gate 		 */
39200Sstevel@tonic-gate 		tdr.PRIM_type = prim;
39210Sstevel@tonic-gate 		iosize = so->so_tidu_size;
39220Sstevel@tonic-gate 		if (iosize <= 0)
39230Sstevel@tonic-gate 			return (EMSGSIZE);
39240Sstevel@tonic-gate 		if (uiop->uio_resid > iosize) {
39250Sstevel@tonic-gate 			tdr.MORE_flag = 1;
39260Sstevel@tonic-gate 		} else {
39270Sstevel@tonic-gate 			if (more)
39280Sstevel@tonic-gate 				tdr.MORE_flag = 1;
39290Sstevel@tonic-gate 			else
39300Sstevel@tonic-gate 				tdr.MORE_flag = 0;
39310Sstevel@tonic-gate 			iosize = uiop->uio_resid;
39320Sstevel@tonic-gate 		}
39330Sstevel@tonic-gate 		dprintso(so, 1, ("sosend_svc: sending 0x%x %d, %ld bytes\n",
39340Sstevel@tonic-gate 			prim, tdr.MORE_flag, iosize));
39350Sstevel@tonic-gate 		mp = soallocproto1(&tdr, sizeof (tdr), 0, _ALLOC_INTR);
39360Sstevel@tonic-gate 		if (mp == NULL) {
39370Sstevel@tonic-gate 			/*
39380Sstevel@tonic-gate 			 * Caught a signal waiting for memory.
39390Sstevel@tonic-gate 			 * Let send* return EINTR.
39400Sstevel@tonic-gate 			 */
39410Sstevel@tonic-gate 			if (first)
39420Sstevel@tonic-gate 				return (EINTR);
39430Sstevel@tonic-gate 			else
39440Sstevel@tonic-gate 				return (0);
39450Sstevel@tonic-gate 		}
39460Sstevel@tonic-gate 
39470Sstevel@tonic-gate 		error = kstrputmsg(SOTOV(so), mp, uiop, iosize,
39480Sstevel@tonic-gate 					0, sflag | MSG_BAND, 0);
39490Sstevel@tonic-gate 		if (error) {
39500Sstevel@tonic-gate 			if (!first && error == EWOULDBLOCK)
39510Sstevel@tonic-gate 				return (0);
39520Sstevel@tonic-gate 			eprintsoline(so, error);
39530Sstevel@tonic-gate 			return (error);
39540Sstevel@tonic-gate 		}
39550Sstevel@tonic-gate 		first = 0;
39560Sstevel@tonic-gate 		if (uiop->uio_resid > 0) {
39570Sstevel@tonic-gate 			/*
39580Sstevel@tonic-gate 			 * Recheck for fatal errors. Fail write even though
39590Sstevel@tonic-gate 			 * some data have been written. This is consistent
39600Sstevel@tonic-gate 			 * with strwrite semantics and BSD sockets semantics.
39610Sstevel@tonic-gate 			 */
39620Sstevel@tonic-gate 			if (so->so_state & SS_CANTSENDMORE) {
39630Sstevel@tonic-gate 				tsignal(curthread, SIGPIPE);
39640Sstevel@tonic-gate 				eprintsoline(so, error);
39650Sstevel@tonic-gate 				return (EPIPE);
39660Sstevel@tonic-gate 			}
39670Sstevel@tonic-gate 			if (so->so_error != 0) {
39680Sstevel@tonic-gate 				mutex_enter(&so->so_lock);
39690Sstevel@tonic-gate 				error = sogeterr(so);
39700Sstevel@tonic-gate 				mutex_exit(&so->so_lock);
39710Sstevel@tonic-gate 				if (error != 0) {
39720Sstevel@tonic-gate 					eprintsoline(so, error);
39730Sstevel@tonic-gate 					return (error);
39740Sstevel@tonic-gate 				}
39750Sstevel@tonic-gate 			}
39760Sstevel@tonic-gate 		}
39770Sstevel@tonic-gate 	} while (uiop->uio_resid > 0);
39780Sstevel@tonic-gate 	return (0);
39790Sstevel@tonic-gate }
39800Sstevel@tonic-gate 
39810Sstevel@tonic-gate /*
39820Sstevel@tonic-gate  * Check the state for errors and call the appropriate send function.
39830Sstevel@tonic-gate  *
39840Sstevel@tonic-gate  * If MSG_DONTROUTE is set (and SO_DONTROUTE isn't already set)
39850Sstevel@tonic-gate  * this function issues a setsockopt to toggle SO_DONTROUTE before and
39860Sstevel@tonic-gate  * after sending the message.
39870Sstevel@tonic-gate  */
39880Sstevel@tonic-gate static int
39890Sstevel@tonic-gate sotpi_sendmsg(struct sonode *so, struct nmsghdr *msg, struct uio *uiop)
39900Sstevel@tonic-gate {
39910Sstevel@tonic-gate 	int		so_state;
39920Sstevel@tonic-gate 	int		so_mode;
39930Sstevel@tonic-gate 	int		error;
39940Sstevel@tonic-gate 	struct sockaddr *name;
39950Sstevel@tonic-gate 	t_uscalar_t	namelen;
39960Sstevel@tonic-gate 	int		dontroute;
39970Sstevel@tonic-gate 	int		flags;
39980Sstevel@tonic-gate 
39990Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_sendmsg(%p, %p, 0x%x) state %s, error %d\n",
40000Sstevel@tonic-gate 		so, msg, msg->msg_flags,
40010Sstevel@tonic-gate 		pr_state(so->so_state, so->so_mode), so->so_error));
40020Sstevel@tonic-gate 
40030Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
40040Sstevel@tonic-gate 	so_state = so->so_state;
40050Sstevel@tonic-gate 
40060Sstevel@tonic-gate 	if (so_state & SS_CANTSENDMORE) {
40070Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
40080Sstevel@tonic-gate 		tsignal(curthread, SIGPIPE);
40090Sstevel@tonic-gate 		return (EPIPE);
40100Sstevel@tonic-gate 	}
40110Sstevel@tonic-gate 
40120Sstevel@tonic-gate 	if (so->so_error != 0) {
40130Sstevel@tonic-gate 		error = sogeterr(so);
40140Sstevel@tonic-gate 		if (error != 0) {
40150Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
40160Sstevel@tonic-gate 			return (error);
40170Sstevel@tonic-gate 		}
40180Sstevel@tonic-gate 	}
40190Sstevel@tonic-gate 
40200Sstevel@tonic-gate 	name = (struct sockaddr *)msg->msg_name;
40210Sstevel@tonic-gate 	namelen = msg->msg_namelen;
40220Sstevel@tonic-gate 
40230Sstevel@tonic-gate 	so_mode = so->so_mode;
40240Sstevel@tonic-gate 
40250Sstevel@tonic-gate 	if (name == NULL) {
40260Sstevel@tonic-gate 		if (!(so_state & SS_ISCONNECTED)) {
40270Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
40280Sstevel@tonic-gate 			if (so_mode & SM_CONNREQUIRED)
40290Sstevel@tonic-gate 				return (ENOTCONN);
40300Sstevel@tonic-gate 			else
40310Sstevel@tonic-gate 				return (EDESTADDRREQ);
40320Sstevel@tonic-gate 		}
40330Sstevel@tonic-gate 		if (so_mode & SM_CONNREQUIRED) {
40340Sstevel@tonic-gate 			name = NULL;
40350Sstevel@tonic-gate 			namelen = 0;
40360Sstevel@tonic-gate 		} else {
40370Sstevel@tonic-gate 			/*
40380Sstevel@tonic-gate 			 * Note that this code does not prevent so_faddr_sa
40390Sstevel@tonic-gate 			 * from changing while it is being used. Thus
40400Sstevel@tonic-gate 			 * if an "unconnect"+connect occurs concurrently with
40410Sstevel@tonic-gate 			 * this send the datagram might be delivered to a
40420Sstevel@tonic-gate 			 * garbaled address.
40430Sstevel@tonic-gate 			 */
40440Sstevel@tonic-gate 			ASSERT(so->so_faddr_sa);
40450Sstevel@tonic-gate 			name = so->so_faddr_sa;
40460Sstevel@tonic-gate 			namelen = (t_uscalar_t)so->so_faddr_len;
40470Sstevel@tonic-gate 		}
40480Sstevel@tonic-gate 	} else {
40490Sstevel@tonic-gate 		if (!(so_state & SS_ISCONNECTED) &&
40500Sstevel@tonic-gate 		    (so_mode & SM_CONNREQUIRED)) {
40510Sstevel@tonic-gate 			/* Required but not connected */
40520Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
40530Sstevel@tonic-gate 			return (ENOTCONN);
40540Sstevel@tonic-gate 		}
40550Sstevel@tonic-gate 		/*
40560Sstevel@tonic-gate 		 * Ignore the address on connection-oriented sockets.
40570Sstevel@tonic-gate 		 * Just like BSD this code does not generate an error for
40580Sstevel@tonic-gate 		 * TCP (a CONNREQUIRED socket) when sending to an address
40590Sstevel@tonic-gate 		 * passed in with sendto/sendmsg. Instead the data is
40600Sstevel@tonic-gate 		 * delivered on the connection as if no address had been
40610Sstevel@tonic-gate 		 * supplied.
40620Sstevel@tonic-gate 		 */
40630Sstevel@tonic-gate 		if ((so_state & SS_ISCONNECTED) &&
40640Sstevel@tonic-gate 		    !(so_mode & SM_CONNREQUIRED)) {
40650Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
40660Sstevel@tonic-gate 			return (EISCONN);
40670Sstevel@tonic-gate 		}
40680Sstevel@tonic-gate 		if (!(so_state & SS_ISBOUND)) {
40690Sstevel@tonic-gate 			so_lock_single(so);	/* Set SOLOCKED */
40700Sstevel@tonic-gate 			error = sotpi_bind(so, NULL, 0,
40710Sstevel@tonic-gate 			    _SOBIND_UNSPEC|_SOBIND_LOCK_HELD);
40720Sstevel@tonic-gate 			so_unlock_single(so, SOLOCKED);
40730Sstevel@tonic-gate 			if (error) {
40740Sstevel@tonic-gate 				mutex_exit(&so->so_lock);
40750Sstevel@tonic-gate 				eprintsoline(so, error);
40760Sstevel@tonic-gate 				return (error);
40770Sstevel@tonic-gate 			}
40780Sstevel@tonic-gate 		}
40790Sstevel@tonic-gate 		/*
40800Sstevel@tonic-gate 		 * Handle delayed datagram errors. These are only queued
40810Sstevel@tonic-gate 		 * when the application sets SO_DGRAM_ERRIND.
40820Sstevel@tonic-gate 		 * Return the error if we are sending to the address
40830Sstevel@tonic-gate 		 * that was returned in the last T_UDERROR_IND.
40840Sstevel@tonic-gate 		 * If sending to some other address discard the delayed
40850Sstevel@tonic-gate 		 * error indication.
40860Sstevel@tonic-gate 		 */
40870Sstevel@tonic-gate 		if (so->so_delayed_error) {
40880Sstevel@tonic-gate 			struct T_uderror_ind	*tudi;
40890Sstevel@tonic-gate 			void			*addr;
40900Sstevel@tonic-gate 			t_uscalar_t		addrlen;
40910Sstevel@tonic-gate 			boolean_t		match = B_FALSE;
40920Sstevel@tonic-gate 
40930Sstevel@tonic-gate 			ASSERT(so->so_eaddr_mp);
40940Sstevel@tonic-gate 			error = so->so_delayed_error;
40950Sstevel@tonic-gate 			so->so_delayed_error = 0;
40960Sstevel@tonic-gate 			tudi = (struct T_uderror_ind *)so->so_eaddr_mp->b_rptr;
40970Sstevel@tonic-gate 			addrlen = tudi->DEST_length;
40980Sstevel@tonic-gate 			addr = sogetoff(so->so_eaddr_mp,
40990Sstevel@tonic-gate 					tudi->DEST_offset,
41000Sstevel@tonic-gate 					addrlen, 1);
41010Sstevel@tonic-gate 			ASSERT(addr);	/* Checked by strsock_proto */
41020Sstevel@tonic-gate 			switch (so->so_family) {
41030Sstevel@tonic-gate 			case AF_INET: {
41040Sstevel@tonic-gate 				/* Compare just IP address and port */
41050Sstevel@tonic-gate 				sin_t *sin1 = (sin_t *)name;
41060Sstevel@tonic-gate 				sin_t *sin2 = (sin_t *)addr;
41070Sstevel@tonic-gate 
41080Sstevel@tonic-gate 				if (addrlen == sizeof (sin_t) &&
41090Sstevel@tonic-gate 				    namelen == addrlen &&
41100Sstevel@tonic-gate 				    sin1->sin_port == sin2->sin_port &&
41110Sstevel@tonic-gate 				    sin1->sin_addr.s_addr ==
41120Sstevel@tonic-gate 				    sin2->sin_addr.s_addr)
41130Sstevel@tonic-gate 					match = B_TRUE;
41140Sstevel@tonic-gate 				break;
41150Sstevel@tonic-gate 			}
41160Sstevel@tonic-gate 			case AF_INET6: {
41170Sstevel@tonic-gate 				/* Compare just IP address and port. Not flow */
41180Sstevel@tonic-gate 				sin6_t *sin1 = (sin6_t *)name;
41190Sstevel@tonic-gate 				sin6_t *sin2 = (sin6_t *)addr;
41200Sstevel@tonic-gate 
41210Sstevel@tonic-gate 				if (addrlen == sizeof (sin6_t) &&
41220Sstevel@tonic-gate 				    namelen == addrlen &&
41230Sstevel@tonic-gate 				    sin1->sin6_port == sin2->sin6_port &&
41240Sstevel@tonic-gate 				    IN6_ARE_ADDR_EQUAL(&sin1->sin6_addr,
41250Sstevel@tonic-gate 					&sin2->sin6_addr))
41260Sstevel@tonic-gate 					match = B_TRUE;
41270Sstevel@tonic-gate 				break;
41280Sstevel@tonic-gate 			}
41290Sstevel@tonic-gate 			case AF_UNIX:
41300Sstevel@tonic-gate 			default:
41310Sstevel@tonic-gate 				if (namelen == addrlen &&
41320Sstevel@tonic-gate 				    bcmp(name, addr, namelen) == 0)
41330Sstevel@tonic-gate 					match = B_TRUE;
41340Sstevel@tonic-gate 			}
41350Sstevel@tonic-gate 			if (match) {
41360Sstevel@tonic-gate 				freemsg(so->so_eaddr_mp);
41370Sstevel@tonic-gate 				so->so_eaddr_mp = NULL;
41380Sstevel@tonic-gate 				mutex_exit(&so->so_lock);
41390Sstevel@tonic-gate #ifdef DEBUG
41400Sstevel@tonic-gate 				dprintso(so, 0,
41410Sstevel@tonic-gate 					("sockfs delayed error %d for %s\n",
41420Sstevel@tonic-gate 					error,
41430Sstevel@tonic-gate 					pr_addr(so->so_family, name, namelen)));
41440Sstevel@tonic-gate #endif /* DEBUG */
41450Sstevel@tonic-gate 				return (error);
41460Sstevel@tonic-gate 			}
41470Sstevel@tonic-gate 			freemsg(so->so_eaddr_mp);
41480Sstevel@tonic-gate 			so->so_eaddr_mp = NULL;
41490Sstevel@tonic-gate 		}
41500Sstevel@tonic-gate 	}
41510Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
41520Sstevel@tonic-gate 
41530Sstevel@tonic-gate 	flags = msg->msg_flags;
41540Sstevel@tonic-gate 	dontroute = 0;
41550Sstevel@tonic-gate 	if ((flags & MSG_DONTROUTE) && !(so->so_options & SO_DONTROUTE)) {
41560Sstevel@tonic-gate 		uint32_t	val;
41570Sstevel@tonic-gate 
41580Sstevel@tonic-gate 		val = 1;
41590Sstevel@tonic-gate 		error = sotpi_setsockopt(so, SOL_SOCKET, SO_DONTROUTE,
41600Sstevel@tonic-gate 					&val, (t_uscalar_t)sizeof (val));
41610Sstevel@tonic-gate 		if (error)
41620Sstevel@tonic-gate 			return (error);
41630Sstevel@tonic-gate 		dontroute = 1;
41640Sstevel@tonic-gate 	}
41650Sstevel@tonic-gate 
41660Sstevel@tonic-gate 	if ((flags & MSG_OOB) && !(so_mode & SM_EXDATA)) {
41670Sstevel@tonic-gate 		error = EOPNOTSUPP;
41680Sstevel@tonic-gate 		goto done;
41690Sstevel@tonic-gate 	}
41700Sstevel@tonic-gate 	if (msg->msg_controllen != 0) {
41710Sstevel@tonic-gate 		if (!(so_mode & SM_CONNREQUIRED)) {
41720Sstevel@tonic-gate 			error = sosend_dgramcmsg(so, name, namelen, uiop,
4173741Smasputra 			    msg->msg_control, msg->msg_controllen, flags);
41740Sstevel@tonic-gate 		} else {
41750Sstevel@tonic-gate 			if (flags & MSG_OOB) {
41760Sstevel@tonic-gate 				/* Can't generate T_EXDATA_REQ with options */
41770Sstevel@tonic-gate 				error = EOPNOTSUPP;
41780Sstevel@tonic-gate 				goto done;
41790Sstevel@tonic-gate 			}
41800Sstevel@tonic-gate 			error = sosend_svccmsg(so, uiop,
41810Sstevel@tonic-gate 				!(flags & MSG_EOR),
41820Sstevel@tonic-gate 				msg->msg_control, msg->msg_controllen,
41830Sstevel@tonic-gate 				flags);
41840Sstevel@tonic-gate 		}
41850Sstevel@tonic-gate 		goto done;
41860Sstevel@tonic-gate 	}
41870Sstevel@tonic-gate 
41880Sstevel@tonic-gate 	if (!(so_mode & SM_CONNREQUIRED)) {
41890Sstevel@tonic-gate 		/*
41900Sstevel@tonic-gate 		 * If there is no SO_DONTROUTE to turn off return immediately
4191741Smasputra 		 * from send_dgram. This can allow tail-call optimizations.
41920Sstevel@tonic-gate 		 */
41930Sstevel@tonic-gate 		if (!dontroute) {
41940Sstevel@tonic-gate 			return (sosend_dgram(so, name, namelen, uiop, flags));
41950Sstevel@tonic-gate 		}
41960Sstevel@tonic-gate 		error = sosend_dgram(so, name, namelen, uiop, flags);
41970Sstevel@tonic-gate 	} else {
41980Sstevel@tonic-gate 		t_scalar_t prim;
41990Sstevel@tonic-gate 		int sflag;
42000Sstevel@tonic-gate 
42010Sstevel@tonic-gate 		/* Ignore msg_name in the connected state */
42020Sstevel@tonic-gate 		if (flags & MSG_OOB) {
42030Sstevel@tonic-gate 			prim = T_EXDATA_REQ;
42040Sstevel@tonic-gate 			/*
42050Sstevel@tonic-gate 			 * Send down T_EXDATA_REQ even if there is flow
42060Sstevel@tonic-gate 			 * control for data.
42070Sstevel@tonic-gate 			 */
42080Sstevel@tonic-gate 			sflag = MSG_IGNFLOW;
42090Sstevel@tonic-gate 		} else {
42100Sstevel@tonic-gate 			if (so_mode & SM_BYTESTREAM) {
42110Sstevel@tonic-gate 				/* Byte stream transport - use write */
42120Sstevel@tonic-gate 
42130Sstevel@tonic-gate 				dprintso(so, 1, ("sotpi_sendmsg: write\n"));
42140Sstevel@tonic-gate 				/*
4215741Smasputra 				 * If there is no SO_DONTROUTE to turn off,
4216741Smasputra 				 * SS_DIRECT is on, and there is no flow
4217741Smasputra 				 * control, we can take the fast path.
42180Sstevel@tonic-gate 				 */
4219741Smasputra 				if (!dontroute &&
4220741Smasputra 				    (so_state & SS_DIRECT) &&
4221741Smasputra 				    canputnext(SOTOV(so)->v_stream->sd_wrq)) {
4222741Smasputra 					return (sostream_direct(so, uiop,
4223741Smasputra 					    NULL, CRED()));
4224741Smasputra 				}
42250Sstevel@tonic-gate 				error = strwrite(SOTOV(so), uiop, CRED());
42260Sstevel@tonic-gate 				goto done;
42270Sstevel@tonic-gate 			}
42280Sstevel@tonic-gate 			prim = T_DATA_REQ;
42290Sstevel@tonic-gate 			sflag = 0;
42300Sstevel@tonic-gate 		}
42310Sstevel@tonic-gate 		/*
42320Sstevel@tonic-gate 		 * If there is no SO_DONTROUTE to turn off return immediately
42330Sstevel@tonic-gate 		 * from sosend_svc. This can allow tail-call optimizations.
42340Sstevel@tonic-gate 		 */
42350Sstevel@tonic-gate 		if (!dontroute)
42360Sstevel@tonic-gate 			return (sosend_svc(so, uiop, prim,
42370Sstevel@tonic-gate 				!(flags & MSG_EOR), sflag));
42380Sstevel@tonic-gate 		error = sosend_svc(so, uiop, prim,
42390Sstevel@tonic-gate 				!(flags & MSG_EOR), sflag);
42400Sstevel@tonic-gate 	}
42410Sstevel@tonic-gate 	ASSERT(dontroute);
42420Sstevel@tonic-gate done:
42430Sstevel@tonic-gate 	if (dontroute) {
42440Sstevel@tonic-gate 		uint32_t	val;
42450Sstevel@tonic-gate 
42460Sstevel@tonic-gate 		val = 0;
42470Sstevel@tonic-gate 		(void) sotpi_setsockopt(so, SOL_SOCKET, SO_DONTROUTE,
42480Sstevel@tonic-gate 				&val, (t_uscalar_t)sizeof (val));
42490Sstevel@tonic-gate 	}
42500Sstevel@tonic-gate 	return (error);
42510Sstevel@tonic-gate }
42520Sstevel@tonic-gate 
42530Sstevel@tonic-gate /*
4254741Smasputra  * Sending data on a datagram socket.
4255741Smasputra  * Assumes caller has verified that SS_ISBOUND etc. are set.
4256741Smasputra  */
4257741Smasputra /* ARGSUSED */
4258741Smasputra static int
4259741Smasputra sodgram_direct(struct sonode *so, struct sockaddr *name,
4260741Smasputra     socklen_t namelen, struct uio *uiop, int flags)
4261741Smasputra {
4262741Smasputra 	struct T_unitdata_req	tudr;
4263741Smasputra 	mblk_t			*mp;
4264741Smasputra 	int			error = 0;
4265741Smasputra 	void			*addr;
4266741Smasputra 	socklen_t		addrlen;
4267741Smasputra 	ssize_t			len;
4268741Smasputra 	struct stdata		*stp = SOTOV(so)->v_stream;
4269741Smasputra 	int			so_state;
4270741Smasputra 	queue_t			*udp_wq;
4271741Smasputra 
4272741Smasputra 	ASSERT(name != NULL && namelen != 0);
4273741Smasputra 	ASSERT(!(so->so_mode & SM_CONNREQUIRED));
4274741Smasputra 	ASSERT(!(so->so_mode & SM_EXDATA));
4275741Smasputra 	ASSERT(so->so_family == AF_INET || so->so_family == AF_INET6);
4276741Smasputra 	ASSERT(SOTOV(so)->v_type == VSOCK);
4277741Smasputra 
4278741Smasputra 	/* Caller checked for proper length */
4279741Smasputra 	len = uiop->uio_resid;
4280741Smasputra 	ASSERT(len <= so->so_tidu_size);
4281741Smasputra 
4282741Smasputra 	/* Length and family checks have been done by caller */
4283741Smasputra 	ASSERT(name->sa_family == so->so_family);
4284741Smasputra 	ASSERT(so->so_family == AF_INET ||
4285741Smasputra 	    (namelen == (socklen_t)sizeof (struct sockaddr_in6)));
4286741Smasputra 	ASSERT(so->so_family == AF_INET6 ||
4287741Smasputra 	    (namelen == (socklen_t)sizeof (struct sockaddr_in)));
4288741Smasputra 
4289741Smasputra 	addr = name;
4290741Smasputra 	addrlen = namelen;
4291741Smasputra 
4292741Smasputra 	if (stp->sd_sidp != NULL &&
4293741Smasputra 	    (error = straccess(stp, JCWRITE)) != 0)
4294741Smasputra 		goto done;
4295741Smasputra 
4296741Smasputra 	so_state = so->so_state;
4297741Smasputra 
4298741Smasputra 	/*
4299741Smasputra 	 * For UDP we don't break up the copyin into smaller pieces
4300741Smasputra 	 * as in the TCP case.  That means if ENOMEM is returned by
4301741Smasputra 	 * mcopyinuio() then the uio vector has not been modified at
4302741Smasputra 	 * all and we fallback to either strwrite() or kstrputmsg()
4303741Smasputra 	 * below.  Note also that we never generate priority messages
4304741Smasputra 	 * from here.
4305741Smasputra 	 */
4306741Smasputra 	udp_wq = stp->sd_wrq->q_next;
4307741Smasputra 	if (canput(udp_wq) &&
4308741Smasputra 	    (mp = mcopyinuio(stp, uiop, -1, -1, &error)) != NULL) {
4309741Smasputra 		ASSERT(DB_TYPE(mp) == M_DATA);
4310741Smasputra 		ASSERT(uiop->uio_resid == 0);
4311741Smasputra #ifdef C2_AUDIT
4312741Smasputra 		if (audit_active)
4313741Smasputra 			audit_sock(T_UNITDATA_REQ, strvp2wq(SOTOV(so)), mp, 0);
4314741Smasputra #endif /* C2_AUDIT */
4315741Smasputra 		udp_wput_data(udp_wq, mp, addr, addrlen);
4316741Smasputra 		return (0);
4317741Smasputra 	}
4318741Smasputra 	if (error != 0 && error != ENOMEM)
4319741Smasputra 		return (error);
4320741Smasputra 
4321741Smasputra 	/*
4322741Smasputra 	 * For connected, let strwrite() handle the blocking case.
4323741Smasputra 	 * Otherwise we fall thru and use kstrputmsg().
4324741Smasputra 	 */
4325741Smasputra 	if (so_state & SS_ISCONNECTED)
4326741Smasputra 		return (strwrite(SOTOV(so), uiop, CRED()));
4327741Smasputra 
4328741Smasputra 	tudr.PRIM_type = T_UNITDATA_REQ;
4329741Smasputra 	tudr.DEST_length = addrlen;
4330741Smasputra 	tudr.DEST_offset = (t_scalar_t)sizeof (tudr);
4331741Smasputra 	tudr.OPT_length = 0;
4332741Smasputra 	tudr.OPT_offset = 0;
4333741Smasputra 
4334741Smasputra 	mp = soallocproto2(&tudr, sizeof (tudr), addr, addrlen, 0, _ALLOC_INTR);
4335741Smasputra 	if (mp == NULL) {
4336741Smasputra 		/*
4337741Smasputra 		 * Caught a signal waiting for memory.
4338741Smasputra 		 * Let send* return EINTR.
4339741Smasputra 		 */
4340741Smasputra 		error = EINTR;
4341741Smasputra 		goto done;
4342741Smasputra 	}
4343741Smasputra 
4344741Smasputra #ifdef C2_AUDIT
4345741Smasputra 	if (audit_active)
4346741Smasputra 		audit_sock(T_UNITDATA_REQ, strvp2wq(SOTOV(so)), mp, 0);
4347741Smasputra #endif /* C2_AUDIT */
4348741Smasputra 
4349741Smasputra 	error = kstrputmsg(SOTOV(so), mp, uiop, len, 0, MSG_BAND, 0);
4350741Smasputra done:
4351741Smasputra #ifdef SOCK_DEBUG
4352741Smasputra 	if (error != 0) {
4353741Smasputra 		eprintsoline(so, error);
4354741Smasputra 	}
4355741Smasputra #endif /* SOCK_DEBUG */
4356741Smasputra 	return (error);
4357741Smasputra }
4358741Smasputra 
4359741Smasputra int
4360741Smasputra sostream_direct(struct sonode *so, struct uio *uiop, mblk_t *mp, cred_t *cr)
4361741Smasputra {
4362741Smasputra 	struct stdata *stp = SOTOV(so)->v_stream;
4363741Smasputra 	ssize_t iosize, rmax, maxblk;
4364741Smasputra 	queue_t *tcp_wq = stp->sd_wrq->q_next;
4365898Skais 	mblk_t *newmp;
4366741Smasputra 	int error = 0, wflag = 0;
4367741Smasputra 
4368741Smasputra 	ASSERT(so->so_mode & SM_BYTESTREAM);
4369741Smasputra 	ASSERT(SOTOV(so)->v_type == VSOCK);
4370741Smasputra 
4371741Smasputra 	if (stp->sd_sidp != NULL &&
4372741Smasputra 	    (error = straccess(stp, JCWRITE)) != 0)
4373741Smasputra 		return (error);
4374741Smasputra 
4375741Smasputra 	if (uiop == NULL) {
4376741Smasputra 		/*
4377741Smasputra 		 * kstrwritemp() should have checked sd_flag and
4378741Smasputra 		 * flow-control before coming here.  If we end up
4379741Smasputra 		 * here it means that we can simply pass down the
4380741Smasputra 		 * data to tcp.
4381741Smasputra 		 */
4382741Smasputra 		ASSERT(mp != NULL);
4383898Skais 		if (stp->sd_wputdatafunc != NULL) {
4384898Skais 			newmp = (stp->sd_wputdatafunc)(SOTOV(so), mp, NULL,
4385898Skais 			    NULL, NULL, NULL);
4386898Skais 			if (newmp == NULL) {
4387898Skais 				/* The caller will free mp */
4388898Skais 				return (ECOMM);
4389898Skais 			}
4390898Skais 			mp = newmp;
4391898Skais 		}
4392741Smasputra 		tcp_wput(tcp_wq, mp);
4393741Smasputra 		return (0);
4394741Smasputra 	}
4395741Smasputra 
4396741Smasputra 	/* Fallback to strwrite() to do proper error handling */
4397741Smasputra 	if (stp->sd_flag & (STWRERR|STRHUP|STPLEX|STRDELIM|OLDNDELAY))
4398741Smasputra 		return (strwrite(SOTOV(so), uiop, cr));
4399741Smasputra 
4400741Smasputra 	rmax = stp->sd_qn_maxpsz;
4401741Smasputra 	ASSERT(rmax >= 0 || rmax == INFPSZ);
4402741Smasputra 	if (rmax == 0 || uiop->uio_resid <= 0)
4403741Smasputra 		return (0);
4404741Smasputra 
4405741Smasputra 	if (rmax == INFPSZ)
4406741Smasputra 		rmax = uiop->uio_resid;
4407741Smasputra 
4408741Smasputra 	maxblk = stp->sd_maxblk;
4409741Smasputra 
4410741Smasputra 	for (;;) {
4411741Smasputra 		iosize = MIN(uiop->uio_resid, rmax);
4412741Smasputra 
4413741Smasputra 		mp = mcopyinuio(stp, uiop, iosize, maxblk, &error);
4414741Smasputra 		if (mp == NULL) {
4415741Smasputra 			/*
4416741Smasputra 			 * Fallback to strwrite() for ENOMEM; if this
4417741Smasputra 			 * is our first time in this routine and the uio
4418741Smasputra 			 * vector has not been modified, we will end up
4419741Smasputra 			 * calling strwrite() without any flag set.
4420741Smasputra 			 */
4421741Smasputra 			if (error == ENOMEM)
4422741Smasputra 				goto slow_send;
4423741Smasputra 			else
4424741Smasputra 				return (error);
4425741Smasputra 		}
4426741Smasputra 		ASSERT(uiop->uio_resid >= 0);
4427741Smasputra 		/*
4428741Smasputra 		 * If mp is non-NULL and ENOMEM is set, it means that
4429741Smasputra 		 * mcopyinuio() was able to break down some of the user
4430741Smasputra 		 * data into one or more mblks.  Send the partial data
4431741Smasputra 		 * to tcp and let the rest be handled in strwrite().
4432741Smasputra 		 */
4433741Smasputra 		ASSERT(error == 0 || error == ENOMEM);
4434898Skais 		if (stp->sd_wputdatafunc != NULL) {
4435898Skais 			newmp = (stp->sd_wputdatafunc)(SOTOV(so), mp, NULL,
4436898Skais 			    NULL, NULL, NULL);
4437898Skais 			if (newmp == NULL) {
4438898Skais 				/* The caller will free mp */
4439898Skais 				return (ECOMM);
4440898Skais 			}
4441898Skais 			mp = newmp;
4442898Skais 		}
4443741Smasputra 		tcp_wput(tcp_wq, mp);
4444741Smasputra 
4445741Smasputra 		wflag |= NOINTR;
4446741Smasputra 
4447741Smasputra 		if (uiop->uio_resid == 0) {	/* No more data; we're done */
4448741Smasputra 			ASSERT(error == 0);
4449741Smasputra 			break;
4450741Smasputra 		} else if (error == ENOMEM || !canput(tcp_wq) || (stp->sd_flag &
4451741Smasputra 		    (STWRERR|STRHUP|STPLEX|STRDELIM|OLDNDELAY))) {
4452741Smasputra slow_send:
4453741Smasputra 			/*
4454741Smasputra 			 * We were able to send down partial data using
4455741Smasputra 			 * the direct call interface, but are now relying
4456741Smasputra 			 * on strwrite() to handle the non-fastpath cases.
4457741Smasputra 			 * If the socket is blocking we will sleep in
4458741Smasputra 			 * strwaitq() until write is permitted, otherwise,
4459741Smasputra 			 * we will need to return the amount of bytes
4460741Smasputra 			 * written so far back to the app.  This is the
4461741Smasputra 			 * reason why we pass NOINTR flag to strwrite()
4462741Smasputra 			 * for non-blocking socket, because we don't want
4463741Smasputra 			 * to return EAGAIN when portion of the user data
4464741Smasputra 			 * has actually been sent down.
4465741Smasputra 			 */
4466741Smasputra 			return (strwrite_common(SOTOV(so), uiop, cr, wflag));
4467741Smasputra 		}
4468741Smasputra 	}
4469741Smasputra 	return (0);
4470741Smasputra }
4471741Smasputra 
4472741Smasputra /*
44730Sstevel@tonic-gate  * Update so_faddr by asking the transport (unless AF_UNIX).
44740Sstevel@tonic-gate  */
44750Sstevel@tonic-gate int
44760Sstevel@tonic-gate sotpi_getpeername(struct sonode *so)
44770Sstevel@tonic-gate {
44780Sstevel@tonic-gate 	struct strbuf	strbuf;
44790Sstevel@tonic-gate 	int		error = 0, res;
44800Sstevel@tonic-gate 	void		*addr;
44810Sstevel@tonic-gate 	t_uscalar_t	addrlen;
44820Sstevel@tonic-gate 	k_sigset_t	smask;
44830Sstevel@tonic-gate 
44840Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_getpeername(%p) %s\n",
44850Sstevel@tonic-gate 		so, pr_state(so->so_state, so->so_mode)));
44860Sstevel@tonic-gate 
44870Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
44880Sstevel@tonic-gate 	so_lock_single(so);	/* Set SOLOCKED */
44890Sstevel@tonic-gate 	if (!(so->so_state & SS_ISCONNECTED)) {
44900Sstevel@tonic-gate 		error = ENOTCONN;
44910Sstevel@tonic-gate 		goto done;
44920Sstevel@tonic-gate 	}
44930Sstevel@tonic-gate 	/* Added this check for X/Open */
44940Sstevel@tonic-gate 	if ((so->so_state & SS_CANTSENDMORE) && !xnet_skip_checks) {
44950Sstevel@tonic-gate 		error = EINVAL;
44960Sstevel@tonic-gate 		if (xnet_check_print) {
44970Sstevel@tonic-gate 			printf("sockfs: X/Open getpeername check => EINVAL\n");
44980Sstevel@tonic-gate 		}
44990Sstevel@tonic-gate 		goto done;
45000Sstevel@tonic-gate 	}
45010Sstevel@tonic-gate #ifdef DEBUG
45020Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_getpeername (local): %s\n",
45030Sstevel@tonic-gate 		pr_addr(so->so_family, so->so_faddr_sa,
45040Sstevel@tonic-gate 			(t_uscalar_t)so->so_faddr_len)));
45050Sstevel@tonic-gate #endif /* DEBUG */
45060Sstevel@tonic-gate 
45070Sstevel@tonic-gate 	if (so->so_family == AF_UNIX || so->so_family == AF_NCA) {
45080Sstevel@tonic-gate 		/* Transport has different name space - return local info */
45090Sstevel@tonic-gate 		error = 0;
45100Sstevel@tonic-gate 		goto done;
45110Sstevel@tonic-gate 	}
45120Sstevel@tonic-gate 
45130Sstevel@tonic-gate 	ASSERT(so->so_faddr_sa);
45140Sstevel@tonic-gate 	/* Allocate local buffer to use with ioctl */
45150Sstevel@tonic-gate 	addrlen = (t_uscalar_t)so->so_faddr_maxlen;
45160Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
45170Sstevel@tonic-gate 	addr = kmem_alloc(addrlen, KM_SLEEP);
45180Sstevel@tonic-gate 
45190Sstevel@tonic-gate 	/*
45200Sstevel@tonic-gate 	 * Issue TI_GETPEERNAME with signals masked.
45210Sstevel@tonic-gate 	 * Put the result in so_faddr_sa so that getpeername works after
45220Sstevel@tonic-gate 	 * a shutdown(output).
45230Sstevel@tonic-gate 	 * If the ioctl fails (e.g. due to a ECONNRESET) the error is reposted
45240Sstevel@tonic-gate 	 * back to the socket.
45250Sstevel@tonic-gate 	 */
45260Sstevel@tonic-gate 	strbuf.buf = addr;
45270Sstevel@tonic-gate 	strbuf.maxlen = addrlen;
45280Sstevel@tonic-gate 	strbuf.len = 0;
45290Sstevel@tonic-gate 
45300Sstevel@tonic-gate 	sigintr(&smask, 0);
45310Sstevel@tonic-gate 	res = 0;
45320Sstevel@tonic-gate 	ASSERT(CRED());
45330Sstevel@tonic-gate 	error = strioctl(SOTOV(so), TI_GETPEERNAME, (intptr_t)&strbuf,
45340Sstevel@tonic-gate 			0, K_TO_K, CRED(), &res);
45350Sstevel@tonic-gate 	sigunintr(&smask);
45360Sstevel@tonic-gate 
45370Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
45380Sstevel@tonic-gate 	/*
45390Sstevel@tonic-gate 	 * If there is an error record the error in so_error put don't fail
45400Sstevel@tonic-gate 	 * the getpeername. Instead fallback on the recorded
45410Sstevel@tonic-gate 	 * so->so_faddr_sa.
45420Sstevel@tonic-gate 	 */
45430Sstevel@tonic-gate 	if (error) {
45440Sstevel@tonic-gate 		/*
45450Sstevel@tonic-gate 		 * Various stream head errors can be returned to the ioctl.
45460Sstevel@tonic-gate 		 * However, it is impossible to determine which ones of
45470Sstevel@tonic-gate 		 * these are really socket level errors that were incorrectly
45480Sstevel@tonic-gate 		 * consumed by the ioctl. Thus this code silently ignores the
45490Sstevel@tonic-gate 		 * error - to code explicitly does not reinstate the error
45500Sstevel@tonic-gate 		 * using soseterror().
45510Sstevel@tonic-gate 		 * Experiments have shows that at least this set of
45520Sstevel@tonic-gate 		 * errors are reported and should not be reinstated on the
45530Sstevel@tonic-gate 		 * socket:
45540Sstevel@tonic-gate 		 *	EINVAL	E.g. if an I_LINK was in effect when
45550Sstevel@tonic-gate 		 *		getpeername was called.
45560Sstevel@tonic-gate 		 *	EPIPE	The ioctl error semantics prefer the write
45570Sstevel@tonic-gate 		 *		side error over the read side error.
45580Sstevel@tonic-gate 		 *	ENOTCONN The transport just got disconnected but
45590Sstevel@tonic-gate 		 *		sockfs had not yet seen the T_DISCON_IND
45600Sstevel@tonic-gate 		 *		when issuing the ioctl.
45610Sstevel@tonic-gate 		 */
45620Sstevel@tonic-gate 		error = 0;
45630Sstevel@tonic-gate 	} else if (res == 0 && strbuf.len > 0 &&
45640Sstevel@tonic-gate 	    (so->so_state & SS_ISCONNECTED)) {
45650Sstevel@tonic-gate 		ASSERT(strbuf.len <= (int)so->so_faddr_maxlen);
45660Sstevel@tonic-gate 		so->so_faddr_len = (socklen_t)strbuf.len;
45670Sstevel@tonic-gate 		bcopy(addr, so->so_faddr_sa, so->so_faddr_len);
45680Sstevel@tonic-gate 		so->so_state |= SS_FADDR_VALID;
45690Sstevel@tonic-gate 	}
45700Sstevel@tonic-gate 	kmem_free(addr, addrlen);
45710Sstevel@tonic-gate #ifdef DEBUG
45720Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_getpeername (tp): %s\n",
45730Sstevel@tonic-gate 			pr_addr(so->so_family, so->so_faddr_sa,
45740Sstevel@tonic-gate 				(t_uscalar_t)so->so_faddr_len)));
45750Sstevel@tonic-gate #endif /* DEBUG */
45760Sstevel@tonic-gate done:
45770Sstevel@tonic-gate 	so_unlock_single(so, SOLOCKED);
45780Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
45790Sstevel@tonic-gate 	return (error);
45800Sstevel@tonic-gate }
45810Sstevel@tonic-gate 
45820Sstevel@tonic-gate /*
45830Sstevel@tonic-gate  * Update so_laddr by asking the transport (unless AF_UNIX).
45840Sstevel@tonic-gate  */
45850Sstevel@tonic-gate int
45860Sstevel@tonic-gate sotpi_getsockname(struct sonode *so)
45870Sstevel@tonic-gate {
45880Sstevel@tonic-gate 	struct strbuf	strbuf;
45890Sstevel@tonic-gate 	int		error = 0, res;
45900Sstevel@tonic-gate 	void		*addr;
45910Sstevel@tonic-gate 	t_uscalar_t	addrlen;
45920Sstevel@tonic-gate 	k_sigset_t	smask;
45930Sstevel@tonic-gate 
45940Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_getsockname(%p) %s\n",
45950Sstevel@tonic-gate 		so, pr_state(so->so_state, so->so_mode)));
45960Sstevel@tonic-gate 
45970Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
45980Sstevel@tonic-gate 	so_lock_single(so);	/* Set SOLOCKED */
45990Sstevel@tonic-gate 	if (!(so->so_state & SS_ISBOUND) && so->so_family != AF_UNIX) {
46000Sstevel@tonic-gate 		/* Return an all zero address except for the family */
46010Sstevel@tonic-gate 		if (so->so_family == AF_INET)
46020Sstevel@tonic-gate 			so->so_laddr_len = (socklen_t)sizeof (sin_t);
46030Sstevel@tonic-gate 		else if (so->so_family == AF_INET6)
46040Sstevel@tonic-gate 			so->so_laddr_len = (socklen_t)sizeof (sin6_t);
46050Sstevel@tonic-gate 		ASSERT(so->so_laddr_len <= so->so_laddr_maxlen);
46060Sstevel@tonic-gate 		bzero(so->so_laddr_sa, so->so_laddr_len);
46070Sstevel@tonic-gate 		/*
46080Sstevel@tonic-gate 		 * Can not assume there is a sa_family for all
46090Sstevel@tonic-gate 		 * protocol families.
46100Sstevel@tonic-gate 		 */
46110Sstevel@tonic-gate 		if (so->so_family == AF_INET || so->so_family == AF_INET6)
46120Sstevel@tonic-gate 			so->so_laddr_sa->sa_family = so->so_family;
46130Sstevel@tonic-gate 	}
46140Sstevel@tonic-gate #ifdef DEBUG
46150Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_getsockname (local): %s\n",
46160Sstevel@tonic-gate 		pr_addr(so->so_family, so->so_laddr_sa,
46170Sstevel@tonic-gate 			(t_uscalar_t)so->so_laddr_len)));
46180Sstevel@tonic-gate #endif /* DEBUG */
46190Sstevel@tonic-gate 	if (so->so_family == AF_UNIX) {
46200Sstevel@tonic-gate 		/* Transport has different name space - return local info */
46210Sstevel@tonic-gate 		error = 0;
46220Sstevel@tonic-gate 		goto done;
46230Sstevel@tonic-gate 	}
4624*1156Sblu 	if (!(so->so_state & SS_ISBOUND)) {
4625*1156Sblu 		/* If not bound, then nothing to return. */
4626*1156Sblu 		error = 0;
4627*1156Sblu 		goto done;
4628*1156Sblu 	}
46290Sstevel@tonic-gate 	/* Allocate local buffer to use with ioctl */
46300Sstevel@tonic-gate 	addrlen = (t_uscalar_t)so->so_laddr_maxlen;
46310Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
46320Sstevel@tonic-gate 	addr = kmem_alloc(addrlen, KM_SLEEP);
46330Sstevel@tonic-gate 
46340Sstevel@tonic-gate 	/*
46350Sstevel@tonic-gate 	 * Issue TI_GETMYNAME with signals masked.
46360Sstevel@tonic-gate 	 * Put the result in so_laddr_sa so that getsockname works after
46370Sstevel@tonic-gate 	 * a shutdown(output).
46380Sstevel@tonic-gate 	 * If the ioctl fails (e.g. due to a ECONNRESET) the error is reposted
46390Sstevel@tonic-gate 	 * back to the socket.
46400Sstevel@tonic-gate 	 */
46410Sstevel@tonic-gate 	strbuf.buf = addr;
46420Sstevel@tonic-gate 	strbuf.maxlen = addrlen;
46430Sstevel@tonic-gate 	strbuf.len = 0;
46440Sstevel@tonic-gate 
46450Sstevel@tonic-gate 	sigintr(&smask, 0);
46460Sstevel@tonic-gate 	res = 0;
46470Sstevel@tonic-gate 	ASSERT(CRED());
46480Sstevel@tonic-gate 	error = strioctl(SOTOV(so), TI_GETMYNAME, (intptr_t)&strbuf,
46490Sstevel@tonic-gate 			0, K_TO_K, CRED(), &res);
46500Sstevel@tonic-gate 	sigunintr(&smask);
46510Sstevel@tonic-gate 
46520Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
46530Sstevel@tonic-gate 	/*
46540Sstevel@tonic-gate 	 * If there is an error record the error in so_error put don't fail
46550Sstevel@tonic-gate 	 * the getsockname. Instead fallback on the recorded
46560Sstevel@tonic-gate 	 * so->so_laddr_sa.
46570Sstevel@tonic-gate 	 */
46580Sstevel@tonic-gate 	if (error) {
46590Sstevel@tonic-gate 		/*
46600Sstevel@tonic-gate 		 * Various stream head errors can be returned to the ioctl.
46610Sstevel@tonic-gate 		 * However, it is impossible to determine which ones of
46620Sstevel@tonic-gate 		 * these are really socket level errors that were incorrectly
46630Sstevel@tonic-gate 		 * consumed by the ioctl. Thus this code silently ignores the
46640Sstevel@tonic-gate 		 * error - to code explicitly does not reinstate the error
46650Sstevel@tonic-gate 		 * using soseterror().
46660Sstevel@tonic-gate 		 * Experiments have shows that at least this set of
46670Sstevel@tonic-gate 		 * errors are reported and should not be reinstated on the
46680Sstevel@tonic-gate 		 * socket:
46690Sstevel@tonic-gate 		 *	EINVAL	E.g. if an I_LINK was in effect when
46700Sstevel@tonic-gate 		 *		getsockname was called.
46710Sstevel@tonic-gate 		 *	EPIPE	The ioctl error semantics prefer the write
46720Sstevel@tonic-gate 		 *		side error over the read side error.
46730Sstevel@tonic-gate 		 */
46740Sstevel@tonic-gate 		error = 0;
46750Sstevel@tonic-gate 	} else if (res == 0 && strbuf.len > 0 &&
46760Sstevel@tonic-gate 	    (so->so_state & SS_ISBOUND)) {
46770Sstevel@tonic-gate 		ASSERT(strbuf.len <= (int)so->so_laddr_maxlen);
46780Sstevel@tonic-gate 		so->so_laddr_len = (socklen_t)strbuf.len;
46790Sstevel@tonic-gate 		bcopy(addr, so->so_laddr_sa, so->so_laddr_len);
46800Sstevel@tonic-gate 		so->so_state |= SS_LADDR_VALID;
46810Sstevel@tonic-gate 	}
46820Sstevel@tonic-gate 	kmem_free(addr, addrlen);
46830Sstevel@tonic-gate #ifdef DEBUG
46840Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_getsockname (tp): %s\n",
46850Sstevel@tonic-gate 			pr_addr(so->so_family, so->so_laddr_sa,
46860Sstevel@tonic-gate 				(t_uscalar_t)so->so_laddr_len)));
46870Sstevel@tonic-gate #endif /* DEBUG */
46880Sstevel@tonic-gate done:
46890Sstevel@tonic-gate 	so_unlock_single(so, SOLOCKED);
46900Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
46910Sstevel@tonic-gate 	return (error);
46920Sstevel@tonic-gate }
46930Sstevel@tonic-gate 
46940Sstevel@tonic-gate /*
46950Sstevel@tonic-gate  * Get socket options. For SOL_SOCKET options some options are handled
46960Sstevel@tonic-gate  * by the sockfs while others use the value recorded in the sonode as a
46970Sstevel@tonic-gate  * fallback should the T_SVR4_OPTMGMT_REQ fail.
46980Sstevel@tonic-gate  *
46990Sstevel@tonic-gate  * On the return most *optlenp bytes are copied to optval.
47000Sstevel@tonic-gate  */
47010Sstevel@tonic-gate int
47020Sstevel@tonic-gate sotpi_getsockopt(struct sonode *so, int level, int option_name,
47030Sstevel@tonic-gate 		void *optval, socklen_t *optlenp, int flags)
47040Sstevel@tonic-gate {
47050Sstevel@tonic-gate 	struct T_optmgmt_req	optmgmt_req;
47060Sstevel@tonic-gate 	struct T_optmgmt_ack	*optmgmt_ack;
47070Sstevel@tonic-gate 	struct opthdr		oh;
47080Sstevel@tonic-gate 	struct opthdr		*opt_res;
47090Sstevel@tonic-gate 	mblk_t			*mp = NULL;
47100Sstevel@tonic-gate 	int			error = 0;
47110Sstevel@tonic-gate 	void			*option = NULL;	/* Set if fallback value */
47120Sstevel@tonic-gate 	t_uscalar_t		maxlen = *optlenp;
47130Sstevel@tonic-gate 	t_uscalar_t		len;
47140Sstevel@tonic-gate 	uint32_t		value;
47150Sstevel@tonic-gate 
47160Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_getsockopt(%p, 0x%x, 0x%x, %p, %p) %s\n",
47170Sstevel@tonic-gate 			so, level, option_name, optval, optlenp,
47180Sstevel@tonic-gate 			pr_state(so->so_state, so->so_mode)));
47190Sstevel@tonic-gate 
47200Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
47210Sstevel@tonic-gate 	so_lock_single(so);	/* Set SOLOCKED */
47220Sstevel@tonic-gate 
47230Sstevel@tonic-gate 	/*
47240Sstevel@tonic-gate 	 * Check for SOL_SOCKET options.
47250Sstevel@tonic-gate 	 * Certain SOL_SOCKET options are returned directly whereas
47260Sstevel@tonic-gate 	 * others only provide a default (fallback) value should
47270Sstevel@tonic-gate 	 * the T_SVR4_OPTMGMT_REQ fail.
47280Sstevel@tonic-gate 	 */
47290Sstevel@tonic-gate 	if (level == SOL_SOCKET) {
47300Sstevel@tonic-gate 		/* Check parameters */
47310Sstevel@tonic-gate 		switch (option_name) {
47320Sstevel@tonic-gate 		case SO_TYPE:
47330Sstevel@tonic-gate 		case SO_ERROR:
47340Sstevel@tonic-gate 		case SO_DEBUG:
47350Sstevel@tonic-gate 		case SO_ACCEPTCONN:
47360Sstevel@tonic-gate 		case SO_REUSEADDR:
47370Sstevel@tonic-gate 		case SO_KEEPALIVE:
47380Sstevel@tonic-gate 		case SO_DONTROUTE:
47390Sstevel@tonic-gate 		case SO_BROADCAST:
47400Sstevel@tonic-gate 		case SO_USELOOPBACK:
47410Sstevel@tonic-gate 		case SO_OOBINLINE:
47420Sstevel@tonic-gate 		case SO_SNDBUF:
47430Sstevel@tonic-gate 		case SO_RCVBUF:
47440Sstevel@tonic-gate #ifdef notyet
47450Sstevel@tonic-gate 		case SO_SNDLOWAT:
47460Sstevel@tonic-gate 		case SO_RCVLOWAT:
47470Sstevel@tonic-gate 		case SO_SNDTIMEO:
47480Sstevel@tonic-gate 		case SO_RCVTIMEO:
47490Sstevel@tonic-gate #endif /* notyet */
47500Sstevel@tonic-gate 		case SO_DGRAM_ERRIND:
47510Sstevel@tonic-gate 			if (maxlen < (t_uscalar_t)sizeof (int32_t)) {
47520Sstevel@tonic-gate 				error = EINVAL;
47530Sstevel@tonic-gate 				eprintsoline(so, error);
47540Sstevel@tonic-gate 				goto done2;
47550Sstevel@tonic-gate 			}
47560Sstevel@tonic-gate 			break;
47570Sstevel@tonic-gate 		case SO_LINGER:
47580Sstevel@tonic-gate 			if (maxlen < (t_uscalar_t)sizeof (struct linger)) {
47590Sstevel@tonic-gate 				error = EINVAL;
47600Sstevel@tonic-gate 				eprintsoline(so, error);
47610Sstevel@tonic-gate 				goto done2;
47620Sstevel@tonic-gate 			}
47630Sstevel@tonic-gate 			break;
47640Sstevel@tonic-gate 		}
47650Sstevel@tonic-gate 
47660Sstevel@tonic-gate 		len = (t_uscalar_t)sizeof (uint32_t);	/* Default */
47670Sstevel@tonic-gate 
47680Sstevel@tonic-gate 		switch (option_name) {
47690Sstevel@tonic-gate 		case SO_TYPE:
47700Sstevel@tonic-gate 			value = so->so_type;
47710Sstevel@tonic-gate 			option = &value;
47720Sstevel@tonic-gate 			goto copyout; /* No need to issue T_SVR4_OPTMGMT_REQ */
47730Sstevel@tonic-gate 
47740Sstevel@tonic-gate 		case SO_ERROR:
47750Sstevel@tonic-gate 			value = sogeterr(so);
47760Sstevel@tonic-gate 			option = &value;
47770Sstevel@tonic-gate 			goto copyout; /* No need to issue T_SVR4_OPTMGMT_REQ */
47780Sstevel@tonic-gate 
47790Sstevel@tonic-gate 		case SO_ACCEPTCONN:
47800Sstevel@tonic-gate 			if (so->so_state & SS_ACCEPTCONN)
47810Sstevel@tonic-gate 				value = SO_ACCEPTCONN;
47820Sstevel@tonic-gate 			else
47830Sstevel@tonic-gate 				value = 0;
47840Sstevel@tonic-gate #ifdef DEBUG
47850Sstevel@tonic-gate 			if (value) {
47860Sstevel@tonic-gate 				dprintso(so, 1,
47870Sstevel@tonic-gate 				    ("sotpi_getsockopt: 0x%x is set\n",
47880Sstevel@tonic-gate 				    option_name));
47890Sstevel@tonic-gate 			} else {
47900Sstevel@tonic-gate 				dprintso(so, 1,
47910Sstevel@tonic-gate 				    ("sotpi_getsockopt: 0x%x not set\n",
47920Sstevel@tonic-gate 				    option_name));
47930Sstevel@tonic-gate 			}
47940Sstevel@tonic-gate #endif /* DEBUG */
47950Sstevel@tonic-gate 			option = &value;
47960Sstevel@tonic-gate 			goto copyout; /* No need to issue T_SVR4_OPTMGMT_REQ */
47970Sstevel@tonic-gate 
47980Sstevel@tonic-gate 		case SO_DEBUG:
47990Sstevel@tonic-gate 		case SO_REUSEADDR:
48000Sstevel@tonic-gate 		case SO_KEEPALIVE:
48010Sstevel@tonic-gate 		case SO_DONTROUTE:
48020Sstevel@tonic-gate 		case SO_BROADCAST:
48030Sstevel@tonic-gate 		case SO_USELOOPBACK:
48040Sstevel@tonic-gate 		case SO_OOBINLINE:
48050Sstevel@tonic-gate 		case SO_DGRAM_ERRIND:
48060Sstevel@tonic-gate 			value = (so->so_options & option_name);
48070Sstevel@tonic-gate #ifdef DEBUG
48080Sstevel@tonic-gate 			if (value) {
48090Sstevel@tonic-gate 				dprintso(so, 1,
48100Sstevel@tonic-gate 				    ("sotpi_getsockopt: 0x%x is set\n",
48110Sstevel@tonic-gate 				    option_name));
48120Sstevel@tonic-gate 			} else {
48130Sstevel@tonic-gate 				dprintso(so, 1,
48140Sstevel@tonic-gate 				    ("sotpi_getsockopt: 0x%x not set\n",
48150Sstevel@tonic-gate 				    option_name));
48160Sstevel@tonic-gate 			}
48170Sstevel@tonic-gate #endif /* DEBUG */
48180Sstevel@tonic-gate 			option = &value;
48190Sstevel@tonic-gate 			goto copyout; /* No need to issue T_SVR4_OPTMGMT_REQ */
48200Sstevel@tonic-gate 
48210Sstevel@tonic-gate 		/*
48220Sstevel@tonic-gate 		 * The following options are only returned by sockfs when the
48230Sstevel@tonic-gate 		 * T_SVR4_OPTMGMT_REQ fails.
48240Sstevel@tonic-gate 		 */
48250Sstevel@tonic-gate 		case SO_LINGER:
48260Sstevel@tonic-gate 			option = &so->so_linger;
48270Sstevel@tonic-gate 			len = (t_uscalar_t)sizeof (struct linger);
48280Sstevel@tonic-gate 			break;
48290Sstevel@tonic-gate 		case SO_SNDBUF: {
48300Sstevel@tonic-gate 			ssize_t lvalue;
48310Sstevel@tonic-gate 
48320Sstevel@tonic-gate 			/*
48330Sstevel@tonic-gate 			 * If the option has not been set then get a default
48340Sstevel@tonic-gate 			 * value from the read queue. This value is
48350Sstevel@tonic-gate 			 * returned if the transport fails
48360Sstevel@tonic-gate 			 * the T_SVR4_OPTMGMT_REQ.
48370Sstevel@tonic-gate 			 */
48380Sstevel@tonic-gate 			lvalue = so->so_sndbuf;
48390Sstevel@tonic-gate 			if (lvalue == 0) {
48400Sstevel@tonic-gate 				mutex_exit(&so->so_lock);
48410Sstevel@tonic-gate 				(void) strqget(strvp2wq(SOTOV(so))->q_next,
48420Sstevel@tonic-gate 						QHIWAT, 0, &lvalue);
48430Sstevel@tonic-gate 				mutex_enter(&so->so_lock);
48440Sstevel@tonic-gate 				dprintso(so, 1,
48450Sstevel@tonic-gate 				    ("got SO_SNDBUF %ld from q\n", lvalue));
48460Sstevel@tonic-gate 			}
48470Sstevel@tonic-gate 			value = (int)lvalue;
48480Sstevel@tonic-gate 			option = &value;
48490Sstevel@tonic-gate 			len = (t_uscalar_t)sizeof (so->so_sndbuf);
48500Sstevel@tonic-gate 			break;
48510Sstevel@tonic-gate 		}
48520Sstevel@tonic-gate 		case SO_RCVBUF: {
48530Sstevel@tonic-gate 			ssize_t lvalue;
48540Sstevel@tonic-gate 
48550Sstevel@tonic-gate 			/*
48560Sstevel@tonic-gate 			 * If the option has not been set then get a default
48570Sstevel@tonic-gate 			 * value from the read queue. This value is
48580Sstevel@tonic-gate 			 * returned if the transport fails
48590Sstevel@tonic-gate 			 * the T_SVR4_OPTMGMT_REQ.
48600Sstevel@tonic-gate 			 *
48610Sstevel@tonic-gate 			 * XXX If SO_RCVBUF has been set and this is an
48620Sstevel@tonic-gate 			 * XPG 4.2 application then do not ask the transport
48630Sstevel@tonic-gate 			 * since the transport might adjust the value and not
48640Sstevel@tonic-gate 			 * return exactly what was set by the application.
48650Sstevel@tonic-gate 			 * For non-XPG 4.2 application we return the value
48660Sstevel@tonic-gate 			 * that the transport is actually using.
48670Sstevel@tonic-gate 			 */
48680Sstevel@tonic-gate 			lvalue = so->so_rcvbuf;
48690Sstevel@tonic-gate 			if (lvalue == 0) {
48700Sstevel@tonic-gate 				mutex_exit(&so->so_lock);
48710Sstevel@tonic-gate 				(void) strqget(RD(strvp2wq(SOTOV(so))),
48720Sstevel@tonic-gate 						QHIWAT, 0, &lvalue);
48730Sstevel@tonic-gate 				mutex_enter(&so->so_lock);
48740Sstevel@tonic-gate 				dprintso(so, 1,
48750Sstevel@tonic-gate 				    ("got SO_RCVBUF %ld from q\n", lvalue));
48760Sstevel@tonic-gate 			} else if (flags & _SOGETSOCKOPT_XPG4_2) {
48770Sstevel@tonic-gate 				value = (int)lvalue;
48780Sstevel@tonic-gate 				option = &value;
48790Sstevel@tonic-gate 				goto copyout;	/* skip asking transport */
48800Sstevel@tonic-gate 			}
48810Sstevel@tonic-gate 			value = (int)lvalue;
48820Sstevel@tonic-gate 			option = &value;
48830Sstevel@tonic-gate 			len = (t_uscalar_t)sizeof (so->so_rcvbuf);
48840Sstevel@tonic-gate 			break;
48850Sstevel@tonic-gate 		}
48860Sstevel@tonic-gate #ifdef notyet
48870Sstevel@tonic-gate 		/*
48880Sstevel@tonic-gate 		 * We do not implement the semantics of these options
48890Sstevel@tonic-gate 		 * thus we shouldn't implement the options either.
48900Sstevel@tonic-gate 		 */
48910Sstevel@tonic-gate 		case SO_SNDLOWAT:
48920Sstevel@tonic-gate 			value = so->so_sndlowat;
48930Sstevel@tonic-gate 			option = &value;
48940Sstevel@tonic-gate 			break;
48950Sstevel@tonic-gate 		case SO_RCVLOWAT:
48960Sstevel@tonic-gate 			value = so->so_rcvlowat;
48970Sstevel@tonic-gate 			option = &value;
48980Sstevel@tonic-gate 			break;
48990Sstevel@tonic-gate 		case SO_SNDTIMEO:
49000Sstevel@tonic-gate 			value = so->so_sndtimeo;
49010Sstevel@tonic-gate 			option = &value;
49020Sstevel@tonic-gate 			break;
49030Sstevel@tonic-gate 		case SO_RCVTIMEO:
49040Sstevel@tonic-gate 			value = so->so_rcvtimeo;
49050Sstevel@tonic-gate 			option = &value;
49060Sstevel@tonic-gate 			break;
49070Sstevel@tonic-gate #endif /* notyet */
49080Sstevel@tonic-gate 		}
49090Sstevel@tonic-gate 	}
49100Sstevel@tonic-gate 
49110Sstevel@tonic-gate 	if (so->so_family == AF_NCA) {
49120Sstevel@tonic-gate 		goto done2;
49130Sstevel@tonic-gate 	}
49140Sstevel@tonic-gate 
49150Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
49160Sstevel@tonic-gate 
49170Sstevel@tonic-gate 	/* Send request */
49180Sstevel@tonic-gate 	optmgmt_req.PRIM_type = T_SVR4_OPTMGMT_REQ;
49190Sstevel@tonic-gate 	optmgmt_req.MGMT_flags = T_CHECK;
49200Sstevel@tonic-gate 	optmgmt_req.OPT_length = (t_scalar_t)(sizeof (oh) + maxlen);
49210Sstevel@tonic-gate 	optmgmt_req.OPT_offset = (t_scalar_t)sizeof (optmgmt_req);
49220Sstevel@tonic-gate 
49230Sstevel@tonic-gate 	oh.level = level;
49240Sstevel@tonic-gate 	oh.name = option_name;
49250Sstevel@tonic-gate 	oh.len = maxlen;
49260Sstevel@tonic-gate 
49270Sstevel@tonic-gate 	mp = soallocproto3(&optmgmt_req, sizeof (optmgmt_req),
49280Sstevel@tonic-gate 	    &oh, sizeof (oh), NULL, maxlen, 0, _ALLOC_SLEEP);
49290Sstevel@tonic-gate 	/* Let option management work in the presence of data flow control */
49300Sstevel@tonic-gate 	error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
49310Sstevel@tonic-gate 			MSG_BAND|MSG_HOLDSIG|MSG_IGNERROR|MSG_IGNFLOW, 0);
49320Sstevel@tonic-gate 	mp = NULL;
49330Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
49340Sstevel@tonic-gate 	if (error) {
49350Sstevel@tonic-gate 		eprintsoline(so, error);
49360Sstevel@tonic-gate 		goto done2;
49370Sstevel@tonic-gate 	}
49380Sstevel@tonic-gate 	error = sowaitprim(so, T_SVR4_OPTMGMT_REQ, T_OPTMGMT_ACK,
49390Sstevel@tonic-gate 	    (t_uscalar_t)(sizeof (*optmgmt_ack) + sizeof (*opt_res)), &mp, 0);
49400Sstevel@tonic-gate 	if (error) {
49410Sstevel@tonic-gate 		if (option != NULL) {
49420Sstevel@tonic-gate 			/* We have a fallback value */
49430Sstevel@tonic-gate 			error = 0;
49440Sstevel@tonic-gate 			goto copyout;
49450Sstevel@tonic-gate 		}
49460Sstevel@tonic-gate 		eprintsoline(so, error);
49470Sstevel@tonic-gate 		goto done2;
49480Sstevel@tonic-gate 	}
49490Sstevel@tonic-gate 	ASSERT(mp);
49500Sstevel@tonic-gate 	optmgmt_ack = (struct T_optmgmt_ack *)mp->b_rptr;
49510Sstevel@tonic-gate 	opt_res = (struct opthdr *)sogetoff(mp, optmgmt_ack->OPT_offset,
49520Sstevel@tonic-gate 			optmgmt_ack->OPT_length, __TPI_ALIGN_SIZE);
49530Sstevel@tonic-gate 	if (opt_res == NULL) {
49540Sstevel@tonic-gate 		if (option != NULL) {
49550Sstevel@tonic-gate 			/* We have a fallback value */
49560Sstevel@tonic-gate 			error = 0;
49570Sstevel@tonic-gate 			goto copyout;
49580Sstevel@tonic-gate 		}
49590Sstevel@tonic-gate 		error = EPROTO;
49600Sstevel@tonic-gate 		eprintsoline(so, error);
49610Sstevel@tonic-gate 		goto done;
49620Sstevel@tonic-gate 	}
49630Sstevel@tonic-gate 	option = &opt_res[1];
49640Sstevel@tonic-gate 
49650Sstevel@tonic-gate 	/* check to ensure that the option is within bounds */
49660Sstevel@tonic-gate 	if (((uintptr_t)option + opt_res->len < (uintptr_t)option) ||
49670Sstevel@tonic-gate 		(uintptr_t)option + opt_res->len > (uintptr_t)mp->b_wptr) {
49680Sstevel@tonic-gate 		if (option != NULL) {
49690Sstevel@tonic-gate 			/* We have a fallback value */
49700Sstevel@tonic-gate 			error = 0;
49710Sstevel@tonic-gate 			goto copyout;
49720Sstevel@tonic-gate 		}
49730Sstevel@tonic-gate 		error = EPROTO;
49740Sstevel@tonic-gate 		eprintsoline(so, error);
49750Sstevel@tonic-gate 		goto done;
49760Sstevel@tonic-gate 	}
49770Sstevel@tonic-gate 
49780Sstevel@tonic-gate 	len = opt_res->len;
49790Sstevel@tonic-gate 
49800Sstevel@tonic-gate copyout: {
49810Sstevel@tonic-gate 		t_uscalar_t size = MIN(len, maxlen);
49820Sstevel@tonic-gate 		bcopy(option, optval, size);
49830Sstevel@tonic-gate 		bcopy(&size, optlenp, sizeof (size));
49840Sstevel@tonic-gate 	}
49850Sstevel@tonic-gate done:
49860Sstevel@tonic-gate 	freemsg(mp);
49870Sstevel@tonic-gate done2:
49880Sstevel@tonic-gate 	so_unlock_single(so, SOLOCKED);
49890Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
49900Sstevel@tonic-gate 	return (error);
49910Sstevel@tonic-gate }
49920Sstevel@tonic-gate 
49930Sstevel@tonic-gate /*
49940Sstevel@tonic-gate  * Set socket options. All options are passed down in a T_SVR4_OPTMGMT_REQ.
49950Sstevel@tonic-gate  * SOL_SOCKET options are also recorded in the sonode. A setsockopt for
49960Sstevel@tonic-gate  * SOL_SOCKET options will not fail just because the T_SVR4_OPTMGMT_REQ fails -
49970Sstevel@tonic-gate  * setsockopt has to work even if the transport does not support the option.
49980Sstevel@tonic-gate  */
49990Sstevel@tonic-gate int
50000Sstevel@tonic-gate sotpi_setsockopt(struct sonode *so, int level, int option_name,
50010Sstevel@tonic-gate 	const void *optval, t_uscalar_t optlen)
50020Sstevel@tonic-gate {
50030Sstevel@tonic-gate 	struct T_optmgmt_req	optmgmt_req;
50040Sstevel@tonic-gate 	struct opthdr		oh;
50050Sstevel@tonic-gate 	mblk_t			*mp;
50060Sstevel@tonic-gate 	int			error = 0;
50070Sstevel@tonic-gate 	boolean_t		handled = B_FALSE;
50080Sstevel@tonic-gate 
50090Sstevel@tonic-gate 	dprintso(so, 1, ("sotpi_setsockopt(%p, 0x%x, 0x%x, %p, %d) %s\n",
50100Sstevel@tonic-gate 			so, level, option_name, optval, optlen,
50110Sstevel@tonic-gate 			pr_state(so->so_state, so->so_mode)));
50120Sstevel@tonic-gate 
50130Sstevel@tonic-gate 
50140Sstevel@tonic-gate 	/* X/Open requires this check */
50150Sstevel@tonic-gate 	if ((so->so_state & SS_CANTSENDMORE) && !xnet_skip_checks) {
50160Sstevel@tonic-gate 		if (xnet_check_print)
50170Sstevel@tonic-gate 			printf("sockfs: X/Open setsockopt check => EINVAL\n");
50180Sstevel@tonic-gate 		return (EINVAL);
50190Sstevel@tonic-gate 	}
50200Sstevel@tonic-gate 
50210Sstevel@tonic-gate 	/* Caller allocates aligned optval, or passes null */
50220Sstevel@tonic-gate 	ASSERT(((uintptr_t)optval & (sizeof (t_scalar_t) - 1)) == 0);
50230Sstevel@tonic-gate 	/* If optval is null optlen is 0, and vice-versa */
50240Sstevel@tonic-gate 	ASSERT(optval != NULL || optlen == 0);
50250Sstevel@tonic-gate 	ASSERT(optlen != 0 || optval == NULL);
50260Sstevel@tonic-gate 
50270Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
50280Sstevel@tonic-gate 	so_lock_single(so);	/* Set SOLOCKED */
50290Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
50300Sstevel@tonic-gate 
50310Sstevel@tonic-gate 	if (so->so_family == AF_NCA) {
50320Sstevel@tonic-gate 		/* Ignore any flow control problems with the transport. */
50330Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
50340Sstevel@tonic-gate 		goto done;
50350Sstevel@tonic-gate 	}
50360Sstevel@tonic-gate 
50370Sstevel@tonic-gate 	/*
50380Sstevel@tonic-gate 	 * For SOCKET or TCP level options, try to set it here itself
50390Sstevel@tonic-gate 	 * provided socket has not been popped and we know the tcp
50400Sstevel@tonic-gate 	 * structure (stored in so_priv).
50410Sstevel@tonic-gate 	 */
50420Sstevel@tonic-gate 	if ((level == SOL_SOCKET || level == IPPROTO_TCP) &&
50430Sstevel@tonic-gate 	    (so->so_family == AF_INET || so->so_family == AF_INET6) &&
50440Sstevel@tonic-gate 	    (so->so_version == SOV_SOCKSTREAM) && (so->so_priv != NULL)) {
50450Sstevel@tonic-gate 		tcp_t		*tcp = so->so_priv;
50460Sstevel@tonic-gate 		boolean_t	onoff;
50470Sstevel@tonic-gate 
50480Sstevel@tonic-gate #define	intvalue	(*(int32_t *)optval)
50490Sstevel@tonic-gate 
50500Sstevel@tonic-gate 		switch (level) {
50510Sstevel@tonic-gate 		case SOL_SOCKET:
50520Sstevel@tonic-gate 			switch (option_name) {		/* Check length param */
50530Sstevel@tonic-gate 			case SO_DEBUG:
50540Sstevel@tonic-gate 			case SO_REUSEADDR:
50550Sstevel@tonic-gate 			case SO_DONTROUTE:
50560Sstevel@tonic-gate 			case SO_BROADCAST:
50570Sstevel@tonic-gate 			case SO_USELOOPBACK:
50580Sstevel@tonic-gate 			case SO_OOBINLINE:
50590Sstevel@tonic-gate 			case SO_DGRAM_ERRIND:
50600Sstevel@tonic-gate 				if (optlen != (t_uscalar_t)sizeof (int32_t)) {
50610Sstevel@tonic-gate 					error = EINVAL;
50620Sstevel@tonic-gate 					eprintsoline(so, error);
50630Sstevel@tonic-gate 					mutex_enter(&so->so_lock);
50640Sstevel@tonic-gate 					goto done2;
50650Sstevel@tonic-gate 				}
50660Sstevel@tonic-gate 				ASSERT(optval);
50670Sstevel@tonic-gate 				onoff = intvalue != 0;
50680Sstevel@tonic-gate 				handled = B_TRUE;
50690Sstevel@tonic-gate 				break;
50700Sstevel@tonic-gate 			case SO_LINGER:
50710Sstevel@tonic-gate 				if (optlen !=
50720Sstevel@tonic-gate 				    (t_uscalar_t)sizeof (struct linger)) {
50730Sstevel@tonic-gate 					error = EINVAL;
50740Sstevel@tonic-gate 					eprintsoline(so, error);
50750Sstevel@tonic-gate 					mutex_enter(&so->so_lock);
50760Sstevel@tonic-gate 					goto done2;
50770Sstevel@tonic-gate 				}
50780Sstevel@tonic-gate 				ASSERT(optval);
50790Sstevel@tonic-gate 				handled = B_TRUE;
50800Sstevel@tonic-gate 				break;
50810Sstevel@tonic-gate 			}
50820Sstevel@tonic-gate 
50830Sstevel@tonic-gate 			switch (option_name) {			/* Do actions */
50840Sstevel@tonic-gate 			case SO_LINGER: {
50850Sstevel@tonic-gate 				struct linger *lgr = (struct linger *)optval;
50860Sstevel@tonic-gate 
50870Sstevel@tonic-gate 				if (lgr->l_onoff) {
50880Sstevel@tonic-gate 					tcp->tcp_linger = 1;
50890Sstevel@tonic-gate 					tcp->tcp_lingertime = lgr->l_linger;
50900Sstevel@tonic-gate 					so->so_linger.l_onoff = SO_LINGER;
50910Sstevel@tonic-gate 					so->so_options |= SO_LINGER;
50920Sstevel@tonic-gate 				} else {
50930Sstevel@tonic-gate 					tcp->tcp_linger = 0;
50940Sstevel@tonic-gate 					tcp->tcp_lingertime = 0;
50950Sstevel@tonic-gate 					so->so_linger.l_onoff = 0;
50960Sstevel@tonic-gate 					so->so_options &= ~SO_LINGER;
50970Sstevel@tonic-gate 				}
50980Sstevel@tonic-gate 				so->so_linger.l_linger = lgr->l_linger;
50990Sstevel@tonic-gate 				handled = B_TRUE;
51000Sstevel@tonic-gate 				break;
51010Sstevel@tonic-gate 			}
51020Sstevel@tonic-gate 			case SO_DEBUG:
51030Sstevel@tonic-gate 				tcp->tcp_debug = onoff;
51040Sstevel@tonic-gate #ifdef SOCK_TEST
51050Sstevel@tonic-gate 				if (intvalue & 2)
51060Sstevel@tonic-gate 					sock_test_timelimit = 10 * hz;
51070Sstevel@tonic-gate 				else
51080Sstevel@tonic-gate 					sock_test_timelimit = 0;
51090Sstevel@tonic-gate 
51100Sstevel@tonic-gate 				if (intvalue & 4)
51110Sstevel@tonic-gate 					do_useracc = 0;
51120Sstevel@tonic-gate 				else
51130Sstevel@tonic-gate 					do_useracc = 1;
51140Sstevel@tonic-gate #endif /* SOCK_TEST */
51150Sstevel@tonic-gate 				break;
51160Sstevel@tonic-gate 			case SO_DONTROUTE:
51170Sstevel@tonic-gate 				/*
51180Sstevel@tonic-gate 				 * SO_DONTROUTE, SO_USELOOPBACK and
51190Sstevel@tonic-gate 				 * SO_BROADCAST are only of interest to IP.
51200Sstevel@tonic-gate 				 * We track them here only so
51210Sstevel@tonic-gate 				 * that we can report their current value.
51220Sstevel@tonic-gate 				 */
51230Sstevel@tonic-gate 				tcp->tcp_dontroute = onoff;
51240Sstevel@tonic-gate 				if (onoff)
51250Sstevel@tonic-gate 					so->so_options |= option_name;
51260Sstevel@tonic-gate 				else
51270Sstevel@tonic-gate 					so->so_options &= ~option_name;
51280Sstevel@tonic-gate 				break;
51290Sstevel@tonic-gate 			case SO_USELOOPBACK:
51300Sstevel@tonic-gate 				tcp->tcp_useloopback = onoff;
51310Sstevel@tonic-gate 				if (onoff)
51320Sstevel@tonic-gate 					so->so_options |= option_name;
51330Sstevel@tonic-gate 				else
51340Sstevel@tonic-gate 					so->so_options &= ~option_name;
51350Sstevel@tonic-gate 				break;
51360Sstevel@tonic-gate 			case SO_BROADCAST:
51370Sstevel@tonic-gate 				tcp->tcp_broadcast = onoff;
51380Sstevel@tonic-gate 				if (onoff)
51390Sstevel@tonic-gate 					so->so_options |= option_name;
51400Sstevel@tonic-gate 				else
51410Sstevel@tonic-gate 					so->so_options &= ~option_name;
51420Sstevel@tonic-gate 				break;
51430Sstevel@tonic-gate 			case SO_REUSEADDR:
51440Sstevel@tonic-gate 				tcp->tcp_reuseaddr = onoff;
51450Sstevel@tonic-gate 				if (onoff)
51460Sstevel@tonic-gate 					so->so_options |= option_name;
51470Sstevel@tonic-gate 				else
51480Sstevel@tonic-gate 					so->so_options &= ~option_name;
51490Sstevel@tonic-gate 				break;
51500Sstevel@tonic-gate 			case SO_OOBINLINE:
51510Sstevel@tonic-gate 				tcp->tcp_oobinline = onoff;
51520Sstevel@tonic-gate 				if (onoff)
51530Sstevel@tonic-gate 					so->so_options |= option_name;
51540Sstevel@tonic-gate 				else
51550Sstevel@tonic-gate 					so->so_options &= ~option_name;
51560Sstevel@tonic-gate 				break;
51570Sstevel@tonic-gate 			case SO_DGRAM_ERRIND:
51580Sstevel@tonic-gate 				tcp->tcp_dgram_errind = onoff;
51590Sstevel@tonic-gate 				if (onoff)
51600Sstevel@tonic-gate 					so->so_options |= option_name;
51610Sstevel@tonic-gate 				else
51620Sstevel@tonic-gate 					so->so_options &= ~option_name;
51630Sstevel@tonic-gate 				break;
51640Sstevel@tonic-gate 			}
51650Sstevel@tonic-gate 			break;
51660Sstevel@tonic-gate 		case IPPROTO_TCP:
51670Sstevel@tonic-gate 			switch (option_name) {
51680Sstevel@tonic-gate 			case TCP_NODELAY:
51690Sstevel@tonic-gate 				if (optlen != (t_uscalar_t)sizeof (int32_t)) {
51700Sstevel@tonic-gate 					error = EINVAL;
51710Sstevel@tonic-gate 					eprintsoline(so, error);
51720Sstevel@tonic-gate 					mutex_enter(&so->so_lock);
51730Sstevel@tonic-gate 					goto done2;
51740Sstevel@tonic-gate 				}
51750Sstevel@tonic-gate 				ASSERT(optval);
51760Sstevel@tonic-gate 				tcp->tcp_naglim = intvalue ? 1 : tcp->tcp_mss;
51770Sstevel@tonic-gate 				handled = B_TRUE;
51780Sstevel@tonic-gate 				break;
51790Sstevel@tonic-gate 			}
51800Sstevel@tonic-gate 			break;
51810Sstevel@tonic-gate 		default:
51820Sstevel@tonic-gate 			handled = B_FALSE;
51830Sstevel@tonic-gate 			break;
51840Sstevel@tonic-gate 		}
51850Sstevel@tonic-gate 	}
51860Sstevel@tonic-gate 
51870Sstevel@tonic-gate 	if (handled) {
51880Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
51890Sstevel@tonic-gate 		goto done2;
51900Sstevel@tonic-gate 	}
51910Sstevel@tonic-gate 
51920Sstevel@tonic-gate 	optmgmt_req.PRIM_type = T_SVR4_OPTMGMT_REQ;
51930Sstevel@tonic-gate 	optmgmt_req.MGMT_flags = T_NEGOTIATE;
51940Sstevel@tonic-gate 	optmgmt_req.OPT_length = (t_scalar_t)sizeof (oh) + optlen;
51950Sstevel@tonic-gate 	optmgmt_req.OPT_offset = (t_scalar_t)sizeof (optmgmt_req);
51960Sstevel@tonic-gate 
51970Sstevel@tonic-gate 	oh.level = level;
51980Sstevel@tonic-gate 	oh.name = option_name;
51990Sstevel@tonic-gate 	oh.len = optlen;
52000Sstevel@tonic-gate 
52010Sstevel@tonic-gate 	mp = soallocproto3(&optmgmt_req, sizeof (optmgmt_req),
52020Sstevel@tonic-gate 	    &oh, sizeof (oh), optval, optlen, 0, _ALLOC_SLEEP);
52030Sstevel@tonic-gate 	/* Let option management work in the presence of data flow control */
52040Sstevel@tonic-gate 	error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
52050Sstevel@tonic-gate 			MSG_BAND|MSG_HOLDSIG|MSG_IGNERROR|MSG_IGNFLOW, 0);
52060Sstevel@tonic-gate 	mp = NULL;
52070Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
52080Sstevel@tonic-gate 	if (error) {
52090Sstevel@tonic-gate 		eprintsoline(so, error);
52100Sstevel@tonic-gate 		goto done;
52110Sstevel@tonic-gate 	}
52120Sstevel@tonic-gate 	error = sowaitprim(so, T_SVR4_OPTMGMT_REQ, T_OPTMGMT_ACK,
52130Sstevel@tonic-gate 	    (t_uscalar_t)sizeof (struct T_optmgmt_ack), &mp, 0);
52140Sstevel@tonic-gate 	if (error) {
52150Sstevel@tonic-gate 		eprintsoline(so, error);
52160Sstevel@tonic-gate 		goto done;
52170Sstevel@tonic-gate 	}
52180Sstevel@tonic-gate 	ASSERT(mp);
52190Sstevel@tonic-gate 	/* No need to verify T_optmgmt_ack */
52200Sstevel@tonic-gate 	freemsg(mp);
52210Sstevel@tonic-gate done:
52220Sstevel@tonic-gate 	/*
52230Sstevel@tonic-gate 	 * Check for SOL_SOCKET options and record their values.
52240Sstevel@tonic-gate 	 * If we know about a SOL_SOCKET parameter and the transport
52250Sstevel@tonic-gate 	 * failed it with TBADOPT or TOUTSTATE (i.e. ENOPROTOOPT or
52260Sstevel@tonic-gate 	 * EPROTO) we let the setsockopt succeed.
52270Sstevel@tonic-gate 	 */
52280Sstevel@tonic-gate 	if (level == SOL_SOCKET) {
52290Sstevel@tonic-gate 		/* Check parameters */
52300Sstevel@tonic-gate 		switch (option_name) {
52310Sstevel@tonic-gate 		case SO_DEBUG:
52320Sstevel@tonic-gate 		case SO_REUSEADDR:
52330Sstevel@tonic-gate 		case SO_KEEPALIVE:
52340Sstevel@tonic-gate 		case SO_DONTROUTE:
52350Sstevel@tonic-gate 		case SO_BROADCAST:
52360Sstevel@tonic-gate 		case SO_USELOOPBACK:
52370Sstevel@tonic-gate 		case SO_OOBINLINE:
52380Sstevel@tonic-gate 		case SO_SNDBUF:
52390Sstevel@tonic-gate 		case SO_RCVBUF:
52400Sstevel@tonic-gate #ifdef notyet
52410Sstevel@tonic-gate 		case SO_SNDLOWAT:
52420Sstevel@tonic-gate 		case SO_RCVLOWAT:
52430Sstevel@tonic-gate 		case SO_SNDTIMEO:
52440Sstevel@tonic-gate 		case SO_RCVTIMEO:
52450Sstevel@tonic-gate #endif /* notyet */
52460Sstevel@tonic-gate 		case SO_DGRAM_ERRIND:
52470Sstevel@tonic-gate 			if (optlen != (t_uscalar_t)sizeof (int32_t)) {
52480Sstevel@tonic-gate 				error = EINVAL;
52490Sstevel@tonic-gate 				eprintsoline(so, error);
52500Sstevel@tonic-gate 				goto done2;
52510Sstevel@tonic-gate 			}
52520Sstevel@tonic-gate 			ASSERT(optval);
52530Sstevel@tonic-gate 			handled = B_TRUE;
52540Sstevel@tonic-gate 			break;
52550Sstevel@tonic-gate 		case SO_LINGER:
52560Sstevel@tonic-gate 			if (optlen != (t_uscalar_t)sizeof (struct linger)) {
52570Sstevel@tonic-gate 				error = EINVAL;
52580Sstevel@tonic-gate 				eprintsoline(so, error);
52590Sstevel@tonic-gate 				goto done2;
52600Sstevel@tonic-gate 			}
52610Sstevel@tonic-gate 			ASSERT(optval);
52620Sstevel@tonic-gate 			handled = B_TRUE;
52630Sstevel@tonic-gate 			break;
52640Sstevel@tonic-gate 		}
52650Sstevel@tonic-gate 
52660Sstevel@tonic-gate #define	intvalue	(*(int32_t *)optval)
52670Sstevel@tonic-gate 
52680Sstevel@tonic-gate 		switch (option_name) {
52690Sstevel@tonic-gate 		case SO_TYPE:
52700Sstevel@tonic-gate 		case SO_ERROR:
52710Sstevel@tonic-gate 		case SO_ACCEPTCONN:
52720Sstevel@tonic-gate 			/* Can't be set */
52730Sstevel@tonic-gate 			error = ENOPROTOOPT;
52740Sstevel@tonic-gate 			goto done2;
52750Sstevel@tonic-gate 		case SO_LINGER: {
52760Sstevel@tonic-gate 			struct linger *l = (struct linger *)optval;
52770Sstevel@tonic-gate 
52780Sstevel@tonic-gate 			so->so_linger.l_linger = l->l_linger;
52790Sstevel@tonic-gate 			if (l->l_onoff) {
52800Sstevel@tonic-gate 				so->so_linger.l_onoff = SO_LINGER;
52810Sstevel@tonic-gate 				so->so_options |= SO_LINGER;
52820Sstevel@tonic-gate 			} else {
52830Sstevel@tonic-gate 				so->so_linger.l_onoff = 0;
52840Sstevel@tonic-gate 				so->so_options &= ~SO_LINGER;
52850Sstevel@tonic-gate 			}
52860Sstevel@tonic-gate 			break;
52870Sstevel@tonic-gate 		}
52880Sstevel@tonic-gate 
52890Sstevel@tonic-gate 		case SO_DEBUG:
52900Sstevel@tonic-gate #ifdef SOCK_TEST
52910Sstevel@tonic-gate 			if (intvalue & 2)
52920Sstevel@tonic-gate 				sock_test_timelimit = 10 * hz;
52930Sstevel@tonic-gate 			else
52940Sstevel@tonic-gate 				sock_test_timelimit = 0;
52950Sstevel@tonic-gate 
52960Sstevel@tonic-gate 			if (intvalue & 4)
52970Sstevel@tonic-gate 				do_useracc = 0;
52980Sstevel@tonic-gate 			else
52990Sstevel@tonic-gate 				do_useracc = 1;
53000Sstevel@tonic-gate #endif /* SOCK_TEST */
53010Sstevel@tonic-gate 			/* FALLTHRU */
53020Sstevel@tonic-gate 		case SO_REUSEADDR:
53030Sstevel@tonic-gate 		case SO_KEEPALIVE:
53040Sstevel@tonic-gate 		case SO_DONTROUTE:
53050Sstevel@tonic-gate 		case SO_BROADCAST:
53060Sstevel@tonic-gate 		case SO_USELOOPBACK:
53070Sstevel@tonic-gate 		case SO_OOBINLINE:
53080Sstevel@tonic-gate 		case SO_DGRAM_ERRIND:
53090Sstevel@tonic-gate 			if (intvalue != 0) {
53100Sstevel@tonic-gate 				dprintso(so, 1,
53110Sstevel@tonic-gate 					("sotpi_setsockopt: setting 0x%x\n",
53120Sstevel@tonic-gate 					option_name));
53130Sstevel@tonic-gate 				so->so_options |= option_name;
53140Sstevel@tonic-gate 			} else {
53150Sstevel@tonic-gate 				dprintso(so, 1,
53160Sstevel@tonic-gate 					("sotpi_setsockopt: clearing 0x%x\n",
53170Sstevel@tonic-gate 					option_name));
53180Sstevel@tonic-gate 				so->so_options &= ~option_name;
53190Sstevel@tonic-gate 			}
53200Sstevel@tonic-gate 			break;
53210Sstevel@tonic-gate 		/*
53220Sstevel@tonic-gate 		 * The following options are only returned by us when the
53230Sstevel@tonic-gate 		 * T_SVR4_OPTMGMT_REQ fails.
53240Sstevel@tonic-gate 		 * XXX XPG 4.2 applications retrieve SO_RCVBUF from sockfs
53250Sstevel@tonic-gate 		 * since the transport might adjust the value and not
53260Sstevel@tonic-gate 		 * return exactly what was set by the application.
53270Sstevel@tonic-gate 		 */
53280Sstevel@tonic-gate 		case SO_SNDBUF:
53290Sstevel@tonic-gate 			so->so_sndbuf = intvalue;
53300Sstevel@tonic-gate 			break;
53310Sstevel@tonic-gate 		case SO_RCVBUF:
53320Sstevel@tonic-gate 			so->so_rcvbuf = intvalue;
53330Sstevel@tonic-gate 			break;
53340Sstevel@tonic-gate #ifdef notyet
53350Sstevel@tonic-gate 		/*
53360Sstevel@tonic-gate 		 * We do not implement the semantics of these options
53370Sstevel@tonic-gate 		 * thus we shouldn't implement the options either.
53380Sstevel@tonic-gate 		 */
53390Sstevel@tonic-gate 		case SO_SNDLOWAT:
53400Sstevel@tonic-gate 			so->so_sndlowat = intvalue;
53410Sstevel@tonic-gate 			break;
53420Sstevel@tonic-gate 		case SO_RCVLOWAT:
53430Sstevel@tonic-gate 			so->so_rcvlowat = intvalue;
53440Sstevel@tonic-gate 			break;
53450Sstevel@tonic-gate 		case SO_SNDTIMEO:
53460Sstevel@tonic-gate 			so->so_sndtimeo = intvalue;
53470Sstevel@tonic-gate 			break;
53480Sstevel@tonic-gate 		case SO_RCVTIMEO:
53490Sstevel@tonic-gate 			so->so_rcvtimeo = intvalue;
53500Sstevel@tonic-gate 			break;
53510Sstevel@tonic-gate #endif /* notyet */
53520Sstevel@tonic-gate 		}
53530Sstevel@tonic-gate #undef	intvalue
53540Sstevel@tonic-gate 
53550Sstevel@tonic-gate 		if (error) {
53560Sstevel@tonic-gate 			if ((error == ENOPROTOOPT || error == EPROTO ||
53570Sstevel@tonic-gate 			    error == EINVAL) && handled) {
53580Sstevel@tonic-gate 				dprintso(so, 1,
53590Sstevel@tonic-gate 				    ("setsockopt: ignoring error %d for 0x%x\n",
53600Sstevel@tonic-gate 				    error, option_name));
53610Sstevel@tonic-gate 				error = 0;
53620Sstevel@tonic-gate 			}
53630Sstevel@tonic-gate 		}
53640Sstevel@tonic-gate 	}
53650Sstevel@tonic-gate done2:
53660Sstevel@tonic-gate ret:
53670Sstevel@tonic-gate 	so_unlock_single(so, SOLOCKED);
53680Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
53690Sstevel@tonic-gate 	return (error);
53700Sstevel@tonic-gate }
5371