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