xref: /onnv-gate/usr/src/uts/common/fs/sockfs/sockstr.c (revision 12644:4f9a0cd40c5f)
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
51548Srshoaib  * Common Development and Distribution License (the "License").
61548Srshoaib  * You may not use this file except in compliance with the License.
70Sstevel@tonic-gate  *
80Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
90Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
100Sstevel@tonic-gate  * See the License for the specific language governing permissions
110Sstevel@tonic-gate  * and limitations under the License.
120Sstevel@tonic-gate  *
130Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
140Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
150Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
160Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
170Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
180Sstevel@tonic-gate  *
190Sstevel@tonic-gate  * CDDL HEADER END
200Sstevel@tonic-gate  */
211548Srshoaib 
220Sstevel@tonic-gate /*
23*12644SAnders.Persson@Sun.COM  * Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
240Sstevel@tonic-gate  */
250Sstevel@tonic-gate 
260Sstevel@tonic-gate #include <sys/types.h>
270Sstevel@tonic-gate #include <sys/inttypes.h>
280Sstevel@tonic-gate #include <sys/t_lock.h>
290Sstevel@tonic-gate #include <sys/param.h>
300Sstevel@tonic-gate #include <sys/systm.h>
310Sstevel@tonic-gate #include <sys/buf.h>
320Sstevel@tonic-gate #include <sys/conf.h>
330Sstevel@tonic-gate #include <sys/cred.h>
340Sstevel@tonic-gate #include <sys/kmem.h>
350Sstevel@tonic-gate #include <sys/sysmacros.h>
360Sstevel@tonic-gate #include <sys/vfs.h>
370Sstevel@tonic-gate #include <sys/vnode.h>
380Sstevel@tonic-gate #include <sys/debug.h>
390Sstevel@tonic-gate #include <sys/errno.h>
400Sstevel@tonic-gate #include <sys/time.h>
410Sstevel@tonic-gate #include <sys/file.h>
420Sstevel@tonic-gate #include <sys/user.h>
430Sstevel@tonic-gate #include <sys/stream.h>
440Sstevel@tonic-gate #include <sys/strsubr.h>
450Sstevel@tonic-gate #include <sys/esunddi.h>
460Sstevel@tonic-gate #include <sys/flock.h>
470Sstevel@tonic-gate #include <sys/modctl.h>
480Sstevel@tonic-gate #include <sys/vtrace.h>
490Sstevel@tonic-gate #include <sys/strsun.h>
500Sstevel@tonic-gate #include <sys/cmn_err.h>
510Sstevel@tonic-gate #include <sys/proc.h>
520Sstevel@tonic-gate #include <sys/ddi.h>
530Sstevel@tonic-gate 
540Sstevel@tonic-gate #include <sys/suntpi.h>
550Sstevel@tonic-gate #include <sys/socket.h>
560Sstevel@tonic-gate #include <sys/sockio.h>
570Sstevel@tonic-gate #include <sys/socketvar.h>
580Sstevel@tonic-gate #include <netinet/in.h>
598348SEric.Yu@Sun.COM #include <inet/common.h>
608348SEric.Yu@Sun.COM #include <inet/proto_set.h>
610Sstevel@tonic-gate 
620Sstevel@tonic-gate #include <sys/tiuser.h>
630Sstevel@tonic-gate #define	_SUN_TPI_VERSION	2
640Sstevel@tonic-gate #include <sys/tihdr.h>
650Sstevel@tonic-gate 
660Sstevel@tonic-gate #include <c2/audit.h>
670Sstevel@tonic-gate 
688348SEric.Yu@Sun.COM #include <fs/sockfs/socktpi.h>
698348SEric.Yu@Sun.COM #include <fs/sockfs/socktpi_impl.h>
706707Sbrutus 
710Sstevel@tonic-gate int so_default_version = SOV_SOCKSTREAM;
720Sstevel@tonic-gate 
730Sstevel@tonic-gate #ifdef DEBUG
740Sstevel@tonic-gate /* Set sockdebug to print debug messages when SO_DEBUG is set */
750Sstevel@tonic-gate int sockdebug = 0;
760Sstevel@tonic-gate 
770Sstevel@tonic-gate /* Set sockprinterr to print error messages when SO_DEBUG is set */
780Sstevel@tonic-gate int sockprinterr = 0;
790Sstevel@tonic-gate 
800Sstevel@tonic-gate /*
810Sstevel@tonic-gate  * Set so_default_options to SO_DEBUG is all sockets should be created
820Sstevel@tonic-gate  * with SO_DEBUG set. This is needed to get debug printouts from the
830Sstevel@tonic-gate  * socket() call itself.
840Sstevel@tonic-gate  */
850Sstevel@tonic-gate int so_default_options = 0;
860Sstevel@tonic-gate #endif /* DEBUG */
870Sstevel@tonic-gate 
880Sstevel@tonic-gate #ifdef SOCK_TEST
890Sstevel@tonic-gate /*
900Sstevel@tonic-gate  * Set to number of ticks to limit cv_waits for code coverage testing.
910Sstevel@tonic-gate  * Set to 1000 when SO_DEBUG is set to 2.
920Sstevel@tonic-gate  */
930Sstevel@tonic-gate clock_t sock_test_timelimit = 0;
940Sstevel@tonic-gate #endif /* SOCK_TEST */
950Sstevel@tonic-gate 
960Sstevel@tonic-gate /*
970Sstevel@tonic-gate  * For concurrency testing of e.g. opening /dev/ip which does not
980Sstevel@tonic-gate  * handle T_INFO_REQ messages.
990Sstevel@tonic-gate  */
1000Sstevel@tonic-gate int so_no_tinfo = 0;
1010Sstevel@tonic-gate 
1020Sstevel@tonic-gate /*
1030Sstevel@tonic-gate  * Timeout for getting a T_CAPABILITY_ACK - it is possible for a provider
1040Sstevel@tonic-gate  * to simply ignore the T_CAPABILITY_REQ.
1050Sstevel@tonic-gate  */
1060Sstevel@tonic-gate clock_t	sock_capability_timeout	= 2;	/* seconds */
1070Sstevel@tonic-gate 
1080Sstevel@tonic-gate static int	do_tcapability(struct sonode *so, t_uscalar_t cap_bits1);
1090Sstevel@tonic-gate static void	so_removehooks(struct sonode *so);
1100Sstevel@tonic-gate 
1110Sstevel@tonic-gate static mblk_t *strsock_proto(vnode_t *vp, mblk_t *mp,
1120Sstevel@tonic-gate 		strwakeup_t *wakeups, strsigset_t *firstmsgsigs,
1130Sstevel@tonic-gate 		strsigset_t *allmsgsigs, strpollset_t *pollwakeups);
1140Sstevel@tonic-gate static mblk_t *strsock_misc(vnode_t *vp, mblk_t *mp,
1150Sstevel@tonic-gate 		strwakeup_t *wakeups, strsigset_t *firstmsgsigs,
1160Sstevel@tonic-gate 		strsigset_t *allmsgsigs, strpollset_t *pollwakeups);
1176707Sbrutus 
1186707Sbrutus /*
1190Sstevel@tonic-gate  * Convert a socket to a stream. Invoked when the illusory sockmod
1200Sstevel@tonic-gate  * is popped from the stream.
1210Sstevel@tonic-gate  * Change the stream head back to default operation without losing
1220Sstevel@tonic-gate  * any messages (T_conn_ind's are moved to the stream head queue).
1230Sstevel@tonic-gate  */
1240Sstevel@tonic-gate int
so_sock2stream(struct sonode * so)1250Sstevel@tonic-gate so_sock2stream(struct sonode *so)
1260Sstevel@tonic-gate {
1270Sstevel@tonic-gate 	struct vnode		*vp = SOTOV(so);
1280Sstevel@tonic-gate 	queue_t			*rq;
1290Sstevel@tonic-gate 	mblk_t			*mp;
1300Sstevel@tonic-gate 	int			error = 0;
1318348SEric.Yu@Sun.COM 	sotpi_info_t		*sti = SOTOTPI(so);
1320Sstevel@tonic-gate 
1338348SEric.Yu@Sun.COM 	ASSERT(MUTEX_HELD(&sti->sti_plumb_lock));
1340Sstevel@tonic-gate 
1350Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
1360Sstevel@tonic-gate 	so_lock_single(so);
1370Sstevel@tonic-gate 
1380Sstevel@tonic-gate 	ASSERT(so->so_version != SOV_STREAM);
1390Sstevel@tonic-gate 
1408348SEric.Yu@Sun.COM 	if (sti->sti_direct) {
141741Smasputra 		mblk_t **mpp;
142741Smasputra 		int rval;
1430Sstevel@tonic-gate 
144741Smasputra 		/*
145741Smasputra 		 * Tell the transport below that sockmod is being popped
146741Smasputra 		 */
1470Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
148741Smasputra 		error = strioctl(vp, _SIOCSOCKFALLBACK, 0, 0, K_TO_K, CRED(),
1490Sstevel@tonic-gate 		    &rval);
1500Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
1510Sstevel@tonic-gate 		if (error != 0) {
152741Smasputra 			dprintso(so, 0, ("so_sock2stream(%p): "
1537240Srh87107 			    "_SIOCSOCKFALLBACK failed\n", (void *)so));
1540Sstevel@tonic-gate 			goto exit;
1550Sstevel@tonic-gate 		}
1568348SEric.Yu@Sun.COM 		sti->sti_direct = 0;
1570Sstevel@tonic-gate 
1588348SEric.Yu@Sun.COM 		for (mpp = &sti->sti_conn_ind_head; (mp = *mpp) != NULL;
1590Sstevel@tonic-gate 		    mpp = &mp->b_next) {
1600Sstevel@tonic-gate 			struct T_conn_ind	*conn_ind;
1610Sstevel@tonic-gate 
1620Sstevel@tonic-gate 			/*
1630Sstevel@tonic-gate 			 * strsock_proto() has already verified the length of
1640Sstevel@tonic-gate 			 * this message block.
1650Sstevel@tonic-gate 			 */
1660Sstevel@tonic-gate 			ASSERT(MBLKL(mp) >= sizeof (struct T_conn_ind));
1670Sstevel@tonic-gate 
1680Sstevel@tonic-gate 			conn_ind = (struct T_conn_ind *)mp->b_rptr;
1690Sstevel@tonic-gate 			if (conn_ind->OPT_length == 0 &&
1700Sstevel@tonic-gate 			    conn_ind->OPT_offset == 0)
1710Sstevel@tonic-gate 				continue;
1720Sstevel@tonic-gate 
1730Sstevel@tonic-gate 			if (DB_REF(mp) > 1) {
1740Sstevel@tonic-gate 				mblk_t	*newmp;
1750Sstevel@tonic-gate 				size_t	length;
1760Sstevel@tonic-gate 				cred_t	*cr;
1778778SErik.Nordmark@Sun.COM 				pid_t	cpid;
1788778SErik.Nordmark@Sun.COM 				int error;	/* Dummy - error not returned */
1790Sstevel@tonic-gate 
1800Sstevel@tonic-gate 				/*
1810Sstevel@tonic-gate 				 * Copy the message block because it is used
1820Sstevel@tonic-gate 				 * elsewhere, too.
1838778SErik.Nordmark@Sun.COM 				 * Can't use copyb since we want to wait
1848778SErik.Nordmark@Sun.COM 				 * yet allow for EINTR.
1850Sstevel@tonic-gate 				 */
1868778SErik.Nordmark@Sun.COM 				/* Round up size for reuse */
1878778SErik.Nordmark@Sun.COM 				length = MAX(MBLKL(mp), 64);
1888778SErik.Nordmark@Sun.COM 				cr = msg_getcred(mp, &cpid);
1898778SErik.Nordmark@Sun.COM 				if (cr != NULL) {
1908778SErik.Nordmark@Sun.COM 					newmp = allocb_cred_wait(length, 0,
1918778SErik.Nordmark@Sun.COM 					    &error, cr, cpid);
1928778SErik.Nordmark@Sun.COM 				} else {
1938778SErik.Nordmark@Sun.COM 					newmp = allocb_wait(length, 0, 0,
1948778SErik.Nordmark@Sun.COM 					    &error);
1958778SErik.Nordmark@Sun.COM 				}
1960Sstevel@tonic-gate 				if (newmp == NULL) {
1970Sstevel@tonic-gate 					error = EINTR;
1980Sstevel@tonic-gate 					goto exit;
1990Sstevel@tonic-gate 				}
2000Sstevel@tonic-gate 				bcopy(mp->b_rptr, newmp->b_wptr, length);
2010Sstevel@tonic-gate 				newmp->b_wptr += length;
2020Sstevel@tonic-gate 				newmp->b_next = mp->b_next;
2030Sstevel@tonic-gate 
2040Sstevel@tonic-gate 				/*
2050Sstevel@tonic-gate 				 * Link the new message block into the queue
2060Sstevel@tonic-gate 				 * and free the old one.
2070Sstevel@tonic-gate 				 */
2080Sstevel@tonic-gate 				*mpp = newmp;
2090Sstevel@tonic-gate 				mp->b_next = NULL;
2100Sstevel@tonic-gate 				freemsg(mp);
2110Sstevel@tonic-gate 
2120Sstevel@tonic-gate 				mp = newmp;
2130Sstevel@tonic-gate 				conn_ind = (struct T_conn_ind *)mp->b_rptr;
2140Sstevel@tonic-gate 			}
2150Sstevel@tonic-gate 
2160Sstevel@tonic-gate 			/*
2170Sstevel@tonic-gate 			 * Remove options added by TCP for accept fast-path.
2180Sstevel@tonic-gate 			 */
2190Sstevel@tonic-gate 			conn_ind->OPT_length = 0;
2200Sstevel@tonic-gate 			conn_ind->OPT_offset = 0;
2210Sstevel@tonic-gate 		}
2220Sstevel@tonic-gate 	}
2230Sstevel@tonic-gate 
2240Sstevel@tonic-gate 	so->so_version = SOV_STREAM;
2258348SEric.Yu@Sun.COM 	so->so_proto_handle = NULL;
2260Sstevel@tonic-gate 
2270Sstevel@tonic-gate 	/*
2280Sstevel@tonic-gate 	 * Remove the hooks in the stream head to avoid queuing more
2290Sstevel@tonic-gate 	 * packets in sockfs.
2300Sstevel@tonic-gate 	 */
2310Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
2320Sstevel@tonic-gate 	so_removehooks(so);
2330Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
2340Sstevel@tonic-gate 
2350Sstevel@tonic-gate 	/*
2360Sstevel@tonic-gate 	 * Clear any state related to urgent data. Leave any T_EXDATA_IND
2370Sstevel@tonic-gate 	 * on the queue - the behavior of urgent data after a switch is
2380Sstevel@tonic-gate 	 * left undefined.
2390Sstevel@tonic-gate 	 */
2408348SEric.Yu@Sun.COM 	so->so_error = sti->sti_delayed_error = 0;
2410Sstevel@tonic-gate 	freemsg(so->so_oobmsg);
2420Sstevel@tonic-gate 	so->so_oobmsg = NULL;
2438348SEric.Yu@Sun.COM 	sti->sti_oobsigcnt = sti->sti_oobcnt = 0;
2440Sstevel@tonic-gate 
2450Sstevel@tonic-gate 	so->so_state &= ~(SS_RCVATMARK|SS_OOBPEND|SS_HAVEOOBDATA|SS_HADOOBDATA|
2468348SEric.Yu@Sun.COM 	    SS_SAVEDEOR);
2470Sstevel@tonic-gate 	ASSERT(so_verify_oobstate(so));
2480Sstevel@tonic-gate 
2498348SEric.Yu@Sun.COM 	freemsg(sti->sti_ack_mp);
2508348SEric.Yu@Sun.COM 	sti->sti_ack_mp = NULL;
2510Sstevel@tonic-gate 
2520Sstevel@tonic-gate 	/*
2538348SEric.Yu@Sun.COM 	 * Flush the T_DISCON_IND on sti_discon_ind_mp.
2540Sstevel@tonic-gate 	 */
2550Sstevel@tonic-gate 	so_flush_discon_ind(so);
2560Sstevel@tonic-gate 
2570Sstevel@tonic-gate 	/*
2580Sstevel@tonic-gate 	 * Move any queued T_CONN_IND messages to stream head queue.
2590Sstevel@tonic-gate 	 */
2600Sstevel@tonic-gate 	rq = RD(strvp2wq(vp));
2618348SEric.Yu@Sun.COM 	while ((mp = sti->sti_conn_ind_head) != NULL) {
2628348SEric.Yu@Sun.COM 		sti->sti_conn_ind_head = mp->b_next;
2630Sstevel@tonic-gate 		mp->b_next = NULL;
2648348SEric.Yu@Sun.COM 		if (sti->sti_conn_ind_head == NULL) {
2658348SEric.Yu@Sun.COM 			ASSERT(sti->sti_conn_ind_tail == mp);
2668348SEric.Yu@Sun.COM 			sti->sti_conn_ind_tail = NULL;
2670Sstevel@tonic-gate 		}
2680Sstevel@tonic-gate 		dprintso(so, 0,
2698348SEric.Yu@Sun.COM 		    ("so_sock2stream(%p): moving T_CONN_IND\n", (void *)so));
2700Sstevel@tonic-gate 
2710Sstevel@tonic-gate 		/* Drop lock across put() */
2720Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
2730Sstevel@tonic-gate 		put(rq, mp);
2740Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
2750Sstevel@tonic-gate 	}
2760Sstevel@tonic-gate 
2770Sstevel@tonic-gate exit:
2780Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
2790Sstevel@tonic-gate 	so_unlock_single(so, SOLOCKED);
2800Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
2810Sstevel@tonic-gate 	return (error);
2820Sstevel@tonic-gate }
2830Sstevel@tonic-gate 
2840Sstevel@tonic-gate /*
2850Sstevel@tonic-gate  * Covert a stream back to a socket. This is invoked when the illusory
2860Sstevel@tonic-gate  * sockmod is pushed on a stream (where the stream was "created" by
2870Sstevel@tonic-gate  * popping the illusory sockmod).
2880Sstevel@tonic-gate  * This routine can not recreate the socket state (certain aspects of
2890Sstevel@tonic-gate  * it like urgent data state and the bound/connected addresses for AF_UNIX
2900Sstevel@tonic-gate  * sockets can not be recreated by asking the transport for information).
2910Sstevel@tonic-gate  * Thus this routine implicitly assumes that the socket is in an initial
2920Sstevel@tonic-gate  * state (as if it was just created). It flushes any messages queued on the
2930Sstevel@tonic-gate  * read queue to avoid dealing with e.g. TPI acks or T_exdata_ind messages.
2940Sstevel@tonic-gate  */
2950Sstevel@tonic-gate void
so_stream2sock(struct sonode * so)2960Sstevel@tonic-gate so_stream2sock(struct sonode *so)
2970Sstevel@tonic-gate {
2980Sstevel@tonic-gate 	struct vnode *vp = SOTOV(so);
2998348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
3000Sstevel@tonic-gate 
3018348SEric.Yu@Sun.COM 	ASSERT(MUTEX_HELD(&sti->sti_plumb_lock));
3020Sstevel@tonic-gate 
3030Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
3040Sstevel@tonic-gate 	so_lock_single(so);
3050Sstevel@tonic-gate 	ASSERT(so->so_version == SOV_STREAM);
3060Sstevel@tonic-gate 	so->so_version = SOV_SOCKSTREAM;
3078348SEric.Yu@Sun.COM 	sti->sti_pushcnt = 0;
3080Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
3090Sstevel@tonic-gate 
3100Sstevel@tonic-gate 	/*
3110Sstevel@tonic-gate 	 * Set a permenent error to force any thread in sorecvmsg to
3120Sstevel@tonic-gate 	 * return (and drop SOREADLOCKED). Clear the error once
3130Sstevel@tonic-gate 	 * we have SOREADLOCKED.
3140Sstevel@tonic-gate 	 * This makes a read sleeping during the I_PUSH of sockmod return
3150Sstevel@tonic-gate 	 * EIO.
3160Sstevel@tonic-gate 	 */
3170Sstevel@tonic-gate 	strsetrerror(SOTOV(so), EIO, 1, NULL);
3180Sstevel@tonic-gate 
3190Sstevel@tonic-gate 	/*
3200Sstevel@tonic-gate 	 * Get the read lock before flushing data to avoid
3210Sstevel@tonic-gate 	 * problems with the T_EXDATA_IND MSG_PEEK code in sorecvmsg.
3220Sstevel@tonic-gate 	 */
3230Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
3240Sstevel@tonic-gate 	(void) so_lock_read(so, 0);	/* Set SOREADLOCKED */
3250Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
3260Sstevel@tonic-gate 
3270Sstevel@tonic-gate 	strsetrerror(SOTOV(so), 0, 0, NULL);
3280Sstevel@tonic-gate 	so_installhooks(so);
3290Sstevel@tonic-gate 
3300Sstevel@tonic-gate 	/*
3310Sstevel@tonic-gate 	 * Flush everything on the read queue.
3320Sstevel@tonic-gate 	 * This ensures that no T_CONN_IND remain and that no T_EXDATA_IND
3330Sstevel@tonic-gate 	 * remain; those types of messages would confuse sockfs.
3340Sstevel@tonic-gate 	 */
3350Sstevel@tonic-gate 	strflushrq(vp, FLUSHALL);
3360Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
3370Sstevel@tonic-gate 
3380Sstevel@tonic-gate 	/*
3398348SEric.Yu@Sun.COM 	 * Flush the T_DISCON_IND on sti_discon_ind_mp.
3400Sstevel@tonic-gate 	 */
3410Sstevel@tonic-gate 	so_flush_discon_ind(so);
3420Sstevel@tonic-gate 	so_unlock_read(so);	/* Clear SOREADLOCKED */
3430Sstevel@tonic-gate 
3440Sstevel@tonic-gate 	so_unlock_single(so, SOLOCKED);
3450Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
3460Sstevel@tonic-gate }
3470Sstevel@tonic-gate 
3480Sstevel@tonic-gate /*
3490Sstevel@tonic-gate  * Install the hooks in the stream head.
3500Sstevel@tonic-gate  */
3510Sstevel@tonic-gate void
so_installhooks(struct sonode * so)3520Sstevel@tonic-gate so_installhooks(struct sonode *so)
3530Sstevel@tonic-gate {
3540Sstevel@tonic-gate 	struct vnode *vp = SOTOV(so);
3550Sstevel@tonic-gate 
3560Sstevel@tonic-gate 	strsetrputhooks(vp, SH_SIGALLDATA | SH_IGN_ZEROLEN | SH_CONSOL_DATA,
3570Sstevel@tonic-gate 	    strsock_proto, strsock_misc);
3580Sstevel@tonic-gate 	strsetwputhooks(vp, SH_SIGPIPE | SH_RECHECK_ERR, 0);
3590Sstevel@tonic-gate }
3600Sstevel@tonic-gate 
3610Sstevel@tonic-gate /*
3620Sstevel@tonic-gate  * Remove the hooks in the stream head.
3630Sstevel@tonic-gate  */
3640Sstevel@tonic-gate static void
so_removehooks(struct sonode * so)3650Sstevel@tonic-gate so_removehooks(struct sonode *so)
3660Sstevel@tonic-gate {
3670Sstevel@tonic-gate 	struct vnode *vp = SOTOV(so);
3680Sstevel@tonic-gate 
3690Sstevel@tonic-gate 	strsetrputhooks(vp, 0, NULL, NULL);
3700Sstevel@tonic-gate 	strsetwputhooks(vp, 0, STRTIMOUT);
3710Sstevel@tonic-gate 	/*
3720Sstevel@tonic-gate 	 * Leave read behavior as it would have been for a normal
3730Sstevel@tonic-gate 	 * stream i.e. a read of an M_PROTO will fail.
3740Sstevel@tonic-gate 	 */
3750Sstevel@tonic-gate }
3760Sstevel@tonic-gate 
3778348SEric.Yu@Sun.COM void
so_basic_strinit(struct sonode * so)3788348SEric.Yu@Sun.COM so_basic_strinit(struct sonode *so)
3790Sstevel@tonic-gate {
3800Sstevel@tonic-gate 	struct vnode *vp = SOTOV(so);
3810Sstevel@tonic-gate 	struct stdata *stp;
3820Sstevel@tonic-gate 	mblk_t *mp;
3838348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
3840Sstevel@tonic-gate 
3850Sstevel@tonic-gate 	/* Preallocate an unbind_req message */
3868778SErik.Nordmark@Sun.COM 	mp = soallocproto(sizeof (struct T_unbind_req), _ALLOC_SLEEP, CRED());
3870Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
3888348SEric.Yu@Sun.COM 	sti->sti_unbind_mp = mp;
3890Sstevel@tonic-gate #ifdef DEBUG
3900Sstevel@tonic-gate 	so->so_options = so_default_options;
3910Sstevel@tonic-gate #endif /* DEBUG */
3920Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
3930Sstevel@tonic-gate 
3940Sstevel@tonic-gate 	so_installhooks(so);
3950Sstevel@tonic-gate 
3960Sstevel@tonic-gate 	stp = vp->v_stream;
3970Sstevel@tonic-gate 	/*
3980Sstevel@tonic-gate 	 * Have to keep minpsz at zero in order to allow write/send of zero
3990Sstevel@tonic-gate 	 * bytes.
4000Sstevel@tonic-gate 	 */
4010Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
4020Sstevel@tonic-gate 	if (stp->sd_qn_minpsz == 1)
4030Sstevel@tonic-gate 		stp->sd_qn_minpsz = 0;
4040Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
4058348SEric.Yu@Sun.COM }
4066707Sbrutus 
4078348SEric.Yu@Sun.COM /*
4088348SEric.Yu@Sun.COM  * Initialize the streams side of a socket including
4098348SEric.Yu@Sun.COM  * T_info_req/ack processing. If tso is not NULL its values are used thereby
4108348SEric.Yu@Sun.COM  * avoiding the T_INFO_REQ.
4118348SEric.Yu@Sun.COM  */
4128348SEric.Yu@Sun.COM int
so_strinit(struct sonode * so,struct sonode * tso)4138348SEric.Yu@Sun.COM so_strinit(struct sonode *so, struct sonode *tso)
4148348SEric.Yu@Sun.COM {
4158348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
4168348SEric.Yu@Sun.COM 	sotpi_info_t *tsti;
4178348SEric.Yu@Sun.COM 	int error;
4188348SEric.Yu@Sun.COM 
4198348SEric.Yu@Sun.COM 	so_basic_strinit(so);
4208348SEric.Yu@Sun.COM 
4218348SEric.Yu@Sun.COM 	/*
4228348SEric.Yu@Sun.COM 	 * The T_CAPABILITY_REQ should be the first message sent down because
4238348SEric.Yu@Sun.COM 	 * at least TCP has a fast-path for this which avoids timeouts while
4248348SEric.Yu@Sun.COM 	 * waiting for the T_CAPABILITY_ACK under high system load.
4258348SEric.Yu@Sun.COM 	 */
4268348SEric.Yu@Sun.COM 	if (tso == NULL) {
4278348SEric.Yu@Sun.COM 		error = do_tcapability(so, TC1_ACCEPTOR_ID | TC1_INFO);
4288348SEric.Yu@Sun.COM 		if (error)
4298348SEric.Yu@Sun.COM 			return (error);
4308348SEric.Yu@Sun.COM 	} else {
4318348SEric.Yu@Sun.COM 		tsti = SOTOTPI(tso);
4326707Sbrutus 
4338348SEric.Yu@Sun.COM 		mutex_enter(&so->so_lock);
4348348SEric.Yu@Sun.COM 		sti->sti_tsdu_size = tsti->sti_tsdu_size;
4358348SEric.Yu@Sun.COM 		sti->sti_etsdu_size = tsti->sti_etsdu_size;
4368348SEric.Yu@Sun.COM 		sti->sti_addr_size = tsti->sti_addr_size;
4378348SEric.Yu@Sun.COM 		sti->sti_opt_size = tsti->sti_opt_size;
4388348SEric.Yu@Sun.COM 		sti->sti_tidu_size = tsti->sti_tidu_size;
4398348SEric.Yu@Sun.COM 		sti->sti_serv_type = tsti->sti_serv_type;
4408348SEric.Yu@Sun.COM 		so->so_mode = tso->so_mode & ~SM_ACCEPTOR_ID;
4418348SEric.Yu@Sun.COM 		mutex_exit(&so->so_lock);
4428348SEric.Yu@Sun.COM 
4438348SEric.Yu@Sun.COM 		/* the following do_tcapability may update so->so_mode */
4448348SEric.Yu@Sun.COM 		if ((tsti->sti_serv_type != T_CLTS) &&
4458348SEric.Yu@Sun.COM 		    (sti->sti_direct == 0)) {
4468348SEric.Yu@Sun.COM 			error = do_tcapability(so, TC1_ACCEPTOR_ID);
4478348SEric.Yu@Sun.COM 			if (error)
4488348SEric.Yu@Sun.COM 				return (error);
4498348SEric.Yu@Sun.COM 		}
4506707Sbrutus 	}
4518348SEric.Yu@Sun.COM 	/*
4528348SEric.Yu@Sun.COM 	 * If the addr_size is 0 we treat it as already bound
4538348SEric.Yu@Sun.COM 	 * and connected. This is used by the routing socket.
4548348SEric.Yu@Sun.COM 	 * We set the addr_size to something to allocate a the address
4558348SEric.Yu@Sun.COM 	 * structures.
4568348SEric.Yu@Sun.COM 	 */
4578348SEric.Yu@Sun.COM 	if (sti->sti_addr_size == 0) {
4588348SEric.Yu@Sun.COM 		so->so_state |= SS_ISBOUND | SS_ISCONNECTED;
4598348SEric.Yu@Sun.COM 		/* Address size can vary with address families. */
4608348SEric.Yu@Sun.COM 		if (so->so_family == AF_INET6)
4618348SEric.Yu@Sun.COM 			sti->sti_addr_size =
4628348SEric.Yu@Sun.COM 			    (t_scalar_t)sizeof (struct sockaddr_in6);
4638348SEric.Yu@Sun.COM 		else
4648348SEric.Yu@Sun.COM 			sti->sti_addr_size =
4658348SEric.Yu@Sun.COM 			    (t_scalar_t)sizeof (struct sockaddr_in);
4668348SEric.Yu@Sun.COM 		ASSERT(sti->sti_unbind_mp);
4678348SEric.Yu@Sun.COM 	}
4688348SEric.Yu@Sun.COM 
4698348SEric.Yu@Sun.COM 	so_alloc_addr(so, sti->sti_addr_size);
4706707Sbrutus 
4710Sstevel@tonic-gate 	return (0);
4720Sstevel@tonic-gate }
4730Sstevel@tonic-gate 
4740Sstevel@tonic-gate static void
copy_tinfo(struct sonode * so,struct T_info_ack * tia)4750Sstevel@tonic-gate copy_tinfo(struct sonode *so, struct T_info_ack *tia)
4760Sstevel@tonic-gate {
4778348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
4788348SEric.Yu@Sun.COM 
4798348SEric.Yu@Sun.COM 	sti->sti_tsdu_size = tia->TSDU_size;
4808348SEric.Yu@Sun.COM 	sti->sti_etsdu_size = tia->ETSDU_size;
4818348SEric.Yu@Sun.COM 	sti->sti_addr_size = tia->ADDR_size;
4828348SEric.Yu@Sun.COM 	sti->sti_opt_size = tia->OPT_size;
4838348SEric.Yu@Sun.COM 	sti->sti_tidu_size = tia->TIDU_size;
4848348SEric.Yu@Sun.COM 	sti->sti_serv_type = tia->SERV_type;
4850Sstevel@tonic-gate 	switch (tia->CURRENT_state) {
4860Sstevel@tonic-gate 	case TS_UNBND:
4870Sstevel@tonic-gate 		break;
4880Sstevel@tonic-gate 	case TS_IDLE:
4890Sstevel@tonic-gate 		so->so_state |= SS_ISBOUND;
4908348SEric.Yu@Sun.COM 		sti->sti_laddr_len = 0;
4918348SEric.Yu@Sun.COM 		sti->sti_laddr_valid = 0;
4920Sstevel@tonic-gate 		break;
4930Sstevel@tonic-gate 	case TS_DATA_XFER:
4940Sstevel@tonic-gate 		so->so_state |= SS_ISBOUND|SS_ISCONNECTED;
4958348SEric.Yu@Sun.COM 		sti->sti_laddr_len = 0;
4968348SEric.Yu@Sun.COM 		sti->sti_faddr_len = 0;
4978348SEric.Yu@Sun.COM 		sti->sti_laddr_valid = 0;
4988348SEric.Yu@Sun.COM 		sti->sti_faddr_valid = 0;
4990Sstevel@tonic-gate 		break;
5000Sstevel@tonic-gate 	}
5010Sstevel@tonic-gate 
5020Sstevel@tonic-gate 	/*
5030Sstevel@tonic-gate 	 * Heuristics for determining the socket mode flags
5040Sstevel@tonic-gate 	 * (SM_ATOMIC, SM_CONNREQUIRED, SM_ADDR, SM_FDPASSING,
5050Sstevel@tonic-gate 	 * and SM_EXDATA, SM_OPTDATA, and SM_BYTESTREAM)
5060Sstevel@tonic-gate 	 * from the info ack.
5070Sstevel@tonic-gate 	 */
5088348SEric.Yu@Sun.COM 	if (sti->sti_serv_type == T_CLTS) {
5090Sstevel@tonic-gate 		so->so_mode |= SM_ATOMIC | SM_ADDR;
5100Sstevel@tonic-gate 	} else {
5110Sstevel@tonic-gate 		so->so_mode |= SM_CONNREQUIRED;
5128348SEric.Yu@Sun.COM 		if (sti->sti_etsdu_size != 0 && sti->sti_etsdu_size != -2)
5130Sstevel@tonic-gate 			so->so_mode |= SM_EXDATA;
5140Sstevel@tonic-gate 	}
5150Sstevel@tonic-gate 	if (so->so_type == SOCK_SEQPACKET || so->so_type == SOCK_RAW) {
5160Sstevel@tonic-gate 		/* Semantics are to discard tail end of messages */
5170Sstevel@tonic-gate 		so->so_mode |= SM_ATOMIC;
5180Sstevel@tonic-gate 	}
5190Sstevel@tonic-gate 	if (so->so_family == AF_UNIX) {
5200Sstevel@tonic-gate 		so->so_mode |= SM_FDPASSING | SM_OPTDATA;
5218348SEric.Yu@Sun.COM 		if (sti->sti_addr_size == -1) {
5220Sstevel@tonic-gate 			/* MAXPATHLEN + soun_family + nul termination */
5238348SEric.Yu@Sun.COM 			sti->sti_addr_size = (t_scalar_t)(MAXPATHLEN +
5245753Sgww 			    sizeof (short) + 1);
5250Sstevel@tonic-gate 		}
5260Sstevel@tonic-gate 		if (so->so_type == SOCK_STREAM) {
5270Sstevel@tonic-gate 			/*
5280Sstevel@tonic-gate 			 * Make it into a byte-stream transport.
5290Sstevel@tonic-gate 			 * SOCK_SEQPACKET sockets are unchanged.
5300Sstevel@tonic-gate 			 */
5318348SEric.Yu@Sun.COM 			sti->sti_tsdu_size = 0;
5320Sstevel@tonic-gate 		}
5338348SEric.Yu@Sun.COM 	} else if (sti->sti_addr_size == -1) {
5340Sstevel@tonic-gate 		/*
5350Sstevel@tonic-gate 		 * Logic extracted from sockmod - have to pick some max address
5360Sstevel@tonic-gate 		 * length in order to preallocate the addresses.
5370Sstevel@tonic-gate 		 */
5388348SEric.Yu@Sun.COM 		sti->sti_addr_size = SOA_DEFSIZE;
5390Sstevel@tonic-gate 	}
5408348SEric.Yu@Sun.COM 	if (sti->sti_tsdu_size == 0)
5410Sstevel@tonic-gate 		so->so_mode |= SM_BYTESTREAM;
5420Sstevel@tonic-gate }
5430Sstevel@tonic-gate 
5440Sstevel@tonic-gate static int
check_tinfo(struct sonode * so)5450Sstevel@tonic-gate check_tinfo(struct sonode *so)
5460Sstevel@tonic-gate {
5478348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
5488348SEric.Yu@Sun.COM 
5490Sstevel@tonic-gate 	/* Consistency checks */
5508348SEric.Yu@Sun.COM 	if (so->so_type == SOCK_DGRAM && sti->sti_serv_type != T_CLTS) {
5510Sstevel@tonic-gate 		eprintso(so, ("service type and socket type mismatch\n"));
5520Sstevel@tonic-gate 		eprintsoline(so, EPROTO);
5530Sstevel@tonic-gate 		return (EPROTO);
5540Sstevel@tonic-gate 	}
5558348SEric.Yu@Sun.COM 	if (so->so_type == SOCK_STREAM && sti->sti_serv_type == T_CLTS) {
5560Sstevel@tonic-gate 		eprintso(so, ("service type and socket type mismatch\n"));
5570Sstevel@tonic-gate 		eprintsoline(so, EPROTO);
5580Sstevel@tonic-gate 		return (EPROTO);
5590Sstevel@tonic-gate 	}
5608348SEric.Yu@Sun.COM 	if (so->so_type == SOCK_SEQPACKET && sti->sti_serv_type == T_CLTS) {
5610Sstevel@tonic-gate 		eprintso(so, ("service type and socket type mismatch\n"));
5620Sstevel@tonic-gate 		eprintsoline(so, EPROTO);
5630Sstevel@tonic-gate 		return (EPROTO);
5640Sstevel@tonic-gate 	}
5650Sstevel@tonic-gate 	if (so->so_family == AF_INET &&
5668348SEric.Yu@Sun.COM 	    sti->sti_addr_size != (t_scalar_t)sizeof (struct sockaddr_in)) {
5670Sstevel@tonic-gate 		eprintso(so,
5680Sstevel@tonic-gate 		    ("AF_INET must have sockaddr_in address length. Got %d\n",
5698348SEric.Yu@Sun.COM 		    sti->sti_addr_size));
5700Sstevel@tonic-gate 		eprintsoline(so, EMSGSIZE);
5710Sstevel@tonic-gate 		return (EMSGSIZE);
5720Sstevel@tonic-gate 	}
5730Sstevel@tonic-gate 	if (so->so_family == AF_INET6 &&
5748348SEric.Yu@Sun.COM 	    sti->sti_addr_size != (t_scalar_t)sizeof (struct sockaddr_in6)) {
5750Sstevel@tonic-gate 		eprintso(so,
5760Sstevel@tonic-gate 		    ("AF_INET6 must have sockaddr_in6 address length. Got %d\n",
5778348SEric.Yu@Sun.COM 		    sti->sti_addr_size));
5780Sstevel@tonic-gate 		eprintsoline(so, EMSGSIZE);
5790Sstevel@tonic-gate 		return (EMSGSIZE);
5800Sstevel@tonic-gate 	}
5810Sstevel@tonic-gate 
5820Sstevel@tonic-gate 	dprintso(so, 1, (
5830Sstevel@tonic-gate 	    "tinfo: serv %d tsdu %d, etsdu %d, addr %d, opt %d, tidu %d\n",
5848348SEric.Yu@Sun.COM 	    sti->sti_serv_type, sti->sti_tsdu_size, sti->sti_etsdu_size,
5858348SEric.Yu@Sun.COM 	    sti->sti_addr_size, sti->sti_opt_size,
5868348SEric.Yu@Sun.COM 	    sti->sti_tidu_size));
5870Sstevel@tonic-gate 	dprintso(so, 1, ("tinfo: so_state %s\n",
5885753Sgww 	    pr_state(so->so_state, so->so_mode)));
5890Sstevel@tonic-gate 	return (0);
5900Sstevel@tonic-gate }
5910Sstevel@tonic-gate 
5920Sstevel@tonic-gate /*
5930Sstevel@tonic-gate  * Send down T_info_req and wait for the ack.
5940Sstevel@tonic-gate  * Record interesting T_info_ack values in the sonode.
5950Sstevel@tonic-gate  */
5960Sstevel@tonic-gate static int
do_tinfo(struct sonode * so)5970Sstevel@tonic-gate do_tinfo(struct sonode *so)
5980Sstevel@tonic-gate {
5990Sstevel@tonic-gate 	struct T_info_req tir;
6000Sstevel@tonic-gate 	mblk_t *mp;
6010Sstevel@tonic-gate 	int error;
6020Sstevel@tonic-gate 
6030Sstevel@tonic-gate 	ASSERT(MUTEX_NOT_HELD(&so->so_lock));
6040Sstevel@tonic-gate 
6050Sstevel@tonic-gate 	if (so_no_tinfo) {
6068348SEric.Yu@Sun.COM 		SOTOTPI(so)->sti_addr_size = 0;
6070Sstevel@tonic-gate 		return (0);
6080Sstevel@tonic-gate 	}
6090Sstevel@tonic-gate 
6107240Srh87107 	dprintso(so, 1, ("do_tinfo(%p)\n", (void *)so));
6110Sstevel@tonic-gate 
6120Sstevel@tonic-gate 	/* Send T_INFO_REQ */
6130Sstevel@tonic-gate 	tir.PRIM_type = T_INFO_REQ;
6140Sstevel@tonic-gate 	mp = soallocproto1(&tir, sizeof (tir),
6150Sstevel@tonic-gate 	    sizeof (struct T_info_req) + sizeof (struct T_info_ack),
6168778SErik.Nordmark@Sun.COM 	    _ALLOC_INTR, CRED());
6170Sstevel@tonic-gate 	if (mp == NULL) {
6180Sstevel@tonic-gate 		eprintsoline(so, ENOBUFS);
6190Sstevel@tonic-gate 		return (ENOBUFS);
6200Sstevel@tonic-gate 	}
6210Sstevel@tonic-gate 	/* T_INFO_REQ has to be M_PCPROTO */
6220Sstevel@tonic-gate 	DB_TYPE(mp) = M_PCPROTO;
6230Sstevel@tonic-gate 
6240Sstevel@tonic-gate 	error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
6255753Sgww 	    MSG_BAND|MSG_HOLDSIG|MSG_IGNERROR, 0);
6260Sstevel@tonic-gate 	if (error) {
6270Sstevel@tonic-gate 		eprintsoline(so, error);
6280Sstevel@tonic-gate 		return (error);
6290Sstevel@tonic-gate 	}
6300Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
6310Sstevel@tonic-gate 	/* Wait for T_INFO_ACK */
6320Sstevel@tonic-gate 	if ((error = sowaitprim(so, T_INFO_REQ, T_INFO_ACK,
6330Sstevel@tonic-gate 	    (t_uscalar_t)sizeof (struct T_info_ack), &mp, 0))) {
6340Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
6350Sstevel@tonic-gate 		eprintsoline(so, error);
6360Sstevel@tonic-gate 		return (error);
6370Sstevel@tonic-gate 	}
6380Sstevel@tonic-gate 
6390Sstevel@tonic-gate 	ASSERT(mp);
6400Sstevel@tonic-gate 	copy_tinfo(so, (struct T_info_ack *)mp->b_rptr);
6410Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
6420Sstevel@tonic-gate 	freemsg(mp);
6430Sstevel@tonic-gate 	return (check_tinfo(so));
6440Sstevel@tonic-gate }
6450Sstevel@tonic-gate 
6460Sstevel@tonic-gate /*
6470Sstevel@tonic-gate  * Send down T_capability_req and wait for the ack.
6480Sstevel@tonic-gate  * Record interesting T_capability_ack values in the sonode.
6490Sstevel@tonic-gate  */
6500Sstevel@tonic-gate static int
do_tcapability(struct sonode * so,t_uscalar_t cap_bits1)6510Sstevel@tonic-gate do_tcapability(struct sonode *so, t_uscalar_t cap_bits1)
6520Sstevel@tonic-gate {
6530Sstevel@tonic-gate 	struct T_capability_req tcr;
6540Sstevel@tonic-gate 	struct T_capability_ack *tca;
6550Sstevel@tonic-gate 	mblk_t *mp;
6560Sstevel@tonic-gate 	int error;
6578348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
6580Sstevel@tonic-gate 
6590Sstevel@tonic-gate 	ASSERT(cap_bits1 != 0);
6600Sstevel@tonic-gate 	ASSERT((cap_bits1 & ~(TC1_ACCEPTOR_ID | TC1_INFO)) == 0);
6610Sstevel@tonic-gate 	ASSERT(MUTEX_NOT_HELD(&so->so_lock));
6620Sstevel@tonic-gate 
6638348SEric.Yu@Sun.COM 	if (sti->sti_provinfo->tpi_capability == PI_NO)
6640Sstevel@tonic-gate 		return (do_tinfo(so));
6650Sstevel@tonic-gate 
6660Sstevel@tonic-gate 	if (so_no_tinfo) {
6678348SEric.Yu@Sun.COM 		sti->sti_addr_size = 0;
6680Sstevel@tonic-gate 		if ((cap_bits1 &= ~TC1_INFO) == 0)
6690Sstevel@tonic-gate 			return (0);
6700Sstevel@tonic-gate 	}
6710Sstevel@tonic-gate 
6727240Srh87107 	dprintso(so, 1, ("do_tcapability(%p)\n", (void *)so));
6730Sstevel@tonic-gate 
6740Sstevel@tonic-gate 	/* Send T_CAPABILITY_REQ */
6750Sstevel@tonic-gate 	tcr.PRIM_type = T_CAPABILITY_REQ;
6760Sstevel@tonic-gate 	tcr.CAP_bits1 = cap_bits1;
6770Sstevel@tonic-gate 	mp = soallocproto1(&tcr, sizeof (tcr),
6780Sstevel@tonic-gate 	    sizeof (struct T_capability_req) + sizeof (struct T_capability_ack),
6798778SErik.Nordmark@Sun.COM 	    _ALLOC_INTR, CRED());
6800Sstevel@tonic-gate 	if (mp == NULL) {
6810Sstevel@tonic-gate 		eprintsoline(so, ENOBUFS);
6820Sstevel@tonic-gate 		return (ENOBUFS);
6830Sstevel@tonic-gate 	}
6840Sstevel@tonic-gate 	/* T_CAPABILITY_REQ should be M_PCPROTO here */
6850Sstevel@tonic-gate 	DB_TYPE(mp) = M_PCPROTO;
6860Sstevel@tonic-gate 
6870Sstevel@tonic-gate 	error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
6880Sstevel@tonic-gate 	    MSG_BAND|MSG_HOLDSIG|MSG_IGNERROR, 0);
6890Sstevel@tonic-gate 	if (error) {
6900Sstevel@tonic-gate 		eprintsoline(so, error);
6910Sstevel@tonic-gate 		return (error);
6920Sstevel@tonic-gate 	}
6930Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
6940Sstevel@tonic-gate 	/* Wait for T_CAPABILITY_ACK */
6950Sstevel@tonic-gate 	if ((error = sowaitprim(so, T_CAPABILITY_REQ, T_CAPABILITY_ACK,
6960Sstevel@tonic-gate 	    (t_uscalar_t)sizeof (*tca), &mp, sock_capability_timeout * hz))) {
6970Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
6988348SEric.Yu@Sun.COM 		PI_PROVLOCK(sti->sti_provinfo);
6998348SEric.Yu@Sun.COM 		if (sti->sti_provinfo->tpi_capability == PI_DONTKNOW)
7008348SEric.Yu@Sun.COM 			sti->sti_provinfo->tpi_capability = PI_NO;
7018348SEric.Yu@Sun.COM 		PI_PROVUNLOCK(sti->sti_provinfo);
7020Sstevel@tonic-gate 		ASSERT((so->so_mode & SM_ACCEPTOR_ID) == 0);
7030Sstevel@tonic-gate 		if (cap_bits1 & TC1_INFO) {
7040Sstevel@tonic-gate 			/*
7050Sstevel@tonic-gate 			 * If the T_CAPABILITY_REQ timed out and then a
7060Sstevel@tonic-gate 			 * T_INFO_REQ gets a protocol error, most likely
7070Sstevel@tonic-gate 			 * the capability was slow (vs. unsupported). Return
7080Sstevel@tonic-gate 			 * ENOSR for this case as a best guess.
7090Sstevel@tonic-gate 			 */
7100Sstevel@tonic-gate 			if (error == ETIME) {
7110Sstevel@tonic-gate 				return ((error = do_tinfo(so)) == EPROTO ?
7120Sstevel@tonic-gate 				    ENOSR : error);
7130Sstevel@tonic-gate 			}
7140Sstevel@tonic-gate 			return (do_tinfo(so));
7150Sstevel@tonic-gate 		}
7160Sstevel@tonic-gate 		return (0);
7170Sstevel@tonic-gate 	}
7180Sstevel@tonic-gate 
7190Sstevel@tonic-gate 	ASSERT(mp);
7200Sstevel@tonic-gate 	tca = (struct T_capability_ack *)mp->b_rptr;
7210Sstevel@tonic-gate 
7220Sstevel@tonic-gate 	ASSERT((cap_bits1 & TC1_INFO) == (tca->CAP_bits1 & TC1_INFO));
7238348SEric.Yu@Sun.COM 	so_proc_tcapability_ack(so, tca);
7240Sstevel@tonic-gate 
7250Sstevel@tonic-gate 	cap_bits1 = tca->CAP_bits1;
7260Sstevel@tonic-gate 
7270Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
7280Sstevel@tonic-gate 	freemsg(mp);
7290Sstevel@tonic-gate 
7300Sstevel@tonic-gate 	if (cap_bits1 & TC1_INFO)
7310Sstevel@tonic-gate 		return (check_tinfo(so));
7320Sstevel@tonic-gate 
7330Sstevel@tonic-gate 	return (0);
7340Sstevel@tonic-gate }
7350Sstevel@tonic-gate 
7360Sstevel@tonic-gate /*
7378348SEric.Yu@Sun.COM  * Process a T_CAPABILITY_ACK
7388348SEric.Yu@Sun.COM  */
7398348SEric.Yu@Sun.COM void
so_proc_tcapability_ack(struct sonode * so,struct T_capability_ack * tca)7408348SEric.Yu@Sun.COM so_proc_tcapability_ack(struct sonode *so, struct T_capability_ack *tca)
7418348SEric.Yu@Sun.COM {
7428348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
7438348SEric.Yu@Sun.COM 
7448348SEric.Yu@Sun.COM 	if (sti->sti_provinfo->tpi_capability == PI_DONTKNOW) {
7458348SEric.Yu@Sun.COM 		PI_PROVLOCK(sti->sti_provinfo);
7468348SEric.Yu@Sun.COM 		sti->sti_provinfo->tpi_capability = PI_YES;
7478348SEric.Yu@Sun.COM 		PI_PROVUNLOCK(sti->sti_provinfo);
7488348SEric.Yu@Sun.COM 	}
7498348SEric.Yu@Sun.COM 
7508348SEric.Yu@Sun.COM 	if (tca->CAP_bits1 & TC1_ACCEPTOR_ID) {
7518348SEric.Yu@Sun.COM 		sti->sti_acceptor_id = tca->ACCEPTOR_id;
7528348SEric.Yu@Sun.COM 		so->so_mode |= SM_ACCEPTOR_ID;
7538348SEric.Yu@Sun.COM 	}
7548348SEric.Yu@Sun.COM 
7558348SEric.Yu@Sun.COM 	if (tca->CAP_bits1 & TC1_INFO)
7568348SEric.Yu@Sun.COM 		copy_tinfo(so, &tca->INFO_ack);
7578348SEric.Yu@Sun.COM }
7588348SEric.Yu@Sun.COM 
7598348SEric.Yu@Sun.COM /*
7608348SEric.Yu@Sun.COM  * Retrieve socket error, clear error if not peek.
7610Sstevel@tonic-gate  */
7620Sstevel@tonic-gate int
sogeterr(struct sonode * so,boolean_t clear_err)7638348SEric.Yu@Sun.COM sogeterr(struct sonode *so, boolean_t clear_err)
7640Sstevel@tonic-gate {
7650Sstevel@tonic-gate 	int error;
7660Sstevel@tonic-gate 
7670Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
7680Sstevel@tonic-gate 
7690Sstevel@tonic-gate 	error = so->so_error;
7708348SEric.Yu@Sun.COM 	if (clear_err)
7718348SEric.Yu@Sun.COM 		so->so_error = 0;
7720Sstevel@tonic-gate 
7730Sstevel@tonic-gate 	return (error);
7740Sstevel@tonic-gate }
7750Sstevel@tonic-gate 
7760Sstevel@tonic-gate /*
7770Sstevel@tonic-gate  * This routine is registered with the stream head to retrieve read
7780Sstevel@tonic-gate  * side errors.
7790Sstevel@tonic-gate  * It does not clear the socket error for a peeking read side operation.
7800Sstevel@tonic-gate  * It the error is to be cleared it sets *clearerr.
7810Sstevel@tonic-gate  */
7820Sstevel@tonic-gate int
sogetrderr(vnode_t * vp,int ispeek,int * clearerr)7830Sstevel@tonic-gate sogetrderr(vnode_t *vp, int ispeek, int *clearerr)
7840Sstevel@tonic-gate {
7850Sstevel@tonic-gate 	struct sonode *so = VTOSO(vp);
7860Sstevel@tonic-gate 	int error;
7870Sstevel@tonic-gate 
7880Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
7890Sstevel@tonic-gate 	if (ispeek) {
7900Sstevel@tonic-gate 		error = so->so_error;
7910Sstevel@tonic-gate 		*clearerr = 0;
7920Sstevel@tonic-gate 	} else {
7930Sstevel@tonic-gate 		error = so->so_error;
7940Sstevel@tonic-gate 		so->so_error = 0;
7950Sstevel@tonic-gate 		*clearerr = 1;
7960Sstevel@tonic-gate 	}
7970Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
7980Sstevel@tonic-gate 	return (error);
7990Sstevel@tonic-gate }
8000Sstevel@tonic-gate 
8010Sstevel@tonic-gate /*
8020Sstevel@tonic-gate  * This routine is registered with the stream head to retrieve write
8030Sstevel@tonic-gate  * side errors.
8040Sstevel@tonic-gate  * It does not clear the socket error for a peeking read side operation.
8050Sstevel@tonic-gate  * It the error is to be cleared it sets *clearerr.
8060Sstevel@tonic-gate  */
8070Sstevel@tonic-gate int
sogetwrerr(vnode_t * vp,int ispeek,int * clearerr)8080Sstevel@tonic-gate sogetwrerr(vnode_t *vp, int ispeek, int *clearerr)
8090Sstevel@tonic-gate {
8100Sstevel@tonic-gate 	struct sonode *so = VTOSO(vp);
8110Sstevel@tonic-gate 	int error;
8120Sstevel@tonic-gate 
8130Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
8140Sstevel@tonic-gate 	if (so->so_state & SS_CANTSENDMORE) {
8150Sstevel@tonic-gate 		error = EPIPE;
8160Sstevel@tonic-gate 		*clearerr = 0;
8170Sstevel@tonic-gate 	} else {
8180Sstevel@tonic-gate 		error = so->so_error;
8190Sstevel@tonic-gate 		if (ispeek) {
8200Sstevel@tonic-gate 			*clearerr = 0;
8210Sstevel@tonic-gate 		} else {
8220Sstevel@tonic-gate 			so->so_error = 0;
8230Sstevel@tonic-gate 			*clearerr = 1;
8240Sstevel@tonic-gate 		}
8250Sstevel@tonic-gate 	}
8260Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
8270Sstevel@tonic-gate 	return (error);
8280Sstevel@tonic-gate }
8290Sstevel@tonic-gate 
8300Sstevel@tonic-gate /*
8310Sstevel@tonic-gate  * Set a nonpersistent read and write error on the socket.
8320Sstevel@tonic-gate  * Used when there is a T_uderror_ind for a connected socket.
8330Sstevel@tonic-gate  * The caller also needs to call strsetrerror and strsetwerror
8340Sstevel@tonic-gate  * after dropping the lock.
8350Sstevel@tonic-gate  */
8360Sstevel@tonic-gate void
soseterror(struct sonode * so,int error)8370Sstevel@tonic-gate soseterror(struct sonode *so, int error)
8380Sstevel@tonic-gate {
8390Sstevel@tonic-gate 	ASSERT(error != 0);
8400Sstevel@tonic-gate 
8410Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
8420Sstevel@tonic-gate 	so->so_error = (ushort_t)error;
8430Sstevel@tonic-gate }
8440Sstevel@tonic-gate 
8450Sstevel@tonic-gate void
soisconnecting(struct sonode * so)8460Sstevel@tonic-gate soisconnecting(struct sonode *so)
8470Sstevel@tonic-gate {
8480Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
8490Sstevel@tonic-gate 	so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING);
8500Sstevel@tonic-gate 	so->so_state |= SS_ISCONNECTING;
8510Sstevel@tonic-gate 	cv_broadcast(&so->so_state_cv);
8520Sstevel@tonic-gate }
8530Sstevel@tonic-gate 
8540Sstevel@tonic-gate void
soisconnected(struct sonode * so)8550Sstevel@tonic-gate soisconnected(struct sonode *so)
8560Sstevel@tonic-gate {
8570Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
8580Sstevel@tonic-gate 	so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING);
8590Sstevel@tonic-gate 	so->so_state |= SS_ISCONNECTED;
8600Sstevel@tonic-gate 	cv_broadcast(&so->so_state_cv);
8610Sstevel@tonic-gate }
8620Sstevel@tonic-gate 
8630Sstevel@tonic-gate /*
8640Sstevel@tonic-gate  * The caller also needs to call strsetrerror, strsetwerror and strseteof.
8650Sstevel@tonic-gate  */
8660Sstevel@tonic-gate void
soisdisconnected(struct sonode * so,int error)8670Sstevel@tonic-gate soisdisconnected(struct sonode *so, int error)
8680Sstevel@tonic-gate {
8690Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
8708348SEric.Yu@Sun.COM 	so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
8710Sstevel@tonic-gate 	so->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE);
8720Sstevel@tonic-gate 	so->so_error = (ushort_t)error;
8730Sstevel@tonic-gate 	if (so->so_peercred != NULL) {
8740Sstevel@tonic-gate 		crfree(so->so_peercred);
8750Sstevel@tonic-gate 		so->so_peercred = NULL;
8760Sstevel@tonic-gate 	}
8770Sstevel@tonic-gate 	cv_broadcast(&so->so_state_cv);
8780Sstevel@tonic-gate }
8790Sstevel@tonic-gate 
8800Sstevel@tonic-gate /*
8810Sstevel@tonic-gate  * For connected AF_UNIX SOCK_DGRAM sockets when the peer closes.
8820Sstevel@tonic-gate  * Does not affect write side.
8830Sstevel@tonic-gate  * The caller also has to call strsetrerror.
8840Sstevel@tonic-gate  */
8850Sstevel@tonic-gate static void
sobreakconn(struct sonode * so,int error)8860Sstevel@tonic-gate sobreakconn(struct sonode *so, int error)
8870Sstevel@tonic-gate {
8880Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
8890Sstevel@tonic-gate 	so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
8900Sstevel@tonic-gate 	so->so_error = (ushort_t)error;
8910Sstevel@tonic-gate 	cv_broadcast(&so->so_state_cv);
8920Sstevel@tonic-gate }
8930Sstevel@tonic-gate 
8940Sstevel@tonic-gate /*
8950Sstevel@tonic-gate  * Can no longer send.
8960Sstevel@tonic-gate  * Caller must also call strsetwerror.
8970Sstevel@tonic-gate  *
8980Sstevel@tonic-gate  * We mark the peer address as no longer valid for getpeername, but
8990Sstevel@tonic-gate  * leave it around for so_unix_close to notify the peer (that
9000Sstevel@tonic-gate  * transport has no addressing held at that layer).
9010Sstevel@tonic-gate  */
9020Sstevel@tonic-gate void
socantsendmore(struct sonode * so)9030Sstevel@tonic-gate socantsendmore(struct sonode *so)
9040Sstevel@tonic-gate {
9050Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
9068348SEric.Yu@Sun.COM 	so->so_state |= SS_CANTSENDMORE;
9070Sstevel@tonic-gate 	cv_broadcast(&so->so_state_cv);
9080Sstevel@tonic-gate }
9090Sstevel@tonic-gate 
9100Sstevel@tonic-gate /*
9110Sstevel@tonic-gate  * The caller must call strseteof(,1) as well as this routine
9120Sstevel@tonic-gate  * to change the socket state.
9130Sstevel@tonic-gate  */
9140Sstevel@tonic-gate void
socantrcvmore(struct sonode * so)9150Sstevel@tonic-gate socantrcvmore(struct sonode *so)
9160Sstevel@tonic-gate {
9170Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
9180Sstevel@tonic-gate 	so->so_state |= SS_CANTRCVMORE;
9190Sstevel@tonic-gate 	cv_broadcast(&so->so_state_cv);
9200Sstevel@tonic-gate }
9210Sstevel@tonic-gate 
9220Sstevel@tonic-gate /*
9230Sstevel@tonic-gate  * The caller has sent down a "request_prim" primitive and wants to wait for
9240Sstevel@tonic-gate  * an ack ("ack_prim") or an T_ERROR_ACK for it.
9250Sstevel@tonic-gate  * The specified "ack_prim" can be a T_OK_ACK.
9260Sstevel@tonic-gate  *
9270Sstevel@tonic-gate  * Assumes that all the TPI acks are M_PCPROTO messages.
9280Sstevel@tonic-gate  *
9290Sstevel@tonic-gate  * Note that the socket is single-threaded (using so_lock_single)
9300Sstevel@tonic-gate  * for all operations that generate TPI ack messages. Since
9310Sstevel@tonic-gate  * only TPI ack messages are M_PCPROTO we should never receive
9320Sstevel@tonic-gate  * anything except either the ack we are expecting or a T_ERROR_ACK
9330Sstevel@tonic-gate  * for the same primitive.
9340Sstevel@tonic-gate  */
9350Sstevel@tonic-gate int
sowaitprim(struct sonode * so,t_scalar_t request_prim,t_scalar_t ack_prim,t_uscalar_t min_size,mblk_t ** mpp,clock_t wait)9360Sstevel@tonic-gate sowaitprim(struct sonode *so, t_scalar_t request_prim, t_scalar_t ack_prim,
9370Sstevel@tonic-gate 	    t_uscalar_t min_size, mblk_t **mpp, clock_t wait)
9380Sstevel@tonic-gate {
9390Sstevel@tonic-gate 	mblk_t *mp;
9400Sstevel@tonic-gate 	union T_primitives *tpr;
9410Sstevel@tonic-gate 	int error;
9420Sstevel@tonic-gate 
9430Sstevel@tonic-gate 	dprintso(so, 1, ("sowaitprim(%p, %d, %d, %d, %p, %lu)\n",
9447240Srh87107 	    (void *)so, request_prim, ack_prim, min_size, (void *)mpp, wait));
9450Sstevel@tonic-gate 
9460Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
9470Sstevel@tonic-gate 
9480Sstevel@tonic-gate 	error = sowaitack(so, &mp, wait);
9490Sstevel@tonic-gate 	if (error)
9500Sstevel@tonic-gate 		return (error);
9510Sstevel@tonic-gate 
9527240Srh87107 	dprintso(so, 1, ("got msg %p\n", (void *)mp));
9530Sstevel@tonic-gate 	if (DB_TYPE(mp) != M_PCPROTO ||
9540Sstevel@tonic-gate 	    MBLKL(mp) < sizeof (tpr->type)) {
9550Sstevel@tonic-gate 		freemsg(mp);
9560Sstevel@tonic-gate 		eprintsoline(so, EPROTO);
9570Sstevel@tonic-gate 		return (EPROTO);
9580Sstevel@tonic-gate 	}
9590Sstevel@tonic-gate 	tpr = (union T_primitives *)mp->b_rptr;
9600Sstevel@tonic-gate 	/*
9610Sstevel@tonic-gate 	 * Did we get the primitive that we were asking for?
9620Sstevel@tonic-gate 	 * For T_OK_ACK we also check that it matches the request primitive.
9630Sstevel@tonic-gate 	 */
9640Sstevel@tonic-gate 	if (tpr->type == ack_prim &&
9650Sstevel@tonic-gate 	    (ack_prim != T_OK_ACK ||
9660Sstevel@tonic-gate 	    tpr->ok_ack.CORRECT_prim == request_prim)) {
9670Sstevel@tonic-gate 		if (MBLKL(mp) >= (ssize_t)min_size) {
9680Sstevel@tonic-gate 			/* Found what we are looking for */
9690Sstevel@tonic-gate 			*mpp = mp;
9700Sstevel@tonic-gate 			return (0);
9710Sstevel@tonic-gate 		}
9720Sstevel@tonic-gate 		/* Too short */
9730Sstevel@tonic-gate 		freemsg(mp);
9740Sstevel@tonic-gate 		eprintsoline(so, EPROTO);
9750Sstevel@tonic-gate 		return (EPROTO);
9760Sstevel@tonic-gate 	}
9770Sstevel@tonic-gate 
9780Sstevel@tonic-gate 	if (tpr->type == T_ERROR_ACK &&
9790Sstevel@tonic-gate 	    tpr->error_ack.ERROR_prim == request_prim) {
9800Sstevel@tonic-gate 		/* Error to the primitive we were looking for */
9810Sstevel@tonic-gate 		if (tpr->error_ack.TLI_error == TSYSERR) {
9820Sstevel@tonic-gate 			error = tpr->error_ack.UNIX_error;
9830Sstevel@tonic-gate 		} else {
9848348SEric.Yu@Sun.COM 			error = proto_tlitosyserr(tpr->error_ack.TLI_error);
9850Sstevel@tonic-gate 		}
9860Sstevel@tonic-gate 		dprintso(so, 0, ("error_ack for %d: %d/%d ->%d\n",
9878348SEric.Yu@Sun.COM 		    tpr->error_ack.ERROR_prim, tpr->error_ack.TLI_error,
9888348SEric.Yu@Sun.COM 		    tpr->error_ack.UNIX_error, error));
9890Sstevel@tonic-gate 		freemsg(mp);
9900Sstevel@tonic-gate 		return (error);
9910Sstevel@tonic-gate 	}
9920Sstevel@tonic-gate 	/*
9930Sstevel@tonic-gate 	 * Wrong primitive or T_ERROR_ACK for the wrong primitive
9940Sstevel@tonic-gate 	 */
9950Sstevel@tonic-gate #ifdef DEBUG
9960Sstevel@tonic-gate 	if (tpr->type == T_ERROR_ACK) {
9970Sstevel@tonic-gate 		dprintso(so, 0, ("error_ack for %d: %d/%d\n",
9988348SEric.Yu@Sun.COM 		    tpr->error_ack.ERROR_prim, tpr->error_ack.TLI_error,
9995753Sgww 		    tpr->error_ack.UNIX_error));
10000Sstevel@tonic-gate 	} else if (tpr->type == T_OK_ACK) {
10010Sstevel@tonic-gate 		dprintso(so, 0, ("ok_ack for %d, expected %d for %d\n",
10028348SEric.Yu@Sun.COM 		    tpr->ok_ack.CORRECT_prim, ack_prim, request_prim));
10030Sstevel@tonic-gate 	} else {
10040Sstevel@tonic-gate 		dprintso(so, 0,
10055753Sgww 		    ("unexpected primitive %d, expected %d for %d\n",
10065753Sgww 		    tpr->type, ack_prim, request_prim));
10070Sstevel@tonic-gate 	}
10080Sstevel@tonic-gate #endif /* DEBUG */
10090Sstevel@tonic-gate 
10100Sstevel@tonic-gate 	freemsg(mp);
10110Sstevel@tonic-gate 	eprintsoline(so, EPROTO);
10120Sstevel@tonic-gate 	return (EPROTO);
10130Sstevel@tonic-gate }
10140Sstevel@tonic-gate 
10150Sstevel@tonic-gate /*
10160Sstevel@tonic-gate  * Wait for a T_OK_ACK for the specified primitive.
10170Sstevel@tonic-gate  */
10180Sstevel@tonic-gate int
sowaitokack(struct sonode * so,t_scalar_t request_prim)10190Sstevel@tonic-gate sowaitokack(struct sonode *so, t_scalar_t request_prim)
10200Sstevel@tonic-gate {
10210Sstevel@tonic-gate 	mblk_t *mp;
10220Sstevel@tonic-gate 	int error;
10230Sstevel@tonic-gate 
10240Sstevel@tonic-gate 	error = sowaitprim(so, request_prim, T_OK_ACK,
10250Sstevel@tonic-gate 	    (t_uscalar_t)sizeof (struct T_ok_ack), &mp, 0);
10260Sstevel@tonic-gate 	if (error)
10270Sstevel@tonic-gate 		return (error);
10280Sstevel@tonic-gate 	freemsg(mp);
10290Sstevel@tonic-gate 	return (0);
10300Sstevel@tonic-gate }
10310Sstevel@tonic-gate 
10320Sstevel@tonic-gate /*
10338348SEric.Yu@Sun.COM  * Queue a received TPI ack message on sti_ack_mp.
10340Sstevel@tonic-gate  */
10350Sstevel@tonic-gate void
soqueueack(struct sonode * so,mblk_t * mp)10360Sstevel@tonic-gate soqueueack(struct sonode *so, mblk_t *mp)
10370Sstevel@tonic-gate {
10388348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
10398348SEric.Yu@Sun.COM 
10400Sstevel@tonic-gate 	if (DB_TYPE(mp) != M_PCPROTO) {
10411548Srshoaib 		zcmn_err(getzoneid(), CE_WARN,
10420Sstevel@tonic-gate 		    "sockfs: received unexpected M_PROTO TPI ack. Prim %d\n",
10430Sstevel@tonic-gate 		    *(t_scalar_t *)mp->b_rptr);
10440Sstevel@tonic-gate 		freemsg(mp);
10450Sstevel@tonic-gate 		return;
10460Sstevel@tonic-gate 	}
10470Sstevel@tonic-gate 
10480Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
10498348SEric.Yu@Sun.COM 	if (sti->sti_ack_mp != NULL) {
10508348SEric.Yu@Sun.COM 		dprintso(so, 1, ("sti_ack_mp already set\n"));
10518348SEric.Yu@Sun.COM 		freemsg(sti->sti_ack_mp);
10528348SEric.Yu@Sun.COM 		sti->sti_ack_mp = NULL;
10530Sstevel@tonic-gate 	}
10548348SEric.Yu@Sun.COM 	sti->sti_ack_mp = mp;
10558348SEric.Yu@Sun.COM 	cv_broadcast(&sti->sti_ack_cv);
10560Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
10570Sstevel@tonic-gate }
10580Sstevel@tonic-gate 
10590Sstevel@tonic-gate /*
10600Sstevel@tonic-gate  * Wait for a TPI ack ignoring signals and errors.
10610Sstevel@tonic-gate  */
10620Sstevel@tonic-gate int
sowaitack(struct sonode * so,mblk_t ** mpp,clock_t wait)10630Sstevel@tonic-gate sowaitack(struct sonode *so, mblk_t **mpp, clock_t wait)
10640Sstevel@tonic-gate {
10658348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
10668348SEric.Yu@Sun.COM 
10670Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
10680Sstevel@tonic-gate 
10698348SEric.Yu@Sun.COM 	while (sti->sti_ack_mp == NULL) {
10700Sstevel@tonic-gate #ifdef SOCK_TEST
10710Sstevel@tonic-gate 		if (wait == 0 && sock_test_timelimit != 0)
10720Sstevel@tonic-gate 			wait = sock_test_timelimit;
10730Sstevel@tonic-gate #endif
10740Sstevel@tonic-gate 		if (wait != 0) {
10750Sstevel@tonic-gate 			/*
10760Sstevel@tonic-gate 			 * Only wait for the time limit.
10770Sstevel@tonic-gate 			 */
107811066Srafael.vanoni@sun.com 			if (cv_reltimedwait(&sti->sti_ack_cv, &so->so_lock,
107911066Srafael.vanoni@sun.com 			    wait, TR_CLOCK_TICK) == -1) {
10800Sstevel@tonic-gate 				eprintsoline(so, ETIME);
10810Sstevel@tonic-gate 				return (ETIME);
10820Sstevel@tonic-gate 			}
10830Sstevel@tonic-gate 		}
10840Sstevel@tonic-gate 		else
10858348SEric.Yu@Sun.COM 			cv_wait(&sti->sti_ack_cv, &so->so_lock);
10860Sstevel@tonic-gate 	}
10878348SEric.Yu@Sun.COM 	*mpp = sti->sti_ack_mp;
10880Sstevel@tonic-gate #ifdef DEBUG
10890Sstevel@tonic-gate 	{
10900Sstevel@tonic-gate 		union T_primitives *tpr;
10910Sstevel@tonic-gate 		mblk_t *mp = *mpp;
10920Sstevel@tonic-gate 
10930Sstevel@tonic-gate 		tpr = (union T_primitives *)mp->b_rptr;
10940Sstevel@tonic-gate 		ASSERT(DB_TYPE(mp) == M_PCPROTO);
10950Sstevel@tonic-gate 		ASSERT(tpr->type == T_OK_ACK ||
10965753Sgww 		    tpr->type == T_ERROR_ACK ||
10975753Sgww 		    tpr->type == T_BIND_ACK ||
10985753Sgww 		    tpr->type == T_CAPABILITY_ACK ||
10995753Sgww 		    tpr->type == T_INFO_ACK ||
11005753Sgww 		    tpr->type == T_OPTMGMT_ACK);
11010Sstevel@tonic-gate 	}
11020Sstevel@tonic-gate #endif /* DEBUG */
11038348SEric.Yu@Sun.COM 	sti->sti_ack_mp = NULL;
11040Sstevel@tonic-gate 	return (0);
11050Sstevel@tonic-gate }
11060Sstevel@tonic-gate 
11070Sstevel@tonic-gate /*
11088348SEric.Yu@Sun.COM  * Queue a received T_CONN_IND message on sti_conn_ind_head/tail.
11090Sstevel@tonic-gate  */
11100Sstevel@tonic-gate void
soqueueconnind(struct sonode * so,mblk_t * mp)11110Sstevel@tonic-gate soqueueconnind(struct sonode *so, mblk_t *mp)
11120Sstevel@tonic-gate {
11138348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
11148348SEric.Yu@Sun.COM 
11150Sstevel@tonic-gate 	if (DB_TYPE(mp) != M_PROTO) {
11161548Srshoaib 		zcmn_err(getzoneid(), CE_WARN,
11170Sstevel@tonic-gate 		    "sockfs: received unexpected M_PCPROTO T_CONN_IND\n");
11180Sstevel@tonic-gate 		freemsg(mp);
11190Sstevel@tonic-gate 		return;
11200Sstevel@tonic-gate 	}
11210Sstevel@tonic-gate 
11220Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
11230Sstevel@tonic-gate 	ASSERT(mp->b_next == NULL);
11248348SEric.Yu@Sun.COM 	if (sti->sti_conn_ind_head == NULL) {
11258348SEric.Yu@Sun.COM 		sti->sti_conn_ind_head = mp;
11260Sstevel@tonic-gate 	} else {
11278348SEric.Yu@Sun.COM 		ASSERT(sti->sti_conn_ind_tail->b_next == NULL);
11288348SEric.Yu@Sun.COM 		sti->sti_conn_ind_tail->b_next = mp;
11290Sstevel@tonic-gate 	}
11308348SEric.Yu@Sun.COM 	sti->sti_conn_ind_tail = mp;
11310Sstevel@tonic-gate 	/* Wakeup a single consumer of the T_CONN_IND */
11328348SEric.Yu@Sun.COM 	cv_signal(&so->so_acceptq_cv);
11330Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
11340Sstevel@tonic-gate }
11350Sstevel@tonic-gate 
11360Sstevel@tonic-gate /*
11370Sstevel@tonic-gate  * Wait for a T_CONN_IND.
11380Sstevel@tonic-gate  * Don't wait if nonblocking.
11390Sstevel@tonic-gate  * Accept signals and socket errors.
11400Sstevel@tonic-gate  */
11410Sstevel@tonic-gate int
sowaitconnind(struct sonode * so,int fmode,mblk_t ** mpp)11420Sstevel@tonic-gate sowaitconnind(struct sonode *so, int fmode, mblk_t **mpp)
11430Sstevel@tonic-gate {
11440Sstevel@tonic-gate 	mblk_t *mp;
11458348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
11460Sstevel@tonic-gate 	int error = 0;
11470Sstevel@tonic-gate 
11480Sstevel@tonic-gate 	ASSERT(MUTEX_NOT_HELD(&so->so_lock));
11490Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
11500Sstevel@tonic-gate check_error:
11510Sstevel@tonic-gate 	if (so->so_error) {
11528348SEric.Yu@Sun.COM 		error = sogeterr(so, B_TRUE);
11530Sstevel@tonic-gate 		if (error) {
11540Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
11550Sstevel@tonic-gate 			return (error);
11560Sstevel@tonic-gate 		}
11570Sstevel@tonic-gate 	}
11580Sstevel@tonic-gate 
11598348SEric.Yu@Sun.COM 	if (sti->sti_conn_ind_head == NULL) {
11600Sstevel@tonic-gate 		if (fmode & (FNDELAY|FNONBLOCK)) {
11610Sstevel@tonic-gate 			error = EWOULDBLOCK;
11620Sstevel@tonic-gate 			goto done;
11630Sstevel@tonic-gate 		}
11648348SEric.Yu@Sun.COM 
11658348SEric.Yu@Sun.COM 		if (so->so_state & SS_CLOSING) {
11668348SEric.Yu@Sun.COM 			error = EINTR;
11678348SEric.Yu@Sun.COM 			goto done;
11688348SEric.Yu@Sun.COM 		}
11698348SEric.Yu@Sun.COM 
11708348SEric.Yu@Sun.COM 		if (!cv_wait_sig_swap(&so->so_acceptq_cv, &so->so_lock)) {
11710Sstevel@tonic-gate 			error = EINTR;
11720Sstevel@tonic-gate 			goto done;
11730Sstevel@tonic-gate 		}
11740Sstevel@tonic-gate 		goto check_error;
11750Sstevel@tonic-gate 	}
11768348SEric.Yu@Sun.COM 	mp = sti->sti_conn_ind_head;
11778348SEric.Yu@Sun.COM 	sti->sti_conn_ind_head = mp->b_next;
11780Sstevel@tonic-gate 	mp->b_next = NULL;
11798348SEric.Yu@Sun.COM 	if (sti->sti_conn_ind_head == NULL) {
11808348SEric.Yu@Sun.COM 		ASSERT(sti->sti_conn_ind_tail == mp);
11818348SEric.Yu@Sun.COM 		sti->sti_conn_ind_tail = NULL;
11820Sstevel@tonic-gate 	}
11830Sstevel@tonic-gate 	*mpp = mp;
11840Sstevel@tonic-gate done:
11850Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
11860Sstevel@tonic-gate 	return (error);
11870Sstevel@tonic-gate }
11880Sstevel@tonic-gate 
11890Sstevel@tonic-gate /*
11900Sstevel@tonic-gate  * Flush a T_CONN_IND matching the sequence number from the list.
11910Sstevel@tonic-gate  * Return zero if found; non-zero otherwise.
11920Sstevel@tonic-gate  * This is called very infrequently thus it is ok to do a linear search.
11930Sstevel@tonic-gate  */
11940Sstevel@tonic-gate int
soflushconnind(struct sonode * so,t_scalar_t seqno)11950Sstevel@tonic-gate soflushconnind(struct sonode *so, t_scalar_t seqno)
11960Sstevel@tonic-gate {
11970Sstevel@tonic-gate 	mblk_t *prevmp, *mp;
11980Sstevel@tonic-gate 	struct T_conn_ind *tci;
11998348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
12000Sstevel@tonic-gate 
12010Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
12028348SEric.Yu@Sun.COM 	for (prevmp = NULL, mp = sti->sti_conn_ind_head; mp != NULL;
12030Sstevel@tonic-gate 	    prevmp = mp, mp = mp->b_next) {
12040Sstevel@tonic-gate 		tci = (struct T_conn_ind *)mp->b_rptr;
12050Sstevel@tonic-gate 		if (tci->SEQ_number == seqno) {
12060Sstevel@tonic-gate 			dprintso(so, 1,
12075753Sgww 			    ("t_discon_ind: found T_CONN_IND %d\n", seqno));
12080Sstevel@tonic-gate 			/* Deleting last? */
12098348SEric.Yu@Sun.COM 			if (sti->sti_conn_ind_tail == mp) {
12108348SEric.Yu@Sun.COM 				sti->sti_conn_ind_tail = prevmp;
12110Sstevel@tonic-gate 			}
12120Sstevel@tonic-gate 			if (prevmp == NULL) {
12130Sstevel@tonic-gate 				/* Deleting first */
12148348SEric.Yu@Sun.COM 				sti->sti_conn_ind_head = mp->b_next;
12150Sstevel@tonic-gate 			} else {
12160Sstevel@tonic-gate 				prevmp->b_next = mp->b_next;
12170Sstevel@tonic-gate 			}
12180Sstevel@tonic-gate 			mp->b_next = NULL;
12198348SEric.Yu@Sun.COM 
12208348SEric.Yu@Sun.COM 			ASSERT((sti->sti_conn_ind_head == NULL &&
12218348SEric.Yu@Sun.COM 			    sti->sti_conn_ind_tail == NULL) ||
12228348SEric.Yu@Sun.COM 			    (sti->sti_conn_ind_head != NULL &&
12238348SEric.Yu@Sun.COM 			    sti->sti_conn_ind_tail != NULL));
12248348SEric.Yu@Sun.COM 
12250Sstevel@tonic-gate 			so->so_error = ECONNABORTED;
12260Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
1227898Skais 
12280Sstevel@tonic-gate 			freemsg(mp);
12290Sstevel@tonic-gate 			return (0);
12300Sstevel@tonic-gate 		}
12310Sstevel@tonic-gate 	}
12320Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
12330Sstevel@tonic-gate 	dprintso(so, 1,	("t_discon_ind: NOT found T_CONN_IND %d\n", seqno));
12340Sstevel@tonic-gate 	return (-1);
12350Sstevel@tonic-gate }
12360Sstevel@tonic-gate 
12370Sstevel@tonic-gate /*
12380Sstevel@tonic-gate  * Wait until the socket is connected or there is an error.
12390Sstevel@tonic-gate  * fmode should contain any nonblocking flags. nosig should be
12400Sstevel@tonic-gate  * set if the caller does not want the wait to be interrupted by a signal.
12410Sstevel@tonic-gate  */
12420Sstevel@tonic-gate int
sowaitconnected(struct sonode * so,int fmode,int nosig)12430Sstevel@tonic-gate sowaitconnected(struct sonode *so, int fmode, int nosig)
12440Sstevel@tonic-gate {
12450Sstevel@tonic-gate 	int error;
12460Sstevel@tonic-gate 
12470Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
12480Sstevel@tonic-gate 
12490Sstevel@tonic-gate 	while ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) ==
12505753Sgww 	    SS_ISCONNECTING && so->so_error == 0) {
12510Sstevel@tonic-gate 
12527240Srh87107 		dprintso(so, 1, ("waiting for SS_ISCONNECTED on %p\n",
12537240Srh87107 		    (void *)so));
12540Sstevel@tonic-gate 		if (fmode & (FNDELAY|FNONBLOCK))
12550Sstevel@tonic-gate 			return (EINPROGRESS);
12560Sstevel@tonic-gate 
12578348SEric.Yu@Sun.COM 		if (so->so_state & SS_CLOSING)
12588348SEric.Yu@Sun.COM 			return (EINTR);
12598348SEric.Yu@Sun.COM 
12600Sstevel@tonic-gate 		if (nosig)
12610Sstevel@tonic-gate 			cv_wait(&so->so_state_cv, &so->so_lock);
12620Sstevel@tonic-gate 		else if (!cv_wait_sig_swap(&so->so_state_cv, &so->so_lock)) {
12630Sstevel@tonic-gate 			/*
12640Sstevel@tonic-gate 			 * Return EINTR and let the application use
12650Sstevel@tonic-gate 			 * nonblocking techniques for detecting when
12660Sstevel@tonic-gate 			 * the connection has been established.
12670Sstevel@tonic-gate 			 */
12680Sstevel@tonic-gate 			return (EINTR);
12690Sstevel@tonic-gate 		}
12707240Srh87107 		dprintso(so, 1, ("awoken on %p\n", (void *)so));
12710Sstevel@tonic-gate 	}
12720Sstevel@tonic-gate 
12730Sstevel@tonic-gate 	if (so->so_error != 0) {
12748348SEric.Yu@Sun.COM 		error = sogeterr(so, B_TRUE);
12750Sstevel@tonic-gate 		ASSERT(error != 0);
12760Sstevel@tonic-gate 		dprintso(so, 1, ("sowaitconnected: error %d\n", error));
12770Sstevel@tonic-gate 		return (error);
12780Sstevel@tonic-gate 	}
12790Sstevel@tonic-gate 	if (!(so->so_state & SS_ISCONNECTED)) {
12800Sstevel@tonic-gate 		/*
12810Sstevel@tonic-gate 		 * Could have received a T_ORDREL_IND or a T_DISCON_IND with
12820Sstevel@tonic-gate 		 * zero errno. Or another thread could have consumed so_error
12830Sstevel@tonic-gate 		 * e.g. by calling read.
12840Sstevel@tonic-gate 		 */
12850Sstevel@tonic-gate 		error = ECONNREFUSED;
12860Sstevel@tonic-gate 		dprintso(so, 1, ("sowaitconnected: error %d\n", error));
12870Sstevel@tonic-gate 		return (error);
12880Sstevel@tonic-gate 	}
12890Sstevel@tonic-gate 	return (0);
12900Sstevel@tonic-gate }
12910Sstevel@tonic-gate 
12920Sstevel@tonic-gate 
12930Sstevel@tonic-gate /*
12940Sstevel@tonic-gate  * Handle the signal generation aspect of urgent data.
12950Sstevel@tonic-gate  */
12960Sstevel@tonic-gate static void
so_oob_sig(struct sonode * so,int extrasig,strsigset_t * signals,strpollset_t * pollwakeups)12970Sstevel@tonic-gate so_oob_sig(struct sonode *so, int extrasig,
12980Sstevel@tonic-gate     strsigset_t *signals, strpollset_t *pollwakeups)
12990Sstevel@tonic-gate {
13008348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
13018348SEric.Yu@Sun.COM 
13020Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
13030Sstevel@tonic-gate 
13040Sstevel@tonic-gate 	ASSERT(so_verify_oobstate(so));
13058348SEric.Yu@Sun.COM 	ASSERT(sti->sti_oobsigcnt >= sti->sti_oobcnt);
13068348SEric.Yu@Sun.COM 	if (sti->sti_oobsigcnt > sti->sti_oobcnt) {
13070Sstevel@tonic-gate 		/*
13080Sstevel@tonic-gate 		 * Signal has already been generated once for this
13090Sstevel@tonic-gate 		 * urgent "event". However, since TCP can receive updated
13100Sstevel@tonic-gate 		 * urgent pointers we still generate a signal.
13110Sstevel@tonic-gate 		 */
13120Sstevel@tonic-gate 		ASSERT(so->so_state & SS_OOBPEND);
13130Sstevel@tonic-gate 		if (extrasig) {
13140Sstevel@tonic-gate 			*signals |= S_RDBAND;
13150Sstevel@tonic-gate 			*pollwakeups |= POLLRDBAND;
13160Sstevel@tonic-gate 		}
13170Sstevel@tonic-gate 		return;
13180Sstevel@tonic-gate 	}
13190Sstevel@tonic-gate 
13208348SEric.Yu@Sun.COM 	sti->sti_oobsigcnt++;
13218348SEric.Yu@Sun.COM 	ASSERT(sti->sti_oobsigcnt > 0);	/* Wraparound */
13228348SEric.Yu@Sun.COM 	ASSERT(sti->sti_oobsigcnt > sti->sti_oobcnt);
13230Sstevel@tonic-gate 
13240Sstevel@tonic-gate 	/*
13250Sstevel@tonic-gate 	 * Record (for select/poll) that urgent data is pending.
13260Sstevel@tonic-gate 	 */
13270Sstevel@tonic-gate 	so->so_state |= SS_OOBPEND;
13280Sstevel@tonic-gate 	/*
13290Sstevel@tonic-gate 	 * New urgent data on the way so forget about any old
13300Sstevel@tonic-gate 	 * urgent data.
13310Sstevel@tonic-gate 	 */
13320Sstevel@tonic-gate 	so->so_state &= ~(SS_HAVEOOBDATA|SS_HADOOBDATA);
13330Sstevel@tonic-gate 	if (so->so_oobmsg != NULL) {
13340Sstevel@tonic-gate 		dprintso(so, 1, ("sock: discarding old oob\n"));
13350Sstevel@tonic-gate 		freemsg(so->so_oobmsg);
13360Sstevel@tonic-gate 		so->so_oobmsg = NULL;
13370Sstevel@tonic-gate 	}
13380Sstevel@tonic-gate 	*signals |= S_RDBAND;
13390Sstevel@tonic-gate 	*pollwakeups |= POLLRDBAND;
13400Sstevel@tonic-gate 	ASSERT(so_verify_oobstate(so));
13410Sstevel@tonic-gate }
13420Sstevel@tonic-gate 
13430Sstevel@tonic-gate /*
13440Sstevel@tonic-gate  * Handle the processing of the T_EXDATA_IND with urgent data.
13450Sstevel@tonic-gate  * Returns the T_EXDATA_IND if it should be queued on the read queue.
13460Sstevel@tonic-gate  */
13470Sstevel@tonic-gate /* ARGSUSED2 */
13480Sstevel@tonic-gate static mblk_t *
so_oob_exdata(struct sonode * so,mblk_t * mp,strsigset_t * signals,strpollset_t * pollwakeups)13490Sstevel@tonic-gate so_oob_exdata(struct sonode *so, mblk_t *mp,
13500Sstevel@tonic-gate 	strsigset_t *signals, strpollset_t *pollwakeups)
13510Sstevel@tonic-gate {
13528348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
13538348SEric.Yu@Sun.COM 
13540Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
13550Sstevel@tonic-gate 
13560Sstevel@tonic-gate 	ASSERT(so_verify_oobstate(so));
13570Sstevel@tonic-gate 
13588348SEric.Yu@Sun.COM 	ASSERT(sti->sti_oobsigcnt > sti->sti_oobcnt);
13590Sstevel@tonic-gate 
13608348SEric.Yu@Sun.COM 	sti->sti_oobcnt++;
13618348SEric.Yu@Sun.COM 	ASSERT(sti->sti_oobcnt > 0);	/* wraparound? */
13628348SEric.Yu@Sun.COM 	ASSERT(sti->sti_oobsigcnt >= sti->sti_oobcnt);
13630Sstevel@tonic-gate 
13640Sstevel@tonic-gate 	/*
13650Sstevel@tonic-gate 	 * Set MSGMARK for SIOCATMARK.
13660Sstevel@tonic-gate 	 */
13670Sstevel@tonic-gate 	mp->b_flag |= MSGMARK;
13680Sstevel@tonic-gate 
13690Sstevel@tonic-gate 	ASSERT(so_verify_oobstate(so));
13700Sstevel@tonic-gate 	return (mp);
13710Sstevel@tonic-gate }
13720Sstevel@tonic-gate 
13730Sstevel@tonic-gate /*
13740Sstevel@tonic-gate  * Handle the processing of the actual urgent data.
13750Sstevel@tonic-gate  * Returns the data mblk if it should be queued on the read queue.
13760Sstevel@tonic-gate  */
13770Sstevel@tonic-gate static mblk_t *
so_oob_data(struct sonode * so,mblk_t * mp,strsigset_t * signals,strpollset_t * pollwakeups)13780Sstevel@tonic-gate so_oob_data(struct sonode *so, mblk_t *mp,
13790Sstevel@tonic-gate 	strsigset_t *signals, strpollset_t *pollwakeups)
13800Sstevel@tonic-gate {
13818348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
13828348SEric.Yu@Sun.COM 
13830Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
13840Sstevel@tonic-gate 
13850Sstevel@tonic-gate 	ASSERT(so_verify_oobstate(so));
13860Sstevel@tonic-gate 
13878348SEric.Yu@Sun.COM 	ASSERT(sti->sti_oobsigcnt >= sti->sti_oobcnt);
13880Sstevel@tonic-gate 	ASSERT(mp != NULL);
13890Sstevel@tonic-gate 	/*
13900Sstevel@tonic-gate 	 * For OOBINLINE we keep the data in the T_EXDATA_IND.
13910Sstevel@tonic-gate 	 * Otherwise we store it in so_oobmsg.
13920Sstevel@tonic-gate 	 */
13930Sstevel@tonic-gate 	ASSERT(so->so_oobmsg == NULL);
13940Sstevel@tonic-gate 	if (so->so_options & SO_OOBINLINE) {
13950Sstevel@tonic-gate 		*pollwakeups |= POLLIN | POLLRDNORM | POLLRDBAND;
13960Sstevel@tonic-gate 		*signals |= S_INPUT | S_RDNORM;
13970Sstevel@tonic-gate 	} else {
13980Sstevel@tonic-gate 		*pollwakeups |= POLLRDBAND;
13990Sstevel@tonic-gate 		so->so_state |= SS_HAVEOOBDATA;
14000Sstevel@tonic-gate 		so->so_oobmsg = mp;
14010Sstevel@tonic-gate 		mp = NULL;
14020Sstevel@tonic-gate 	}
14030Sstevel@tonic-gate 	ASSERT(so_verify_oobstate(so));
14040Sstevel@tonic-gate 	return (mp);
14050Sstevel@tonic-gate }
14060Sstevel@tonic-gate 
14070Sstevel@tonic-gate /*
14080Sstevel@tonic-gate  * Caller must hold the mutex.
14090Sstevel@tonic-gate  * For delayed processing, save the T_DISCON_IND received
14108348SEric.Yu@Sun.COM  * from below on sti_discon_ind_mp.
14110Sstevel@tonic-gate  * When the message is processed the framework will call:
14120Sstevel@tonic-gate  *      (*func)(so, mp);
14130Sstevel@tonic-gate  */
14140Sstevel@tonic-gate static void
so_save_discon_ind(struct sonode * so,mblk_t * mp,void (* func)(struct sonode * so,mblk_t *))14150Sstevel@tonic-gate so_save_discon_ind(struct sonode *so,
14160Sstevel@tonic-gate 	mblk_t *mp,
14170Sstevel@tonic-gate 	void (*func)(struct sonode *so, mblk_t *))
14180Sstevel@tonic-gate {
14198348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
14208348SEric.Yu@Sun.COM 
14210Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
14220Sstevel@tonic-gate 
14230Sstevel@tonic-gate 	/*
14240Sstevel@tonic-gate 	 * Discard new T_DISCON_IND if we have already received another.
14258348SEric.Yu@Sun.COM 	 * Currently the earlier message can either be on sti_discon_ind_mp
14260Sstevel@tonic-gate 	 * or being processed.
14270Sstevel@tonic-gate 	 */
14288348SEric.Yu@Sun.COM 	if (sti->sti_discon_ind_mp != NULL || (so->so_flag & SOASYNC_UNBIND)) {
14291548Srshoaib 		zcmn_err(getzoneid(), CE_WARN,
14300Sstevel@tonic-gate 		    "sockfs: received unexpected additional T_DISCON_IND\n");
14310Sstevel@tonic-gate 		freemsg(mp);
14320Sstevel@tonic-gate 		return;
14330Sstevel@tonic-gate 	}
14340Sstevel@tonic-gate 	mp->b_prev = (mblk_t *)func;
14350Sstevel@tonic-gate 	mp->b_next = NULL;
14368348SEric.Yu@Sun.COM 	sti->sti_discon_ind_mp = mp;
14370Sstevel@tonic-gate }
14380Sstevel@tonic-gate 
14390Sstevel@tonic-gate /*
14400Sstevel@tonic-gate  * Caller must hold the mutex and make sure that either SOLOCKED
14410Sstevel@tonic-gate  * or SOASYNC_UNBIND is set. Called from so_unlock_single().
14428348SEric.Yu@Sun.COM  * Perform delayed processing of T_DISCON_IND message on sti_discon_ind_mp.
14430Sstevel@tonic-gate  * Need to ensure that strsock_proto() will not end up sleeping for
14440Sstevel@tonic-gate  * SOASYNC_UNBIND, while executing this function.
14450Sstevel@tonic-gate  */
14460Sstevel@tonic-gate void
so_drain_discon_ind(struct sonode * so)14470Sstevel@tonic-gate so_drain_discon_ind(struct sonode *so)
14480Sstevel@tonic-gate {
14490Sstevel@tonic-gate 	mblk_t	*bp;
14500Sstevel@tonic-gate 	void (*func)(struct sonode *so, mblk_t *);
14518348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
14520Sstevel@tonic-gate 
14530Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
14540Sstevel@tonic-gate 	ASSERT(so->so_flag & (SOLOCKED|SOASYNC_UNBIND));
14550Sstevel@tonic-gate 
14568348SEric.Yu@Sun.COM 	/* Process T_DISCON_IND on sti_discon_ind_mp */
14578348SEric.Yu@Sun.COM 	if ((bp = sti->sti_discon_ind_mp) != NULL) {
14588348SEric.Yu@Sun.COM 		sti->sti_discon_ind_mp = NULL;
14590Sstevel@tonic-gate 		func = (void (*)())bp->b_prev;
14600Sstevel@tonic-gate 		bp->b_prev = NULL;
14610Sstevel@tonic-gate 
14620Sstevel@tonic-gate 		/*
14630Sstevel@tonic-gate 		 * This (*func) is supposed to generate a message downstream
14640Sstevel@tonic-gate 		 * and we need to have a flag set until the corresponding
14650Sstevel@tonic-gate 		 * upstream message reaches stream head.
14660Sstevel@tonic-gate 		 * When processing T_DISCON_IND in strsock_discon_ind
14670Sstevel@tonic-gate 		 * we hold SOASYN_UNBIND when sending T_UNBIND_REQ down and
14680Sstevel@tonic-gate 		 * drop the flag after we get the ACK in strsock_proto.
14690Sstevel@tonic-gate 		 */
14700Sstevel@tonic-gate 		(void) (*func)(so, bp);
14710Sstevel@tonic-gate 	}
14720Sstevel@tonic-gate }
14730Sstevel@tonic-gate 
14740Sstevel@tonic-gate /*
14750Sstevel@tonic-gate  * Caller must hold the mutex.
14768348SEric.Yu@Sun.COM  * Remove the T_DISCON_IND on sti_discon_ind_mp.
14770Sstevel@tonic-gate  */
14780Sstevel@tonic-gate void
so_flush_discon_ind(struct sonode * so)14790Sstevel@tonic-gate so_flush_discon_ind(struct sonode *so)
14800Sstevel@tonic-gate {
14810Sstevel@tonic-gate 	mblk_t	*bp;
14828348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
14830Sstevel@tonic-gate 
14840Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
14850Sstevel@tonic-gate 
14860Sstevel@tonic-gate 	/*
14878348SEric.Yu@Sun.COM 	 * Remove T_DISCON_IND mblk at sti_discon_ind_mp.
14880Sstevel@tonic-gate 	 */
14898348SEric.Yu@Sun.COM 	if ((bp = sti->sti_discon_ind_mp) != NULL) {
14908348SEric.Yu@Sun.COM 		sti->sti_discon_ind_mp = NULL;
14910Sstevel@tonic-gate 		bp->b_prev = NULL;
14920Sstevel@tonic-gate 		freemsg(bp);
14930Sstevel@tonic-gate 	}
14940Sstevel@tonic-gate }
14950Sstevel@tonic-gate 
14960Sstevel@tonic-gate /*
14970Sstevel@tonic-gate  * Caller must hold the mutex.
14980Sstevel@tonic-gate  *
14990Sstevel@tonic-gate  * This function is used to process the T_DISCON_IND message. It does
15000Sstevel@tonic-gate  * immediate processing when called from strsock_proto and delayed
15018348SEric.Yu@Sun.COM  * processing of discon_ind saved on sti_discon_ind_mp when called from
15020Sstevel@tonic-gate  * so_drain_discon_ind. When a T_DISCON_IND message is saved in
15038348SEric.Yu@Sun.COM  * sti_discon_ind_mp for delayed processing, this function is registered
15040Sstevel@tonic-gate  * as the callback function to process the message.
15050Sstevel@tonic-gate  *
15060Sstevel@tonic-gate  * SOASYNC_UNBIND should be held in this function, during the non-blocking
15070Sstevel@tonic-gate  * unbind operation, and should be released only after we receive the ACK
15080Sstevel@tonic-gate  * in strsock_proto, for the T_UNBIND_REQ sent here. Since SOLOCKED is not set,
15090Sstevel@tonic-gate  * no TPI messages would be sent down at this time. This is to prevent M_FLUSH
15100Sstevel@tonic-gate  * sent from either this function or tcp_unbind(), flushing away any TPI
15110Sstevel@tonic-gate  * message that is being sent down and stays in a lower module's queue.
15120Sstevel@tonic-gate  *
15130Sstevel@tonic-gate  * This function drops so_lock and grabs it again.
15140Sstevel@tonic-gate  */
15150Sstevel@tonic-gate static void
strsock_discon_ind(struct sonode * so,mblk_t * discon_mp)15160Sstevel@tonic-gate strsock_discon_ind(struct sonode *so, mblk_t *discon_mp)
15170Sstevel@tonic-gate {
15180Sstevel@tonic-gate 	struct vnode *vp;
15190Sstevel@tonic-gate 	struct stdata *stp;
15200Sstevel@tonic-gate 	union T_primitives *tpr;
15210Sstevel@tonic-gate 	struct T_unbind_req *ubr;
15220Sstevel@tonic-gate 	mblk_t *mp;
15230Sstevel@tonic-gate 	int error;
15248348SEric.Yu@Sun.COM 	sotpi_info_t *sti = SOTOTPI(so);
15250Sstevel@tonic-gate 
15260Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&so->so_lock));
15270Sstevel@tonic-gate 	ASSERT(discon_mp);
15280Sstevel@tonic-gate 	ASSERT(discon_mp->b_rptr);
15290Sstevel@tonic-gate 
15300Sstevel@tonic-gate 	tpr = (union T_primitives *)discon_mp->b_rptr;
15310Sstevel@tonic-gate 	ASSERT(tpr->type == T_DISCON_IND);
15320Sstevel@tonic-gate 
15330Sstevel@tonic-gate 	vp = SOTOV(so);
15340Sstevel@tonic-gate 	stp = vp->v_stream;
15350Sstevel@tonic-gate 	ASSERT(stp);
15360Sstevel@tonic-gate 
15370Sstevel@tonic-gate 	/*
15380Sstevel@tonic-gate 	 * Not a listener
15390Sstevel@tonic-gate 	 */
15400Sstevel@tonic-gate 	ASSERT((so->so_state & SS_ACCEPTCONN) == 0);
15410Sstevel@tonic-gate 
15420Sstevel@tonic-gate 	/*
15430Sstevel@tonic-gate 	 * This assumes that the name space for DISCON_reason
15440Sstevel@tonic-gate 	 * is the errno name space.
15450Sstevel@tonic-gate 	 */
15460Sstevel@tonic-gate 	soisdisconnected(so, tpr->discon_ind.DISCON_reason);
15478348SEric.Yu@Sun.COM 	sti->sti_laddr_valid = 0;
15488348SEric.Yu@Sun.COM 	sti->sti_faddr_valid = 0;
15490Sstevel@tonic-gate 
15500Sstevel@tonic-gate 	/*
15510Sstevel@tonic-gate 	 * Unbind with the transport without blocking.
15520Sstevel@tonic-gate 	 * If we've already received a T_DISCON_IND do not unbind.
15530Sstevel@tonic-gate 	 *
15540Sstevel@tonic-gate 	 * If there is no preallocated unbind message, we have already
15550Sstevel@tonic-gate 	 * unbound with the transport
15560Sstevel@tonic-gate 	 *
15570Sstevel@tonic-gate 	 * If the socket is not bound, no need to unbind.
15580Sstevel@tonic-gate 	 */
15598348SEric.Yu@Sun.COM 	mp = sti->sti_unbind_mp;
15600Sstevel@tonic-gate 	if (mp == NULL) {
15610Sstevel@tonic-gate 		ASSERT(!(so->so_state & SS_ISBOUND));
15620Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
15630Sstevel@tonic-gate 	} else if (!(so->so_state & SS_ISBOUND))  {
15640Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
15650Sstevel@tonic-gate 	} else {
15668348SEric.Yu@Sun.COM 		sti->sti_unbind_mp = NULL;
15670Sstevel@tonic-gate 
15680Sstevel@tonic-gate 		/*
15690Sstevel@tonic-gate 		 * Is another T_DISCON_IND being processed.
15700Sstevel@tonic-gate 		 */
15710Sstevel@tonic-gate 		ASSERT((so->so_flag & SOASYNC_UNBIND) == 0);
15720Sstevel@tonic-gate 
15730Sstevel@tonic-gate 		/*
15740Sstevel@tonic-gate 		 * Make strsock_proto ignore T_OK_ACK and T_ERROR_ACK for
15750Sstevel@tonic-gate 		 * this unbind. Set SOASYNC_UNBIND. This should be cleared
15760Sstevel@tonic-gate 		 * only after we receive the ACK in strsock_proto.
15770Sstevel@tonic-gate 		 */
15780Sstevel@tonic-gate 		so->so_flag |= SOASYNC_UNBIND;
15790Sstevel@tonic-gate 		ASSERT(!(so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)));
15808348SEric.Yu@Sun.COM 		so->so_state &= ~(SS_ISBOUND|SS_ACCEPTCONN);
15818348SEric.Yu@Sun.COM 		sti->sti_laddr_valid = 0;
15820Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
15830Sstevel@tonic-gate 
15840Sstevel@tonic-gate 		/*
15850Sstevel@tonic-gate 		 * Send down T_UNBIND_REQ ignoring flow control.
15860Sstevel@tonic-gate 		 * XXX Assumes that MSG_IGNFLOW implies that this thread
15870Sstevel@tonic-gate 		 * does not run service procedures.
15880Sstevel@tonic-gate 		 */
15890Sstevel@tonic-gate 		ASSERT(DB_TYPE(mp) == M_PROTO);
15900Sstevel@tonic-gate 		ubr = (struct T_unbind_req *)mp->b_rptr;
15910Sstevel@tonic-gate 		mp->b_wptr += sizeof (*ubr);
15920Sstevel@tonic-gate 		ubr->PRIM_type = T_UNBIND_REQ;
15930Sstevel@tonic-gate 
15940Sstevel@tonic-gate 		/*
15950Sstevel@tonic-gate 		 * Flush the read and write side (except stream head read queue)
15960Sstevel@tonic-gate 		 * and send down T_UNBIND_REQ.
15970Sstevel@tonic-gate 		 */
15980Sstevel@tonic-gate 		(void) putnextctl1(strvp2wq(SOTOV(so)), M_FLUSH, FLUSHRW);
15990Sstevel@tonic-gate 		error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
16005753Sgww 		    MSG_BAND|MSG_HOLDSIG|MSG_IGNERROR|MSG_IGNFLOW, 0);
16010Sstevel@tonic-gate 		/* LINTED - warning: statement has no consequent: if */
16020Sstevel@tonic-gate 		if (error) {
16030Sstevel@tonic-gate 			eprintsoline(so, error);
16040Sstevel@tonic-gate 		}
16050Sstevel@tonic-gate 	}
16060Sstevel@tonic-gate 
16070Sstevel@tonic-gate 	if (tpr->discon_ind.DISCON_reason != 0)
16080Sstevel@tonic-gate 		strsetrerror(SOTOV(so), 0, 0, sogetrderr);
16090Sstevel@tonic-gate 	strsetwerror(SOTOV(so), 0, 0, sogetwrerr);
16100Sstevel@tonic-gate 	strseteof(SOTOV(so), 1);
16110Sstevel@tonic-gate 	/*
16120Sstevel@tonic-gate 	 * strseteof takes care of read side wakeups,
16130Sstevel@tonic-gate 	 * pollwakeups, and signals.
16140Sstevel@tonic-gate 	 */
16150Sstevel@tonic-gate 	dprintso(so, 1, ("T_DISCON_IND: error %d\n", so->so_error));
16160Sstevel@tonic-gate 	freemsg(discon_mp);
16170Sstevel@tonic-gate 
16180Sstevel@tonic-gate 
16190Sstevel@tonic-gate 	pollwakeup(&stp->sd_pollist, POLLOUT);
16200Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
16210Sstevel@tonic-gate 
16220Sstevel@tonic-gate 	/*
16230Sstevel@tonic-gate 	 * Wake sleeping write
16240Sstevel@tonic-gate 	 */
16250Sstevel@tonic-gate 	if (stp->sd_flag & WSLEEP) {
16260Sstevel@tonic-gate 		stp->sd_flag &= ~WSLEEP;
16270Sstevel@tonic-gate 		cv_broadcast(&stp->sd_wrq->q_wait);
16280Sstevel@tonic-gate 	}
16290Sstevel@tonic-gate 
16300Sstevel@tonic-gate 	/*
16310Sstevel@tonic-gate 	 * strsendsig can handle multiple signals with a
16320Sstevel@tonic-gate 	 * single call.  Send SIGPOLL for S_OUTPUT event.
16330Sstevel@tonic-gate 	 */
16340Sstevel@tonic-gate 	if (stp->sd_sigflags & S_OUTPUT)
16350Sstevel@tonic-gate 		strsendsig(stp->sd_siglist, S_OUTPUT, 0, 0);
16360Sstevel@tonic-gate 
16370Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
16380Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
16390Sstevel@tonic-gate }
16400Sstevel@tonic-gate 
16410Sstevel@tonic-gate /*
16420Sstevel@tonic-gate  * This routine is registered with the stream head to receive M_PROTO
16430Sstevel@tonic-gate  * and M_PCPROTO messages.
16440Sstevel@tonic-gate  *
16450Sstevel@tonic-gate  * Returns NULL if the message was consumed.
16460Sstevel@tonic-gate  * Returns an mblk to make that mblk be processed (and queued) by the stream
16470Sstevel@tonic-gate  * head.
16480Sstevel@tonic-gate  *
16490Sstevel@tonic-gate  * Sets the return parameters (*wakeups, *firstmsgsigs, *allmsgsigs, and
16500Sstevel@tonic-gate  * *pollwakeups) for the stream head to take action on. Note that since
16510Sstevel@tonic-gate  * sockets always deliver SIGIO for every new piece of data this routine
16520Sstevel@tonic-gate  * never sets *firstmsgsigs; any signals are returned in *allmsgsigs.
16530Sstevel@tonic-gate  *
16540Sstevel@tonic-gate  * This routine handles all data related TPI messages independent of
16550Sstevel@tonic-gate  * the type of the socket i.e. it doesn't care if T_UNITDATA_IND message
16560Sstevel@tonic-gate  * arrive on a SOCK_STREAM.
16570Sstevel@tonic-gate  */
16580Sstevel@tonic-gate static mblk_t *
strsock_proto(vnode_t * vp,mblk_t * mp,strwakeup_t * wakeups,strsigset_t * firstmsgsigs,strsigset_t * allmsgsigs,strpollset_t * pollwakeups)16590Sstevel@tonic-gate strsock_proto(vnode_t *vp, mblk_t *mp,
16600Sstevel@tonic-gate 		strwakeup_t *wakeups, strsigset_t *firstmsgsigs,
16610Sstevel@tonic-gate 		strsigset_t *allmsgsigs, strpollset_t *pollwakeups)
16620Sstevel@tonic-gate {
16630Sstevel@tonic-gate 	union T_primitives *tpr;
16640Sstevel@tonic-gate 	struct sonode *so;
16658348SEric.Yu@Sun.COM 	sotpi_info_t *sti;
166611861SMarek.Pospisil@Sun.COM 	uint32_t auditing = AU_AUDITING();
16670Sstevel@tonic-gate 
16680Sstevel@tonic-gate 	so = VTOSO(vp);
16698348SEric.Yu@Sun.COM 	sti = SOTOTPI(so);
16700Sstevel@tonic-gate 
16717240Srh87107 	dprintso(so, 1, ("strsock_proto(%p, %p)\n", (void *)vp, (void *)mp));
16720Sstevel@tonic-gate 
16730Sstevel@tonic-gate 	/* Set default return values */
16740Sstevel@tonic-gate 	*firstmsgsigs = *wakeups = *allmsgsigs = *pollwakeups = 0;
16750Sstevel@tonic-gate 
16760Sstevel@tonic-gate 	ASSERT(DB_TYPE(mp) == M_PROTO ||
16770Sstevel@tonic-gate 	    DB_TYPE(mp) == M_PCPROTO);
16780Sstevel@tonic-gate 
16790Sstevel@tonic-gate 	if (MBLKL(mp) < sizeof (tpr->type)) {
16800Sstevel@tonic-gate 		/* The message is too short to even contain the primitive */
16811548Srshoaib 		zcmn_err(getzoneid(), CE_WARN,
16820Sstevel@tonic-gate 		    "sockfs: Too short TPI message received. Len = %ld\n",
16830Sstevel@tonic-gate 		    (ptrdiff_t)(MBLKL(mp)));
16840Sstevel@tonic-gate 		freemsg(mp);
16850Sstevel@tonic-gate 		return (NULL);
16860Sstevel@tonic-gate 	}
16870Sstevel@tonic-gate 	if (!__TPI_PRIM_ISALIGNED(mp->b_rptr)) {
16880Sstevel@tonic-gate 		/* The read pointer is not aligned correctly for TPI */
16891548Srshoaib 		zcmn_err(getzoneid(), CE_WARN,
16900Sstevel@tonic-gate 		    "sockfs: Unaligned TPI message received. rptr = %p\n",
16910Sstevel@tonic-gate 		    (void *)mp->b_rptr);
16920Sstevel@tonic-gate 		freemsg(mp);
16930Sstevel@tonic-gate 		return (NULL);
16940Sstevel@tonic-gate 	}
16950Sstevel@tonic-gate 	tpr = (union T_primitives *)mp->b_rptr;
16960Sstevel@tonic-gate 	dprintso(so, 1, ("strsock_proto: primitive %d\n", tpr->type));
16970Sstevel@tonic-gate 
16980Sstevel@tonic-gate 	switch (tpr->type) {
16990Sstevel@tonic-gate 
17000Sstevel@tonic-gate 	case T_DATA_IND:
17010Sstevel@tonic-gate 		if (MBLKL(mp) < sizeof (struct T_data_ind)) {
17021548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
17030Sstevel@tonic-gate 			    "sockfs: Too short T_DATA_IND. Len = %ld\n",
17040Sstevel@tonic-gate 			    (ptrdiff_t)(MBLKL(mp)));
17050Sstevel@tonic-gate 			freemsg(mp);
17060Sstevel@tonic-gate 			return (NULL);
17070Sstevel@tonic-gate 		}
17080Sstevel@tonic-gate 		/*
17090Sstevel@tonic-gate 		 * Ignore zero-length T_DATA_IND messages. These might be
17100Sstevel@tonic-gate 		 * generated by some transports.
17110Sstevel@tonic-gate 		 * This is needed to prevent read (which skips the M_PROTO
17120Sstevel@tonic-gate 		 * part) to unexpectedly return 0 (or return EWOULDBLOCK
17130Sstevel@tonic-gate 		 * on a non-blocking socket after select/poll has indicated
17140Sstevel@tonic-gate 		 * that data is available).
17150Sstevel@tonic-gate 		 */
17160Sstevel@tonic-gate 		if (msgdsize(mp->b_cont) == 0) {
17170Sstevel@tonic-gate 			dprintso(so, 0,
17180Sstevel@tonic-gate 			    ("strsock_proto: zero length T_DATA_IND\n"));
17190Sstevel@tonic-gate 			freemsg(mp);
17200Sstevel@tonic-gate 			return (NULL);
17210Sstevel@tonic-gate 		}
17220Sstevel@tonic-gate 		*allmsgsigs = S_INPUT | S_RDNORM;
17230Sstevel@tonic-gate 		*pollwakeups = POLLIN | POLLRDNORM;
17240Sstevel@tonic-gate 		*wakeups = RSLEEP;
17250Sstevel@tonic-gate 		return (mp);
17260Sstevel@tonic-gate 
17270Sstevel@tonic-gate 	case T_UNITDATA_IND: {
17280Sstevel@tonic-gate 		struct T_unitdata_ind	*tudi = &tpr->unitdata_ind;
17290Sstevel@tonic-gate 		void			*addr;
17300Sstevel@tonic-gate 		t_uscalar_t		addrlen;
17310Sstevel@tonic-gate 
17320Sstevel@tonic-gate 		if (MBLKL(mp) < sizeof (struct T_unitdata_ind)) {
17331548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
17340Sstevel@tonic-gate 			    "sockfs: Too short T_UNITDATA_IND. Len = %ld\n",
17350Sstevel@tonic-gate 			    (ptrdiff_t)(MBLKL(mp)));
17360Sstevel@tonic-gate 			freemsg(mp);
17370Sstevel@tonic-gate 			return (NULL);
17380Sstevel@tonic-gate 		}
17390Sstevel@tonic-gate 
17400Sstevel@tonic-gate 		/* Is this is not a connected datagram socket? */
17410Sstevel@tonic-gate 		if ((so->so_mode & SM_CONNREQUIRED) ||
17420Sstevel@tonic-gate 		    !(so->so_state & SS_ISCONNECTED)) {
17430Sstevel@tonic-gate 			/*
17440Sstevel@tonic-gate 			 * Not a connected datagram socket. Look for
17450Sstevel@tonic-gate 			 * the SO_UNIX_CLOSE option. If such an option is found
17460Sstevel@tonic-gate 			 * discard the message (since it has no meaning
17470Sstevel@tonic-gate 			 * unless connected).
17480Sstevel@tonic-gate 			 */
17490Sstevel@tonic-gate 			if (so->so_family == AF_UNIX && msgdsize(mp) == 0 &&
17500Sstevel@tonic-gate 			    tudi->OPT_length != 0) {
17510Sstevel@tonic-gate 				void *opt;
17520Sstevel@tonic-gate 				t_uscalar_t optlen = tudi->OPT_length;
17530Sstevel@tonic-gate 
17540Sstevel@tonic-gate 				opt = sogetoff(mp, tudi->OPT_offset,
17555753Sgww 				    optlen, __TPI_ALIGN_SIZE);
17560Sstevel@tonic-gate 				if (opt == NULL) {
17570Sstevel@tonic-gate 					/* The len/off falls outside mp */
17580Sstevel@tonic-gate 					freemsg(mp);
17590Sstevel@tonic-gate 					mutex_enter(&so->so_lock);
17600Sstevel@tonic-gate 					soseterror(so, EPROTO);
17610Sstevel@tonic-gate 					mutex_exit(&so->so_lock);
17621548Srshoaib 					zcmn_err(getzoneid(), CE_WARN,
17630Sstevel@tonic-gate 					    "sockfs: T_unidata_ind with "
17640Sstevel@tonic-gate 					    "invalid optlen/offset %u/%d\n",
17650Sstevel@tonic-gate 					    optlen, tudi->OPT_offset);
17660Sstevel@tonic-gate 					return (NULL);
17670Sstevel@tonic-gate 				}
17680Sstevel@tonic-gate 				if (so_getopt_unix_close(opt, optlen)) {
17690Sstevel@tonic-gate 					freemsg(mp);
17700Sstevel@tonic-gate 					return (NULL);
17710Sstevel@tonic-gate 				}
17720Sstevel@tonic-gate 			}
17730Sstevel@tonic-gate 			*allmsgsigs = S_INPUT | S_RDNORM;
17740Sstevel@tonic-gate 			*pollwakeups = POLLIN | POLLRDNORM;
17750Sstevel@tonic-gate 			*wakeups = RSLEEP;
177611861SMarek.Pospisil@Sun.COM 			if (auditing)
17770Sstevel@tonic-gate 				audit_sock(T_UNITDATA_IND, strvp2wq(vp),
17785753Sgww 				    mp, 0);
17790Sstevel@tonic-gate 			return (mp);
17800Sstevel@tonic-gate 		}
17810Sstevel@tonic-gate 
17820Sstevel@tonic-gate 		/*
17830Sstevel@tonic-gate 		 * A connect datagram socket. For AF_INET{,6} we verify that
17840Sstevel@tonic-gate 		 * the source address matches the "connected to" address.
17850Sstevel@tonic-gate 		 * The semantics of AF_UNIX sockets is to not verify
17860Sstevel@tonic-gate 		 * the source address.
17870Sstevel@tonic-gate 		 * Note that this source address verification is transport
17880Sstevel@tonic-gate 		 * specific. Thus the real fix would be to extent TPI
17890Sstevel@tonic-gate 		 * to allow T_CONN_REQ messages to be send to connectionless
17900Sstevel@tonic-gate 		 * transport providers and always let the transport provider
17910Sstevel@tonic-gate 		 * do whatever filtering is needed.
17920Sstevel@tonic-gate 		 *
17930Sstevel@tonic-gate 		 * The verification/filtering semantics for transports
17940Sstevel@tonic-gate 		 * other than AF_INET and AF_UNIX are unknown. The choice
17950Sstevel@tonic-gate 		 * would be to either filter using bcmp or let all messages
17960Sstevel@tonic-gate 		 * get through. This code does not filter other address
17970Sstevel@tonic-gate 		 * families since this at least allows the application to
17980Sstevel@tonic-gate 		 * work around any missing filtering.
17990Sstevel@tonic-gate 		 *
18000Sstevel@tonic-gate 		 * XXX Should we move filtering to UDP/ICMP???
18010Sstevel@tonic-gate 		 * That would require passing e.g. a T_DISCON_REQ to UDP
18020Sstevel@tonic-gate 		 * when the socket becomes unconnected.
18030Sstevel@tonic-gate 		 */
18040Sstevel@tonic-gate 		addrlen = tudi->SRC_length;
18050Sstevel@tonic-gate 		/*
18060Sstevel@tonic-gate 		 * The alignment restriction is really to strict but
18070Sstevel@tonic-gate 		 * we want enough alignment to inspect the fields of
18080Sstevel@tonic-gate 		 * a sockaddr_in.
18090Sstevel@tonic-gate 		 */
18100Sstevel@tonic-gate 		addr = sogetoff(mp, tudi->SRC_offset, addrlen,
18115753Sgww 		    __TPI_ALIGN_SIZE);
18120Sstevel@tonic-gate 		if (addr == NULL) {
18130Sstevel@tonic-gate 			freemsg(mp);
18140Sstevel@tonic-gate 			mutex_enter(&so->so_lock);
18150Sstevel@tonic-gate 			soseterror(so, EPROTO);
18160Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
18171548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
18180Sstevel@tonic-gate 			    "sockfs: T_unidata_ind with invalid "
18190Sstevel@tonic-gate 			    "addrlen/offset %u/%d\n",
18200Sstevel@tonic-gate 			    addrlen, tudi->SRC_offset);
18210Sstevel@tonic-gate 			return (NULL);
18220Sstevel@tonic-gate 		}
18230Sstevel@tonic-gate 
18240Sstevel@tonic-gate 		if (so->so_family == AF_INET) {
18250Sstevel@tonic-gate 			/*
18260Sstevel@tonic-gate 			 * For AF_INET we allow wildcarding both sin_addr
18270Sstevel@tonic-gate 			 * and sin_port.
18280Sstevel@tonic-gate 			 */
18290Sstevel@tonic-gate 			struct sockaddr_in *faddr, *sin;
18300Sstevel@tonic-gate 
18318348SEric.Yu@Sun.COM 			/* Prevent sti_faddr_sa from changing while accessed */
18320Sstevel@tonic-gate 			mutex_enter(&so->so_lock);
18338348SEric.Yu@Sun.COM 			ASSERT(sti->sti_faddr_len ==
18345753Sgww 			    (socklen_t)sizeof (struct sockaddr_in));
18358348SEric.Yu@Sun.COM 			faddr = (struct sockaddr_in *)sti->sti_faddr_sa;
18360Sstevel@tonic-gate 			sin = (struct sockaddr_in *)addr;
18370Sstevel@tonic-gate 			if (addrlen !=
18385753Sgww 			    (t_uscalar_t)sizeof (struct sockaddr_in) ||
18390Sstevel@tonic-gate 			    (sin->sin_addr.s_addr != faddr->sin_addr.s_addr &&
18400Sstevel@tonic-gate 			    faddr->sin_addr.s_addr != INADDR_ANY) ||
18410Sstevel@tonic-gate 			    (so->so_type != SOCK_RAW &&
18420Sstevel@tonic-gate 			    sin->sin_port != faddr->sin_port &&
18430Sstevel@tonic-gate 			    faddr->sin_port != 0)) {
18440Sstevel@tonic-gate #ifdef DEBUG
18450Sstevel@tonic-gate 				dprintso(so, 0,
18465753Sgww 				    ("sockfs: T_UNITDATA_IND mismatch: %s",
18475753Sgww 				    pr_addr(so->so_family,
18488348SEric.Yu@Sun.COM 				    (struct sockaddr *)addr, addrlen)));
18490Sstevel@tonic-gate 				dprintso(so, 0, (" - %s\n",
18508348SEric.Yu@Sun.COM 				    pr_addr(so->so_family, sti->sti_faddr_sa,
18518348SEric.Yu@Sun.COM 				    (t_uscalar_t)sti->sti_faddr_len)));
18520Sstevel@tonic-gate #endif /* DEBUG */
18530Sstevel@tonic-gate 				mutex_exit(&so->so_lock);
18540Sstevel@tonic-gate 				freemsg(mp);
18550Sstevel@tonic-gate 				return (NULL);
18560Sstevel@tonic-gate 			}
18570Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
18580Sstevel@tonic-gate 		} else if (so->so_family == AF_INET6) {
18590Sstevel@tonic-gate 			/*
18600Sstevel@tonic-gate 			 * For AF_INET6 we allow wildcarding both sin6_addr
18610Sstevel@tonic-gate 			 * and sin6_port.
18620Sstevel@tonic-gate 			 */
18630Sstevel@tonic-gate 			struct sockaddr_in6 *faddr6, *sin6;
18640Sstevel@tonic-gate 			static struct in6_addr zeroes; /* inits to all zeros */
18650Sstevel@tonic-gate 
18668348SEric.Yu@Sun.COM 			/* Prevent sti_faddr_sa from changing while accessed */
18670Sstevel@tonic-gate 			mutex_enter(&so->so_lock);
18688348SEric.Yu@Sun.COM 			ASSERT(sti->sti_faddr_len ==
18690Sstevel@tonic-gate 			    (socklen_t)sizeof (struct sockaddr_in6));
18708348SEric.Yu@Sun.COM 			faddr6 = (struct sockaddr_in6 *)sti->sti_faddr_sa;
18710Sstevel@tonic-gate 			sin6 = (struct sockaddr_in6 *)addr;
18720Sstevel@tonic-gate 			/* XXX could we get a mapped address ::ffff:0.0.0.0 ? */
18730Sstevel@tonic-gate 			if (addrlen !=
18740Sstevel@tonic-gate 			    (t_uscalar_t)sizeof (struct sockaddr_in6) ||
18750Sstevel@tonic-gate 			    (!IN6_ARE_ADDR_EQUAL(&sin6->sin6_addr,
18765753Sgww 			    &faddr6->sin6_addr) &&
18770Sstevel@tonic-gate 			    !IN6_ARE_ADDR_EQUAL(&faddr6->sin6_addr, &zeroes)) ||
18780Sstevel@tonic-gate 			    (so->so_type != SOCK_RAW &&
18790Sstevel@tonic-gate 			    sin6->sin6_port != faddr6->sin6_port &&
18800Sstevel@tonic-gate 			    faddr6->sin6_port != 0)) {
18810Sstevel@tonic-gate #ifdef DEBUG
18820Sstevel@tonic-gate 				dprintso(so, 0,
18830Sstevel@tonic-gate 				    ("sockfs: T_UNITDATA_IND mismatch: %s",
18845753Sgww 				    pr_addr(so->so_family,
18858348SEric.Yu@Sun.COM 				    (struct sockaddr *)addr, addrlen)));
18860Sstevel@tonic-gate 				dprintso(so, 0, (" - %s\n",
18878348SEric.Yu@Sun.COM 				    pr_addr(so->so_family, sti->sti_faddr_sa,
18888348SEric.Yu@Sun.COM 				    (t_uscalar_t)sti->sti_faddr_len)));
18890Sstevel@tonic-gate #endif /* DEBUG */
18900Sstevel@tonic-gate 				mutex_exit(&so->so_lock);
18910Sstevel@tonic-gate 				freemsg(mp);
18920Sstevel@tonic-gate 				return (NULL);
18930Sstevel@tonic-gate 			}
18940Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
18950Sstevel@tonic-gate 		} else if (so->so_family == AF_UNIX &&
18960Sstevel@tonic-gate 		    msgdsize(mp->b_cont) == 0 &&
18970Sstevel@tonic-gate 		    tudi->OPT_length != 0) {
18980Sstevel@tonic-gate 			/*
18990Sstevel@tonic-gate 			 * Attempt to extract AF_UNIX
19000Sstevel@tonic-gate 			 * SO_UNIX_CLOSE indication from options.
19010Sstevel@tonic-gate 			 */
19020Sstevel@tonic-gate 			void *opt;
19030Sstevel@tonic-gate 			t_uscalar_t optlen = tudi->OPT_length;
19040Sstevel@tonic-gate 
19050Sstevel@tonic-gate 			opt = sogetoff(mp, tudi->OPT_offset,
19065753Sgww 			    optlen, __TPI_ALIGN_SIZE);
19070Sstevel@tonic-gate 			if (opt == NULL) {
19080Sstevel@tonic-gate 				/* The len/off falls outside mp */
19090Sstevel@tonic-gate 				freemsg(mp);
19100Sstevel@tonic-gate 				mutex_enter(&so->so_lock);
19110Sstevel@tonic-gate 				soseterror(so, EPROTO);
19120Sstevel@tonic-gate 				mutex_exit(&so->so_lock);
19131548Srshoaib 				zcmn_err(getzoneid(), CE_WARN,
19140Sstevel@tonic-gate 				    "sockfs: T_unidata_ind with invalid "
19150Sstevel@tonic-gate 				    "optlen/offset %u/%d\n",
19160Sstevel@tonic-gate 				    optlen, tudi->OPT_offset);
19170Sstevel@tonic-gate 				return (NULL);
19180Sstevel@tonic-gate 			}
19190Sstevel@tonic-gate 			/*
19200Sstevel@tonic-gate 			 * If we received a unix close indication mark the
19210Sstevel@tonic-gate 			 * socket and discard this message.
19220Sstevel@tonic-gate 			 */
19230Sstevel@tonic-gate 			if (so_getopt_unix_close(opt, optlen)) {
19240Sstevel@tonic-gate 				mutex_enter(&so->so_lock);
19250Sstevel@tonic-gate 				sobreakconn(so, ECONNRESET);
19260Sstevel@tonic-gate 				mutex_exit(&so->so_lock);
19270Sstevel@tonic-gate 				strsetrerror(SOTOV(so), 0, 0, sogetrderr);
19280Sstevel@tonic-gate 				freemsg(mp);
19290Sstevel@tonic-gate 				*pollwakeups = POLLIN | POLLRDNORM;
19300Sstevel@tonic-gate 				*allmsgsigs = S_INPUT | S_RDNORM;
19310Sstevel@tonic-gate 				*wakeups = RSLEEP;
19320Sstevel@tonic-gate 				return (NULL);
19330Sstevel@tonic-gate 			}
19340Sstevel@tonic-gate 		}
19350Sstevel@tonic-gate 		*allmsgsigs = S_INPUT | S_RDNORM;
19360Sstevel@tonic-gate 		*pollwakeups = POLLIN | POLLRDNORM;
19370Sstevel@tonic-gate 		*wakeups = RSLEEP;
19380Sstevel@tonic-gate 		return (mp);
19390Sstevel@tonic-gate 	}
19400Sstevel@tonic-gate 
19410Sstevel@tonic-gate 	case T_OPTDATA_IND: {
19420Sstevel@tonic-gate 		struct T_optdata_ind	*tdi = &tpr->optdata_ind;
19430Sstevel@tonic-gate 
19440Sstevel@tonic-gate 		if (MBLKL(mp) < sizeof (struct T_optdata_ind)) {
19451548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
19460Sstevel@tonic-gate 			    "sockfs: Too short T_OPTDATA_IND. Len = %ld\n",
19470Sstevel@tonic-gate 			    (ptrdiff_t)(MBLKL(mp)));
19480Sstevel@tonic-gate 			freemsg(mp);
19490Sstevel@tonic-gate 			return (NULL);
19500Sstevel@tonic-gate 		}
19510Sstevel@tonic-gate 		/*
19520Sstevel@tonic-gate 		 * Allow zero-length messages carrying options.
19530Sstevel@tonic-gate 		 * This is used when carrying the SO_UNIX_CLOSE option.
19540Sstevel@tonic-gate 		 */
19550Sstevel@tonic-gate 		if (so->so_family == AF_UNIX && msgdsize(mp->b_cont) == 0 &&
19560Sstevel@tonic-gate 		    tdi->OPT_length != 0) {
19570Sstevel@tonic-gate 			/*
19580Sstevel@tonic-gate 			 * Attempt to extract AF_UNIX close indication
19590Sstevel@tonic-gate 			 * from the options. Ignore any other options -
19600Sstevel@tonic-gate 			 * those are handled once the message is removed
19610Sstevel@tonic-gate 			 * from the queue.
19620Sstevel@tonic-gate 			 * The close indication message should not carry data.
19630Sstevel@tonic-gate 			 */
19640Sstevel@tonic-gate 			void *opt;
19650Sstevel@tonic-gate 			t_uscalar_t optlen = tdi->OPT_length;
19660Sstevel@tonic-gate 
19670Sstevel@tonic-gate 			opt = sogetoff(mp, tdi->OPT_offset,
19685753Sgww 			    optlen, __TPI_ALIGN_SIZE);
19690Sstevel@tonic-gate 			if (opt == NULL) {
19700Sstevel@tonic-gate 				/* The len/off falls outside mp */
19710Sstevel@tonic-gate 				freemsg(mp);
19720Sstevel@tonic-gate 				mutex_enter(&so->so_lock);
19730Sstevel@tonic-gate 				soseterror(so, EPROTO);
19740Sstevel@tonic-gate 				mutex_exit(&so->so_lock);
19751548Srshoaib 				zcmn_err(getzoneid(), CE_WARN,
19760Sstevel@tonic-gate 				    "sockfs: T_optdata_ind with invalid "
19770Sstevel@tonic-gate 				    "optlen/offset %u/%d\n",
19780Sstevel@tonic-gate 				    optlen, tdi->OPT_offset);
19790Sstevel@tonic-gate 				return (NULL);
19800Sstevel@tonic-gate 			}
19810Sstevel@tonic-gate 			/*
19820Sstevel@tonic-gate 			 * If we received a close indication mark the
19830Sstevel@tonic-gate 			 * socket and discard this message.
19840Sstevel@tonic-gate 			 */
19850Sstevel@tonic-gate 			if (so_getopt_unix_close(opt, optlen)) {
19860Sstevel@tonic-gate 				mutex_enter(&so->so_lock);
19870Sstevel@tonic-gate 				socantsendmore(so);
19888348SEric.Yu@Sun.COM 				sti->sti_faddr_valid = 0;
19890Sstevel@tonic-gate 				mutex_exit(&so->so_lock);
19900Sstevel@tonic-gate 				strsetwerror(SOTOV(so), 0, 0, sogetwrerr);
19910Sstevel@tonic-gate 				freemsg(mp);
19920Sstevel@tonic-gate 				return (NULL);
19930Sstevel@tonic-gate 			}
19940Sstevel@tonic-gate 		}
19950Sstevel@tonic-gate 		*allmsgsigs = S_INPUT | S_RDNORM;
19960Sstevel@tonic-gate 		*pollwakeups = POLLIN | POLLRDNORM;
19970Sstevel@tonic-gate 		*wakeups = RSLEEP;
19980Sstevel@tonic-gate 		return (mp);
19990Sstevel@tonic-gate 	}
20000Sstevel@tonic-gate 
20010Sstevel@tonic-gate 	case T_EXDATA_IND: {
20020Sstevel@tonic-gate 		mblk_t		*mctl, *mdata;
20032933Sss146032 		mblk_t *lbp;
20042933Sss146032 		union T_primitives *tprp;
20052933Sss146032 		struct stdata   *stp;
20062933Sss146032 		queue_t *qp;
20070Sstevel@tonic-gate 
20080Sstevel@tonic-gate 		if (MBLKL(mp) < sizeof (struct T_exdata_ind)) {
20091548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
20100Sstevel@tonic-gate 			    "sockfs: Too short T_EXDATA_IND. Len = %ld\n",
20110Sstevel@tonic-gate 			    (ptrdiff_t)(MBLKL(mp)));
20120Sstevel@tonic-gate 			freemsg(mp);
20130Sstevel@tonic-gate 			return (NULL);
20140Sstevel@tonic-gate 		}
20150Sstevel@tonic-gate 		/*
20160Sstevel@tonic-gate 		 * Ignore zero-length T_EXDATA_IND messages. These might be
20170Sstevel@tonic-gate 		 * generated by some transports.
20180Sstevel@tonic-gate 		 *
20190Sstevel@tonic-gate 		 * This is needed to prevent read (which skips the M_PROTO
20200Sstevel@tonic-gate 		 * part) to unexpectedly return 0 (or return EWOULDBLOCK
20210Sstevel@tonic-gate 		 * on a non-blocking socket after select/poll has indicated
20220Sstevel@tonic-gate 		 * that data is available).
20230Sstevel@tonic-gate 		 */
20240Sstevel@tonic-gate 		dprintso(so, 1,
20255753Sgww 		    ("T_EXDATA_IND(%p): counts %d/%d state %s\n",
20268348SEric.Yu@Sun.COM 		    (void *)vp, sti->sti_oobsigcnt, sti->sti_oobcnt,
20275753Sgww 		    pr_state(so->so_state, so->so_mode)));
20280Sstevel@tonic-gate 
20290Sstevel@tonic-gate 		if (msgdsize(mp->b_cont) == 0) {
20300Sstevel@tonic-gate 			dprintso(so, 0,
20315753Sgww 			    ("strsock_proto: zero length T_EXDATA_IND\n"));
20320Sstevel@tonic-gate 			freemsg(mp);
20330Sstevel@tonic-gate 			return (NULL);
20340Sstevel@tonic-gate 		}
20350Sstevel@tonic-gate 
20360Sstevel@tonic-gate 		/*
20370Sstevel@tonic-gate 		 * Split into the T_EXDATA_IND and the M_DATA part.
20380Sstevel@tonic-gate 		 * We process these three pieces separately:
20390Sstevel@tonic-gate 		 *	signal generation
20400Sstevel@tonic-gate 		 *	handling T_EXDATA_IND
20410Sstevel@tonic-gate 		 *	handling M_DATA component
20420Sstevel@tonic-gate 		 */
20430Sstevel@tonic-gate 		mctl = mp;
20440Sstevel@tonic-gate 		mdata = mctl->b_cont;
20450Sstevel@tonic-gate 		mctl->b_cont = NULL;
20460Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
20470Sstevel@tonic-gate 		so_oob_sig(so, 0, allmsgsigs, pollwakeups);
20480Sstevel@tonic-gate 		mctl = so_oob_exdata(so, mctl, allmsgsigs, pollwakeups);
20490Sstevel@tonic-gate 		mdata = so_oob_data(so, mdata, allmsgsigs, pollwakeups);
20500Sstevel@tonic-gate 
20512933Sss146032 		stp = vp->v_stream;
20522933Sss146032 		ASSERT(stp != NULL);
20532933Sss146032 		qp = _RD(stp->sd_wrq);
20542933Sss146032 
20552933Sss146032 		mutex_enter(QLOCK(qp));
20562933Sss146032 		lbp = qp->q_last;
20572933Sss146032 
20582933Sss146032 		/*
20592933Sss146032 		 * We want to avoid queueing up a string of T_EXDATA_IND
20602933Sss146032 		 * messages with no intervening data messages at the stream
20612933Sss146032 		 * head. These messages contribute to the total message
20622933Sss146032 		 * count. Eventually this can lead to STREAMS flow contol
20632933Sss146032 		 * and also cause TCP to advertise a zero window condition
20642933Sss146032 		 * to the peer. This can happen in the degenerate case where
20652933Sss146032 		 * the sender and receiver exchange only OOB data. The sender
20662933Sss146032 		 * only sends messages with MSG_OOB flag and the receiver
20672933Sss146032 		 * receives only MSG_OOB messages and does not use SO_OOBINLINE.
20682933Sss146032 		 * An example of this scenario has been reported in applications
20692933Sss146032 		 * that use OOB data to exchange heart beats. Flow control
20702933Sss146032 		 * relief will never happen if the application only reads OOB
20712933Sss146032 		 * data which is done directly by sorecvoob() and the
20722933Sss146032 		 * T_EXDATA_IND messages at the streamhead won't be consumed.
20732933Sss146032 		 * Note that there is no correctness issue in compressing the
20742933Sss146032 		 * string of T_EXDATA_IND messages into a single T_EXDATA_IND
20752933Sss146032 		 * message. A single read that does not specify MSG_OOB will
20762933Sss146032 		 * read across all the marks in a loop in sotpi_recvmsg().
20772933Sss146032 		 * Each mark is individually distinguishable only if the
20782933Sss146032 		 * T_EXDATA_IND messages are separated by data messages.
20792933Sss146032 		 */
20802933Sss146032 		if ((qp->q_first != NULL) && (DB_TYPE(lbp) == M_PROTO)) {
20812933Sss146032 			tprp = (union T_primitives *)lbp->b_rptr;
20822933Sss146032 			if ((tprp->type == T_EXDATA_IND) &&
20832933Sss146032 			    !(so->so_options & SO_OOBINLINE)) {
20842933Sss146032 
20852933Sss146032 				/*
20862933Sss146032 				 * free the new M_PROTO message
20872933Sss146032 				 */
20882933Sss146032 				freemsg(mctl);
20892933Sss146032 
20902933Sss146032 				/*
20912933Sss146032 				 * adjust the OOB count and OOB	signal count
20922933Sss146032 				 * just incremented for the new OOB data.
20932933Sss146032 				 */
20948348SEric.Yu@Sun.COM 				sti->sti_oobcnt--;
20958348SEric.Yu@Sun.COM 				sti->sti_oobsigcnt--;
20962933Sss146032 				mutex_exit(QLOCK(qp));
20972933Sss146032 				mutex_exit(&so->so_lock);
20982933Sss146032 				return (NULL);
20992933Sss146032 			}
21002933Sss146032 		}
21012933Sss146032 		mutex_exit(QLOCK(qp));
21022933Sss146032 
21030Sstevel@tonic-gate 		/*
21040Sstevel@tonic-gate 		 * Pass the T_EXDATA_IND and the M_DATA back separately
21050Sstevel@tonic-gate 		 * by using b_next linkage. (The stream head will queue any
21060Sstevel@tonic-gate 		 * b_next linked messages separately.) This is needed
21070Sstevel@tonic-gate 		 * since MSGMARK applies to the last by of the message
21080Sstevel@tonic-gate 		 * hence we can not have any M_DATA component attached
21090Sstevel@tonic-gate 		 * to the marked T_EXDATA_IND. Note that the stream head
21100Sstevel@tonic-gate 		 * will not consolidate M_DATA messages onto an MSGMARK'ed
21110Sstevel@tonic-gate 		 * message in order to preserve the constraint that
21120Sstevel@tonic-gate 		 * the T_EXDATA_IND always is a separate message.
21130Sstevel@tonic-gate 		 */
21140Sstevel@tonic-gate 		ASSERT(mctl != NULL);
21150Sstevel@tonic-gate 		mctl->b_next = mdata;
21160Sstevel@tonic-gate 		mp = mctl;
21170Sstevel@tonic-gate #ifdef DEBUG
21180Sstevel@tonic-gate 		if (mdata == NULL) {
21190Sstevel@tonic-gate 			dprintso(so, 1,
21205753Sgww 			    ("after outofline T_EXDATA_IND(%p): "
21215753Sgww 			    "counts %d/%d  poll 0x%x sig 0x%x state %s\n",
21228348SEric.Yu@Sun.COM 			    (void *)vp, sti->sti_oobsigcnt,
21238348SEric.Yu@Sun.COM 			    sti->sti_oobcnt, *pollwakeups, *allmsgsigs,
21245753Sgww 			    pr_state(so->so_state, so->so_mode)));
21250Sstevel@tonic-gate 		} else {
21260Sstevel@tonic-gate 			dprintso(so, 1,
21275753Sgww 			    ("after inline T_EXDATA_IND(%p): "
21285753Sgww 			    "counts %d/%d  poll 0x%x sig 0x%x state %s\n",
21298348SEric.Yu@Sun.COM 			    (void *)vp, sti->sti_oobsigcnt,
21308348SEric.Yu@Sun.COM 			    sti->sti_oobcnt, *pollwakeups, *allmsgsigs,
21315753Sgww 			    pr_state(so->so_state, so->so_mode)));
21320Sstevel@tonic-gate 		}
21330Sstevel@tonic-gate #endif /* DEBUG */
21340Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
21350Sstevel@tonic-gate 		*wakeups = RSLEEP;
21360Sstevel@tonic-gate 		return (mp);
21370Sstevel@tonic-gate 	}
21380Sstevel@tonic-gate 
21390Sstevel@tonic-gate 	case T_CONN_CON: {
21400Sstevel@tonic-gate 		struct T_conn_con	*conn_con;
21410Sstevel@tonic-gate 		void			*addr;
21420Sstevel@tonic-gate 		t_uscalar_t		addrlen;
21430Sstevel@tonic-gate 
21440Sstevel@tonic-gate 		/*
21450Sstevel@tonic-gate 		 * Verify the state, update the state to ISCONNECTED,
21460Sstevel@tonic-gate 		 * record the potentially new address in the message,
21470Sstevel@tonic-gate 		 * and drop the message.
21480Sstevel@tonic-gate 		 */
21490Sstevel@tonic-gate 		if (MBLKL(mp) < sizeof (struct T_conn_con)) {
21501548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
21510Sstevel@tonic-gate 			    "sockfs: Too short T_CONN_CON. Len = %ld\n",
21520Sstevel@tonic-gate 			    (ptrdiff_t)(MBLKL(mp)));
21530Sstevel@tonic-gate 			freemsg(mp);
21540Sstevel@tonic-gate 			return (NULL);
21550Sstevel@tonic-gate 		}
21560Sstevel@tonic-gate 
21570Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
21580Sstevel@tonic-gate 		if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) !=
21590Sstevel@tonic-gate 		    SS_ISCONNECTING) {
21600Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
21610Sstevel@tonic-gate 			dprintso(so, 1,
21625753Sgww 			    ("T_CONN_CON: state %x\n", so->so_state));
21630Sstevel@tonic-gate 			freemsg(mp);
21640Sstevel@tonic-gate 			return (NULL);
21650Sstevel@tonic-gate 		}
21660Sstevel@tonic-gate 
21670Sstevel@tonic-gate 		conn_con = &tpr->conn_con;
21680Sstevel@tonic-gate 		addrlen = conn_con->RES_length;
21690Sstevel@tonic-gate 		/*
21700Sstevel@tonic-gate 		 * Allow the address to be of different size than sent down
21710Sstevel@tonic-gate 		 * in the T_CONN_REQ as long as it doesn't exceed the maxlen.
21720Sstevel@tonic-gate 		 * For AF_UNIX require the identical length.
21730Sstevel@tonic-gate 		 */
21740Sstevel@tonic-gate 		if (so->so_family == AF_UNIX ?
21758348SEric.Yu@Sun.COM 		    addrlen != (t_uscalar_t)sizeof (sti->sti_ux_laddr) :
21768348SEric.Yu@Sun.COM 		    addrlen > (t_uscalar_t)sti->sti_faddr_maxlen) {
21771548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
21780Sstevel@tonic-gate 			    "sockfs: T_conn_con with different "
21790Sstevel@tonic-gate 			    "length %u/%d\n",
21800Sstevel@tonic-gate 			    addrlen, conn_con->RES_length);
21810Sstevel@tonic-gate 			soisdisconnected(so, EPROTO);
21828348SEric.Yu@Sun.COM 			sti->sti_laddr_valid = 0;
21838348SEric.Yu@Sun.COM 			sti->sti_faddr_valid = 0;
21840Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
21850Sstevel@tonic-gate 			strsetrerror(SOTOV(so), 0, 0, sogetrderr);
21860Sstevel@tonic-gate 			strsetwerror(SOTOV(so), 0, 0, sogetwrerr);
21870Sstevel@tonic-gate 			strseteof(SOTOV(so), 1);
21880Sstevel@tonic-gate 			freemsg(mp);
21890Sstevel@tonic-gate 			/*
21900Sstevel@tonic-gate 			 * strseteof takes care of read side wakeups,
21910Sstevel@tonic-gate 			 * pollwakeups, and signals.
21920Sstevel@tonic-gate 			 */
21930Sstevel@tonic-gate 			*wakeups = WSLEEP;
21940Sstevel@tonic-gate 			*allmsgsigs = S_OUTPUT;
21950Sstevel@tonic-gate 			*pollwakeups = POLLOUT;
21960Sstevel@tonic-gate 			return (NULL);
21970Sstevel@tonic-gate 		}
21980Sstevel@tonic-gate 		addr = sogetoff(mp, conn_con->RES_offset, addrlen, 1);
21990Sstevel@tonic-gate 		if (addr == NULL) {
22001548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
22010Sstevel@tonic-gate 			    "sockfs: T_conn_con with invalid "
22020Sstevel@tonic-gate 			    "addrlen/offset %u/%d\n",
22030Sstevel@tonic-gate 			    addrlen, conn_con->RES_offset);
22040Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
22050Sstevel@tonic-gate 			strsetrerror(SOTOV(so), 0, 0, sogetrderr);
22060Sstevel@tonic-gate 			strsetwerror(SOTOV(so), 0, 0, sogetwrerr);
22070Sstevel@tonic-gate 			strseteof(SOTOV(so), 1);
22080Sstevel@tonic-gate 			freemsg(mp);
22090Sstevel@tonic-gate 			/*
22100Sstevel@tonic-gate 			 * strseteof takes care of read side wakeups,
22110Sstevel@tonic-gate 			 * pollwakeups, and signals.
22120Sstevel@tonic-gate 			 */
22130Sstevel@tonic-gate 			*wakeups = WSLEEP;
22140Sstevel@tonic-gate 			*allmsgsigs = S_OUTPUT;
22150Sstevel@tonic-gate 			*pollwakeups = POLLOUT;
22160Sstevel@tonic-gate 			return (NULL);
22170Sstevel@tonic-gate 		}
22180Sstevel@tonic-gate 
22190Sstevel@tonic-gate 		/*
22200Sstevel@tonic-gate 		 * Save for getpeername.
22210Sstevel@tonic-gate 		 */
22220Sstevel@tonic-gate 		if (so->so_family != AF_UNIX) {
22238348SEric.Yu@Sun.COM 			sti->sti_faddr_len = (socklen_t)addrlen;
22248348SEric.Yu@Sun.COM 			ASSERT(sti->sti_faddr_len <= sti->sti_faddr_maxlen);
22258348SEric.Yu@Sun.COM 			bcopy(addr, sti->sti_faddr_sa, addrlen);
22268348SEric.Yu@Sun.COM 			sti->sti_faddr_valid = 1;
22270Sstevel@tonic-gate 		}
22280Sstevel@tonic-gate 
22290Sstevel@tonic-gate 		if (so->so_peercred != NULL)
22300Sstevel@tonic-gate 			crfree(so->so_peercred);
22318778SErik.Nordmark@Sun.COM 		so->so_peercred = msg_getcred(mp, &so->so_cpid);
22320Sstevel@tonic-gate 		if (so->so_peercred != NULL)
22330Sstevel@tonic-gate 			crhold(so->so_peercred);
22340Sstevel@tonic-gate 
22350Sstevel@tonic-gate 		/* Wakeup anybody sleeping in sowaitconnected */
22360Sstevel@tonic-gate 		soisconnected(so);
22370Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
22380Sstevel@tonic-gate 
22390Sstevel@tonic-gate 		/*
22400Sstevel@tonic-gate 		 * The socket is now available for sending data.
22410Sstevel@tonic-gate 		 */
22420Sstevel@tonic-gate 		*wakeups = WSLEEP;
22430Sstevel@tonic-gate 		*allmsgsigs = S_OUTPUT;
22440Sstevel@tonic-gate 		*pollwakeups = POLLOUT;
22450Sstevel@tonic-gate 		freemsg(mp);
22460Sstevel@tonic-gate 		return (NULL);
22470Sstevel@tonic-gate 	}
22480Sstevel@tonic-gate 
22490Sstevel@tonic-gate 	case T_CONN_IND:
22500Sstevel@tonic-gate 		/*
22510Sstevel@tonic-gate 		 * Verify the min size and queue the message on
22528348SEric.Yu@Sun.COM 		 * the sti_conn_ind_head/tail list.
22530Sstevel@tonic-gate 		 */
22540Sstevel@tonic-gate 		if (MBLKL(mp) < sizeof (struct T_conn_ind)) {
22551548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
22560Sstevel@tonic-gate 			    "sockfs: Too short T_CONN_IND. Len = %ld\n",
22570Sstevel@tonic-gate 			    (ptrdiff_t)(MBLKL(mp)));
22580Sstevel@tonic-gate 			freemsg(mp);
22590Sstevel@tonic-gate 			return (NULL);
22600Sstevel@tonic-gate 		}
22610Sstevel@tonic-gate 
226211861SMarek.Pospisil@Sun.COM 		if (auditing)
22630Sstevel@tonic-gate 			audit_sock(T_CONN_IND, strvp2wq(vp), mp, 0);
22640Sstevel@tonic-gate 		if (!(so->so_state & SS_ACCEPTCONN)) {
22651548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
22660Sstevel@tonic-gate 			    "sockfs: T_conn_ind on non-listening socket\n");
22670Sstevel@tonic-gate 			freemsg(mp);
22680Sstevel@tonic-gate 			return (NULL);
22690Sstevel@tonic-gate 		}
2270898Skais 
22710Sstevel@tonic-gate 		soqueueconnind(so, mp);
22720Sstevel@tonic-gate 		*allmsgsigs = S_INPUT | S_RDNORM;
22730Sstevel@tonic-gate 		*pollwakeups = POLLIN | POLLRDNORM;
22740Sstevel@tonic-gate 		*wakeups = RSLEEP;
22750Sstevel@tonic-gate 		return (NULL);
22760Sstevel@tonic-gate 
22770Sstevel@tonic-gate 	case T_ORDREL_IND:
22780Sstevel@tonic-gate 		if (MBLKL(mp) < sizeof (struct T_ordrel_ind)) {
22791548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
22800Sstevel@tonic-gate 			    "sockfs: Too short T_ORDREL_IND. Len = %ld\n",
22810Sstevel@tonic-gate 			    (ptrdiff_t)(MBLKL(mp)));
22820Sstevel@tonic-gate 			freemsg(mp);
22830Sstevel@tonic-gate 			return (NULL);
22840Sstevel@tonic-gate 		}
22850Sstevel@tonic-gate 
22860Sstevel@tonic-gate 		/*
22870Sstevel@tonic-gate 		 * Some providers send this when not fully connected.
22880Sstevel@tonic-gate 		 * SunLink X.25 needs to retrieve disconnect reason after
22890Sstevel@tonic-gate 		 * disconnect for compatibility. It uses T_ORDREL_IND
22900Sstevel@tonic-gate 		 * instead of T_DISCON_IND so that it may use the
22910Sstevel@tonic-gate 		 * endpoint after a connect failure to retrieve the
22920Sstevel@tonic-gate 		 * reason using an ioctl. Thus we explicitly clear
22930Sstevel@tonic-gate 		 * SS_ISCONNECTING here for SunLink X.25.
22940Sstevel@tonic-gate 		 * This is a needed TPI violation.
22950Sstevel@tonic-gate 		 */
22960Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
22970Sstevel@tonic-gate 		so->so_state &= ~SS_ISCONNECTING;
22980Sstevel@tonic-gate 		socantrcvmore(so);
22990Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
23000Sstevel@tonic-gate 		strseteof(SOTOV(so), 1);
23010Sstevel@tonic-gate 		/*
23020Sstevel@tonic-gate 		 * strseteof takes care of read side wakeups,
23030Sstevel@tonic-gate 		 * pollwakeups, and signals.
23040Sstevel@tonic-gate 		 */
23050Sstevel@tonic-gate 		freemsg(mp);
23060Sstevel@tonic-gate 		return (NULL);
23070Sstevel@tonic-gate 
23080Sstevel@tonic-gate 	case T_DISCON_IND:
23090Sstevel@tonic-gate 		if (MBLKL(mp) < sizeof (struct T_discon_ind)) {
23101548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
23110Sstevel@tonic-gate 			    "sockfs: Too short T_DISCON_IND. Len = %ld\n",
23120Sstevel@tonic-gate 			    (ptrdiff_t)(MBLKL(mp)));
23130Sstevel@tonic-gate 			freemsg(mp);
23140Sstevel@tonic-gate 			return (NULL);
23150Sstevel@tonic-gate 		}
23160Sstevel@tonic-gate 		if (so->so_state & SS_ACCEPTCONN) {
23170Sstevel@tonic-gate 			/*
23180Sstevel@tonic-gate 			 * This is a listener. Look for a queued T_CONN_IND
23190Sstevel@tonic-gate 			 * with a matching sequence number and remove it
23200Sstevel@tonic-gate 			 * from the list.
23210Sstevel@tonic-gate 			 * It is normal to not find the sequence number since
23220Sstevel@tonic-gate 			 * the soaccept might have already dequeued it
23230Sstevel@tonic-gate 			 * (in which case the T_CONN_RES will fail with
23240Sstevel@tonic-gate 			 * TBADSEQ).
23250Sstevel@tonic-gate 			 */
23260Sstevel@tonic-gate 			(void) soflushconnind(so, tpr->discon_ind.SEQ_number);
23270Sstevel@tonic-gate 			freemsg(mp);
23280Sstevel@tonic-gate 			return (0);
23290Sstevel@tonic-gate 		}
23300Sstevel@tonic-gate 
23310Sstevel@tonic-gate 		/*
23320Sstevel@tonic-gate 		 * Not a listener
23330Sstevel@tonic-gate 		 *
23340Sstevel@tonic-gate 		 * If SS_CANTRCVMORE for AF_UNIX ignore the discon_reason.
23350Sstevel@tonic-gate 		 * Such a discon_ind appears when the peer has first done
23360Sstevel@tonic-gate 		 * a shutdown() followed by a close() in which case we just
23370Sstevel@tonic-gate 		 * want to record socantsendmore.
23380Sstevel@tonic-gate 		 * In this case sockfs first receives a T_ORDREL_IND followed
23390Sstevel@tonic-gate 		 * by a T_DISCON_IND.
23400Sstevel@tonic-gate 		 * Note that for other transports (e.g. TCP) we need to handle
23410Sstevel@tonic-gate 		 * the discon_ind in this case since it signals an error.
23420Sstevel@tonic-gate 		 */
23430Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
23440Sstevel@tonic-gate 		if ((so->so_state & SS_CANTRCVMORE) &&
23450Sstevel@tonic-gate 		    (so->so_family == AF_UNIX)) {
23460Sstevel@tonic-gate 			socantsendmore(so);
23478348SEric.Yu@Sun.COM 			sti->sti_faddr_valid = 0;
23480Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
23490Sstevel@tonic-gate 			strsetwerror(SOTOV(so), 0, 0, sogetwrerr);
23500Sstevel@tonic-gate 			dprintso(so, 1,
23515753Sgww 			    ("T_DISCON_IND: error %d\n", so->so_error));
23520Sstevel@tonic-gate 			freemsg(mp);
23530Sstevel@tonic-gate 			/*
23540Sstevel@tonic-gate 			 * Set these variables for caller to process them.
23550Sstevel@tonic-gate 			 * For the else part where T_DISCON_IND is processed,
23560Sstevel@tonic-gate 			 * this will be done in the function being called
23570Sstevel@tonic-gate 			 * (strsock_discon_ind())
23580Sstevel@tonic-gate 			 */
23590Sstevel@tonic-gate 			*wakeups = WSLEEP;
23600Sstevel@tonic-gate 			*allmsgsigs = S_OUTPUT;
23610Sstevel@tonic-gate 			*pollwakeups = POLLOUT;
23620Sstevel@tonic-gate 		} else if (so->so_flag & (SOASYNC_UNBIND | SOLOCKED)) {
23630Sstevel@tonic-gate 			/*
23640Sstevel@tonic-gate 			 * Deferred processing of T_DISCON_IND
23650Sstevel@tonic-gate 			 */
23660Sstevel@tonic-gate 			so_save_discon_ind(so, mp, strsock_discon_ind);
23670Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
23680Sstevel@tonic-gate 		} else {
23690Sstevel@tonic-gate 			/*
23700Sstevel@tonic-gate 			 * Process T_DISCON_IND now
23710Sstevel@tonic-gate 			 */
23720Sstevel@tonic-gate 			(void) strsock_discon_ind(so, mp);
23730Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
23740Sstevel@tonic-gate 		}
23750Sstevel@tonic-gate 		return (NULL);
23760Sstevel@tonic-gate 
23770Sstevel@tonic-gate 	case T_UDERROR_IND: {
23780Sstevel@tonic-gate 		struct T_uderror_ind	*tudi = &tpr->uderror_ind;
23790Sstevel@tonic-gate 		void			*addr;
23800Sstevel@tonic-gate 		t_uscalar_t		addrlen;
23810Sstevel@tonic-gate 		int			error;
23820Sstevel@tonic-gate 
23830Sstevel@tonic-gate 		dprintso(so, 0,
23845753Sgww 		    ("T_UDERROR_IND: error %d\n", tudi->ERROR_type));
23850Sstevel@tonic-gate 
23860Sstevel@tonic-gate 		if (MBLKL(mp) < sizeof (struct T_uderror_ind)) {
23871548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
23880Sstevel@tonic-gate 			    "sockfs: Too short T_UDERROR_IND. Len = %ld\n",
23890Sstevel@tonic-gate 			    (ptrdiff_t)(MBLKL(mp)));
23900Sstevel@tonic-gate 			freemsg(mp);
23910Sstevel@tonic-gate 			return (NULL);
23920Sstevel@tonic-gate 		}
23930Sstevel@tonic-gate 		/* Ignore on connection-oriented transports */
23940Sstevel@tonic-gate 		if (so->so_mode & SM_CONNREQUIRED) {
23950Sstevel@tonic-gate 			freemsg(mp);
23960Sstevel@tonic-gate 			eprintsoline(so, 0);
23971548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
23980Sstevel@tonic-gate 			    "sockfs: T_uderror_ind on connection-oriented "
23990Sstevel@tonic-gate 			    "transport\n");
24000Sstevel@tonic-gate 			return (NULL);
24010Sstevel@tonic-gate 		}
24020Sstevel@tonic-gate 		addrlen = tudi->DEST_length;
24030Sstevel@tonic-gate 		addr = sogetoff(mp, tudi->DEST_offset, addrlen, 1);
24040Sstevel@tonic-gate 		if (addr == NULL) {
24051548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
24060Sstevel@tonic-gate 			    "sockfs: T_uderror_ind with invalid "
24070Sstevel@tonic-gate 			    "addrlen/offset %u/%d\n",
24080Sstevel@tonic-gate 			    addrlen, tudi->DEST_offset);
24090Sstevel@tonic-gate 			freemsg(mp);
24100Sstevel@tonic-gate 			return (NULL);
24110Sstevel@tonic-gate 		}
24120Sstevel@tonic-gate 
24130Sstevel@tonic-gate 		/* Verify source address for connected socket. */
24140Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
24150Sstevel@tonic-gate 		if (so->so_state & SS_ISCONNECTED) {
24160Sstevel@tonic-gate 			void *faddr;
24170Sstevel@tonic-gate 			t_uscalar_t faddr_len;
24180Sstevel@tonic-gate 			boolean_t match = B_FALSE;
24190Sstevel@tonic-gate 
24200Sstevel@tonic-gate 			switch (so->so_family) {
24210Sstevel@tonic-gate 			case AF_INET: {
24220Sstevel@tonic-gate 				/* Compare just IP address and port */
24230Sstevel@tonic-gate 				struct sockaddr_in *sin1, *sin2;
24240Sstevel@tonic-gate 
24258348SEric.Yu@Sun.COM 				sin1 = (struct sockaddr_in *)sti->sti_faddr_sa;
24260Sstevel@tonic-gate 				sin2 = (struct sockaddr_in *)addr;
24270Sstevel@tonic-gate 				if (addrlen == sizeof (struct sockaddr_in) &&
24280Sstevel@tonic-gate 				    sin1->sin_port == sin2->sin_port &&
24290Sstevel@tonic-gate 				    sin1->sin_addr.s_addr ==
24300Sstevel@tonic-gate 				    sin2->sin_addr.s_addr)
24310Sstevel@tonic-gate 					match = B_TRUE;
24320Sstevel@tonic-gate 				break;
24330Sstevel@tonic-gate 			}
24340Sstevel@tonic-gate 			case AF_INET6: {
24350Sstevel@tonic-gate 				/* Compare just IP address and port. Not flow */
24360Sstevel@tonic-gate 				struct sockaddr_in6 *sin1, *sin2;
24370Sstevel@tonic-gate 
24388348SEric.Yu@Sun.COM 				sin1 = (struct sockaddr_in6 *)sti->sti_faddr_sa;
24390Sstevel@tonic-gate 				sin2 = (struct sockaddr_in6 *)addr;
24400Sstevel@tonic-gate 				if (addrlen == sizeof (struct sockaddr_in6) &&
24410Sstevel@tonic-gate 				    sin1->sin6_port == sin2->sin6_port &&
24420Sstevel@tonic-gate 				    IN6_ARE_ADDR_EQUAL(&sin1->sin6_addr,
24435753Sgww 				    &sin2->sin6_addr))
24440Sstevel@tonic-gate 					match = B_TRUE;
24450Sstevel@tonic-gate 				break;
24460Sstevel@tonic-gate 			}
24470Sstevel@tonic-gate 			case AF_UNIX:
24488348SEric.Yu@Sun.COM 				faddr = &sti->sti_ux_faddr;
24490Sstevel@tonic-gate 				faddr_len =
24508348SEric.Yu@Sun.COM 				    (t_uscalar_t)sizeof (sti->sti_ux_faddr);
24510Sstevel@tonic-gate 				if (faddr_len == addrlen &&
24520Sstevel@tonic-gate 				    bcmp(addr, faddr, addrlen) == 0)
24530Sstevel@tonic-gate 					match = B_TRUE;
24540Sstevel@tonic-gate 				break;
24550Sstevel@tonic-gate 			default:
24568348SEric.Yu@Sun.COM 				faddr = sti->sti_faddr_sa;
24578348SEric.Yu@Sun.COM 				faddr_len = (t_uscalar_t)sti->sti_faddr_len;
24580Sstevel@tonic-gate 				if (faddr_len == addrlen &&
24590Sstevel@tonic-gate 				    bcmp(addr, faddr, addrlen) == 0)
24600Sstevel@tonic-gate 					match = B_TRUE;
24610Sstevel@tonic-gate 				break;
24620Sstevel@tonic-gate 			}
24630Sstevel@tonic-gate 
24640Sstevel@tonic-gate 			if (!match) {
24650Sstevel@tonic-gate #ifdef DEBUG
24660Sstevel@tonic-gate 				dprintso(so, 0,
24675753Sgww 				    ("sockfs: T_UDERR_IND mismatch: %s - ",
24685753Sgww 				    pr_addr(so->so_family,
24698348SEric.Yu@Sun.COM 				    (struct sockaddr *)addr, addrlen)));
24700Sstevel@tonic-gate 				dprintso(so, 0, ("%s\n",
24718348SEric.Yu@Sun.COM 				    pr_addr(so->so_family, sti->sti_faddr_sa,
24728348SEric.Yu@Sun.COM 				    sti->sti_faddr_len)));
24730Sstevel@tonic-gate #endif /* DEBUG */
24740Sstevel@tonic-gate 				mutex_exit(&so->so_lock);
24750Sstevel@tonic-gate 				freemsg(mp);
24760Sstevel@tonic-gate 				return (NULL);
24770Sstevel@tonic-gate 			}
24780Sstevel@tonic-gate 			/*
24790Sstevel@tonic-gate 			 * Make the write error nonpersistent. If the error
24800Sstevel@tonic-gate 			 * is zero we use ECONNRESET.
24810Sstevel@tonic-gate 			 * This assumes that the name space for ERROR_type
24820Sstevel@tonic-gate 			 * is the errno name space.
24830Sstevel@tonic-gate 			 */
24840Sstevel@tonic-gate 			if (tudi->ERROR_type != 0)
24850Sstevel@tonic-gate 				error = tudi->ERROR_type;
24860Sstevel@tonic-gate 			else
24870Sstevel@tonic-gate 				error = ECONNRESET;
24880Sstevel@tonic-gate 
24890Sstevel@tonic-gate 			soseterror(so, error);
24900Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
24910Sstevel@tonic-gate 			strsetrerror(SOTOV(so), 0, 0, sogetrderr);
24920Sstevel@tonic-gate 			strsetwerror(SOTOV(so), 0, 0, sogetwrerr);
24930Sstevel@tonic-gate 			*wakeups = RSLEEP | WSLEEP;
24940Sstevel@tonic-gate 			*allmsgsigs = S_INPUT | S_RDNORM | S_OUTPUT;
24950Sstevel@tonic-gate 			*pollwakeups = POLLIN | POLLRDNORM | POLLOUT;
24960Sstevel@tonic-gate 			freemsg(mp);
24970Sstevel@tonic-gate 			return (NULL);
24980Sstevel@tonic-gate 		}
24990Sstevel@tonic-gate 		/*
25000Sstevel@tonic-gate 		 * If the application asked for delayed errors
25018348SEric.Yu@Sun.COM 		 * record the T_UDERROR_IND sti_eaddr_mp and the reason in
25028348SEric.Yu@Sun.COM 		 * sti_delayed_error for delayed error posting. If the reason
25030Sstevel@tonic-gate 		 * is zero use ECONNRESET.
25040Sstevel@tonic-gate 		 * Note that delayed error indications do not make sense for
25050Sstevel@tonic-gate 		 * AF_UNIX sockets since sendto checks that the destination
25060Sstevel@tonic-gate 		 * address is valid at the time of the sendto.
25070Sstevel@tonic-gate 		 */
25080Sstevel@tonic-gate 		if (!(so->so_options & SO_DGRAM_ERRIND)) {
25090Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
25100Sstevel@tonic-gate 			freemsg(mp);
25110Sstevel@tonic-gate 			return (NULL);
25120Sstevel@tonic-gate 		}
25138348SEric.Yu@Sun.COM 		if (sti->sti_eaddr_mp != NULL)
25148348SEric.Yu@Sun.COM 			freemsg(sti->sti_eaddr_mp);
25150Sstevel@tonic-gate 
25168348SEric.Yu@Sun.COM 		sti->sti_eaddr_mp = mp;
25170Sstevel@tonic-gate 		if (tudi->ERROR_type != 0)
25180Sstevel@tonic-gate 			error = tudi->ERROR_type;
25190Sstevel@tonic-gate 		else
25200Sstevel@tonic-gate 			error = ECONNRESET;
25218348SEric.Yu@Sun.COM 		sti->sti_delayed_error = (ushort_t)error;
25220Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
25230Sstevel@tonic-gate 		return (NULL);
25240Sstevel@tonic-gate 	}
25250Sstevel@tonic-gate 
25260Sstevel@tonic-gate 	case T_ERROR_ACK:
25270Sstevel@tonic-gate 		dprintso(so, 0,
25285753Sgww 		    ("strsock_proto: T_ERROR_ACK for %d, error %d/%d\n",
25295753Sgww 		    tpr->error_ack.ERROR_prim,
25305753Sgww 		    tpr->error_ack.TLI_error,
25315753Sgww 		    tpr->error_ack.UNIX_error));
25320Sstevel@tonic-gate 
25330Sstevel@tonic-gate 		if (MBLKL(mp) < sizeof (struct T_error_ack)) {
25341548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
25350Sstevel@tonic-gate 			    "sockfs: Too short T_ERROR_ACK. Len = %ld\n",
25360Sstevel@tonic-gate 			    (ptrdiff_t)(MBLKL(mp)));
25370Sstevel@tonic-gate 			freemsg(mp);
25380Sstevel@tonic-gate 			return (NULL);
25390Sstevel@tonic-gate 		}
25400Sstevel@tonic-gate 		/*
25410Sstevel@tonic-gate 		 * Check if we were waiting for the async message
25420Sstevel@tonic-gate 		 */
25430Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
25440Sstevel@tonic-gate 		if ((so->so_flag & SOASYNC_UNBIND) &&
25450Sstevel@tonic-gate 		    tpr->error_ack.ERROR_prim == T_UNBIND_REQ) {
25460Sstevel@tonic-gate 			so_unlock_single(so, SOASYNC_UNBIND);
25470Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
25480Sstevel@tonic-gate 			freemsg(mp);
25490Sstevel@tonic-gate 			return (NULL);
25500Sstevel@tonic-gate 		}
25510Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
25520Sstevel@tonic-gate 		soqueueack(so, mp);
25530Sstevel@tonic-gate 		return (NULL);
25540Sstevel@tonic-gate 
25550Sstevel@tonic-gate 	case T_OK_ACK:
25560Sstevel@tonic-gate 		if (MBLKL(mp) < sizeof (struct T_ok_ack)) {
25571548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
25580Sstevel@tonic-gate 			    "sockfs: Too short T_OK_ACK. Len = %ld\n",
25590Sstevel@tonic-gate 			    (ptrdiff_t)(MBLKL(mp)));
25600Sstevel@tonic-gate 			freemsg(mp);
25610Sstevel@tonic-gate 			return (NULL);
25620Sstevel@tonic-gate 		}
25630Sstevel@tonic-gate 		/*
25640Sstevel@tonic-gate 		 * Check if we were waiting for the async message
25650Sstevel@tonic-gate 		 */
25660Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
25670Sstevel@tonic-gate 		if ((so->so_flag & SOASYNC_UNBIND) &&
25680Sstevel@tonic-gate 		    tpr->ok_ack.CORRECT_prim == T_UNBIND_REQ) {
25690Sstevel@tonic-gate 			dprintso(so, 1,
25705753Sgww 			    ("strsock_proto: T_OK_ACK async unbind\n"));
25710Sstevel@tonic-gate 			so_unlock_single(so, SOASYNC_UNBIND);
25720Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
25730Sstevel@tonic-gate 			freemsg(mp);
25740Sstevel@tonic-gate 			return (NULL);
25750Sstevel@tonic-gate 		}
25760Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
25770Sstevel@tonic-gate 		soqueueack(so, mp);
25780Sstevel@tonic-gate 		return (NULL);
25790Sstevel@tonic-gate 
25800Sstevel@tonic-gate 	case T_INFO_ACK:
25810Sstevel@tonic-gate 		if (MBLKL(mp) < sizeof (struct T_info_ack)) {
25821548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
25830Sstevel@tonic-gate 			    "sockfs: Too short T_INFO_ACK. Len = %ld\n",
25840Sstevel@tonic-gate 			    (ptrdiff_t)(MBLKL(mp)));
25850Sstevel@tonic-gate 			freemsg(mp);
25860Sstevel@tonic-gate 			return (NULL);
25870Sstevel@tonic-gate 		}
25880Sstevel@tonic-gate 		soqueueack(so, mp);
25890Sstevel@tonic-gate 		return (NULL);
25900Sstevel@tonic-gate 
25910Sstevel@tonic-gate 	case T_CAPABILITY_ACK:
25920Sstevel@tonic-gate 		/*
25930Sstevel@tonic-gate 		 * A T_capability_ack need only be large enough to hold
25940Sstevel@tonic-gate 		 * the PRIM_type and CAP_bits1 fields; checking for anything
25950Sstevel@tonic-gate 		 * larger might reject a correct response from an older
25960Sstevel@tonic-gate 		 * provider.
25970Sstevel@tonic-gate 		 */
25980Sstevel@tonic-gate 		if (MBLKL(mp) < 2 * sizeof (t_uscalar_t)) {
25991548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
26000Sstevel@tonic-gate 			    "sockfs: Too short T_CAPABILITY_ACK. Len = %ld\n",
26010Sstevel@tonic-gate 			    (ptrdiff_t)(MBLKL(mp)));
26020Sstevel@tonic-gate 			freemsg(mp);
26030Sstevel@tonic-gate 			return (NULL);
26040Sstevel@tonic-gate 		}
26050Sstevel@tonic-gate 		soqueueack(so, mp);
26060Sstevel@tonic-gate 		return (NULL);
26070Sstevel@tonic-gate 
26080Sstevel@tonic-gate 	case T_BIND_ACK:
26090Sstevel@tonic-gate 		if (MBLKL(mp) < sizeof (struct T_bind_ack)) {
26101548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
26110Sstevel@tonic-gate 			    "sockfs: Too short T_BIND_ACK. Len = %ld\n",
26120Sstevel@tonic-gate 			    (ptrdiff_t)(MBLKL(mp)));
26130Sstevel@tonic-gate 			freemsg(mp);
26140Sstevel@tonic-gate 			return (NULL);
26150Sstevel@tonic-gate 		}
26160Sstevel@tonic-gate 		soqueueack(so, mp);
26170Sstevel@tonic-gate 		return (NULL);
26180Sstevel@tonic-gate 
26190Sstevel@tonic-gate 	case T_OPTMGMT_ACK:
26200Sstevel@tonic-gate 		if (MBLKL(mp) < sizeof (struct T_optmgmt_ack)) {
26211548Srshoaib 			zcmn_err(getzoneid(), CE_WARN,
26220Sstevel@tonic-gate 			    "sockfs: Too short T_OPTMGMT_ACK. Len = %ld\n",
26230Sstevel@tonic-gate 			    (ptrdiff_t)(MBLKL(mp)));
26240Sstevel@tonic-gate 			freemsg(mp);
26250Sstevel@tonic-gate 			return (NULL);
26260Sstevel@tonic-gate 		}
26270Sstevel@tonic-gate 		soqueueack(so, mp);
26280Sstevel@tonic-gate 		return (NULL);
26290Sstevel@tonic-gate 	default:
26300Sstevel@tonic-gate #ifdef DEBUG
26311548Srshoaib 		zcmn_err(getzoneid(), CE_WARN,
26325753Sgww 		    "sockfs: unknown TPI primitive %d received\n",
26335753Sgww 		    tpr->type);
26340Sstevel@tonic-gate #endif /* DEBUG */
26350Sstevel@tonic-gate 		freemsg(mp);
26360Sstevel@tonic-gate 		return (NULL);
26370Sstevel@tonic-gate 	}
26380Sstevel@tonic-gate }
26390Sstevel@tonic-gate 
26400Sstevel@tonic-gate /*
26410Sstevel@tonic-gate  * This routine is registered with the stream head to receive other
26420Sstevel@tonic-gate  * (non-data, and non-proto) messages.
26430Sstevel@tonic-gate  *
26440Sstevel@tonic-gate  * Returns NULL if the message was consumed.
26450Sstevel@tonic-gate  * Returns an mblk to make that mblk be processed by the stream head.
26460Sstevel@tonic-gate  *
26470Sstevel@tonic-gate  * Sets the return parameters (*wakeups, *firstmsgsigs, *allmsgsigs, and
26480Sstevel@tonic-gate  * *pollwakeups) for the stream head to take action on.
26490Sstevel@tonic-gate  */
26500Sstevel@tonic-gate static mblk_t *
strsock_misc(vnode_t * vp,mblk_t * mp,strwakeup_t * wakeups,strsigset_t * firstmsgsigs,strsigset_t * allmsgsigs,strpollset_t * pollwakeups)26510Sstevel@tonic-gate strsock_misc(vnode_t *vp, mblk_t *mp,
26520Sstevel@tonic-gate 		strwakeup_t *wakeups, strsigset_t *firstmsgsigs,
26530Sstevel@tonic-gate 		strsigset_t *allmsgsigs, strpollset_t *pollwakeups)
26540Sstevel@tonic-gate {
26550Sstevel@tonic-gate 	struct sonode *so;
26568348SEric.Yu@Sun.COM 	sotpi_info_t *sti;
26570Sstevel@tonic-gate 
26580Sstevel@tonic-gate 	so = VTOSO(vp);
26598348SEric.Yu@Sun.COM 	sti = SOTOTPI(so);
26600Sstevel@tonic-gate 
26610Sstevel@tonic-gate 	dprintso(so, 1, ("strsock_misc(%p, %p, 0x%x)\n",
26627240Srh87107 	    (void *)vp, (void *)mp, DB_TYPE(mp)));
26630Sstevel@tonic-gate 
26640Sstevel@tonic-gate 	/* Set default return values */
26650Sstevel@tonic-gate 	*wakeups = *allmsgsigs = *firstmsgsigs = *pollwakeups = 0;
26660Sstevel@tonic-gate 
26670Sstevel@tonic-gate 	switch (DB_TYPE(mp)) {
26680Sstevel@tonic-gate 	case M_PCSIG:
26690Sstevel@tonic-gate 		/*
26700Sstevel@tonic-gate 		 * This assumes that an M_PCSIG for the urgent data arrives
26710Sstevel@tonic-gate 		 * before the corresponding T_EXDATA_IND.
26720Sstevel@tonic-gate 		 *
26730Sstevel@tonic-gate 		 * Note: Just like in SunOS 4.X and 4.4BSD a poll will be
26740Sstevel@tonic-gate 		 * awoken before the urgent data shows up.
26750Sstevel@tonic-gate 		 * For OOBINLINE this can result in select returning
26760Sstevel@tonic-gate 		 * only exceptions as opposed to except|read.
26770Sstevel@tonic-gate 		 */
26780Sstevel@tonic-gate 		if (*mp->b_rptr == SIGURG) {
26790Sstevel@tonic-gate 			mutex_enter(&so->so_lock);
26800Sstevel@tonic-gate 			dprintso(so, 1,
26815753Sgww 			    ("SIGURG(%p): counts %d/%d state %s\n",
26828348SEric.Yu@Sun.COM 			    (void *)vp, sti->sti_oobsigcnt, sti->sti_oobcnt,
26835753Sgww 			    pr_state(so->so_state, so->so_mode)));
26840Sstevel@tonic-gate 			so_oob_sig(so, 1, allmsgsigs, pollwakeups);
26850Sstevel@tonic-gate 			dprintso(so, 1,
26865753Sgww 			    ("after SIGURG(%p): counts %d/%d "
26875753Sgww 			    " poll 0x%x sig 0x%x state %s\n",
26888348SEric.Yu@Sun.COM 			    (void *)vp, sti->sti_oobsigcnt, sti->sti_oobcnt,
26898348SEric.Yu@Sun.COM 			    *pollwakeups, *allmsgsigs,
26905753Sgww 			    pr_state(so->so_state, so->so_mode)));
26910Sstevel@tonic-gate 			mutex_exit(&so->so_lock);
26920Sstevel@tonic-gate 		}
26930Sstevel@tonic-gate 		freemsg(mp);
26940Sstevel@tonic-gate 		return (NULL);
26950Sstevel@tonic-gate 
26960Sstevel@tonic-gate 	case M_SIG:
26970Sstevel@tonic-gate 	case M_HANGUP:
26980Sstevel@tonic-gate 	case M_UNHANGUP:
26990Sstevel@tonic-gate 	case M_ERROR:
27000Sstevel@tonic-gate 		/* M_ERRORs etc are ignored */
27010Sstevel@tonic-gate 		freemsg(mp);
27020Sstevel@tonic-gate 		return (NULL);
27030Sstevel@tonic-gate 
27040Sstevel@tonic-gate 	case M_FLUSH:
27050Sstevel@tonic-gate 		/*
27060Sstevel@tonic-gate 		 * Do not flush read queue. If the M_FLUSH
27070Sstevel@tonic-gate 		 * arrives because of an impending T_discon_ind
27080Sstevel@tonic-gate 		 * we still have to keep any queued data - this is part of
27090Sstevel@tonic-gate 		 * socket semantics.
27100Sstevel@tonic-gate 		 */
27110Sstevel@tonic-gate 		if (*mp->b_rptr & FLUSHW) {
27120Sstevel@tonic-gate 			*mp->b_rptr &= ~FLUSHR;
27130Sstevel@tonic-gate 			return (mp);
27140Sstevel@tonic-gate 		}
27150Sstevel@tonic-gate 		freemsg(mp);
27160Sstevel@tonic-gate 		return (NULL);
27170Sstevel@tonic-gate 
27180Sstevel@tonic-gate 	default:
27190Sstevel@tonic-gate 		return (mp);
27200Sstevel@tonic-gate 	}
27210Sstevel@tonic-gate }
27220Sstevel@tonic-gate 
27230Sstevel@tonic-gate 
27240Sstevel@tonic-gate /* Register to receive signals for certain events */
27250Sstevel@tonic-gate int
so_set_asyncsigs(vnode_t * vp,pid_t pgrp,int events,int mode,cred_t * cr)27260Sstevel@tonic-gate so_set_asyncsigs(vnode_t *vp, pid_t pgrp, int events, int mode, cred_t *cr)
27270Sstevel@tonic-gate {
27280Sstevel@tonic-gate 	struct strsigset ss;
27290Sstevel@tonic-gate 	int32_t rval;
27300Sstevel@tonic-gate 
27310Sstevel@tonic-gate 	/*
27320Sstevel@tonic-gate 	 * Note that SOLOCKED will be set except for the call from soaccept().
27330Sstevel@tonic-gate 	 */
27340Sstevel@tonic-gate 	ASSERT(!mutex_owned(&VTOSO(vp)->so_lock));
27350Sstevel@tonic-gate 	ss.ss_pid = pgrp;
27360Sstevel@tonic-gate 	ss.ss_events = events;
27370Sstevel@tonic-gate 	return (strioctl(vp, I_ESETSIG, (intptr_t)&ss, mode, K_TO_K, cr,
27380Sstevel@tonic-gate 	    &rval));
27390Sstevel@tonic-gate }
27400Sstevel@tonic-gate 
27410Sstevel@tonic-gate 
27420Sstevel@tonic-gate /* Register for events matching the SS_ASYNC flag */
27430Sstevel@tonic-gate int
so_set_events(struct sonode * so,vnode_t * vp,cred_t * cr)27440Sstevel@tonic-gate so_set_events(struct sonode *so, vnode_t *vp, cred_t *cr)
27450Sstevel@tonic-gate {
27460Sstevel@tonic-gate 	int events = so->so_state & SS_ASYNC ?
27470Sstevel@tonic-gate 	    S_RDBAND | S_BANDURG | S_RDNORM | S_OUTPUT :
27480Sstevel@tonic-gate 	    S_RDBAND | S_BANDURG;
27490Sstevel@tonic-gate 
27500Sstevel@tonic-gate 	return (so_set_asyncsigs(vp, so->so_pgrp, events, 0, cr));
27510Sstevel@tonic-gate }
27520Sstevel@tonic-gate 
27530Sstevel@tonic-gate 
27540Sstevel@tonic-gate /* Change the SS_ASYNC flag, and update signal delivery if needed */
27550Sstevel@tonic-gate int
so_flip_async(struct sonode * so,vnode_t * vp,int mode,cred_t * cr)27560Sstevel@tonic-gate so_flip_async(struct sonode *so, vnode_t *vp, int mode, cred_t *cr)
27570Sstevel@tonic-gate {
27580Sstevel@tonic-gate 	ASSERT(mutex_owned(&so->so_lock));
27590Sstevel@tonic-gate 	if (so->so_pgrp != 0) {
27600Sstevel@tonic-gate 		int error;
27610Sstevel@tonic-gate 		int events = so->so_state & SS_ASYNC ?		/* Old flag */
27620Sstevel@tonic-gate 		    S_RDBAND | S_BANDURG :			/* New sigs */
27630Sstevel@tonic-gate 		    S_RDBAND | S_BANDURG | S_RDNORM | S_OUTPUT;
27640Sstevel@tonic-gate 
27650Sstevel@tonic-gate 		so_lock_single(so);
27660Sstevel@tonic-gate 		mutex_exit(&so->so_lock);
27670Sstevel@tonic-gate 
27680Sstevel@tonic-gate 		error = so_set_asyncsigs(vp, so->so_pgrp, events, mode, cr);
27690Sstevel@tonic-gate 
27700Sstevel@tonic-gate 		mutex_enter(&so->so_lock);
27710Sstevel@tonic-gate 		so_unlock_single(so, SOLOCKED);
27720Sstevel@tonic-gate 		if (error)
27730Sstevel@tonic-gate 			return (error);
27740Sstevel@tonic-gate 	}
27750Sstevel@tonic-gate 	so->so_state ^= SS_ASYNC;
27760Sstevel@tonic-gate 	return (0);
27770Sstevel@tonic-gate }
27780Sstevel@tonic-gate 
27790Sstevel@tonic-gate /*
27800Sstevel@tonic-gate  * Set new pid/pgrp for SIGPOLL (or SIGIO for FIOASYNC mode), replacing
27810Sstevel@tonic-gate  * any existing one.  If passed zero, just clear the existing one.
27820Sstevel@tonic-gate  */
27830Sstevel@tonic-gate int
so_set_siggrp(struct sonode * so,vnode_t * vp,pid_t pgrp,int mode,cred_t * cr)27840Sstevel@tonic-gate so_set_siggrp(struct sonode *so, vnode_t *vp, pid_t pgrp, int mode, cred_t *cr)
27850Sstevel@tonic-gate {
27860Sstevel@tonic-gate 	int events = so->so_state & SS_ASYNC ?
27870Sstevel@tonic-gate 	    S_RDBAND | S_BANDURG | S_RDNORM | S_OUTPUT :
27880Sstevel@tonic-gate 	    S_RDBAND | S_BANDURG;
27890Sstevel@tonic-gate 	int error;
27900Sstevel@tonic-gate 
27910Sstevel@tonic-gate 	ASSERT(mutex_owned(&so->so_lock));
27920Sstevel@tonic-gate 
27930Sstevel@tonic-gate 	/*
27940Sstevel@tonic-gate 	 * Change socket process (group).
27950Sstevel@tonic-gate 	 *
27960Sstevel@tonic-gate 	 * strioctl (via so_set_asyncsigs) will perform permission check and
27970Sstevel@tonic-gate 	 * also keep a PID_HOLD to prevent the pid from being reused.
27980Sstevel@tonic-gate 	 */
27990Sstevel@tonic-gate 	so_lock_single(so);
28000Sstevel@tonic-gate 	mutex_exit(&so->so_lock);
28010Sstevel@tonic-gate 
28020Sstevel@tonic-gate 	if (pgrp != 0) {
28030Sstevel@tonic-gate 		dprintso(so, 1, ("setown: adding pgrp %d ev 0x%x\n",
28040Sstevel@tonic-gate 		    pgrp, events));
28050Sstevel@tonic-gate 		error = so_set_asyncsigs(vp, pgrp, events, mode, cr);
28060Sstevel@tonic-gate 		if (error != 0) {
28070Sstevel@tonic-gate 			eprintsoline(so, error);
28080Sstevel@tonic-gate 			goto bad;
28090Sstevel@tonic-gate 		}
28100Sstevel@tonic-gate 	}
28110Sstevel@tonic-gate 	/* Remove the previously registered process/group */
28120Sstevel@tonic-gate 	if (so->so_pgrp != 0) {
28130Sstevel@tonic-gate 		dprintso(so, 1, ("setown: removing pgrp %d\n", so->so_pgrp));
28140Sstevel@tonic-gate 		error = so_set_asyncsigs(vp, so->so_pgrp, 0, mode, cr);
28150Sstevel@tonic-gate 		if (error != 0) {
28160Sstevel@tonic-gate 			eprintsoline(so, error);
28170Sstevel@tonic-gate 			error = 0;
28180Sstevel@tonic-gate 		}
28190Sstevel@tonic-gate 	}
28200Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
28210Sstevel@tonic-gate 	so_unlock_single(so, SOLOCKED);
28220Sstevel@tonic-gate 	so->so_pgrp = pgrp;
28230Sstevel@tonic-gate 	return (0);
28240Sstevel@tonic-gate bad:
28250Sstevel@tonic-gate 	mutex_enter(&so->so_lock);
28260Sstevel@tonic-gate 	so_unlock_single(so, SOLOCKED);
28270Sstevel@tonic-gate 	return (error);
28280Sstevel@tonic-gate }
28290Sstevel@tonic-gate 
28308348SEric.Yu@Sun.COM /*
28318348SEric.Yu@Sun.COM  * Wrapper for getmsg. If the socket has been converted to a stream
28328348SEric.Yu@Sun.COM  * pass the request to the stream head.
28338348SEric.Yu@Sun.COM  */
28348348SEric.Yu@Sun.COM int
sock_getmsg(struct vnode * vp,struct strbuf * mctl,struct strbuf * mdata,uchar_t * prip,int * flagsp,int fmode,rval_t * rvp)28358348SEric.Yu@Sun.COM sock_getmsg(
28368348SEric.Yu@Sun.COM 	struct vnode *vp,
28378348SEric.Yu@Sun.COM 	struct strbuf *mctl,
28388348SEric.Yu@Sun.COM 	struct strbuf *mdata,
28398348SEric.Yu@Sun.COM 	uchar_t *prip,
28408348SEric.Yu@Sun.COM 	int *flagsp,
28418348SEric.Yu@Sun.COM 	int fmode,
28428348SEric.Yu@Sun.COM 	rval_t *rvp
28438348SEric.Yu@Sun.COM )
28448348SEric.Yu@Sun.COM {
28458348SEric.Yu@Sun.COM 	struct sonode *so;
28460Sstevel@tonic-gate 
28478348SEric.Yu@Sun.COM 	ASSERT(vp->v_type == VSOCK);
28488348SEric.Yu@Sun.COM 	/*
28498348SEric.Yu@Sun.COM 	 * Use the stream head to find the real socket vnode.
28508348SEric.Yu@Sun.COM 	 * This is needed when namefs sits above sockfs.  Some
28518348SEric.Yu@Sun.COM 	 * sockets (like SCTP) are not streams.
28528348SEric.Yu@Sun.COM 	 */
28538348SEric.Yu@Sun.COM 	if (!vp->v_stream) {
28548348SEric.Yu@Sun.COM 		return (ENOSTR);
28558348SEric.Yu@Sun.COM 	}
28568348SEric.Yu@Sun.COM 	ASSERT(vp->v_stream->sd_vnode);
28578348SEric.Yu@Sun.COM 	vp = vp->v_stream->sd_vnode;
28588348SEric.Yu@Sun.COM 	ASSERT(vn_matchops(vp, socket_vnodeops));
28598348SEric.Yu@Sun.COM 	so = VTOSO(vp);
28608348SEric.Yu@Sun.COM 
28618348SEric.Yu@Sun.COM 	dprintso(so, 1, ("sock_getmsg(%p) %s\n",
28628348SEric.Yu@Sun.COM 	    (void *)so, pr_state(so->so_state, so->so_mode)));
28638348SEric.Yu@Sun.COM 
28648348SEric.Yu@Sun.COM 	if (so->so_version == SOV_STREAM) {
28658348SEric.Yu@Sun.COM 		/* The imaginary "sockmod" has been popped - act as a stream */
28668348SEric.Yu@Sun.COM 		return (strgetmsg(vp, mctl, mdata, prip, flagsp, fmode, rvp));
28678348SEric.Yu@Sun.COM 	}
28688348SEric.Yu@Sun.COM 	eprintsoline(so, ENOSTR);
28698348SEric.Yu@Sun.COM 	return (ENOSTR);
28708348SEric.Yu@Sun.COM }
28710Sstevel@tonic-gate 
28720Sstevel@tonic-gate /*
28738348SEric.Yu@Sun.COM  * Wrapper for putmsg. If the socket has been converted to a stream
28748348SEric.Yu@Sun.COM  * pass the request to the stream head.
28758348SEric.Yu@Sun.COM  *
28768348SEric.Yu@Sun.COM  * Note that a while a regular socket (SOV_SOCKSTREAM) does support the
28778348SEric.Yu@Sun.COM  * streams ioctl set it does not support putmsg and getmsg.
28788348SEric.Yu@Sun.COM  * Allowing putmsg would prevent sockfs from tracking the state of
28798348SEric.Yu@Sun.COM  * the socket/transport and would also invalidate the locking in sockfs.
28800Sstevel@tonic-gate  */
28818348SEric.Yu@Sun.COM int
sock_putmsg(struct vnode * vp,struct strbuf * mctl,struct strbuf * mdata,uchar_t pri,int flag,int fmode)28828348SEric.Yu@Sun.COM sock_putmsg(
28838348SEric.Yu@Sun.COM 	struct vnode *vp,
28848348SEric.Yu@Sun.COM 	struct strbuf *mctl,
28858348SEric.Yu@Sun.COM 	struct strbuf *mdata,
28868348SEric.Yu@Sun.COM 	uchar_t pri,
28878348SEric.Yu@Sun.COM 	int flag,
28888348SEric.Yu@Sun.COM 	int fmode
28898348SEric.Yu@Sun.COM )
28908348SEric.Yu@Sun.COM {
28918348SEric.Yu@Sun.COM 	struct sonode *so;
28928348SEric.Yu@Sun.COM 
28938348SEric.Yu@Sun.COM 	ASSERT(vp->v_type == VSOCK);
28948348SEric.Yu@Sun.COM 	/*
28958348SEric.Yu@Sun.COM 	 * Use the stream head to find the real socket vnode.
28968348SEric.Yu@Sun.COM 	 * This is needed when namefs sits above sockfs.
28978348SEric.Yu@Sun.COM 	 */
28988348SEric.Yu@Sun.COM 	if (!vp->v_stream) {
28998348SEric.Yu@Sun.COM 		return (ENOSTR);
29008348SEric.Yu@Sun.COM 	}
29018348SEric.Yu@Sun.COM 	ASSERT(vp->v_stream->sd_vnode);
29028348SEric.Yu@Sun.COM 	vp = vp->v_stream->sd_vnode;
29038348SEric.Yu@Sun.COM 	ASSERT(vn_matchops(vp, socket_vnodeops));
29048348SEric.Yu@Sun.COM 	so = VTOSO(vp);
29058348SEric.Yu@Sun.COM 
29068348SEric.Yu@Sun.COM 	dprintso(so, 1, ("sock_putmsg(%p) %s\n",
29078348SEric.Yu@Sun.COM 	    (void *)so, pr_state(so->so_state, so->so_mode)));
29080Sstevel@tonic-gate 
29098348SEric.Yu@Sun.COM 	if (so->so_version == SOV_STREAM) {
29108348SEric.Yu@Sun.COM 		/* The imaginary "sockmod" has been popped - act as a stream */
29118348SEric.Yu@Sun.COM 		return (strputmsg(vp, mctl, mdata, pri, flag, fmode));
29128348SEric.Yu@Sun.COM 	}
29138348SEric.Yu@Sun.COM 	eprintsoline(so, ENOSTR);
29148348SEric.Yu@Sun.COM 	return (ENOSTR);
29158348SEric.Yu@Sun.COM }
29168348SEric.Yu@Sun.COM 
29178348SEric.Yu@Sun.COM /*
29188348SEric.Yu@Sun.COM  * Special function called only from f_getfl().
29198348SEric.Yu@Sun.COM  * Returns FASYNC if the SS_ASYNC flag is set on a socket, else 0.
29208348SEric.Yu@Sun.COM  * No locks are acquired here, so it is safe to use while uf_lock is held.
29218348SEric.Yu@Sun.COM  * This exists solely for BSD fcntl() FASYNC compatibility.
29228348SEric.Yu@Sun.COM  */
29238348SEric.Yu@Sun.COM int
sock_getfasync(vnode_t * vp)29248348SEric.Yu@Sun.COM sock_getfasync(vnode_t *vp)
29250Sstevel@tonic-gate {
29268348SEric.Yu@Sun.COM 	struct sonode *so;
29278348SEric.Yu@Sun.COM 
29288348SEric.Yu@Sun.COM 	ASSERT(vp->v_type == VSOCK);
29298348SEric.Yu@Sun.COM 	/*
29308348SEric.Yu@Sun.COM 	 * For stream model, v_stream is used; For non-stream, v_stream always
29318348SEric.Yu@Sun.COM 	 * equals NULL
29328348SEric.Yu@Sun.COM 	 */
29338348SEric.Yu@Sun.COM 	if (vp->v_stream != NULL)
29348348SEric.Yu@Sun.COM 		so = VTOSO(vp->v_stream->sd_vnode);
29350Sstevel@tonic-gate 	else
29368348SEric.Yu@Sun.COM 		so = VTOSO(vp);
29378348SEric.Yu@Sun.COM 
29388348SEric.Yu@Sun.COM 	if (so->so_version == SOV_STREAM || !(so->so_state & SS_ASYNC))
29398348SEric.Yu@Sun.COM 		return (0);
29408348SEric.Yu@Sun.COM 
29418348SEric.Yu@Sun.COM 	return (FASYNC);
29420Sstevel@tonic-gate }
2943