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