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