The Tcpdump Group git mirrors - tcpdump/blob - print-atm.c

   1 /*
   2  * Copyright (c) 1994, 1995, 1996, 1997
   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 #ifndef lint
  22 static const char rcsid[] _U_ =
  23     "@(#) $Header: /tcpdump/master/tcpdump/print-atm.c,v 1.37 2004-10-18 16:26:20 hannes Exp $ (LBL)";
  24 #endif
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29
  30 #include <tcpdump-stdinc.h>
  31
  32 #include <stdio.h>
  33 #include <pcap.h>
  34 #include <string.h>
  35
  36 #include "interface.h"
  37 #include "extract.h"
  38 #include "addrtoname.h"
  39 #include "ethertype.h"
  40 #include "atm.h"
  41 #include "atmuni31.h"
  42 #include "llc.h"
  43
  44 #include "ether.h"
  45
  46 struct tok oam_celltype_values[] = {
  47     { 0x1, "Fault Management" },
  48     { 0x2, "Performance Management" },
  49     { 0x8, "activate/deactivate" },
  50     { 0xf, "System Management" },
  51     { 0, NULL }
  52 };
  53
  54 struct tok oam_fm_functype_values[] = {
  55     { 0x0, "AIS" },
  56     { 0x1, "RDI" },
  57     { 0x8, "Loopback" },
  58     { 0, NULL }
  59 };
  60
  61 static const struct tok *oam_functype_values[16] = {
  62     NULL,
  63     oam_fm_functype_values,
  64     NULL,
  65     NULL,
  66     NULL,
  67     NULL,
  68     NULL,
  69     NULL,
  70     NULL,
  71     NULL,
  72     NULL,
  73     NULL,
  74     NULL,
  75     NULL,
  76     NULL,
  77     NULL
  78 };
  79
  80 /*
  81  * Print an RFC 1483 LLC-encapsulated ATM frame.
  82  */
  83 static void
  84 atm_llc_print(const u_char *p, int length, int caplen)
  85 {
  86         u_short extracted_ethertype;
  87
  88         if (!llc_print(p, length, caplen, NULL, NULL,
  89             &extracted_ethertype)) {
  90                 /* ether_type not known, print raw packet */
  91                 if (extracted_ethertype) {
  92                         printf("(LLC %s) ",
  93                 etherproto_string(htons(extracted_ethertype)));
  94                 }
  95                 if (!xflag && !qflag)
  96                         default_print(p, caplen);
  97         }
  98 }
  99
 100 /*
 101  * Given a SAP value, generate the LLC header value for a UI packet
 102  * with that SAP as the source and destination SAP.
 103  */
 104 #define LLC_UI_HDR(sap) ((sap)<<16 | (sap<<8) | 0x03)
 105
 106 /*
 107  * This is the top level routine of the printer.  'p' points
 108  * to the LLC/SNAP header of the packet, 'h->ts' is the timestamp,
 109  * 'h->len' is the length of the packet off the wire, and 'h->caplen'
 110  * is the number of bytes actually captured.
 111  */
 112 u_int
 113 atm_if_print(const struct pcap_pkthdr *h, const u_char *p)
 114 {
 115         u_int caplen = h->caplen;
 116         u_int length = h->len;
 117         u_int32_t llchdr;
 118         u_int hdrlen = 0;
 119
 120         if (caplen < 8) {
 121                 printf("[|atm]");
 122                 return (caplen);
 123         }
 124
 125         /*
 126          * Extract the presumed LLC header into a variable, for quick
 127          * testing.
 128          * Then check for a header that's neither a header for a SNAP
 129          * packet nor an RFC 2684 routed NLPID-formatted PDU nor
 130          * an 802.2-but-no-SNAP IP packet.
 131          */
 132         llchdr = EXTRACT_24BITS(p);
 133         if (llchdr != LLC_UI_HDR(LLCSAP_SNAP) &&
 134             llchdr != LLC_UI_HDR(LLCSAP_ISONS) &&
 135             llchdr != LLC_UI_HDR(LLCSAP_IP)) {
 136                 /*
 137                  * XXX - assume 802.6 MAC header from Fore driver.
 138                  *
 139                  * Unfortunately, the above list doesn't check for
 140                  * all known SAPs, doesn't check for headers where
 141                  * the source and destination SAP aren't the same,
 142                  * and doesn't check for non-UI frames.  It also
 143                  * runs the risk of an 802.6 MAC header that happens
 144                  * to begin with one of those values being
 145                  * incorrectly treated as an 802.2 header.
 146                  *
 147                  * So is that Fore driver still around?  And, if so,
 148                  * is it still putting 802.6 MAC headers on ATM
 149                  * packets?  If so, could it be changed to use a
 150                  * new DLT_IEEE802_6 value if we added it?
 151                  */
 152                 if (eflag)
 153                         printf("%08x%08x %08x%08x ",
 154                                EXTRACT_32BITS(p),
 155                                EXTRACT_32BITS(p+4),
 156                                EXTRACT_32BITS(p+8),
 157                                EXTRACT_32BITS(p+12));
 158                 p += 20;
 159                 length -= 20;
 160                 caplen -= 20;
 161                 hdrlen += 20;
 162         }
 163         atm_llc_print(p, length, caplen);
 164         return (hdrlen);
 165 }
 166
 167 /*
 168  * ATM signalling.
 169  */
 170 static struct tok msgtype2str[] = {
 171         { CALL_PROCEED,         "Call_proceeding" },
 172         { CONNECT,              "Connect" },
 173         { CONNECT_ACK,          "Connect_ack" },
 174         { SETUP,                "Setup" },
 175         { RELEASE,              "Release" },
 176         { RELEASE_DONE,         "Release_complete" },
 177         { RESTART,              "Restart" },
 178         { RESTART_ACK,          "Restart_ack" },
 179         { STATUS,               "Status" },
 180         { STATUS_ENQ,           "Status_enquiry" },
 181         { ADD_PARTY,            "Add_party" },
 182         { ADD_PARTY_ACK,        "Add_party_ack" },
 183         { ADD_PARTY_REJ,        "Add_party_reject" },
 184         { DROP_PARTY,           "Drop_party" },
 185         { DROP_PARTY_ACK,       "Drop_party_ack" },
 186         { 0,                    NULL }
 187 };
 188
 189 static void
 190 sig_print(const u_char *p, int caplen)
 191 {
 192         bpf_u_int32 call_ref;
 193
 194         if (caplen < PROTO_POS) {
 195                 printf("[|atm]");
 196                 return;
 197         }
 198         if (p[PROTO_POS] == Q2931) {
 199                 /*
 200                  * protocol:Q.2931 for User to Network Interface
 201                  * (UNI 3.1) signalling
 202                  */
 203                 printf("Q.2931");
 204                 if (caplen < MSG_TYPE_POS) {
 205                         printf(" [|atm]");
 206                         return;
 207                 }
 208                 printf(":%s ",
 209                     tok2str(msgtype2str, "msgtype#%d", p[MSG_TYPE_POS]));
 210
 211                 if (caplen < CALL_REF_POS+3) {
 212                         printf("[|atm]");
 213                         return;
 214                 }
 215                 call_ref = EXTRACT_24BITS(&p[CALL_REF_POS]);
 216                 printf("CALL_REF:0x%06x", call_ref);
 217         } else {
 218                 /* SCCOP with some unknown protocol atop it */
 219                 printf("SSCOP, proto %d ", p[PROTO_POS]);
 220         }
 221 }
 222
 223 /*
 224  * Print an ATM PDU (such as an AAL5 PDU).
 225  */
 226 void
 227 atm_print(u_int vpi, u_int vci, u_int traftype, const u_char *p, u_int length,
 228     u_int caplen)
 229 {
 230         if (eflag)
 231                 printf("VPI:%u VCI:%u ", vpi, vci);
 232
 233         if (vpi == 0) {
 234                 switch (vci) {
 235
 236                 case PPC:
 237                         sig_print(p, caplen);
 238                         return;
 239
 240                 case BCC:
 241                         printf("broadcast sig: ");
 242                         return;
 243
 244                 case OAMF4SC: /* fall through */
 245                 case OAMF4EC:
 246                         oam_print(p, length);
 247                         return;
 248
 249                 case METAC:
 250                         printf("meta: ");
 251                         return;
 252
 253                 case ILMIC:
 254                         printf("ilmi: ");
 255                         snmp_print(p, length);
 256                         return;
 257                 }
 258         }
 259
 260         switch (traftype) {
 261
 262         case ATM_LLC:
 263         default:
 264                 /*
 265                  * Assumes traffic is LLC if unknown.
 266                  */
 267                 atm_llc_print(p, length, caplen);
 268                 break;
 269
 270         case ATM_LANE:
 271                 lane_print(p, length, caplen);
 272                 break;
 273         }
 274 }
 275
 276 int
 277 oam_print (const u_char *p, u_int length) {
 278
 279     u_int16_t cell_header, cell_type, func_type,vpi,vci,payload,clp;
 280
 281     cell_header = EXTRACT_32BITS(p);
 282     cell_type = ((*(p+4))>>4) & 0x0f;
 283     func_type = *(p) & 0x0f;
 284
 285     vpi = (cell_header>>20)&0xff;
 286     vci = (cell_header>>4)&0xffff;
 287     payload = (cell_header>>1)&0x7;
 288     clp = cell_header&0x1;
 289
 290     switch (vci) {
 291     case OAMF4SC:
 292         printf("OAM F4 (segment), ");
 293             break;
 294     case OAMF4EC:
 295         printf("OAM F4 (end), ");
 296         break;
 297     default:
 298         printf("OAM F5, ");
 299         break;
 300     }
 301
 302     if (eflag)
 303         printf("vpi %u, vci %u, payload %u, clp %u, ",vpi,vci,payload,clp);
 304
 305     printf("cell-type %s (%u)",
 306            tok2str(oam_celltype_values, "unknown", cell_type),
 307            cell_type);
 308
 309     if (oam_functype_values[cell_type] == NULL)
 310         printf(", func-type unknown (%u)", func_type);
 311     else
 312         printf(", func-type %s (%u)",
 313                bittok2str(oam_functype_values[cell_type],"none",func_type),
 314                func_type);
 315
 316     printf(", length %u",length);
 317     return 1;
 318 }