1 /* 2 * Redistribution and use in source and binary forms, with or without 3 * modification, are permitted provided that: (1) source code 4 * distributions retain the above copyright notice and this paragraph 5 * in its entirety, and (2) distributions including binary code include 6 * the above copyright notice and this paragraph in its entirety in 7 * the documentation or other materials provided with the distribution. 8 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND 9 * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT 10 * LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 11 * FOR A PARTICULAR PURPOSE. 12 * 13 * Original code by Andy Heffernan (ahh@juniper.net) 14 */ 15 16 #ifndef lint 17 static const char rcsid[] _U_ = 18 "@(#) $Header: /tcpdump/master/tcpdump/print-pgm.c,v 1.1.2.5 2005/06/07 22:06:16 guy Exp $"; 19 #endif 20 21 #ifdef HAVE_CONFIG_H 22 #include "config.h" 23 #endif 24 25 #include <tcpdump-stdinc.h> 26 27 #include <stdio.h> 28 #include <stdlib.h> 29 #include <string.h> 30 31 #include "interface.h" 32 #include "extract.h" 33 #include "addrtoname.h" 34 35 #include "ip.h" 36 #ifdef INET6 37 #include "ip6.h" 38 #endif 39 #include "ipproto.h" 40 41 /* 42 * PGM header (RFC 3208) 43 */ 44 struct pgm_header { 45 u_int16_t pgm_sport; 46 u_int16_t pgm_dport; 47 u_int8_t pgm_type; 48 u_int8_t pgm_options; 49 u_int16_t pgm_sum; 50 u_int8_t pgm_gsid[6]; 51 u_int16_t pgm_length; 52 }; 53 54 struct pgm_spm { 55 u_int32_t pgms_seq; 56 u_int32_t pgms_trailseq; 57 u_int32_t pgms_leadseq; 58 u_int16_t pgms_nla_afi; 59 u_int16_t pgms_reserved; 60 /* ... u_int8_t pgms_nla[0]; */ 61 /* ... options */ 62 }; 63 64 struct pgm_nak { 65 u_int32_t pgmn_seq; 66 u_int16_t pgmn_source_afi; 67 u_int16_t pgmn_reserved; 68 /* ... u_int8_t pgmn_source[0]; */ 69 /* ... u_int16_t pgmn_group_afi */ 70 /* ... u_int16_t pgmn_reserved2; */ 71 /* ... u_int8_t pgmn_group[0]; */ 72 /* ... options */ 73 }; 74 75 struct pgm_poll { 76 u_int32_t pgmp_seq; 77 u_int16_t pgmp_round; 78 u_int16_t pgmp_reserved; 79 /* ... options */ 80 }; 81 82 struct pgm_polr { 83 u_int32_t pgmp_seq; 84 u_int16_t pgmp_round; 85 u_int16_t pgmp_subtype; 86 u_int16_t pgmp_nla_afi; 87 u_int16_t pgmp_reserved; 88 /* ... u_int8_t pgmp_nla[0]; */ 89 /* ... options */ 90 }; 91 92 struct pgm_data { 93 u_int32_t pgmd_seq; 94 u_int32_t pgmd_trailseq; 95 /* ... options */ 96 }; 97 98 typedef enum _pgm_type { 99 PGM_SPM = 0, /* source path message */ 100 PGM_POLL = 1, /* POLL Request */ 101 PGM_POLR = 2, /* POLL Response */ 102 PGM_ODATA = 4, /* original data */ 103 PGM_RDATA = 5, /* repair data */ 104 PGM_NAK = 8, /* NAK */ 105 PGM_NULLNAK = 9, /* Null NAK */ 106 PGM_NCF = 10, /* NAK Confirmation */ 107 PGM_ACK = 11, /* ACK for congestion control */ 108 PGM_SPMR = 12, /* SPM request */ 109 PGM_MAX = 255 110 } pgm_type; 111 112 #define PGM_OPT_BIT_PRESENT 0x01 113 #define PGM_OPT_BIT_NETWORK 0x02 114 #define PGM_OPT_BIT_VAR_PKTLEN 0x40 115 #define PGM_OPT_BIT_PARITY 0x80 116 117 #define PGM_OPT_LENGTH 0x00 118 #define PGM_OPT_FRAGMENT 0x01 119 #define PGM_OPT_NAK_LIST 0x02 120 #define PGM_OPT_JOIN 0x03 121 #define PGM_OPT_NAK_BO_IVL 0x04 122 #define PGM_OPT_NAK_BO_RNG 0x05 123 124 #define PGM_OPT_REDIRECT 0x07 125 #define PGM_OPT_PARITY_PRM 0x08 126 #define PGM_OPT_PARITY_GRP 0x09 127 #define PGM_OPT_CURR_TGSIZE 0x0A 128 #define PGM_OPT_NBR_UNREACH 0x0B 129 #define PGM_OPT_PATH_NLA 0x0C 130 131 #define PGM_OPT_SYN 0x0D 132 #define PGM_OPT_FIN 0x0E 133 #define PGM_OPT_RST 0x0F 134 #define PGM_OPT_CR 0x10 135 #define PGM_OPT_CRQST 0x11 136 137 #define PGM_OPT_MASK 0x7f 138 139 #define PGM_OPT_END 0x80 /* end of options marker */ 140 141 #define PGM_MIN_OPT_LEN 4 142 143 #ifndef AFI_IP 144 #define AFI_IP 1 145 #define AFI_IP6 2 146 #endif 147 148 void 149 pgm_print(register const u_char *bp, register u_int length, 150 register const u_char *bp2) 151 { 152 register const struct pgm_header *pgm; 153 register const struct ip *ip; 154 register char ch; 155 u_int16_t sport, dport; 156 int addr_size; 157 const void *nla; 158 int nla_af; 159 #ifdef INET6 160 char nla_buf[INET6_ADDRSTRLEN]; 161 register const struct ip6_hdr *ip6; 162 #else 163 char nla_buf[INET_ADDRSTRLEN]; 164 #endif 165 u_int8_t opt_type, opt_len, flags1, flags2; 166 u_int32_t seq, opts_len, len, offset; 167 168 pgm = (struct pgm_header *)bp; 169 ip = (struct ip *)bp2; 170 #ifdef INET6 171 if (IP_V(ip) == 6) 172 ip6 = (struct ip6_hdr *)bp2; 173 else 174 ip6 = NULL; 175 #else /* INET6 */ 176 if (IP_V(ip) == 6) { 177 (void)printf("Can't handle IPv6"); 178 return; 179 } 180 #endif /* INET6 */ 181 ch = '\0'; 182 if (!TTEST(pgm->pgm_dport)) { 183 #ifdef INET6 184 if (ip6) { 185 (void)printf("%s > %s: [|pgm]", 186 ip6addr_string(&ip6->ip6_src), 187 ip6addr_string(&ip6->ip6_dst)); 188 return; 189 } else 190 #endif /* INET6 */ 191 { 192 (void)printf("%s > %s: [|pgm]", 193 ipaddr_string(&ip->ip_src), 194 ipaddr_string(&ip->ip_dst)); 195 return; 196 } 197 } 198 199 sport = EXTRACT_16BITS(&pgm->pgm_sport); 200 dport = EXTRACT_16BITS(&pgm->pgm_dport); 201 202 #ifdef INET6 203 if (ip6) { 204 if (ip6->ip6_nxt == IPPROTO_PGM) { 205 (void)printf("%s.%s > %s.%s: ", 206 ip6addr_string(&ip6->ip6_src), 207 tcpport_string(sport), 208 ip6addr_string(&ip6->ip6_dst), 209 tcpport_string(dport)); 210 } else { 211 (void)printf("%s > %s: ", 212 tcpport_string(sport), tcpport_string(dport)); 213 } 214 } else 215 #endif /*INET6*/ 216 { 217 if (ip->ip_p == IPPROTO_PGM) { 218 (void)printf("%s.%s > %s.%s: ", 219 ipaddr_string(&ip->ip_src), 220 tcpport_string(sport), 221 ipaddr_string(&ip->ip_dst), 222 tcpport_string(dport)); 223 } else { 224 (void)printf("%s > %s: ", 225 tcpport_string(sport), tcpport_string(dport)); 226 } 227 } 228 229 TCHECK(*pgm); 230 231 (void)printf("PGM, length %u", pgm->pgm_length); 232 233 if (!vflag) 234 return; 235 236 if (length > pgm->pgm_length) 237 length = pgm->pgm_length; 238 239 (void)printf(" 0x%02x%02x%02x%02x%02x%02x ", 240 pgm->pgm_gsid[0], 241 pgm->pgm_gsid[1], 242 pgm->pgm_gsid[2], 243 pgm->pgm_gsid[3], 244 pgm->pgm_gsid[4], 245 pgm->pgm_gsid[5]); 246 switch (pgm->pgm_type) { 247 case PGM_SPM: { 248 struct pgm_spm *spm; 249 250 spm = (struct pgm_spm *)(pgm + 1); 251 TCHECK(*spm); 252 253 switch (EXTRACT_16BITS(&spm->pgms_nla_afi)) { 254 case AFI_IP: 255 addr_size = sizeof(struct in_addr); 256 nla_af = AF_INET; 257 break; 258 #ifdef INET6 259 case AFI_IP6: 260 addr_size = sizeof(struct in6_addr); 261 nla_af = AF_INET6; 262 break; 263 #endif 264 default: 265 goto trunc; 266 break; 267 } 268 bp = (u_char *) (spm + 1); 269 TCHECK2(*bp, addr_size); 270 nla = bp; 271 bp += addr_size; 272 273 inet_ntop(nla_af, nla, nla_buf, sizeof(nla_buf)); 274 (void)printf("SPM seq %u trail %u lead %u nla %s", 275 EXTRACT_32BITS(&spm->pgms_seq), 276 EXTRACT_32BITS(&spm->pgms_trailseq), 277 EXTRACT_32BITS(&spm->pgms_leadseq), 278 nla_buf); 279 break; 280 } 281 282 case PGM_POLL: { 283 struct pgm_poll *poll; 284 285 poll = (struct pgm_poll *)(pgm + 1); 286 TCHECK(*poll); 287 (void)printf("POLL seq %u round %u", 288 EXTRACT_32BITS(&poll->pgmp_seq), 289 EXTRACT_16BITS(&poll->pgmp_round)); 290 bp = (u_char *) (poll + 1); 291 break; 292 } 293 case PGM_POLR: { 294 struct pgm_polr *polr; 295 u_int32_t ivl, rnd, mask; 296 297 polr = (struct pgm_polr *)(pgm + 1); 298 TCHECK(*polr); 299 300 switch (EXTRACT_16BITS(&polr->pgmp_nla_afi)) { 301 case AFI_IP: 302 addr_size = sizeof(struct in_addr); 303 nla_af = AF_INET; 304 break; 305 #ifdef INET6 306 case AFI_IP6: 307 addr_size = sizeof(struct in6_addr); 308 nla_af = AF_INET6; 309 break; 310 #endif 311 default: 312 goto trunc; 313 break; 314 } 315 bp = (u_char *) (polr + 1); 316 TCHECK2(*bp, addr_size); 317 nla = bp; 318 bp += addr_size; 319 320 inet_ntop(nla_af, nla, nla_buf, sizeof(nla_buf)); 321 322 TCHECK2(*bp, sizeof(u_int32_t)); 323 ivl = EXTRACT_32BITS(bp); 324 bp += sizeof(u_int32_t); 325 326 TCHECK2(*bp, sizeof(u_int32_t)); 327 rnd = EXTRACT_32BITS(bp); 328 bp += sizeof(u_int32_t); 329 330 TCHECK2(*bp, sizeof(u_int32_t)); 331 mask = EXTRACT_32BITS(bp); 332 bp += sizeof(u_int32_t); 333 334 (void)printf("POLR seq %u round %u nla %s ivl %u rnd 0x%08x " 335 "mask 0x%08x", EXTRACT_32BITS(&polr->pgmp_seq), 336 EXTRACT_16BITS(&polr->pgmp_round), nla_buf, ivl, rnd, mask); 337 break; 338 } 339 case PGM_ODATA: { 340 struct pgm_data *odata; 341 342 odata = (struct pgm_data *)(pgm + 1); 343 TCHECK(*odata); 344 (void)printf("ODATA trail %u seq %u", 345 EXTRACT_32BITS(&odata->pgmd_trailseq), 346 EXTRACT_32BITS(&odata->pgmd_seq)); 347 bp = (u_char *) (odata + 1); 348 break; 349 } 350 351 case PGM_RDATA: { 352 struct pgm_data *rdata; 353 354 rdata = (struct pgm_data *)(pgm + 1); 355 TCHECK(*rdata); 356 (void)printf("RDATA trail %u seq %u", 357 EXTRACT_32BITS(&rdata->pgmd_trailseq), 358 EXTRACT_32BITS(&rdata->pgmd_seq)); 359 bp = (u_char *) (rdata + 1); 360 break; 361 } 362 363 case PGM_NAK: 364 case PGM_NULLNAK: 365 case PGM_NCF: { 366 struct pgm_nak *nak; 367 const void *source, *group; 368 int source_af, group_af; 369 #ifdef INET6 370 char source_buf[INET6_ADDRSTRLEN], group_buf[INET6_ADDRSTRLEN]; 371 #else 372 char source_buf[INET_ADDRSTRLEN], group_buf[INET_ADDRSTRLEN]; 373 #endif 374 375 nak = (struct pgm_nak *)(pgm + 1); 376 TCHECK(*nak); 377 378 /* 379 * Skip past the source, saving info along the way 380 * and stopping if we don't have enough. 381 */ 382 switch (EXTRACT_16BITS(&nak->pgmn_source_afi)) { 383 case AFI_IP: 384 addr_size = sizeof(struct in_addr); 385 source_af = AF_INET; 386 break; 387 #ifdef INET6 388 case AFI_IP6: 389 addr_size = sizeof(struct in6_addr); 390 source_af = AF_INET6; 391 break; 392 #endif 393 default: 394 goto trunc; 395 break; 396 } 397 bp = (u_char *) (nak + 1); 398 TCHECK2(*bp, addr_size); 399 source = bp; 400 bp += addr_size; 401 402 /* 403 * Skip past the group, saving info along the way 404 * and stopping if we don't have enough. 405 */ 406 switch (EXTRACT_16BITS(bp)) { 407 case AFI_IP: 408 addr_size = sizeof(struct in_addr); 409 group_af = AF_INET; 410 break; 411 #ifdef INET6 412 case AFI_IP6: 413 addr_size = sizeof(struct in6_addr); 414 group_af = AF_INET6; 415 break; 416 #endif 417 default: 418 goto trunc; 419 break; 420 } 421 bp += (2 * sizeof(u_int16_t)); 422 TCHECK2(*bp, addr_size); 423 group = bp; 424 bp += addr_size; 425 426 /* 427 * Options decoding can go here. 428 */ 429 inet_ntop(source_af, source, source_buf, sizeof(source_buf)); 430 inet_ntop(group_af, group, group_buf, sizeof(group_buf)); 431 switch (pgm->pgm_type) { 432 case PGM_NAK: 433 (void)printf("NAK "); 434 break; 435 case PGM_NULLNAK: 436 (void)printf("NNAK "); 437 break; 438 case PGM_NCF: 439 (void)printf("NCF "); 440 break; 441 default: 442 break; 443 } 444 (void)printf("(%s -> %s), seq %u", 445 source_buf, group_buf, EXTRACT_32BITS(&nak->pgmn_seq)); 446 break; 447 } 448 449 case PGM_SPMR: 450 (void)printf("SPMR"); 451 break; 452 453 default: 454 (void)printf("UNKNOWN type %0x02x", pgm->pgm_type); 455 break; 456 457 } 458 if (pgm->pgm_options & PGM_OPT_BIT_PRESENT) { 459 460 /* 461 * make sure there's enough for the first option header 462 */ 463 if (!TTEST2(*bp, PGM_MIN_OPT_LEN)) { 464 (void)printf("[|OPT]"); 465 return; 466 } 467 468 /* 469 * That option header MUST be an OPT_LENGTH option 470 * (see the first paragraph of section 9.1 in RFC 3208). 471 */ 472 opt_type = *bp++; 473 if ((opt_type & PGM_OPT_MASK) != PGM_OPT_LENGTH) { 474 (void)printf("[First option bad, should be PGM_OPT_LENGTH, is %u]", opt_type & PGM_OPT_MASK); 475 return; 476 } 477 opt_len = *bp++; 478 if (opt_len != 4) { 479 (void)printf("[Bad OPT_LENGTH option, length %u != 4]", opt_len); 480 return; 481 } 482 opts_len = EXTRACT_16BITS(bp); 483 if (opts_len < 4) { 484 (void)printf("[Bad total option length %u < 4]", opts_len); 485 return; 486 } 487 bp += sizeof(u_int16_t); 488 (void)printf(" OPTS LEN %d", opts_len); 489 opts_len -= 4; 490 491 while (opts_len) { 492 if (opts_len < PGM_MIN_OPT_LEN) { 493 (void)printf("[Total option length leaves no room for final option]"); 494 return; 495 } 496 opt_type = *bp++; 497 opt_len = *bp++; 498 if (opt_len < PGM_MIN_OPT_LEN) { 499 (void)printf("[Bad option, length %u < %u]", opt_len, 500 PGM_MIN_OPT_LEN); 501 break; 502 } 503 if (opts_len < opt_len) { 504 (void)printf("[Total option length leaves no room for final option]"); 505 return; 506 } 507 if (!TTEST2(*bp, opt_len - 2)) { 508 (void)printf(" [|OPT]"); 509 return; 510 } 511 512 switch (opt_type & PGM_OPT_MASK) { 513 case PGM_OPT_LENGTH: 514 if (opt_len != 4) { 515 (void)printf("[Bad OPT_LENGTH option, length %u != 4]", opt_len); 516 return; 517 } 518 (void)printf(" OPTS LEN (extra?) %d", EXTRACT_16BITS(bp)); 519 bp += sizeof(u_int16_t); 520 opts_len -= 4; 521 break; 522 523 case PGM_OPT_FRAGMENT: 524 if (opt_len != 16) { 525 (void)printf("[Bad OPT_FRAGMENT option, length %u != 16]", opt_len); 526 return; 527 } 528 flags1 = *bp++; 529 flags2 = *bp++; 530 seq = EXTRACT_32BITS(bp); 531 bp += sizeof(u_int32_t); 532 offset = EXTRACT_32BITS(bp); 533 bp += sizeof(u_int32_t); 534 len = EXTRACT_32BITS(bp); 535 bp += sizeof(u_int32_t); 536 (void)printf(" FRAG seq %u off %u len %u", seq, offset, len); 537 opts_len -= 16; 538 break; 539 540 case PGM_OPT_NAK_LIST: 541 flags1 = *bp++; 542 flags2 = *bp++; 543 opt_len -= sizeof(u_int32_t); /* option header */ 544 (void)printf(" NAK LIST"); 545 while (opt_len) { 546 if (opt_len < sizeof(u_int32_t)) { 547 (void)printf("[Option length not a multiple of 4]"); 548 return; 549 } 550 TCHECK2(*bp, sizeof(u_int32_t)); 551 (void)printf(" %u", EXTRACT_32BITS(bp)); 552 bp += sizeof(u_int32_t); 553 opt_len -= sizeof(u_int32_t); 554 opts_len -= sizeof(u_int32_t); 555 } 556 break; 557 558 case PGM_OPT_JOIN: 559 if (opt_len != 8) { 560 (void)printf("[Bad OPT_JOIN option, length %u != 8]", opt_len); 561 return; 562 } 563 flags1 = *bp++; 564 flags2 = *bp++; 565 seq = EXTRACT_32BITS(bp); 566 bp += sizeof(u_int32_t); 567 (void)printf(" JOIN %u", seq); 568 opts_len -= 8; 569 break; 570 571 case PGM_OPT_NAK_BO_IVL: 572 if (opt_len != 12) { 573 (void)printf("[Bad OPT_NAK_BO_IVL option, length %u != 12]", opt_len); 574 return; 575 } 576 flags1 = *bp++; 577 flags2 = *bp++; 578 offset = EXTRACT_32BITS(bp); 579 bp += sizeof(u_int32_t); 580 seq = EXTRACT_32BITS(bp); 581 bp += sizeof(u_int32_t); 582 (void)printf(" BACKOFF ivl %u ivlseq %u", offset, seq); 583 opts_len -= 12; 584 break; 585 586 case PGM_OPT_NAK_BO_RNG: 587 if (opt_len != 12) { 588 (void)printf("[Bad OPT_NAK_BO_RNG option, length %u != 12]", opt_len); 589 return; 590 } 591 flags1 = *bp++; 592 flags2 = *bp++; 593 offset = EXTRACT_32BITS(bp); 594 bp += sizeof(u_int32_t); 595 seq = EXTRACT_32BITS(bp); 596 bp += sizeof(u_int32_t); 597 (void)printf(" BACKOFF max %u min %u", offset, seq); 598 opts_len -= 12; 599 break; 600 601 case PGM_OPT_REDIRECT: 602 flags1 = *bp++; 603 flags2 = *bp++; 604 switch (EXTRACT_16BITS(bp)) { 605 case AFI_IP: 606 addr_size = sizeof(struct in_addr); 607 nla_af = AF_INET; 608 break; 609 #ifdef INET6 610 case AFI_IP6: 611 addr_size = sizeof(struct in6_addr); 612 nla_af = AF_INET6; 613 break; 614 #endif 615 default: 616 goto trunc; 617 break; 618 } 619 bp += (2 * sizeof(u_int16_t)); 620 if (opt_len != 4 + addr_size) { 621 (void)printf("[Bad OPT_REDIRECT option, length %u != 4 + address size]", opt_len); 622 return; 623 } 624 TCHECK2(*bp, addr_size); 625 nla = bp; 626 bp += addr_size; 627 628 inet_ntop(nla_af, nla, nla_buf, sizeof(nla_buf)); 629 (void)printf(" REDIRECT %s", (char *)nla); 630 opts_len -= 4 + addr_size; 631 break; 632 633 case PGM_OPT_PARITY_PRM: 634 if (opt_len != 8) { 635 (void)printf("[Bad OPT_PARITY_PRM option, length %u != 8]", opt_len); 636 return; 637 } 638 flags1 = *bp++; 639 flags2 = *bp++; 640 len = EXTRACT_32BITS(bp); 641 bp += sizeof(u_int32_t); 642 (void)printf(" PARITY MAXTGS %u", len); 643 opts_len -= 8; 644 break; 645 646 case PGM_OPT_PARITY_GRP: 647 if (opt_len != 8) { 648 (void)printf("[Bad OPT_PARITY_GRP option, length %u != 8]", opt_len); 649 return; 650 } 651 flags1 = *bp++; 652 flags2 = *bp++; 653 seq = EXTRACT_32BITS(bp); 654 bp += sizeof(u_int32_t); 655 (void)printf(" PARITY GROUP %u", seq); 656 opts_len -= 8; 657 break; 658 659 case PGM_OPT_CURR_TGSIZE: 660 if (opt_len != 8) { 661 (void)printf("[Bad OPT_CURR_TGSIZE option, length %u != 8]", opt_len); 662 return; 663 } 664 flags1 = *bp++; 665 flags2 = *bp++; 666 len = EXTRACT_32BITS(bp); 667 bp += sizeof(u_int32_t); 668 (void)printf(" PARITY ATGS %u", len); 669 opts_len -= 8; 670 break; 671 672 case PGM_OPT_NBR_UNREACH: 673 if (opt_len != 4) { 674 (void)printf("[Bad OPT_NBR_UNREACH option, length %u != 4]", opt_len); 675 return; 676 } 677 flags1 = *bp++; 678 flags2 = *bp++; 679 (void)printf(" NBR_UNREACH"); 680 opts_len -= 4; 681 break; 682 683 case PGM_OPT_PATH_NLA: 684 (void)printf(" PATH_NLA [%d]", opt_len); 685 bp += opt_len; 686 opts_len -= opt_len; 687 break; 688 689 case PGM_OPT_SYN: 690 if (opt_len != 4) { 691 (void)printf("[Bad OPT_SYN option, length %u != 4]", opt_len); 692 return; 693 } 694 flags1 = *bp++; 695 flags2 = *bp++; 696 (void)printf(" SYN"); 697 opts_len -= 4; 698 break; 699 700 case PGM_OPT_FIN: 701 if (opt_len != 4) { 702 (void)printf("[Bad OPT_FIN option, length %u != 4]", opt_len); 703 return; 704 } 705 flags1 = *bp++; 706 flags2 = *bp++; 707 (void)printf(" FIN"); 708 opts_len -= 4; 709 break; 710 711 case PGM_OPT_RST: 712 if (opt_len != 4) { 713 (void)printf("[Bad OPT_RST option, length %u != 4]", opt_len); 714 return; 715 } 716 flags1 = *bp++; 717 flags2 = *bp++; 718 (void)printf(" RST"); 719 opts_len -= 4; 720 break; 721 722 case PGM_OPT_CR: 723 (void)printf(" CR"); 724 bp += opt_len; 725 opts_len -= opt_len; 726 break; 727 728 case PGM_OPT_CRQST: 729 if (opt_len != 4) { 730 (void)printf("[Bad OPT_CRQST option, length %u != 4]", opt_len); 731 return; 732 } 733 flags1 = *bp++; 734 flags2 = *bp++; 735 (void)printf(" CRQST"); 736 opts_len -= 4; 737 break; 738 739 default: 740 (void)printf(" OPT_%02X [%d] ", opt_type, opt_len); 741 bp += opt_len; 742 opts_len -= opt_len; 743 break; 744 } 745 746 if (opt_type & PGM_OPT_END) 747 break; 748 } 749 } 750 751 (void)printf(" [%u]", EXTRACT_16BITS(&pgm->pgm_length)); 752 753 return; 754 755 trunc: 756 fputs("[|pgm]", stdout); 757 if (ch != '\0') 758 putchar('>'); 759 } 760