[dragonfly.git] / contrib / tcpdump / print-fddi.c

/*
 * Copyright (c) 1991, 1992, 1993, 1994, 1995, 1996, 1997
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that: (1) source code distributions
 * retain the above copyright notice and this paragraph in its entirety, (2)
 * distributions including binary code include the above copyright notice and
 * this paragraph in its entirety in the documentation or other materials
 * provided with the distribution, and (3) all advertising materials mentioning
 * features or use of this software display the following acknowledgement:
 * ``This product includes software developed by the University of California,
 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
 * the University nor the names of its contributors may be used to endorse
 * or promote products derived from this software without specific prior
 * written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#ifndef lint
static const char rcsid[] _U_ =
    "@(#) $Header: /tcpdump/master/tcpdump/print-fddi.c,v 1.64.2.2 2005/11/13 12:12:59 guy Exp $ (LBL)";
#endif

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <tcpdump-stdinc.h>

#include <pcap.h>
#include <stdio.h>
#include <string.h>

#include "interface.h"
#include "addrtoname.h"
#include "ethertype.h"

#include "ether.h"
#include "fddi.h"

/*
 * Some FDDI interfaces use bit-swapped addresses.
 */
#if defined(ultrix) || defined(__alpha) || defined(__bsdi) || defined(__NetBSD__) || defined(__linux__)
int	fddi_bitswap = 0;
#else
int	fddi_bitswap = 1;
#endif

/*
 * FDDI support for tcpdump, by Jeffrey Mogul [DECWRL], June 1992
 *
 * Based in part on code by Van Jacobson, which bears this note:
 *
 * NOTE:  This is a very preliminary hack for FDDI support.
 * There are all sorts of wired in constants & nothing (yet)
 * to print SMT packets as anything other than hex dumps.
 * Most of the necessary changes are waiting on my redoing
 * the "header" that a kernel fddi driver supplies to bpf:  I
 * want it to look like one byte of 'direction' (0 or 1
 * depending on whether the packet was inbound or outbound),
 * two bytes of system/driver dependent data (anything an
 * implementor thinks would be useful to filter on and/or
 * save per-packet, then the real 21-byte FDDI header.
 * Steve McCanne & I have also talked about adding the
 * 'direction' byte to all bpf headers (e.g., in the two
 * bytes of padding on an ethernet header).  It's not clear
 * we could do this in a backwards compatible way & we hate
 * the idea of an incompatible bpf change.  Discussions are
 * proceeding.
 *
 * Also, to really support FDDI (and better support 802.2
 * over ethernet) we really need to re-think the rather simple
 * minded assumptions about fixed length & fixed format link
 * level headers made in gencode.c.  One day...
 *
 *  - vj
 */

static u_char fddi_bit_swap[] = {
	0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
	0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
	0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
	0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
	0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
	0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
	0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
	0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
	0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
	0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
	0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
	0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
	0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
	0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
	0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
	0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
	0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
	0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
	0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
	0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
	0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
	0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
	0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
	0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
	0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
	0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
	0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
	0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
	0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
	0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
	0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
	0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
};

/*
 * Print FDDI frame-control bits
 */
static inline void
print_fddi_fc(u_char fc)
{
	switch (fc) {

	case FDDIFC_VOID:                         /* Void frame */
		printf("void ");
		break;

	case FDDIFC_NRT:                          /* Nonrestricted token */
		printf("nrt ");
		break;

	case FDDIFC_RT:                           /* Restricted token */
		printf("rt ");
		break;

	case FDDIFC_SMT_INFO:                     /* SMT Info */
		printf("info ");
		break;

	case FDDIFC_SMT_NSA:                      /* SMT Next station adrs */
		printf("nsa ");
		break;

	case FDDIFC_MAC_BEACON:                   /* MAC Beacon frame */
		printf("beacon ");
		break;

	case FDDIFC_MAC_CLAIM:                    /* MAC Claim frame */
		printf("claim ");
		break;

	default:
		switch (fc & FDDIFC_CLFF) {

		case FDDIFC_MAC:
			printf("mac%1x ", fc & FDDIFC_ZZZZ);
			break;

		case FDDIFC_SMT:
			printf("smt%1x ", fc & FDDIFC_ZZZZ);
			break;

		case FDDIFC_LLC_ASYNC:
			printf("async%1x ", fc & FDDIFC_ZZZZ);
			break;

		case FDDIFC_LLC_SYNC:
			printf("sync%1x ", fc & FDDIFC_ZZZZ);
			break;

		case FDDIFC_IMP_ASYNC:
			printf("imp_async%1x ", fc & FDDIFC_ZZZZ);
			break;

		case FDDIFC_IMP_SYNC:
			printf("imp_sync%1x ", fc & FDDIFC_ZZZZ);
			break;

		default:
			printf("%02x ", fc);
			break;
		}
	}
}

