The Tcpdump Group git mirrors - tcpdump/blobdiff

* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF

* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

*/

* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF

* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

*/

-#ifndef lint

-static const char rcsid[] _U_ =

- "@(#) $Header: /tcpdump/master/tcpdump/print-ether.c,v 1.99 2005-07-10 14:41:34 hannes Exp $ (LBL)";

-#endif

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

-#include <tcpdump-stdinc.h>

-

-#include <stdio.h>

-#include <pcap.h>

+#include <netdissect-stdinc.h>

-#include "interface.h"

+#include "netdissect.h"

+#include "extract.h"

#include "addrtoname.h"

#include "ethertype.h"

#include "addrtoname.h"

#include "ethertype.h"

-

#include "ether.h"

-const struct tok ethertype_values[] = {

+const struct tok ethertype_values[] = {

{ ETHERTYPE_IP, "IPv4" },

{ ETHERTYPE_MPLS, "MPLS unicast" },

{ ETHERTYPE_MPLS_MULTI, "MPLS multicast" },

{ ETHERTYPE_IPV6, "IPv6" },

{ ETHERTYPE_8021Q, "802.1Q" },

{ ETHERTYPE_IP, "IPv4" },

{ ETHERTYPE_MPLS, "MPLS unicast" },

{ ETHERTYPE_MPLS_MULTI, "MPLS multicast" },

{ ETHERTYPE_IPV6, "IPv6" },

{ ETHERTYPE_8021Q, "802.1Q" },

+ { ETHERTYPE_8021Q9100, "802.1Q-9100" },

+ { ETHERTYPE_8021QinQ, "802.1Q-QinQ" },

+ { ETHERTYPE_8021Q9200, "802.1Q-9200" },

{ ETHERTYPE_VMAN, "VMAN" },

{ ETHERTYPE_PUP, "PUP" },

{ ETHERTYPE_ARP, "ARP"},

{ ETHERTYPE_VMAN, "VMAN" },

{ ETHERTYPE_PUP, "PUP" },

{ ETHERTYPE_ARP, "ARP"},

- { ETHERTYPE_REVARP , "Reverse ARP"},

+ { ETHERTYPE_REVARP, "Reverse ARP"},

{ ETHERTYPE_NS, "NS" },

{ ETHERTYPE_SPRITE, "Sprite" },

{ ETHERTYPE_TRAIL, "Trail" },

{ ETHERTYPE_NS, "NS" },

{ ETHERTYPE_SPRITE, "Sprite" },

{ ETHERTYPE_TRAIL, "Trail" },

{ ETHERTYPE_DN, "DN" },

{ ETHERTYPE_LAT, "LAT" },

{ ETHERTYPE_SCA, "SCA" },

{ ETHERTYPE_DN, "DN" },

{ ETHERTYPE_LAT, "LAT" },

{ ETHERTYPE_SCA, "SCA" },

+ { ETHERTYPE_TEB, "TEB" },

{ ETHERTYPE_LANBRIDGE, "Lanbridge" },

{ ETHERTYPE_DECDNS, "DEC DNS" },

{ ETHERTYPE_DECDTS, "DEC DTS" },

{ ETHERTYPE_LANBRIDGE, "Lanbridge" },

{ ETHERTYPE_DECDNS, "DEC DNS" },

{ ETHERTYPE_DECDTS, "DEC DTS" },

{ ETHERTYPE_AARP, "Appletalk ARP" },

{ ETHERTYPE_IPX, "IPX" },

{ ETHERTYPE_PPP, "PPP" },

{ ETHERTYPE_AARP, "Appletalk ARP" },

{ ETHERTYPE_IPX, "IPX" },

{ ETHERTYPE_PPP, "PPP" },

+ { ETHERTYPE_MPCP, "MPCP" },

{ ETHERTYPE_SLOW, "Slow Protocols" },

{ ETHERTYPE_PPPOED, "PPPoE D" },

{ ETHERTYPE_PPPOES, "PPPoE S" },

{ ETHERTYPE_EAPOL, "EAPOL" },

{ ETHERTYPE_SLOW, "Slow Protocols" },

{ ETHERTYPE_PPPOED, "PPPoE D" },

{ ETHERTYPE_PPPOES, "PPPoE S" },

{ ETHERTYPE_EAPOL, "EAPOL" },

+ { ETHERTYPE_RRCP, "RRCP" },

+ { ETHERTYPE_MS_NLB_HB, "MS NLB heartbeat" },

{ ETHERTYPE_JUMBO, "Jumbo" },

{ ETHERTYPE_LOOPBACK, "Loopback" },

{ ETHERTYPE_ISO, "OSI" },

{ ETHERTYPE_GRE_ISO, "GRE-OSI" },

{ ETHERTYPE_JUMBO, "Jumbo" },

{ ETHERTYPE_LOOPBACK, "Loopback" },

{ ETHERTYPE_ISO, "OSI" },

{ ETHERTYPE_GRE_ISO, "GRE-OSI" },

+ { ETHERTYPE_CFM_OLD, "CFM (old)" },

+ { ETHERTYPE_CFM, "CFM" },

+ { ETHERTYPE_IEEE1905_1, "IEEE1905.1" },

+ { ETHERTYPE_LLDP, "LLDP" },

+ { ETHERTYPE_TIPC, "TIPC"},

+ { ETHERTYPE_GEONET_OLD, "GeoNet (old)"},

+ { ETHERTYPE_GEONET, "GeoNet"},

+ { ETHERTYPE_CALM_FAST, "CALM FAST"},

+ { ETHERTYPE_AOE, "AoE" },

+ { ETHERTYPE_MEDSA, "MEDSA" },

{ 0, NULL}

};

static inline void

{ 0, NULL}

};

