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