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

   1 /*
   2  * Copyright (c) 1991, 1992, 1993, 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
  22 #ifndef lint
  23 static const char rcsid[] =
  24     "@(#) $Header: /tcpdump/master/tcpdump/print-fddi.c,v 1.55 2002-05-29 10:06:27 guy Exp $ (LBL)";
  25 #endif
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include <sys/param.h>
  32 #include <sys/time.h>
  33 #include <sys/socket.h>
  34 #include <sys/file.h>
  35 #include <sys/ioctl.h>
  36
  37 #include <netinet/in.h>
  38
  39 #include <ctype.h>
  40 #include <netdb.h>
  41 #include <pcap.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44
  45 #include "interface.h"
  46 #include "addrtoname.h"
  47 #include "ethertype.h"
  48
  49 #include "ether.h"
  50 #include "fddi.h"
  51
  52 /*
  53  * Some FDDI interfaces use bit-swapped addresses.
  54  */
  55 #if defined(ultrix) || defined(__alpha) || defined(__bsdi) || defined(__NetBSD__) || defined(__linux__)
  56 int     fddi_bitswap = 0;
  57 #else
  58 int     fddi_bitswap = 1;
  59 #endif
  60
  61 /*
  62  * FDDI support for tcpdump, by Jeffrey Mogul [DECWRL], June 1992
  63  *
  64  * Based in part on code by Van Jacobson, which bears this note:
  65  *
  66  * NOTE:  This is a very preliminary hack for FDDI support.
  67  * There are all sorts of wired in constants & nothing (yet)
  68  * to print SMT packets as anything other than hex dumps.
  69  * Most of the necessary changes are waiting on my redoing
  70  * the "header" that a kernel fddi driver supplies to bpf:  I
  71  * want it to look like one byte of 'direction' (0 or 1
  72  * depending on whether the packet was inbound or outbound),
  73  * two bytes of system/driver dependent data (anything an
  74  * implementor thinks would be useful to filter on and/or
  75  * save per-packet, then the real 21-byte FDDI header.
  76  * Steve McCanne & I have also talked about adding the
  77  * 'direction' byte to all bpf headers (e.g., in the two
  78  * bytes of padding on an ethernet header).  It's not clear
  79  * we could do this in a backwards compatible way & we hate
  80  * the idea of an incompatible bpf change.  Discussions are
  81  * proceeding.
  82  *
  83  * Also, to really support FDDI (and better support 802.2
  84  * over ethernet) we really need to re-think the rather simple
  85  * minded assumptions about fixed length & fixed format link
  86  * level headers made in gencode.c.  One day...
  87  *
  88  *  - vj
  89  */
  90
  91 static u_char fddi_bit_swap[] = {
  92         0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
  93         0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
  94         0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
  95         0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
  96         0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
  97         0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
  98         0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
  99         0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
 100         0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
 101         0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
 102         0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
 103         0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
 104         0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
 105         0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
 106         0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
 107         0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
 108         0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
 109         0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
 110         0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
 111         0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
 112         0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
 113         0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
 114         0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
 115         0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
 116         0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
 117         0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
 118         0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
 119         0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
 120         0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
 121         0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
 122         0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
 123         0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
 124 };
 125
 126 /*
 127  * Print FDDI frame-control bits
 128  */
 129 static inline void
 130 print_fddi_fc(u_char fc)
 131 {
 132         switch (fc) {
 133
 134         case FDDIFC_VOID:                         /* Void frame */
 135                 printf("void ");
 136                 break;
 137
 138         case FDDIFC_NRT:                          /* Nonrestricted token */
 139                 printf("nrt ");
 140                 break;
 141
 142         case FDDIFC_RT:                           /* Restricted token */
 143                 printf("rt ");
 144                 break;
 145
 146         case FDDIFC_SMT_INFO:                     /* SMT Info */
 147                 printf("info ");
 148                 break;
 149
 150         case FDDIFC_SMT_NSA:                      /* SMT Next station adrs */
 151                 printf("nsa ");
 152                 break;
 153
 154         case FDDIFC_MAC_BEACON:                   /* MAC Beacon frame */
 155                 printf("beacon ");
 156                 break;
 157
 158         case FDDIFC_MAC_CLAIM:                    /* MAC Claim frame */
 159                 printf("claim ");
 160                 break;
 161
 162         default:
 163                 switch (fc & FDDIFC_CLFF) {
 164
 165                 case FDDIFC_MAC:
 166                         printf("mac%1x ", fc & FDDIFC_ZZZZ);
 167                         break;
 168
 169                 case FDDIFC_SMT:
 170                         printf("smt%1x ", fc & FDDIFC_ZZZZ);
 171                         break;
 172
 173                 case FDDIFC_LLC_ASYNC:
 174                         printf("async%1x ", fc & FDDIFC_ZZZZ);
 175                         break;
 176
 177                 case FDDIFC_LLC_SYNC:
 178                         printf("sync%1x ", fc & FDDIFC_ZZZZ);
 179                         break;
 180
 181                 case FDDIFC_IMP_ASYNC:
 182                         printf("imp_async%1x ", fc & FDDIFC_ZZZZ);
 183                         break;
 184
 185                 case FDDIFC_IMP_SYNC:
 186                         printf("imp_sync%1x ", fc & FDDIFC_ZZZZ);
 187                         break;
 188
 189                 default:
 190                         printf("%02x ", fc);
 191                         break;
 192                 }
 193         }
 194 }
 195
 196 /* Extract src, dst addresses */
 197 static inline void
 198 extract_fddi_addrs(const struct fddi_header *fddip, char *fsrc, char *fdst)
 199 {
 200         register int i;
 201
 202         if (fddi_bitswap) {
 203                 /*
 204                  * bit-swap the fddi addresses (isn't the IEEE standards
 205                  * process wonderful!) then convert them to names.
 206                  */
 207                 for (i = 0; i < 6; ++i)
 208                         fdst[i] = fddi_bit_swap[fddip->fddi_dhost[i]];
 209                 for (i = 0; i < 6; ++i)
 210                         fsrc[i] = fddi_bit_swap[fddip->fddi_shost[i]];
 211         }
 212         else {
 213                 memcpy(fdst, (const char *)fddip->fddi_dhost, 6);
 214                 memcpy(fsrc, (const char *)fddip->fddi_shost, 6);
 215         }
 216 }
 217
 218 /*
 219  * Print the FDDI MAC header
 220  */
 221 static inline void
 222 fddi_hdr_print(register const struct fddi_header *fddip, register u_int length,
 223            register const u_char *fsrc, register const u_char *fdst)
 224 {
 225         const char *srcname, *dstname;
 226
 227         srcname = etheraddr_string(fsrc);
 228         dstname = etheraddr_string(fdst);
 229
 230         if (vflag)
 231                 (void) printf("%02x %s %s %d: ",
 232                        fddip->fddi_fc,
 233                        srcname, dstname,
 234                        length);
 235         else if (qflag)
 236                 printf("%s %s %d: ", srcname, dstname, length);
 237         else {
 238                 (void) print_fddi_fc(fddip->fddi_fc);
 239                 (void) printf("%s %s %d: ", srcname, dstname, length);
 240         }
 241 }
 242
 243 static inline void
 244 fddi_smt_print(const u_char *p, u_int length)
 245 {
 246         printf("<SMT printer not yet implemented>");
 247 }
 248
 249 void
 250 fddi_print(const u_char *p, u_int length, u_int caplen)
 251 {
 252         const struct fddi_header *fddip = (const struct fddi_header *)p;
 253         struct ether_header ehdr;
 254         u_short extracted_ethertype;
 255
 256         if (caplen < FDDI_HDRLEN) {
 257                 printf("[|fddi]");
 258                 return;
 259         }
 260         /*
 261          * Get the FDDI addresses into a canonical form
 262          */
 263         extract_fddi_addrs(fddip, (char *)ESRC(&ehdr), (char *)EDST(&ehdr));
 264         /*
 265          * Some printers want to get back at the link level addresses,
 266          * and/or check that they're not walking off the end of the packet.
 267          * Rather than pass them all the way down, we set these globals.
 268          */
 269         snapend = p + caplen;
 270         /*
 271          * Actually, the only printers that use packetp are print-arp.c
 272          * and print-bootp.c, and they assume that packetp points to an
 273          * Ethernet header.  The right thing to do is to fix them to know
 274          * which link type is in use when they excavate. XXX
 275          */
 276         packetp = (u_char *)&ehdr;
 277
 278         if (eflag)
 279                 fddi_hdr_print(fddip, length, ESRC(&ehdr), EDST(&ehdr));
 280
 281         /* Skip over FDDI MAC header */
 282         length -= FDDI_HDRLEN;
 283         p += FDDI_HDRLEN;
 284         caplen -= FDDI_HDRLEN;
 285
 286         /* Frame Control field determines interpretation of packet */
 287         extracted_ethertype = 0;
 288         if ((fddip->fddi_fc & FDDIFC_CLFF) == FDDIFC_LLC_ASYNC) {
 289                 /* Try to print the LLC-layer header & higher layers */
 290                 if (llc_print(p, length, caplen, ESRC(&ehdr), EDST(&ehdr),
 291                     &extracted_ethertype) == 0) {
 292                         /*
 293                          * Some kinds of LLC packet we cannot
 294                          * handle intelligently
 295                          */
 296                         if (!eflag)
 297                                 fddi_hdr_print(fddip, length + FDDI_HDRLEN,
 298                                     ESRC(&ehdr), EDST(&ehdr));
 299                         if (extracted_ethertype) {
 300                                 printf("(LLC %s) ",
 301                         etherproto_string(htons(extracted_ethertype)));
 302                         }
 303                         if (!xflag && !qflag)
 304                                 default_print(p, caplen);
 305                 }
 306         } else if ((fddip->fddi_fc & FDDIFC_CLFF) == FDDIFC_SMT)
 307                 fddi_smt_print(p, caplen);
 308         else {
 309                 /* Some kinds of FDDI packet we cannot handle intelligently */
 310                 if (!eflag)
 311                         fddi_hdr_print(fddip, length + FDDI_HDRLEN, ESRC(&ehdr),
 312                             EDST(&ehdr));
 313                 if (!xflag && !qflag)
 314                         default_print(p, caplen);
 315         }
 316 }
 317
 318 /*
 319  * This is the top level routine of the printer.  'sp' is the points
 320  * to the FDDI header of the packet, 'tvp' is the timestamp,
 321  * 'length' is the length of the packet off the wire, and 'caplen'
 322  * is the number of bytes actually captured.
 323  */
 324 void
 325 fddi_if_print(u_char *pcap, const struct pcap_pkthdr *h,
 326               register const u_char *p)
 327 {
 328         u_int caplen = h->caplen;
 329         u_int length = h->len;
 330
 331         ++infodelay;
 332         ts_print(&h->ts);
 333
 334         fddi_print(p, length, caplen);
 335
 336         /*
 337          * If "-x" was specified, print stuff past the FDDI header,
 338          * if there's anything to print.
 339          */
 340         if (xflag && caplen > FDDI_HDRLEN)
 341                 default_print(p + FDDI_HDRLEN, caplen - FDDI_HDRLEN);
 342
 343         putchar('\n');
 344
 345         --infodelay;
 346         if (infoprint)
 347                 info(0);
 348 }