static inline void

-ether_hdr_print(register const u_char *bp, u_int length)

+ether_hdr_print(netdissect_options *ndo,

+ const u_char *bp, u_int length)

{

register const struct ether_header *ep;

{

register const struct ether_header *ep;

+ uint16_t ether_type;

+

ep = (const struct ether_header *)bp;

- (void)printf("%s > %s",

- etheraddr_string(ESRC(ep)),

- etheraddr_string(EDST(ep)));

-

- if (!qflag) {

- if (ntohs(ep->ether_type) <= ETHERMTU)

- (void)printf(", 802.3");

- else

- (void)printf(", ethertype %s (0x%04x)",

- tok2str(ethertype_values,"Unknown", ntohs(ep->ether_type)),

- ntohs(ep->ether_type));

+ ND_PRINT((ndo, "%s > %s",

+ etheraddr_string(ndo, ESRC(ep)),

+ etheraddr_string(ndo, EDST(ep))));

+

+ ether_type = EXTRACT_16BITS(&ep->ether_type);

+ if (!ndo->ndo_qflag) {

+ if (ether_type <= ETHERMTU)

+ ND_PRINT((ndo, ", 802.3"));

+ else

+ ND_PRINT((ndo, ", ethertype %s (0x%04x)",

+ tok2str(ethertype_values,"Unknown", ether_type),

+ ether_type));

} else {

- if (ntohs(ep->ether_type) <= ETHERMTU)

- (void)printf(", 802.3");

- else

- (void)printf(", %s", tok2str(ethertype_values,"Unknown Ethertype (0x%04x)", ntohs(ep->ether_type)));

+ if (ether_type <= ETHERMTU)

+ ND_PRINT((ndo, ", 802.3"));

+ else

+ ND_PRINT((ndo, ", %s", tok2str(ethertype_values,"Unknown Ethertype (0x%04x)", ether_type)));

}

- (void)printf(", length %u: ", length);

+ ND_PRINT((ndo, ", length %u: ", length));

}

-void

-ether_print(const u_char *p, u_int length, u_int caplen)

+/*

+ * Print an Ethernet frame.

+ * This might be encapsulated within another frame; we might be passed

+ * a pointer to a function that can print header information for that

+ * frame's protocol, and an argument to pass to that function.

+ */

+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)

{

- struct ether_header *ep;

+ const struct ether_header *ep;

+ u_int orig_length;

u_short ether_type;

- u_short extracted_ether_type;

+ u_int hdrlen;

+ int llc_hdrlen;

if (caplen < ETHER_HDRLEN) {

- printf("[|ether]");

- return;

+ ND_PRINT((ndo, "[|ether]"));

+ return (caplen);

+ }

+ if (length < ETHER_HDRLEN) {

+ ND_PRINT((ndo, "[|ether]"));

+ return (length);

}

- if (eflag)

- ether_hdr_print(p, length);

+ if (ndo->ndo_eflag) {

+ if (print_encap_header != NULL)

+ (*print_encap_header)(ndo, encap_header_arg);

+ ether_hdr_print(ndo, p, length);

+ }

+ orig_length = length;

length -= ETHER_HDRLEN;

caplen -= ETHER_HDRLEN;

length -= ETHER_HDRLEN;

caplen -= ETHER_HDRLEN;

- ep = (struct ether_header *)p;

+ ep = (const struct ether_header *)p;

p += ETHER_HDRLEN;

+ hdrlen = ETHER_HDRLEN;

- ether_type = ntohs(ep->ether_type);

+ ether_type = EXTRACT_16BITS(&ep->ether_type);

+recurse:

/*

* Is it (gag) an 802.3 encapsulation?

*/

/*

* Is it (gag) an 802.3 encapsulation?

*/

- extracted_ether_type = 0;

if (ether_type <= ETHERMTU) {

/* Try to print the LLC-layer header & higher layers */

if (ether_type <= ETHERMTU) {

/* Try to print the LLC-layer header & higher layers */

- if (llc_print(p, length, caplen, ESRC(ep), EDST(ep),

- &extracted_ether_type) == 0) {

- /* ether_type not known, print raw packet */

- if (!eflag)

- ether_hdr_print((u_char *)ep, length + ETHER_HDRLEN);

+ llc_hdrlen = llc_print(ndo, p, length, caplen, ESRC(ep), EDST(ep));

+ if (llc_hdrlen < 0) {

+ /* packet type not known, print raw packet */

+ if (!ndo->ndo_suppress_default_print)

+ ND_DEFAULTPRINT(p, caplen);

+ llc_hdrlen = -llc_hdrlen;

+ }

+ hdrlen += llc_hdrlen;

+ } else if (ether_type == ETHERTYPE_8021Q ||

+ ether_type == ETHERTYPE_8021Q9100 ||

+ ether_type == ETHERTYPE_8021Q9200 ||

+ ether_type == ETHERTYPE_8021QinQ) {

+ /*

+ * Print VLAN information, and then go back and process

+ * the enclosed type field.

+ */

+ if (caplen < 4) {

+ ND_PRINT((ndo, "[|vlan]"));

+ return (hdrlen + caplen);

+ }

+ if (length < 4) {

+ ND_PRINT((ndo, "[|vlan]"));

+ return (hdrlen + length);

+ }

+ if (ndo->ndo_eflag) {

+ uint16_t tag = EXTRACT_16BITS(p);

- if (!suppress_default_print)

- default_print(p, caplen);

+ ND_PRINT((ndo, "%s, ", ieee8021q_tci_string(tag)));

}

- } else if (ether_encap_print(ether_type, p, length, caplen,

- &extracted_ether_type) == 0) {

- /* ether_type not known, print raw packet */

- if (!eflag)

- ether_hdr_print((u_char *)ep, length + ETHER_HDRLEN);

-

- if (!suppress_default_print)

- default_print(p, caplen);

- }

+

+ ether_type = EXTRACT_16BITS(p + 2);

+ if (ndo->ndo_eflag && ether_type > ETHERMTU)

+ ND_PRINT((ndo, "ethertype %s, ", tok2str(ethertype_values,"0x%04x", ether_type)));

+ p += 4;

+ length -= 4;

+ caplen -= 4;

+ hdrlen += 4;

+ goto recurse;

+ } else if (ether_type == ETHERTYPE_JUMBO) {

+ /*

+ * Alteon jumbo frames.

+ * See

+ *

+ * http://tools.ietf.org/html/draft-ietf-isis-ext-eth-01

+ *

+ * which indicates that, following the type field,

+ * there's an LLC header and payload.

+ */

+ /* Try to print the LLC-layer header & higher layers */

+ llc_hdrlen = llc_print(ndo, p, length, caplen, ESRC(ep), EDST(ep));

+ if (llc_hdrlen < 0) {

+ /* packet type not known, print raw packet */

+ if (!ndo->ndo_suppress_default_print)

+ ND_DEFAULTPRINT(p, caplen);

+ llc_hdrlen = -llc_hdrlen;

+ }

+ hdrlen += llc_hdrlen;

+ } else {

+ if (ethertype_print(ndo, ether_type, p, length, caplen) == 0) {

+ /* ether_type not known, print raw packet */

+ if (!ndo->ndo_eflag) {

+ if (print_encap_header != NULL)

+ (*print_encap_header)(ndo, encap_header_arg);

+ ether_hdr_print(ndo, (const u_char *)ep, orig_length);

+ }

+

+ if (!ndo->ndo_suppress_default_print)

+ ND_DEFAULTPRINT(p, caplen);

+ }

+ return (hdrlen);

+}

+

+/*

+ * This is the top level routine of the printer. 'p' points

+ * to the ether header of the packet, 'h->ts' is the timestamp,

+ * 'h->len' is the length of the packet off the wire, and 'h->caplen'

+ * is the number of bytes actually captured.

+ */

+u_int

+ether_if_print(netdissect_options *ndo, const struct pcap_pkthdr *h,

+ const u_char *p)

+{

+ return (ether_print(ndo, p, h->len, h->caplen, NULL, NULL));

}

/*

}

/*

* to the ether header of the packet, 'h->ts' is the timestamp,

* 'h->len' is the length of the packet off the wire, and 'h->caplen'

* is the number of bytes actually captured.

* to the ether header of the packet, 'h->ts' is the timestamp,

* 'h->len' is the length of the packet off the wire, and 'h->caplen'

* is the number of bytes actually captured.

+ *

+ * This is for DLT_NETANALYZER, which has a 4-byte pseudo-header

+ * before the Ethernet header.

*/

u_int

*/

u_int

-ether_if_print(const struct pcap_pkthdr *h, const u_char *p)

+netanalyzer_if_print(netdissect_options *ndo, const struct pcap_pkthdr *h,

+ const u_char *p)

{

- ether_print(p, h->len, h->caplen);

+ /*

+ * Fail if we don't have enough data for the Hilscher pseudo-header.

+ */

+ if (h->len < 4 || h->caplen < 4) {

+ ND_PRINT((ndo, "[|netanalyzer]"));

+ return (h->caplen);

+ }

- return (ETHER_HDRLEN);

+ /* Skip the pseudo-header. */

+ return (4 + ether_print(ndo, p + 4, h->len - 4, h->caplen - 4, NULL, NULL));

}

/*

}

/*

- * Prints the packet encapsulated in an Ethernet data segment

- * (or an equivalent encapsulation), given the Ethernet type code.

+ * This is the top level routine of the printer. 'p' points

+ * to the ether header of the packet, 'h->ts' is the timestamp,

+ * 'h->len' is the length of the packet off the wire, and 'h->caplen'

+ * is the number of bytes actually captured.

*

- * Returns non-zero if it can do so, zero if the ethertype is unknown.

+ * This is for DLT_NETANALYZER_TRANSPARENT, which has a 4-byte

+ * pseudo-header, a 7-byte Ethernet preamble, and a 1-byte Ethernet SOF

+ * before the Ethernet header.

+ */

+u_int

+netanalyzer_transparent_if_print(netdissect_options *ndo,

+ const struct pcap_pkthdr *h,

+ const u_char *p)

+{

+ /*

+ * Fail if we don't have enough data for the Hilscher pseudo-header,

+ * preamble, and SOF.

+ */

+ if (h->len < 12 || h->caplen < 12) {

+ ND_PRINT((ndo, "[|netanalyzer-transparent]"));

+ return (h->caplen);

+ }

+

+ /* Skip the pseudo-header, preamble, and SOF. */

+ return (12 + ether_print(ndo, p + 12, h->len - 12, h->caplen - 12, NULL, NULL));

+}

+

+/*

+ * Prints the packet payload, given an Ethernet type code for the payload's

+ * protocol.

*

- * The Ethernet type code is passed through a pointer; if it was

- * ETHERTYPE_8021Q, it gets updated to be the Ethernet type of

- * the 802.1Q payload, for the benefit of lower layers that might

- * want to know what it is.

+ * Returns non-zero if it can do so, zero if the ethertype is unknown.

*/

int

*/

int

-ether_encap_print(u_short ether_type, const u_char *p,

- u_int length, u_int caplen, u_short *extracted_ether_type)

+ethertype_print(netdissect_options *ndo,

+ u_short ether_type, const u_char *p,

+ u_int length, u_int caplen)

{

- recurse:

- *extracted_ether_type = ether_type;

-

switch (ether_type) {

case ETHERTYPE_IP:

switch (ether_type) {

case ETHERTYPE_IP:

- ip_print(gndo, p, length);

+ ip_print(ndo, p, length);

return (1);

-#ifdef INET6

case ETHERTYPE_IPV6:

- ip6_print(p, length);

+ ip6_print(ndo, p, length);

return (1);

-#endif /*INET6*/

case ETHERTYPE_ARP:

case ETHERTYPE_REVARP:

case ETHERTYPE_ARP:

case ETHERTYPE_REVARP:

- arp_print(gndo, p, length, caplen);

+ arp_print(ndo, p, length, caplen);

return (1);

case ETHERTYPE_DN:

return (1);

case ETHERTYPE_DN:

- decnet_print(p, length, caplen);

+ decnet_print(ndo, p, length, caplen);

return (1);

case ETHERTYPE_ATALK:

return (1);

case ETHERTYPE_ATALK:

- if (vflag)

- fputs("et1 ", stdout);

- atalk_print(p, length);

+ if (ndo->ndo_vflag)

+ ND_PRINT((ndo, "et1 "));

+ atalk_print(ndo, p, length);

return (1);

case ETHERTYPE_AARP:

return (1);

case ETHERTYPE_AARP:

- aarp_print(p, length);

+ aarp_print(ndo, p, length);

return (1);

case ETHERTYPE_IPX:

return (1);

case ETHERTYPE_IPX:

- printf("(NOV-ETHII) ");

- ipx_print(p, length);

+ ND_PRINT((ndo, "(NOV-ETHII) "));

+ ipx_print(ndo, p, length);

return (1);

- case ETHERTYPE_8021Q:

- if (eflag)

- printf("vlan %u, p %u%s, ",

- ntohs(*(u_int16_t *)p) & 0xfff,

- ntohs(*(u_int16_t *)p) >> 13,

- (ntohs(*(u_int16_t *)p) & 0x1000) ? ", CFI" : "");

+ case ETHERTYPE_ISO:

+ isoclns_print(ndo, p + 1, length - 1, length - 1);

+ return(1);

- ether_type = ntohs(*(u_int16_t *)(p + 2));

- p += 4;

- length -= 4;

- caplen -= 4;

+ case ETHERTYPE_PPPOED:

+ case ETHERTYPE_PPPOES:

+ case ETHERTYPE_PPPOED2:

+ case ETHERTYPE_PPPOES2:

+ pppoe_print(ndo, p, length);

+ return (1);

- if (ether_type > ETHERMTU) {

- if (eflag)

- printf("ethertype %s, ",

- tok2str(ethertype_values,"0x%04x", ether_type));

- goto recurse;

- }

+ case ETHERTYPE_EAPOL:

+ eap_print(ndo, p, length);

+ return (1);

- *extracted_ether_type = 0;

+ case ETHERTYPE_RRCP:

+ rrcp_print(ndo, p - 14 , length + 14);

+ return (1);

- if (llc_print(p, length, caplen, p - 18, p - 12,

- extracted_ether_type) == 0) {

- ether_hdr_print(p - 18, length + 4);

+ case ETHERTYPE_PPP:

+ if (length) {

+ ND_PRINT((ndo, ": "));

+ ppp_print(ndo, p, length);

}

-

- if (!suppress_default_print)

- default_print(p - 18, caplen + 4);

-

return (1);

- case ETHERTYPE_JUMBO:

- ether_type = ntohs(*(u_int16_t *)(p));

- p += 2;

- length -= 2;

- caplen -= 2;

-

- if (ether_type > ETHERMTU) {

- if (eflag)

- printf("ethertype %s, ",

- tok2str(ethertype_values,"0x%04x", ether_type));

- goto recurse;

- }

+ case ETHERTYPE_MPCP:

+ mpcp_print(ndo, p, length);

+ return (1);

- *extracted_ether_type = 0;

+ case ETHERTYPE_SLOW:

+ slow_print(ndo, p, length);

+ return (1);

- if (llc_print(p, length, caplen, p - 16, p - 10,

- extracted_ether_type) == 0) {

- ether_hdr_print(p - 16, length + 2);

- }

+ case ETHERTYPE_CFM:

+ case ETHERTYPE_CFM_OLD:

+ cfm_print(ndo, p, length);

+ return (1);

- if (!suppress_default_print)

- default_print(p - 16, caplen + 2);

+ case ETHERTYPE_LLDP:

+ lldp_print(ndo, p, length);

+ return (1);

+ case ETHERTYPE_LOOPBACK:

+ loopback_print(ndo, p, length);

return (1);

- case ETHERTYPE_ISO:

- isoclns_print(p+1, length-1, length-1);

- return(1);

-

- case ETHERTYPE_PPPOED:

- case ETHERTYPE_PPPOES:

- pppoe_print(p, length);

+ case ETHERTYPE_MPLS:

+ case ETHERTYPE_MPLS_MULTI:

+ mpls_print(ndo, p, length);

return (1);

- case ETHERTYPE_EAPOL:

- eap_print(gndo, p, length);

+ case ETHERTYPE_TIPC:

+ tipc_print(ndo, p, length, caplen);

return (1);

- case ETHERTYPE_PPP:

- if (length) {

- printf(": ");

- ppp_print(p, length);

- }

+ case ETHERTYPE_MS_NLB_HB:

+ msnlb_print(ndo, p);

return (1);

- case ETHERTYPE_SLOW:

- slow_print(p, length);

- return (1);

+ case ETHERTYPE_GEONET_OLD:

+ case ETHERTYPE_GEONET:

+ geonet_print(ndo, p-14, p, length);

+ return (1);

- case ETHERTYPE_LOOPBACK:

+ case ETHERTYPE_CALM_FAST:

+ calm_fast_print(ndo, p-14, p, length);

return (1);

- case ETHERTYPE_MPLS:

- case ETHERTYPE_MPLS_MULTI:

- mpls_print(p, length);

+ case ETHERTYPE_AOE:

+ aoe_print(ndo, p, length);

+ return (1);

+

+ case ETHERTYPE_MEDSA:

+ medsa_print(ndo, p, length, caplen);

return (1);

case ETHERTYPE_LAT:

case ETHERTYPE_SCA:

case ETHERTYPE_MOPRC:

case ETHERTYPE_MOPDL:

return (1);

case ETHERTYPE_LAT:

case ETHERTYPE_SCA:

case ETHERTYPE_MOPRC:

case ETHERTYPE_MOPDL:

+ case ETHERTYPE_IEEE1905_1:

/* default_print for now */

default:

return (0);

/* default_print for now */

default:

return (0);