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