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 */
30
31 /*
32 * t_rcv.c and t_rcvv.c are very similar and contain common code.
33 * Any changes to either of them should be reviewed to see whether they
34 * are applicable to the other file.
35 */
36 #include "mt.h"
37 #include <stdlib.h>
38 #include <errno.h>
39 #include <unistd.h>
40 #include <stropts.h>
41 #include <sys/stream.h>
42 #define _SUN_TPI_VERSION 2
43 #include <sys/tihdr.h>
44 #include <sys/timod.h>
45 #include <xti.h>
46 #include <syslog.h>
47 #include <assert.h>
48 #include "tx.h"
49
50 int
_tx_rcv(int fd,char * buf,unsigned nbytes,int * flags,int api_semantics)51 _tx_rcv(int fd, char *buf, unsigned nbytes, int *flags, int api_semantics)
52 {
53 struct strbuf ctlbuf, databuf;
54 int retval, flg = 0;
55 int msglen;
56 union T_primitives *pptr;
57 struct _ti_user *tiptr;
58 int sv_errno;
59 int didalloc;
60
61 if ((tiptr = _t_checkfd(fd, 0, api_semantics)) == NULL)
62 return (-1);
63 sig_mutex_lock(&tiptr->ti_lock);
64
65 if (tiptr->ti_servtype == T_CLTS) {
66 t_errno = TNOTSUPPORT;
67 sig_mutex_unlock(&tiptr->ti_lock);
68 return (-1);
69 }
70
71 if (_T_IS_XTI(api_semantics)) {
72 /*
73 * User level state verification only done for XTI
74 * because doing for TLI may break existing applications
75 */
76 if (!(tiptr->ti_state == T_DATAXFER ||
77 tiptr->ti_state == T_OUTREL)) {
78 t_errno = TOUTSTATE;
79 sig_mutex_unlock(&tiptr->ti_lock);
80 return (-1);
81 }
82 }
83
84 /*
85 * Check in lookbuf for stuff
86 */
87 if (tiptr->ti_lookcnt > 0) {
88 /*
89 * Implied preference rules give priority to
90 * T_DISCON_IND over T_ORDREL_IND. Also certain errors like
91 * data received after T_ORDREL_IND or a duplicate T_ORDREL_IND
92 * after a T_ORDRELING have priority over TLOOK.
93 * This manifests in following code behavior.
94 *
95 * (1) If something in lookbuf then check
96 * the stream head also. This may result
97 * in retuning a TLOOK error but only if there are
98 * - message at stream head but look buffer
99 * has a T_DISCON_IND event.
100 * - no messages are on the stream head
101 *
102 * (2) If there are messages on the stream head and
103 * all of them are T_ORDREL_IND(i.e. no message in
104 * look buffer is T_DISCON_IND), there
105 * could be data on stream head to be picked up and
106 * we work on the stream head and not return TLOOK.
107 * We remove the event on the stream head and queue it.
108 *
109 */
110 do {
111 retval = ioctl(fd, I_NREAD, &msglen);
112 } while (retval < 0 && errno == EINTR);
113
114 if (retval < 0) {
115 sv_errno = errno;
116
117 t_errno = TSYSERR;
118 sig_mutex_unlock(&tiptr->ti_lock);
119 errno = sv_errno;
120 return (-1);
121 }
122
123 if (retval > 0) {
124 /*
125 * If any T_DISCON_IND event in look buffer
126 * list then return TLOOK. Else continue
127 * processing as what could be on the stream
128 * head might be a possible T_DISCON_IND (which
129 * would have priority over the T_ORDREL_INDs
130 * on the look buffer.)
131 */
132 struct _ti_lookbufs *tlbs;
133
134 tlbs = &tiptr->ti_lookbufs;
135 do {
136 /* LINTED pointer cast */
137 if (*((t_scalar_t *)tlbs->tl_lookcbuf)
138 == T_DISCON_IND) {
139 t_errno = TLOOK;
140 sig_mutex_unlock(&tiptr->ti_lock);
141 return (-1);
142 }
143 } while ((tlbs = tlbs->tl_next) != NULL);
144
145 } else { /* retval == 0 */
146 /*
147 * Nothing on stream head so whatever in
148 * look buffer has nothing that might override
149 * it.
150 */
151 t_errno = TLOOK;
152 sig_mutex_unlock(&tiptr->ti_lock);
153 return (-1);
154 }
155 }
156
157 /*
158 * Acquire ctlbuf for use in sending/receiving control part
159 * of the message.
160 */
161 if (_t_acquire_ctlbuf(tiptr, &ctlbuf, &didalloc) < 0) {
162 sv_errno = errno;
163 sig_mutex_unlock(&tiptr->ti_lock);
164 errno = sv_errno;
165 return (-1);
166 }
167
168 databuf.maxlen = nbytes;
169 databuf.len = 0;
170 databuf.buf = buf;
171
172 *flags = 0;
173
174 /*
175 * This is a call that may block indefinitely so we drop the
176 * lock and allow signals in MT case here and reacquire it.
177 * Error case should roll back state changes done above
178 * (happens to be no state change here)
179 */
180 sig_mutex_unlock(&tiptr->ti_lock);
181 if ((retval = getmsg(fd, &ctlbuf, &databuf, &flg)) < 0) {
182 if (errno == EAGAIN)
183 t_errno = TNODATA;
184 else
185 t_errno = TSYSERR;
186 sv_errno = errno;
187 sig_mutex_lock(&tiptr->ti_lock);
188 errno = sv_errno;
189 goto err_out;
190 }
191 sig_mutex_lock(&tiptr->ti_lock);
192
193 assert((retval & MORECTL) == 0); /* MORECTL should not be on */
194
195 if (databuf.len == -1) databuf.len = 0;
196
197 if (ctlbuf.len > 0) {
198 if (ctlbuf.len < (int)sizeof (t_scalar_t)) {
199 t_errno = TSYSERR;
200 errno = EPROTO;
201 goto err_out;
202 }
203
204 /* LINTED pointer cast */
205 pptr = (union T_primitives *)ctlbuf.buf;
206
207 switch (pptr->type) {
208
209 case T_EXDATA_IND:
210 *flags |= T_EXPEDITED;
211 if (retval > 0)
212 tiptr->ti_flags |= EXPEDITED;
213 /* FALLTHROUGH */
214 case T_DATA_IND:
215 /*
216 * Uses the fact T_DATA_IND and T_EXDATA_IND
217 * are same in size
218 */
219 if ((ctlbuf.len < (int)sizeof (struct T_data_ind)) ||
220 (tiptr->ti_lookcnt > 0)) {
221 /*
222 * ti_lookcnt > 0 implies data
223 * received after T_DISCON_IND or
224 * T_ORDREL_IND hence error
225 */
226 t_errno = TSYSERR;
227 errno = EPROTO;
228 goto err_out;
229 }
230
231 if ((pptr->data_ind.MORE_flag) || retval)
232 *flags |= T_MORE;
233 if ((pptr->data_ind.MORE_flag) && retval)
234 tiptr->ti_flags |= MORE;
235 /*
236 * No real state change on T_RCV event (noop)
237 *
238 * We invoke the macro only for error logging
239 * part of its capabilities when in a bad state.
240 */
241 _T_TX_NEXTSTATE(T_RCV, tiptr,
242 "t_rcv: invalid state event T_RCV");
243 if (didalloc)
244 free(ctlbuf.buf);
245 else
246 tiptr->ti_ctlbuf = ctlbuf.buf;
247 sig_mutex_unlock(&tiptr->ti_lock);
248 return (databuf.len);
249
250 case T_ORDREL_IND:
251 if (tiptr->ti_lookcnt > 0) {
252 /*
253 * ti_lookcnt > 0 implies T_ORDREL_IND
254 * received after T_DISCON_IND or
255 * another T_ORDREL_IND hence error.
256 */
257 t_errno = TSYSERR;
258 errno = EPROTO;
259 goto err_out;
260 }
261 /* FALLTHROUGH */
262 case T_DISCON_IND:
263 /*
264 * Post event (T_ORDREL_IND/T_DISCON_IND) to
265 * the lookbuffer list.
266 */
267
268 if (_t_register_lookevent(tiptr, databuf.buf,
269 databuf.len,
270 ctlbuf.buf, ctlbuf.len) < 0) {
271 t_errno = TSYSERR;
272 errno = ENOMEM;
273 goto err_out;
274 }
275 /*
276 * We know that T_DISCON_IND is stored in
277 * last look buffer. If there is more data
278 * that follows, we try to append it to
279 * the same look buffer
280 */
281 if (retval & MOREDATA) {
282 ctlbuf.maxlen = 0; /* XXX why ? */
283 ctlbuf.len = 0;
284
285 /*
286 * XXX Will break (-ve maxlen) for
287 * transport provider with unbounded
288 * T_DISCON_IND data part (-1).
289 */
290 databuf.maxlen =
291 tiptr->ti_rcvsize - databuf.len;
292
293 databuf.len = 0;
294 databuf.buf =
295 tiptr->ti_lookbufs.tl_lookdbuf +
296 tiptr->ti_lookbufs.tl_lookdlen;
297 *flags = 0;
298
299 /*
300 * Since MOREDATA was set, we assume
301 * that this getmsg will not block
302 * indefinitely
303 */
304 do {
305 retval = getmsg(fd, &ctlbuf,
306 &databuf, &flg);
307 } while (retval < 0 && errno == EINTR);
308
309 if (retval < 0) {
310 t_errno = TSYSERR;
311 goto err_out;
312 }
313 if (databuf.len == -1) databuf.len = 0;
314 if (retval > 0) {
315 /* MORECTL should not be on */
316 assert((retval & MORECTL) == 0);
317 /*
318 * XXX - Why ?
319 * No support for unbounded data
320 * on T_DISCON_IND ?
321 */
322 t_errno = TSYSERR;
323 errno = EPROTO;
324 goto err_out;
325 }
326 tiptr->ti_lookbufs.tl_lookdlen +=
327 databuf.len;
328 }
329
330 t_errno = TLOOK;
331 goto err_out;
332
333 default:
334 break;
335 }
336
337 t_errno = TSYSERR;
338 errno = EPROTO;
339 goto err_out;
340
341 } else { /* else for "if (ctlbuf.len > 0)" */
342 if (!retval && (tiptr->ti_flags & MORE)) {
343 *flags |= T_MORE;
344 tiptr->ti_flags &= ~MORE;
345 }
346 if (retval & MOREDATA)
347 *flags |= T_MORE;
348
349 /*
350 * If inside an ETSDU, set expedited flag and turn
351 * of internal version when reach end of "ETIDU".
352 */
353 if (tiptr->ti_flags & EXPEDITED) {
354 *flags |= T_EXPEDITED;
355 if (!retval)
356 tiptr->ti_flags &= ~EXPEDITED;
357 }
358
359 /*
360 * No real state change on T_RCV events (It is a NOOP)
361 *
362 * We invoke the macro only for error logging
363 * part of its capabilities when in a bad state.
364 */
365 _T_TX_NEXTSTATE(T_RCV, tiptr,
366 "t_rcv: state invalid T_RCV event");
367 if (didalloc)
368 free(ctlbuf.buf);
369 else
370 tiptr->ti_ctlbuf = ctlbuf.buf;
371 sig_mutex_unlock(&tiptr->ti_lock);
372 return (databuf.len);
373 }
374 /* NOTREACHED */
375
376 err_out:
377 sv_errno = errno;
378 if (didalloc)
379 free(ctlbuf.buf);
380 else
381 tiptr->ti_ctlbuf = ctlbuf.buf;
382 sig_mutex_unlock(&tiptr->ti_lock);
383
384 errno = sv_errno;
385 return (-1);
386 }
387