/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ /* * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. * Copyright 2014 Gary Mills */ #include "mt.h" #include <errno.h> #include <unistd.h> #include <sys/stream.h> #include <stropts.h> #define _SUN_TPI_VERSION 2 #include <sys/tihdr.h> #include <sys/timod.h> #include <xti.h> #include <assert.h> #include "tx.h" int _tx_look(int fd, int api_semantics) { int state; int sv_errno; int do_expinline_peek; /* unusual XTI specific processing */ struct _ti_user *tiptr; if ((tiptr = _t_checkfd(fd, 0, api_semantics)) == NULL) return (-1); sig_mutex_lock(&tiptr->ti_lock); if (_T_IS_XTI(api_semantics)) do_expinline_peek = 1; else do_expinline_peek = 0; state = _t_look_locked(fd, tiptr, do_expinline_peek, api_semantics); sv_errno = errno; sig_mutex_unlock(&tiptr->ti_lock); errno = sv_errno; return (state); } /* * _t_look_locked() assumes tiptr->ti_lock lock is already held and signals * already blocked in MT case. * Intended for use by other TLI routines only. */ int _t_look_locked( int fd, struct _ti_user *tiptr, int do_expinline_peek, int api_semantics ) { struct strpeek strpeek; int retval; union T_primitives *pptr; t_scalar_t type; t_scalar_t ctltype; assert(MUTEX_HELD(&tiptr->ti_lock)); #ifdef notyet if (_T_IS_XTI(api_semantics)) { /* * XTI requires the strange T_GODATA and T_GOEXDATA * events which are almost brain-damaged but thankfully * not tested. Anyone feeling the need for those should * consider the need for using non-blocking endpoint. * Probably introduced at the behest of some weird-os * vendor which did not understand the non-blocking endpoint * option. * We choose not to implment these mis-features. * Here is the plan-of-action (POA)if we are ever forced * to implement these. * - When returning TFLOW set state to indicate if it was * a normal or expedited data send attempt. * - In routines that set TFLOW, clear the above set state * on each entry/reentry * - In this routine, if that state flag is set, * do a I_CANPUT on appropriate band to to see if it * is writeable. If that indicates that the band is * writeable, return T_GODATA or T_GOEXDATA event. * * Actions are also influenced by whether T_EXDATA_REQ stays * band 1 or goes to band 0 if EXPINLINE is set * * We will also need to sort out if "write side" events * (such as T_GODATA/T_GOEXDATA) take precedence over * all other events (all read side) or not. */ } #endif /* notyet */ strpeek.ctlbuf.maxlen = (int)sizeof (ctltype); strpeek.ctlbuf.len = 0; strpeek.ctlbuf.buf = (char *)&ctltype; strpeek.databuf.maxlen = 0; strpeek.databuf.len = 0; strpeek.databuf.buf = NULL; strpeek.flags = 0; do { retval = ioctl(fd, I_PEEK, &strpeek); } while (retval < 0 && errno == EINTR); if (retval < 0) { /* * XTI semantics (also identical to documented * TLI semantics). */ t_errno = TSYSERR; return (-1); } /* * if something there and cntl part also there */ if ((tiptr->ti_lookcnt > 0) || ((retval > 0) && (strpeek.ctlbuf.len >= (int)sizeof (t_scalar_t)))) { /* LINTED pointer cast */ pptr = (union T_primitives *)strpeek.ctlbuf.buf; if (tiptr->ti_lookcnt > 0) { /* LINTED pointer cast */ type = *((t_scalar_t *)tiptr->ti_lookbufs.tl_lookcbuf); /* * If message on stream head is a T_DISCON_IND, that * has priority over a T_ORDREL_IND in the look * buffer. * (This assumes that T_ORDREL_IND can only be in the * first look buffer in the list) */ if ((type == T_ORDREL_IND) && retval && (pptr->type == T_DISCON_IND)) { type = pptr->type; /* * Blow away T_ORDREL_IND */ _t_free_looklist_head(tiptr); } } else type = pptr->type; switch (type) { case T_CONN_IND: return (T_LISTEN); case T_CONN_CON: return (T_CONNECT); case T_DISCON_IND: return (T_DISCONNECT); case T_DATA_IND: { int event = T_DATA; int retval, exp_on_q; if (do_expinline_peek && (tiptr->ti_prov_flag & EXPINLINE)) { assert(_T_IS_XTI(api_semantics)); retval = _t_expinline_queued(fd, &exp_on_q); if (retval < 0) { t_errno = TSYSERR; return (-1); } if (exp_on_q) event = T_EXDATA; } return (event); } case T_UNITDATA_IND: return (T_DATA); case T_EXDATA_IND: return (T_EXDATA); case T_UDERROR_IND: return (T_UDERR); case T_ORDREL_IND: return (T_ORDREL); default: t_errno = TSYSERR; errno = EPROTO; return (-1); } } /* * if something there put no control part * it must be data on the stream head. */ if ((retval > 0) && (strpeek.ctlbuf.len <= 0)) { int event = T_DATA; int retval, exp_on_q; if (do_expinline_peek && (tiptr->ti_prov_flag & EXPINLINE)) { assert(_T_IS_XTI(api_semantics)); retval = _t_expinline_queued(fd, &exp_on_q); if (retval < 0) return (-1); if (exp_on_q) event = T_EXDATA; } return (event); } /* * if msg there and control * part not large enough to determine type? * it must be illegal TLI message */ if ((retval > 0) && (strpeek.ctlbuf.len > 0)) { t_errno = TSYSERR; errno = EPROTO; return (-1); } return (0); }
