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 #define NETDISSECT_REWORKED
     23 #ifdef HAVE_CONFIG_H
     24 #include "config.h"
     25 #endif
     26 
     27 #include <tcpdump-stdinc.h>
     28 
     29 #include <string.h>
     30 
     31 #include "interface.h"
     32 #include "addrtoname.h"
     33 #include "ether.h"
     34 
     35 /*
     36  * Based on Ultrix if_fddi.h
     37  */
     38 
     39 struct fddi_header {
     40 	u_char  fddi_fc;		/* frame control */
     41 	u_char  fddi_dhost[6];
     42 	u_char  fddi_shost[6];
     43 };
     44 
     45 /*
     46  * Length of an FDDI header; note that some compilers may pad
     47  * "struct fddi_header" to a multiple of 4 bytes, for example, so
     48  * "sizeof (struct fddi_header)" may not give the right
     49  * answer.
     50  */
     51 #define FDDI_HDRLEN 13
     52 
     53 /* Useful values for fddi_fc (frame control) field */
     54 
     55 /*
     56  * FDDI Frame Control bits
     57  */
     58 #define	FDDIFC_C		0x80		/* Class bit */
     59 #define	FDDIFC_L		0x40		/* Address length bit */
     60 #define	FDDIFC_F		0x30		/* Frame format bits */
     61 #define	FDDIFC_Z		0x0f		/* Control bits */
     62 
     63 /*
     64  * FDDI Frame Control values. (48-bit addressing only).
     65  */
     66 #define	FDDIFC_VOID		0x40		/* Void frame */
     67 #define	FDDIFC_NRT		0x80		/* Nonrestricted token */
     68 #define	FDDIFC_RT		0xc0		/* Restricted token */
     69 #define	FDDIFC_SMT_INFO		0x41		/* SMT Info */
     70 #define	FDDIFC_SMT_NSA		0x4F		/* SMT Next station adrs */
     71 #define	FDDIFC_MAC_BEACON	0xc2		/* MAC Beacon frame */
     72 #define	FDDIFC_MAC_CLAIM	0xc3		/* MAC Claim frame */
     73 #define	FDDIFC_LLC_ASYNC	0x50		/* Async. LLC frame */
     74 #define	FDDIFC_LLC_SYNC		0xd0		/* Sync. LLC frame */
     75 #define	FDDIFC_IMP_ASYNC	0x60		/* Implementor Async. */
     76 #define	FDDIFC_IMP_SYNC		0xe0		/* Implementor Synch. */
     77 #define FDDIFC_SMT		0x40		/* SMT frame */
     78 #define FDDIFC_MAC		0xc0		/* MAC frame */
     79 
     80 #define	FDDIFC_CLFF		0xF0		/* Class/Length/Format bits */
     81 #define	FDDIFC_ZZZZ		0x0F		/* Control bits */
     82 
     83 /*
     84  * Some FDDI interfaces use bit-swapped addresses.
     85  */
     86 #if defined(ultrix) || defined(__alpha) || defined(__bsdi) || defined(__NetBSD__) || defined(__linux__)
     87 int	fddi_bitswap = 0;
     88 #else
     89 int	fddi_bitswap = 1;
     90 #endif
     91 
     92 /*
     93  * FDDI support for tcpdump, by Jeffrey Mogul [DECWRL], June 1992
     94  *
     95  * Based in part on code by Van Jacobson, which bears this note:
     96  *
     97  * NOTE:  This is a very preliminary hack for FDDI support.
     98  * There are all sorts of wired in constants & nothing (yet)
     99  * to print SMT packets as anything other than hex dumps.
    100  * Most of the necessary changes are waiting on my redoing
    101  * the "header" that a kernel fddi driver supplies to bpf:  I
    102  * want it to look like one byte of 'direction' (0 or 1
    103  * depending on whether the packet was inbound or outbound),
    104  * two bytes of system/driver dependent data (anything an
    105  * implementor thinks would be useful to filter on and/or
    106  * save per-packet, then the real 21-byte FDDI header.
    107  * Steve McCanne & I have also talked about adding the
    108  * 'direction' byte to all bpf headers (e.g., in the two
    109  * bytes of padding on an ethernet header).  It's not clear
    110  * we could do this in a backwards compatible way & we hate
    111  * the idea of an incompatible bpf change.  Discussions are
    112  * proceeding.
    113  *
    114  * Also, to really support FDDI (and better support 802.2
    115  * over ethernet) we really need to re-think the rather simple
    116  * minded assumptions about fixed length & fixed format link
    117  * level headers made in gencode.c.  One day...
    118  *
    119  *  - vj
    120  */
    121 
    122 static const 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(netdissect_options *ndo, u_char fc)
    162 {
    163 	switch (fc) {
    164 
    165 	case FDDIFC_VOID:                         /* Void frame */
    166 		ND_PRINT((ndo, "void "));
    167 		break;
    168 
    169 	case FDDIFC_NRT:                          /* Nonrestricted token */
    170 		ND_PRINT((ndo, "nrt "));
    171 		break;
    172 
    173 	case FDDIFC_RT:                           /* Restricted token */
    174 		ND_PRINT((ndo, "rt "));
    175 		break;
    176 
    177 	case FDDIFC_SMT_INFO:                     /* SMT Info */
    178 		ND_PRINT((ndo, "info "));
    179 		break;
    180 
    181 	case FDDIFC_SMT_NSA:                      /* SMT Next station adrs */
    182 		ND_PRINT((ndo, "nsa "));
    183 		break;
    184 
    185 	case FDDIFC_MAC_BEACON:                   /* MAC Beacon frame */
    186 		ND_PRINT((ndo, "beacon "));
    187 		break;
    188 
    189 	case FDDIFC_MAC_CLAIM:                    /* MAC Claim frame */
    190 		ND_PRINT((ndo, "claim "));
    191 		break;
    192 
    193 	default:
    194 		switch (fc & FDDIFC_CLFF) {
    195 
    196 		case FDDIFC_MAC:
    197 			ND_PRINT((ndo, "mac%1x ", fc & FDDIFC_ZZZZ));
    198 			break;
    199 
    200 		case FDDIFC_SMT:
    201 			ND_PRINT((ndo, "smt%1x ", fc & FDDIFC_ZZZZ));
    202 			break;
    203 
    204 		case FDDIFC_LLC_ASYNC:
    205 			ND_PRINT((ndo, "async%1x ", fc & FDDIFC_ZZZZ));
    206 			break;
    207 
    208 		case FDDIFC_LLC_SYNC:
    209 			ND_PRINT((ndo, "sync%1x ", fc & FDDIFC_ZZZZ));
    210 			break;
    211 
    212 		case FDDIFC_IMP_ASYNC:
    213 			ND_PRINT((ndo, "imp_async%1x ", fc & FDDIFC_ZZZZ));
    214 			break;
    215 
    216 		case FDDIFC_IMP_SYNC:
    217 			ND_PRINT((ndo, "imp_sync%1x ", fc & FDDIFC_ZZZZ));
    218 			break;
    219 
    220 		default:
    221 			ND_PRINT((ndo, "%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, (const char *)fddip->fddi_dhost, 6);
    245 		memcpy(fsrc, (const char *)fddip->fddi_shost, 6);
    246 	}
    247 }
    248 
    249 /*
    250  * Print the FDDI MAC header
    251  */
    252 static inline void
    253 fddi_hdr_print(netdissect_options *ndo,
    254                register const struct fddi_header *fddip, register u_int length,
    255                register const u_char *fsrc, register const u_char *fdst)
    256 {
    257 	const char *srcname, *dstname;
    258 
    259 	srcname = etheraddr_string(ndo, fsrc);
    260 	dstname = etheraddr_string(ndo, fdst);
    261 
    262 	if (ndo->ndo_vflag)
    263 		ND_PRINT((ndo, "%02x %s %s %d: ",
    264 		       fddip->fddi_fc,
    265 		       srcname, dstname,
    266 		       length));
    267 	else if (ndo->ndo_qflag)
    268 		ND_PRINT((ndo, "%s %s %d: ", srcname, dstname, length));
    269 	else {
    270 		print_fddi_fc(ndo, fddip->fddi_fc);
    271 		ND_PRINT((ndo, "%s %s %d: ", srcname, dstname, length));
    272 	}
    273 }
    274 
    275 static inline void
    276 fddi_smt_print(netdissect_options *ndo, const u_char *p _U_, u_int length _U_)
    277 {
    278 	ND_PRINT((ndo, "<SMT printer not yet implemented>"));
    279 }
    280 
    281 void
    282 fddi_print(netdissect_options *ndo, const u_char *p, u_int length, u_int caplen)
    283 {
    284 	const struct fddi_header *fddip = (const struct fddi_header *)p;
    285 	struct ether_header ehdr;
    286 	u_short extracted_ethertype;
    287 
    288 	if (caplen < FDDI_HDRLEN) {
    289 		ND_PRINT((ndo, "[|fddi]"));
    290 		return;
    291 	}
    292 
    293 	/*
    294 	 * Get the FDDI addresses into a canonical form
    295 	 */
    296 	extract_fddi_addrs(fddip, (char *)ESRC(&ehdr), (char *)EDST(&ehdr));
    297 
    298 	if (ndo->ndo_eflag)
    299 		fddi_hdr_print(ndo, fddip, length, ESRC(&ehdr), EDST(&ehdr));
    300 
    301 	/* Skip over FDDI MAC header */
    302 	length -= FDDI_HDRLEN;
    303 	p += FDDI_HDRLEN;
    304 	caplen -= FDDI_HDRLEN;
    305 
    306 	/* Frame Control field determines interpretation of packet */
    307 	if ((fddip->fddi_fc & FDDIFC_CLFF) == FDDIFC_LLC_ASYNC) {
    308 		/* Try to print the LLC-layer header & higher layers */
    309 		if (llc_print(ndo, p, length, caplen, ESRC(&ehdr), EDST(&ehdr),
    310 		    &extracted_ethertype) == 0) {
    311 			/*
    312 			 * Some kinds of LLC packet we cannot
    313 			 * handle intelligently
    314 			 */
    315 			if (!ndo->ndo_eflag)
    316 				fddi_hdr_print(ndo, fddip, length + FDDI_HDRLEN,
    317 				    ESRC(&ehdr), EDST(&ehdr));
    318 			if (extracted_ethertype) {
    319 				ND_PRINT((ndo, "(LLC %s) ",
    320 			etherproto_string(htons(extracted_ethertype))));
    321 			}
    322 			if (!ndo->ndo_suppress_default_print)
    323 				ND_DEFAULTPRINT(p, caplen);
    324 		}
    325 	} else if ((fddip->fddi_fc & FDDIFC_CLFF) == FDDIFC_SMT)
    326 		fddi_smt_print(ndo, p, caplen);
    327 	else {
    328 		/* Some kinds of FDDI packet we cannot handle intelligently */
    329 		if (!ndo->ndo_eflag)
    330 			fddi_hdr_print(ndo, fddip, length + FDDI_HDRLEN, ESRC(&ehdr),
    331 			    EDST(&ehdr));
    332 		if (!ndo->ndo_suppress_default_print)
    333 			ND_DEFAULTPRINT(p, caplen);
    334 	}
    335 }
    336 
    337 /*
    338  * This is the top level routine of the printer.  'p' points
    339  * to the FDDI header of the packet, 'h->ts' is the timestamp,
    340  * 'h->len' is the length of the packet off the wire, and 'h->caplen'
    341  * is the number of bytes actually captured.
    342  */
    343 u_int
    344 fddi_if_print(netdissect_options *ndo, const struct pcap_pkthdr *h, register const u_char *p)
    345 {
    346 	fddi_print(ndo, p, h->len, h->caplen);
    347 
    348 	return (FDDI_HDRLEN);
    349 }
    350