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