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