contrib/tcpdump/print-pgm.c

   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.5 2005-06-07 22:05:58 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 }