![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to dlcommon.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / iftop|
Return to dlcommon.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / iftop |
1.1 misho 1: /*
2: * Common (shared) DLPI test routines.
3: * Mostly pretty boring boilerplate sorta stuff.
4: * These can be split into individual library routines later
5: * but it's just convenient to keep them in a single file
6: * while they're being developed.
7: *
8: * Not supported:
9: * Connection Oriented stuff
10: * QOS stuff
11: */
12:
13: #include "config.h"
14:
15: #ifdef HAVE_DLPI
16:
17: /*
18: typedef unsigned long ulong;
19: */
20:
21:
22: #include <sys/types.h>
23: #include <sys/stream.h>
24: #include <sys/stropts.h>
25: #include <sys/dlpi.h>
26: #include <sys/signal.h>
27: #include <stdio.h>
1.1.1.2 ! misho 28: #include <stdlib.h>
1.1 misho 29: #include <string.h>
30: #include "dlcommon.h"
31:
32: #define CASERET(s) case s: return ("s")
33:
34: char *dlprim();
35: char *dlstate();
36: char *dlerrno();
37: char *dlpromisclevel();
38: char *dlservicemode();
39: char *dlstyle();
40: char *dlmactype();
41:
42:
43: dlinforeq(fd)
44: int fd;
45: {
46: dl_info_req_t info_req;
47: struct strbuf ctl;
48: int flags;
49:
50: info_req.dl_primitive = DL_INFO_REQ;
51:
52: ctl.maxlen = 0;
53: ctl.len = sizeof (info_req);
54: ctl.buf = (char *) &info_req;
55:
56: flags = RS_HIPRI;
57:
58: if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
59: syserr("dlinforeq: putmsg");
60: }
61:
62: dlinfoack(fd, bufp)
63: int fd;
64: char *bufp;
65: {
66: union DL_primitives *dlp;
67: struct strbuf ctl;
68: int flags;
69:
70: ctl.maxlen = MAXDLBUF;
71: ctl.len = 0;
72: ctl.buf = bufp;
73:
74: strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlinfoack");
75:
76: dlp = (union DL_primitives *) ctl.buf;
77:
78: expecting(DL_INFO_ACK, dlp);
79:
80: if (ctl.len < sizeof (dl_info_ack_t))
81: err("dlinfoack: response ctl.len too short: %d", ctl.len);
82:
83: if (flags != RS_HIPRI)
84: err("dlinfoack: DL_INFO_ACK was not M_PCPROTO");
85:
86: if (ctl.len < sizeof (dl_info_ack_t))
87: err("dlinfoack: short response ctl.len: %d", ctl.len);
88: }
89:
90: dlattachreq(fd, ppa)
91: int fd;
92: u_long ppa;
93: {
94: dl_attach_req_t attach_req;
95: struct strbuf ctl;
96: int flags;
97:
98: attach_req.dl_primitive = DL_ATTACH_REQ;
99: attach_req.dl_ppa = ppa;
100:
101: ctl.maxlen = 0;
102: ctl.len = sizeof (attach_req);
103: ctl.buf = (char *) &attach_req;
104:
105: flags = 0;
106:
107: if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
108: syserr("dlattachreq: putmsg");
109: }
110:
111: dlenabmultireq(fd, addr, length)
112: int fd;
113: char *addr;
114: int length;
115: {
116: long buf[MAXDLBUF];
117: union DL_primitives *dlp;
118: struct strbuf ctl;
119: int flags;
120:
121: dlp = (union DL_primitives*) buf;
122:
123: dlp->enabmulti_req.dl_primitive = DL_ENABMULTI_REQ;
124: dlp->enabmulti_req.dl_addr_length = length;
125: dlp->enabmulti_req.dl_addr_offset = sizeof (dl_enabmulti_req_t);
126:
127: (void) memcpy((char*)OFFADDR(buf, sizeof (dl_enabmulti_req_t)), addr, length);
128:
129: ctl.maxlen = 0;
130: ctl.len = sizeof (dl_enabmulti_req_t) + length;
131: ctl.buf = (char*) buf;
132:
133: flags = 0;
134:
135: if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
136: syserr("dlenabmultireq: putmsg");
137: }
138:
139: dldisabmultireq(fd, addr, length)
140: int fd;
141: char *addr;
142: int length;
143: {
144: long buf[MAXDLBUF];
145: union DL_primitives *dlp;
146: struct strbuf ctl;
147: int flags;
148:
149: dlp = (union DL_primitives*) buf;
150:
151: dlp->disabmulti_req.dl_primitive = DL_ENABMULTI_REQ;
152: dlp->disabmulti_req.dl_addr_length = length;
153: dlp->disabmulti_req.dl_addr_offset = sizeof (dl_disabmulti_req_t);
154:
155: (void) memcpy((char*)OFFADDR(buf, sizeof (dl_disabmulti_req_t)), addr, length);
156:
157: ctl.maxlen = 0;
158: ctl.len = sizeof (dl_disabmulti_req_t) + length;
159: ctl.buf = (char*) buf;
160:
161: flags = 0;
162:
163: if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
164: syserr("dldisabmultireq: putmsg");
165: }
166:
167: dlpromisconreq(fd, level)
168: int fd;
169: u_long level;
170: {
171: dl_promiscon_req_t promiscon_req;
172: struct strbuf ctl;
173: int flags;
174:
175: promiscon_req.dl_primitive = DL_PROMISCON_REQ;
176: promiscon_req.dl_level = level;
177:
178: ctl.maxlen = 0;
179: ctl.len = sizeof (promiscon_req);
180: ctl.buf = (char *) &promiscon_req;
181:
182: flags = 0;
183:
184: if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
185: syserr("dlpromiscon: putmsg");
186:
187: }
188:
189: dlpromiscoff(fd, level)
190: int fd;
191: u_long level;
192: {
193: dl_promiscoff_req_t promiscoff_req;
194: struct strbuf ctl;
195: int flags;
196:
197: promiscoff_req.dl_primitive = DL_PROMISCOFF_REQ;
198: promiscoff_req.dl_level = level;
199:
200: ctl.maxlen = 0;
201: ctl.len = sizeof (promiscoff_req);
202: ctl.buf = (char *) &promiscoff_req;
203:
204: flags = 0;
205:
206: if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
207: syserr("dlpromiscoff: putmsg");
208: }
209:
210: dlphysaddrreq(fd, addrtype)
211: int fd;
212: u_long addrtype;
213: {
214: dl_phys_addr_req_t phys_addr_req;
215: struct strbuf ctl;
216: int flags;
217:
218: phys_addr_req.dl_primitive = DL_PHYS_ADDR_REQ;
219: phys_addr_req.dl_addr_type = addrtype;
220:
221: ctl.maxlen = 0;
222: ctl.len = sizeof (phys_addr_req);
223: ctl.buf = (char *) &phys_addr_req;
224:
225: flags = 0;
226:
227: if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
228: syserr("dlphysaddrreq: putmsg");
229: }
230:
231: dlsetphysaddrreq(fd, addr, length)
232: int fd;
233: char *addr;
234: int length;
235: {
236: long buf[MAXDLBUF];
237: union DL_primitives *dlp;
238: struct strbuf ctl;
239: int flags;
240:
241: dlp = (union DL_primitives*) buf;
242:
243: dlp->set_physaddr_req.dl_primitive = DL_ENABMULTI_REQ;
244: dlp->set_physaddr_req.dl_addr_length = length;
245: dlp->set_physaddr_req.dl_addr_offset = sizeof (dl_set_phys_addr_req_t);
246:
247: (void) memcpy((char*)OFFADDR(buf, sizeof (dl_set_phys_addr_req_t)), addr, length);
248:
249: ctl.maxlen = 0;
250: ctl.len = sizeof (dl_set_phys_addr_req_t) + length;
251: ctl.buf = (char*) buf;
252:
253: flags = 0;
254:
255: if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
256: syserr("dlsetphysaddrreq: putmsg");
257: }
258:
259: dldetachreq(fd)
260: int fd;
261: {
262: dl_detach_req_t detach_req;
263: struct strbuf ctl;
264: int flags;
265:
266: detach_req.dl_primitive = DL_DETACH_REQ;
267:
268: ctl.maxlen = 0;
269: ctl.len = sizeof (detach_req);
270: ctl.buf = (char *) &detach_req;
271:
272: flags = 0;
273:
274: if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
275: syserr("dldetachreq: putmsg");
276: }
277:
278: dlbindreq(fd, sap, max_conind, service_mode, conn_mgmt, xidtest)
279: int fd;
280: u_long sap;
281: u_long max_conind;
282: u_long service_mode;
283: u_long conn_mgmt;
284: u_long xidtest;
285: {
286: dl_bind_req_t bind_req;
287: struct strbuf ctl;
288: int flags;
289:
290: bind_req.dl_primitive = DL_BIND_REQ;
291: bind_req.dl_sap = sap;
292: bind_req.dl_max_conind = max_conind;
293: bind_req.dl_service_mode = service_mode;
294: bind_req.dl_conn_mgmt = conn_mgmt;
295: bind_req.dl_xidtest_flg = xidtest;
296:
297: ctl.maxlen = 0;
298: ctl.len = sizeof (bind_req);
299: ctl.buf = (char *) &bind_req;
300:
301: flags = 0;
302:
303: if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
304: syserr("dlbindreq: putmsg");
305: }
306:
307: dlunitdatareq(fd, addrp, addrlen, minpri, maxpri, datap, datalen)
308: int fd;
309: u_char *addrp;
310: int addrlen;
311: u_long minpri, maxpri;
312: u_char *datap;
313: int datalen;
314: {
315: long buf[MAXDLBUF];
316: union DL_primitives *dlp;
317: struct strbuf data, ctl;
318:
319: dlp = (union DL_primitives*) buf;
320:
321: dlp->unitdata_req.dl_primitive = DL_UNITDATA_REQ;
322: dlp->unitdata_req.dl_dest_addr_length = addrlen;
323: dlp->unitdata_req.dl_dest_addr_offset = sizeof (dl_unitdata_req_t);
324: dlp->unitdata_req.dl_priority.dl_min = minpri;
325: dlp->unitdata_req.dl_priority.dl_max = maxpri;
326:
327: (void) memcpy(OFFADDR(dlp, sizeof (dl_unitdata_req_t)), addrp, addrlen);
328:
329: ctl.maxlen = 0;
330: ctl.len = sizeof (dl_unitdata_req_t) + addrlen;
331: ctl.buf = (char *) buf;
332:
333: data.maxlen = 0;
334: data.len = datalen;
335: data.buf = (char *) datap;
336:
337: if (putmsg(fd, &ctl, &data, 0) < 0)
338: syserr("dlunitdatareq: putmsg");
339: }
340:
341: dlunbindreq(fd)
342: int fd;
343: {
344: dl_unbind_req_t unbind_req;
345: struct strbuf ctl;
346: int flags;
347:
348: unbind_req.dl_primitive = DL_UNBIND_REQ;
349:
350: ctl.maxlen = 0;
351: ctl.len = sizeof (unbind_req);
352: ctl.buf = (char *) &unbind_req;
353:
354: flags = 0;
355:
356: if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
357: syserr("dlunbindreq: putmsg");
358: }
359:
360: dlokack(fd, bufp)
361: int fd;
362: char *bufp;
363: {
364: union DL_primitives *dlp;
365: struct strbuf ctl;
366: int flags;
367:
368: ctl.maxlen = MAXDLBUF;
369: ctl.len = 0;
370: ctl.buf = bufp;
371:
372: strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlokack");
373:
374: dlp = (union DL_primitives *) ctl.buf;
375:
376: expecting(DL_OK_ACK, dlp);
377:
378: if (ctl.len < sizeof (dl_ok_ack_t))
379: err("dlokack: response ctl.len too short: %d", ctl.len);
380:
381: if (flags != RS_HIPRI)
382: err("dlokack: DL_OK_ACK was not M_PCPROTO");
383:
384: if (ctl.len < sizeof (dl_ok_ack_t))
385: err("dlokack: short response ctl.len: %d", ctl.len);
386: }
387:
388: dlerrorack(fd, bufp)
389: int fd;
390: char *bufp;
391: {
392: union DL_primitives *dlp;
393: struct strbuf ctl;
394: int flags;
395:
396: ctl.maxlen = MAXDLBUF;
397: ctl.len = 0;
398: ctl.buf = bufp;
399:
400: strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlerrorack");
401:
402: dlp = (union DL_primitives *) ctl.buf;
403:
404: expecting(DL_ERROR_ACK, dlp);
405:
406: if (ctl.len < sizeof (dl_error_ack_t))
407: err("dlerrorack: response ctl.len too short: %d", ctl.len);
408:
409: if (flags != RS_HIPRI)
410: err("dlerrorack: DL_OK_ACK was not M_PCPROTO");
411:
412: if (ctl.len < sizeof (dl_error_ack_t))
413: err("dlerrorack: short response ctl.len: %d", ctl.len);
414: }
415:
416: dlbindack(fd, bufp)
417: int fd;
418: char *bufp;
419: {
420: union DL_primitives *dlp;
421: struct strbuf ctl;
422: int flags;
423:
424: ctl.maxlen = MAXDLBUF;
425: ctl.len = 0;
426: ctl.buf = bufp;
427:
428: strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlbindack");
429:
430: dlp = (union DL_primitives *) ctl.buf;
431:
432: expecting(DL_BIND_ACK, dlp);
433:
434: if (flags != RS_HIPRI)
435: err("dlbindack: DL_OK_ACK was not M_PCPROTO");
436:
437: if (ctl.len < sizeof (dl_bind_ack_t))
438: err("dlbindack: short response ctl.len: %d", ctl.len);
439: }
440:
441: dlphysaddrack(fd, bufp)
442: int fd;
443: char *bufp;
444: {
445: union DL_primitives *dlp;
446: struct strbuf ctl;
447: int flags;
448:
449: ctl.maxlen = MAXDLBUF;
450: ctl.len = 0;
451: ctl.buf = bufp;
452:
453: strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlphysaddrack");
454:
455: dlp = (union DL_primitives *) ctl.buf;
456:
457: expecting(DL_PHYS_ADDR_ACK, dlp);
458:
459: if (flags != RS_HIPRI)
460: err("dlbindack: DL_OK_ACK was not M_PCPROTO");
461:
462: if (ctl.len < sizeof (dl_phys_addr_ack_t))
463: err("dlphysaddrack: short response ctl.len: %d", ctl.len);
464: }
465:
1.1.1.2 ! misho 466: void
1.1 misho 467: sigalrm()
468: {
469: (void) err("sigalrm: TIMEOUT");
470: }
471:
472: strgetmsg(fd, ctlp, datap, flagsp, caller)
473: int fd;
474: struct strbuf *ctlp, *datap;
475: int *flagsp;
476: char *caller;
477: {
478: int rc;
479: static char errmsg[80];
480:
481: /*
482: * Start timer.
483: */
484: (void) signal(SIGALRM, sigalrm);
485: if (alarm(MAXWAIT) < 0) {
486: (void) sprintf(errmsg, "%s: alarm", caller);
487: syserr(errmsg);
488: }
489:
490: /*
491: * Set flags argument and issue getmsg().
492: */
493: *flagsp = 0;
494: if ((rc = getmsg(fd, ctlp, datap, flagsp)) < 0) {
495: (void) sprintf(errmsg, "%s: getmsg", caller);
496: syserr(errmsg);
497: }
498:
499: /*
500: * Stop timer.
501: */
502: if (alarm(0) < 0) {
503: (void) sprintf(errmsg, "%s: alarm", caller);
504: syserr(errmsg);
505: }
506:
507: /*
508: * Check for MOREDATA and/or MORECTL.
509: */
510: if ((rc & (MORECTL | MOREDATA)) == (MORECTL | MOREDATA))
511: err("%s: MORECTL|MOREDATA", caller);
512: if (rc & MORECTL)
513: err("%s: MORECTL", caller);
514: if (rc & MOREDATA)
515: err("%s: MOREDATA", caller);
516:
517: /*
518: * Check for at least sizeof (long) control data portion.
519: */
520: if (ctlp->len < sizeof (long))
521: err("getmsg: control portion length < sizeof (long): %d", ctlp->len);
522: }
523:
524: expecting(prim, dlp)
525: int prim;
526: union DL_primitives *dlp;
527: {
528: if (dlp->dl_primitive != (u_long)prim) {
529: printdlprim(dlp);
530: err("expected %s got %s", dlprim(prim),
531: dlprim(dlp->dl_primitive));
532: exit(1);
533: }
534: }
535:
536: /*
537: * Print any DLPI msg in human readable format.
538: */
539: printdlprim(dlp)
540: union DL_primitives *dlp;
541: {
542: switch (dlp->dl_primitive) {
543: case DL_INFO_REQ:
544: printdlinforeq(dlp);
545: break;
546:
547: case DL_INFO_ACK:
548: printdlinfoack(dlp);
549: break;
550:
551: case DL_ATTACH_REQ:
552: printdlattachreq(dlp);
553: break;
554:
555: case DL_OK_ACK:
556: printdlokack(dlp);
557: break;
558:
559: case DL_ERROR_ACK:
560: printdlerrorack(dlp);
561: break;
562:
563: case DL_DETACH_REQ:
564: printdldetachreq(dlp);
565: break;
566:
567: case DL_BIND_REQ:
568: printdlbindreq(dlp);
569: break;
570:
571: case DL_BIND_ACK:
572: printdlbindack(dlp);
573: break;
574:
575: case DL_UNBIND_REQ:
576: printdlunbindreq(dlp);
577: break;
578:
579: case DL_SUBS_BIND_REQ:
580: printdlsubsbindreq(dlp);
581: break;
582:
583: case DL_SUBS_BIND_ACK:
584: printdlsubsbindack(dlp);
585: break;
586:
587: case DL_SUBS_UNBIND_REQ:
588: printdlsubsunbindreq(dlp);
589: break;
590:
591: case DL_ENABMULTI_REQ:
592: printdlenabmultireq(dlp);
593: break;
594:
595: case DL_DISABMULTI_REQ:
596: printdldisabmultireq(dlp);
597: break;
598:
599: case DL_PROMISCON_REQ:
600: printdlpromisconreq(dlp);
601: break;
602:
603: case DL_PROMISCOFF_REQ:
604: printdlpromiscoffreq(dlp);
605: break;
606:
607: case DL_UNITDATA_REQ:
608: printdlunitdatareq(dlp);
609: break;
610:
611: case DL_UNITDATA_IND:
612: printdlunitdataind(dlp);
613: break;
614:
615: case DL_UDERROR_IND:
616: printdluderrorind(dlp);
617: break;
618:
619: case DL_UDQOS_REQ:
620: printdludqosreq(dlp);
621: break;
622:
623: case DL_PHYS_ADDR_REQ:
624: printdlphysaddrreq(dlp);
625: break;
626:
627: case DL_PHYS_ADDR_ACK:
628: printdlphysaddrack(dlp);
629: break;
630:
631: case DL_SET_PHYS_ADDR_REQ:
632: printdlsetphysaddrreq(dlp);
633: break;
634:
635: default:
636: err("printdlprim: unknown primitive type 0x%x",
637: dlp->dl_primitive);
638: break;
639: }
640: }
641:
642: /* ARGSUSED */
643: printdlinforeq(dlp)
644: union DL_primitives *dlp;
645: {
646: (void) printf("DL_INFO_REQ\n");
647: }
648:
649: printdlinfoack(dlp)
650: union DL_primitives *dlp;
651: {
652: u_char addr[MAXDLADDR];
653: u_char brdcst[MAXDLADDR];
654:
655: addrtostring(OFFADDR(dlp, dlp->info_ack.dl_addr_offset),
656: dlp->info_ack.dl_addr_length, addr);
657: addrtostring(OFFADDR(dlp, dlp->info_ack.dl_brdcst_addr_offset),
658: dlp->info_ack.dl_brdcst_addr_length, brdcst);
659:
660: (void) printf("DL_INFO_ACK: max_sdu %d min_sdu %d\n",
661: dlp->info_ack.dl_max_sdu,
662: dlp->info_ack.dl_min_sdu);
663: (void) printf("addr_length %d mac_type %s current_state %s\n",
664: dlp->info_ack.dl_addr_length,
665: dlmactype(dlp->info_ack.dl_mac_type),
666: dlstate(dlp->info_ack.dl_current_state));
667: (void) printf("sap_length %d service_mode %s qos_length %d\n",
668: dlp->info_ack.dl_sap_length,
669: dlservicemode(dlp->info_ack.dl_service_mode),
670: dlp->info_ack.dl_qos_length);
671: (void) printf("qos_offset %d qos_range_length %d qos_range_offset %d\n",
672: dlp->info_ack.dl_qos_offset,
673: dlp->info_ack.dl_qos_range_length,
674: dlp->info_ack.dl_qos_range_offset);
675: (void) printf("provider_style %s addr_offset %d version %d\n",
676: dlstyle(dlp->info_ack.dl_provider_style),
677: dlp->info_ack.dl_addr_offset,
678: dlp->info_ack.dl_version);
679: (void) printf("brdcst_addr_length %d brdcst_addr_offset %d\n",
680: dlp->info_ack.dl_brdcst_addr_length,
681: dlp->info_ack.dl_brdcst_addr_offset);
682: (void) printf("addr %s\n", addr);
683: (void) printf("brdcst_addr %s\n", brdcst);
684: }
685:
686: printdlattachreq(dlp)
687: union DL_primitives *dlp;
688: {
689: (void) printf("DL_ATTACH_REQ: ppa %d\n",
690: dlp->attach_req.dl_ppa);
691: }
692:
693: printdlokack(dlp)
694: union DL_primitives *dlp;
695: {
696: (void) printf("DL_OK_ACK: correct_primitive %s\n",
697: dlprim(dlp->ok_ack.dl_correct_primitive));
698: }
699:
700: printdlerrorack(dlp)
701: union DL_primitives *dlp;
702: {
703: (void) printf("DL_ERROR_ACK: error_primitive %s errno %s unix_errno %d\n",
704: dlprim(dlp->error_ack.dl_error_primitive),
705: dlerrno(dlp->error_ack.dl_errno),
706: dlp->error_ack.dl_unix_errno);
707: }
708:
709: printdlenabmultireq(dlp)
710: union DL_primitives *dlp;
711: {
712: u_char addr[MAXDLADDR];
713:
714: addrtostring(OFFADDR(dlp, dlp->enabmulti_req.dl_addr_offset),
715: dlp->enabmulti_req.dl_addr_length, addr);
716:
717: (void) printf("DL_ENABMULTI_REQ: addr_length %d addr_offset %d\n",
718: dlp->enabmulti_req.dl_addr_length,
719: dlp->enabmulti_req.dl_addr_offset);
720: (void) printf("addr %s\n", addr);
721: }
722:
723: printdldisabmultireq(dlp)
724: union DL_primitives *dlp;
725: {
726: u_char addr[MAXDLADDR];
727:
728: addrtostring(OFFADDR(dlp, dlp->disabmulti_req.dl_addr_offset),
729: dlp->disabmulti_req.dl_addr_length, addr);
730:
731: (void) printf("DL_DISABMULTI_REQ: addr_length %d addr_offset %d\n",
732: dlp->disabmulti_req.dl_addr_length,
733: dlp->disabmulti_req.dl_addr_offset);
734: (void) printf("addr %s\n", addr);
735: }
736:
737: printdlpromisconreq(dlp)
738: union DL_primitives *dlp;
739: {
740: (void) printf("DL_PROMISCON_REQ: level %s\n",
741: dlpromisclevel(dlp->promiscon_req.dl_level));
742: }
743:
744: printdlpromiscoffreq(dlp)
745: union DL_primitives *dlp;
746: {
747: (void) printf("DL_PROMISCOFF_REQ: level %s\n",
748: dlpromisclevel(dlp->promiscoff_req.dl_level));
749: }
750:
751: printdlphysaddrreq(dlp)
752: union DL_primitives *dlp;
753: {
754: (void) printf("DL_PHYS_ADDR_REQ: addr_type 0x%x\n",
755: dlp->physaddr_req.dl_addr_type);
756: }
757:
758: printdlphysaddrack(dlp)
759: union DL_primitives *dlp;
760: {
761: u_char addr[MAXDLADDR];
762:
763: addrtostring(OFFADDR(dlp, dlp->physaddr_ack.dl_addr_offset),
764: dlp->physaddr_ack.dl_addr_length, addr);
765:
766: (void) printf("DL_PHYS_ADDR_ACK: addr_length %d addr_offset %d\n",
767: dlp->physaddr_ack.dl_addr_length,
768: dlp->physaddr_ack.dl_addr_offset);
769: (void) printf("addr %s\n", addr);
770: }
771:
772: printdlsetphysaddrreq(dlp)
773: union DL_primitives *dlp;
774: {
775: u_char addr[MAXDLADDR];
776:
777: addrtostring(OFFADDR(dlp, dlp->set_physaddr_req.dl_addr_offset),
778: dlp->set_physaddr_req.dl_addr_length, addr);
779:
780: (void) printf("DL_SET_PHYS_ADDR_REQ: addr_length %d addr_offset %d\n",
781: dlp->set_physaddr_req.dl_addr_length,
782: dlp->set_physaddr_req.dl_addr_offset);
783: (void) printf("addr %s\n", addr);
784: }
785:
786: /* ARGSUSED */
787: printdldetachreq(dlp)
788: union DL_primitives *dlp;
789: {
790: (void) printf("DL_DETACH_REQ\n");
791: }
792:
793: printdlbindreq(dlp)
794: union DL_primitives *dlp;
795: {
796: (void) printf("DL_BIND_REQ: sap %d max_conind %d\n",
797: dlp->bind_req.dl_sap,
798: dlp->bind_req.dl_max_conind);
799: (void) printf("service_mode %s conn_mgmt %d xidtest_flg 0x%x\n",
800: dlservicemode(dlp->bind_req.dl_service_mode),
801: dlp->bind_req.dl_conn_mgmt,
802: dlp->bind_req.dl_xidtest_flg);
803: }
804:
805: printdlbindack(dlp)
806: union DL_primitives *dlp;
807: {
808: u_char addr[MAXDLADDR];
809:
810: addrtostring(OFFADDR(dlp, dlp->bind_ack.dl_addr_offset),
811: dlp->bind_ack.dl_addr_length, addr);
812:
813: (void) printf("DL_BIND_ACK: sap %d addr_length %d addr_offset %d\n",
814: dlp->bind_ack.dl_sap,
815: dlp->bind_ack.dl_addr_length,
816: dlp->bind_ack.dl_addr_offset);
817: (void) printf("max_conind %d xidtest_flg 0x%x\n",
818: dlp->bind_ack.dl_max_conind,
819: dlp->bind_ack.dl_xidtest_flg);
820: (void) printf("addr %s\n", addr);
821: }
822:
823: /* ARGSUSED */
824: printdlunbindreq(dlp)
825: union DL_primitives *dlp;
826: {
827: (void) printf("DL_UNBIND_REQ\n");
828: }
829:
830: printdlsubsbindreq(dlp)
831: union DL_primitives *dlp;
832: {
833: u_char sap[MAXDLADDR];
834:
835: addrtostring(OFFADDR(dlp, dlp->subs_bind_req.dl_subs_sap_offset),
836: dlp->subs_bind_req.dl_subs_sap_length, sap);
837:
838: (void) printf("DL_SUBS_BIND_REQ: subs_sap_offset %d sub_sap_len %d\n",
839: dlp->subs_bind_req.dl_subs_sap_offset,
840: dlp->subs_bind_req.dl_subs_sap_length);
841: (void) printf("sap %s\n", sap);
842: }
843:
844: printdlsubsbindack(dlp)
845: union DL_primitives *dlp;
846: {
847: u_char sap[MAXDLADDR];
848:
849: addrtostring(OFFADDR(dlp, dlp->subs_bind_ack.dl_subs_sap_offset),
850: dlp->subs_bind_ack.dl_subs_sap_length, sap);
851:
852: (void) printf("DL_SUBS_BIND_ACK: subs_sap_offset %d sub_sap_length %d\n",
853: dlp->subs_bind_ack.dl_subs_sap_offset,
854: dlp->subs_bind_ack.dl_subs_sap_length);
855: (void) printf("sap %s\n", sap);
856: }
857:
858: printdlsubsunbindreq(dlp)
859: union DL_primitives *dlp;
860: {
861: u_char sap[MAXDLADDR];
862:
863: addrtostring(OFFADDR(dlp, dlp->subs_unbind_req.dl_subs_sap_offset),
864: dlp->subs_unbind_req.dl_subs_sap_length, sap);
865:
866: (void) printf("DL_SUBS_UNBIND_REQ: subs_sap_offset %d sub_sap_length %d\n",
867: dlp->subs_unbind_req.dl_subs_sap_offset,
868: dlp->subs_unbind_req.dl_subs_sap_length);
869: (void) printf("sap %s\n", sap);
870: }
871:
872: printdlunitdatareq(dlp)
873: union DL_primitives *dlp;
874: {
875: u_char addr[MAXDLADDR];
876:
877: addrtostring(OFFADDR(dlp, dlp->unitdata_req.dl_dest_addr_offset),
878: dlp->unitdata_req.dl_dest_addr_length, addr);
879:
880: (void) printf("DL_UNITDATA_REQ: dest_addr_length %d dest_addr_offset %d\n",
881: dlp->unitdata_req.dl_dest_addr_length,
882: dlp->unitdata_req.dl_dest_addr_offset);
883: (void) printf("dl_priority.min %d dl_priority.max %d\n",
884: dlp->unitdata_req.dl_priority.dl_min,
885: dlp->unitdata_req.dl_priority.dl_max);
886: (void) printf("addr %s\n", addr);
887: }
888:
889: printdlunitdataind(dlp)
890: union DL_primitives *dlp;
891: {
892: u_char dest[MAXDLADDR];
893: u_char src[MAXDLADDR];
894:
895: addrtostring(OFFADDR(dlp, dlp->unitdata_ind.dl_dest_addr_offset),
896: dlp->unitdata_ind.dl_dest_addr_length, dest);
897: addrtostring(OFFADDR(dlp, dlp->unitdata_ind.dl_src_addr_offset),
898: dlp->unitdata_ind.dl_src_addr_length, src);
899:
900: (void) printf("DL_UNITDATA_IND: dest_addr_length %d dest_addr_offset %d\n",
901: dlp->unitdata_ind.dl_dest_addr_length,
902: dlp->unitdata_ind.dl_dest_addr_offset);
903: (void) printf("src_addr_length %d src_addr_offset %d\n",
904: dlp->unitdata_ind.dl_src_addr_length,
905: dlp->unitdata_ind.dl_src_addr_offset);
906: (void) printf("group_address 0x%x\n",
907: dlp->unitdata_ind.dl_group_address);
908: (void) printf("dest %s\n", dest);
909: (void) printf("src %s\n", src);
910: }
911:
912: printdluderrorind(dlp)
913: union DL_primitives *dlp;
914: {
915: u_char addr[MAXDLADDR];
916:
917: addrtostring(OFFADDR(dlp, dlp->uderror_ind.dl_dest_addr_offset),
918: dlp->uderror_ind.dl_dest_addr_length, addr);
919:
920: (void) printf("DL_UDERROR_IND: dest_addr_length %d dest_addr_offset %d\n",
921: dlp->uderror_ind.dl_dest_addr_length,
922: dlp->uderror_ind.dl_dest_addr_offset);
923: (void) printf("unix_errno %d errno %s\n",
924: dlp->uderror_ind.dl_unix_errno,
925: dlerrno(dlp->uderror_ind.dl_errno));
926: (void) printf("addr %s\n", addr);
927: }
928:
929: printdltestreq(dlp)
930: union DL_primitives *dlp;
931: {
932: u_char addr[MAXDLADDR];
933:
934: addrtostring(OFFADDR(dlp, dlp->test_req.dl_dest_addr_offset),
935: dlp->test_req.dl_dest_addr_length, addr);
936:
937: (void) printf("DL_TEST_REQ: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
938: dlp->test_req.dl_flag,
939: dlp->test_req.dl_dest_addr_length,
940: dlp->test_req.dl_dest_addr_offset);
941: (void) printf("dest_addr %s\n", addr);
942: }
943:
944: printdltestind(dlp)
945: union DL_primitives *dlp;
946: {
947: u_char dest[MAXDLADDR];
948: u_char src[MAXDLADDR];
949:
950: addrtostring(OFFADDR(dlp, dlp->test_ind.dl_dest_addr_offset),
951: dlp->test_ind.dl_dest_addr_length, dest);
952: addrtostring(OFFADDR(dlp, dlp->test_ind.dl_src_addr_offset),
953: dlp->test_ind.dl_src_addr_length, src);
954:
955: (void) printf("DL_TEST_IND: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
956: dlp->test_ind.dl_flag,
957: dlp->test_ind.dl_dest_addr_length,
958: dlp->test_ind.dl_dest_addr_offset);
959: (void) printf("src_addr_length %d src_addr_offset %d\n",
960: dlp->test_ind.dl_src_addr_length,
961: dlp->test_ind.dl_src_addr_offset);
962: (void) printf("dest_addr %s\n", dest);
963: (void) printf("src_addr %s\n", src);
964: }
965:
966: printdltestres(dlp)
967: union DL_primitives *dlp;
968: {
969: u_char dest[MAXDLADDR];
970:
971: addrtostring(OFFADDR(dlp, dlp->test_res.dl_dest_addr_offset),
972: dlp->test_res.dl_dest_addr_length, dest);
973:
974: (void) printf("DL_TEST_RES: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
975: dlp->test_res.dl_flag,
976: dlp->test_res.dl_dest_addr_length,
977: dlp->test_res.dl_dest_addr_offset);
978: (void) printf("dest_addr %s\n", dest);
979: }
980:
981: printdltestcon(dlp)
982: union DL_primitives *dlp;
983: {
984: u_char dest[MAXDLADDR];
985: u_char src[MAXDLADDR];
986:
987: addrtostring(OFFADDR(dlp, dlp->test_con.dl_dest_addr_offset),
988: dlp->test_con.dl_dest_addr_length, dest);
989: addrtostring(OFFADDR(dlp, dlp->test_con.dl_src_addr_offset),
990: dlp->test_con.dl_src_addr_length, src);
991:
992: (void) printf("DL_TEST_CON: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
993: dlp->test_con.dl_flag,
994: dlp->test_con.dl_dest_addr_length,
995: dlp->test_con.dl_dest_addr_offset);
996: (void) printf("src_addr_length %d src_addr_offset %d\n",
997: dlp->test_con.dl_src_addr_length,
998: dlp->test_con.dl_src_addr_offset);
999: (void) printf("dest_addr %s\n", dest);
1000: (void) printf("src_addr %s\n", src);
1001: }
1002:
1003: printdlxidreq(dlp)
1004: union DL_primitives *dlp;
1005: {
1006: u_char dest[MAXDLADDR];
1007:
1008: addrtostring(OFFADDR(dlp, dlp->xid_req.dl_dest_addr_offset),
1009: dlp->xid_req.dl_dest_addr_length, dest);
1010:
1011: (void) printf("DL_XID_REQ: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
1012: dlp->xid_req.dl_flag,
1013: dlp->xid_req.dl_dest_addr_length,
1014: dlp->xid_req.dl_dest_addr_offset);
1015: (void) printf("dest_addr %s\n", dest);
1016: }
1017:
1018: printdlxidind(dlp)
1019: union DL_primitives *dlp;
1020: {
1021: u_char dest[MAXDLADDR];
1022: u_char src[MAXDLADDR];
1023:
1024: addrtostring(OFFADDR(dlp, dlp->xid_ind.dl_dest_addr_offset),
1025: dlp->xid_ind.dl_dest_addr_length, dest);
1026: addrtostring(OFFADDR(dlp, dlp->xid_ind.dl_src_addr_offset),
1027: dlp->xid_ind.dl_src_addr_length, src);
1028:
1029: (void) printf("DL_XID_IND: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
1030: dlp->xid_ind.dl_flag,
1031: dlp->xid_ind.dl_dest_addr_length,
1032: dlp->xid_ind.dl_dest_addr_offset);
1033: (void) printf("src_addr_length %d src_addr_offset %d\n",
1034: dlp->xid_ind.dl_src_addr_length,
1035: dlp->xid_ind.dl_src_addr_offset);
1036: (void) printf("dest_addr %s\n", dest);
1037: (void) printf("src_addr %s\n", src);
1038: }
1039:
1040: printdlxidres(dlp)
1041: union DL_primitives *dlp;
1042: {
1043: u_char dest[MAXDLADDR];
1044:
1045: addrtostring(OFFADDR(dlp, dlp->xid_res.dl_dest_addr_offset),
1046: dlp->xid_res.dl_dest_addr_length, dest);
1047:
1048: (void) printf("DL_XID_RES: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
1049: dlp->xid_res.dl_flag,
1050: dlp->xid_res.dl_dest_addr_length,
1051: dlp->xid_res.dl_dest_addr_offset);
1052: (void) printf("dest_addr %s\n", dest);
1053: }
1054:
1055: printdlxidcon(dlp)
1056: union DL_primitives *dlp;
1057: {
1058: u_char dest[MAXDLADDR];
1059: u_char src[MAXDLADDR];
1060:
1061: addrtostring(OFFADDR(dlp, dlp->xid_con.dl_dest_addr_offset),
1062: dlp->xid_con.dl_dest_addr_length, dest);
1063: addrtostring(OFFADDR(dlp, dlp->xid_con.dl_src_addr_offset),
1064: dlp->xid_con.dl_src_addr_length, src);
1065:
1066: (void) printf("DL_XID_CON: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
1067: dlp->xid_con.dl_flag,
1068: dlp->xid_con.dl_dest_addr_length,
1069: dlp->xid_con.dl_dest_addr_offset);
1070: (void) printf("src_addr_length %d src_addr_offset %d\n",
1071: dlp->xid_con.dl_src_addr_length,
1072: dlp->xid_con.dl_src_addr_offset);
1073: (void) printf("dest_addr %s\n", dest);
1074: (void) printf("src_addr %s\n", src);
1075: }
1076:
1077: printdludqosreq(dlp)
1078: union DL_primitives *dlp;
1079: {
1080: (void) printf("DL_UDQOS_REQ: qos_length %d qos_offset %d\n",
1081: dlp->udqos_req.dl_qos_length,
1082: dlp->udqos_req.dl_qos_offset);
1083: }
1084:
1085: /*
1086: * Return string.
1087: */
1088: addrtostring(addr, length, s)
1089: u_char *addr;
1090: u_long length;
1091: u_char *s;
1092: {
1093: int i;
1094:
1095: for (i = 0; i < length; i++) {
1096: (void) sprintf((char*) s, "%x:", addr[i] & 0xff);
1097: s = s + strlen((char*)s);
1098: }
1099: if (length)
1100: *(--s) = '\0';
1101: }
1102:
1103: /*
1104: * Return length
1105: */
1106: stringtoaddr(sp, addr)
1107: char *sp;
1108: char *addr;
1109: {
1110: int n = 0;
1111: char *p;
1112: int val;
1113:
1114: p = sp;
1115: while (p = strtok(p, ":")) {
1116: if (sscanf(p, "%x", &val) != 1)
1117: err("stringtoaddr: invalid input string: %s", sp);
1118: if (val > 0xff)
1119: err("stringtoaddr: invalid input string: %s", sp);
1120: *addr++ = val;
1121: n++;
1122: p = NULL;
1123: }
1124:
1125: return (n);
1126: }
1127:
1128:
1129: static char
1130: hexnibble(c)
1131: char c;
1132: {
1133: static char hextab[] = {
1134: '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
1135: 'a', 'b', 'c', 'd', 'e', 'f'
1136: };
1137:
1138: return (hextab[c & 0x0f]);
1139: }
1140:
1141: char*
1142: dlprim(prim)
1143: u_long prim;
1144: {
1145: static char primbuf[80];
1146:
1147: switch ((int)prim) {
1148: CASERET(DL_INFO_REQ);
1149: CASERET(DL_INFO_ACK);
1150: CASERET(DL_ATTACH_REQ);
1151: CASERET(DL_DETACH_REQ);
1152: CASERET(DL_BIND_REQ);
1153: CASERET(DL_BIND_ACK);
1154: CASERET(DL_UNBIND_REQ);
1155: CASERET(DL_OK_ACK);
1156: CASERET(DL_ERROR_ACK);
1157: CASERET(DL_SUBS_BIND_REQ);
1158: CASERET(DL_SUBS_BIND_ACK);
1159: CASERET(DL_UNITDATA_REQ);
1160: CASERET(DL_UNITDATA_IND);
1161: CASERET(DL_UDERROR_IND);
1162: CASERET(DL_UDQOS_REQ);
1163: CASERET(DL_CONNECT_REQ);
1164: CASERET(DL_CONNECT_IND);
1165: CASERET(DL_CONNECT_RES);
1166: CASERET(DL_CONNECT_CON);
1167: CASERET(DL_TOKEN_REQ);
1168: CASERET(DL_TOKEN_ACK);
1169: CASERET(DL_DISCONNECT_REQ);
1170: CASERET(DL_DISCONNECT_IND);
1171: CASERET(DL_RESET_REQ);
1172: CASERET(DL_RESET_IND);
1173: CASERET(DL_RESET_RES);
1174: CASERET(DL_RESET_CON);
1175: default:
1176: (void) sprintf(primbuf, "unknown primitive 0x%x", prim);
1177: return (primbuf);
1178: }
1179: }
1180:
1181:
1182: char*
1183: dlstate(state)
1184: u_long state;
1185: {
1186: static char statebuf[80];
1187:
1188: switch (state) {
1189: CASERET(DL_UNATTACHED);
1190: CASERET(DL_ATTACH_PENDING);
1191: CASERET(DL_DETACH_PENDING);
1192: CASERET(DL_UNBOUND);
1193: CASERET(DL_BIND_PENDING);
1194: CASERET(DL_UNBIND_PENDING);
1195: CASERET(DL_IDLE);
1196: CASERET(DL_UDQOS_PENDING);
1197: CASERET(DL_OUTCON_PENDING);
1198: CASERET(DL_INCON_PENDING);
1199: CASERET(DL_CONN_RES_PENDING);
1200: CASERET(DL_DATAXFER);
1201: CASERET(DL_USER_RESET_PENDING);
1202: CASERET(DL_PROV_RESET_PENDING);
1203: CASERET(DL_RESET_RES_PENDING);
1204: CASERET(DL_DISCON8_PENDING);
1205: CASERET(DL_DISCON9_PENDING);
1206: CASERET(DL_DISCON11_PENDING);
1207: CASERET(DL_DISCON12_PENDING);
1208: CASERET(DL_DISCON13_PENDING);
1209: CASERET(DL_SUBS_BIND_PND);
1210: default:
1211: (void) sprintf(statebuf, "unknown state 0x%x", state);
1212: return (statebuf);
1213: }
1214: }
1215:
1216: char*
1217: dlerrno(errno)
1218: u_long errno;
1219: {
1220: static char errnobuf[80];
1221:
1222: switch (errno) {
1223: CASERET(DL_ACCESS);
1224: CASERET(DL_BADADDR);
1225: CASERET(DL_BADCORR);
1226: CASERET(DL_BADDATA);
1227: CASERET(DL_BADPPA);
1228: CASERET(DL_BADPRIM);
1229: CASERET(DL_BADQOSPARAM);
1230: CASERET(DL_BADQOSTYPE);
1231: CASERET(DL_BADSAP);
1232: CASERET(DL_BADTOKEN);
1233: CASERET(DL_BOUND);
1234: CASERET(DL_INITFAILED);
1235: CASERET(DL_NOADDR);
1236: CASERET(DL_NOTINIT);
1237: CASERET(DL_OUTSTATE);
1238: CASERET(DL_SYSERR);
1239: CASERET(DL_UNSUPPORTED);
1240: CASERET(DL_UNDELIVERABLE);
1241: CASERET(DL_NOTSUPPORTED);
1242: CASERET(DL_TOOMANY);
1243: CASERET(DL_NOTENAB);
1244: CASERET(DL_BUSY);
1245: CASERET(DL_NOAUTO);
1246: CASERET(DL_NOXIDAUTO);
1247: CASERET(DL_NOTESTAUTO);
1248: CASERET(DL_XIDAUTO);
1249: CASERET(DL_TESTAUTO);
1250: CASERET(DL_PENDING);
1251:
1252: default:
1253: (void) sprintf(errnobuf, "unknown dlpi errno 0x%x", errno);
1254: return (errnobuf);
1255: }
1256: }
1257:
1258: char*
1259: dlpromisclevel(level)
1260: u_long level;
1261: {
1262: static char levelbuf[80];
1263:
1264: switch (level) {
1265: CASERET(DL_PROMISC_PHYS);
1266: CASERET(DL_PROMISC_SAP);
1267: CASERET(DL_PROMISC_MULTI);
1268: default:
1269: (void) sprintf(levelbuf, "unknown promisc level 0x%x", level);
1270: return (levelbuf);
1271: }
1272: }
1273:
1274: char*
1275: dlservicemode(servicemode)
1276: u_long servicemode;
1277: {
1278: static char servicemodebuf[80];
1279:
1280: switch (servicemode) {
1281: CASERET(DL_CODLS);
1282: CASERET(DL_CLDLS);
1283: CASERET(DL_CODLS|DL_CLDLS);
1284: default:
1285: (void) sprintf(servicemodebuf,
1286: "unknown provider service mode 0x%x", servicemode);
1287: return (servicemodebuf);
1288: }
1289: }
1290:
1291: char*
1292: dlstyle(style)
1293: long style;
1294: {
1295: static char stylebuf[80];
1296:
1297: switch (style) {
1298: CASERET(DL_STYLE1);
1299: CASERET(DL_STYLE2);
1300: default:
1301: (void) sprintf(stylebuf, "unknown provider style 0x%x", style);
1302: return (stylebuf);
1303: }
1304: }
1305:
1306: char*
1307: dlmactype(media)
1308: u_long media;
1309: {
1310: static char mediabuf[80];
1311:
1312: switch (media) {
1313: CASERET(DL_CSMACD);
1314: CASERET(DL_TPB);
1315: CASERET(DL_TPR);
1316: CASERET(DL_METRO);
1317: CASERET(DL_ETHER);
1318: CASERET(DL_HDLC);
1319: CASERET(DL_CHAR);
1320: CASERET(DL_CTCA);
1321: default:
1322: (void) sprintf(mediabuf, "unknown media type 0x%x", media);
1323: return (mediabuf);
1324: }
1325: }
1326:
1327: /*VARARGS1*/
1328: err(fmt, a1, a2, a3, a4)
1329: char *fmt;
1330: char *a1, *a2, *a3, *a4;
1331: {
1332: (void) fprintf(stderr, fmt, a1, a2, a3, a4);
1333: (void) fprintf(stderr, "\n");
1334: (void) exit(1);
1335: }
1336:
1337: syserr(s)
1338: char *s;
1339: {
1340: (void) perror(s);
1341: exit(1);
1342: }
1343:
1344: strioctl(fd, cmd, timout, len, dp)
1345: int fd;
1346: int cmd;
1347: int timout;
1348: int len;
1349: char *dp;
1350: {
1351: struct strioctl sioc;
1352: int rc;
1353:
1354: sioc.ic_cmd = cmd;
1355: sioc.ic_timout = timout;
1356: sioc.ic_len = len;
1357: sioc.ic_dp = dp;
1358: rc = ioctl(fd, I_STR, &sioc);
1359:
1360: if (rc < 0)
1361: return (rc);
1362: else
1363: return (sioc.ic_len);
1364: }
1365:
1366: #endif /* HAVE_DLPI */