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