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>
31 #define CASERET(s) case s: return ("s")
36 char *dlpromisclevel();
37 char *dlservicemode();
45 dl_info_req_t info_req;
49 info_req.dl_primitive = DL_INFO_REQ;
52 ctl.len = sizeof (info_req);
53 ctl.buf = (char *) &info_req;
57 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
58 syserr("dlinforeq: putmsg");
65 union DL_primitives *dlp;
69 ctl.maxlen = MAXDLBUF;
73 strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlinfoack");
75 dlp = (union DL_primitives *) ctl.buf;
77 expecting(DL_INFO_ACK, dlp);
79 if (ctl.len < sizeof (dl_info_ack_t))
80 err("dlinfoack: response ctl.len too short: %d", ctl.len);
82 if (flags != RS_HIPRI)
83 err("dlinfoack: DL_INFO_ACK was not M_PCPROTO");
85 if (ctl.len < sizeof (dl_info_ack_t))
86 err("dlinfoack: short response ctl.len: %d", ctl.len);
93 dl_attach_req_t attach_req;
97 attach_req.dl_primitive = DL_ATTACH_REQ;
98 attach_req.dl_ppa = ppa;
101 ctl.len = sizeof (attach_req);
102 ctl.buf = (char *) &attach_req;
106 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
107 syserr("dlattachreq: putmsg");
110 dlenabmultireq(fd, addr, length)
116 union DL_primitives *dlp;
120 dlp = (union DL_primitives*) buf;
122 dlp->enabmulti_req.dl_primitive = DL_ENABMULTI_REQ;
123 dlp->enabmulti_req.dl_addr_length = length;
124 dlp->enabmulti_req.dl_addr_offset = sizeof (dl_enabmulti_req_t);
126 (void) memcpy((char*)OFFADDR(buf, sizeof (dl_enabmulti_req_t)), addr, length);
129 ctl.len = sizeof (dl_enabmulti_req_t) + length;
130 ctl.buf = (char*) buf;
134 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
135 syserr("dlenabmultireq: putmsg");
138 dldisabmultireq(fd, addr, length)
144 union DL_primitives *dlp;
148 dlp = (union DL_primitives*) buf;
150 dlp->disabmulti_req.dl_primitive = DL_ENABMULTI_REQ;
151 dlp->disabmulti_req.dl_addr_length = length;
152 dlp->disabmulti_req.dl_addr_offset = sizeof (dl_disabmulti_req_t);
154 (void) memcpy((char*)OFFADDR(buf, sizeof (dl_disabmulti_req_t)), addr, length);
157 ctl.len = sizeof (dl_disabmulti_req_t) + length;
158 ctl.buf = (char*) buf;
162 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
163 syserr("dldisabmultireq: putmsg");
166 dlpromisconreq(fd, level)
170 dl_promiscon_req_t promiscon_req;
174 promiscon_req.dl_primitive = DL_PROMISCON_REQ;
175 promiscon_req.dl_level = level;
178 ctl.len = sizeof (promiscon_req);
179 ctl.buf = (char *) &promiscon_req;
183 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
184 syserr("dlpromiscon: putmsg");
188 dlpromiscoff(fd, level)
192 dl_promiscoff_req_t promiscoff_req;
196 promiscoff_req.dl_primitive = DL_PROMISCOFF_REQ;
197 promiscoff_req.dl_level = level;
200 ctl.len = sizeof (promiscoff_req);
201 ctl.buf = (char *) &promiscoff_req;
205 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
206 syserr("dlpromiscoff: putmsg");
209 dlphysaddrreq(fd, addrtype)
213 dl_phys_addr_req_t phys_addr_req;
217 phys_addr_req.dl_primitive = DL_PHYS_ADDR_REQ;
218 phys_addr_req.dl_addr_type = addrtype;
221 ctl.len = sizeof (phys_addr_req);
222 ctl.buf = (char *) &phys_addr_req;
226 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
227 syserr("dlphysaddrreq: putmsg");
230 dlsetphysaddrreq(fd, addr, length)
236 union DL_primitives *dlp;
240 dlp = (union DL_primitives*) buf;
242 dlp->set_physaddr_req.dl_primitive = DL_ENABMULTI_REQ;
243 dlp->set_physaddr_req.dl_addr_length = length;
244 dlp->set_physaddr_req.dl_addr_offset = sizeof (dl_set_phys_addr_req_t);
246 (void) memcpy((char*)OFFADDR(buf, sizeof (dl_set_phys_addr_req_t)), addr, length);
249 ctl.len = sizeof (dl_set_phys_addr_req_t) + length;
250 ctl.buf = (char*) buf;
254 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
255 syserr("dlsetphysaddrreq: putmsg");
261 dl_detach_req_t detach_req;
265 detach_req.dl_primitive = DL_DETACH_REQ;
268 ctl.len = sizeof (detach_req);
269 ctl.buf = (char *) &detach_req;
273 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
274 syserr("dldetachreq: putmsg");
277 dlbindreq(fd, sap, max_conind, service_mode, conn_mgmt, xidtest)
285 dl_bind_req_t bind_req;
289 bind_req.dl_primitive = DL_BIND_REQ;
290 bind_req.dl_sap = sap;
291 bind_req.dl_max_conind = max_conind;
292 bind_req.dl_service_mode = service_mode;
293 bind_req.dl_conn_mgmt = conn_mgmt;
294 bind_req.dl_xidtest_flg = xidtest;
297 ctl.len = sizeof (bind_req);
298 ctl.buf = (char *) &bind_req;
302 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
303 syserr("dlbindreq: putmsg");
306 dlunitdatareq(fd, addrp, addrlen, minpri, maxpri, datap, datalen)
310 u_long minpri, maxpri;
315 union DL_primitives *dlp;
316 struct strbuf data, ctl;
318 dlp = (union DL_primitives*) buf;
320 dlp->unitdata_req.dl_primitive = DL_UNITDATA_REQ;
321 dlp->unitdata_req.dl_dest_addr_length = addrlen;
322 dlp->unitdata_req.dl_dest_addr_offset = sizeof (dl_unitdata_req_t);
323 dlp->unitdata_req.dl_priority.dl_min = minpri;
324 dlp->unitdata_req.dl_priority.dl_max = maxpri;
326 (void) memcpy(OFFADDR(dlp, sizeof (dl_unitdata_req_t)), addrp, addrlen);
329 ctl.len = sizeof (dl_unitdata_req_t) + addrlen;
330 ctl.buf = (char *) buf;
334 data.buf = (char *) datap;
336 if (putmsg(fd, &ctl, &data, 0) < 0)
337 syserr("dlunitdatareq: putmsg");
343 dl_unbind_req_t unbind_req;
347 unbind_req.dl_primitive = DL_UNBIND_REQ;
350 ctl.len = sizeof (unbind_req);
351 ctl.buf = (char *) &unbind_req;
355 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0)
356 syserr("dlunbindreq: putmsg");
363 union DL_primitives *dlp;
367 ctl.maxlen = MAXDLBUF;
371 strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlokack");
373 dlp = (union DL_primitives *) ctl.buf;
375 expecting(DL_OK_ACK, dlp);
377 if (ctl.len < sizeof (dl_ok_ack_t))
378 err("dlokack: response ctl.len too short: %d", ctl.len);
380 if (flags != RS_HIPRI)
381 err("dlokack: DL_OK_ACK was not M_PCPROTO");
383 if (ctl.len < sizeof (dl_ok_ack_t))
384 err("dlokack: short response ctl.len: %d", ctl.len);
391 union DL_primitives *dlp;
395 ctl.maxlen = MAXDLBUF;
399 strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlerrorack");
401 dlp = (union DL_primitives *) ctl.buf;
403 expecting(DL_ERROR_ACK, dlp);
405 if (ctl.len < sizeof (dl_error_ack_t))
406 err("dlerrorack: response ctl.len too short: %d", ctl.len);
408 if (flags != RS_HIPRI)
409 err("dlerrorack: DL_OK_ACK was not M_PCPROTO");
411 if (ctl.len < sizeof (dl_error_ack_t))
412 err("dlerrorack: short response ctl.len: %d", ctl.len);
419 union DL_primitives *dlp;
423 ctl.maxlen = MAXDLBUF;
427 strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlbindack");
429 dlp = (union DL_primitives *) ctl.buf;
431 expecting(DL_BIND_ACK, dlp);
433 if (flags != RS_HIPRI)
434 err("dlbindack: DL_OK_ACK was not M_PCPROTO");
436 if (ctl.len < sizeof (dl_bind_ack_t))
437 err("dlbindack: short response ctl.len: %d", ctl.len);
440 dlphysaddrack(fd, bufp)
444 union DL_primitives *dlp;
448 ctl.maxlen = MAXDLBUF;
452 strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlphysaddrack");
454 dlp = (union DL_primitives *) ctl.buf;
456 expecting(DL_PHYS_ADDR_ACK, dlp);
458 if (flags != RS_HIPRI)
459 err("dlbindack: DL_OK_ACK was not M_PCPROTO");
461 if (ctl.len < sizeof (dl_phys_addr_ack_t))
462 err("dlphysaddrack: short response ctl.len: %d", ctl.len);
468 (void) err("sigalrm: TIMEOUT");
471 strgetmsg(fd, ctlp, datap, flagsp, caller)
473 struct strbuf *ctlp, *datap;
478 static char errmsg[80];
483 (void) signal(SIGALRM, sigalrm);
484 if (alarm(MAXWAIT) < 0) {
485 (void) sprintf(errmsg, "%s: alarm", caller);
490 * Set flags argument and issue getmsg().
493 if ((rc = getmsg(fd, ctlp, datap, flagsp)) < 0) {
494 (void) sprintf(errmsg, "%s: getmsg", caller);
502 (void) sprintf(errmsg, "%s: alarm", caller);
507 * Check for MOREDATA and/or MORECTL.
509 if ((rc & (MORECTL | MOREDATA)) == (MORECTL | MOREDATA))
510 err("%s: MORECTL|MOREDATA", caller);
512 err("%s: MORECTL", caller);
514 err("%s: MOREDATA", caller);
517 * Check for at least sizeof (long) control data portion.
519 if (ctlp->len < sizeof (long))
520 err("getmsg: control portion length < sizeof (long): %d", ctlp->len);
525 union DL_primitives *dlp;
527 if (dlp->dl_primitive != (u_long)prim) {
529 err("expected %s got %s", dlprim(prim),
530 dlprim(dlp->dl_primitive));
536 * Print any DLPI msg in human readable format.
539 union DL_primitives *dlp;
541 switch (dlp->dl_primitive) {
551 printdlattachreq(dlp);
559 printdlerrorack(dlp);
563 printdldetachreq(dlp);
575 printdlunbindreq(dlp);
578 case DL_SUBS_BIND_REQ:
579 printdlsubsbindreq(dlp);
582 case DL_SUBS_BIND_ACK:
583 printdlsubsbindack(dlp);
586 case DL_SUBS_UNBIND_REQ:
587 printdlsubsunbindreq(dlp);
590 case DL_ENABMULTI_REQ:
591 printdlenabmultireq(dlp);
594 case DL_DISABMULTI_REQ:
595 printdldisabmultireq(dlp);
598 case DL_PROMISCON_REQ:
599 printdlpromisconreq(dlp);
602 case DL_PROMISCOFF_REQ:
603 printdlpromiscoffreq(dlp);
606 case DL_UNITDATA_REQ:
607 printdlunitdatareq(dlp);
610 case DL_UNITDATA_IND:
611 printdlunitdataind(dlp);
615 printdluderrorind(dlp);
619 printdludqosreq(dlp);
622 case DL_PHYS_ADDR_REQ:
623 printdlphysaddrreq(dlp);
626 case DL_PHYS_ADDR_ACK:
627 printdlphysaddrack(dlp);
630 case DL_SET_PHYS_ADDR_REQ:
631 printdlsetphysaddrreq(dlp);
635 err("printdlprim: unknown primitive type 0x%x",
643 union DL_primitives *dlp;
645 (void) printf("DL_INFO_REQ\n");
649 union DL_primitives *dlp;
651 u_char addr[MAXDLADDR];
652 u_char brdcst[MAXDLADDR];
654 addrtostring(OFFADDR(dlp, dlp->info_ack.dl_addr_offset),
655 dlp->info_ack.dl_addr_length, addr);
656 addrtostring(OFFADDR(dlp, dlp->info_ack.dl_brdcst_addr_offset),
657 dlp->info_ack.dl_brdcst_addr_length, brdcst);
659 (void) printf("DL_INFO_ACK: max_sdu %d min_sdu %d\n",
660 dlp->info_ack.dl_max_sdu,
661 dlp->info_ack.dl_min_sdu);
662 (void) printf("addr_length %d mac_type %s current_state %s\n",
663 dlp->info_ack.dl_addr_length,
664 dlmactype(dlp->info_ack.dl_mac_type),
665 dlstate(dlp->info_ack.dl_current_state));
666 (void) printf("sap_length %d service_mode %s qos_length %d\n",
667 dlp->info_ack.dl_sap_length,
668 dlservicemode(dlp->info_ack.dl_service_mode),
669 dlp->info_ack.dl_qos_length);
670 (void) printf("qos_offset %d qos_range_length %d qos_range_offset %d\n",
671 dlp->info_ack.dl_qos_offset,
672 dlp->info_ack.dl_qos_range_length,
673 dlp->info_ack.dl_qos_range_offset);
674 (void) printf("provider_style %s addr_offset %d version %d\n",
675 dlstyle(dlp->info_ack.dl_provider_style),
676 dlp->info_ack.dl_addr_offset,
677 dlp->info_ack.dl_version);
678 (void) printf("brdcst_addr_length %d brdcst_addr_offset %d\n",
679 dlp->info_ack.dl_brdcst_addr_length,
680 dlp->info_ack.dl_brdcst_addr_offset);
681 (void) printf("addr %s\n", addr);
682 (void) printf("brdcst_addr %s\n", brdcst);
685 printdlattachreq(dlp)
686 union DL_primitives *dlp;
688 (void) printf("DL_ATTACH_REQ: ppa %d\n",
689 dlp->attach_req.dl_ppa);
693 union DL_primitives *dlp;
695 (void) printf("DL_OK_ACK: correct_primitive %s\n",
696 dlprim(dlp->ok_ack.dl_correct_primitive));
700 union DL_primitives *dlp;
702 (void) printf("DL_ERROR_ACK: error_primitive %s errno %s unix_errno %d\n",
703 dlprim(dlp->error_ack.dl_error_primitive),
704 dlerrno(dlp->error_ack.dl_errno),
705 dlp->error_ack.dl_unix_errno);
708 printdlenabmultireq(dlp)
709 union DL_primitives *dlp;
711 u_char addr[MAXDLADDR];
713 addrtostring(OFFADDR(dlp, dlp->enabmulti_req.dl_addr_offset),
714 dlp->enabmulti_req.dl_addr_length, addr);
716 (void) printf("DL_ENABMULTI_REQ: addr_length %d addr_offset %d\n",
717 dlp->enabmulti_req.dl_addr_length,
718 dlp->enabmulti_req.dl_addr_offset);
719 (void) printf("addr %s\n", addr);
722 printdldisabmultireq(dlp)
723 union DL_primitives *dlp;
725 u_char addr[MAXDLADDR];
727 addrtostring(OFFADDR(dlp, dlp->disabmulti_req.dl_addr_offset),
728 dlp->disabmulti_req.dl_addr_length, addr);
730 (void) printf("DL_DISABMULTI_REQ: addr_length %d addr_offset %d\n",
731 dlp->disabmulti_req.dl_addr_length,
732 dlp->disabmulti_req.dl_addr_offset);
733 (void) printf("addr %s\n", addr);
736 printdlpromisconreq(dlp)
737 union DL_primitives *dlp;
739 (void) printf("DL_PROMISCON_REQ: level %s\n",
740 dlpromisclevel(dlp->promiscon_req.dl_level));
743 printdlpromiscoffreq(dlp)
744 union DL_primitives *dlp;
746 (void) printf("DL_PROMISCOFF_REQ: level %s\n",
747 dlpromisclevel(dlp->promiscoff_req.dl_level));
750 printdlphysaddrreq(dlp)
751 union DL_primitives *dlp;
753 (void) printf("DL_PHYS_ADDR_REQ: addr_type 0x%x\n",
754 dlp->physaddr_req.dl_addr_type);
757 printdlphysaddrack(dlp)
758 union DL_primitives *dlp;
760 u_char addr[MAXDLADDR];
762 addrtostring(OFFADDR(dlp, dlp->physaddr_ack.dl_addr_offset),
763 dlp->physaddr_ack.dl_addr_length, addr);
765 (void) printf("DL_PHYS_ADDR_ACK: addr_length %d addr_offset %d\n",
766 dlp->physaddr_ack.dl_addr_length,
767 dlp->physaddr_ack.dl_addr_offset);
768 (void) printf("addr %s\n", addr);
771 printdlsetphysaddrreq(dlp)
772 union DL_primitives *dlp;
774 u_char addr[MAXDLADDR];
776 addrtostring(OFFADDR(dlp, dlp->set_physaddr_req.dl_addr_offset),
777 dlp->set_physaddr_req.dl_addr_length, addr);
779 (void) printf("DL_SET_PHYS_ADDR_REQ: addr_length %d addr_offset %d\n",
780 dlp->set_physaddr_req.dl_addr_length,
781 dlp->set_physaddr_req.dl_addr_offset);
782 (void) printf("addr %s\n", addr);
786 printdldetachreq(dlp)
787 union DL_primitives *dlp;
789 (void) printf("DL_DETACH_REQ\n");
793 union DL_primitives *dlp;
795 (void) printf("DL_BIND_REQ: sap %d max_conind %d\n",
796 dlp->bind_req.dl_sap,
797 dlp->bind_req.dl_max_conind);
798 (void) printf("service_mode %s conn_mgmt %d xidtest_flg 0x%x\n",
799 dlservicemode(dlp->bind_req.dl_service_mode),
800 dlp->bind_req.dl_conn_mgmt,
801 dlp->bind_req.dl_xidtest_flg);
805 union DL_primitives *dlp;
807 u_char addr[MAXDLADDR];
809 addrtostring(OFFADDR(dlp, dlp->bind_ack.dl_addr_offset),
810 dlp->bind_ack.dl_addr_length, addr);
812 (void) printf("DL_BIND_ACK: sap %d addr_length %d addr_offset %d\n",
813 dlp->bind_ack.dl_sap,
814 dlp->bind_ack.dl_addr_length,
815 dlp->bind_ack.dl_addr_offset);
816 (void) printf("max_conind %d xidtest_flg 0x%x\n",
817 dlp->bind_ack.dl_max_conind,
818 dlp->bind_ack.dl_xidtest_flg);
819 (void) printf("addr %s\n", addr);
823 printdlunbindreq(dlp)
824 union DL_primitives *dlp;
826 (void) printf("DL_UNBIND_REQ\n");
829 printdlsubsbindreq(dlp)
830 union DL_primitives *dlp;
832 u_char sap[MAXDLADDR];
834 addrtostring(OFFADDR(dlp, dlp->subs_bind_req.dl_subs_sap_offset),
835 dlp->subs_bind_req.dl_subs_sap_length, sap);
837 (void) printf("DL_SUBS_BIND_REQ: subs_sap_offset %d sub_sap_len %d\n",
838 dlp->subs_bind_req.dl_subs_sap_offset,
839 dlp->subs_bind_req.dl_subs_sap_length);
840 (void) printf("sap %s\n", sap);
843 printdlsubsbindack(dlp)
844 union DL_primitives *dlp;
846 u_char sap[MAXDLADDR];
848 addrtostring(OFFADDR(dlp, dlp->subs_bind_ack.dl_subs_sap_offset),
849 dlp->subs_bind_ack.dl_subs_sap_length, sap);
851 (void) printf("DL_SUBS_BIND_ACK: subs_sap_offset %d sub_sap_length %d\n",
852 dlp->subs_bind_ack.dl_subs_sap_offset,
853 dlp->subs_bind_ack.dl_subs_sap_length);
854 (void) printf("sap %s\n", sap);
857 printdlsubsunbindreq(dlp)
858 union DL_primitives *dlp;
860 u_char sap[MAXDLADDR];
862 addrtostring(OFFADDR(dlp, dlp->subs_unbind_req.dl_subs_sap_offset),
863 dlp->subs_unbind_req.dl_subs_sap_length, sap);
865 (void) printf("DL_SUBS_UNBIND_REQ: subs_sap_offset %d sub_sap_length %d\n",
866 dlp->subs_unbind_req.dl_subs_sap_offset,
867 dlp->subs_unbind_req.dl_subs_sap_length);
868 (void) printf("sap %s\n", sap);
871 printdlunitdatareq(dlp)
872 union DL_primitives *dlp;
874 u_char addr[MAXDLADDR];
876 addrtostring(OFFADDR(dlp, dlp->unitdata_req.dl_dest_addr_offset),
877 dlp->unitdata_req.dl_dest_addr_length, addr);
879 (void) printf("DL_UNITDATA_REQ: dest_addr_length %d dest_addr_offset %d\n",
880 dlp->unitdata_req.dl_dest_addr_length,
881 dlp->unitdata_req.dl_dest_addr_offset);
882 (void) printf("dl_priority.min %d dl_priority.max %d\n",
883 dlp->unitdata_req.dl_priority.dl_min,
884 dlp->unitdata_req.dl_priority.dl_max);
885 (void) printf("addr %s\n", addr);
888 printdlunitdataind(dlp)
889 union DL_primitives *dlp;
891 u_char dest[MAXDLADDR];
892 u_char src[MAXDLADDR];
894 addrtostring(OFFADDR(dlp, dlp->unitdata_ind.dl_dest_addr_offset),
895 dlp->unitdata_ind.dl_dest_addr_length, dest);
896 addrtostring(OFFADDR(dlp, dlp->unitdata_ind.dl_src_addr_offset),
897 dlp->unitdata_ind.dl_src_addr_length, src);
899 (void) printf("DL_UNITDATA_IND: dest_addr_length %d dest_addr_offset %d\n",
900 dlp->unitdata_ind.dl_dest_addr_length,
901 dlp->unitdata_ind.dl_dest_addr_offset);
902 (void) printf("src_addr_length %d src_addr_offset %d\n",
903 dlp->unitdata_ind.dl_src_addr_length,
904 dlp->unitdata_ind.dl_src_addr_offset);
905 (void) printf("group_address 0x%x\n",
906 dlp->unitdata_ind.dl_group_address);
907 (void) printf("dest %s\n", dest);
908 (void) printf("src %s\n", src);
911 printdluderrorind(dlp)
912 union DL_primitives *dlp;
914 u_char addr[MAXDLADDR];
916 addrtostring(OFFADDR(dlp, dlp->uderror_ind.dl_dest_addr_offset),
917 dlp->uderror_ind.dl_dest_addr_length, addr);
919 (void) printf("DL_UDERROR_IND: dest_addr_length %d dest_addr_offset %d\n",
920 dlp->uderror_ind.dl_dest_addr_length,
921 dlp->uderror_ind.dl_dest_addr_offset);
922 (void) printf("unix_errno %d errno %s\n",
923 dlp->uderror_ind.dl_unix_errno,
924 dlerrno(dlp->uderror_ind.dl_errno));
925 (void) printf("addr %s\n", addr);
929 union DL_primitives *dlp;
931 u_char addr[MAXDLADDR];
933 addrtostring(OFFADDR(dlp, dlp->test_req.dl_dest_addr_offset),
934 dlp->test_req.dl_dest_addr_length, addr);
936 (void) printf("DL_TEST_REQ: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
937 dlp->test_req.dl_flag,
938 dlp->test_req.dl_dest_addr_length,
939 dlp->test_req.dl_dest_addr_offset);
940 (void) printf("dest_addr %s\n", addr);
944 union DL_primitives *dlp;
946 u_char dest[MAXDLADDR];
947 u_char src[MAXDLADDR];
949 addrtostring(OFFADDR(dlp, dlp->test_ind.dl_dest_addr_offset),
950 dlp->test_ind.dl_dest_addr_length, dest);
951 addrtostring(OFFADDR(dlp, dlp->test_ind.dl_src_addr_offset),
952 dlp->test_ind.dl_src_addr_length, src);
954 (void) printf("DL_TEST_IND: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
955 dlp->test_ind.dl_flag,
956 dlp->test_ind.dl_dest_addr_length,
957 dlp->test_ind.dl_dest_addr_offset);
958 (void) printf("src_addr_length %d src_addr_offset %d\n",
959 dlp->test_ind.dl_src_addr_length,
960 dlp->test_ind.dl_src_addr_offset);
961 (void) printf("dest_addr %s\n", dest);
962 (void) printf("src_addr %s\n", src);
966 union DL_primitives *dlp;
968 u_char dest[MAXDLADDR];
970 addrtostring(OFFADDR(dlp, dlp->test_res.dl_dest_addr_offset),
971 dlp->test_res.dl_dest_addr_length, dest);
973 (void) printf("DL_TEST_RES: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
974 dlp->test_res.dl_flag,
975 dlp->test_res.dl_dest_addr_length,
976 dlp->test_res.dl_dest_addr_offset);
977 (void) printf("dest_addr %s\n", dest);
981 union DL_primitives *dlp;
983 u_char dest[MAXDLADDR];
984 u_char src[MAXDLADDR];
986 addrtostring(OFFADDR(dlp, dlp->test_con.dl_dest_addr_offset),
987 dlp->test_con.dl_dest_addr_length, dest);
988 addrtostring(OFFADDR(dlp, dlp->test_con.dl_src_addr_offset),
989 dlp->test_con.dl_src_addr_length, src);
991 (void) printf("DL_TEST_CON: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
992 dlp->test_con.dl_flag,
993 dlp->test_con.dl_dest_addr_length,
994 dlp->test_con.dl_dest_addr_offset);
995 (void) printf("src_addr_length %d src_addr_offset %d\n",
996 dlp->test_con.dl_src_addr_length,
997 dlp->test_con.dl_src_addr_offset);
998 (void) printf("dest_addr %s\n", dest);
999 (void) printf("src_addr %s\n", src);
1003 union DL_primitives *dlp;
1005 u_char dest[MAXDLADDR];
1007 addrtostring(OFFADDR(dlp, dlp->xid_req.dl_dest_addr_offset),
1008 dlp->xid_req.dl_dest_addr_length, dest);
1010 (void) printf("DL_XID_REQ: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
1011 dlp->xid_req.dl_flag,
1012 dlp->xid_req.dl_dest_addr_length,
1013 dlp->xid_req.dl_dest_addr_offset);
1014 (void) printf("dest_addr %s\n", dest);
1018 union DL_primitives *dlp;
1020 u_char dest[MAXDLADDR];
1021 u_char src[MAXDLADDR];
1023 addrtostring(OFFADDR(dlp, dlp->xid_ind.dl_dest_addr_offset),
1024 dlp->xid_ind.dl_dest_addr_length, dest);
1025 addrtostring(OFFADDR(dlp, dlp->xid_ind.dl_src_addr_offset),
1026 dlp->xid_ind.dl_src_addr_length, src);
1028 (void) printf("DL_XID_IND: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
1029 dlp->xid_ind.dl_flag,
1030 dlp->xid_ind.dl_dest_addr_length,
1031 dlp->xid_ind.dl_dest_addr_offset);
1032 (void) printf("src_addr_length %d src_addr_offset %d\n",
1033 dlp->xid_ind.dl_src_addr_length,
1034 dlp->xid_ind.dl_src_addr_offset);
1035 (void) printf("dest_addr %s\n", dest);
1036 (void) printf("src_addr %s\n", src);
1040 union DL_primitives *dlp;
1042 u_char dest[MAXDLADDR];
1044 addrtostring(OFFADDR(dlp, dlp->xid_res.dl_dest_addr_offset),
1045 dlp->xid_res.dl_dest_addr_length, dest);
1047 (void) printf("DL_XID_RES: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
1048 dlp->xid_res.dl_flag,
1049 dlp->xid_res.dl_dest_addr_length,
1050 dlp->xid_res.dl_dest_addr_offset);
1051 (void) printf("dest_addr %s\n", dest);
1055 union DL_primitives *dlp;
1057 u_char dest[MAXDLADDR];
1058 u_char src[MAXDLADDR];
1060 addrtostring(OFFADDR(dlp, dlp->xid_con.dl_dest_addr_offset),
1061 dlp->xid_con.dl_dest_addr_length, dest);
1062 addrtostring(OFFADDR(dlp, dlp->xid_con.dl_src_addr_offset),
1063 dlp->xid_con.dl_src_addr_length, src);
1065 (void) printf("DL_XID_CON: flag 0x%x dest_addr_length %d dest_addr_offset %d\n",
1066 dlp->xid_con.dl_flag,
1067 dlp->xid_con.dl_dest_addr_length,
1068 dlp->xid_con.dl_dest_addr_offset);
1069 (void) printf("src_addr_length %d src_addr_offset %d\n",
1070 dlp->xid_con.dl_src_addr_length,
1071 dlp->xid_con.dl_src_addr_offset);
1072 (void) printf("dest_addr %s\n", dest);
1073 (void) printf("src_addr %s\n", src);
1076 printdludqosreq(dlp)
1077 union DL_primitives *dlp;
1079 (void) printf("DL_UDQOS_REQ: qos_length %d qos_offset %d\n",
1080 dlp->udqos_req.dl_qos_length,
1081 dlp->udqos_req.dl_qos_offset);
1087 addrtostring(addr, length, s)
1094 for (i = 0; i < length; i++) {
1095 (void) sprintf((char*) s, "%x:", addr[i] & 0xff);
1096 s = s + strlen((char*)s);
1105 stringtoaddr(sp, addr)
1114 while (p = strtok(p, ":")) {
1115 if (sscanf(p, "%x", &val) != 1)
1116 err("stringtoaddr: invalid input string: %s", sp);
1118 err("stringtoaddr: invalid input string: %s", sp);
1132 static char hextab[] = {
1133 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
1134 'a', 'b', 'c', 'd', 'e', 'f'
1137 return (hextab[c & 0x0f]);
1144 static char primbuf[80];
1146 switch ((int)prim) {
1147 CASERET(DL_INFO_REQ);
1148 CASERET(DL_INFO_ACK);
1149 CASERET(DL_ATTACH_REQ);
1150 CASERET(DL_DETACH_REQ);
1151 CASERET(DL_BIND_REQ);
1152 CASERET(DL_BIND_ACK);
1153 CASERET(DL_UNBIND_REQ);
1155 CASERET(DL_ERROR_ACK);
1156 CASERET(DL_SUBS_BIND_REQ);
1157 CASERET(DL_SUBS_BIND_ACK);
1158 CASERET(DL_UNITDATA_REQ);
1159 CASERET(DL_UNITDATA_IND);
1160 CASERET(DL_UDERROR_IND);
1161 CASERET(DL_UDQOS_REQ);
1162 CASERET(DL_CONNECT_REQ);
1163 CASERET(DL_CONNECT_IND);
1164 CASERET(DL_CONNECT_RES);
1165 CASERET(DL_CONNECT_CON);
1166 CASERET(DL_TOKEN_REQ);
1167 CASERET(DL_TOKEN_ACK);
1168 CASERET(DL_DISCONNECT_REQ);
1169 CASERET(DL_DISCONNECT_IND);
1170 CASERET(DL_RESET_REQ);
1171 CASERET(DL_RESET_IND);
1172 CASERET(DL_RESET_RES);
1173 CASERET(DL_RESET_CON);
1175 (void) sprintf(primbuf, "unknown primitive 0x%x", prim);
1185 static char statebuf[80];
1188 CASERET(DL_UNATTACHED);
1189 CASERET(DL_ATTACH_PENDING);
1190 CASERET(DL_DETACH_PENDING);
1191 CASERET(DL_UNBOUND);
1192 CASERET(DL_BIND_PENDING);
1193 CASERET(DL_UNBIND_PENDING);
1195 CASERET(DL_UDQOS_PENDING);
1196 CASERET(DL_OUTCON_PENDING);
1197 CASERET(DL_INCON_PENDING);
1198 CASERET(DL_CONN_RES_PENDING);
1199 CASERET(DL_DATAXFER);
1200 CASERET(DL_USER_RESET_PENDING);
1201 CASERET(DL_PROV_RESET_PENDING);
1202 CASERET(DL_RESET_RES_PENDING);
1203 CASERET(DL_DISCON8_PENDING);
1204 CASERET(DL_DISCON9_PENDING);
1205 CASERET(DL_DISCON11_PENDING);
1206 CASERET(DL_DISCON12_PENDING);
1207 CASERET(DL_DISCON13_PENDING);
1208 CASERET(DL_SUBS_BIND_PND);
1210 (void) sprintf(statebuf, "unknown state 0x%x", state);
1219 static char errnobuf[80];
1223 CASERET(DL_BADADDR);
1224 CASERET(DL_BADCORR);
1225 CASERET(DL_BADDATA);
1227 CASERET(DL_BADPRIM);
1228 CASERET(DL_BADQOSPARAM);
1229 CASERET(DL_BADQOSTYPE);
1231 CASERET(DL_BADTOKEN);
1233 CASERET(DL_INITFAILED);
1235 CASERET(DL_NOTINIT);
1236 CASERET(DL_OUTSTATE);
1238 CASERET(DL_UNSUPPORTED);
1239 CASERET(DL_UNDELIVERABLE);
1240 CASERET(DL_NOTSUPPORTED);
1241 CASERET(DL_TOOMANY);
1242 CASERET(DL_NOTENAB);
1245 CASERET(DL_NOXIDAUTO);
1246 CASERET(DL_NOTESTAUTO);
1247 CASERET(DL_XIDAUTO);
1248 CASERET(DL_TESTAUTO);
1249 CASERET(DL_PENDING);
1252 (void) sprintf(errnobuf, "unknown dlpi errno 0x%x", errno);
1258 dlpromisclevel(level)
1261 static char levelbuf[80];
1264 CASERET(DL_PROMISC_PHYS);
1265 CASERET(DL_PROMISC_SAP);
1266 CASERET(DL_PROMISC_MULTI);
1268 (void) sprintf(levelbuf, "unknown promisc level 0x%x", level);
1274 dlservicemode(servicemode)
1277 static char servicemodebuf[80];
1279 switch (servicemode) {
1282 CASERET(DL_CODLS|DL_CLDLS);
1284 (void) sprintf(servicemodebuf,
1285 "unknown provider service mode 0x%x", servicemode);
1286 return (servicemodebuf);
1294 static char stylebuf[80];
1300 (void) sprintf(stylebuf, "unknown provider style 0x%x", style);
1309 static char mediabuf[80];
1321 (void) sprintf(mediabuf, "unknown media type 0x%x", media);
1327 err(fmt, a1, a2, a3, a4)
1329 char *a1, *a2, *a3, *a4;
1331 (void) fprintf(stderr, fmt, a1, a2, a3, a4);
1332 (void) fprintf(stderr, "\n");
1343 strioctl(fd, cmd, timout, len, dp)
1350 struct strioctl sioc;
1354 sioc.ic_timout = timout;
1357 rc = ioctl(fd, I_STR, &sioc);
1362 return (sioc.ic_len);
1365 #endif /* HAVE_DLPI */