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