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