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