Removed trailing whitespaces from .h and .c files using the
[obnox/wireshark/wip.git] / packet-gre.c
index fa8e86d1c38c80950869b2d3f977baf583fe886e..b82aa03ff447fa36b0ca35e9725c9fe501f0f584 100644 (file)
@@ -2,12 +2,11 @@
  * Routines for the Generic Routing Encapsulation (GRE) protocol
  * Brad Robel-Forrest <brad.robel-forrest@watchguard.com>
  *
- * $Id: packet-gre.c,v 1.23 2000/06/15 03:48:40 gram Exp $
+ * $Id: packet-gre.c,v 1.51 2002/08/02 23:35:49 jmayer Exp $
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
- *
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
 # include "config.h"
 #endif
 
-#ifdef HAVE_SYS_TYPES_H
-# include <sys/types.h>
-#endif
-
-#ifdef HAVE_NETINET_IN_H
-#include <netinet/in.h>
-#endif
 #include <glib.h>
-#include "packet.h"
-#include "packet-ip.h"
-#include "packet-ppp.h"
-#include "packet-ipx.h"
+#include <epan/packet.h>
+#include "packet-wccp.h"
+#include "in_cksum.h"
+#include "etypes.h"
+#include "greproto.h"
+#include "ipproto.h"
+
+/*
+ * See RFC 1701 "Generic Routing Encapsulation (GRE)", RFC 1702
+ * "Generic Routing Encapsulation over IPv4 networks", RFC 2637
+ * "Point-to-Point Tunneling Protocol (PPTP)", RFC 2784 "Generic
+ * Routing Encapsulation (GRE)", and RFC 2890 "Key and Sequence
+ * Number Extensions to GRE".
+ */
 
 static int proto_gre = -1;
 static int hf_gre_proto = -1;
 
 static gint ett_gre = -1;
 static gint ett_gre_flags = -1;
+static gint ett_gre_wccp2_redirect_header = -1;
+
+static dissector_table_t gre_dissector_table;
+static dissector_handle_t data_handle;
 
 /* bit positions for flags in header */
 #define GH_B_C         0x8000
@@ -59,223 +65,287 @@ static gint ett_gre_flags = -1;
 #define GH_R_FLAGS     0x00F8
 #define GH_B_VER       0x0007
 
-#define GRE_PPP                0x880B
-#define        GRE_IP          0x0800
-#define GRE_WCCP       0x883E
-#define GRE_IPX                0x8137
-
-static void add_flags_and_ver(proto_tree *, guint16, int, int);
+static void add_flags_and_ver(proto_tree *, guint16, tvbuff_t *, int, int);
+static void dissect_gre_wccp2_redirect_header(tvbuff_t *, int, proto_tree *);
 
 static const value_string typevals[] = {
-       { GRE_PPP,  "PPP" },
-       { GRE_IP,   "IP" },
-       { GRE_WCCP, "WCCP"},
-       { GRE_IPX,  "IPX"},
-       { 0,        NULL  }
+       { ETHERTYPE_PPP,       "PPP" },
+       { ETHERTYPE_IP,        "IP" },
+       { GRE_WCCP,            "WCCP"},
+       { ETHERTYPE_IPX,       "IPX"},
+       { ETHERTYPE_ETHBRIDGE, "Transparent Ethernet bridging" },
+       { GRE_FR,              "Frame Relay"},
+       { 0,                   NULL }
 };
 
 static void
