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