1 /*
2 * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 2000
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 /* \summary: Ethernet printer */
23
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include "netdissect-stdinc.h"
29
30 #define ND_LONGJMP_FROM_TCHECK
31 #include "netdissect.h"
32 #include "extract.h"
33 #include "addrtoname.h"
34 #include "ethertype.h"
35
36 /*
37 * Structure of an Ethernet header.
38 */
39 struct ether_header {
40 nd_mac_addr ether_dhost;
41 nd_mac_addr ether_shost;
42 nd_uint16_t ether_length_type;
43 };
44
45 /*
46 * Length of an Ethernet header; note that some compilers may pad
47 * "struct ether_header" to a multiple of 4 bytes, for example, so
48 * "sizeof (struct ether_header)" may not give the right answer.
49 */
50 #define ETHER_HDRLEN 14
51
52 const struct tok ethertype_values[] = {
53 { ETHERTYPE_IP, "IPv4" },
54 { ETHERTYPE_MPLS, "MPLS unicast" },
55 { ETHERTYPE_MPLS_MULTI, "MPLS multicast" },
56 { ETHERTYPE_IPV6, "IPv6" },
57 { ETHERTYPE_8021Q, "802.1Q" },
58 { ETHERTYPE_8021Q9100, "802.1Q-9100" },
59 { ETHERTYPE_8021QinQ, "802.1Q-QinQ" },
60 { ETHERTYPE_8021Q9200, "802.1Q-9200" },
61 { ETHERTYPE_MACSEC, "802.1AE MACsec" },
62 { ETHERTYPE_VMAN, "VMAN" },
63 { ETHERTYPE_PUP, "PUP" },
64 { ETHERTYPE_ARP, "ARP"},
65 { ETHERTYPE_REVARP, "Reverse ARP"},
66 { ETHERTYPE_NS, "NS" },
67 { ETHERTYPE_SPRITE, "Sprite" },
68 { ETHERTYPE_TRAIL, "Trail" },
69 { ETHERTYPE_MOPDL, "MOP DL" },
70 { ETHERTYPE_MOPRC, "MOP RC" },
71 { ETHERTYPE_DN, "DN" },
72 { ETHERTYPE_LAT, "LAT" },
73 { ETHERTYPE_SCA, "SCA" },
74 { ETHERTYPE_TEB, "TEB" },
75 { ETHERTYPE_LANBRIDGE, "Lanbridge" },
76 { ETHERTYPE_DECDNS, "DEC DNS" },
77 { ETHERTYPE_DECDTS, "DEC DTS" },
78 { ETHERTYPE_VEXP, "VEXP" },
79 { ETHERTYPE_VPROD, "VPROD" },
80 { ETHERTYPE_ATALK, "Appletalk" },
81 { ETHERTYPE_AARP, "Appletalk ARP" },
82 { ETHERTYPE_IPX, "IPX" },
83 { ETHERTYPE_PPP, "PPP" },
84 { ETHERTYPE_MPCP, "MPCP" },
85 { ETHERTYPE_SLOW, "Slow Protocols" },
86 { ETHERTYPE_PPPOED, "PPPoE D" },
87 { ETHERTYPE_PPPOES, "PPPoE S" },
88 { ETHERTYPE_EAPOL, "EAPOL" },
89 { ETHERTYPE_RRCP, "RRCP" },
90 { ETHERTYPE_MS_NLB_HB, "MS NLB heartbeat" },
91 { ETHERTYPE_JUMBO, "Jumbo" },
92 { ETHERTYPE_NSH, "NSH" },
93 { ETHERTYPE_LOOPBACK, "Loopback" },
94 { ETHERTYPE_ISO, "OSI" },
95 { ETHERTYPE_GRE_ISO, "GRE-OSI" },
96 { ETHERTYPE_CFM_OLD, "CFM (old)" },
97 { ETHERTYPE_CFM, "CFM" },
98 { ETHERTYPE_IEEE1905_1, "IEEE1905.1" },
99 { ETHERTYPE_LLDP, "LLDP" },
100 { ETHERTYPE_TIPC, "TIPC"},
101 { ETHERTYPE_GEONET_OLD, "GeoNet (old)"},
102 { ETHERTYPE_GEONET, "GeoNet"},
103 { ETHERTYPE_CALM_FAST, "CALM FAST"},
104 { ETHERTYPE_AOE, "AoE" },
105 { ETHERTYPE_PTP, "PTP" },
106 { ETHERTYPE_ARISTA, "Arista Vendor Specific Protocol" },
107 { 0, NULL}
108 };
109
110 static void
ether_addresses_print(netdissect_options * ndo,const u_char * src,const u_char * dst)111 ether_addresses_print(netdissect_options *ndo, const u_char *src,
112 const u_char *dst)
113 {
114 ND_PRINT("%s > %s, ",
115 GET_ETHERADDR_STRING(src), GET_ETHERADDR_STRING(dst));
116 }
117
118 static void
ether_type_print(netdissect_options * ndo,uint16_t type)119 ether_type_print(netdissect_options *ndo, uint16_t type)
120 {
121 if (!ndo->ndo_qflag)
122 ND_PRINT("ethertype %s (0x%04x)",
123 tok2str(ethertype_values, "Unknown", type), type);
124 else
125 ND_PRINT("%s",
126 tok2str(ethertype_values, "Unknown Ethertype (0x%04x)", type));
127 }
128
129 /*
130 * Common code for printing Ethernet frames.
131 *
132 * It can handle Ethernet headers with extra tag information inserted
133 * after the destination and source addresses, as is inserted by some
134 * switch chips, and extra encapsulation header information before
135 * printing Ethernet header information (such as a LANE ID for ATM LANE).
136 */
137 static u_int
ether_common_print(netdissect_options * ndo,const u_char * p,u_int length,u_int caplen,void (* print_switch_tag)(netdissect_options * ndo,const u_char *),u_int switch_tag_len,void (* print_encap_header)(netdissect_options * ndo,const u_char *),const u_char * encap_header_arg)138 ether_common_print(netdissect_options *ndo, const u_char *p, u_int length,
139 u_int caplen,
140 void (*print_switch_tag)(netdissect_options *ndo, const u_char *),
141 u_int switch_tag_len,
142 void (*print_encap_header)(netdissect_options *ndo, const u_char *),
143 const u_char *encap_header_arg)
144 {
145 const struct ether_header *ehp;
146 u_int orig_length;
147 u_int hdrlen;
148 u_short length_type;
149 int printed_length;
150 int llc_hdrlen;
151 struct lladdr_info src, dst;
152
153 if (caplen < ETHER_HDRLEN + switch_tag_len) {
154 nd_print_trunc(ndo);
155 return caplen;
156 }
157 if (length < ETHER_HDRLEN + switch_tag_len) {
158 nd_print_trunc(ndo);
159 return length;
160 }
161
162 if (print_encap_header != NULL)
163 (*print_encap_header)(ndo, encap_header_arg);
164
165 orig_length = length;
166
167 /*
168 * Get the source and destination addresses, skip past them,
169 * and print them if we're printing the link-layer header.
170 */
171 ehp = (const struct ether_header *)p;
172 src.addr = ehp->ether_shost;
173 src.addr_string = etheraddr_string;
174 dst.addr = ehp->ether_dhost;
175 dst.addr_string = etheraddr_string;
176
177 length -= 2*MAC_ADDR_LEN;
178 caplen -= 2*MAC_ADDR_LEN;
179 p += 2*MAC_ADDR_LEN;
180 hdrlen = 2*MAC_ADDR_LEN;
181
182 if (ndo->ndo_eflag)
183 ether_addresses_print(ndo, src.addr, dst.addr);
184
185 /*
186 * Print the switch tag, if we have one, and skip past it.
187 */
188 if (print_switch_tag != NULL)
189 (*print_switch_tag)(ndo, p);
190
191 length -= switch_tag_len;
192 caplen -= switch_tag_len;
193 p += switch_tag_len;
194 hdrlen += switch_tag_len;
195
196 /*
197 * Get the length/type field, skip past it, and print it
198 * if we're printing the link-layer header.
199 */
200 recurse:
201 length_type = GET_BE_U_2(p);
202
203 length -= 2;
204 caplen -= 2;
205 p += 2;
206 hdrlen += 2;
207
208 /*
209 * Process 802.1AE MACsec headers.
210 */
211 printed_length = 0;
212 if (length_type == ETHERTYPE_MACSEC) {
213 /*
214 * MACsec, aka IEEE 802.1AE-2006
215 * Print the header, and try to print the payload if it's not encrypted
216 */
217 if (ndo->ndo_eflag) {
218 ether_type_print(ndo, length_type);
219 ND_PRINT(", length %u: ", orig_length);
220 printed_length = 1;
221 }
222
223 int ret = macsec_print(ndo, &p, &length, &caplen, &hdrlen,
224 &src, &dst);
225
226 if (ret == 0) {
227 /* Payload is encrypted; print it as raw data. */
228 if (!ndo->ndo_suppress_default_print)
229 ND_DEFAULTPRINT(p, caplen);
230 return hdrlen;
231 } else if (ret > 0) {
232 /* Problem printing the header; just quit. */
233 return ret;
234 } else {
235 /*
236 * Keep processing type/length fields.
237 */
238 length_type = GET_BE_U_2(p);
239
240 length -= 2;
241 caplen -= 2;
242 p += 2;
243 hdrlen += 2;
244 }
245 }
246
247 /*
248 * Process VLAN tag types.
249 */
250 while (length_type == ETHERTYPE_8021Q ||
251 length_type == ETHERTYPE_8021Q9100 ||
252 length_type == ETHERTYPE_8021Q9200 ||
253 length_type == ETHERTYPE_8021QinQ) {
254 /*
255 * It has a VLAN tag.
256 * Print VLAN information, and then go back and process
257 * the enclosed type field.
258 */
259 if (caplen < 4) {
260 ndo->ndo_protocol = "vlan";
261 nd_print_trunc(ndo);
262 return hdrlen + caplen;
263 }
264 if (length < 4) {
265 ndo->ndo_protocol = "vlan";
266 nd_print_trunc(ndo);
267 return hdrlen + length;
268 }
269 if (ndo->ndo_eflag) {
270 uint16_t tag = GET_BE_U_2(p);
271
272 ether_type_print(ndo, length_type);
273 if (!printed_length) {
274 ND_PRINT(", length %u: ", orig_length);
275 printed_length = 1;
276 } else
277 ND_PRINT(", ");
278 ND_PRINT("%s, ", ieee8021q_tci_string(tag));
279 }
280
281 length_type = GET_BE_U_2(p + 2);
282 p += 4;
283 length -= 4;
284 caplen -= 4;
285 hdrlen += 4;
286 }
287
288 /*
289 * We now have the final length/type field.
290 */
291 if (length_type <= MAX_ETHERNET_LENGTH_VAL) {
292 /*
293 * It's a length field, containing the length of the
294 * remaining payload; use it as such, as long as
295 * it's not too large (bigger than the actual payload).
296 */
297 if (length_type < length) {
298 length = length_type;
299 if (caplen > length)
300 caplen = length;
301 }
302
303 /*
304 * Cut off the snapshot length to the end of the
305 * payload.
306 */
307 nd_push_snapend(ndo, p + length);
308
309 if (ndo->ndo_eflag) {
310 ND_PRINT("802.3");
311 if (!printed_length)
312 ND_PRINT(", length %u: ", length);
313 }
314
315 /*
316 * An LLC header follows the length. Print that and
317 * higher layers.
318 */
319 llc_hdrlen = llc_print(ndo, p, length, caplen, &src, &dst);
320 if (llc_hdrlen < 0) {
321 /* packet type not known, print raw packet */
322 if (!ndo->ndo_suppress_default_print)
323 ND_DEFAULTPRINT(p, caplen);
324 llc_hdrlen = -llc_hdrlen;
325 }
326 hdrlen += llc_hdrlen;
327 nd_pop_packet_info(ndo);
328 } else if (length_type == ETHERTYPE_JUMBO) {
329 /*
330 * It's a type field, with the type for Alteon jumbo frames.
331 * See
332 *
333 * https://tools.ietf.org/html/draft-ietf-isis-ext-eth-01
334 *
335 * which indicates that, following the type field,
336 * there's an LLC header and payload.
337 */
338 /* Try to print the LLC-layer header & higher layers */
339 llc_hdrlen = llc_print(ndo, p, length, caplen, &src, &dst);
340 if (llc_hdrlen < 0) {
341 /* packet type not known, print raw packet */
342 if (!ndo->ndo_suppress_default_print)
343 ND_DEFAULTPRINT(p, caplen);
344 llc_hdrlen = -llc_hdrlen;
345 }
346 hdrlen += llc_hdrlen;
347 } else if (length_type == ETHERTYPE_ARISTA) {
348 if (caplen < 2) {
349 ND_PRINT("[|arista]");
350 return hdrlen + caplen;
351 }
352 if (length < 2) {
353 ND_PRINT("[|arista]");
354 return hdrlen + length;
355 }
356 ether_type_print(ndo, length_type);
357 ND_PRINT(", length %u: ", orig_length);
358 int bytesConsumed = arista_ethertype_print(ndo, p, length);
359 if (bytesConsumed > 0) {
360 p += bytesConsumed;
361 length -= bytesConsumed;
362 caplen -= bytesConsumed;
363 hdrlen += bytesConsumed;
364 goto recurse;
365 } else {
366 /* subtype/version not known, print raw packet */
367 if (!ndo->ndo_eflag && length_type > MAX_ETHERNET_LENGTH_VAL) {
368 ether_addresses_print(ndo, src.addr, dst.addr);
369 ether_type_print(ndo, length_type);
370 ND_PRINT(", length %u: ", orig_length);
371 }
372 if (!ndo->ndo_suppress_default_print)
373 ND_DEFAULTPRINT(p, caplen);
374 }
375 } else {
376 /*
377 * It's a type field with some other value.
378 */
379 if (ndo->ndo_eflag) {
380 ether_type_print(ndo, length_type);
381 if (!printed_length)
382 ND_PRINT(", length %u: ", orig_length);
383 else
384 ND_PRINT(", ");
385 }
386 if (ethertype_print(ndo, length_type, p, length, caplen, &src, &dst) == 0) {
387 /* type not known, print raw packet */
388 if (!ndo->ndo_eflag) {
389 /*
390 * We didn't print the full link-layer
391 * header, as -e wasn't specified, so
392 * print only the source and destination
393 * MAC addresses and the final Ethernet
394 * type.
395 */
396 ether_addresses_print(ndo, src.addr, dst.addr);
397 ether_type_print(ndo, length_type);
398 ND_PRINT(", length %u: ", orig_length);
399 }
400
401 if (!ndo->ndo_suppress_default_print)
402 ND_DEFAULTPRINT(p, caplen);
403 }
404 }
405 return hdrlen;
406 }
407
408 /*
409 * Print an Ethernet frame while specyfing a non-standard Ethernet header
410 * length.
411 * This might be encapsulated within another frame; we might be passed
412 * a pointer to a function that can print header information for that
413 * frame's protocol, and an argument to pass to that function.
414 *
415 * FIXME: caplen can and should be derived from ndo->ndo_snapend and p.
416 */
417 u_int
ether_switch_tag_print(netdissect_options * ndo,const u_char * p,u_int length,u_int caplen,void (* print_switch_tag)(netdissect_options *,const u_char *),u_int switch_tag_len)418 ether_switch_tag_print(netdissect_options *ndo, const u_char *p, u_int length,
419 u_int caplen,
420 void (*print_switch_tag)(netdissect_options *, const u_char *),
421 u_int switch_tag_len)
422 {
423 return ether_common_print(ndo, p, length, caplen, print_switch_tag,
424 switch_tag_len, NULL, NULL);
425 }
426
427 /*
428 * Print an Ethernet frame.
429 * This might be encapsulated within another frame; we might be passed
430 * a pointer to a function that can print header information for that
431 * frame's protocol, and an argument to pass to that function.
432 *
433 * FIXME: caplen can and should be derived from ndo->ndo_snapend and p.
434 */
435 u_int
ether_print(netdissect_options * ndo,const u_char * p,u_int length,u_int caplen,void (* print_encap_header)(netdissect_options * ndo,const u_char *),const u_char * encap_header_arg)436 ether_print(netdissect_options *ndo,
437 const u_char *p, u_int length, u_int caplen,
438 void (*print_encap_header)(netdissect_options *ndo, const u_char *),
439 const u_char *encap_header_arg)
440 {
441 ndo->ndo_protocol = "ether";
442 return ether_common_print(ndo, p, length, caplen, NULL, 0,
443 print_encap_header, encap_header_arg);
444 }
445
446 /*
447 * This is the top level routine of the printer. 'p' points
448 * to the ether header of the packet, 'h->len' is the length
449 * of the packet off the wire, and 'h->caplen' is the number
450 * of bytes actually captured.
451 */
452 void
ether_if_print(netdissect_options * ndo,const struct pcap_pkthdr * h,const u_char * p)453 ether_if_print(netdissect_options *ndo, const struct pcap_pkthdr *h,
454 const u_char *p)
455 {
456 ndo->ndo_protocol = "ether";
457 ndo->ndo_ll_hdr_len +=
458 ether_print(ndo, p, h->len, h->caplen, NULL, NULL);
459 }
460
461 /*
462 * This is the top level routine of the printer. 'p' points
463 * to the ether header of the packet, 'h->len' is the length
464 * of the packet off the wire, and 'h->caplen' is the number
465 * of bytes actually captured.
466 *
467 * This is for DLT_NETANALYZER, which has a 4-byte pseudo-header
468 * before the Ethernet header.
469 */
470 void
netanalyzer_if_print(netdissect_options * ndo,const struct pcap_pkthdr * h,const u_char * p)471 netanalyzer_if_print(netdissect_options *ndo, const struct pcap_pkthdr *h,
472 const u_char *p)
473 {
474 /*
475 * Fail if we don't have enough data for the Hilscher pseudo-header.
476 */
477 ndo->ndo_protocol = "netanalyzer";
478 ND_TCHECK_LEN(p, 4);
479
480 /* Skip the pseudo-header. */
481 ndo->ndo_ll_hdr_len += 4;
482 ndo->ndo_ll_hdr_len +=
483 ether_print(ndo, p + 4, h->len - 4, h->caplen - 4, NULL, NULL);
484 }
485
486 /*
487 * This is the top level routine of the printer. 'p' points
488 * to the ether header of the packet, 'h->len' is the length
489 * of the packet off the wire, and 'h->caplen' is the number
490 * of bytes actually captured.
491 *
492 * This is for DLT_NETANALYZER_TRANSPARENT, which has a 4-byte
493 * pseudo-header, a 7-byte Ethernet preamble, and a 1-byte Ethernet SOF
494 * before the Ethernet header.
495 */
496 void
netanalyzer_transparent_if_print(netdissect_options * ndo,const struct pcap_pkthdr * h,const u_char * p)497 netanalyzer_transparent_if_print(netdissect_options *ndo,
498 const struct pcap_pkthdr *h,
499 const u_char *p)
500 {
501 /*
502 * Fail if we don't have enough data for the Hilscher pseudo-header,
503 * preamble, and SOF.
504 */
505 ndo->ndo_protocol = "netanalyzer_transparent";
506 ND_TCHECK_LEN(p, 12);
507
508 /* Skip the pseudo-header, preamble, and SOF. */
509 ndo->ndo_ll_hdr_len += 12;
510 ndo->ndo_ll_hdr_len +=
511 ether_print(ndo, p + 12, h->len - 12, h->caplen - 12, NULL, NULL);
512 }
513
514 /*
515 * Prints the packet payload, given an Ethernet type code for the payload's
516 * protocol.
517 *
518 * Returns non-zero if it can do so, zero if the ethertype is unknown.
519 */
520
521 int
ethertype_print(netdissect_options * ndo,u_short ether_type,const u_char * p,u_int length,u_int caplen,const struct lladdr_info * src,const struct lladdr_info * dst)522 ethertype_print(netdissect_options *ndo,
523 u_short ether_type, const u_char *p,
524 u_int length, u_int caplen,
525 const struct lladdr_info *src, const struct lladdr_info *dst)
526 {
527 switch (ether_type) {
528
529 case ETHERTYPE_IP:
530 ip_print(ndo, p, length);
531 return (1);
532
533 case ETHERTYPE_IPV6:
534 ip6_print(ndo, p, length);
535 return (1);
536
537 case ETHERTYPE_ARP:
538 case ETHERTYPE_REVARP:
539 arp_print(ndo, p, length, caplen);
540 return (1);
541
542 case ETHERTYPE_DN:
543 decnet_print(ndo, p, length, caplen);
544 return (1);
545
546 case ETHERTYPE_ATALK:
547 if (ndo->ndo_vflag)
548 ND_PRINT("et1 ");
549 atalk_print(ndo, p, length);
550 return (1);
551
552 case ETHERTYPE_AARP:
553 aarp_print(ndo, p, length);
554 return (1);
555
556 case ETHERTYPE_IPX:
557 ND_PRINT("(NOV-ETHII) ");
558 ipx_print(ndo, p, length);
559 return (1);
560
561 case ETHERTYPE_ISO:
562 if (length == 0 || caplen == 0) {
563 ndo->ndo_protocol = "isoclns";
564 nd_print_trunc(ndo);
565 return (1);
566 }
567 /* At least one byte is required */
568 /* FIXME: Reference for this byte? */
569 ND_TCHECK_LEN(p, 1);
570 isoclns_print(ndo, p + 1, length - 1);
571 return(1);
572
573 case ETHERTYPE_PPPOED:
574 case ETHERTYPE_PPPOES:
575 case ETHERTYPE_PPPOED2:
576 case ETHERTYPE_PPPOES2:
577 pppoe_print(ndo, p, length);
578 return (1);
579
580 case ETHERTYPE_EAPOL:
581 eapol_print(ndo, p);
582 return (1);
583
584 case ETHERTYPE_RRCP:
585 rrcp_print(ndo, p, length, src, dst);
586 return (1);
587
588 case ETHERTYPE_PPP:
589 if (length) {
590 ND_PRINT(": ");
591 ppp_print(ndo, p, length);
592 }
593 return (1);
594
595 case ETHERTYPE_MPCP:
596 mpcp_print(ndo, p, length);
597 return (1);
598
599 case ETHERTYPE_SLOW:
600 slow_print(ndo, p, length);
601 return (1);
602
603 case ETHERTYPE_CFM:
604 case ETHERTYPE_CFM_OLD:
605 cfm_print(ndo, p, length);
606 return (1);
607
608 case ETHERTYPE_LLDP:
609 lldp_print(ndo, p, length);
610 return (1);
611
612 case ETHERTYPE_NSH:
613 nsh_print(ndo, p, length);
614 return (1);
615
616 case ETHERTYPE_LOOPBACK:
617 loopback_print(ndo, p, length);
618 return (1);
619
620 case ETHERTYPE_MPLS:
621 case ETHERTYPE_MPLS_MULTI:
622 mpls_print(ndo, p, length);
623 return (1);
624
625 case ETHERTYPE_TIPC:
626 tipc_print(ndo, p, length, caplen);
627 return (1);
628
629 case ETHERTYPE_MS_NLB_HB:
630 msnlb_print(ndo, p);
631 return (1);
632
633 case ETHERTYPE_GEONET_OLD:
634 case ETHERTYPE_GEONET:
635 geonet_print(ndo, p, length, src);
636 return (1);
637
638 case ETHERTYPE_CALM_FAST:
639 calm_fast_print(ndo, p, length, src);
640 return (1);
641
642 case ETHERTYPE_AOE:
643 aoe_print(ndo, p, length);
644 return (1);
645
646 case ETHERTYPE_PTP:
647 ptp_print(ndo, p, length);
648 return (1);
649
650 case ETHERTYPE_LAT:
651 case ETHERTYPE_SCA:
652 case ETHERTYPE_MOPRC:
653 case ETHERTYPE_MOPDL:
654 case ETHERTYPE_IEEE1905_1:
655 /* default_print for now */
656 default:
657 return (0);
658 }
659 }
660