Put in some missing brackets.

[tcpdump] / print-ether.c

diff --git a/print-ether.c b/print-ether.c
index 4b6527cca81e8264decaabd47bd38ebf9285bfd0..a12e7b05342edddd77e811195053ef4f97c6dfdc 100644 (file)
--- a/print-ether.c
+++ b/print-ether.c
@@ -19,8 +19,8 @@
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
 #ifndef lint
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
 #ifndef lint

-static const char rcsid[] =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-ether.c,v 1.78 2003-05-08 14:40:54 hannes Exp $ (LBL)";
+static const char rcsid[] _U_ =
+    "@(#) $Header: /tcpdump/master/tcpdump/print-ether.c,v 1.95 2005-04-06 21:32:39 mcr Exp $ (LBL)";

 #endif
 
 #ifdef HAVE_CONFIG_H
 #endif
 
 #ifdef HAVE_CONFIG_H


@@ -37,26 +37,85 @@ static const char rcsid[] =
 #include "ethertype.h"
 
 #include "ether.h"
 #include "ethertype.h"
 
 #include "ether.h"

-
-const u_char *snapend;
+#include "llc.h"
+
+const struct tok ethertype_values[] = { 
+    /* not really ethertypes but PIDs that are used
+       in the SNAP printer - its more convenient
+       to put them into a single tokentable */
+    { PID_RFC2684_ETH_FCS,      "Ethernet + FCS" },
+    { PID_RFC2684_ETH_NOFCS,    "Ethernet no FCS" },
+    { PID_RFC2684_802_4_FCS,    "802.4 + FCS" },
+    { PID_RFC2684_802_4_NOFCS,  "w/o FCS" },
+    { PID_RFC2684_802_5_FCS,    "Tokenring + FCS" },
+    { PID_RFC2684_802_5_NOFCS,  "Tokenring no FCS" },
+    { PID_RFC2684_FDDI_FCS,     "FDDI + FCS" },
+    { PID_RFC2684_FDDI_NOFCS,   "FDDI no FCS" },
+    { PID_RFC2684_802_6_FCS,    "802.6 + FCS" },
+    { PID_RFC2684_802_6_NOFCS,  "802.6 no FCS" },
+    { PID_RFC2684_BPDU,         "BPDU" },
+    /* the real Ethertypes */
+    { ETHERTYPE_IP,            "IPv4" },
+    { ETHERTYPE_MPLS,          "MPLS unicast" },
+    { ETHERTYPE_MPLS_MULTI,    "MPLS multicast" },
+    { ETHERTYPE_IPV6,          "IPv6" },
+    { ETHERTYPE_8021Q,         "802.1Q" },
+    { ETHERTYPE_VMAN,          "VMAN" },
+    { ETHERTYPE_PUP,            "PUP" },
+    { ETHERTYPE_ARP,            "ARP"},
+    { ETHERTYPE_REVARP ,        "Reverse ARP"},
+    { ETHERTYPE_NS,             "NS" },
+    { ETHERTYPE_SPRITE,         "Sprite" },
+    { ETHERTYPE_TRAIL,          "Trail" },
+    { ETHERTYPE_MOPDL,          "MOP DL" },
+    { ETHERTYPE_MOPRC,          "MOP RC" },
+    { ETHERTYPE_DN,             "DN" },
+    { ETHERTYPE_LAT,            "LAT" },
+    { ETHERTYPE_SCA,            "SCA" },
+    { ETHERTYPE_LANBRIDGE,      "Lanbridge" },
+    { ETHERTYPE_DECDNS,         "DEC DNS" },
+    { ETHERTYPE_DECDTS,         "DEC DTS" },
+    { ETHERTYPE_VEXP,           "VEXP" },
+    { ETHERTYPE_VPROD,          "VPROD" },
+    { ETHERTYPE_ATALK,          "Appletalk" },
+    { ETHERTYPE_AARP,           "Appletalk ARP" },
+    { ETHERTYPE_IPX,            "IPX" },
+    { ETHERTYPE_PPP,            "PPP" },
+    { ETHERTYPE_PPPOED,         "PPPoE D" },
+    { ETHERTYPE_PPPOES,         "PPPoE S" },
+    { ETHERTYPE_EAPOL,          "EAPOL" },
+    { ETHERTYPE_JUMBO,          "Jumbo" },
+    { ETHERTYPE_LOOPBACK,       "Loopback" },
+    { ETHERTYPE_ISO,            "OSI" },
+    { ETHERTYPE_GRE_ISO,        "GRE-OSI" },
+    { 0, NULL}
+};

 
 static inline void
 ether_hdr_print(register const u_char *bp, u_int length)
 {
        register const struct ether_header *ep;
 
 static inline void
 ether_hdr_print(register const u_char *bp, u_int length)
 {
        register const struct ether_header *ep;

-

        ep = (const struct ether_header *)bp;
        ep = (const struct ether_header *)bp;

-       if (qflag)
-               (void)printf("%s > %s (length: %u): ",
-                            etheraddr_string(ESRC(ep)),
-                            etheraddr_string(EDST(ep)),
-                            length);
-       else
-               (void)printf("%s > %s %s (length: %u): ",
-                            etheraddr_string(ESRC(ep)),
-                            etheraddr_string(EDST(ep)),
-                            etherproto_string(ep->ether_type),
-                            length);
+
+       (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));       
+        } 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)));  
+        }
+
+       (void)printf(", length %u: ", length);

 }
 
 void
 }
 
 void


