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