contrib/tcpdump/print-fr.c

   1 /*
   2  * Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that: (1) source code distributions
   7  * retain the above copyright notice and this paragraph in its entirety, (2)
   8  * distributions including binary code include the above copyright notice and
   9  * this paragraph in its entirety in the documentation or other materials
  10  * provided with the distribution, and (3) all advertising materials mentioning
  11  * features or use of this software display the following acknowledgement:
  12  * ``This product includes software developed by the University of California,
  13  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  14  * the University nor the names of its contributors may be used to endorse
  15  * or promote products derived from this software without specific prior
  16  * written permission.
  17  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20  *
  21  * $FreeBSD$
  22  */
  23
  24 #ifndef lint
  25 static const char rcsid[] _U_ =
  26         "@(#)$Header: /tcpdump/master/tcpdump/print-fr.c,v 1.51 2006-06-23 22:20:32 hannes Exp $ (LBL)";
  27 #endif
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #include <tcpdump-stdinc.h>
  34
  35 #include <stdio.h>
  36 #include <string.h>
  37 #include <pcap.h>
  38
  39 #include "addrtoname.h"
  40 #include "interface.h"
  41 #include "ethertype.h"
  42 #include "nlpid.h"
  43 #include "extract.h"
  44 #include "oui.h"
  45
  46 static void frf15_print(const u_char *, u_int);
  47
  48 /*
  49  * the frame relay header has a variable length
  50  *
  51  * the EA bit determines if there is another byte
  52  * in the header
  53  *
  54  * minimum header length is 2 bytes
  55  * maximum header length is 4 bytes
  56  *
  57  *      7    6    5    4    3    2    1    0
  58  *    +----+----+----+----+----+----+----+----+
  59  *    |        DLCI (6 bits)        | CR | EA |
  60  *    +----+----+----+----+----+----+----+----+
  61  *    |   DLCI (4 bits)   |FECN|BECN| DE | EA |
  62  *    +----+----+----+----+----+----+----+----+
  63  *    |           DLCI (7 bits)          | EA |
  64  *    +----+----+----+----+----+----+----+----+
  65  *    |        DLCI (6 bits)        |SDLC| EA |
  66  *    +----+----+----+----+----+----+----+----+
  67  */
  68
  69 #define FR_EA_BIT       0x01
  70
  71 #define FR_CR_BIT       0x02000000
  72 #define FR_DE_BIT       0x00020000
  73 #define FR_BECN_BIT     0x00040000
  74 #define FR_FECN_BIT     0x00080000
  75 #define FR_SDLC_BIT     0x00000002
  76
  77
  78 struct tok fr_header_flag_values[] = {
  79     { FR_CR_BIT, "C!" },
  80     { FR_DE_BIT, "DE" },
  81     { FR_BECN_BIT, "BECN" },
  82     { FR_FECN_BIT, "FECN" },
  83     { FR_SDLC_BIT, "sdlcore" },
  84     { 0, NULL }
  85 };
  86
  87 /* FRF.15 / FRF.16 */
  88 #define MFR_B_BIT 0x80
  89 #define MFR_E_BIT 0x40
  90 #define MFR_C_BIT 0x20
  91 #define MFR_BEC_MASK    (MFR_B_BIT | MFR_E_BIT | MFR_C_BIT)
  92 #define MFR_CTRL_FRAME  (MFR_B_BIT | MFR_E_BIT | MFR_C_BIT)
  93 #define MFR_FRAG_FRAME  (MFR_B_BIT | MFR_E_BIT )
  94
  95 struct tok frf_flag_values[] = {
  96     { MFR_B_BIT, "Begin" },
  97     { MFR_E_BIT, "End" },
  98     { MFR_C_BIT, "Control" },
  99     { 0, NULL }
 100 };
 101
 102 /* Finds out Q.922 address length, DLCI and flags. Returns 0 on success
 103  * save the flags dep. on address length
 104  */
 105 static int parse_q922_addr(const u_char *p, u_int *dlci,
 106                            u_int *addr_len, u_int8_t *flags)
 107 {
 108         if ((p[0] & FR_EA_BIT))
 109                 return -1;
 110
 111         *addr_len = 2;
 112         *dlci = ((p[0] & 0xFC) << 2) | ((p[1] & 0xF0) >> 4);
 113
 114         flags[0] = p[0] & 0x02; /* populate the first flag fields */
 115         flags[1] = p[1] & 0x0c;
 116         flags[2] = 0;           /* clear the rest of the flags */
 117         flags[3] = 0;
 118
 119         if (p[1] & FR_EA_BIT)
 120                 return 0;       /* 2-byte Q.922 address */
 121
 122         p += 2;
 123         (*addr_len)++;          /* 3- or 4-byte Q.922 address */
 124         if ((p[0] & FR_EA_BIT) == 0) {
 125                 *dlci = (*dlci << 7) | (p[0] >> 1);
 126                 (*addr_len)++;  /* 4-byte Q.922 address */
 127                 p++;
 128         }
 129
 130         if ((p[0] & FR_EA_BIT) == 0)
 131                 return -1; /* more than 4 bytes of Q.922 address? */
 132
 133         flags[3] = p[0] & 0x02;
 134
 135         *dlci = (*dlci << 6) | (p[0] >> 2);
 136
 137         return 0;
 138 }
 139
 140 char *q922_string(const u_char *p) {
 141
 142     static u_int dlci, addr_len;
 143     static u_int8_t flags[4];
 144     static char buffer[sizeof("DLCI xxxxxxxxxx")];
 145     memset(buffer, 0, sizeof(buffer));
 146
 147     if (parse_q922_addr(p, &dlci, &addr_len, flags) == 0){
 148         snprintf(buffer, sizeof(buffer), "DLCI %u", dlci);
 149     }
 150
 151     return buffer;
 152 }
 153
 154
 155 /* Frame Relay packet structure, with flags and CRC removed
 156
 157                   +---------------------------+
 158                   |       Q.922 Address*      |
 159                   +--                       --+
 160                   |                           |
 161                   +---------------------------+
 162                   | Control (UI = 0x03)       |
 163                   +---------------------------+
 164                   | Optional Pad      (0x00)  |
 165                   +---------------------------+
 166                   | NLPID                     |
 167                   +---------------------------+
 168                   |             .             |
 169                   |             .             |
 170                   |             .             |
 171                   |           Data            |
 172                   |             .             |
 173                   |             .             |
 174                   +---------------------------+
 175
 176            * Q.922 addresses, as presently defined, are two octets and
 177              contain a 10-bit DLCI.  In some networks Q.922 addresses
 178              may optionally be increased to three or four octets.
 179 */
 180
 181 static u_int
 182 fr_hdrlen(const u_char *p, u_int addr_len)
 183 {
 184         if (!p[addr_len + 1] /* pad exist */)
 185                 return addr_len + 1 /* UI */ + 1 /* pad */ + 1 /* NLPID */;
 186         else
 187                 return addr_len + 1 /* UI */ + 1 /* NLPID */;
 188 }
 189
 190 static void
 191 fr_hdr_print(int length, u_int addr_len, u_int dlci, u_int8_t *flags, u_int16_t nlpid)
 192 {
 193     if (qflag) {
 194         (void)printf("Q.922, DLCI %u, length %u: ",
 195                      dlci,
 196                      length);
 197     } else {
 198         if (nlpid <= 0xff) /* if its smaller than 256 then its a NLPID */
 199             (void)printf("Q.922, hdr-len %u, DLCI %u, Flags [%s], NLPID %s (0x%02x), length %u: ",
 200                          addr_len,
 201                          dlci,
 202                          bittok2str(fr_header_flag_values, "none", EXTRACT_32BITS(flags)),
 203                          tok2str(nlpid_values,"unknown", nlpid),
 204                          nlpid,
 205                          length);
 206         else /* must be an ethertype */
 207             (void)printf("Q.922, hdr-len %u, DLCI %u, Flags [%s], cisco-ethertype %s (0x%04x), length %u: ",
 208                          addr_len,
 209                          dlci,
 210                          bittok2str(fr_header_flag_values, "none", EXTRACT_32BITS(flags)),
 211                          tok2str(ethertype_values, "unknown", nlpid),
 212                          nlpid,
 213                          length);
 214     }
 215 }
 216
 217 u_int
 218 fr_if_print(const struct pcap_pkthdr *h, register const u_char *p)
 219 {
 220         register u_int length = h->len;
 221         register u_int caplen = h->caplen;
 222
 223         TCHECK2(*p, 4); /* minimum frame header length */
 224
 225         if ((length = fr_print(p, length)) == 0)
 226             return (0);
 227         else
 228             return length;
 229  trunc:
 230         printf("[|fr]");
 231         return caplen;
 232 }
 233
 234 u_int
 235 fr_print(register const u_char *p, u_int length)
 236 {
 237         u_int16_t extracted_ethertype;
 238         u_int dlci;
 239         u_int addr_len;
 240         u_int16_t nlpid;
 241         u_int hdr_len;
 242         u_int8_t flags[4];
 243
 244         if (parse_q922_addr(p, &dlci, &addr_len, flags)) {
 245                 printf("Q.922, invalid address");
 246                 return 0;
 247         }
 248
 249         TCHECK2(*p,addr_len+1+1);
 250         hdr_len = fr_hdrlen(p, addr_len);
 251         TCHECK2(*p,hdr_len);
 252
 253         if (p[addr_len] != 0x03 && dlci != 0) {
 254
 255                 /* lets figure out if we have cisco style encapsulation: */
 256                 extracted_ethertype = EXTRACT_16BITS(p+addr_len);
 257
 258                 if (eflag)
 259                     fr_hdr_print(length, addr_len, dlci, flags, extracted_ethertype);
 260
 261                 if (ether_encap_print(extracted_ethertype,
 262                                       p+addr_len+ETHERTYPE_LEN,
 263                                       length-addr_len-ETHERTYPE_LEN,
 264                                       length-addr_len-ETHERTYPE_LEN,
 265                                       &extracted_ethertype) == 0)
 266                     /* ether_type not known, probably it wasn't one */
 267                     printf("UI %02x! ", p[addr_len]);
 268                 else
 269                     return hdr_len;
 270         }
 271
 272         if (!p[addr_len + 1]) { /* pad byte should be used with 3-byte Q.922 */
 273                 if (addr_len != 3)
 274                         printf("Pad! ");
 275         } else if (addr_len == 3)
 276                 printf("No pad! ");
 277
 278         nlpid = p[hdr_len - 1];
 279
 280         if (eflag)
 281                 fr_hdr_print(length, addr_len, dlci, flags, nlpid);
 282         p += hdr_len;
 283         length -= hdr_len;
 284
 285         switch (nlpid) {
 286         case NLPID_IP:
 287                 ip_print(gndo, p, length);
 288                 break;
 289
 290 #ifdef INET6
 291         case NLPID_IP6:
 292                 ip6_print(p, length);
 293                 break;
 294 #endif
 295         case NLPID_CLNP:
 296         case NLPID_ESIS:
 297         case NLPID_ISIS:
 298                 isoclns_print(p-1, length+1, length+1); /* OSI printers need the NLPID field */
 299                 break;
 300
 301         case NLPID_SNAP:
 302                 if (snap_print(p, length, length, &extracted_ethertype, 0) == 0) {
 303                         /* ether_type not known, print raw packet */
 304                         if (!eflag)
 305                             fr_hdr_print(length + hdr_len, hdr_len,
 306                                          dlci, flags, nlpid);
 307                         if (!suppress_default_print)
 308                             default_print(p - hdr_len, length + hdr_len);
 309                 }
 310                 break;
 311
 312         case NLPID_Q933:
 313                 q933_print(p, length);
 314                 break;
 315
 316         case NLPID_MFR:
 317                 frf15_print(p, length);
 318                 break;
 319
 320         case NLPID_PPP:
 321                 ppp_print(p, length);
 322                 break;
 323
 324         default:
 325                 if (!eflag)
 326                     fr_hdr_print(length + hdr_len, addr_len,
 327                                      dlci, flags, nlpid);
 328                 if (!xflag)
 329                         default_print(p, length);
 330         }
 331
 332         return hdr_len;
 333
 334  trunc:
 335         printf("[|fr]");
 336         return 0;
 337
 338 }
 339
 340 u_int
 341 mfr_if_print(const struct pcap_pkthdr *h, register const u_char *p)
 342 {
 343         register u_int length = h->len;
 344         register u_int caplen = h->caplen;
 345
 346         TCHECK2(*p, 2); /* minimum frame header length */
 347
 348         if ((length = mfr_print(p, length)) == 0)
 349             return (0);
 350         else
 351             return length;
 352  trunc:
 353         printf("[|mfr]");
 354         return caplen;
 355 }
 356
 357
 358 #define MFR_CTRL_MSG_ADD_LINK        1
 359 #define MFR_CTRL_MSG_ADD_LINK_ACK    2
 360 #define MFR_CTRL_MSG_ADD_LINK_REJ    3
 361 #define MFR_CTRL_MSG_HELLO           4
 362 #define MFR_CTRL_MSG_HELLO_ACK       5
 363 #define MFR_CTRL_MSG_REMOVE_LINK     6
 364 #define MFR_CTRL_MSG_REMOVE_LINK_ACK 7
 365
 366 struct tok mfr_ctrl_msg_values[] = {
 367     { MFR_CTRL_MSG_ADD_LINK, "Add Link" },
 368     { MFR_CTRL_MSG_ADD_LINK_ACK, "Add Link ACK" },
 369     { MFR_CTRL_MSG_ADD_LINK_REJ, "Add Link Reject" },
 370     { MFR_CTRL_MSG_HELLO, "Hello" },
 371     { MFR_CTRL_MSG_HELLO_ACK, "Hello ACK" },
 372     { MFR_CTRL_MSG_REMOVE_LINK, "Remove Link" },
 373     { MFR_CTRL_MSG_REMOVE_LINK_ACK, "Remove Link ACK" },
 374     { 0, NULL }
 375 };
 376
 377 #define MFR_CTRL_IE_BUNDLE_ID  1
 378 #define MFR_CTRL_IE_LINK_ID    2
 379 #define MFR_CTRL_IE_MAGIC_NUM  3
 380 #define MFR_CTRL_IE_TIMESTAMP  5
 381 #define MFR_CTRL_IE_VENDOR_EXT 6
 382 #define MFR_CTRL_IE_CAUSE      7
 383
 384 struct tok mfr_ctrl_ie_values[] = {
 385     { MFR_CTRL_IE_BUNDLE_ID, "Bundle ID"},
 386     { MFR_CTRL_IE_LINK_ID, "Link ID"},
 387     { MFR_CTRL_IE_MAGIC_NUM, "Magic Number"},
 388     { MFR_CTRL_IE_TIMESTAMP, "Timestamp"},
 389     { MFR_CTRL_IE_VENDOR_EXT, "Vendor Extension"},
 390     { MFR_CTRL_IE_CAUSE, "Cause"},
 391     { 0, NULL }
 392 };
 393
 394 #define MFR_ID_STRING_MAXLEN 50
 395
 396 struct ie_tlv_header_t {
 397     u_int8_t ie_type;
 398     u_int8_t ie_len;
 399 };
 400
 401 u_int
 402 mfr_print(register const u_char *p, u_int length)
 403 {
 404     u_int tlen,idx,hdr_len = 0;
 405     u_int16_t sequence_num;
 406     u_int8_t ie_type,ie_len;
 407     const u_int8_t *tptr;
 408
 409
 410 /*
 411  * FRF.16 Link Integrity Control Frame
 412  *
 413  *      7    6    5    4    3    2    1    0
 414  *    +----+----+----+----+----+----+----+----+
 415  *    | B  | E  | C=1| 0    0    0    0  | EA |
 416  *    +----+----+----+----+----+----+----+----+
 417  *    | 0    0    0    0    0    0    0    0  |
 418  *    +----+----+----+----+----+----+----+----+
 419  *    |              message type             |
 420  *    +----+----+----+----+----+----+----+----+
 421  */
 422
 423     TCHECK2(*p, 4); /* minimum frame header length */
 424
 425     if ((p[0] & MFR_BEC_MASK) == MFR_CTRL_FRAME && p[1] == 0) {
 426         printf("FRF.16 Control, Flags [%s], %s, length %u",
 427                bittok2str(frf_flag_values,"none",(p[0] & MFR_BEC_MASK)),
 428                tok2str(mfr_ctrl_msg_values,"Unknown Message (0x%02x)",p[2]),
 429                length);
 430         tptr = p + 3;
 431         tlen = length -3;
 432         hdr_len = 3;
 433
 434         if (!vflag)
 435             return hdr_len;
 436
 437         while (tlen>sizeof(struct ie_tlv_header_t)) {
 438             TCHECK2(*tptr, sizeof(struct ie_tlv_header_t));
 439             ie_type=tptr[0];
 440             ie_len=tptr[1];
 441
 442             printf("\n\tIE %s (%u), length %u: ",
 443                    tok2str(mfr_ctrl_ie_values,"Unknown",ie_type),
 444                    ie_type,
 445                    ie_len);
 446
 447             /* infinite loop check */
 448             if (ie_type == 0 || ie_len <= sizeof(struct ie_tlv_header_t))
 449                 return hdr_len;
 450
 451             TCHECK2(*tptr,ie_len);
 452             tptr+=sizeof(struct ie_tlv_header_t);
 453             /* tlv len includes header */
 454             ie_len-=sizeof(struct ie_tlv_header_t);
 455             tlen-=sizeof(struct ie_tlv_header_t);
 456
 457             switch (ie_type) {
 458
 459             case MFR_CTRL_IE_MAGIC_NUM:
 460                 printf("0x%08x",EXTRACT_32BITS(tptr));
 461                 break;
 462
 463             case MFR_CTRL_IE_BUNDLE_ID: /* same message format */
 464             case MFR_CTRL_IE_LINK_ID:
 465                 for (idx = 0; idx < ie_len && idx < MFR_ID_STRING_MAXLEN; idx++) {
 466                     if (*(tptr+idx) != 0) /* don't print null termination */
 467                         safeputchar(*(tptr+idx));
 468                     else
 469                         break;
 470                 }
 471                 break;
 472
 473             case MFR_CTRL_IE_TIMESTAMP:
 474                 if (ie_len == sizeof(struct timeval)) {
 475                     ts_print((const struct timeval *)tptr);
 476                     break;
 477                 }
 478                 /* fall through and hexdump if no unix timestamp */
 479
 480                 /*
 481                  * FIXME those are the defined IEs that lack a decoder
 482                  * you are welcome to contribute code ;-)
 483                  */
 484
 485             case MFR_CTRL_IE_VENDOR_EXT:
 486             case MFR_CTRL_IE_CAUSE:
 487
 488             default:
 489                 if (vflag <= 1)
 490                     print_unknown_data(tptr,"\n\t  ",ie_len);
 491                 break;
 492             }
 493
 494             /* do we want to see a hexdump of the IE ? */
 495             if (vflag > 1 )
 496                 print_unknown_data(tptr,"\n\t  ",ie_len);
 497
 498             tlen-=ie_len;
 499             tptr+=ie_len;
 500         }
 501         return hdr_len;
 502     }
 503 /*
 504  * FRF.16 Fragmentation Frame
 505  *
 506  *      7    6    5    4    3    2    1    0
 507  *    +----+----+----+----+----+----+----+----+
 508  *    | B  | E  | C=0|seq. (high 4 bits) | EA  |
 509  *    +----+----+----+----+----+----+----+----+
 510  *    |        sequence  (low 8 bits)         |
 511  *    +----+----+----+----+----+----+----+----+
 512  *    |        DLCI (6 bits)        | CR | EA  |
 513  *    +----+----+----+----+----+----+----+----+
 514  *    |   DLCI (4 bits)   |FECN|BECN| DE | EA |
 515  *    +----+----+----+----+----+----+----+----+
 516  */
 517
 518     sequence_num = (p[0]&0x1e)<<7 | p[1];
 519     /* whole packet or first fragment ? */
 520     if ((p[0] & MFR_BEC_MASK) == MFR_FRAG_FRAME ||
 521         (p[0] & MFR_BEC_MASK) == MFR_B_BIT) {
 522         printf("FRF.16 Frag, seq %u, Flags [%s], ",
 523                sequence_num,
 524                bittok2str(frf_flag_values,"none",(p[0] & MFR_BEC_MASK)));
 525         hdr_len = 2;
 526         fr_print(p+hdr_len,length-hdr_len);
 527         return hdr_len;
 528     }
 529
 530     /* must be a middle or the last fragment */
 531     printf("FRF.16 Frag, seq %u, Flags [%s]",
 532            sequence_num,
 533            bittok2str(frf_flag_values,"none",(p[0] & MFR_BEC_MASK)));
 534     print_unknown_data(p,"\n\t",length);
 535
 536     return hdr_len;
 537
 538  trunc:
 539     printf("[|mfr]");
 540     return length;
 541 }
 542
 543 /* an NLPID of 0xb1 indicates a 2-byte
 544  * FRF.15 header
 545  *
 546  *      7    6    5    4    3    2    1    0
 547  *    +----+----+----+----+----+----+----+----+
 548  *    ~              Q.922 header             ~
 549  *    +----+----+----+----+----+----+----+----+
 550  *    |             NLPID (8 bits)            | NLPID=0xb1
 551  *    +----+----+----+----+----+----+----+----+
 552  *    | B  | E  | C  |seq. (high 4 bits) | R  |
 553  *    +----+----+----+----+----+----+----+----+
 554  *    |        sequence  (low 8 bits)         |
 555  *    +----+----+----+----+----+----+----+----+
 556  */
 557
 558 #define FR_FRF15_FRAGTYPE 0x01
 559
 560 static void
 561 frf15_print (const u_char *p, u_int length) {
 562
 563     u_int16_t sequence_num, flags;
 564
 565     flags = p[0]&MFR_BEC_MASK;
 566     sequence_num = (p[0]&0x1e)<<7 | p[1];
 567
 568     printf("FRF.15, seq 0x%03x, Flags [%s],%s Fragmentation, length %u",
 569            sequence_num,
 570            bittok2str(frf_flag_values,"none",flags),
 571            p[0]&FR_FRF15_FRAGTYPE ? "Interface" : "End-to-End",
 572            length);
 573
 574 /* TODO:
 575  * depending on all permutations of the B, E and C bit
 576  * dig as deep as we can - e.g. on the first (B) fragment
 577  * there is enough payload to print the IP header
 578  * on non (B) fragments it depends if the fragmentation
 579  * model is end-to-end or interface based wether we want to print
 580  * another Q.922 header
 581  */
 582
 583 }
 584
 585 /*
 586  * Q.933 decoding portion for framerelay specific.
 587  */
 588
 589 /* Q.933 packet format
 590                       Format of Other Protocols
 591                           using Q.933 NLPID
 592                   +-------------------------------+
 593                   |        Q.922 Address          |
 594                   +---------------+---------------+
 595                   |Control  0x03  | NLPID   0x08  |
 596                   +---------------+---------------+
 597                   |          L2 Protocol ID       |
 598                   | octet 1       |  octet 2      |
 599                   +-------------------------------+
 600                   |          L3 Protocol ID       |
 601                   | octet 2       |  octet 2      |
 602                   +-------------------------------+
 603                   |         Protocol Data         |
 604                   +-------------------------------+
 605                   | FCS                           |
 606                   +-------------------------------+
 607  */
 608
 609 /* L2 (Octet 1)- Call Reference Usually is 0x0 */
 610
 611 /*
 612  * L2 (Octet 2)- Message Types definition 1 byte long.
 613  */
 614 /* Call Establish */
 615 #define MSG_TYPE_ESC_TO_NATIONAL  0x00
 616 #define MSG_TYPE_ALERT            0x01
 617 #define MSG_TYPE_CALL_PROCEEDING  0x02
 618 #define MSG_TYPE_CONNECT          0x07
 619 #define MSG_TYPE_CONNECT_ACK      0x0F
 620 #define MSG_TYPE_PROGRESS         0x03
 621 #define MSG_TYPE_SETUP            0x05
 622 /* Call Clear */
 623 #define MSG_TYPE_DISCONNECT       0x45
 624 #define MSG_TYPE_RELEASE          0x4D
 625 #define MSG_TYPE_RELEASE_COMPLETE 0x5A
 626 #define MSG_TYPE_RESTART          0x46
 627 #define MSG_TYPE_RESTART_ACK      0x4E
 628 /* Status */
 629 #define MSG_TYPE_STATUS           0x7D
 630 #define MSG_TYPE_STATUS_ENQ       0x75
 631
 632 struct tok fr_q933_msg_values[] = {
 633     { MSG_TYPE_ESC_TO_NATIONAL, "ESC to National" },
 634     { MSG_TYPE_ALERT, "Alert" },
 635     { MSG_TYPE_CALL_PROCEEDING, "Call proceeding" },
 636     { MSG_TYPE_CONNECT, "Connect" },
 637     { MSG_TYPE_CONNECT_ACK, "Connect ACK" },
 638     { MSG_TYPE_PROGRESS, "Progress" },
 639     { MSG_TYPE_SETUP, "Setup" },
 640     { MSG_TYPE_DISCONNECT, "Disconnect" },
 641     { MSG_TYPE_RELEASE, "Release" },
 642     { MSG_TYPE_RELEASE_COMPLETE, "Release Complete" },
 643     { MSG_TYPE_RESTART, "Restart" },
 644     { MSG_TYPE_RESTART_ACK, "Restart ACK" },
 645     { MSG_TYPE_STATUS, "Status Reply" },
 646     { MSG_TYPE_STATUS_ENQ, "Status Enquiry" },
 647     { 0, NULL }
 648 };
 649
 650 #define MSG_ANSI_LOCKING_SHIFT  0x95
 651
 652 #define FR_LMI_ANSI_REPORT_TYPE_IE      0x01
 653 #define FR_LMI_ANSI_LINK_VERIFY_IE_91   0x19 /* details? */
 654 #define FR_LMI_ANSI_LINK_VERIFY_IE      0x03
 655 #define FR_LMI_ANSI_PVC_STATUS_IE       0x07
 656
 657 #define FR_LMI_CCITT_REPORT_TYPE_IE     0x51
 658 #define FR_LMI_CCITT_LINK_VERIFY_IE     0x53
 659 #define FR_LMI_CCITT_PVC_STATUS_IE      0x57
 660
 661 struct tok fr_q933_ie_values_codeset5[] = {
 662     { FR_LMI_ANSI_REPORT_TYPE_IE, "ANSI Report Type" },
 663     { FR_LMI_ANSI_LINK_VERIFY_IE_91, "ANSI Link Verify" },
 664     { FR_LMI_ANSI_LINK_VERIFY_IE, "ANSI Link Verify" },
 665     { FR_LMI_ANSI_PVC_STATUS_IE, "ANSI PVC Status" },
 666     { FR_LMI_CCITT_REPORT_TYPE_IE, "CCITT Report Type" },
 667     { FR_LMI_CCITT_LINK_VERIFY_IE, "CCITT Link Verify" },
 668     { FR_LMI_CCITT_PVC_STATUS_IE, "CCITT PVC Status" },
 669     { 0, NULL }
 670 };
 671
 672 #define FR_LMI_REPORT_TYPE_IE_FULL_STATUS 0
 673 #define FR_LMI_REPORT_TYPE_IE_LINK_VERIFY 1
 674 #define FR_LMI_REPORT_TYPE_IE_ASYNC_PVC   2
 675
 676 struct tok fr_lmi_report_type_ie_values[] = {
 677     { FR_LMI_REPORT_TYPE_IE_FULL_STATUS, "Full Status" },
 678     { FR_LMI_REPORT_TYPE_IE_LINK_VERIFY, "Link verify" },
 679     { FR_LMI_REPORT_TYPE_IE_ASYNC_PVC, "Async PVC Status" },
 680     { 0, NULL }
 681 };
 682
 683 /* array of 16 codepages - currently we only support codepage 1,5 */
 684 static struct tok *fr_q933_ie_codesets[] = {
 685     NULL,
 686     fr_q933_ie_values_codeset5,
 687     NULL,
 688     NULL,
 689     NULL,
 690     fr_q933_ie_values_codeset5,
 691     NULL,
 692     NULL,
 693     NULL,
 694     NULL,
 695     NULL,
 696     NULL,
 697     NULL,
 698     NULL,
 699     NULL,
 700     NULL
 701 };
 702
 703 static int fr_q933_print_ie_codeset5(const struct ie_tlv_header_t  *ie_p,
 704     const u_char *p);
 705
 706 typedef int (*codeset_pr_func_t)(const struct ie_tlv_header_t  *ie_p,
 707     const u_char *p);
 708
 709 /* array of 16 codepages - currently we only support codepage 1,5 */
 710 static codeset_pr_func_t fr_q933_print_ie_codeset[] = {
 711     NULL,
 712     fr_q933_print_ie_codeset5,
 713     NULL,
 714     NULL,
 715     NULL,
 716     fr_q933_print_ie_codeset5,
 717     NULL,
 718     NULL,
 719     NULL,
 720     NULL,
 721     NULL,
 722     NULL,
 723     NULL,
 724     NULL,
 725     NULL,
 726     NULL
 727 };
 728
 729 void
 730 q933_print(const u_char *p, u_int length)
 731 {
 732         const u_char *ptemp = p;
 733         struct ie_tlv_header_t  *ie_p;
 734         int olen;
 735         int is_ansi = 0;
 736         u_int codeset;
 737         u_int ie_is_known = 0;
 738
 739         if (length < 9) {       /* shortest: Q.933a LINK VERIFY */
 740                 printf("[|q.933]");
 741                 return;
 742         }
 743
 744         codeset = p[2]&0x0f;   /* extract the codeset */
 745
 746         if (p[2] == MSG_ANSI_LOCKING_SHIFT) {
 747                 is_ansi = 1;
 748         }
 749
 750         printf("%s", eflag ? "" : "Q.933, ");
 751
 752         /* printing out header part */
 753         printf("%s, codeset %u", is_ansi ? "ANSI" : "CCITT", codeset);
 754
 755         if (p[0]) {
 756                 printf(", Call Ref: 0x%02x", p[0]);
 757         }
 758         if (vflag) {
 759                 printf(", %s (0x%02x), length %u",
 760                        tok2str(fr_q933_msg_values,
 761                                "unknown message", p[1]),
 762                        p[1],
 763                        length);
 764         } else {
 765                 printf(", %s",
 766                        tok2str(fr_q933_msg_values,
 767                                "unknown message 0x%02x", p[1]));
 768         }
 769
 770         olen = length; /* preserve the original length for non verbose mode */
 771
 772         if (length < (u_int)(2 - is_ansi)) {
 773                 printf("[|q.933]");
 774                 return;
 775         }
 776         length -= 2 + is_ansi;
 777         ptemp += 2 + is_ansi;
 778
 779         /* Loop through the rest of IE */
 780         while (length > sizeof(struct ie_tlv_header_t)) {
 781                 ie_p = (struct ie_tlv_header_t  *)ptemp;
 782                 if (length < sizeof(struct ie_tlv_header_t) ||
 783                     length < sizeof(struct ie_tlv_header_t) + ie_p->ie_len) {
 784                     if (vflag) { /* not bark if there is just a trailer */
 785                         printf("\n[|q.933]");
 786                     } else {
 787                         printf(", length %u",olen);
 788                     }
 789                     return;
 790                 }
 791
 792                 /* lets do the full IE parsing only in verbose mode
 793                  * however some IEs (DLCI Status, Link Verify)
 794                  * are also interestting in non-verbose mode */
 795                 if (vflag) {
 796                     printf("\n\t%s IE (0x%02x), length %u: ",
 797                            tok2str(fr_q933_ie_codesets[codeset],
 798                                    "unknown", ie_p->ie_type),
 799                            ie_p->ie_type,
 800                            ie_p->ie_len);
 801                 }
 802
 803                 /* sanity check */
 804                 if (ie_p->ie_type == 0 || ie_p->ie_len == 0) {
 805                     return;
 806                 }
 807
 808                 if (fr_q933_print_ie_codeset[codeset] != NULL) {
 809                     ie_is_known = fr_q933_print_ie_codeset[codeset](ie_p, ptemp);
 810                 }
 811
 812                 if (vflag >= 1 && !ie_is_known) {
 813                     print_unknown_data(ptemp+2,"\n\t",ie_p->ie_len);
 814                 }
 815
 816                 /* do we want to see a hexdump of the IE ? */
 817                 if (vflag> 1 && ie_is_known) {
 818                     print_unknown_data(ptemp+2,"\n\t  ",ie_p->ie_len);
 819                 }
 820
 821                 length = length - ie_p->ie_len - 2;
 822                 ptemp = ptemp + ie_p->ie_len + 2;
 823         }
 824         if (!vflag) {
 825             printf(", length %u",olen);
 826         }
 827 }
 828
 829 static int
 830 fr_q933_print_ie_codeset5(const struct ie_tlv_header_t  *ie_p, const u_char *p)
 831 {
 832         u_int dlci;
 833
 834         switch (ie_p->ie_type) {
 835
 836         case FR_LMI_ANSI_REPORT_TYPE_IE: /* fall through */
 837         case FR_LMI_CCITT_REPORT_TYPE_IE:
 838             if (vflag) {
 839                 printf("%s (%u)",
 840                        tok2str(fr_lmi_report_type_ie_values,"unknown",p[2]),
 841                        p[2]);
 842             }
 843             return 1;
 844
 845         case FR_LMI_ANSI_LINK_VERIFY_IE: /* fall through */
 846         case FR_LMI_CCITT_LINK_VERIFY_IE:
 847         case FR_LMI_ANSI_LINK_VERIFY_IE_91:
 848             if (!vflag) {
 849                 printf(", ");
 850             }
 851             printf("TX Seq: %3d, RX Seq: %3d", p[2], p[3]);
 852             return 1;
 853
 854         case FR_LMI_ANSI_PVC_STATUS_IE: /* fall through */
 855         case FR_LMI_CCITT_PVC_STATUS_IE:
 856             if (!vflag) {
 857                 printf(", ");
 858             }
 859             /* now parse the DLCI information element. */
 860             if ((ie_p->ie_len < 3) ||
 861                 (p[2] & 0x80) ||
 862                 ((ie_p->ie_len == 3) && !(p[3] & 0x80)) ||
 863                 ((ie_p->ie_len == 4) && ((p[3] & 0x80) || !(p[4] & 0x80))) ||
 864                 ((ie_p->ie_len == 5) && ((p[3] & 0x80) || (p[4] & 0x80) ||
 865                                    !(p[5] & 0x80))) ||
 866                 (ie_p->ie_len > 5) ||
 867                 !(p[ie_p->ie_len + 1] & 0x80)) {
 868                 printf("Invalid DLCI IE");
 869             }
 870
 871             dlci = ((p[2] & 0x3F) << 4) | ((p[3] & 0x78) >> 3);
 872             if (ie_p->ie_len == 4) {
 873                 dlci = (dlci << 6) | ((p[4] & 0x7E) >> 1);
 874             }
 875             else if (ie_p->ie_len == 5) {
 876                 dlci = (dlci << 13) | (p[4] & 0x7F) | ((p[5] & 0x7E) >> 1);
 877             }
 878
 879             printf("DLCI %u: status %s%s", dlci,
 880                     p[ie_p->ie_len + 1] & 0x8 ? "New, " : "",
 881                     p[ie_p->ie_len + 1] & 0x2 ? "Active" : "Inactive");
 882             return 1;
 883         }
 884
 885         return 0;
 886 }