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