The Tcpdump Group git mirrors - tcpdump/blob - 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
  22 #ifndef lint
  23 static const char rcsid[] =
  24         "@(#)$Header: /tcpdump/master/tcpdump/print-fr.c,v 1.11 2002-12-19 09:39:12 guy Exp $ (LBL)";
  25 #endif
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include <tcpdump-stdinc.h>
  32
  33 struct mbuf;
  34 struct rtentry;
  35
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <pcap.h>
  39
  40 #include "interface.h"
  41 #include "addrtoname.h"
  42 #include "ethertype.h"
  43 #include "extract.h"
  44
  45 static void q933_print(const u_char *, int);
  46
  47 #define FR_CR_BIT       0x02
  48 #define FR_EA_BIT(p)    ((p)&0x01)
  49 #define FR_FECN         0x08
  50 #define FR_BECN         0x04
  51 #define FR_DE           0x02
  52 #define FR_DLCI(b0, b1) ((((b0)&0xFC)<<2)+(((b1)&0xF0)>>4))
  53
  54 /* find out how many bytes are there in a frame */
  55 static u_int
  56 fr_addr_len(const u_char *p)
  57 {
  58         u_int i=0;
  59
  60         while (!FR_EA_BIT(p[i]) && i++ && !FR_EA_BIT(p[i+1])) i++;
  61         return (i+1);
  62 }
  63
  64 /* the following is for framerelay */
  65 #define NLPID_LEN       1       /* NLPID is one byte long */
  66 #define NLPID_Q933      0x08
  67 #define NLPID_LMI       0x09
  68 #define NLPID_SNAP      0x80
  69 #define NLPID_CLNP      0x81
  70 #define NLPID_ESIS      0x82
  71 #define NLPID_ISIS      0x83
  72 #define NLPID_CONS      0x84
  73 #define NLPID_IDRP      0x85
  74 #define NLPID_X25_ESIS  0x8a
  75 #define NLPID_IP        0xcc
  76
  77
  78 static const char *fr_nlpids[256];
  79
  80 static void
  81 init_fr_nlpids(void)
  82 {
  83         int i;
  84         static int fr_nlpid_flag = 0;
  85
  86         if (!fr_nlpid_flag) {
  87                 for (i=0; i < 256; i++)
  88                         fr_nlpids[i] = NULL;
  89                 fr_nlpids[NLPID_Q933] = "Q.933";
  90                 fr_nlpids[NLPID_LMI] = "LMI";
  91                 fr_nlpids[NLPID_SNAP] = "SNAP";
  92                 fr_nlpids[NLPID_CLNP] = "CLNP";
  93                 fr_nlpids[NLPID_ESIS] = "ESIS";
  94                 fr_nlpids[NLPID_ISIS] = "ISIS";
  95                 fr_nlpids[NLPID_CONS] = "CONS";
  96                 fr_nlpids[NLPID_IDRP] = "IDRP";
  97                 fr_nlpids[NLPID_X25_ESIS] = "X25_ESIS";
  98                 fr_nlpids[NLPID_IP] = "IP";
  99         }
 100         fr_nlpid_flag = 1;
 101 }
 102
 103 /* Framerelay packet structure */
 104
 105 /*
 106                   +---------------------------+
 107                   |    flag (7E hexadecimal)  |
 108                   +---------------------------+
 109                   |       Q.922 Address*      |
 110                   +--                       --+
 111                   |                           |
 112                   +---------------------------+
 113                   | Control (UI = 0x03)       |
 114                   +---------------------------+
 115                   | Optional Pad      (0x00)  |
 116                   +---------------------------+
 117                   | NLPID                     |
 118                   +---------------------------+
 119                   |             .             |
 120                   |             .             |
 121                   |             .             |
 122                   |           Data            |
 123                   |             .             |
 124                   |             .             |
 125                   +---------------------------+
 126                   |   Frame Check Sequence    |
 127                   +--           .           --+
 128                   |       (two octets)        |
 129                   +---------------------------+
 130                   |   flag (7E hexadecimal)   |
 131                   +---------------------------+
 132
 133            * Q.922 addresses, as presently defined, are two octets and
 134              contain a 10-bit DLCI.  In some networks Q.922 addresses
 135              may optionally be increased to three or four octets.
 136
 137 */
 138
 139 #define FR_PROTOCOL(p) fr_protocol((p))
 140
 141 static u_int
 142 fr_hdrlen(const u_char *p)
 143 {
 144         u_int hlen;
 145         hlen = fr_addr_len(p)+1;  /* addr_len + 0x03 + padding */
 146         if (p[hlen])
 147                 return hlen;
 148         else
 149                 return hlen+1;
 150 }
 151
 152 #define LAYER2_LEN(p) (fr_hdrlen((p))+NLPID_LEN)
 153
 154 static int
 155 fr_protocol(const u_char *p)
 156 {
 157         int hlen;
 158
 159         hlen = fr_addr_len(p) + 1;
 160         if (p[hlen])  /* check for padding */
 161                 return p[hlen];
 162         else
 163                 return p[hlen+1];
 164 }
 165
 166 static char *
 167 fr_flags(const u_char *p)
 168 {
 169         static char flags[1+1+4+1+4+1+2+1];
 170
 171         if (p[0] & FR_CR_BIT)
 172                 strcpy(flags, "C");
 173         else
 174                 strcpy(flags, "R");
 175         if (p[1] & FR_FECN)
 176                 strcat(flags, ",FECN");
 177         if (p[1] & FR_BECN)
 178                 strcat(flags, ",BECN");
 179         if (p[1] & FR_DE)
 180                 strcat(flags, ",DE");
 181         return flags;
 182 }
 183
 184 static const char *
 185 fr_protostring(u_int8_t proto)
 186 {
 187         static char buf[5+1+2+1];
 188
 189         if (nflag || fr_nlpids[proto] == NULL) {
 190                 sprintf(buf, "proto-%02x", proto);
 191                 return buf;
 192         }
 193         return fr_nlpids[proto];
 194 }
 195
 196 static void
 197 fr_hdr_print(const u_char *p, int length)
 198 {
 199         u_int8_t proto;
 200
 201         proto = FR_PROTOCOL(p);
 202
 203         init_fr_nlpids();
 204         /* this is kinda kludge since it assumed that DLCI is two bytes. */
 205         if (qflag)
 206                 (void)printf("DLCI-%u-%s %d: ",
 207                              FR_DLCI(p[0], p[1]), fr_flags(p), length);
 208         else
 209                 (void)printf("DLCI-%u-%s %s %d: ",
 210                              FR_DLCI(p[0], p[1]), fr_flags(p),
 211                              fr_protostring(proto), length);
 212 }
 213
 214 u_int
 215 fr_if_print(const struct pcap_pkthdr *h, register const u_char *p)
 216 {
 217         register u_int length = h->len;
 218         register u_int caplen = h->caplen;
 219         u_char protocol;
 220         int layer2_len;
 221         u_short extracted_ethertype;
 222         u_int32_t orgcode;
 223         register u_short et;
 224
 225         if (caplen < fr_hdrlen(p)) {
 226                 printf("[|fr]");
 227                 return (caplen);
 228         }
 229
 230         if (eflag)
 231                 fr_hdr_print(p, length);
 232
 233         protocol = FR_PROTOCOL(p);
 234         layer2_len = LAYER2_LEN(p);
 235         p += layer2_len;
 236         length -= layer2_len;
 237         caplen -= layer2_len;
 238
 239         switch (protocol) {
 240
 241         case NLPID_IP:
 242                 ip_print(p, length);
 243                 break;
 244
 245         case NLPID_CLNP:
 246         case NLPID_ESIS:
 247         case NLPID_ISIS:
 248                 isoclns_print(p, length, caplen, NULL, NULL);
 249                 break;
 250
 251         case NLPID_SNAP:
 252                 orgcode = EXTRACT_24BITS(p);
 253                 et = EXTRACT_16BITS(p + 3);
 254                 if (snap_print((const u_char *)(p + 5), length - 5,
 255                            caplen - 5, &extracted_ethertype, orgcode, et,
 256                            0) == 0) {
 257                         /* ether_type not known, print raw packet */
 258                         if (!eflag)
 259                                 fr_hdr_print(p - layer2_len, length + layer2_len);
 260                         if (extracted_ethertype) {
 261                                 printf("(SNAP %s) ",
 262                                etherproto_string(htons(extracted_ethertype)));
 263                         }
 264                         if (!xflag && !qflag)
 265                                 default_print(p - layer2_len, caplen + layer2_len);
 266                 }
 267                 break;
 268
 269         case NLPID_Q933:
 270                 q933_print(p, length);
 271                 break;
 272
 273         default:
 274                 if (!eflag)
 275                         fr_hdr_print(p - layer2_len, length + layer2_len);
 276                 if (!xflag)
 277                         default_print(p, caplen);
 278         }
 279
 280         return (layer2_len);
 281 }
 282
 283 /*
 284  * Q.933 decoding portion for framerelay specific.
 285  */
 286
 287 /* Q.933 packet format
 288                       Format of Other Protocols
 289                           using Q.933 NLPID
 290                   +-------------------------------+
 291                   |        Q.922 Address          |
 292                   +---------------+---------------+
 293                   |Control  0x03  | NLPID   0x08  |
 294                   +---------------+---------------+
 295                   |          L2 Protocol ID       |
 296                   | octet 1       |  octet 2      |
 297                   +-------------------------------+
 298                   |          L3 Protocol ID       |
 299                   | octet 2       |  octet 2      |
 300                   +-------------------------------+
 301                   |         Protocol Data         |
 302                   +-------------------------------+
 303                   | FCS                           |
 304                   +-------------------------------+
 305  */
 306
 307 /* L2 (Octet 1)- Call Reference Usually is 0x0 */
 308
 309 /*
 310  * L2 (Octet 2)- Message Types definition 1 byte long.
 311  */
 312 /* Call Establish */
 313 #define MSG_TYPE_ESC_TO_NATIONAL  0x00
 314 #define MSG_TYPE_ALERT            0x01
 315 #define MSG_TYPE_CALL_PROCEEDING  0x02
 316 #define MSG_TYPE_CONNECT          0x07
 317 #define MSG_TYPE_CONNECT_ACK      0x0F
 318 #define MSG_TYPE_PROGRESS         0x03
 319 #define MSG_TYPE_SETUP            0x05
 320 /* Call Clear */
 321 #define MSG_TYPE_DISCONNECT       0x45
 322 #define MSG_TYPE_RELEASE          0x4D
 323 #define MSG_TYPE_RELEASE_COMPLETE 0x5A
 324 #define MSG_TYPE_RESTART          0x46
 325 #define MSG_TYPE_RESTART_ACK      0x4E
 326 /* Status */
 327 #define MSG_TYPE_STATUS           0x7D
 328 #define MSG_TYPE_STATUS_ENQ       0x75
 329
 330 #define ONE_BYTE_IE_MASK 0xF0
 331
 332 /* See L2 protocol ID picture above */
 333 struct q933_header {
 334     u_int8_t call_ref;  /* usually is 0 for framerelay PVC */
 335     u_int8_t msg_type;
 336 };
 337
 338 #define REPORT_TYPE_IE    0x01
 339 #define LINK_VERIFY_IE_91 0x19
 340 #define LINK_VERIFY_IE_94 0x03
 341 #define PVC_STATUS_IE     0x07
 342
 343 #define MAX_IE_SIZE
 344
 345 struct common_ie_header {
 346     u_int8_t ie_id;
 347     u_int8_t ie_len;
 348 };
 349
 350 #define FULL_STATUS 0
 351 #define LINK_VERIFY 1
 352 #define ASYNC_PVC   2
 353
 354 static void
 355 q933_print(const u_char *p, int length)
 356 {
 357         struct q933_header *header = (struct q933_header *)(p+1);
 358         const u_char *ptemp = p;
 359         int ie_len;
 360         const char *decode_str;
 361         char temp_str[255];
 362         struct common_ie_header *ie_p;
 363
 364         /* printing out header part */
 365         printf("Call Ref: %02x, MSG Type: %02x",
 366                header->call_ref, header->msg_type);
 367         switch(header->msg_type) {
 368         case MSG_TYPE_STATUS:
 369             decode_str = "STATUS REPLY";
 370             break;
 371         case MSG_TYPE_STATUS_ENQ:
 372             decode_str = "STATUS ENQUIRY";
 373             break;
 374         default:
 375             decode_str = "UNKNOWN MSG Type";
 376         }
 377         printf(" %s\n", decode_str);
 378
 379         length = length - 3;
 380         ptemp = ptemp + 3;
 381
 382         /* Loop through the rest of IE */
 383         while( length > 0 ) {
 384             if (ptemp[0] & ONE_BYTE_IE_MASK) {
 385                 ie_len = 1;
 386                 printf("\t\tOne byte IE: %02x, Content %02x\n",
 387                        (*ptemp & 0x70)>>4, (*ptemp & 0x0F));
 388                 length--;
 389                 ptemp++;
 390             }
 391             else {  /* Multi-byte IE */
 392                 ie_p = (struct common_ie_header *)ptemp;
 393                 switch (ie_p->ie_id) {
 394                 case REPORT_TYPE_IE:
 395                     switch(ptemp[2]) {
 396                     case FULL_STATUS:
 397                         decode_str = "FULL STATUS";
 398                         break;
 399                     case LINK_VERIFY:
 400                         decode_str = "LINK VERIFY";
 401                         break;
 402                     case ASYNC_PVC:
 403                         decode_str = "Async PVC Status";
 404                         break;
 405                     default:
 406                         decode_str = "Reserved Value";
 407                     }
 408                     break;
 409                 case LINK_VERIFY_IE_91:
 410                 case LINK_VERIFY_IE_94:
 411                     snprintf(temp_str, sizeof (temp_str), "TX Seq: %3d, RX Seq: %3d",
 412                             ptemp[2], ptemp[3]);
 413                     decode_str = temp_str;
 414                     break;
 415                 case PVC_STATUS_IE:
 416                     snprintf(temp_str, sizeof (temp_str), "DLCI %d: status %s %s",
 417                             ((ptemp[2]&0x3f)<<4)+ ((ptemp[3]&0x78)>>3),
 418                             ptemp[4] & 0x8 ?"new,":" ",
 419                             ptemp[4] & 0x2 ?"Active":"Inactive");
 420                     break;
 421                 default:
 422                     decode_str = "Non-decoded Value";
 423                 }
 424                 printf("\t\tIE: %02X Len: %d, %s\n",
 425                        ie_p->ie_id, ie_p->ie_len, decode_str);
 426                 length = length - ie_p->ie_len - 2;
 427                 ptemp = ptemp + ie_p->ie_len + 2;
 428             }
 429         }
 430 }