@@ -64,7 +123,7 @@ ether_print(const u_char *p, u_int length, u_int caplen)
 {
        struct ether_header *ep;
        u_short ether_type;
 {
        struct ether_header *ep;
        u_short ether_type;

-       u_short extracted_ethertype;
+       u_short extracted_ether_type;

 
        if (caplen < ETHER_HDRLEN) {
                printf("[|ether]");
 
        if (caplen < ETHER_HDRLEN) {
                printf("[|ether]");


@@ -84,35 +143,33 @@ ether_print(const u_char *p, u_int length, u_int caplen)
        /*
         * Is it (gag) an 802.3 encapsulation?
         */
        /*
         * Is it (gag) an 802.3 encapsulation?
         */

-       extracted_ethertype = 0;
+       extracted_ether_type = 0;

        if (ether_type <= ETHERMTU) {
                /* Try to print the LLC-layer header & higher layers */
                if (llc_print(p, length, caplen, ESRC(ep), EDST(ep),
        if (ether_type <= ETHERMTU) {
                /* Try to print the LLC-layer header & higher layers */
                if (llc_print(p, length, caplen, ESRC(ep), EDST(ep),

-                   &extracted_ethertype) == 0) {
+                   &extracted_ether_type) == 0) {

                        /* ether_type not known, print raw packet */
                        if (!eflag)
                                ether_hdr_print((u_char *)ep, length + ETHER_HDRLEN);
                        /* ether_type not known, print raw packet */
                        if (!eflag)
                                ether_hdr_print((u_char *)ep, length + ETHER_HDRLEN);

-                       if (extracted_ethertype) {
-                               printf("(LLC %s) ",
-                              etherproto_string(htons(extracted_ethertype)));
-                       }
+

                        if (!xflag && !qflag)
                                default_print(p, caplen);
                }
        } else if (ether_encap_print(ether_type, p, length, caplen,
                        if (!xflag && !qflag)
                                default_print(p, caplen);
                }
        } else if (ether_encap_print(ether_type, p, length, caplen,

-           &extracted_ethertype) == 0) {
+           &extracted_ether_type) == 0) {

                /* ether_type not known, print raw packet */
                if (!eflag)
                        ether_hdr_print((u_char *)ep, length + ETHER_HDRLEN);
                /* ether_type not known, print raw packet */
                if (!eflag)
                        ether_hdr_print((u_char *)ep, length + ETHER_HDRLEN);

+

                if (!xflag && !qflag)
                        default_print(p, caplen);
                if (!xflag && !qflag)
                        default_print(p, caplen);

-       }
+       } 

 }
 
 /*
  * This is the top level routine of the printer.  'p' points
  * to the ether header of the packet, 'h->ts' is the timestamp,
 }
 
 /*
  * This is the top level routine of the printer.  'p' points
  * to the ether header of the packet, 'h->ts' is the timestamp,

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

  * is the number of bytes actually captured.
  */
 u_int
  * is the number of bytes actually captured.
  */
 u_int


@@ -136,16 +193,16 @@ ether_if_print(const struct pcap_pkthdr *h, const u_char *p)
  */
 
 int
  */
 
 int

-ether_encap_print(u_short ethertype, const u_char *p,
-    u_int length, u_int caplen, u_short *extracted_ethertype)
+ether_encap_print(u_short ether_type, const u_char *p,
+    u_int length, u_int caplen, u_short *extracted_ether_type)

 {
  recurse:
 {
  recurse:

-       *extracted_ethertype = ethertype;
+       *extracted_ether_type = ether_type;

 
 

-       switch (ethertype) {
+       switch (ether_type) {

 
        case ETHERTYPE_IP:
 
        case ETHERTYPE_IP:

-               ip_print(p, length);
+               ip_print(gndo, p, length);

                return (1);
 
 #ifdef INET6
                return (1);
 
 #ifdef INET6


@@ -156,7 +213,7 @@ ether_encap_print(u_short ethertype, const u_char *p,
 
        case ETHERTYPE_ARP:
        case ETHERTYPE_REVARP:
 
        case ETHERTYPE_ARP:
        case ETHERTYPE_REVARP:

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

                return (1);
 
        case ETHERTYPE_DN:
                return (1);
 
        case ETHERTYPE_DN:


@@ -179,40 +236,75 @@ ether_encap_print(u_short ethertype, const u_char *p,
                return (1);
 
        case ETHERTYPE_8021Q:
                return (1);
 
        case ETHERTYPE_8021Q:

-               printf("802.1Q vlan#%d P%d%s ",
-                      ntohs(*(u_int16_t *)p) & 0xfff,
-                      ntohs(*(u_int16_t *)p) >> 13,
-                      (ntohs(*(u_int16_t *)p) & 0x1000) ? " CFI" : "");
-               ethertype = ntohs(*(u_int16_t *)(p + 2));
+               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" : "");
+
+               ether_type = ntohs(*(u_int16_t *)(p + 2));

                p += 4;
                length -= 4;
                caplen -= 4;
                p += 4;
                length -= 4;
                caplen -= 4;

-               if (ethertype > ETHERMTU)
+
+               if (ether_type > ETHERMTU) {
+                       if (eflag)
+                               printf("ethertype %s, ",
+                                      tok2str(ethertype_values,"0x%04x", ether_type));

                        goto recurse;
                        goto recurse;

+               }

 
 

-               *extracted_ethertype = 0;
+               *extracted_ether_type = 0;

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

-                   extracted_ethertype) == 0) {
-                       /* ether_type not known, print raw packet */
-                       if (!eflag)
+                   extracted_ether_type) == 0) {

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

-                       if (*extracted_ethertype) {
-                               printf("(LLC %s) ",
-                              etherproto_string(htons(*extracted_ethertype)));
-                       }
-                       if (!xflag && !qflag)
-                               default_print(p - 18, caplen + 4);

                }
                }

+
+               if (!xflag && !qflag)
+                       default_print(p - 18, caplen + 4);
+

                return (1);
 
                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;
+                }
+
+                *extracted_ether_type = 0;
+
+                if (llc_print(p, length, caplen, p - 16, p - 10,
+                              extracted_ether_type) == 0) {
+                    ether_hdr_print(p - 16, length + 2);
+                }
+
+                if (!xflag && !qflag)
+                    default_print(p - 16, caplen + 2);
+
+                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);
                return (1);
 
        case ETHERTYPE_PPPOED:
        case ETHERTYPE_PPPOES:
                pppoe_print(p, length);
                return (1);
 

+       case ETHERTYPE_EAPOL:
+               eap_print(gndo, p, length);
+               return (1);
+

        case ETHERTYPE_PPP:
        case ETHERTYPE_PPP:

-               printf("ppp");

                if (length) {
                        printf(": ");
                        ppp_print(p, length);
                if (length) {
                        printf(": ");
                        ppp_print(p, length);


@@ -220,8 +312,7 @@ ether_encap_print(u_short ethertype, const u_char *p,
                return (1);
 
         case ETHERTYPE_LOOPBACK:
                return (1);
 
         case ETHERTYPE_LOOPBACK:

-                printf("loopback");
-                return (1);
+                return (0);

 
        case ETHERTYPE_MPLS:
        case ETHERTYPE_MPLS_MULTI:
 
        case ETHERTYPE_MPLS:
        case ETHERTYPE_MPLS_MULTI:


@@ -237,3 +328,12 @@ ether_encap_print(u_short ethertype, const u_char *p,
                return (0);
        }
 }
                return (0);
        }
 }

+
+
+/*
+ * Local Variables:
+ * c-style: whitesmith
+ * c-basic-offset: 8
+ * End:
+ */
+