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