dist/tcpdump/print-fddi.c

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