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 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30
31 #pragma ident "%Z%%M% %I% %E% SMI" /* from S5R4 1.4 */
32
33 /*
34 * Transport Interface Library read/write module - issue 1
35 */
36
37 #include <sys/types.h>
38 #include <sys/param.h>
39 #include <sys/stream.h>
40 #include <sys/stropts.h>
41 #include <sys/tihdr.h>
42 #include <sys/debug.h>
43 #include <sys/errno.h>
44 #include <sys/kmem.h>
45 #include <sys/tirdwr.h>
46 #include <sys/conf.h>
47 #include <sys/modctl.h>
48 #include <sys/ddi.h>
49 #include <sys/sunddi.h>
50
51 #define ORDREL 002
52 #define DISCON 004
53 #define FATAL 010
54 #define WAITACK 020
55 #define TIRDWR_ID 4
56
57 /*
58 * Per-Stream private data structure.
59 */
60 struct trw_trw {
61 queue_t *trw_rdq;
62 uint_t trw_flags;
63 };
64
65 /*
66 * stream data structure definitions
67 */
68 static int tirdwropen(queue_t *q, dev_t *dev,
69 int flag, int sflag, cred_t *cr);
70
71 static int tirdwrclose(queue_t *q, int flag, cred_t *cr);
72
73 static int check_strhead(queue_t *q);
74
75 /*
76 * To save instructions, since STREAMS ignores the return value
77 * from these functions, they are defined as void here. Kind of icky, but...
78 */
79 static void tirdwrrput(queue_t *q, mblk_t *mp);
80 static void tirdwrwput(queue_t *q, mblk_t *mp);
81
82 static struct module_info tirdwr_info = {
83 TIRDWR_ID,
84 "tirdwr",
85 0,
86 INFPSZ,
87 4096,
88 1024
89 };
90
91 static struct qinit tirdwrrinit = {
92 (int (*)())tirdwrrput,
93 (int (*)())NULL,
94 tirdwropen,
95 tirdwrclose,
96 nulldev,
97 &tirdwr_info,
98 NULL
99 };
100
101 static struct qinit tirdwrwinit = {
102 (int (*)())tirdwrwput,
103 (int (*)())NULL,
104 tirdwropen,
105 tirdwrclose,
106 nulldev,
107 &tirdwr_info,
108 NULL
109 };
110
111 static struct streamtab trwinfo = {
112 &tirdwrrinit,
113 &tirdwrwinit,
114 NULL,
115 NULL
116 };
117
118 static struct fmodsw fsw = {
119 "tirdwr",
120 &trwinfo,
121 D_NEW|D_MTQPAIR|D_MP
122 };
123
124 static struct modlstrmod modlstrmod = {
125 &mod_strmodops, "xport interface rd/wr str mod", &fsw
126 };
127
128 static struct modlinkage modlinkage = {
129 MODREV_1, &modlstrmod, NULL
130 };
131
132 int
133 _init(void)
134 {
135 return (mod_install(&modlinkage));
136 }
137
138 int
139 _fini(void)
140 {
141 return (mod_remove(&modlinkage));
142 }
143
144 int
145 _info(struct modinfo *modinfop)
146 {
147 return (mod_info(&modlinkage, modinfop));
148 }
149
150 static void send_fatal(queue_t *q, mblk_t *mp);
151 static void strip_strhead(queue_t *q);
152
153
154 /*
155 * tirdwropen - open routine gets called when the
156 * module gets pushed onto the stream.
157 */
158 /*ARGSUSED*/
159 static int
160 tirdwropen(
161 queue_t *q,
162 dev_t *dev,
163 int flag,
164 int sflag,
165 cred_t *cr)
166 {
167 struct trw_trw *trwptr;
168
169 /* check if already open */
170 if (q->q_ptr) {
171 return (0);
172 }
173
174 /*
175 * Allocate a new trw_trw struct.
176 */
177 trwptr = kmem_alloc(sizeof (struct trw_trw), KM_SLEEP);
178
179 /* initialize data structure */
180 trwptr->trw_flags = 0;
181 trwptr->trw_rdq = q;
182 q->q_ptr = (caddr_t)trwptr;
183 WR(q)->q_ptr = (caddr_t)trwptr;
184 qprocson(q);
185
186 freezestr(q);
187
188 (void) strqset(WR(q), QMAXPSZ, 0, (uintptr_t)WR(q)->q_next->q_maxpsz);
189 (void) strqset(q, QMAXPSZ, 0, (uintptr_t)q->q_next->q_maxpsz);
190
191 if (!check_strhead(q)) {
192 unfreezestr(q);
193 qprocsoff(q);
194 kmem_free(trwptr, sizeof (struct trw_trw));
195 return (EPROTO);
196 }
197 strip_strhead(q);
198 unfreezestr(q);
199
200 return (0);
201 }
202
203 /*
204 * tirdwrclose - This routine gets called when the module
205 * gets popped off of the stream.
206 */
207
208 /*ARGSUSED1*/
209 static int
210 tirdwrclose(queue_t *q, int flag, cred_t *cr)
211 {
212 struct trw_trw *trwptr;
213 mblk_t *mp;
214 union T_primitives *pptr;
215
216 qprocsoff(q);
217 trwptr = (struct trw_trw *)q->q_ptr;
218
219 ASSERT(trwptr != NULL);
220
221 /*
222 * Send up a T_DISCON_IND if necessary.
223 */
224 if ((trwptr->trw_flags & ORDREL) && !(trwptr->trw_flags & FATAL))
225 if (mp = allocb(sizeof (struct T_discon_req), BPRI_LO)) {
226 pptr = (union T_primitives *)mp->b_rptr;
227 mp->b_wptr = mp->b_rptr + sizeof (struct T_ordrel_req);
228 pptr->type = T_ORDREL_REQ;
229 mp->b_datap->db_type = M_PROTO;
230 putnext(WR(q), mp);
231 }
232
233 kmem_free(trwptr, sizeof (struct trw_trw));
234
235 return (0);
236 }
237
238 /*
239 * tirdwrrput - Module read queue put procedure.
240 * This is called from the module or
241 * driver downstream.
242 */
243
244 static void
245 tirdwrrput(queue_t *q, mblk_t *mp)
246 {
247 union T_primitives *pptr;
248 struct trw_trw *trwptr;
249 mblk_t *tmp;
250
251 trwptr = (struct trw_trw *)q->q_ptr;
252
253 ASSERT(trwptr != NULL);
254
255 if ((trwptr->trw_flags & FATAL) && !(trwptr->trw_flags & WAITACK)) {
256 freemsg(mp);
257 return;
258 }
259
260 switch (mp->b_datap->db_type) {
261
262 default:
263 putnext(q, mp);
264 break;
265
266 case M_DATA:
267 putnext(q, mp);
268 break;
269
270 case M_PCPROTO:
271 case M_PROTO:
272 /* is there enough data to check type */
273 if ((mp->b_wptr - mp->b_rptr) < sizeof (t_scalar_t)) {
274 /* malformed message */
275 freemsg(mp);
276 break;
277 }
278 pptr = (union T_primitives *)mp->b_rptr;
279
280 switch (pptr->type) {
281
282 case T_EXDATA_IND:
283 send_fatal(q, mp);
284 break;
285 case T_DATA_IND:
286 if (msgdsize(mp) == 0) {
287 freemsg(mp);
288 break;
289 }
290
291 tmp = (mblk_t *)unlinkb(mp);
292 freemsg(mp);
293 putnext(q, tmp);
294 break;
295
296 case T_ORDREL_IND:
297 trwptr->trw_flags |= ORDREL;
298 mp->b_datap->db_type = M_DATA;
299 mp->b_wptr = mp->b_rptr;
300 putnext(q, mp);
301 break;
302
303 case T_DISCON_IND:
304 trwptr->trw_flags |= DISCON;
305 trwptr->trw_flags &= ~ORDREL;
306 if (msgdsize(mp) != 0) {
307 tmp = (mblk_t *)unlinkb(mp);
308 putnext(q, tmp);
309 }
310 mp->b_datap->db_type = M_HANGUP;
311 mp->b_wptr = mp->b_rptr;
312 putnext(q, mp);
313 break;
314
315 default:
316 send_fatal(q, mp);
317 break;
318 }
319 }
320 }
321
322
323 /*
324 * tirdwrwput - Module write queue put procedure.
325 * This is called from the module or
326 * stream head upstream.
327 */
328 static void
329 tirdwrwput(queue_t *q, mblk_t *mp)
330 {
331 struct trw_trw *trwptr;
332
333 trwptr = (struct trw_trw *)q->q_ptr;
334
335 ASSERT(trwptr != NULL);
336
337 if (trwptr->trw_flags & FATAL) {
338 freemsg(mp);
339 return;
340 }
341
342 switch (mp->b_datap->db_type) {
343 default:
344 putnext(q, mp);
345 break;
346
347 case M_DATA:
348 putnext(q, mp);
349 break;
350
351 case M_PROTO:
352 case M_PCPROTO:
353 send_fatal(q, mp);
354 break;
355 }
356 }
357
358
359 static void
360 send_fatal(queue_t *q, mblk_t *mp)
361 {
362 struct trw_trw *trwptr;
363
364 trwptr = (struct trw_trw *)q->q_ptr;
365
366 trwptr->trw_flags |= FATAL;
367 mp->b_datap->db_type = M_ERROR;
368 *mp->b_datap->db_base = EPROTO;
369 mp->b_rptr = mp->b_datap->db_base;
370 mp->b_wptr = mp->b_datap->db_base + sizeof (char);
371 freemsg(unlinkb(mp));
372 if (q->q_flag&QREADR)
373 putnext(q, mp);
374 else
375 qreply(q, mp);
376 }
377
378 static int
379 check_strhead(queue_t *q)
380 {
381 mblk_t *mp;
382 union T_primitives *pptr;
383
384 for (mp = q->q_next->q_first; mp != NULL; mp = mp->b_next) {
385
386 switch (mp->b_datap->db_type) {
387 case M_PROTO:
388 pptr = (union T_primitives *)mp->b_rptr;
389 if ((mp->b_wptr - mp->b_rptr) < sizeof (t_scalar_t))
390 return (0);
391 switch (pptr->type) {
392
393 case T_EXDATA_IND:
394 return (0);
395 case T_DATA_IND:
396 if (mp->b_cont &&
397 (mp->b_cont->b_datap->db_type != M_DATA))
398 return (0);
399 break;
400 default:
401 return (0);
402 }
403 break;
404
405 case M_PCPROTO:
406 return (0);
407
408 case M_DATA:
409 case M_SIG:
410 break;
411 default:
412 return (0);
413 }
414 }
415 return (1);
416 }
417
418 static void
419 strip_strhead(queue_t *q)
420 {
421 mblk_t *mp;
422 mblk_t *emp;
423 mblk_t *tmp;
424 union T_primitives *pptr;
425
426 q = q->q_next;
427 /*CSTYLED*/
428 for (mp = q->q_first; mp != NULL; ) {
429
430 switch (mp->b_datap->db_type) {
431 case M_PROTO:
432 pptr = (union T_primitives *)mp->b_rptr;
433 switch (pptr->type) {
434
435 case T_DATA_IND:
436 if (msgdsize(mp) == 0) {
437 strip0:
438 tmp = mp->b_next;
439 rmvq(q, mp);
440 freemsg(mp);
441 mp = tmp;
442 break;
443 }
444 emp = mp->b_next;
445 rmvq(q, mp);
446 tmp = (mblk_t *)unlinkb(mp);
447 freeb(mp);
448 (void) insq(q, emp, tmp);
449 mp = emp;
450 break;
451 }
452 break;
453
454 case M_DATA:
455 if (msgdsize(mp) == 0)
456 goto strip0;
457 mp = mp->b_next;
458 break;
459
460 case M_SIG:
461 mp = mp->b_next;
462 break;
463 }
464 }
465 }