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