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