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