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[] =
  23     "@(#) $Header: /tcpdump/master/tcpdump/print-atm.c,v 1.28 2002-12-09 05:12:25 guy 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
  43 #include "ether.h"
  44
  45 /*
  46  * Print an RFC 1483 LLC-encapsulated ATM frame.
  47  */
  48 static void
  49 atm_llc_print(const u_char *p, int length, int caplen)
  50 {
  51         struct ether_header ehdr;
  52         u_short extracted_ethertype;
  53
  54         /*
  55          * Fake up an Ethernet header for the benefit of printers that
  56          * insist on "packetp" pointing to an Ethernet header.
  57          */
  58         memset(&ehdr, '\0', sizeof ehdr);
  59
  60         /*
  61          * Some printers want to get back at the ethernet addresses.
  62          * Rather than pass it all the way down, we set this global.
  63          *
  64          * Actually, the only printers that use packetp are print-arp.c
  65          * and print-bootp.c, and they assume that packetp points to an
  66          * Ethernet header.  The right thing to do is to fix them to know
  67          * which link type is in use when they excavate. XXX
  68          */
  69         packetp = (u_char *)&ehdr;
  70
  71         if (!llc_print(p, length, caplen, ESRC(&ehdr), EDST(&ehdr),
  72             &extracted_ethertype)) {
  73                 /* ether_type not known, print raw packet */
  74                 if (extracted_ethertype) {
  75                         printf("(LLC %s) ",
  76                 etherproto_string(htons(extracted_ethertype)));
  77                 }
  78                 if (!xflag && !qflag)
  79                         default_print(p, caplen);
  80         }
  81 }
  82
  83 /*
  84  * This is the top level routine of the printer.  'p' points
  85  * to the LLC/SNAP header of the packet, 'h->ts' is the timestamp,
  86  * 'h->length' is the length of the packet off the wire, and 'h->caplen'
  87  * is the number of bytes actually captured.
  88  */
  89 void
  90 atm_if_print(u_char *user _U_, const struct pcap_pkthdr *h, const u_char *p)
  91 {
  92         u_int caplen = h->caplen;
  93         u_int length = h->len;
  94         u_int32_t llchdr;
  95
  96         ++infodelay;
  97         ts_print(&h->ts);
  98
  99         if (caplen < 8) {
 100                 printf("[|atm]");
 101                 goto out;
 102         }
 103
 104         /*
 105          * Some printers want to check that they're not walking off the
 106          * end of the packet.
 107          * Rather than pass it all the way down, we set this global.
 108          */
 109         snapend = p + caplen;
 110
 111         /*
 112          * Extract the presumed LLC header into a variable, for quick
 113          * testing.
 114          * Then check for a header that's neither a header for a SNAP
 115          * packet nor an RFC 2684 routed NLPID-formatted PDU.
 116          */
 117         llchdr = EXTRACT_24BITS(p);
 118         if (llchdr != 0xaaaa03 && llchdr != 0xfefe03) {
 119                 /*
 120                  * XXX - assume 802.6 MAC header from Fore driver.
 121                  */
 122                 if (eflag)
 123                         printf("%08x%08x %08x%08x ",
 124                                EXTRACT_32BITS(p),
 125                                EXTRACT_32BITS(p+4),
 126                                EXTRACT_32BITS(p+8),
 127                                EXTRACT_32BITS(p+12));
 128                 p += 20;
 129                 length -= 20;
 130                 caplen -= 20;
 131         }
 132         atm_llc_print(p, length, caplen);
 133         if (xflag)
 134                 default_print(p, caplen);
 135  out:
 136         putchar('\n');
 137 }
 138
 139 /*
 140  * ATM signalling.
 141  */
 142 static struct tok msgtype2str[] = {
 143         { CALL_PROCEED,         "Call_proceeding" },
 144         { CONNECT,              "Connect" },
 145         { CONNECT_ACK,          "Connect_ack" },
 146         { SETUP,                "Setup" },
 147         { RELEASE,              "Release" },
 148         { RELEASE_DONE,         "Release_complete" },
 149         { RESTART,              "Restart" },
 150         { RESTART_ACK,          "Restart_ack" },
 151         { STATUS,               "Status" },
 152         { STATUS_ENQ,           "Status_enquiry" },
 153         { ADD_PARTY,            "Add_party" },
 154         { ADD_PARTY_ACK,        "Add_party_ack" },
 155         { ADD_PARTY_REJ,        "Add_party_reject" },
 156         { DROP_PARTY,           "Drop_party" },
 157         { DROP_PARTY_ACK,       "Drop_party_ack" },
 158         { 0,                    NULL }
 159 };
 160
 161 static void
 162 sig_print(const u_char *p, int caplen)
 163 {
 164         bpf_u_int32 call_ref;
 165
 166         if (caplen < PROTO_POS) {
 167                 printf("[|atm]");
 168                 return;
 169         }
 170         if (p[PROTO_POS] == Q2931) {
 171                 /*
 172                  * protocol:Q.2931 for User to Network Interface
 173                  * (UNI 3.1) signalling
 174                  */
 175                 printf("Q.2931");
 176                 if (caplen < MSG_TYPE_POS) {
 177                         printf(" [|atm]");
 178                         return;
 179                 }
 180                 printf(":%s ",
 181                     tok2str(msgtype2str, "msgtype#%d", p[MSG_TYPE_POS]));
 182
 183                 if (caplen < CALL_REF_POS+3) {
 184                         printf("[|atm]");
 185                         return;
 186                 }
 187                 call_ref = EXTRACT_24BITS(&p[CALL_REF_POS]);
 188                 printf("CALL_REF:0x%06x", call_ref);
 189         } else {
 190                 /* SCCOP with some unknown protocol atop it */
 191                 printf("SSCOP, proto %d ", p[PROTO_POS]);
 192         }
 193 }
 194
 195 /*
 196  * Print an ATM PDU (such as an AAL5 PDU).
 197  */
 198 void
 199 atm_print(u_int vpi, u_int vci, u_int traftype, const u_char *p, u_int length,
 200     u_int caplen)
 201 {
 202         if (eflag)
 203                 printf("VPI:%u VCI:%u ", vpi, vci);
 204
 205         /*
 206          * Some printers want to check that they're not walking off the
 207          * end of the packet.
 208          * Rather than pass it all the way down, we set this global.
 209          */
 210         snapend = p + caplen;
 211
 212         if (vpi == 0) {
 213                 switch (vci) {
 214
 215                 case PPC:
 216                         sig_print(p, caplen);
 217                         goto out;
 218
 219                 case BCC:
 220                         printf("broadcast sig: ");
 221                         goto out;
 222
 223                 case OAMF4SC:
 224                         printf("oamF4(segment): ");
 225                         goto out;
 226
 227                 case OAMF4EC:
 228                         printf("oamF4(end): ");
 229                         goto out;
 230
 231                 case METAC:
 232                         printf("meta: ");
 233                         goto out;
 234
 235                 case ILMIC:
 236                         printf("ilmi: ");
 237                         snmp_print(p, length);
 238                         goto out;
 239                 }
 240         }
 241
 242         switch (traftype) {
 243
 244         case ATM_LLC:
 245         default:
 246                 /*
 247                  * Assumes traffic is LLC if unknown.
 248                  * call into the generic LLC handler
 249                  */
 250                 llc_print(p, length, caplen, NULL, NULL, NULL);
 251                 break;
 252
 253         case ATM_LANE:
 254                 lane_print(p, length, caplen);
 255                 break;
 256         }
 257
 258 out:
 259         if (xflag)
 260                 default_print(p, caplen);
 261 }