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