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