-dissect_gre(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
-  
-  guint16      flags_and_ver = pntohs(pd + offset);
-  guint16      type          = pntohs(pd + offset + sizeof(flags_and_ver));
+dissect_gre(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
+{
+  int          offset = 0;
+  guint16      flags_and_ver;
+  guint16      type;
+  gboolean     is_ppp = FALSE;
+  gboolean     is_wccp2 = FALSE;
+  guint        len = 4;
+  proto_item   *ti;
+  proto_tree   *gre_tree = NULL;
   guint16      sre_af;
   guint8       sre_length;
   tvbuff_t     *next_tvb;
 
-  if (check_col(fd, COL_PROTOCOL))
-    col_add_str(fd, COL_PROTOCOL, "GRE");
-       
-  if (check_col(fd, COL_INFO)) {
-    col_add_fstr(fd, COL_INFO, "Encapsulated %s",
-        val_to_str(type, typevals, "0x%04X (unknown)"));
+  flags_and_ver = tvb_get_ntohs(tvb, offset);
+  type = tvb_get_ntohs(tvb, offset + sizeof(flags_and_ver));
+
+  if (check_col(pinfo->cinfo, COL_PROTOCOL))
+    col_set_str(pinfo->cinfo, COL_PROTOCOL, "GRE");
+
+  if (check_col(pinfo->cinfo, COL_INFO)) {
+    col_add_fstr(pinfo->cinfo, COL_INFO, "Encapsulated %s",
+                val_to_str(type, typevals, "0x%04X (unknown)"));
   }
-               
-  if (IS_DATA_IN_FRAME(offset) && tree) {
-    gboolean           is_ppp = FALSE;
-    gboolean           is_wccp2 = FALSE;
-    proto_item *       ti;
-    proto_tree *       gre_tree;
-    guint              len = 4;
-
-    if (flags_and_ver & GH_B_C || flags_and_ver & GH_B_R)
-      len += 4;
-    if (flags_and_ver & GH_B_K)
+
+  if (flags_and_ver & GH_B_C || flags_and_ver & GH_B_R)
+    len += 4;
+  if (flags_and_ver & GH_B_K)
+    len += 4;
+  if (flags_and_ver & GH_B_S)
+    len += 4;
+  switch (type) {
+
+  case ETHERTYPE_PPP:
+    if (flags_and_ver & GH_P_A)
       len += 4;
-    if (flags_and_ver & GH_B_S)
+    is_ppp = TRUE;
+    break;
+
+  case GRE_WCCP:
+    /* WCCP2 puts an extra 4 octets into the header, but uses the same
+       encapsulation type; if it looks as if the first octet of the packet
+       isn't the beginning of an IPv4 header, assume it's WCCP2. */
+    if ((tvb_get_guint8(tvb, offset + sizeof(flags_and_ver) + sizeof(type)) & 0xF0) != 0x40) {
       len += 4;
-    switch (type) {
-
-    case GRE_PPP:
-      if (flags_and_ver & GH_P_A)
-        len += 4;
-      is_ppp = TRUE;
-      break;
-
-    case GRE_WCCP:
-      /* WCCP2 apparently puts an extra 4 octets into the header, but uses
-         the same encapsulation type; if it looks as if the first octet of
-        the packet isn't the beginning of an IPv4 header, assume it's
-        WCCP2. */
-      if ((pd[offset + sizeof(flags_and_ver) + sizeof(type)] & 0xF0) != 0x40) {
-       len += 4;
-       is_wccp2 = TRUE;
-      }
-      break;
+      is_wccp2 = TRUE;
     }
+    break;
+  }
 
-    ti = proto_tree_add_protocol_format(tree, proto_gre, NullTVB, offset, len,
+  if (tree) {
+    ti = proto_tree_add_protocol_format(tree, proto_gre, tvb, offset, len,
       "Generic Routing Encapsulation (%s)",
       val_to_str(type, typevals, "0x%04X - unknown"));
     gre_tree = proto_item_add_subtree(ti, ett_gre);
-    add_flags_and_ver(gre_tree, flags_and_ver, offset, is_ppp);
+    add_flags_and_ver(gre_tree, flags_and_ver, tvb, offset, is_ppp);
+  }
+  offset += sizeof(flags_and_ver);
 
-    offset += sizeof(flags_and_ver);
+  if (tree) {
+    proto_tree_add_uint(gre_tree, hf_gre_proto, tvb, offset, sizeof(type), type);
+  }
+  offset += sizeof(type);
 
-    proto_tree_add_uint(gre_tree, hf_gre_proto, NullTVB, offset, sizeof(type), type);
-    offset += sizeof(type);
+  if (flags_and_ver & GH_B_C || flags_and_ver & GH_B_R) {
+    if (tree) {
+      guint length, reported_length;
+      vec_t cksum_vec[1];
+      guint16 cksum, computed_cksum;
 
-    if (flags_and_ver & GH_B_C || flags_and_ver & GH_B_R) {
-      guint16 checksum = pntohs(pd + offset);
-      proto_tree_add_text(gre_tree, NullTVB, offset, sizeof(checksum),
-                         "Checksum: %u", checksum);
-      offset += sizeof(checksum);
+      cksum = tvb_get_ntohs(tvb, offset);
+      length = tvb_length(tvb);
+      reported_length = tvb_reported_length(tvb);
+      if ((flags_and_ver & GH_B_C) && !pinfo->fragmented
+               && length >= reported_length) {
+       /* The Checksum Present bit is set, and the packet isn't part of a
+          fragmented datagram and isn't truncated, so we can checksum it. */
+
+       cksum_vec[0].ptr = tvb_get_ptr(tvb, 0, reported_length);
+       cksum_vec[0].len = reported_length;
+       computed_cksum = in_cksum(cksum_vec, 1);
+       if (computed_cksum == 0) {
+         proto_tree_add_text(gre_tree, tvb, offset, 2,
+                       "Checksum: 0x%04x (correct)", cksum);
+       } else {
+         proto_tree_add_text(gre_tree, tvb, offset, 2,
+                       "Checksum: 0x%04x (incorrect, should be 0x%04x)",
+                       cksum, in_cksum_shouldbe(cksum, computed_cksum));
+       }
+      } else {
+       proto_tree_add_text(gre_tree, tvb, offset, 2,
+                         "Checksum: 0x%04x", cksum);
+      }
     }
-    
-    if (flags_and_ver & GH_B_C || flags_and_ver & GH_B_R) {
-      guint16 rtoffset = pntohs(pd + offset);
-      proto_tree_add_text(gre_tree, NullTVB, offset, sizeof(rtoffset),
-                         "Offset: %u", rtoffset);
-      offset += sizeof(rtoffset);
+    offset += 2;
+  }
+
+  if (flags_and_ver & GH_B_C || flags_and_ver & GH_B_R) {
+    if (tree) {
+      proto_tree_add_text(gre_tree, tvb, offset, 2,
+                         "Offset: %u", tvb_get_ntohs(tvb, offset));
     }
+    offset += 2;
+  }
 
-    if (flags_and_ver & GH_B_K) {
-      if (is_ppp) {
-       guint16 paylen;
-       guint16 callid;
-       
-       paylen = pntohs(pd + offset);
-       proto_tree_add_text(gre_tree, NullTVB, offset, sizeof(paylen),
-                           "Payload length: %u", paylen);
-       offset += sizeof(paylen);
-
-       callid = pntohs(pd + offset);
-       proto_tree_add_text(gre_tree, NullTVB, offset, sizeof(callid),
-                           "Call ID: %u", callid);
-       offset += sizeof(callid);
+  if (flags_and_ver & GH_B_K) {
+    if (is_ppp) {
+      if (tree) {
+       proto_tree_add_text(gre_tree, tvb, offset, 2,
+                           "Payload length: %u", tvb_get_ntohs(tvb, offset));
       }
-      else {
-       guint32 key = pntohl(pd + offset);
-       proto_tree_add_text(gre_tree, NullTVB, offset, sizeof(key),
-                           "Key: %u", key);
-       offset += sizeof(key);
+      offset += 2;
+      if (tree) {
+       proto_tree_add_text(gre_tree, tvb, offset, 2,
+                           "Call ID: %u", tvb_get_ntohs(tvb, offset));
       }
+      offset += 2;
     }
+    else {
+      if (tree) {
+       proto_tree_add_text(gre_tree, tvb, offset, 4,
+                           "Key: %u", tvb_get_ntohl(tvb, offset));
+      }
+      offset += 4;
+    }
+  }
     
-    if (flags_and_ver & GH_B_S) {
-      guint32 seqnum = pntohl(pd + offset);
-      proto_tree_add_text(gre_tree, NullTVB, offset, sizeof(seqnum),
-                         "Sequence number: %u", seqnum);
-      offset += sizeof(seqnum);
+  if (flags_and_ver & GH_B_S) {
+    if (tree) {
+      proto_tree_add_text(gre_tree, tvb, offset, 4,
+                         "Sequence number: %u", tvb_get_ntohl(tvb, offset));
     }
+    offset += 4;
+  }
 
-    if (is_ppp && flags_and_ver & GH_P_A) {
-      guint32 acknum = pntohl(pd + offset);
-      proto_tree_add_text(gre_tree, NullTVB, offset, sizeof(acknum),
-                         "Acknowledgement number: %u", acknum);
-      offset += sizeof(acknum);
+  if (is_ppp && flags_and_ver & GH_P_A) {
+    if (tree) {
+      proto_tree_add_text(gre_tree, tvb, offset, 4,
+                         "Acknowledgement number: %u", tvb_get_ntohl(tvb, offset));
     }
+    offset += 4;
+  }
 
-    if (flags_and_ver & GH_B_R) {
-      for (;;) {
-       sre_af = pntohs(pd + offset);
-        proto_tree_add_text(gre_tree, NullTVB, offset, sizeof(guint16),
+  if (flags_and_ver & GH_B_R) {
+    for (;;) {
+      sre_af = tvb_get_ntohs(tvb, offset);
+      if (tree) {
+        proto_tree_add_text(gre_tree, tvb, offset, sizeof(guint16),
                          "Address family: %u", sre_af);
-        offset += sizeof(guint16);
-        proto_tree_add_text(gre_tree, NullTVB, offset, 1,
-                         "SRE offset: %u", pd[offset++]);
-       sre_length = pd[offset];
-        proto_tree_add_text(gre_tree, NullTVB, offset, sizeof(guint8),
+      }
+      offset += sizeof(guint16);
+      if (tree) {
+        proto_tree_add_text(gre_tree, tvb, offset, 1,
+                         "SRE offset: %u", tvb_get_guint8(tvb, offset));
+      }
+      offset += sizeof(guint8);
+      sre_length = tvb_get_guint8(tvb, offset);
+      if (tree) {
+        proto_tree_add_text(gre_tree, tvb, offset, sizeof(guint8),
                          "SRE length: %u", sre_length);
-       offset += sizeof(guint8);
-       if (sre_af == 0 && sre_length == 0)
-         break;
-       offset += sre_length;
       }
+      offset += sizeof(guint8);
+      if (sre_af == 0 && sre_length == 0)
+       break;
+      offset += sre_length;
     }
+  }
 
-    switch (type) {
-      case GRE_PPP:
-       next_tvb = tvb_create_from_top(offset);
-        dissect_ppp(next_tvb, &pi, tree);
-       break;
-      case GRE_IP:
-        dissect_ip(pd, offset, fd, tree);
-        break;
-      case GRE_WCCP:
-        if (is_wccp2) {
-          proto_tree_add_text(gre_tree, NullTVB, offset, sizeof(guint32), "WCCPv2 Data");
-          offset += 4;
-        }
-        dissect_ip(pd, offset, fd, tree);
-        break;
-      case GRE_IPX:
-        dissect_ipx(pd, offset, fd, tree);
-        break;
-      default:
-       dissect_data(pd, offset, fd, gre_tree);
-       break;
+  if (type == GRE_WCCP) {
+    if (is_wccp2) {
+      if (tree)
+        dissect_gre_wccp2_redirect_header(tvb, offset, gre_tree);
+      offset += 4;
     }
   }
+
+  /* If the S bit is not set, this packet might not have a payload, so
+     check whether there's any data left, first.
+
+     XXX - the S bit isn't in RFC 2784, which deprecates that bit
+     and some other bits in RFC 1701 and says that they should be
+     zero for RFC 2784-compliant GRE; as such, the absence of the
+     S bit doesn't necessarily mean there's no payload.  */
+  if (!(flags_and_ver & GH_B_S)) {
+    if (tvb_reported_length_remaining(tvb, offset) <= 0)
+      return;  /* no payload */
+  }
+  next_tvb = tvb_new_subset(tvb, offset, -1, -1);
+  if (!dissector_try_port(gre_dissector_table, type, next_tvb, pinfo, tree))
+    call_dissector(data_handle,next_tvb, pinfo, gre_tree);
 }
 
 static void
-add_flags_and_ver(proto_tree *tree, guint16 flags_and_ver, int offset, int is_ppp) {
-
+add_flags_and_ver(proto_tree *tree, guint16 flags_and_ver, tvbuff_t *tvb,
+    int offset, int is_ppp)
+{
   proto_item * ti;
   proto_tree * fv_tree;
   int          nbits = sizeof(flags_and_ver) * 8;
   
-  ti = proto_tree_add_text(tree, NullTVB, offset, 2, 
+  ti = proto_tree_add_text(tree, tvb, offset, 2, 
                           "Flags and version: %#04x", flags_and_ver);
   fv_tree = proto_item_add_subtree(ti, ett_gre_flags);
   
-  proto_tree_add_text(fv_tree, NullTVB, offset, sizeof(flags_and_ver), "%s",
+  proto_tree_add_text(fv_tree, tvb, offset, sizeof(flags_and_ver), "%s",
                      decode_boolean_bitfield(flags_and_ver, GH_B_C, nbits,
                                              "Checksum", "No checksum"));
-  proto_tree_add_text(fv_tree, NullTVB, offset, sizeof(flags_and_ver), "%s",
+  proto_tree_add_text(fv_tree, tvb, offset, sizeof(flags_and_ver), "%s",
                      decode_boolean_bitfield(flags_and_ver, GH_B_R, nbits,
                                              "Routing", "No routing"));
-  proto_tree_add_text(fv_tree, NullTVB, offset, sizeof(flags_and_ver), "%s",
+  proto_tree_add_text(fv_tree, tvb, offset, sizeof(flags_and_ver), "%s",
                      decode_boolean_bitfield(flags_and_ver, GH_B_K, nbits,
                                              "Key", "No key"));
-  proto_tree_add_text(fv_tree, NullTVB, offset, sizeof(flags_and_ver), "%s",
+  proto_tree_add_text(fv_tree, tvb, offset, sizeof(flags_and_ver), "%s",
                      decode_boolean_bitfield(flags_and_ver, GH_B_S, nbits,
                                              "Sequence number", "No sequence number"));
-  proto_tree_add_text(fv_tree, NullTVB, offset, sizeof(flags_and_ver), "%s",
+  proto_tree_add_text(fv_tree, tvb, offset, sizeof(flags_and_ver), "%s",
                      decode_boolean_bitfield(flags_and_ver, GH_B_s, nbits,
                                              "Strict source route", "No strict source route"));
-  proto_tree_add_text(fv_tree, NullTVB, offset, sizeof(flags_and_ver), "%s",
+  proto_tree_add_text(fv_tree, tvb, offset, sizeof(flags_and_ver), "%s",
                      decode_numeric_bitfield(flags_and_ver, GH_B_RECUR, nbits,
                                              "Recursion control: %u"));
   if (is_ppp) {
-    proto_tree_add_text(fv_tree, NullTVB, offset, sizeof(flags_and_ver), "%s",
+    proto_tree_add_text(fv_tree, tvb, offset, sizeof(flags_and_ver), "%s",
                        decode_boolean_bitfield(flags_and_ver, GH_P_A, nbits,
                                                "Acknowledgment number", "No acknowledgment number"));
-    proto_tree_add_text(fv_tree, NullTVB, offset, sizeof(flags_and_ver), "%s",
+    proto_tree_add_text(fv_tree, tvb, offset, sizeof(flags_and_ver), "%s",
                        decode_numeric_bitfield(flags_and_ver, GH_P_FLAGS, nbits,
                                                "Flags: %u"));
   }
   else {
-    proto_tree_add_text(fv_tree, NullTVB, offset, sizeof(flags_and_ver), "%s",
+    proto_tree_add_text(fv_tree, tvb, offset, sizeof(flags_and_ver), "%s",
                        decode_numeric_bitfield(flags_and_ver, GH_R_FLAGS, nbits,
                                                "Flags: %u"));
   }
 
-  proto_tree_add_text(fv_tree, NullTVB, offset, sizeof(flags_and_ver), "%s",
+  proto_tree_add_text(fv_tree, tvb, offset, sizeof(flags_and_ver), "%s",
                      decode_numeric_bitfield(flags_and_ver, GH_B_VER, nbits,
                                              "Version: %u"));
  }
+
+static void
+dissect_gre_wccp2_redirect_header(tvbuff_t *tvb, int offset, proto_tree *tree)
+{
+  proto_item * ti;
+  proto_tree * rh_tree;
+  guint8       rh_flags;
+  
+  ti = proto_tree_add_text(tree, tvb, offset, 4, "Redirect header");
+  rh_tree = proto_item_add_subtree(ti, ett_gre_wccp2_redirect_header);
+
+  rh_flags = tvb_get_guint8(tvb, offset);
+  proto_tree_add_text(rh_tree, tvb, offset, 1, "%s",
+                     decode_boolean_bitfield(rh_flags, 0x80, 8,
+                                     "Dynamic service", "Well-known service"));
+  proto_tree_add_text(rh_tree, tvb, offset, 1, "%s",
+                     decode_boolean_bitfield(rh_flags, 0x40, 8,
+                             "Alternative bucket used", "Alternative bucket not used"));
+
+  proto_tree_add_text(rh_tree, tvb, offset + 1, 1, "Service ID: %s",
+      val_to_str(tvb_get_guint8(tvb, offset + 1), service_id_vals, "Unknown (0x%02X)"));
+  if (rh_flags & 0x40)
+    proto_tree_add_text(rh_tree, tvb, offset + 2, 1, "Alternative bucket index: %u",
+                       tvb_get_guint8(tvb, offset + 2));
+  proto_tree_add_text(rh_tree, tvb, offset + 3, 1, "Primary bucket index: %u",
+                       tvb_get_guint8(tvb, offset + 3));
+}
  
 void
 proto_register_gre(void)
@@ -283,21 +353,31 @@ proto_register_gre(void)
        static hf_register_info hf[] = {
                { &hf_gre_proto,
                        { "Protocol Type", "gre.proto", FT_UINT16, BASE_HEX, VALS(typevals), 0x0,
-                               "The protocol that is GRE encapsulated"}
+                               "The protocol that is GRE encapsulated", HFILL }
                },
        };
        static gint *ett[] = {
                &ett_gre,
                &ett_gre_flags,
+               &ett_gre_wccp2_redirect_header,
        };
 
-        proto_gre = proto_register_protocol("Generic Routing Encapsulation", "gre");
+        proto_gre = proto_register_protocol("Generic Routing Encapsulation",
+           "GRE", "gre");
         proto_register_field_array(proto_gre, hf, array_length(hf));
        proto_register_subtree_array(ett, array_length(ett));
+
+       /* subdissector code */
+       gre_dissector_table = register_dissector_table("gre.proto",
+           "GRE protocol type", FT_UINT16, BASE_HEX);
 }
 
 void
 proto_reg_handoff_gre(void)
 {
-       dissector_add("ip.proto", IP_PROTO_GRE, dissect_gre);
+       dissector_handle_t gre_handle;
+
+       gre_handle = create_dissector_handle(dissect_gre, proto_gre);
+       dissector_add("ip.proto", IP_PROTO_GRE, gre_handle);
+       data_handle = find_dissector("data");
 }