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