tcpdump.tproj/print-fddi.c

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