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