Add a new routine "default_print_packet()", which takes a pointer to the

[tcpdump] / print-ether.c

diff --git a/print-ether.c b/print-ether.c
index 573fdba8a124b3341c56771f13065d4b5be88fe3..fdd79642e84dbc1dc5469fafc72f027fe0f6f96f 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


@@ -20,46 +20,28 @@
  */
 #ifndef lint
 static const char rcsid[] =
  */
 #ifndef lint
 static const char rcsid[] =

-    "@(#) $Header: /tcpdump/master/tcpdump/print-ether.c,v 1.51 2000-07-01 03:39:02 assar Exp $ (LBL)";
+    "@(#) $Header: /tcpdump/master/tcpdump/print-ether.c,v 1.75 2002-12-18 09:41:15 guy 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 <net/if.h>
-
-#include <netinet/in.h>
-#include <netinet/if_ether.h>
-#include <netinet/in_systm.h>
-#include <netinet/ip.h>
-#include <netinet/ip_var.h>
-#include <netinet/udp.h>
-#include <netinet/udp_var.h>
-#include <netinet/tcp.h>
+#include <tcpdump-stdinc.h>

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

-#ifdef INET6
-#include <netinet/ip6.h>
-#endif
-

 #include "interface.h"
 #include "addrtoname.h"
 #include "ethertype.h"
 
 #include "interface.h"
 #include "addrtoname.h"
 #include "ethertype.h"
 

-const u_char *packetp;
+#include "ether.h"
+

 const u_char *snapend;
 
 static inline void
 const u_char *snapend;
 
 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;
 


@@ -77,44 +59,32 @@ ether_print(register const u_char *bp, u_int length)
                             length);
 }
 
                             length);
 }
 

-static u_short extracted_ethertype;
-
-/*
- * 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);
-
-       if (caplen < sizeof(struct ether_header)) {
+       if (caplen < ETHER_HDRLEN) {

                printf("[|ether]");
                printf("[|ether]");

-               goto out;
+               return;

        }
 
        if (eflag)
        }
 
        if (eflag)

-               ether_print(p, length);
+               ether_hdr_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.
+        * Some printers want to check that they're not walking off the
+        * end of the packet.
+        * Rather than pass it all the way down, we set this global.

         */
         */

-       packetp = p;

        snapend = p + caplen;
 
        snapend = p + caplen;
 

-       length -= sizeof(struct ether_header);
-       caplen -= sizeof(struct ether_header);
+       length -= ETHER_HDRLEN;
+       caplen -= ETHER_HDRLEN;

        ep = (struct ether_header *)p;
        ep = (struct ether_header *)p;

-       p += sizeof(struct ether_header);
+       p += ETHER_HDRLEN;

 
        ether_type = ntohs(ep->ether_type);
 
 
        ether_type = ntohs(ep->ether_type);
 


@@ -124,10 +94,11 @@ ether_if_print(u_char *user, const struct pcap_pkthdr *h, const u_char *p)
        extracted_ethertype = 0;
        if (ether_type <= ETHERMTU) {
                /* Try to print the LLC-layer header & higher layers */
        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)) == 0) {
+               if (llc_print(p, length, caplen, ESRC(ep), EDST(ep),
+                   &extracted_ethertype) == 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_hdr_print((u_char *)ep, length + ETHER_HDRLEN);

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


@@ -135,17 +106,44 @@ ether_if_print(u_char *user, const struct pcap_pkthdr *h, const u_char *p)
                        if (!xflag && !qflag)
                                default_print(p, caplen);
                }
                        if (!xflag && !qflag)
                                default_print(p, caplen);
                }

-       } else if (ether_encap_print(ether_type, p, length, caplen) == 0) {
+       } else if (ether_encap_print(ether_type, p, length, caplen,
+           &extracted_ethertype) == 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 + sizeof(*ep));
+                       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,
+ * 'h->length' is the length of the packet off the wire, and 'h->caplen'
+ * is the number of bytes actually captured.
+ */
+void
+ether_if_print(u_char *user _U_, const struct pcap_pkthdr *h, const u_char *p)
+{
+       u_int caplen = h->caplen;
+       u_int length = h->len;
+
+       ++infodelay;
+       ts_print(&h->ts);
+
+       ether_print(p, length, caplen);
+
+       /*
+        * If "-x" was specified, print packet data in hex.
+        */

        if (xflag)
        if (xflag)

-               default_print(p, caplen);
- out:
+               default_print_packet(p, caplen, ETHER_HDRLEN);
+

        putchar('\n');
        putchar('\n');

+
+       --infodelay;
+       if (infoprint)
+               info(0);

 }
 
 /*
 }
 
 /*


@@ -154,16 +152,18 @@ ether_if_print(u_char *user, const struct pcap_pkthdr *h, const u_char *p)
  *
  * Returns non-zero if it can do so, zero if the ethertype is unknown.
  *
  *
  * Returns non-zero if it can do so, zero if the ethertype is unknown.
  *

- * Stuffs the ether type into a global for the benefit of lower layers
- * that might want to know what it is.
+ * 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.

  */
 
 int
 ether_encap_print(u_short ethertype, const u_char *p,
  */
 
 int
 ether_encap_print(u_short ethertype, const u_char *p,

-    u_int length, u_int caplen)
+    u_int length, u_int caplen, u_short *extracted_ethertype)

 {
  recurse:
 {
  recurse:

-       extracted_ethertype = ethertype;
+       *extracted_ethertype = ethertype;

 
        switch (ethertype) {
 
 
        switch (ethertype) {
 


@@ -197,11 +197,12 @@ 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",
+               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" : "");
                       ntohs(*(u_int16_t *)p) & 0xfff,
                       ntohs(*(u_int16_t *)p) >> 13,
                       (ntohs(*(u_int16_t *)p) & 0x1000) ? " CFI" : "");


@@ -212,15 +213,16 @@ ether_encap_print(u_short ethertype, const u_char *p,
                if (ethertype > ETHERMTU)
                        goto recurse;
 
                if (ethertype > ETHERMTU)
                        goto recurse;
 

-               extracted_ethertype = 0;
+               *extracted_ethertype = 0;

 
 

-               if (llc_print(p, length, caplen, p - 18, p - 12) == 0) {
+               if (llc_print(p, length, caplen, p - 18, p - 12,
+                   extracted_ethertype) == 0) {

                        /* ether_type not known, print raw packet */
                        if (!eflag)
                        /* ether_type not known, print raw packet */
                        if (!eflag)

-                               ether_print(p - 18, length + 4);
-                       if (extracted_ethertype) {
+                               ether_hdr_print(p - 18, length + 4);
+                       if (*extracted_ethertype) {

                                printf("(LLC %s) ",
                                printf("(LLC %s) ",

-                              etherproto_string(htons(extracted_ethertype)));
+                              etherproto_string(htons(*extracted_ethertype)));

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


@@ -230,8 +232,25 @@ ether_encap_print(u_short ethertype, const u_char *p,
        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_PPP:
+               printf("ppp");
+               if (length) {
+                       printf(": ");
+                       ppp_print(p, length);
+               }
+               return (1);
+
+        case ETHERTYPE_LOOPBACK:
+                printf("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: