?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dmake: do not set MAKEFLAGS=k
[unleashed/tickless.git] / usr / src / cmd / cmd-inet / usr.sbin / snoop / snoop_ether.c
blob332069508ccd7ab20902f969d4c1e5fb9cd86bf3
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <stddef.h>
30 #include <fcntl.h>
31 #include <string.h>
32 #include <sys/types.h>
33 #include <sys/time.h>
34 #include <sys/sysmacros.h>
35 #include <sys/socket.h>
36 #include <net/if.h>
37 #include <netinet/in_systm.h>
38 #include <netinet/in.h>
39 #include <netinet/ip.h>
40 #include <netinet/if_ether.h>
41 #include <sys/ib/clients/ibd/ibd.h>
42 #include <sys/ethernet.h>
43 #include <sys/vlan.h>
44 #include <sys/zone.h>
45 #include <inet/iptun.h>
46 #include <sys/byteorder.h>
47 #include <limits.h>
48 #include <inet/ip.h>
49 #include <inet/ip6.h>
50 #include <net/trill.h>
51
52 #include "at.h"
53 #include "snoop.h"
54
55 static headerlen_fn_t ether_header_len, fddi_header_len, tr_header_len,
56 ib_header_len, ipnet_header_len, ipv4_header_len, ipv6_header_len;
57 static interpreter_fn_t interpret_ether, interpret_fddi, interpret_tr,
58 interpret_ib, interpret_ipnet, interpret_iptun;
59 static void addr_copy_swap(struct ether_addr *, struct ether_addr *);
60 static int tr_machdr_len(char *, int *, int *);
61
62 interface_t *interface;
63 interface_t INTERFACES[] = {
64
65 /* IEEE 802.3 CSMA/CD network */
66 { DL_CSMACD, 1550, 12, 2, ETHERTYPE_IP, ETHERTYPE_IPV6,
67 ether_header_len, interpret_ether, B_TRUE },
68
69 /* Ethernet Bus */
70 { DL_ETHER, 1550, 12, 2, ETHERTYPE_IP, ETHERTYPE_IPV6,
71 ether_header_len, interpret_ether, B_TRUE },
72
73 /* Fiber Distributed data interface */
74 { DL_FDDI, 4500, 19, 2, ETHERTYPE_IP, ETHERTYPE_IPV6,
75 fddi_header_len, interpret_fddi, B_FALSE },
76
77 /* Token Ring interface */
78 { DL_TPR, 17800, 0, 2, ETHERTYPE_IP, ETHERTYPE_IPV6,
79 tr_header_len, interpret_tr, B_FALSE },
80
81 /* Infiniband */
82 { DL_IB, 4096, 0, 2, ETHERTYPE_IP, ETHERTYPE_IPV6,
83 ib_header_len, interpret_ib, B_TRUE },
84
85 /* ipnet */
86 { DL_IPNET, INT_MAX, 1, 1, IPV4_VERSION, IPV6_VERSION,
87 ipnet_header_len, interpret_ipnet, B_TRUE },
88
89 /* IPv4 tunnel */
90 { DL_IPV4, 0, 9, 1, IPPROTO_ENCAP, IPPROTO_IPV6,
91 ipv4_header_len, interpret_iptun, B_FALSE },
92
93 /* IPv6 tunnel */
94 { DL_IPV6, 0, 40, 1, IPPROTO_ENCAP, IPPROTO_IPV6,
95 ipv6_header_len, interpret_iptun, B_FALSE },
96
97 /* 6to4 tunnel */
98 { DL_6TO4, 0, 9, 1, IPPROTO_ENCAP, IPPROTO_IPV6,
99 ipv4_header_len, interpret_iptun, B_FALSE },
100
101 { (uint_t)-1, 0, 0, 0, 0, 0, NULL, B_FALSE }
102 };
103
104 /* externals */
105 extern char *dlc_header;
106 extern int pi_frame;
107 extern int pi_time_hour;
108 extern int pi_time_min;
109 extern int pi_time_sec;
110 extern int pi_time_usec;
111
112 char *printether();
113 char *print_ethertype();
114 static char *print_etherinfo();
115
116 char *print_fc();
117 char *print_smttype();
118 char *print_smtclass();
119
120 struct ether_addr ether_broadcast = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
121 static char *data; /* current data buffer */
122 static int datalen; /* current data buffer length */
123 static const struct ether_addr all_isis_rbridges = ALL_ISIS_RBRIDGES;
124
125 uint_t
126 interpret_ether(int flags, char *header, int elen, int origlen)
127 {
128 struct ether_header *e = (struct ether_header *)header;
129 uchar_t *off, *ieeestart;
130 int len;
131 int ieee8023 = 0;
132 extern char *dst_name;
133 int ethertype;
134 struct ether_vlan_extinfo *evx = NULL;
135 int blen = MAX(origlen, ETHERMTU);
136 boolean_t trillpkt = B_FALSE;
137 uint16_t tci = 0;
138
139 if (data != NULL && datalen != 0 && datalen < blen) {
140 free(data);
141 data = NULL;
142 datalen = 0;
143 }
144 if (!data) {
145 data = (char *)malloc(blen);
146 if (!data)
147 pr_err("Warning: malloc failure");
148 datalen = blen;
149 }
150 inner_pkt:
151 if (origlen < 14) {
152 if (flags & F_SUM) {
153 (void) sprintf(get_sum_line(),
154 "RUNT (short packet - %d bytes)",
155 origlen);
156 }
157 if (flags & F_DTAIL)
158 show_header("RUNT: ", "Short packet", origlen);
159 return (elen);
160 }
161 if (elen < 14)
162 return (elen);
163
164 if (memcmp(&e->ether_dhost, &ether_broadcast,
165 sizeof (struct ether_addr)) == 0)
166 dst_name = "(broadcast)";
167 else if (e->ether_dhost.ether_addr_octet[0] & 1)
168 dst_name = "(multicast)";
169
170 ethertype = ntohs(e->ether_type);
171
172 /*
173 * The 14 byte ether header screws up alignment
174 * of the rest of the packet for 32 bit aligned
175 * architectures like SPARC. Alas, we have to copy
176 * the rest of the packet in order to align it.
177 */
178 len = elen - sizeof (struct ether_header);
179 off = (uchar_t *)(e + 1);
180
181 if (ethertype == ETHERTYPE_VLAN) {
182 if (origlen < sizeof (struct ether_vlan_header)) {
183 if (flags & F_SUM) {
184 (void) sprintf(get_sum_line(),
185 "RUNT (short VLAN packet - %d bytes)",
186 origlen);
187 }
188 if (flags & F_DTAIL) {
189 show_header("RUNT: ", "Short VLAN packet",
190 origlen);
191 }
192 return (elen);
193 }
194 if (len < sizeof (struct ether_vlan_extinfo))
195 return (elen);
196
197 evx = (struct ether_vlan_extinfo *)off;
198 off += sizeof (struct ether_vlan_extinfo);
199 len -= sizeof (struct ether_vlan_extinfo);
200
201 ethertype = ntohs(evx->ether_type);
202 tci = ntohs(evx->ether_tci);
203 }
204
205 if (ethertype <= 1514) {
206 /*
207 * Fake out the IEEE 802.3 packets.
208 * Should be DSAP=0xAA, SSAP=0xAA, control=0x03
209 * then three padding bytes of zero (OUI),
210 * followed by a normal ethernet-type packet.
211 */
212 ieee8023 = ethertype;
213 ieeestart = off;
214 if (off[0] == 0xAA && off[1] == 0xAA) {
215 ethertype = ntohs(*(ushort_t *)(off + 6));
216 off += 8;
217 len -= 8;
218 } else {
219 ethertype = 0;
220 off += 3;
221 len -= 3;
222 }
223 }
224
225 if (flags & F_SUM) {
226 /*
227 * Set the flag that says don't display VLAN information.
228 * If it needs to change, that will be done later if the
229 * packet is VLAN tagged and if snoop is in its default
230 * summary mode.
231 */
232 set_vlan_id(0);
233 if (evx == NULL) {
234 if (ethertype == 0 && ieee8023 > 0) {
235 (void) sprintf(get_sum_line(),
236 "ETHER 802.3 SSAP %02X DSAP %02X, "
237 "size=%d bytes", ieeestart[0], ieeestart[1],
238 origlen);
239 } else {
240 (void) sprintf(get_sum_line(),
241 "ETHER Type=%04X (%s), size=%d bytes",
242 ethertype, print_ethertype(ethertype),
243 origlen);
244 }
245 } else {
246 if (ethertype == 0 && ieee8023 > 0) {
247 (void) sprintf(get_sum_line(),
248 "ETHER 802.3 SSAP %02X DSAP %02X, "
249 "VLAN ID=%hu, size=%d bytes", ieeestart[0],
250 ieeestart[1], VLAN_ID(tci), origlen);
251 } else {
252 (void) sprintf(get_sum_line(),
253 "ETHER Type=%04X (%s), VLAN ID=%hu, "
254 "size=%d bytes", ethertype,
255 print_ethertype(ethertype), VLAN_ID(tci),
256 origlen);
257 }
258
259 if (!(flags & F_ALLSUM))
260 set_vlan_id(VLAN_ID(tci));
261 }
262 }
263
264 if (flags & F_DTAIL) {
265 show_header("ETHER: ", "Ether Header", elen);
266 show_space();
267 if (!trillpkt) {
268 (void) sprintf(get_line(0, 0),
269 "Packet %d arrived at %d:%02d:%d.%05d",
270 pi_frame,
271 pi_time_hour, pi_time_min, pi_time_sec,
272 pi_time_usec / 10);
273 (void) sprintf(get_line(0, 0),
274 "Packet size = %d bytes",
275 elen, elen);
276 }
277 (void) sprintf(get_line(0, 6),
278 "Destination = %s, %s",
279 printether(&e->ether_dhost),
280 print_etherinfo(&e->ether_dhost));
281 (void) sprintf(get_line(6, 6),
282 "Source = %s, %s",
283 printether(&e->ether_shost),
284 print_etherinfo(&e->ether_shost));
285 if (evx != NULL) {
286 (void) sprintf(get_line(0, 0),
287 "VLAN ID = %hu", VLAN_ID(tci));
288 (void) sprintf(get_line(0, 0),
289 "VLAN Priority = %hu", VLAN_PRI(tci));
290 }
291 if (ieee8023 > 0) {
292 (void) sprintf(get_line(12, 2),
293 "IEEE 802.3 length = %d bytes", ieee8023);
294 /* Print LLC only for non-TCP/IP packets */
295 if (ethertype == 0) {
296 (void) snprintf(get_line(0, 0),
297 get_line_remain(),
298 "SSAP = %02X, DSAP = %02X, CTRL = %02X",
299 ieeestart[0], ieeestart[1], ieeestart[2]);
300 }
301 }
302 if (ethertype != 0 || ieee8023 == 0)
303 (void) sprintf(get_line(12, 2),
304 "Ethertype = %04X (%s)",
305 ethertype, print_ethertype(ethertype));
306 show_space();
307 }
308
309 /*
310 * We cannot trust the length field in the header to be correct.
311 * But we should continue to process the packet. Then user can
312 * notice something funny in the header.
313 * Go to the next protocol layer only if data have been
314 * copied.
315 */
316 if (len > 0 && (off + len <= (uchar_t *)e + elen)) {
317 (void) memmove(data, off, len);
318
319 if (!trillpkt && ethertype == ETHERTYPE_TRILL) {
320 ethertype = interpret_trill(flags, &e, data, &len);
321 /* Decode inner Ethernet frame */
322 if (ethertype != 0) {
323 evx = NULL;
324 trillpkt = B_TRUE;
325 (void) memmove(data, e, len);
326 e = (struct ether_header *)data;
327 origlen = len;
328 elen = len;
329 goto inner_pkt;
330 }
331 }
332
333 switch (ethertype) {
334 case ETHERTYPE_IP:
335 (void) interpret_ip(flags, (struct ip *)data, len);
336 break;
337 /* Just in case it is decided to add this type */
338 case ETHERTYPE_IPV6:
339 (void) interpret_ipv6(flags, (ip6_t *)data, len);
340 break;
341 case ETHERTYPE_ARP:
342 case ETHERTYPE_REVARP:
343 interpret_arp(flags, (struct arphdr *)data, len);
344 break;
345 case ETHERTYPE_PPPOED:
346 case ETHERTYPE_PPPOES:
347 (void) interpret_pppoe(flags, (poep_t *)data, len);
348 break;
349 case ETHERTYPE_AARP: /* AppleTalk */
350 interpret_aarp(flags, data, len);
351 break;
352 case ETHERTYPE_AT:
353 interpret_at(flags, (struct ddp_hdr *)data, len);
354 break;
355 case 0:
356 if (ieee8023 == 0)
357 break;
358 switch (ieeestart[0]) {
359 case 0xFE:
360 interpret_isis(flags, data, len,
361 memcmp(&e->ether_dhost, &all_isis_rbridges,
362 sizeof (struct ether_addr)) == 0);
363 break;
364 case 0x42:
365 interpret_bpdu(flags, data, len);
366 break;
367 }
368 break;
369 }
370 }
371
372 return (elen);
373 }
374
375 /*
376 * Return the length of the ethernet header. In the case
377 * where we have a VLAN tagged packet, return the length of
378 * the ethernet header plus the length of the VLAN tag.
379 *
380 * INPUTS: e - A buffer pointer. Passing a NULL pointer
381 * is not allowed, e must be non-NULL.
382 * OUTPUTS: Return the size of an untagged ethernet header
383 * if the packet is not VLAN tagged, and the size
384 * of an untagged ethernet header plus the size of
385 * a VLAN header otherwise.
386 */
387 uint_t
388 ether_header_len(char *e, size_t msgsize)
389 {
390 uint16_t ether_type = 0;
391
392 if (msgsize < sizeof (struct ether_header))
393 return (0);
394
395 e += (offsetof(struct ether_header, ether_type));
396
397 GETINT16(ether_type, e);
398
399 if (ether_type == (uint16_t)ETHERTYPE_VLAN) {
400 return (sizeof (struct ether_vlan_header));
401 } else {
402 return (sizeof (struct ether_header));
403 }
404 }
405
406
407 /*
408 * Table of Ethertypes.
409 * Some of the more popular entries
410 * are at the beginning of the table
411 * to reduce search time.
412 */
413 struct ether_type {
414 int e_type;
415 char *e_name;
416 } ether_type [] = {
417 ETHERTYPE_IP, "IP",
418 ETHERTYPE_ARP, "ARP",
419 ETHERTYPE_REVARP, "RARP",
420 ETHERTYPE_IPV6, "IPv6",
421 ETHERTYPE_PPPOED, "PPPoE Discovery",
422 ETHERTYPE_PPPOES, "PPPoE Session",
423 ETHERTYPE_TRILL, "TRILL",
424 /* end of popular entries */
425 ETHERTYPE_PUP, "Xerox PUP",
426 0x0201, "Xerox PUP",
427 0x0400, "Nixdorf",
428 0x0600, "Xerox NS IDP",
429 0x0601, "XNS Translation",
430 0x0801, "X.75 Internet",
431 0x0802, "NBS Internet",
432 0x0803, "ECMA Internet",
433 0x0804, "CHAOSnet",
434 0x0805, "X.25 Level 3",
435 0x0807, "XNS Compatibility",
436 0x081C, "Symbolics Private",
437 0x0888, "Xyplex",
438 0x0889, "Xyplex",
439 0x088A, "Xyplex",
440 0x0900, "Ungermann-Bass network debugger",
441 0x0A00, "Xerox IEEE802.3 PUP",
442 0x0A01, "Xerox IEEE802.3 PUP Address Translation",
443 0x0BAD, "Banyan Systems",
444 0x0BAF, "Banyon VINES Echo",
445 0x1000, "Berkeley Trailer negotiation",
446 0x1000, "IP trailer (0)",
447 0x1001, "IP trailer (1)",
448 0x1002, "IP trailer (2)",
449 0x1003, "IP trailer (3)",
450 0x1004, "IP trailer (4)",
451 0x1005, "IP trailer (5)",
452 0x1006, "IP trailer (6)",
453 0x1007, "IP trailer (7)",
454 0x1008, "IP trailer (8)",
455 0x1009, "IP trailer (9)",
456 0x100a, "IP trailer (10)",
457 0x100b, "IP trailer (11)",
458 0x100c, "IP trailer (12)",
459 0x100d, "IP trailer (13)",
460 0x100e, "IP trailer (14)",
461 0x100f, "IP trailer (15)",
462 0x1234, "DCA - Multicast",
463 0x1600, "VALID system protocol",
464 0x1989, "Aviator",
465 0x3C00, "3Com NBP virtual circuit datagram",
466 0x3C01, "3Com NBP System control datagram",
467 0x3C02, "3Com NBP Connect request (virtual cct)",
468 0x3C03, "3Com NBP Connect response",
469 0x3C04, "3Com NBP Connect complete",
470 0x3C05, "3Com NBP Close request (virtual cct)",
471 0x3C06, "3Com NBP Close response",
472 0x3C07, "3Com NBP Datagram (like XNS IDP)",
473 0x3C08, "3Com NBP Datagram broadcast",
474 0x3C09, "3Com NBP Claim NetBIOS name",
475 0x3C0A, "3Com NBP Delete Netbios name",
476 0x3C0B, "3Com NBP Remote adaptor status request",
477 0x3C0C, "3Com NBP Remote adaptor response",
478 0x3C0D, "3Com NBP Reset",
479 0x4242, "PCS Basic Block Protocol",
480 0x4321, "THD - Diddle",
481 0x5208, "BBN Simnet Private",
482 0x6000, "DEC unass, experimental",
483 0x6001, "DEC Dump/Load",
484 0x6002, "DEC Remote Console",
485 0x6003, "DECNET Phase IV, DNA Routing",
486 0x6004, "DEC LAT",
487 0x6005, "DEC Diagnostic",
488 0x6006, "DEC customer protocol",
489 0x6007, "DEC Local Area VAX Cluster (LAVC)",
490 0x6008, "DEC unass (AMBER?)",
491 0x6009, "DEC unass (MUMPS?)",
492 0x6010, "3Com",
493 0x6011, "3Com",
494 0x6012, "3Com",
495 0x6013, "3Com",
496 0x6014, "3Com",
497 0x7000, "Ungermann-Bass download",
498 0x7001, "Ungermann-Bass NIUs",
499 0x7002, "Ungermann-Bass diagnostic/loopback",
500 0x7003, "Ungermann-Bass ? (NMC to/from UB Bridge)",
501 0x7005, "Ungermann-Bass Bridge Spanning Tree",
502 0x7007, "OS/9 Microware",
503 0x7009, "OS/9 Net?",
504 0x7020, "Sintrom",
505 0x7021, "Sintrom",
506 0x7022, "Sintrom",
507 0x7023, "Sintrom",
508 0x7024, "Sintrom",
509 0x7025, "Sintrom",
510 0x7026, "Sintrom",
511 0x7027, "Sintrom",
512 0x7028, "Sintrom",
513 0x7029, "Sintrom",
514 0x8003, "Cronus VLN",
515 0x8004, "Cronus Direct",
516 0x8005, "HP Probe protocol",
517 0x8006, "Nestar",
518 0x8008, "AT&T/Stanford Univ",
519 0x8010, "Excelan",
520 0x8013, "SGI diagnostic",
521 0x8014, "SGI network games",
522 0x8015, "SGI reserved",
523 0x8016, "SGI XNS NameServer, bounce server",
524 0x8019, "Apollo DOMAIN",
525 0x802E, "Tymshare",
526 0x802F, "Tigan,",
527 0x8036, "Aeonic Systems",
528 0x8037, "IPX (Novell Netware)",
529 0x8038, "DEC LanBridge Management",
530 0x8039, "DEC unass (DSM/DTP?)",
531 0x803A, "DEC unass (Argonaut Console?)",
532 0x803B, "DEC unass (VAXELN?)",
533 0x803C, "DEC unass (NMSV? DNA Naming Service?)",
534 0x803D, "DEC Ethernet CSMA/CD Encryption Protocol",
535 0x803E, "DEC unass (DNA Time Service?)",
536 0x803F, "DEC LAN Traffic Monitor Protocol",
537 0x8040, "DEC unass (NetBios Emulator?)",
538 0x8041, "DEC unass (MS/DOS?, Local Area System Transport?)",
539 0x8042, "DEC unass",
540 0x8044, "Planning Research Corp.",
541 0x8046, "AT&T",
542 0x8047, "AT&T",
543 0x8049, "ExperData",
544 0x805B, "VMTP",
545 0x805C, "Stanford V Kernel, version 6.0",
546 0x805D, "Evans & Sutherland",
547 0x8060, "Little Machines",
548 0x8062, "Counterpoint",
549 0x8065, "University of Mass. at Amherst",
550 0x8066, "University of Mass. at Amherst",
551 0x8067, "Veeco Integrated Automation",
552 0x8068, "General Dynamics",
553 0x8069, "AT&T",
554 0x806A, "Autophon",
555 0x806C, "ComDesign",
556 0x806D, "Compugraphic Corp",
557 0x806E, "Landmark",
558 0x806F, "Landmark",
559 0x8070, "Landmark",
560 0x8071, "Landmark",
561 0x8072, "Landmark",
562 0x8073, "Landmark",
563 0x8074, "Landmark",
564 0x8075, "Landmark",
565 0x8076, "Landmark",
566 0x8077, "Landmark",
567 0x807A, "Matra",
568 0x807B, "Dansk Data Elektronik",
569 0x807C, "Merit Internodal",
570 0x807D, "Vitalink",
571 0x807E, "Vitalink",
572 0x807F, "Vitalink",
573 0x8080, "Vitalink TransLAN III Management",
574 0x8081, "Counterpoint",
575 0x8082, "Counterpoint",
576 0x8083, "Counterpoint",
577 0x8088, "Xyplex",
578 0x8089, "Xyplex",
579 0x808A, "Xyplex",
580 0x809B, "EtherTalk (AppleTalk over Ethernet)",
581 0x809C, "Datability",
582 0x809D, "Datability",
583 0x809E, "Datability",
584 0x809F, "Spider Systems",
585 0x80A3, "Nixdorf",
586 0x80A4, "Siemens Gammasonics",
587 0x80C0, "DCA Data Exchange Cluster",
588 0x80C6, "Pacer Software",
589 0x80C7, "Applitek Corp",
590 0x80C8, "Intergraph",
591 0x80C9, "Intergraph",
592 0x80CB, "Intergraph",
593 0x80CC, "Intergraph",
594 0x80CA, "Intergraph",
595 0x80CD, "Harris Corp",
596 0x80CE, "Harris Corp",
597 0x80CF, "Taylor Instrument",
598 0x80D0, "Taylor Instrument",
599 0x80D1, "Taylor Instrument",
600 0x80D2, "Taylor Instrument",
601 0x80D3, "Rosemount Corp",
602 0x80D4, "Rosemount Corp",
603 0x80D5, "IBM SNA Services over Ethernet",
604 0x80DD, "Varian Associates",
605 0x80DE, "TRFS",
606 0x80DF, "TRFS",
607 0x80E0, "Allen-Bradley",
608 0x80E1, "Allen-Bradley",
609 0x80E2, "Allen-Bradley",
610 0x80E3, "Allen-Bradley",
611 0x80E4, "Datability",
612 0x80F2, "Retix",
613 0x80F3, "AARP (Appletalk)",
614 0x80F4, "Kinetics",
615 0x80F5, "Kinetics",
616 0x80F7, "Apollo",
617 0x80FF, "Wellfleet Communications",
618 0x8102, "Wellfleet Communications",
619 0x8107, "Symbolics Private",
620 0x8108, "Symbolics Private",
621 0x8109, "Symbolics Private",
622 0x812B, "Talaris",
623 0x8130, "Waterloo",
624 0x8131, "VG Lab",
625 0x8137, "Novell (old) NetWare IPX",
626 0x8138, "Novell",
627 0x814C, "SNMP over Ethernet",
628 0x817D, "XTP",
629 0x81D6, "Lantastic",
630 0x8888, "HP LanProbe test?",
631 0x9000, "Loopback",
632 0x9001, "3Com, XNS Systems Management",
633 0x9002, "3Com, TCP/IP Systems Management",
634 0x9003, "3Com, loopback detection",
635 0xAAAA, "DECNET (VAX 6220 DEBNI)",
636 0xFF00, "BBN VITAL-LanBridge cache wakeups",
637 0, "",
638 };
639
640 char *
641 print_fc(uint_t type)
642 {
643
644 switch (type) {
645 case 0x50: return ("LLC");
646 case 0x4f: return ("SMT NSA");
647 case 0x41: return ("SMT Info");
648 default: return ("Unknown");
649 }
650 }
651
652 char *
653 print_smtclass(uint_t type)
654 {
655 switch (type) {
656 case 0x01: return ("NIF");
657 case 0x02: return ("SIF Conf");
658 case 0x03: return ("SIF Oper");
659 case 0x04: return ("ECF");
660 case 0x05: return ("RAF");
661 case 0x06: return ("RDF");
662 case 0x07: return ("SRF");
663 case 0x08: return ("PMF Get");
664 case 0x09: return ("PMF Change");
665 case 0x0a: return ("PMF Add");
666 case 0x0b: return ("PMF Remove");
667 case 0xff: return ("ESF");
668 default: return ("Unknown");
669 }
670
671 }
672 char *
673 print_smttype(uint_t type)
674 {
675 switch (type) {
676 case 0x01: return ("Announce");
677 case 0x02: return ("Request");
678 case 0x03: return ("Response");
679 default: return ("Unknown");
680 }
681
682 }
683 char *
684 print_ethertype(int type)
685 {
686 int i;
687
688 for (i = 0; ether_type[i].e_type; i++)
689 if (type == ether_type[i].e_type)
690 return (ether_type[i].e_name);
691 if (type < 1500)
692 return ("LLC/802.3");
693
694 return ("Unknown");
695 }
696
697 #define MAX_RDFLDS 14 /* changed to 14 from 8 as per IEEE */
698 #define TR_FN_ADDR 0x80 /* dest addr is functional */
699 #define TR_SR_ADDR 0x80 /* MAC utilizes source route */
700 #define ACFCDASA_LEN 14 /* length of AC|FC|DA|SA */
701 #define TR_MAC_MASK 0xc0
702 #define TR_AC 0x00 /* Token Ring access control */
703 #define TR_LLC_FC 0x40 /* Token Ring llc frame control */
704 #define LSAP_SNAP 0xaa
705 #define LLC_SNAP_HDR_LEN 8
706 #define LLC_HDR1_LEN 3 /* DON'T use sizeof(struct llc_hdr1) */
707 #define CNTL_LLC_UI 0x03 /* un-numbered information packet */
708
709 /*
710 * Source Routing Route Information field.
711 */
712 struct tr_ri {
713 #if defined(_BIT_FIELDS_HTOL)
714 uchar_t rt:3; /* routing type */
715 uchar_t len:5; /* length */
716 uchar_t dir:1; /* direction bit */
717 uchar_t mtu:3; /* largest frame */
718 uchar_t res:4; /* reserved */
719 #elif defined(_BIT_FIELDS_LTOH)
720 uchar_t len:5; /* length */
721 uchar_t rt:3; /* routing type */
722 uchar_t res:4; /* reserved */
723 uchar_t mtu:3; /* largest frame */
724 uchar_t dir:1; /* direction bit */
725 #endif
726 /*
727 * In little endian machine, the ring field has to be stored in a
728 * ushort_t type. This implies that it is not possible to have a
729 * layout of bit field to represent bridge and ring.
730 *
731 * If the compiler uses _BIT_FIELDS_HTOL and it is a big endian
732 * machine, the following bit field definition will work.
733 *
734 * struct tr_rd {
735 * ushort_t bridge:4;
736 * ushort_t ring:12;
737 * } rd[MAX_RDFLDS];
738 *
739 * If the compiler uses _BIT_FIELDS_LTOH and it is a big endian
740 * machine, the definition can be changed to
741 *
742 * struct tr_rd {
743 * ushort_t bridge:4;
744 * ushort_t ring:12;
745 * } rd[MAX_RDFLDS];
746 *
747 * With little endian machine, we need to use 2 macroes. For
748 * simplicity, since the macroes work for both big and little
749 * endian machines, we will not use bit fields for the
750 * definition.
751 */
752 #define bridge(route) (ntohs((ushort_t)(route)) & 0x0F)
753 #define ring(route) (ntohs((ushort_t)(route)) >> 4)
754
755 ushort_t rd[MAX_RDFLDS]; /* route designator fields */
756 };
757
758 struct tr_header {
759 uchar_t ac;
760 uchar_t fc;
761 struct ether_addr dhost;
762 struct ether_addr shost;
763 struct tr_ri ri;
764 };
765
766 struct llc_snap_hdr {
767 uchar_t d_lsap; /* destination service access point */
768 uchar_t s_lsap; /* source link service access point */
769 uchar_t control; /* short control field */
770 uchar_t org[3]; /* Ethernet style organization field */
771 ushort_t type; /* Ethernet style type field */
772 };
773
774 struct ether_addr tokenbroadcastaddr2 = {
775 0xc0, 0x00, 0xff, 0xff, 0xff, 0xff
776 };
777
778 int Mtutab[] = {516, 1470, 2052, 4472, 8144, 11407, 17800};
779
780 char *
781 print_sr(struct tr_ri *rh)
782 {
783 int hops, ii;
784 static char line[512];
785
786 sprintf(line, "TR Source Route dir=%d, mtu=%d",
787 rh->dir, Mtutab[rh->mtu]);
788
789 hops = (int)(rh->len - 2) / (int)2;
790
791 if (hops) {
792 sprintf(line+strlen(line), ", Route: ");
793 for (ii = 0; ii < hops; ii++) {
794 if (! bridge(rh->rd[ii])) {
795 sprintf(line+strlen(line), "(%d)",
796 ring(rh->rd[ii]));
797 } else {
798 sprintf(line+strlen(line), "(%d)%d",
799 ring(rh->rd[ii]), bridge(rh->rd[ii]));
800 }
801 }
802 }
803 return (&line[0]);
804 }
805
806 uint_t
807 interpret_tr(int flags, caddr_t e, int elen, int origlen)
808 {
809 struct tr_header *mh;
810 struct tr_ri *rh;
811 uchar_t fc;
812 struct llc_snap_hdr *snaphdr;
813 char *off;
814 int maclen, len;
815 boolean_t data_copied = B_FALSE;
816 extern char *dst_name, *src_name;
817 int ethertype;
818 int is_llc = 0, is_snap = 0, source_routing = 0;
819 int blen = MAX(origlen, 17800);
820
821 if (data != NULL && datalen != 0 && datalen < blen) {
822 free(data);
823 data = NULL;
824 datalen = 0;
825 }
826 if (!data) {
827 data = (char *)malloc(blen);
828 if (!data)
829 pr_err("Warning: malloc failure");
830 datalen = blen;
831 }
832
833 if (origlen < ACFCDASA_LEN) {
834 if (flags & F_SUM) {
835 (void) sprintf(get_sum_line(),
836 "RUNT (short packet - %d bytes)",
837 origlen);
838 }
839 if (flags & F_DTAIL)
840 show_header("RUNT: ", "Short packet", origlen);
841 return (elen);
842 }
843 if (elen < ACFCDASA_LEN)
844 return (elen);
845
846 mh = (struct tr_header *)e;
847 rh = (struct tr_ri *)&mh->ri;
848 fc = mh->fc;
849
850 if (is_llc = tr_machdr_len(e, &maclen, &source_routing)) {
851 snaphdr = (struct llc_snap_hdr *)(e + maclen);
852 if (snaphdr->d_lsap == LSAP_SNAP &&
853 snaphdr->s_lsap == LSAP_SNAP &&
854 snaphdr->control == CNTL_LLC_UI) {
855 is_snap = 1;
856 }
857 }
858
859 if (memcmp(&mh->dhost, &ether_broadcast,
860 sizeof (struct ether_addr)) == 0)
861 dst_name = "(broadcast)";
862 else if (memcmp(&mh->dhost, &tokenbroadcastaddr2,
863 sizeof (struct ether_addr)) == 0)
864 dst_name = "(mac broadcast)";
865 else if (mh->dhost.ether_addr_octet[0] & TR_FN_ADDR)
866 dst_name = "(functional)";
867
868 if (is_snap)
869 ethertype = ntohs(snaphdr->type);
870 else {
871 src_name = print_etherinfo(&mh->shost);
872 dst_name = print_etherinfo(&mh->dhost);
873 }
874
875 /*
876 * The 14 byte ether header screws up alignment
877 * of the rest of the packet for 32 bit aligned
878 * architectures like SPARC. Alas, we have to copy
879 * the rest of the packet in order to align it.
880 */
881 if (is_llc) {
882 if (is_snap) {
883 len = elen - (maclen + LLC_SNAP_HDR_LEN);
884 off = (char *)(e + maclen + LLC_SNAP_HDR_LEN);
885 } else {
886 len = elen - (maclen + LLC_HDR1_LEN);
887 off = (char *)(e + maclen + LLC_HDR1_LEN);
888 }
889 } else {
890 len = elen - maclen;
891 off = (char *)(e + maclen);
892 }
893
894 if (len > 0 && (off + len <= (char *)e + elen)) {
895 (void) memcpy(data, off, len);
896 data_copied = B_TRUE;
897 }
898
899 if (flags & F_SUM) {
900 if (source_routing)
901 sprintf(get_sum_line(), print_sr(rh));
902
903 if (is_llc) {
904 if (is_snap) {
905 (void) sprintf(get_sum_line(), "TR LLC w/SNAP "
906 "Type=%04X (%s), size=%d bytes",
907 ethertype,
908 print_ethertype(ethertype),
909 origlen);
910 } else {
911 (void) sprintf(get_sum_line(), "TR LLC, but no "
912 "SNAP encoding, size = %d bytes",
913 origlen);
914 }
915 } else {
916 (void) sprintf(get_sum_line(),
917 "TR MAC FC=%02X (%s), size = %d bytes",
918 fc, print_fc(fc), origlen);
919 }
920 }
921
922 if (flags & F_DTAIL) {
923 show_header("TR: ", "TR Header", elen);
924 show_space();
925 (void) sprintf(get_line(0, 0),
926 "Packet %d arrived at %d:%02d:%d.%05d",
927 pi_frame,
928 pi_time_hour, pi_time_min, pi_time_sec,
929 pi_time_usec / 10);
930 (void) sprintf(get_line(0, 0),
931 "Packet size = %d bytes",
932 elen);
933 (void) sprintf(get_line(0, 1),
934 "Frame Control = %02x (%s)",
935 fc, print_fc(fc));
936 (void) sprintf(get_line(2, 6),
937 "Destination = %s, %s",
938 printether(&mh->dhost),
939 print_etherinfo(&mh->dhost));
940 (void) sprintf(get_line(8, 6),
941 "Source = %s, %s",
942 printether(&mh->shost),
943 print_etherinfo(&mh->shost));
944
945 if (source_routing)
946 sprintf(get_line(ACFCDASA_LEN, rh->len), print_sr(rh));
947
948 if (is_llc) {
949 (void) sprintf(get_line(maclen, 1),
950 "Dest Service Access Point = %02x",
951 snaphdr->d_lsap);
952 (void) sprintf(get_line(maclen+1, 1),
953 "Source Service Access Point = %02x",
954 snaphdr->s_lsap);
955 (void) sprintf(get_line(maclen+2, 1),
956 "Control = %02x",
957 snaphdr->control);
958 if (is_snap) {
959 (void) sprintf(get_line(maclen+3, 3),
960 "SNAP Protocol Id = %02x%02x%02x",
961 snaphdr->org[0], snaphdr->org[1],
962 snaphdr->org[2]);
963 }
964 }
965
966 if (is_snap) {
967 (void) sprintf(get_line(maclen+6, 2),
968 "SNAP Type = %04X (%s)",
969 ethertype, print_ethertype(ethertype));
970 }
971
972 show_space();
973 }
974
975 /* go to the next protocol layer */
976 if (is_snap && data_copied) {
977 switch (ethertype) {
978 case ETHERTYPE_IP:
979 (void) interpret_ip(flags, (struct ip *)data, len);
980 break;
981 /* Just in case it is decided to add this type */
982 case ETHERTYPE_IPV6:
983 (void) interpret_ipv6(flags, (ip6_t *)data, len);
984 break;
985 case ETHERTYPE_ARP:
986 case ETHERTYPE_REVARP:
987 interpret_arp(flags, (struct arphdr *)data, len);
988 break;
989 case ETHERTYPE_AARP: /* AppleTalk */
990 interpret_aarp(flags, data, len);
991 break;
992 case ETHERTYPE_AT:
993 interpret_at(flags, (struct ddp_hdr *)data, len);
994 break;
995 default:
996 break;
997 }
998 }
999
1000 return (elen);
1001 }
1002
1003
1004 /*
1005 * stuffs length of mac and ri fields into *lenp
1006 * returns:
1007 * 0: mac frame
1008 * 1: llc frame
1009 */
1010 static int
1011 tr_machdr_len(char *e, int *lenp, int *source_routing)
1012 {
1013 struct tr_header *mh;
1014 struct tr_ri *rh;
1015 uchar_t fc;
1016
1017 mh = (struct tr_header *)e;
1018 rh = (struct tr_ri *)&mh->ri;
1019 fc = mh->fc;
1020
1021 if (mh->shost.ether_addr_octet[0] & TR_SR_ADDR) {
1022 *lenp = ACFCDASA_LEN + rh->len;
1023 *source_routing = 1;
1024 } else {
1025 *lenp = ACFCDASA_LEN;
1026 *source_routing = 0;
1027 }
1028
1029 if ((fc & TR_MAC_MASK) == 0)
1030 return (0); /* it's a MAC frame */
1031 else
1032 return (1); /* it's an LLC frame */
1033 }
1034
1035 uint_t
1036 tr_header_len(char *e, size_t msgsize)
1037 {
1038 struct llc_snap_hdr *snaphdr;
1039 int len = 0, source_routing;
1040
1041 if (tr_machdr_len(e, &len, &source_routing) == 0)
1042 return (len); /* it's a MAC frame */
1043
1044 if (msgsize < sizeof (struct llc_snap_hdr))
1045 return (0);
1046
1047 snaphdr = (struct llc_snap_hdr *)(e + len);
1048 if (snaphdr->d_lsap == LSAP_SNAP &&
1049 snaphdr->s_lsap == LSAP_SNAP &&
1050 snaphdr->control == CNTL_LLC_UI)
1051 len += LLC_SNAP_HDR_LEN; /* it's a SNAP frame */
1052 else
1053 len += LLC_HDR1_LEN;
1054
1055 return (len);
1056 }
1057
1058 struct fddi_header {
1059 uchar_t fc;
1060 struct ether_addr dhost, shost;
1061 uchar_t dsap, ssap, ctl, proto_id[3];
1062 ushort_t type;
1063 };
1064
1065 uint_t
1066 interpret_fddi(int flags, caddr_t e, int elen, int origlen)
1067 {
1068 struct fddi_header fhdr, *f = &fhdr;
1069 char *off;
1070 int len;
1071 boolean_t data_copied = B_FALSE;
1072 extern char *dst_name, *src_name;
1073 int ethertype;
1074 int is_llc = 0, is_smt = 0, is_snap = 0;
1075 int blen = MAX(origlen, 4500);
1076
1077 if (data != NULL && datalen != 0 && datalen < blen) {
1078 free(data);
1079 data = NULL;
1080 datalen = 0;
1081 }
1082 if (!data) {
1083 data = (char *)malloc(blen);
1084 if (!data)
1085 pr_err("Warning: malloc failure");
1086 datalen = blen;
1087 }
1088
1089 if (origlen < 13) {
1090 if (flags & F_SUM) {
1091 (void) sprintf(get_sum_line(),
1092 "RUNT (short packet - %d bytes)",
1093 origlen);
1094 }
1095 if (flags & F_DTAIL)
1096 show_header("RUNT: ", "Short packet", origlen);
1097 return (elen);
1098 }
1099 if (elen < 13)
1100 return (elen);
1101
1102 (void) memcpy(&f->fc, e, sizeof (f->fc));
1103 addr_copy_swap(&f->dhost, (struct ether_addr *)(e+1));
1104 addr_copy_swap(&f->shost, (struct ether_addr *)(e+7));
1105
1106 if ((f->fc&0x50) == 0x50) {
1107 is_llc = 1;
1108 (void) memcpy(&f->dsap, e+13, sizeof (f->dsap));
1109 (void) memcpy(&f->ssap, e+14, sizeof (f->ssap));
1110 (void) memcpy(&f->ctl, e+15, sizeof (f->ctl));
1111 if (f->dsap == 0xaa && f->ssap == 0xaa) {
1112 is_snap = 1;
1113 (void) memcpy(&f->proto_id, e+16, sizeof (f->proto_id));
1114 (void) memcpy(&f->type, e+19, sizeof (f->type));
1115 }
1116 } else {
1117 if ((f->fc&0x41) == 0x41 || (f->fc&0x4f) == 0x4f) {
1118 is_smt = 1;
1119 }
1120 }
1121
1122
1123 if (memcmp(&f->dhost, &ether_broadcast,
1124 sizeof (struct ether_addr)) == 0)
1125 dst_name = "(broadcast)";
1126 else if (f->dhost.ether_addr_octet[0] & 0x01)
1127 dst_name = "(multicast)";
1128
1129 if (is_snap)
1130 ethertype = ntohs(f->type);
1131 else {
1132 src_name = print_etherinfo(&f->shost);
1133 dst_name = print_etherinfo(&f->dhost);
1134 }
1135
1136 /*
1137 * The 14 byte ether header screws up alignment
1138 * of the rest of the packet for 32 bit aligned
1139 * architectures like SPARC. Alas, we have to copy
1140 * the rest of the packet in order to align it.
1141 */
1142 if (is_llc) {
1143 if (is_snap) {
1144 len = elen - 21;
1145 off = (char *)(e + 21);
1146 } else {
1147 len = elen - 16;
1148 off = (char *)(e + 16);
1149 }
1150 } else {
1151 len = elen - 13;
1152 off = (char *)(e + 13);
1153 }
1154
1155 if (len > 0 && (off + len <= (char *)e + elen)) {
1156 (void) memcpy(data, off, len);
1157 data_copied = B_TRUE;
1158 }
1159
1160 if (flags & F_SUM) {
1161 if (is_llc) {
1162 if (is_snap) {
1163 (void) sprintf(get_sum_line(),
1164 "FDDI LLC Type=%04X (%s), size = %d bytes",
1165 ethertype,
1166 print_ethertype(ethertype),
1167 origlen);
1168 } else {
1169 (void) sprintf(get_sum_line(), "LLC, but no "
1170 "SNAP encoding, size = %d bytes",
1171 origlen);
1172 }
1173 } else if (is_smt) {
1174 (void) sprintf(get_sum_line(), "SMT Type=%02X (%s), "
1175 "Class = %02X (%s), size = %d bytes",
1176 *(uchar_t *)(data+1), print_smttype(*(data+1)),
1177 *data, print_smtclass(*data), origlen);
1178 } else {
1179 (void) sprintf(get_sum_line(),
1180 "FC=%02X (%s), size = %d bytes",
1181 f->fc, print_fc(f->fc), origlen);
1182 }
1183 }
1184
1185 if (flags & F_DTAIL) {
1186 show_header("FDDI: ", "FDDI Header", elen);
1187 show_space();
1188 (void) sprintf(get_line(0, 0),
1189 "Packet %d arrived at %d:%02d:%d.%05d",
1190 pi_frame,
1191 pi_time_hour, pi_time_min, pi_time_sec,
1192 pi_time_usec / 10);
1193 (void) sprintf(get_line(0, 0),
1194 "Packet size = %d bytes",
1195 elen, elen);
1196 (void) sprintf(get_line(0, 6),
1197 "Destination = %s, %s",
1198 printether(&f->dhost),
1199 print_etherinfo(&f->dhost));
1200 (void) sprintf(get_line(6, 6),
1201 "Source = %s, %s",
1202 printether(&f->shost),
1203 print_etherinfo(&f->shost));
1204
1205 if (is_llc) {
1206 (void) sprintf(get_line(12, 2),
1207 "Frame Control = %02x (%s)",
1208 f->fc, print_fc(f->fc));
1209 (void) sprintf(get_line(12, 2),
1210 "Dest Service Access Point = %02x",
1211 f->dsap);
1212 (void) sprintf(get_line(12, 2),
1213 "Source Service Access Point = %02x",
1214 f->ssap);
1215 (void) sprintf(get_line(12, 2),
1216 "Control = %02x",
1217 f->ctl);
1218 if (is_snap) {
1219 (void) sprintf(get_line(12, 2),
1220 "Protocol Id = %02x%02x%02x",
1221 f->proto_id[0], f->proto_id[1],
1222 f->proto_id[2]);
1223 }
1224 } else if (is_smt) {
1225 (void) sprintf(get_line(12, 2),
1226 "Frame Control = %02x (%s)",
1227 f->fc, print_fc(f->fc));
1228 (void) sprintf(get_line(12, 2),
1229 "Class = %02x (%s)",
1230 (uchar_t)*data, print_smtclass(*data));
1231 (void) sprintf(get_line(12, 2),
1232 "Type = %02x (%s)",
1233 *(uchar_t *)(data+1), print_smttype(*(data+1)));
1234 } else {
1235 (void) sprintf(get_line(12, 2),
1236 "FC=%02X (%s), size = %d bytes",
1237 f->fc, print_fc(f->fc), origlen);
1238 }
1239
1240 if (is_snap) {
1241 (void) sprintf(get_line(12, 2),
1242 "LLC Type = %04X (%s)",
1243 ethertype, print_ethertype(ethertype));
1244 }
1245
1246 show_space();
1247 }
1248
1249 /* go to the next protocol layer */
1250 if (is_llc && is_snap && f->ctl == 0x03 && data_copied) {
1251 switch (ethertype) {
1252 case ETHERTYPE_IP:
1253 (void) interpret_ip(flags, (struct ip *)data, len);
1254 break;
1255 /* Just in case it is decided to add this type */
1256 case ETHERTYPE_IPV6:
1257 (void) interpret_ipv6(flags, (ip6_t *)data, len);
1258 break;
1259 case ETHERTYPE_ARP:
1260 case ETHERTYPE_REVARP:
1261 interpret_arp(flags, (struct arphdr *)data, len);
1262 break;
1263 default:
1264 break;
1265 }
1266
1267 }
1268
1269 return (elen);
1270 }
1271
1272 uint_t
1273 fddi_header_len(char *e, size_t msgsize)
1274 {
1275 struct fddi_header fhdr, *f = &fhdr;
1276
1277 if (msgsize < sizeof (struct fddi_header))
1278 return (0);
1279
1280 (void) memcpy(&f->fc, e, sizeof (f->fc));
1281 (void) memcpy(&f->dhost, e+1, sizeof (struct ether_addr));
1282 (void) memcpy(&f->shost, e+7, sizeof (struct ether_addr));
1283
1284 if ((f->fc&0x50) == 0x50) {
1285 (void) memcpy(&f->dsap, e+13, sizeof (f->dsap));
1286 (void) memcpy(&f->ssap, e+14, sizeof (f->ssap));
1287 (void) memcpy(&f->ctl, e+15, sizeof (f->ctl));
1288 if (f->dsap == 0xaa && f->ssap == 0xaa) {
1289 return (21);
1290 }
1291 return (16);
1292 } else {
1293 if ((f->fc&0x41) == 0x41 || (f->fc&0x4f) == 0x4f) {
1294 return (13);
1295 }
1296 }
1297 /* Return the default FDDI header length. */
1298 return (13);
1299 }
1300
1301 /*
1302 * Print the given Ethernet address
1303 */
1304 char *
1305 printether(struct ether_addr *p)
1306 {
1307 static char buf[256];
1308
1309 sprintf(buf, "%x:%x:%x:%x:%x:%x",
1310 p->ether_addr_octet[0],
1311 p->ether_addr_octet[1],
1312 p->ether_addr_octet[2],
1313 p->ether_addr_octet[3],
1314 p->ether_addr_octet[4],
1315 p->ether_addr_octet[5]);
1316
1317 return (buf);
1318 }
1319
1320 /*
1321 * Table of Ethernet Address Assignments
1322 * Some of the more popular entries
1323 * are at the beginning of the table
1324 * to reduce search time. Note that the
1325 * e-block's are stored in host byte-order.
1326 */
1327 struct block_type {
1328 int e_block;
1329 char *e_name;
1330 } ether_block [] = {
1331 0x080020, "Sun",
1332 0x0000C6, "HP",
1333 0x08002B, "DEC",
1334 0x00000F, "NeXT",
1335 0x00000C, "Cisco",
1336 0x080069, "Silicon Graphics",
1337 0x000069, "Silicon Graphics",
1338 0x0000A7, "Network Computing Devices (NCD X-terminal)",
1339 0x08005A, "IBM",
1340 0x0000AC, "Apollo",
1341 0x0180C2, "Standard MAC Group Address",
1342 /* end of popular entries */
1343 0x000002, "BBN",
1344 0x000010, "Sytek",
1345 0x000011, "Tektronix",
1346 0x000018, "Webster (?)",
1347 0x00001B, "Novell",
1348 0x00001D, "Cabletron",
1349 0x000020, "DIAB (Data Industrier AB)",
1350 0x000021, "SC&C",
1351 0x000022, "Visual Technology",
1352 0x000029, "IMC",
1353 0x00002A, "TRW",
1354 0x00003D, "AT&T",
1355 0x000049, "Apricot Ltd.",
1356 0x000055, "AT&T",
1357 0x00005A, "S & Koch",
1358 0x00005A, "Xerox 806 (unregistered)",
1359 0x00005E, "U.S. Department of Defense (IANA)",
1360 0x000065, "Network General",
1361 0x00006B, "MIPS",
1362 0x000077, "MIPS",
1363 0x000079, "NetWare (?)",
1364 0x00007A, "Ardent",
1365 0x00007B, "Research Machines",
1366 0x00007D, "Harris (3M) (old)",
1367 0x000080, "Imagen(?)",
1368 0x000081, "Synoptics",
1369 0x000084, "Aquila (?)",
1370 0x000086, "Gateway (?)",
1371 0x000089, "Cayman Systems Gatorbox",
1372 0x000093, "Proteon",
1373 0x000094, "Asante",
1374 0x000098, "Cross Com",
1375 0x00009F, "Ameristar Technology",
1376 0x0000A2, "Wellfleet",
1377 0x0000A3, "Network Application Technology",
1378 0x0000A4, "Acorn",
1379 0x0000A6, "Network General",
1380 0x0000A7, "Network Computing Devices (NCD X-terminal)",
1381 0x0000A9, "Network Systems",
1382 0x0000AA, "Xerox",
1383 0x0000B3, "CIMLinc",
1384 0x0000B5, "Datability Terminal Server",
1385 0x0000B7, "Dove Fastnet",
1386 0x0000BC, "Allen-Bradley",
1387 0x0000C0, "Western Digital",
1388 0x0000C8, "Altos",
1389 0x0000C9, "Emulex Terminal Server",
1390 0x0000D0, "Develcon Electronics, Ltd.",
1391 0x0000D1, "Adaptec Inc. Nodem product",
1392 0x0000D7, "Dartmouth College (NED Router)",
1393 0x0000DD, "Gould",
1394 0x0000DE, "Unigraph",
1395 0x0000E2, "Acer Counterpoint",
1396 0x0000E8, "Accton Technology Corporation",
1397 0x0000EE, "Network Designers Limited(?)",
1398 0x0000EF, "Alantec",
1399 0x0000F3, "Gandalf",
1400 0x0000FD, "High Level Hardware (Orion, UK)",
1401 0x000143, "IEEE 802",
1402 0x001700, "Kabel",
1403 0x004010, "Sonic",
1404 0x00608C, "3Com",
1405 0x00800F, "SMC",
1406 0x008019, "Dayna Communications Etherprint product",
1407 0x00802D, "Xylogics, Inc. Annex terminal servers",
1408 0x008035, "Technology Works",
1409 0x008087, "Okidata",
1410 0x00808C, "Frontier Software Development",
1411 0x0080C7, "Xircom Inc.",
1412 0x0080D0, "Computer Products International",
1413 0x0080D3, "Shiva Appletalk-Ethernet interface",
1414 0x0080D4, "Chase Limited",
1415 0x0080F1, "Opus",
1416 0x00AA00, "Intel",
1417 0x00B0D0, "Computer Products International",
1418 0x00DD00, "Ungermann-Bass",
1419 0x00DD01, "Ungermann-Bass",
1420 0x00EFE5, "IBM (3Com card)",
1421 0x020406, "BBN",
1422 0x026060, "3Com",
1423 0x026086, "Satelcom MegaPac (UK)",
1424 0x02E6D3, "Bus-Tech, Inc. (BTI)",
1425 0x080001, "Computer Vision",
1426 0x080002, "3Com (Formerly Bridge)",
1427 0x080003, "ACC (Advanced Computer Communications)",
1428 0x080005, "Symbolics",
1429 0x080007, "Apple",
1430 0x080008, "BBN",
1431 0x080009, "Hewlett-Packard",
1432 0x08000A, "Nestar Systems",
1433 0x08000B, "Unisys",
1434 0x08000D, "ICL",
1435 0x08000E, "NCR",
1436 0x080010, "AT&T",
1437 0x080011, "Tektronix, Inc.",
1438 0x080017, "NSC",
1439 0x08001A, "Data General",
1440 0x08001B, "Data General",
1441 0x08001E, "Apollo",
1442 0x080022, "NBI",
1443 0x080025, "CDC",
1444 0x080026, "Norsk Data (Nord)",
1445 0x080027, "PCS Computer Systems GmbH",
1446 0x080028, "TI Explorer",
1447 0x08002E, "Metaphor",
1448 0x08002F, "Prime Computer",
1449 0x080036, "Intergraph CAE stations",
1450 0x080037, "Fujitsu-Xerox",
1451 0x080038, "Bull",
1452 0x080039, "Spider Systems",
1453 0x08003B, "Torus Systems",
1454 0x08003E, "Motorola VME bus processor module",
1455 0x080041, "DCA Digital Comm. Assoc.",
1456 0x080046, "Sony",
1457 0x080047, "Sequent",
1458 0x080049, "Univation",
1459 0x08004C, "Encore",
1460 0x08004E, "BICC",
1461 0x080056, "Stanford University",
1462 0x080057, "Evans & Sutherland (?)",
1463 0x080067, "Comdesign",
1464 0x080068, "Ridge",
1465 0x08006A, "ATTst (?)",
1466 0x08006E, "Excelan",
1467 0x080075, "DDE (Danish Data Elektronik A/S)",
1468 0x080077, "TSL (now Retix)",
1469 0x08007C, "Vitalink TransLAN III",
1470 0x080080, "XIOS",
1471 0x080081, "Crosfield Electronics",
1472 0x080086, "Imagen/QMS",
1473 0x080087, "Xyplex terminal server",
1474 0x080089, "Kinetics AppleTalk-Ethernet interface",
1475 0x08008B, "Pyramid",
1476 0x08008D, "XyVision",
1477 0x080090, "Retix Inc Bridge",
1478 0x10005A, "IBM",
1479 0x1000D4, "DEC",
1480 0x400003, "NetWare",
1481 0x800010, "AT&T",
1482 0xAA0004, "DEC (DECNET)",
1483 0xC00000, "SMC",
1484 0, "",
1485 };
1486
1487 /*
1488 * The oui argument should be in host byte-order to conform with
1489 * the above array's values.
1490 */
1491 char *
1492 ether_ouiname(uint32_t oui)
1493 {
1494 uint_t i;
1495
1496 for (i = 0; ether_block[i].e_block != 0; i++)
1497 if (oui == ether_block[i].e_block)
1498 return (ether_block[i].e_name);
1499
1500 return (NULL);
1501 }
1502
1503 /*
1504 * Print the additional Ethernet address info
1505 */
1506 static char *
1507 print_etherinfo(struct ether_addr *eaddr)
1508 {
1509 uint_t addr = 0;
1510 char *p = (char *)&addr + 1;
1511 char *ename;
1512
1513 (void) memcpy(p, eaddr, 3);
1514
1515 if (memcmp(eaddr, &ether_broadcast, sizeof (struct ether_addr)) == 0)
1516 return ("(broadcast)");
1517
1518 addr = ntohl(addr); /* make it right for little-endians */
1519 ename = ether_ouiname(addr);
1520
1521 if (ename != NULL)
1522 return (ename);
1523 else
1524 return ((eaddr->ether_addr_octet[0] & 1) ? "(multicast)" : "");
1525 }
1526
1527 static uchar_t endianswap[] = {
1528 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
1529 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
1530 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
1531 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
1532 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
1533 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
1534 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
1535 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
1536 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
1537 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
1538 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
1539 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
1540 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
1541 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
1542 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
1543 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
1544 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
1545 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
1546 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
1547 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
1548 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
1549 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
1550 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
1551 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
1552 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
1553 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
1554 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
1555 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
1556 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
1557 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
1558 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
1559 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
1560 };
1561
1562 static void
1563 addr_copy_swap(struct ether_addr *pd, struct ether_addr *ps)
1564 {
1565 pd->ether_addr_octet[0] = endianswap[ps->ether_addr_octet[0]];
1566 pd->ether_addr_octet[1] = endianswap[ps->ether_addr_octet[1]];
1567 pd->ether_addr_octet[2] = endianswap[ps->ether_addr_octet[2]];
1568 pd->ether_addr_octet[3] = endianswap[ps->ether_addr_octet[3]];
1569 pd->ether_addr_octet[4] = endianswap[ps->ether_addr_octet[4]];
1570 pd->ether_addr_octet[5] = endianswap[ps->ether_addr_octet[5]];
1571 }
1572
1573 /* ARGSUSED */
1574 uint_t
1575 ib_header_len(char *hdr, size_t msgsize)
1576 {
1577 return (IPOIB_HDRSIZE);
1578 }
1579
1580 static uint_t
1581 interpret_ib(int flags, char *header, int elen, int origlen)
1582 {
1583 struct ipoib_header *hdr = (struct ipoib_header *)header;
1584 char *off;
1585 int len;
1586 unsigned short ethertype;
1587 int blen = MAX(origlen, 4096);
1588
1589 if (data != NULL && datalen != 0 && datalen < blen) {
1590 free(data);
1591 data = NULL;
1592 datalen = 0;
1593 }
1594 if (data == NULL) {
1595 data = malloc(blen);
1596 if (data == NULL)
1597 pr_err("Warning: malloc failure");
1598 datalen = blen;
1599 }
1600 if (origlen < IPOIB_HDRSIZE) {
1601 if (flags & F_SUM)
1602 (void) snprintf(get_sum_line(), MAXLINE,
1603 "RUNT (short packet - %d bytes)", origlen);
1604 if (flags & F_DTAIL)
1605 show_header("RUNT: ", "Short packet", origlen);
1606 return (elen);
1607 }
1608 if (elen < IPOIB_HDRSIZE)
1609 return (elen);
1610
1611 /*
1612 * It is not possible to understand just by looking
1613 * at the header whether this was a broad/multi cast
1614 * packet; thus dst_name is not updated.
1615 */
1616 ethertype = ntohs(hdr->ipoib_type);
1617 len = elen - IPOIB_HDRSIZE;
1618 off = (char *)(hdr + 1);
1619 (void) memcpy(data, off, len);
1620
1621 if (flags & F_SUM) {
1622 (void) snprintf(get_sum_line(), MAXLINE,
1623 "IPIB Type=%04X (%s), size = %d bytes",
1624 ethertype,
1625 print_ethertype(ethertype),
1626 origlen);
1627 }
1628
1629 if (flags & F_DTAIL) {
1630 show_header("IPIB: ", "IPIB Header", elen);
1631 show_space();
1632 (void) snprintf(get_line(0, 0), get_line_remain(),
1633 "Packet %d arrived at %d:%02d:%d.%02d",
1634 pi_frame, pi_time_hour, pi_time_min,
1635 pi_time_sec, pi_time_usec / 10000);
1636 (void) snprintf(get_line(0, 0), get_line_remain(),
1637 "Packet size = %d bytes", elen, elen);
1638 (void) snprintf(get_line(0, 2), get_line_remain(),
1639 "Ethertype = %04X (%s)", ethertype,
1640 print_ethertype(ethertype));
1641 show_space();
1642 }
1643
1644 /* Go to the next protocol layer */
1645 switch (ethertype) {
1646 case ETHERTYPE_IP:
1647 (void) interpret_ip(flags, (struct ip *)data, len);
1648 break;
1649 case ETHERTYPE_IPV6:
1650 (void) interpret_ipv6(flags, (ip6_t *)data, len);
1651 break;
1652 case ETHERTYPE_ARP:
1653 case ETHERTYPE_REVARP:
1654 interpret_arp(flags, (struct arphdr *)data, len);
1655 break;
1656 }
1657
1658 return (elen);
1659 }
1660
1661 /* ARGSUSED */
1662 uint_t
1663 ipnet_header_len(char *hdr, size_t msgsize)
1664 {
1665 return (sizeof (dl_ipnetinfo_t));
1666 }
1667
1668 #define MAX_UINT64_STR 22
1669 static uint_t
1670 interpret_ipnet(int flags, char *header, int elen, int origlen)
1671 {
1672 dl_ipnetinfo_t dl;
1673 size_t len = elen - sizeof (dl_ipnetinfo_t);
1674 char *off = (char *)header + sizeof (dl_ipnetinfo_t);
1675 int blen = MAX(origlen, 8252);
1676 char szone[MAX_UINT64_STR];
1677 char dzone[MAX_UINT64_STR];
1678
1679 (void) memcpy(&dl, header, sizeof (dl));
1680 if (data != NULL && datalen != 0 && datalen < blen) {
1681 free(data);
1682 data = NULL;
1683 datalen = 0;
1684 }
1685 if (data == NULL) {
1686 data = (char *)malloc(blen);
1687 if (!data)
1688 pr_err("Warning: malloc failure");
1689 datalen = blen;
1690 }
1691
1692 if (dl.dli_zsrc == ALL_ZONES)
1693 sprintf(szone, "Unknown");
1694 else
1695 sprintf(szone, "%lu", BE_32(dl.dli_zsrc));
1696
1697 if (dl.dli_zdst == ALL_ZONES)
1698 sprintf(dzone, "Unknown");
1699 else
1700 sprintf(dzone, "%lu", BE_32(dl.dli_zdst));
1701
1702 if (flags & F_SUM) {
1703 (void) snprintf(get_sum_line(), MAXLINE,
1704 "IPNET src zone %s dst zone %s", szone, dzone);
1705 }
1706
1707 if (flags & F_DTAIL) {
1708 show_header("IPNET: ", "IPNET Header", elen);
1709 show_space();
1710 (void) sprintf(get_line(0, 0),
1711 "Packet %d arrived at %d:%02d:%d.%05d",
1712 pi_frame,
1713 pi_time_hour, pi_time_min, pi_time_sec,
1714 pi_time_usec / 10);
1715 (void) sprintf(get_line(0, 0),
1716 "Packet size = %d bytes",
1717 elen);
1718 (void) snprintf(get_line(0, 0), get_line_remain(),
1719 "dli_version = %d", dl.dli_version);
1720 (void) snprintf(get_line(0, 0), get_line_remain(),
1721 "dli_family = %d", dl.dli_family);
1722 (void) snprintf(get_line(0, 2), get_line_remain(),
1723 "dli_zsrc = %s", szone);
1724 (void) snprintf(get_line(0, 2), get_line_remain(),
1725 "dli_zdst = %s", dzone);
1726 show_space();
1727 }
1728 memcpy(data, off, len);
1729
1730 switch (dl.dli_family) {
1731 case AF_INET:
1732 (void) interpret_ip(flags, (struct ip *)data, len);
1733 break;
1734 case AF_INET6:
1735 (void) interpret_ipv6(flags, (ip6_t *)data, len);
1736 break;
1737 default:
1738 break;
1739 }
1740
1741 return (0);
1742 }
1743
1744 uint_t
1745 ipv4_header_len(char *hdr, size_t msgsize)
1746 {
1747 return (msgsize < sizeof (ipha_t) ? 0 : IPH_HDR_LENGTH((ipha_t *)hdr));
1748 }
1749
1750 /*
1751 * The header length needs to include all potential extension headers, as the
1752 * caller expects to use this length as an offset to the inner network layer
1753 * header to be used as a filter offset. IPsec headers aren't passed up here,
1754 * and neither are fragmentation headers.
1755 */
1756 uint_t
1757 ipv6_header_len(char *hdr, size_t msgsize)
1758 {
1759 ip6_t *ip6hdr = (ip6_t *)hdr;
1760 ip6_hbh_t *exthdr;
1761 uint_t hdrlen = sizeof (ip6_t), exthdrlen;
1762 char *pptr;
1763 uint8_t nxt;
1764
1765 if (msgsize < sizeof (ip6_t))
1766 return (0);
1767
1768 nxt = ip6hdr->ip6_nxt;
1769 pptr = (char *)(ip6hdr + 1);
1770
1771 while (nxt != IPPROTO_ENCAP && nxt != IPPROTO_IPV6) {
1772 switch (nxt) {
1773 case IPPROTO_HOPOPTS:
1774 case IPPROTO_DSTOPTS:
1775 case IPPROTO_ROUTING:
1776 if (msgsize < hdrlen + sizeof (ip6_hbh_t))
1777 return (0);
1778 exthdr = (ip6_hbh_t *)pptr;
1779 exthdrlen = 8 + exthdr->ip6h_len * 8;
1780 hdrlen += exthdrlen;
1781 pptr += exthdrlen;
1782 nxt = exthdr->ip6h_nxt;
1783 break;
1784 default:
1785 /*
1786 * This is garbage, there's no way to know where the
1787 * inner IP header is.
1788 */
1789 return (0);
1790 }
1791 }
1792
1793 return (hdrlen);
1794 }
1795
1796 /* ARGSUSED */
1797 uint_t
1798 interpret_iptun(int flags, char *header, int elen, int origlen)
1799 {
1800 (void) interpret_ip(flags, (struct ip *)header, elen);
1801 return (elen);
1802 }
unleashed repo fork