1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22
23 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
24 /* All Rights Reserved */
25
26 /*
27 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
28 * Use is subject to license terms.
29 * Copyright 2014 Gary Mills
30 */
31
32 #include "mt.h"
33 #include <errno.h>
34 #include <unistd.h>
35 #include <sys/stream.h>
36 #include <stropts.h>
37 #define _SUN_TPI_VERSION 2
38 #include <sys/tihdr.h>
39 #include <sys/timod.h>
40 #include <xti.h>
41 #include <assert.h>
42 #include "tx.h"
43
44 int
45 _tx_look(int fd, int api_semantics)
46 {
47 int state;
48 int sv_errno;
49 int do_expinline_peek; /* unusual XTI specific processing */
50 struct _ti_user *tiptr;
51
52 if ((tiptr = _t_checkfd(fd, 0, api_semantics)) == NULL)
53 return (-1);
54 sig_mutex_lock(&tiptr->ti_lock);
55
56 if (_T_IS_XTI(api_semantics))
57 do_expinline_peek = 1;
58 else
59 do_expinline_peek = 0;
60 state = _t_look_locked(fd, tiptr, do_expinline_peek, api_semantics);
61
62 sv_errno = errno;
63
64 sig_mutex_unlock(&tiptr->ti_lock);
65 errno = sv_errno;
66 return (state);
67 }
68
69 /*
70 * _t_look_locked() assumes tiptr->ti_lock lock is already held and signals
71 * already blocked in MT case.
72 * Intended for use by other TLI routines only.
73 */
74 int
75 _t_look_locked(
76 int fd,
77 struct _ti_user *tiptr,
78 int do_expinline_peek,
79 int api_semantics
80 )
81 {
82 struct strpeek strpeek;
83 int retval;
84 union T_primitives *pptr;
85 t_scalar_t type;
86 t_scalar_t ctltype;
87
88 assert(MUTEX_HELD(&tiptr->ti_lock));
89
90 #ifdef notyet
91 if (_T_IS_XTI(api_semantics)) {
92 /*
93 * XTI requires the strange T_GODATA and T_GOEXDATA
94 * events which are almost brain-damaged but thankfully
95 * not tested. Anyone feeling the need for those should
96 * consider the need for using non-blocking endpoint.
97 * Probably introduced at the behest of some weird-os
98 * vendor which did not understand the non-blocking endpoint
99 * option.
100 * We choose not to implment these mis-features.
101 * Here is the plan-of-action (POA)if we are ever forced
102 * to implement these.
103 * - When returning TFLOW set state to indicate if it was
104 * a normal or expedited data send attempt.
105 * - In routines that set TFLOW, clear the above set state
106 * on each entry/reentry
107 * - In this routine, if that state flag is set,
108 * do a I_CANPUT on appropriate band to to see if it
109 * is writeable. If that indicates that the band is
110 * writeable, return T_GODATA or T_GOEXDATA event.
111 *
112 * Actions are also influenced by whether T_EXDATA_REQ stays
113 * band 1 or goes to band 0 if EXPINLINE is set
114 *
115 * We will also need to sort out if "write side" events
116 * (such as T_GODATA/T_GOEXDATA) take precedence over
117 * all other events (all read side) or not.
118 */
119 }
120 #endif /* notyet */
121
122 strpeek.ctlbuf.maxlen = (int)sizeof (ctltype);
123 strpeek.ctlbuf.len = 0;
124 strpeek.ctlbuf.buf = (char *)&ctltype;
125 strpeek.databuf.maxlen = 0;
126 strpeek.databuf.len = 0;
127 strpeek.databuf.buf = NULL;
128 strpeek.flags = 0;
129
130 do {
131 retval = ioctl(fd, I_PEEK, &strpeek);
132 } while (retval < 0 && errno == EINTR);
133
134 if (retval < 0) {
135 /*
136 * XTI semantics (also identical to documented
137 * TLI semantics).
138 */
139 t_errno = TSYSERR;
140 return (-1);
141 }
142
143 /*
144 * if something there and cntl part also there
145 */
146 if ((tiptr->ti_lookcnt > 0) ||
147 ((retval > 0) && (strpeek.ctlbuf.len >=
148 (int)sizeof (t_scalar_t)))) {
149 /* LINTED pointer cast */
150 pptr = (union T_primitives *)strpeek.ctlbuf.buf;
151 if (tiptr->ti_lookcnt > 0) {
152 /* LINTED pointer cast */
153 type = *((t_scalar_t *)tiptr->ti_lookbufs.tl_lookcbuf);
154 /*
155 * If message on stream head is a T_DISCON_IND, that
156 * has priority over a T_ORDREL_IND in the look
157 * buffer.
158 * (This assumes that T_ORDREL_IND can only be in the
159 * first look buffer in the list)
160 */
161 if ((type == T_ORDREL_IND) && retval &&
162 (pptr->type == T_DISCON_IND)) {
163 type = pptr->type;
164 /*
165 * Blow away T_ORDREL_IND
166 */
167 _t_free_looklist_head(tiptr);
168 }
169 } else
170 type = pptr->type;
171
172 switch (type) {
173
174 case T_CONN_IND:
175 return (T_LISTEN);
176
177 case T_CONN_CON:
178 return (T_CONNECT);
179
180 case T_DISCON_IND:
181 return (T_DISCONNECT);
182
183 case T_DATA_IND: {
184 int event = T_DATA;
185 int retval, exp_on_q;
186
187 if (do_expinline_peek &&
188 (tiptr->ti_prov_flag & EXPINLINE)) {
189 assert(_T_IS_XTI(api_semantics));
190 retval = _t_expinline_queued(fd, &exp_on_q);
191 if (retval < 0) {
192 t_errno = TSYSERR;
193 return (-1);
194 }
195 if (exp_on_q)
196 event = T_EXDATA;
197 }
198 return (event);
199 }
200
201 case T_UNITDATA_IND:
202 return (T_DATA);
203
204 case T_EXDATA_IND:
205 return (T_EXDATA);
206
207 case T_UDERROR_IND:
208 return (T_UDERR);
209
210 case T_ORDREL_IND:
211 return (T_ORDREL);
212
213 default:
214 t_errno = TSYSERR;
215 errno = EPROTO;
216 return (-1);
217 }
218 }
219
220 /*
221 * if something there put no control part
222 * it must be data on the stream head.
223 */
224 if ((retval > 0) && (strpeek.ctlbuf.len <= 0)) {
225 int event = T_DATA;
226 int retval, exp_on_q;
227
228 if (do_expinline_peek &&
229 (tiptr->ti_prov_flag & EXPINLINE)) {
230 assert(_T_IS_XTI(api_semantics));
231 retval = _t_expinline_queued(fd, &exp_on_q);
232 if (retval < 0)
233 return (-1);
234 if (exp_on_q)
235 event = T_EXDATA;
236 }
237 return (event);
238 }
239
240 /*
241 * if msg there and control
242 * part not large enough to determine type?
243 * it must be illegal TLI message
244 */
245 if ((retval > 0) && (strpeek.ctlbuf.len > 0)) {
246 t_errno = TSYSERR;
247 errno = EPROTO;
248 return (-1);
249 }
250 return (0);
251 }