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 } 466