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