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