/* Extract src, dst addresses */
static inline void
extract_fddi_addrs(const struct fddi_header *fddip, char *fsrc, char *fdst)
{
	register int i;

	if (fddi_bitswap) {
		/*
		 * bit-swap the fddi addresses (isn't the IEEE standards
		 * process wonderful!) then convert them to names.
		 */
		for (i = 0; i < 6; ++i)
			fdst[i] = fddi_bit_swap[fddip->fddi_dhost[i]];
		for (i = 0; i < 6; ++i)
			fsrc[i] = fddi_bit_swap[fddip->fddi_shost[i]];
	}
	else {
		memcpy(fdst, (const char *)fddip->fddi_dhost, 6);
		memcpy(fsrc, (const char *)fddip->fddi_shost, 6);
	}
}

/*
 * Print the FDDI MAC header
 */
static inline void
fddi_hdr_print(register const struct fddi_header *fddip, register u_int length,
	   register const u_char *fsrc, register const u_char *fdst)
{
	const char *srcname, *dstname;

	srcname = etheraddr_string(fsrc);
	dstname = etheraddr_string(fdst);

	if (vflag)
		(void) printf("%02x %s %s %d: ",
		       fddip->fddi_fc,
		       srcname, dstname,
		       length);
	else if (qflag)
		printf("%s %s %d: ", srcname, dstname, length);
	else {
		(void) print_fddi_fc(fddip->fddi_fc);
		(void) printf("%s %s %d: ", srcname, dstname, length);
	}
}

static inline void
fddi_smt_print(const u_char *p _U_, u_int length _U_)
{
	printf("<SMT printer not yet implemented>");
}

void
fddi_print(const u_char *p, u_int length, u_int caplen)
{
	const struct fddi_header *fddip = (const struct fddi_header *)p;
	struct ether_header ehdr;
	u_short extracted_ethertype;

	if (caplen < FDDI_HDRLEN) {
		printf("[|fddi]");
		return;
	}

	/*
	 * Get the FDDI addresses into a canonical form
	 */
	extract_fddi_addrs(fddip, (char *)ESRC(&ehdr), (char *)EDST(&ehdr));

	if (eflag)
		fddi_hdr_print(fddip, length, ESRC(&ehdr), EDST(&ehdr));

	/* Skip over FDDI MAC header */
	length -= FDDI_HDRLEN;
	p += FDDI_HDRLEN;
	caplen -= FDDI_HDRLEN;

	/* Frame Control field determines interpretation of packet */
	if ((fddip->fddi_fc & FDDIFC_CLFF) == FDDIFC_LLC_ASYNC) {
		/* Try to print the LLC-layer header & higher layers */
		if (llc_print(p, length, caplen, ESRC(&ehdr), EDST(&ehdr),
		    &extracted_ethertype) == 0) {
			/*
			 * Some kinds of LLC packet we cannot
			 * handle intelligently
			 */
			if (!eflag)
				fddi_hdr_print(fddip, length + FDDI_HDRLEN,
				    ESRC(&ehdr), EDST(&ehdr));
			if (extracted_ethertype) {
				printf("(LLC %s) ",
			etherproto_string(htons(extracted_ethertype)));
			}
			if (!suppress_default_print)
				default_print(p, caplen);
		}
	} else if ((fddip->fddi_fc & FDDIFC_CLFF) == FDDIFC_SMT)
		fddi_smt_print(p, caplen);
	else {
		/* Some kinds of FDDI packet we cannot handle intelligently */
		if (!eflag)
			fddi_hdr_print(fddip, length + FDDI_HDRLEN, ESRC(&ehdr),
			    EDST(&ehdr));
		if (!suppress_default_print)
			default_print(p, caplen);
	}
}

/*
 * This is the top level routine of the printer.  'p' points
 * to the FDDI header of the packet, 'h->ts' is the timestamp,
 * 'h->len' is the length of the packet off the wire, and 'h->caplen'
 * is the number of bytes actually captured.
 */
u_int
fddi_if_print(const struct pcap_pkthdr *h, register const u_char *p)
{
	fddi_print(p, h->len, h->caplen);

	return (FDDI_HDRLEN);
}
Commit	Line	Data
c8cf0f94 PA	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	}