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