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