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.
9 * Connection Oriented stuff
18 typedef unsigned long ulong;
22 #include <sys/types.h>
23 #include <sys/stream.h>
24 #include <sys/stropts.h>
26 #include <sys/signal.h>
32 #define CASERET(s) case s: return ("s")
37 char *dlpromisclevel();
38 char *dlservicemode();
46 dl_info_req_t info_req;
50 info_req.dl_primitive = DL_INFO_REQ;
53 ctl.len = sizeof (info_req);
54 ctl.buf = (char *) &info_req;
58 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
59 syserr("dlinforeq: putmsg");
66 union DL_primitives *dlp;
70 ctl.maxlen = MAXDLBUF;
74 strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlinfoack");
76 dlp = (union DL_primitives *) ctl.buf;
78 expecting(DL_INFO_ACK, dlp);
80 if (ctl.len < sizeof (dl_info_ack_t))
81 err("dlinfoack: response ctl.len too short: %d", ctl.len);
83 if (flags != RS_HIPRI)
84 err("dlinfoack: DL_INFO_ACK was not M_PCPROTO");
86 if (ctl.len < sizeof (dl_info_ack_t))
87 err("dlinfoack: short response ctl.len: %d", ctl.len);
94 dl_attach_req_t attach_req;
98 attach_req.dl_primitive = DL_ATTACH_REQ;
99 attach_req.dl_ppa = ppa;
102 ctl.len = sizeof (attach_req);
103 ctl.buf = (char *) &attach_req;
107 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
108 syserr("dlattachreq: putmsg");
111 dlenabmultireq(fd, addr, length)
117 union DL_primitives *dlp;
121 dlp = (union DL_primitives*) buf;
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);
127 (void) memcpy((char*)OFFADDR(buf, sizeof (dl_enabmulti_req_t)), addr, length);
130 ctl.len = sizeof (dl_enabmulti_req_t) + length;
131 ctl.buf = (char*) buf;
135 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
136 syserr("dlenabmultireq: putmsg");
139 dldisabmultireq(fd, addr, length)
145 union DL_primitives *dlp;
149 dlp = (union DL_primitives*) buf;
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);
155 (void) memcpy((char*)OFFADDR(buf, sizeof (dl_disabmulti_req_t)), addr, length);
158 ctl.len = sizeof (dl_disabmulti_req_t) + length;
159 ctl.buf = (char*) buf;
163 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
164 syserr("dldisabmultireq: putmsg");
167 dlpromisconreq(fd, level)
171 dl_promiscon_req_t promiscon_req;
175 promiscon_req.dl_primitive = DL_PROMISCON_REQ;
176 promiscon_req.dl_level = level;
179 ctl.len = sizeof (promiscon_req);
180 ctl.buf = (char *) &promiscon_req;
184 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
185 syserr("dlpromiscon: putmsg");
189 dlpromiscoff(fd, level)
193 dl_promiscoff_req_t promiscoff_req;
197 promiscoff_req.dl_primitive = DL_PROMISCOFF_REQ;
198 promiscoff_req.dl_level = level;
201 ctl.len = sizeof (promiscoff_req);
202 ctl.buf = (char *) &promiscoff_req;
206 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
207 syserr("dlpromiscoff: putmsg");
210 dlphysaddrreq(fd, addrtype)
214 dl_phys_addr_req_t phys_addr_req;
218 phys_addr_req.dl_primitive = DL_PHYS_ADDR_REQ;
219 phys_addr_req.dl_addr_type = addrtype;
222 ctl.len = sizeof (phys_addr_req);
223 ctl.buf = (char *) &phys_addr_req;
227 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
228 syserr("dlphysaddrreq: putmsg");
231 dlsetphysaddrreq(fd, addr, length)
237 union DL_primitives *dlp;
241 dlp = (union DL_primitives*) buf;
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);
247 (void) memcpy((char*)OFFADDR(buf, sizeof (dl_set_phys_addr_req_t)), addr, length);
250 ctl.len = sizeof (dl_set_phys_addr_req_t) + length;
251 ctl.buf = (char*) buf;
255 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
256 syserr("dlsetphysaddrreq: putmsg");
262 dl_detach_req_t detach_req;
266 detach_req.dl_primitive = DL_DETACH_REQ;
269 ctl.len = sizeof (detach_req);
270 ctl.buf = (char *) &detach_req;
274 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
275 syserr("dldetachreq: putmsg");
278 dlbindreq(fd, sap, max_conind, service_mode, conn_mgmt, xidtest)
286 dl_bind_req_t bind_req;
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;
298 ctl.len = sizeof (bind_req);
299 ctl.buf = (char *) &bind_req;
303 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
304 syserr("dlbindreq: putmsg");
307 dlunitdatareq(fd, addrp, addrlen, minpri, maxpri, datap, datalen)
311 u_long minpri, maxpri;
316 union DL_primitives *dlp;
317 struct strbuf data, ctl;
319 dlp = (union DL_primitives*) buf;
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;
327 (void) memcpy(OFFADDR(dlp, sizeof (dl_unitdata_req_t)), addrp, addrlen);
330 ctl.len = sizeof (dl_unitdata_req_t) + addrlen;
331 ctl.buf = (char *) buf;
335 data.buf = (char *) datap;
337 if (putmsg(fd, &ctl, &data, 0) < 0)
338 syserr("dlunitdatareq: putmsg");
344 dl_unbind_req_t unbind_req;
348 unbind_req.dl_primitive = DL_UNBIND_REQ;
351 ctl.len = sizeof (unbind_req);
352 ctl.buf = (char *) &unbind_req;
356 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
357 syserr("dlunbindreq: putmsg");
364 union DL_primitives *dlp;
368 ctl.maxlen = MAXDLBUF;
372 strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlokack");
374 dlp = (union DL_primitives *) ctl.buf;
376 expecting(DL_OK_ACK, dlp);
378 if (ctl.len < sizeof (dl_ok_ack_t))
379 err("dlokack: response ctl.len too short: %d", ctl.len);
381 if (flags != RS_HIPRI)
382 err("dlokack: DL_OK_ACK was not M_PCPROTO");
384 if (ctl.len < sizeof (dl_ok_ack_t))
385 err("dlokack: short response ctl.len: %d", ctl.len);
392 union DL_primitives *dlp;
396 ctl.maxlen = MAXDLBUF;
400 strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlerrorack");
402 dlp = (union DL_primitives *) ctl.buf;
404 expecting(DL_ERROR_ACK, dlp);
406 if (ctl.len < sizeof (dl_error_ack_t))
407 err("dlerrorack: response ctl.len too short: %d", ctl.len);
409 if (flags != RS_HIPRI)
410 err("dlerrorack: DL_OK_ACK was not M_PCPROTO");
412 if (ctl.len < sizeof (dl_error_ack_t))
413 err("dlerrorack: short response ctl.len: %d", ctl.len);
420 union DL_primitives *dlp;
424 ctl.maxlen = MAXDLBUF;
428 strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlbindack");
430 dlp = (union DL_primitives *) ctl.buf;
432 expecting(DL_BIND_ACK, dlp);
434 if (flags != RS_HIPRI)
435 err("dlbindack: DL_OK_ACK was not M_PCPROTO");
437 if (ctl.len < sizeof (dl_bind_ack_t))
438 err("dlbindack: short response ctl.len: %d", ctl.len);
441 dlphysaddrack(fd, bufp)
445 union DL_primitives *dlp;
449 ctl.maxlen = MAXDLBUF;
453 strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlphysaddrack");
455 dlp = (union DL_primitives *) ctl.buf;
457 expecting(DL_PHYS_ADDR_ACK, dlp);
459 if (flags != RS_HIPRI)
460 err("dlbindack: DL_OK_ACK was not M_PCPROTO");
462 if (ctl.len < sizeof (dl_phys_addr_ack_t))
463 err("dlphysaddrack: short response ctl.len: %d", ctl.len);
469 (void) err("sigalrm: TIMEOUT");
472 strgetmsg(fd, ctlp, datap, flagsp, caller)
474 struct strbuf *ctlp, *datap;
479 static char errmsg[80];
484 (void) signal(SIGALRM, sigalrm);
485 if (alarm(MAXWAIT) < 0) {
486 (void) sprintf(errmsg, "%s: alarm", caller);
491 * Set flags argument and issue getmsg().
494 if ((rc = getmsg(fd, ctlp, datap, flagsp)) < 0) {
495 (void) sprintf(errmsg, "%s: getmsg", caller);
503 (void) sprintf(errmsg, "%s: alarm", caller);
508 * Check for MOREDATA and/or MORECTL.
510 if ((rc & (MORECTL | MOREDATA)) == (MORECTL | MOREDATA))
511 err("%s: MORECTL|MOREDATA", caller);
513 err("%s: MORECTL", caller);
515 err("%s: MOREDATA", caller);
518 * Check for at least sizeof (long) control data portion.
520 if (ctlp->len < sizeof (long))
521 err("getmsg: control portion length < sizeof (long): %d", ctlp->len);
526 union DL_primitives *dlp;
528 if (dlp->dl_primitive != (u_long)prim) {
530 err("expected %s got %s", dlprim(prim),
531 dlprim(dlp->dl_primitive));
537 * Print any DLPI msg in human readable format.
540 union DL_primitives *dlp;
542 switch (dlp->dl_primitive) {
552 printdlattachreq(dlp);
560 printdlerrorack(dlp);
564 printdldetachreq(dlp);
576 printdlunbindreq(dlp);
579 case DL_SUBS_BIND_REQ:
580 printdlsubsbindreq(dlp);
583 case DL_SUBS_BIND_ACK:
584 printdlsubsbindack(dlp);
587 case DL_SUBS_UNBIND_REQ:
588 printdlsubsunbindreq(dlp);
591 case DL_ENABMULTI_REQ:
592 printdlenabmultireq(dlp);
595 case DL_DISABMULTI_REQ:
596 printdldisabmultireq(dlp);
599 case DL_PROMISCON_REQ:
600 printdlpromisconreq(dlp);
603 case DL_PROMISCOFF_REQ:
604 printdlpromiscoffreq(dlp);
607 case DL_UNITDATA_REQ:
608 printdlunitdatareq(dlp);
611 case DL_UNITDATA_IND:
612 printdlunitdataind(dlp);
616 printdluderrorind(dlp);
620 printdludqosreq(dlp);
623 case DL_PHYS_ADDR_REQ:
624 printdlphysaddrreq(dlp);
627 case DL_PHYS_ADDR_ACK:
628 printdlphysaddrack(dlp);
631 case DL_SET_PHYS_ADDR_REQ:
632 printdlsetphysaddrreq(dlp);
636 err("printdlprim: unknown primitive type 0x%x",
644 union DL_primitives *dlp;
646 (void) printf("DL_INFO_REQ\n");
650 union DL_primitives *dlp;
652 u_char addr[MAXDLADDR];
653 u_char brdcst[MAXDLADDR];
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);
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);
686 printdlattachreq(dlp)
687 union DL_primitives *dlp;
689 (void) printf("DL_ATTACH_REQ: ppa %d\n",
690 dlp->attach_req.dl_ppa);
694 union DL_primitives *dlp;
696 (void) printf("DL_OK_ACK: correct_primitive %s\n",
697 dlprim(dlp->ok_ack.dl_correct_primitive));
701 union DL_primitives *dlp;
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);
709 printdlenabmultireq(dlp)
710 union DL_primitives *dlp;
712 u_char addr[MAXDLADDR];
714 addrtostring(OFFADDR(dlp, dlp->enabmulti_req.dl_addr_offset),
715 dlp->enabmulti_req.dl_addr_length, addr);
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);
723 printdldisabmultireq(dlp)
724 union DL_primitives *dlp;
726 u_char addr[MAXDLADDR];
728 addrtostring(OFFADDR(dlp, dlp->disabmulti_req.dl_addr_offset),
729 dlp->disabmulti_req.dl_addr_length, addr);
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);
737 printdlpromisconreq(dlp)
738 union DL_primitives *dlp;
740 (void) printf("DL_PROMISCON_REQ: level %s\n",
741 dlpromisclevel(dlp->promiscon_req.dl_level));
744 printdlpromiscoffreq(dlp)
745 union DL_primitives *dlp;
747 (void) printf("DL_PROMISCOFF_REQ: level %s\n",
748 dlpromisclevel(dlp->promiscoff_req.dl_level));
751 printdlphysaddrreq(dlp)
752 union DL_primitives *dlp;
754 (void) printf("DL_PHYS_ADDR_REQ: addr_type 0x%x\n",
755 dlp->physaddr_req.dl_addr_type);
758 printdlphysaddrack(dlp)
759 union DL_primitives *dlp;
761 u_char addr[MAXDLADDR];
763 addrtostring(OFFADDR(dlp, dlp->physaddr_ack.dl_addr_offset),
764 dlp->physaddr_ack.dl_addr_length, addr);
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);
772 printdlsetphysaddrreq(dlp)
773 union DL_primitives *dlp;
775 u_char addr[MAXDLADDR];
777 addrtostring(OFFADDR(dlp, dlp->set_physaddr_req.dl_addr_offset),
778 dlp->set_physaddr_req.dl_addr_length, addr);
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);
787 printdldetachreq(dlp)
788 union DL_primitives *dlp;
790 (void) printf("DL_DETACH_REQ\n");
794 union DL_primitives *dlp;
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);
806 union DL_primitives *dlp;
808 u_char addr[MAXDLADDR];
810 addrtostring(OFFADDR(dlp, dlp->bind_ack.dl_addr_offset),
811 dlp->bind_ack.dl_addr_length, addr);
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);
824 printdlunbindreq(dlp)
825 union DL_primitives *dlp;
827 (void) printf("DL_UNBIND_REQ\n");
830 printdlsubsbindreq(dlp)
831 union DL_primitives *dlp;
833 u_char sap[MAXDLADDR];
835 addrtostring(OFFADDR(dlp, dlp->subs_bind_req.dl_subs_sap_offset),
836 dlp->subs_bind_req.dl_subs_sap_length, sap);
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);
844 printdlsubsbindack(dlp)
845 union DL_primitives *dlp;
847 u_char sap[MAXDLADDR];
849 addrtostring(OFFADDR(dlp, dlp->subs_bind_ack.dl_subs_sap_offset),
850 dlp->subs_bind_ack.dl_subs_sap_length, sap);
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);
858 printdlsubsunbindreq(dlp)
859 union DL_primitives *dlp;
861 u_char sap[MAXDLADDR];
863 addrtostring(OFFADDR(dlp, dlp->subs_unbind_req.dl_subs_sap_offset),
864 dlp->subs_unbind_req.dl_subs_sap_length, sap);
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);
872 printdlunitdatareq(dlp)
873 union DL_primitives *dlp;
875 u_char addr[MAXDLADDR];
877 addrtostring(OFFADDR(dlp, dlp->unitdata_req.dl_dest_addr_offset),
878 dlp->unitdata_req.dl_dest_addr_length, addr);
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);
889 printdlunitdataind(dlp)
890 union DL_primitives *dlp;
892 u_char dest[MAXDLADDR];
893 u_char src[MAXDLADDR];
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);
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);
912 printdluderrorind(dlp)
913 union DL_primitives *dlp;
915 u_char addr[MAXDLADDR];
917 addrtostring(OFFADDR(dlp, dlp->uderror_ind.dl_dest_addr_offset),
918 dlp->uderror_ind.dl_dest_addr_length, addr);
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);
930 union DL_primitives *dlp;
932 u_char addr[MAXDLADDR];
934 addrtostring(OFFADDR(dlp, dlp->test_req.dl_dest_addr_offset),
935 dlp->test_req.dl_dest_addr_length, addr);
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);
945 union DL_primitives *dlp;
947 u_char dest[MAXDLADDR];
948 u_char src[MAXDLADDR];
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);
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);
967 union DL_primitives *dlp;
969 u_char dest[MAXDLADDR];
971 addrtostring(OFFADDR(dlp, dlp->test_res.dl_dest_addr_offset),
972 dlp->test_res.dl_dest_addr_length, dest);
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);
982 union DL_primitives *dlp;
984 u_char dest[MAXDLADDR];
985 u_char src[MAXDLADDR];
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);
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);
1004 union DL_primitives *dlp;
1006 u_char dest[MAXDLADDR];
1008 addrtostring(OFFADDR(dlp, dlp->xid_req.dl_dest_addr_offset),
1009 dlp->xid_req.dl_dest_addr_length, dest);
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);
1019 union DL_primitives *dlp;
1021 u_char dest[MAXDLADDR];
1022 u_char src[MAXDLADDR];
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);
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);
1041 union DL_primitives *dlp;
1043 u_char dest[MAXDLADDR];
1045 addrtostring(OFFADDR(dlp, dlp->xid_res.dl_dest_addr_offset),
1046 dlp->xid_res.dl_dest_addr_length, dest);
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);
1056 union DL_primitives *dlp;
1058 u_char dest[MAXDLADDR];
1059 u_char src[MAXDLADDR];
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);
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);
1077 printdludqosreq(dlp)
1078 union DL_primitives *dlp;
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);
1088 addrtostring(addr, length, s)
1095 for (i = 0; i < length; i++) {
1096 (void) sprintf((char*) s, "%x:", addr[i] & 0xff);
1097 s = s + strlen((char*)s);
1106 stringtoaddr(sp, addr)
1115 while (p = strtok(p, ":")) {
1116 if (sscanf(p, "%x", &val) != 1)
1117 err("stringtoaddr: invalid input string: %s", sp);
1119 err("stringtoaddr: invalid input string: %s", sp);
1133 static char hextab[] = {
1134 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
1135 'a', 'b', 'c', 'd', 'e', 'f'
1138 return (hextab[c & 0x0f]);
1145 static char primbuf[80];
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);
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);
1176 (void) sprintf(primbuf, "unknown primitive 0x%x", prim);
1186 static char statebuf[80];
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);
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);
1211 (void) sprintf(statebuf, "unknown state 0x%x", state);
1220 static char errnobuf[80];
1224 CASERET(DL_BADADDR);
1225 CASERET(DL_BADCORR);
1226 CASERET(DL_BADDATA);
1228 CASERET(DL_BADPRIM);
1229 CASERET(DL_BADQOSPARAM);
1230 CASERET(DL_BADQOSTYPE);
1232 CASERET(DL_BADTOKEN);
1234 CASERET(DL_INITFAILED);
1236 CASERET(DL_NOTINIT);
1237 CASERET(DL_OUTSTATE);
1239 CASERET(DL_UNSUPPORTED);
1240 CASERET(DL_UNDELIVERABLE);
1241 CASERET(DL_NOTSUPPORTED);
1242 CASERET(DL_TOOMANY);
1243 CASERET(DL_NOTENAB);
1246 CASERET(DL_NOXIDAUTO);
1247 CASERET(DL_NOTESTAUTO);
1248 CASERET(DL_XIDAUTO);
1249 CASERET(DL_TESTAUTO);
1250 CASERET(DL_PENDING);
1253 (void) sprintf(errnobuf, "unknown dlpi errno 0x%x", errno);
1259 dlpromisclevel(level)
1262 static char levelbuf[80];
1265 CASERET(DL_PROMISC_PHYS);
1266 CASERET(DL_PROMISC_SAP);
1267 CASERET(DL_PROMISC_MULTI);
1269 (void) sprintf(levelbuf, "unknown promisc level 0x%x", level);
1275 dlservicemode(servicemode)
1278 static char servicemodebuf[80];
1280 switch (servicemode) {
1283 CASERET(DL_CODLS|DL_CLDLS);
1285 (void) sprintf(servicemodebuf,
1286 "unknown provider service mode 0x%x", servicemode);
1287 return (servicemodebuf);
1295 static char stylebuf[80];
1301 (void) sprintf(stylebuf, "unknown provider style 0x%x", style);
1310 static char mediabuf[80];
1322 (void) sprintf(mediabuf, "unknown media type 0x%x", media);
1328 err(fmt, a1, a2, a3, a4)
1330 char *a1, *a2, *a3, *a4;
1332 (void) fprintf(stderr, fmt, a1, a2, a3, a4);
1333 (void) fprintf(stderr, "\n");
1344 strioctl(fd, cmd, timout, len, dp)
1351 struct strioctl sioc;
1355 sioc.ic_timout = timout;
1358 rc = ioctl(fd, I_STR, &sioc);
1363 return (sioc.ic_len);
1366 #endif /* HAVE_DLPI */