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