change 802.1ag pre-standard codepoint to standard codepoint

[tcpdump] / print-ether.c

diff --git a/print-ether.c b/print-ether.c
index 0711cca9651dac52593238d27d7a50b2789095b3..e54c9d4eff37db54d39fc1d12b354d5a1b1fb8fe 100644 (file)
--- a/print-ether.c
+++ b/print-ether.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
+ * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 2000

  *     The Regents of the University of California.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  *     The Regents of the University of California.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without


@@ -19,22 +19,15 @@
  * 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.60 2000-12-18 05:41:59 guy Exp $ (LBL)";
+static const char rcsid[] _U_ =
+    "@(#) $Header: /tcpdump/master/tcpdump/print-ether.c,v 1.104 2007-07-23 09:01:09 hannes Exp $ (LBL)";

 #endif
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #endif
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 

-#include <sys/param.h>
-#include <sys/time.h>
-#include <sys/socket.h>
-
-struct mbuf;
-struct rtentry;
-
-#include <netinet/in.h>
+#include <tcpdump-stdinc.h>

 
 #include <stdio.h>
 #include <pcap.h>
 
 #include <stdio.h>
 #include <pcap.h>


@@ -45,60 +38,88 @@ struct rtentry;
 
 #include "ether.h"
 
 
 #include "ether.h"
 

-const u_char *packetp;
-const u_char *snapend;
+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_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_MPCP,           "MPCP" },
+    { ETHERTYPE_SLOW,           "Slow Protocols" },
+    { 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" },
+    { ETHERTYPE_CFM_OLD,        "CFM (old)" },
+    { ETHERTYPE_CFM,            "CFM" },
+    { 0, NULL}
+};

 
 static inline void
 
 static inline void

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

 {
        register const struct ether_header *ep;
 {
        register const struct ether_header *ep;

-

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

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

 }
 
 }
 

-/*
- * This is the top level routine of the printer.  'p' is the points
- * to the ether header of the packet, 'h->tv' is the timestamp,
- * 'h->length' is the length of the packet off the wire, and 'h->caplen'
- * is the number of bytes actually captured.
- */

 void
 void

-ether_if_print(u_char *user, const struct pcap_pkthdr *h, const u_char *p)
+ether_print(const u_char *p, u_int length, u_int caplen)

 {
 {

-       u_int caplen = h->caplen;
-       u_int length = h->len;

        struct ether_header *ep;
        u_short ether_type;
        struct ether_header *ep;
        u_short ether_type;

-       u_short extracted_ethertype;
-
-       ts_print(&h->ts);
+       u_short extracted_ether_type;

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

-               goto out;
+               return;

        }
 
        if (eflag)
        }
 
        if (eflag)

-               ether_print(p, length);
-
-       /*
-        * Some printers want to get back at the ethernet addresses,
-        * and/or check that they're not walking off the end of the packet.
-        * Rather than pass them all the way down, we set these globals.
-        */
-       packetp = p;
-       snapend = p + caplen;
+               ether_hdr_print(p, length);

 
        length -= ETHER_HDRLEN;
        caplen -= ETHER_HDRLEN;
 
        length -= ETHER_HDRLEN;
        caplen -= ETHER_HDRLEN;


@@ -110,33 +131,40 @@ ether_if_print(u_char *user, const struct pcap_pkthdr *h, const u_char *p)
        /*
         * Is it (gag) an 802.3 encapsulation?
         */
        /*
         * Is it (gag) an 802.3 encapsulation?
         */

-       extracted_ethertype = 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_type not known, print raw packet */
                        if (!eflag)

-                               ether_print((u_char *)ep, length);
-                       if (extracted_ethertype) {
-                               printf("(LLC %s) ",
-                              etherproto_string(htons(extracted_ethertype)));
-                       }
-                       if (!xflag && !qflag)
+                               ether_hdr_print((u_char *)ep, length + ETHER_HDRLEN);
+
+                       if (!suppress_default_print)

                                default_print(p, caplen);
                }
        } else if (ether_encap_print(ether_type, p, length, caplen,
                                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_type not known, print raw packet */
                if (!eflag)

-                       ether_print((u_char *)ep, length + ETHER_HDRLEN);
-               if (!xflag && !qflag)
+                       ether_hdr_print((u_char *)ep, length + ETHER_HDRLEN);
+
+               if (!suppress_default_print)

                        default_print(p, caplen);
                        default_print(p, caplen);

-       }
-       if (xflag)
-               default_print(p, caplen);
- out:
-       putchar('\n');
+       } 
+}
+
+/*
+ * 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(const struct pcap_pkthdr *h, const u_char *p)
+{
+       ether_print(p, h->len, h->caplen);
+
+       return (ETHER_HDRLEN);

 }
 
 /*
 }
 
 /*


@@ -152,16 +180,16 @@ ether_if_print(u_char *user, 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


@@ -172,7 +200,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:


@@ -190,42 +218,110 @@ ether_encap_print(u_short ethertype, const u_char *p,
                return (1);
 
        case ETHERTYPE_IPX:
                return (1);
 
        case ETHERTYPE_IPX:

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

                ipx_print(p, length);
                return (1);
 
        case ETHERTYPE_8021Q:
                ipx_print(p, length);
                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)
-                               ether_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);
+                   extracted_ether_type) == 0) {
+                        ether_hdr_print(p - 18, length + 4);
+
+                        if (!suppress_default_print) {
+                                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 (!suppress_default_print) {
+                            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);
        case ETHERTYPE_PPPOED:
        case ETHERTYPE_PPPOES:
                pppoe_print(p, length);

-               return (1);
- 
+               return (1);
+
+       case ETHERTYPE_EAPOL:
+               eap_print(gndo, p, length);
+               return (1);
+
+       case ETHERTYPE_PPP:
+               if (length) {
+                       printf(": ");
+                       ppp_print(p, length);
+               }
+               return (1);
+
+       case ETHERTYPE_MPCP:
+               mpcp_print(p, length);
+               return (1);
+
+       case ETHERTYPE_SLOW:
+               slow_print(p, length);
+               return (1);
+
+       case ETHERTYPE_CFM:
+       case ETHERTYPE_CFM_OLD:
+               cfm_print(p, length);
+               return (1);
+
+        case ETHERTYPE_LOOPBACK:
+                return (1);
+
+       case ETHERTYPE_MPLS:
+       case ETHERTYPE_MPLS_MULTI:
+               mpls_print(p, length);
+               return (1);
+

        case ETHERTYPE_LAT:
        case ETHERTYPE_SCA:
        case ETHERTYPE_MOPRC:
        case ETHERTYPE_LAT:
        case ETHERTYPE_SCA:
        case ETHERTYPE_MOPRC:


@@ -235,3 +331,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:
+ */
+