/* packet-ip.c
* Routines for IP and miscellaneous IP protocol packet disassembly
*
- * $Id: packet-ip.c,v 1.89 2000/05/28 22:59:18 guy Exp $
+ * $Id: packet-ip.c,v 1.165 2002/03/31 21:43:51 guy 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 <stdio.h>
#include <string.h>
#include <glib.h>
-#include "packet.h"
-#include "resolv.h"
#ifdef NEED_SNPRINTF_H
-# ifdef HAVE_STDARG_H
-# include <stdarg.h>
-# else
-# include <varargs.h>
-# endif
# include "snprintf.h"
#endif
+#include <epan/packet.h>
+#include <epan/resolv.h>
+#include "ipproto.h"
+#include "prefs.h"
+#include "reassemble.h"
#include "etypes.h"
+#include "greproto.h"
#include "ppptypes.h"
#include "llcsaps.h"
+#include "aftypes.h"
#include "packet-ip.h"
#include "packet-ipsec.h"
+#include "in_cksum.h"
+#include "nlpid.h"
-static void dissect_icmp(const u_char *, int, frame_data *, proto_tree *);
-static void dissect_igmp(const u_char *, int, frame_data *, proto_tree *);
-
+static void dissect_icmp(tvbuff_t *, packet_info *, proto_tree *);
/* Decode the old IPv4 TOS field as the DiffServ DS Field */
-gboolean g_ip_dscp_actif = TRUE;
+static gboolean g_ip_dscp_actif = TRUE;
+
+/* Defragment fragmented IP datagrams */
+static gboolean ip_defragment = FALSE;
+
+/* Place IP summary in proto tree */
+static gboolean ip_summary_in_tree = TRUE;
static int proto_ip = -1;
static int hf_ip_version = -1;
static int hf_ip_hdr_len = -1;
static int hf_ip_dsfield = -1;
static int hf_ip_dsfield_dscp = -1;
-static int hf_ip_dsfield_cu = -1;
+static int hf_ip_dsfield_ect = -1;
+static int hf_ip_dsfield_ce = -1;
static int hf_ip_tos = -1;
static int hf_ip_tos_precedence = -1;
static int hf_ip_tos_delay = -1;
static int hf_ip_ttl = -1;
static int hf_ip_proto = -1;
static int hf_ip_checksum = -1;
+static int hf_ip_checksum_bad = -1;
+static int hf_ip_fragments = -1;
+static int hf_ip_fragment = -1;
+static int hf_ip_fragment_overlap = -1;
+static int hf_ip_fragment_overlap_conflict = -1;
+static int hf_ip_fragment_multiple_tails = -1;
+static int hf_ip_fragment_too_long_fragment = -1;
+static int hf_ip_fragment_error = -1;
static gint ett_ip = -1;
static gint ett_ip_dsfield = -1;
static gint ett_ip_option_sec = -1;
static gint ett_ip_option_route = -1;
static gint ett_ip_option_timestamp = -1;
+static gint ett_ip_fragments = -1;
+static gint ett_ip_fragment = -1;
/* Used by IPv6 as well, so not static */
dissector_table_t ip_dissector_table;
-static int proto_igmp = -1;
-static int hf_igmp_version = -1;
-static int hf_igmp_type = -1;
-static int hf_igmp_unused = -1;
-static int hf_igmp_checksum = -1;
-static int hf_igmp_group = -1;
-
-static gint ett_igmp = -1;
+static dissector_handle_t ip_handle;
+static dissector_handle_t data_handle;
static int proto_icmp = -1;
static int hf_icmp_type = -1;
static int hf_icmp_code = -1;
static int hf_icmp_checksum = -1;
+static int hf_icmp_checksum_bad = -1;
+
+/* Mobile ip */
+static int hf_icmp_mip_type = -1;
+static int hf_icmp_mip_length = -1;
+static int hf_icmp_mip_prefix_length = -1;
+static int hf_icmp_mip_seq = -1;
+static int hf_icmp_mip_life = -1;
+static int hf_icmp_mip_flags = -1;
+static int hf_icmp_mip_r = -1;
+static int hf_icmp_mip_b = -1;
+static int hf_icmp_mip_h = -1;
+static int hf_icmp_mip_f = -1;
+static int hf_icmp_mip_m = -1;
+static int hf_icmp_mip_g = -1;
+static int hf_icmp_mip_v = -1;
+static int hf_icmp_mip_res = -1;
+static int hf_icmp_mip_reserved = -1;
+static int hf_icmp_mip_coa = -1;
+static int hf_icmp_mip_challenge = -1;
static gint ett_icmp = -1;
+static gint ett_icmp_mip = -1;
+static gint ett_icmp_mip_flags = -1;
-/* ICMP structs and definitions */
-typedef struct _e_icmp {
- guint8 icmp_type;
- guint8 icmp_code;
- guint16 icmp_cksum;
- union {
- struct { /* Address mask request/reply */
- guint16 id;
- guint16 seq;
- guint32 sn_mask;
- } am;
- struct { /* Timestap request/reply */
- guint16 id;
- guint16 seq;
- guint32 orig;
- guint32 recv;
- guint32 xmit;
- } ts;
- guint32 zero; /* Unreachable */
- } opt;
-} e_icmp;
+/* ICMP definitions */
#define ICMP_ECHOREPLY 0
#define ICMP_UNREACH 3
#define ICMP_PREC_CUTOFF 15 /* Precedence cut off */
-/* IGMP structs and definitions */
-typedef struct _e_igmp {
- guint8 igmp_v_t; /* combines igmp_v and igmp_t */
- guint8 igmp_unused;
- guint16 igmp_cksum;
- guint32 igmp_gaddr;
-} e_igmp;
-
-#define IGMP_M_QRY 0x01
-#define IGMP_V1_M_RPT 0x02
-#define IGMP_V2_LV_GRP 0x07
-#define IGMP_DVMRP 0x03
-#define IGMP_PIM 0x04
-#define IGMP_V2_M_RPT 0x06
-#define IGMP_MTRC_RESP 0x1e
-#define IGMP_MTRC 0x1f
-
/* IP structs and definitions */
typedef struct _e_ip
/* Differentiated Services Field. See RFCs 2474, 2597 and 2598. */
#define IPDSFIELD_DSCP_MASK 0xFC
+#define IPDSFIELD_ECN_MASK 0x03
#define IPDSFIELD_DSCP_SHIFT 2
#define IPDSFIELD_DSCP(dsfield) (((dsfield)&IPDSFIELD_DSCP_MASK)>>IPDSFIELD_DSCP_SHIFT)
+#define IPDSFIELD_ECN(dsfield) ((dsfield)&IPDSFIELD_ECN_MASK)
#define IPDSFIELD_DSCP_DEFAULT 0x00
#define IPDSFIELD_DSCP_CS1 0x08
#define IPDSFIELD_DSCP_CS2 0x10
#define IPDSFIELD_DSCP_AF42 0x24
#define IPDSFIELD_DSCP_AF43 0x26
#define IPDSFIELD_DSCP_EF 0x2E
-#define IPDSFIELD_CU_MASK 0x03
+#define IPDSFIELD_ECT_MASK 0x02
+#define IPDSFIELD_CE_MASK 0x01
/* IP TOS, superseded by the DS Field, RFC 2474. */
#define IPTOS_TOS_MASK 0x1E
#define IPOLEN_RR_MIN 3
#define IPOLEN_SID 4
#define IPOLEN_SSRR_MIN 3
+#define IPOLEN_RA 4
#define IPSEC_UNCLASSIFIED 0x0000
#define IPSEC_CONFIDENTIAL 0xF135
#define IPOPT_TS_TSANDADDR 1 /* timestamps and addresses */
#define IPOPT_TS_PRESPEC 3 /* specified modules only */
+/*
+ * defragmentation of IPv4
+ */
+static GHashTable *ip_fragment_table = NULL;
+
+static void
+ip_defragment_init(void)
+{
+ fragment_table_init(&ip_fragment_table);
+}
void
-capture_ip(const u_char *pd, int offset, packet_counts *ld) {
- if (!BYTES_ARE_IN_FRAME(offset, IPH_MIN_LEN)) {
+capture_ip(const u_char *pd, int offset, int len, packet_counts *ld) {
+ if (!BYTES_ARE_IN_FRAME(offset, len, IPH_MIN_LEN)) {
ld->other++;
return;
}
}
static void
-dissect_ipopt_security(const ip_tcp_opt *optp, const u_char *opd, int offset,
- guint optlen, proto_tree *opt_tree)
+dissect_ipopt_security(const ip_tcp_opt *optp, tvbuff_t *tvb, int offset,
+ guint optlen, packet_info *pinfo _U_,
+ proto_tree *opt_tree)
{
proto_tree *field_tree = NULL;
proto_item *tf;
{IPSEC_RESERVED8, "Reserved" },
{0, NULL } };
- tf = proto_tree_add_text(opt_tree, NullTVB, offset, optlen, "%s:", optp->name);
+ tf = proto_tree_add_text(opt_tree, tvb, offset, optlen, "%s:", optp->name);
field_tree = proto_item_add_subtree(tf, *optp->subtree_index);
offset += 2;
- val = pntohs(opd);
- proto_tree_add_text(field_tree, NullTVB, offset, 2,
+ val = tvb_get_ntohs(tvb, offset);
+ proto_tree_add_text(field_tree, tvb, offset, 2,
"Security: %s", val_to_str(val, secl_vals, "Unknown (0x%x)"));
offset += 2;
- opd += 2;
- val = pntohs(opd);
- proto_tree_add_text(field_tree, NullTVB, offset, 2,
+ val = tvb_get_ntohs(tvb, offset);
+ proto_tree_add_text(field_tree, tvb, offset, 2,
"Compartments: %u", val);
offset += 2;
- opd += 2;
- proto_tree_add_text(field_tree, NullTVB, offset, 2,
- "Handling restrictions: %c%c", opd[0], opd[1]);
+ proto_tree_add_text(field_tree, tvb, offset, 2,
+ "Handling restrictions: %c%c",
+ tvb_get_guint8(tvb, offset),
+ tvb_get_guint8(tvb, offset + 1));
offset += 2;
- opd += 2;
- proto_tree_add_text(field_tree, NullTVB, offset, 3,
- "Transmission control code: %c%c%c", opd[0], opd[1], opd[2]);
+ proto_tree_add_text(field_tree, tvb, offset, 3,
+ "Transmission control code: %c%c%c",
+ tvb_get_guint8(tvb, offset),
+ tvb_get_guint8(tvb, offset + 1),
+ tvb_get_guint8(tvb, offset + 2));
}
static void
-dissect_ipopt_route(const ip_tcp_opt *optp, const u_char *opd, int offset,
- guint optlen, proto_tree *opt_tree)
+dissect_ipopt_route(const ip_tcp_opt *optp, tvbuff_t *tvb, int offset,
+ guint optlen, packet_info *pinfo _U_,
+ proto_tree *opt_tree)
{
proto_tree *field_tree = NULL;
proto_item *tf;
int optoffset = 0;
struct in_addr addr;
- tf = proto_tree_add_text(opt_tree, NullTVB, offset, optlen, "%s (%u bytes)",
+ tf = proto_tree_add_text(opt_tree, tvb, offset, optlen, "%s (%u bytes)",
optp->name, optlen);
field_tree = proto_item_add_subtree(tf, *optp->subtree_index);
optoffset += 2; /* skip past type and length */
optlen -= 2; /* subtract size of type and length */
- ptr = *opd;
- proto_tree_add_text(field_tree, NullTVB, offset + optoffset, 1,
+ ptr = tvb_get_guint8(tvb, offset + optoffset);
+ proto_tree_add_text(field_tree, tvb, offset + optoffset, 1,
"Pointer: %d%s", ptr,
((ptr < 4) ? " (points before first address)" :
((ptr & 3) ? " (points to middle of address)" : "")));
optoffset++;
- opd++;
optlen--;
ptr--; /* ptr is 1-origin */
while (optlen > 0) {
if (optlen < 4) {
- proto_tree_add_text(field_tree, NullTVB, offset, optlen,
+ proto_tree_add_text(field_tree, tvb, offset, optlen,
"(suboption would go past end of option)");
break;
}
/* Avoids alignment problems on many architectures. */
- memcpy((char *)&addr, (char *)opd, sizeof(addr));
+ tvb_memcpy(tvb, (guint8 *)&addr, offset + optoffset, sizeof(addr));
- proto_tree_add_text(field_tree, NullTVB, offset + optoffset, 4,
+ proto_tree_add_text(field_tree, tvb, offset + optoffset, 4,
"%s%s",
((addr.s_addr == 0) ? "-" : (char *)get_hostname(addr.s_addr)),
((optoffset == ptr) ? " <- (current)" : ""));
optoffset += 4;
- opd += 4;
optlen -= 4;
}
}
static void
-dissect_ipopt_sid(const ip_tcp_opt *optp, const u_char *opd, int offset,
- guint optlen, proto_tree *opt_tree)
+dissect_ipopt_sid(const ip_tcp_opt *optp, tvbuff_t *tvb, int offset,
+ guint optlen, packet_info *pinfo _U_,
+ proto_tree *opt_tree)
{
- proto_tree_add_text(opt_tree, NullTVB, offset, optlen,
- "%s: %d", optp->name, pntohs(opd));
+ proto_tree_add_text(opt_tree, tvb, offset, optlen,
+ "%s: %u", optp->name, tvb_get_ntohs(tvb, offset + 2));
return;
}
static void
-dissect_ipopt_timestamp(const ip_tcp_opt *optp, const u_char *opd,
- int offset, guint optlen, proto_tree *opt_tree)
+dissect_ipopt_timestamp(const ip_tcp_opt *optp, tvbuff_t *tvb,
+ int offset, guint optlen, packet_info *pinfo _U_, proto_tree *opt_tree)
{
proto_tree *field_tree = NULL;
proto_item *tf;
struct in_addr addr;
guint ts;
- tf = proto_tree_add_text(opt_tree, NullTVB, offset, optlen, "%s:", optp->name);
+ tf = proto_tree_add_text(opt_tree, tvb, offset, optlen, "%s:", optp->name);
field_tree = proto_item_add_subtree(tf, *optp->subtree_index);
optoffset += 2; /* skip past type and length */
optlen -= 2; /* subtract size of type and length */
- ptr = *opd;
- proto_tree_add_text(field_tree, NullTVB, offset + optoffset, 1,
+ ptr = tvb_get_guint8(tvb, offset + optoffset);
+ proto_tree_add_text(field_tree, tvb, offset + optoffset, 1,
"Pointer: %d%s", ptr,
((ptr < 5) ? " (points before first address)" :
(((ptr - 1) & 3) ? " (points to middle of address)" : "")));
optoffset++;
- opd++;
optlen--;
ptr--; /* ptr is 1-origin */
- flg = *opd;
- proto_tree_add_text(field_tree, NullTVB, offset + optoffset, 1,
- "Overflow: %d", flg >> 4);
+ flg = tvb_get_guint8(tvb, offset + optoffset);
+ proto_tree_add_text(field_tree, tvb, offset + optoffset, 1,
+ "Overflow: %u", flg >> 4);
flg &= 0xF;
- proto_tree_add_text(field_tree, NullTVB, offset + optoffset, 1,
+ proto_tree_add_text(field_tree, tvb, offset + optoffset, 1,
"Flag: %s", val_to_str(flg, flag_vals, "Unknown (0x%x)"));
optoffset++;
- opd++;
optlen--;
while (optlen > 0) {
if (flg == IPOPT_TS_TSANDADDR) {
- /* XXX - check whether it goes past end of packet */
if (optlen < 8) {
- proto_tree_add_text(field_tree, NullTVB, offset + optoffset, optlen,
+ proto_tree_add_text(field_tree, tvb, offset + optoffset, optlen,
"(suboption would go past end of option)");
break;
}
- memcpy((char *)&addr, (char *)opd, sizeof(addr));
- opd += 4;
- ts = pntohl(opd);
- opd += 4;
+ tvb_memcpy(tvb, (char *)&addr, offset + optoffset, sizeof(addr));
+ ts = tvb_get_ntohl(tvb, offset + optoffset + 4);
optlen -= 8;
- proto_tree_add_text(field_tree, NullTVB, offset + optoffset, 8,
+ proto_tree_add_text(field_tree, tvb, offset + optoffset, 8,
"Address = %s, time stamp = %u",
((addr.s_addr == 0) ? "-" : (char *)get_hostname(addr.s_addr)),
ts);
optoffset += 8;
} else {
if (optlen < 4) {
- proto_tree_add_text(field_tree, NullTVB, offset + optoffset, optlen,
+ proto_tree_add_text(field_tree, tvb, offset + optoffset, optlen,
"(suboption would go past end of option)");
break;
}
- /* XXX - check whether it goes past end of packet */
- ts = pntohl(opd);
- opd += 4;
+ ts = tvb_get_ntohl(tvb, offset + optoffset);
optlen -= 4;
- proto_tree_add_text(field_tree, NullTVB, offset + optoffset, 4,
+ proto_tree_add_text(field_tree, tvb, offset + optoffset, 4,
"Time stamp = %u", ts);
optoffset += 4;
}
}
}
+static void
+dissect_ipopt_ra(const ip_tcp_opt *optp, tvbuff_t *tvb, int offset,
+ guint optlen, packet_info *pinfo _U_, proto_tree *opt_tree)
+{
+ /* Router-Alert, as defined by RFC2113 */
+ int opt = tvb_get_ntohs(tvb, offset + 2);
+ static const value_string ra_opts[] = {
+ {0, "Every router examines packet"},
+ {0, NULL}
+ };
+
+ proto_tree_add_text(opt_tree, tvb, offset, optlen,
+ "%s: %s", optp->name, val_to_str(opt, ra_opts, "Unknown (%d)"));
+ return;
+}
+
static const ip_tcp_opt ipopts[] = {
{
IPOPT_END,
VARIABLE_LENGTH,
IPOLEN_TIMESTAMP_MIN,
dissect_ipopt_timestamp
- }
+ },
+ {
+ IPOPT_RA,
+ "Router Alert",
+ NULL,
+ FIXED_LENGTH,
+ IPOLEN_RA,
+ dissect_ipopt_ra
+ },
};
#define N_IP_OPTS (sizeof ipopts / sizeof ipopts[0])
/* Dissect the IP or TCP options in a packet. */
void
-dissect_ip_tcp_options(const u_char *opd, int offset, guint length,
+dissect_ip_tcp_options(tvbuff_t *tvb, int offset, guint length,
const ip_tcp_opt *opttab, int nopts, int eol,
- proto_tree *opt_tree)
+ packet_info *pinfo, proto_tree *opt_tree)
{
u_char opt;
const ip_tcp_opt *optp;
opt_len_type len_type;
- int optlen;
+ unsigned int optlen;
char *name;
char name_str[7+1+1+2+2+1+1]; /* "Unknown (0x%02x)" */
- void (*dissect)(const struct ip_tcp_opt *, const u_char *,
- int, guint, proto_tree *);
+ void (*dissect)(const struct ip_tcp_opt *, tvbuff_t *,
+ int, guint, packet_info *, proto_tree *);
guint len;
while (length > 0) {
- opt = *opd++;
+ opt = tvb_get_guint8(tvb, offset);
for (optp = &opttab[0]; optp < &opttab[nopts]; optp++) {
if (optp->optcode == opt)
break;
if (length == 0) {
/* Bogus - packet must at least include option code byte and
length byte! */
- proto_tree_add_text(opt_tree, NullTVB, offset, 1,
+ proto_tree_add_text(opt_tree, tvb, offset, 1,
"%s (length byte past end of options)", name);
return;
}
- len = *opd++; /* total including type, len */
+ len = tvb_get_guint8(tvb, offset + 1); /* total including type, len */
--length; /* account for length byte */
if (len < 2) {
/* Bogus - option length is too short to include option code and
option length. */
- proto_tree_add_text(opt_tree, NullTVB, offset, 2,
+ proto_tree_add_text(opt_tree, tvb, offset, 2,
"%s (with too-short option length = %u byte%s)", name,
len, plurality(len, "", "s"));
return;
} else if (len - 2 > length) {
/* Bogus - option goes past the end of the header. */
- proto_tree_add_text(opt_tree, NullTVB, offset, length,
+ proto_tree_add_text(opt_tree, tvb, offset, length,
"%s (option length = %u byte%s says option goes past end of options)",
name, len, plurality(len, "", "s"));
return;
} else if (len_type == FIXED_LENGTH && len != optlen) {
/* Bogus - option length isn't what it's supposed to be for this
option. */
- proto_tree_add_text(opt_tree, NullTVB, offset, len,
+ proto_tree_add_text(opt_tree, tvb, offset, len,
"%s (with option length = %u byte%s; should be %u)", name,
len, plurality(len, "", "s"), optlen);
return;
} else if (len_type == VARIABLE_LENGTH && len < optlen) {
/* Bogus - option length is less than what it's supposed to be for
this option. */
- proto_tree_add_text(opt_tree, NullTVB, offset, len,
+ proto_tree_add_text(opt_tree, tvb, offset, len,
"%s (with option length = %u byte%s; should be >= %u)", name,
len, plurality(len, "", "s"), optlen);
return;
} else {
if (optp == NULL) {
- proto_tree_add_text(opt_tree, NullTVB, offset, len, "%s (%u byte%s)",
+ proto_tree_add_text(opt_tree, tvb, offset, len, "%s (%u byte%s)",
name, len, plurality(len, "", "s"));
} else {
if (dissect != NULL) {
/* Option has a dissector. */
- (*dissect)(optp, opd, offset, len, opt_tree);
+ (*dissect)(optp, tvb, offset, len, pinfo, opt_tree);
} else {
/* Option has no data, hence no dissector. */
- proto_tree_add_text(opt_tree, NullTVB, offset, len, "%s", name);
+ proto_tree_add_text(opt_tree, tvb, offset, len, "%s", name);
}
}
len -= 2; /* subtract size of type and length */
offset += 2 + len;
}
- opd += len;
length -= len;
} else {
- proto_tree_add_text(opt_tree, NullTVB, offset, 1, "%s", name);
+ proto_tree_add_text(opt_tree, tvb, offset, 1, "%s", name);
offset += 1;
}
if (opt == eol)
}
}
-static const value_string dscp_vals[] = {
+const value_string dscp_vals[] = {
{ IPDSFIELD_DSCP_DEFAULT, "Default" },
{ IPDSFIELD_DSCP_CS1, "Class Selector 1" },
{ IPDSFIELD_DSCP_CS2, "Class Selector 2" },
"Not set"
};
-static char *ip_checksum_state(e_ip *iph)
+static guint16 ip_checksum(const guint8 *ptr, int len)
{
- unsigned long Sum;
- unsigned char *Ptr, *PtrEnd;
- unsigned short word;
-
- Sum = 0;
- PtrEnd = (lo_nibble(iph->ip_v_hl) * 4 + (char *)iph);
- for (Ptr = (unsigned char *) iph; Ptr < PtrEnd; Ptr += 2) {
- memcpy(&word, Ptr, sizeof word);
- Sum += word;
- }
-
- Sum = (Sum & 0xFFFF) + (Sum >> 16);
- Sum = (Sum & 0xFFFF) + (Sum >> 16);
-
- if (Sum != 0xffff)
- return "incorrect";
+ vec_t cksum_vec[1];
- return "correct";
+ cksum_vec[0].ptr = ptr;
+ cksum_vec[0].len = len;
+ return in_cksum(&cksum_vec[0], 1);
}
-void
-dissect_ip(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
+static void
+dissect_ip(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
+{
e_ip iph;
- proto_tree *ip_tree, *field_tree;
+ proto_tree *ip_tree = NULL, *field_tree;
proto_item *ti, *tf;
- gchar tos_str[32];
+ int offset = 0;
guint hlen, optlen, len;
guint16 flags;
- int advance;
guint8 nxt;
+ guint16 ipsum;
+ fragment_data *ipfd_head;
+ tvbuff_t *next_tvb;
+ gboolean update_col_info = TRUE;
+ gboolean save_fragmented;
- /* To do: check for errs, etc. */
- if (!BYTES_ARE_IN_FRAME(offset, IPH_MIN_LEN)) {
- dissect_data(pd, offset, fd, tree);
- return;
- }
+ if (check_col(pinfo->cinfo, COL_PROTOCOL))
+ col_set_str(pinfo->cinfo, COL_PROTOCOL, "IP");
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_clear(pinfo->cinfo, COL_INFO);
/* Avoids alignment problems on many architectures. */
- memcpy(&iph, &pd[offset], sizeof(e_ip));
+ tvb_memcpy(tvb, (guint8 *)&iph, offset, sizeof(e_ip));
iph.ip_len = ntohs(iph.ip_len);
iph.ip_id = ntohs(iph.ip_id);
iph.ip_off = ntohs(iph.ip_off);
iph.ip_sum = ntohs(iph.ip_sum);
- /* Length of IP datagram plus headers above it. */
- len = iph.ip_len + offset;
+ /* Length of IP datagram.
+ XXX - what if this is greater than the reported length of the
+ tvbuff? This could happen, for example, in an IP datagram
+ inside an ICMP datagram; we need to somehow let the
+ dissector we call know that, as it might want to avoid
+ doing its checksumming. */
+ len = iph.ip_len;
- /* Set the payload and captured-payload lengths to the minima of (the
- IP length plus the length of the headers above it) and the frame
- lengths. */
- if (pi.len > len)
- pi.len = len;
- if (pi.captured_len > len)
- pi.captured_len = len;
+ /* Adjust the length of this tvbuff to include only the IP datagram. */
+ set_actual_length(tvb, len);
- /* XXX - check to make sure this is at least IPH_MIN_LEN. */
hlen = lo_nibble(iph.ip_v_hl) * 4; /* IP header length, in bytes */
-
+
if (tree) {
+ if (ip_summary_in_tree && hlen >= IPH_MIN_LEN) {
+ ti = proto_tree_add_protocol_format(tree, proto_ip, tvb, offset, hlen,
+ "Internet Protocol, Src Addr: %s (%s), Dst Addr: %s (%s)",
+ get_hostname(iph.ip_src), ip_to_str((guint8 *) &iph.ip_src),
+ get_hostname(iph.ip_dst), ip_to_str((guint8 *) &iph.ip_dst));
+ } else {
+ ti = proto_tree_add_item(tree, proto_ip, tvb, offset, hlen, FALSE);
+ }
+ ip_tree = proto_item_add_subtree(ti, ett_ip);
+ }
- switch (IPTOS_TOS(iph.ip_tos)) {
- case IPTOS_NONE:
- strcpy(tos_str, "None");
- break;
- case IPTOS_LOWCOST:
- strcpy(tos_str, "Minimize cost");
- break;
- case IPTOS_RELIABILITY:
- strcpy(tos_str, "Maximize reliability");
- break;
- case IPTOS_THROUGHPUT:
- strcpy(tos_str, "Maximize throughput");
- break;
- case IPTOS_LOWDELAY:
- strcpy(tos_str, "Minimize delay");
- break;
- case IPTOS_SECURITY:
- strcpy(tos_str, "Maximize security");
- break;
- default:
- strcpy(tos_str, "Unknown. Malformed?");
- break;
+ if (hlen < IPH_MIN_LEN) {
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_add_fstr(pinfo->cinfo, COL_INFO, "Bogus IP header length (%u, must be at least %u)",
+ hlen, IPH_MIN_LEN);
+ if (tree) {
+ proto_tree_add_uint_format(ip_tree, hf_ip_hdr_len, tvb, offset, 1, hlen,
+ "Header length: %u bytes (bogus, must be at least %u)", hlen,
+ IPH_MIN_LEN);
}
+ return;
+ }
- ti = proto_tree_add_item(tree, proto_ip, NullTVB, offset, hlen, NULL);
- ip_tree = proto_item_add_subtree(ti, ett_ip);
+ /*
+ * Compute the checksum of the IP header.
+ */
+ ipsum = ip_checksum(tvb_get_ptr(tvb, offset, hlen), hlen);
- proto_tree_add_item(ip_tree, hf_ip_version, NullTVB, offset, 1, hi_nibble(iph.ip_v_hl));
- proto_tree_add_uint_format(ip_tree, hf_ip_hdr_len, NullTVB, offset, 1, hlen,
+ if (tree) {
+ proto_tree_add_uint(ip_tree, hf_ip_version, tvb, offset, 1, hi_nibble(iph.ip_v_hl));
+ proto_tree_add_uint_format(ip_tree, hf_ip_hdr_len, tvb, offset, 1, hlen,
"Header length: %u bytes", hlen);
if (g_ip_dscp_actif) {
- tf = proto_tree_add_uint_format(ip_tree, hf_ip_dsfield, NullTVB, offset + 1, 1, iph.ip_tos,
- "Differentiated Services Field: 0x%02x (DSCP 0x%02x: %s)", iph.ip_tos,
+ tf = proto_tree_add_uint_format(ip_tree, hf_ip_dsfield, tvb, offset + 1, 1, iph.ip_tos,
+ "Differentiated Services Field: 0x%02x (DSCP 0x%02x: %s; ECN: 0x%02x)", iph.ip_tos,
IPDSFIELD_DSCP(iph.ip_tos), val_to_str(IPDSFIELD_DSCP(iph.ip_tos), dscp_vals,
- "Unknown DSCP"));
+ "Unknown DSCP"),IPDSFIELD_ECN(iph.ip_tos));
field_tree = proto_item_add_subtree(tf, ett_ip_dsfield);
- proto_tree_add_item(field_tree, hf_ip_dsfield_dscp, NullTVB, offset + 1, 1, iph.ip_tos);
- proto_tree_add_item(field_tree, hf_ip_dsfield_cu, NullTVB, offset + 1, 1, iph.ip_tos);
+ proto_tree_add_uint(field_tree, hf_ip_dsfield_dscp, tvb, offset + 1, 1, iph.ip_tos);
+ proto_tree_add_uint(field_tree, hf_ip_dsfield_ect, tvb, offset + 1, 1, iph.ip_tos);
+ proto_tree_add_uint(field_tree, hf_ip_dsfield_ce, tvb, offset + 1, 1, iph.ip_tos);
} else {
- tf = proto_tree_add_uint_format(ip_tree, hf_ip_tos, NullTVB, offset + 1, 1, iph.ip_tos,
+ tf = proto_tree_add_uint_format(ip_tree, hf_ip_tos, tvb, offset + 1, 1, iph.ip_tos,
"Type of service: 0x%02x (%s)", iph.ip_tos,
val_to_str( IPTOS_TOS(iph.ip_tos), iptos_vals, "Unknown") );
field_tree = proto_item_add_subtree(tf, ett_ip_tos);
- proto_tree_add_item(field_tree, hf_ip_tos_precedence, NullTVB, offset + 1, 1, iph.ip_tos);
- proto_tree_add_item(field_tree, hf_ip_tos_delay, NullTVB, offset + 1, 1, iph.ip_tos);
- proto_tree_add_item(field_tree, hf_ip_tos_throughput, NullTVB, offset + 1, 1, iph.ip_tos);
- proto_tree_add_item(field_tree, hf_ip_tos_reliability, NullTVB, offset + 1, 1, iph.ip_tos);
- proto_tree_add_item(field_tree, hf_ip_tos_cost, NullTVB, offset + 1, 1, iph.ip_tos);
+ proto_tree_add_uint(field_tree, hf_ip_tos_precedence, tvb, offset + 1, 1, iph.ip_tos);
+ proto_tree_add_boolean(field_tree, hf_ip_tos_delay, tvb, offset + 1, 1, iph.ip_tos);
+ proto_tree_add_boolean(field_tree, hf_ip_tos_throughput, tvb, offset + 1, 1, iph.ip_tos);
+ proto_tree_add_boolean(field_tree, hf_ip_tos_reliability, tvb, offset + 1, 1, iph.ip_tos);
+ proto_tree_add_boolean(field_tree, hf_ip_tos_cost, tvb, offset + 1, 1, iph.ip_tos);
}
- proto_tree_add_item(ip_tree, hf_ip_len, NullTVB, offset + 2, 2, iph.ip_len);
- proto_tree_add_item(ip_tree, hf_ip_id, NullTVB, offset + 4, 2, iph.ip_id);
+ proto_tree_add_uint(ip_tree, hf_ip_len, tvb, offset + 2, 2, iph.ip_len);
+ proto_tree_add_uint(ip_tree, hf_ip_id, tvb, offset + 4, 2, iph.ip_id);
flags = (iph.ip_off & (IP_DF|IP_MF)) >> 12;
- tf = proto_tree_add_item(ip_tree, hf_ip_flags, NullTVB, offset + 6, 1, flags);
+ tf = proto_tree_add_uint(ip_tree, hf_ip_flags, tvb, offset + 6, 1, flags);
field_tree = proto_item_add_subtree(tf, ett_ip_off);
- proto_tree_add_item(field_tree, hf_ip_flags_df, NullTVB, offset + 6, 1, flags),
- proto_tree_add_item(field_tree, hf_ip_flags_mf, NullTVB, offset + 6, 1, flags),
+ proto_tree_add_boolean(field_tree, hf_ip_flags_df, tvb, offset + 6, 1, flags),
+ proto_tree_add_boolean(field_tree, hf_ip_flags_mf, tvb, offset + 6, 1, flags),
- proto_tree_add_item(ip_tree, hf_ip_frag_offset, NullTVB, offset + 6, 2,
+ proto_tree_add_uint(ip_tree, hf_ip_frag_offset, tvb, offset + 6, 2,
(iph.ip_off & IP_OFFSET)*8);
- proto_tree_add_item(ip_tree, hf_ip_ttl, NullTVB, offset + 8, 1, iph.ip_ttl);
- proto_tree_add_uint_format(ip_tree, hf_ip_proto, NullTVB, offset + 9, 1, iph.ip_p,
+
+ proto_tree_add_uint(ip_tree, hf_ip_ttl, tvb, offset + 8, 1, iph.ip_ttl);
+ proto_tree_add_uint_format(ip_tree, hf_ip_proto, tvb, offset + 9, 1, iph.ip_p,
"Protocol: %s (0x%02x)", ipprotostr(iph.ip_p), iph.ip_p);
- proto_tree_add_uint_format(ip_tree, hf_ip_checksum, NullTVB, offset + 10, 2, iph.ip_sum,
- "Header checksum: 0x%04x (%s)", iph.ip_sum, ip_checksum_state((e_ip*) &pd[offset]));
- proto_tree_add_item(ip_tree, hf_ip_src, NullTVB, offset + 12, 4, iph.ip_src);
- proto_tree_add_item(ip_tree, hf_ip_dst, NullTVB, offset + 16, 4, iph.ip_dst);
- proto_tree_add_item_hidden(ip_tree, hf_ip_addr, NullTVB, offset + 12, 4, iph.ip_src);
- proto_tree_add_item_hidden(ip_tree, hf_ip_addr, NullTVB, offset + 16, 4, iph.ip_dst);
+
+ if (ipsum == 0) {
+ proto_tree_add_uint_format(ip_tree, hf_ip_checksum, tvb, offset + 10, 2, iph.ip_sum,
+ "Header checksum: 0x%04x (correct)", iph.ip_sum);
+ }
+ else {
+ proto_tree_add_boolean_hidden(ip_tree, hf_ip_checksum_bad, tvb, offset + 10, 2, TRUE);
+ proto_tree_add_uint_format(ip_tree, hf_ip_checksum, tvb, offset + 10, 2, iph.ip_sum,
+ "Header checksum: 0x%04x (incorrect, should be 0x%04x)", iph.ip_sum,
+ in_cksum_shouldbe(iph.ip_sum, ipsum));
+ }
+
+ proto_tree_add_ipv4(ip_tree, hf_ip_src, tvb, offset + 12, 4, iph.ip_src);
+ proto_tree_add_ipv4(ip_tree, hf_ip_dst, tvb, offset + 16, 4, iph.ip_dst);
+ proto_tree_add_ipv4_hidden(ip_tree, hf_ip_addr, tvb, offset + 12, 4, iph.ip_src);
+ proto_tree_add_ipv4_hidden(ip_tree, hf_ip_addr, tvb, offset + 16, 4, iph.ip_dst);
/* Decode IP options, if any. */
if (hlen > sizeof (e_ip)) {
/* There's more than just the fixed-length header. Decode the
options. */
optlen = hlen - sizeof (e_ip); /* length of options, in bytes */
- tf = proto_tree_add_text(ip_tree, NullTVB, offset + 20, optlen,
+ tf = proto_tree_add_text(ip_tree, tvb, offset + 20, optlen,
"Options: (%u bytes)", optlen);
field_tree = proto_item_add_subtree(tf, ett_ip_options);
- dissect_ip_tcp_options(&pd[offset + 20], offset + 20, optlen,
- ipopts, N_IP_OPTS, IPOPT_END, field_tree);
+ dissect_ip_tcp_options(tvb, offset + 20, optlen,
+ ipopts, N_IP_OPTS, IPOPT_END, pinfo, field_tree);
}
}
- pi.ipproto = iph.ip_p;
- pi.iplen = iph.ip_len;
- pi.iphdrlen = lo_nibble(iph.ip_v_hl);
- SET_ADDRESS(&pi.net_src, AT_IPv4, 4, &pd[offset + IPH_SRC]);
- SET_ADDRESS(&pi.src, AT_IPv4, 4, &pd[offset + IPH_SRC]);
- SET_ADDRESS(&pi.net_dst, AT_IPv4, 4, &pd[offset + IPH_DST]);
- SET_ADDRESS(&pi.dst, AT_IPv4, 4, &pd[offset + IPH_DST]);
+ pinfo->ipproto = iph.ip_p;
+
+ pinfo->iplen = iph.ip_len;
+
+ pinfo->iphdrlen = lo_nibble(iph.ip_v_hl);
+
+ SET_ADDRESS(&pinfo->net_src, AT_IPv4, 4, tvb_get_ptr(tvb, offset + IPH_SRC, 4));
+ SET_ADDRESS(&pinfo->src, AT_IPv4, 4, tvb_get_ptr(tvb, offset + IPH_SRC, 4));
+ SET_ADDRESS(&pinfo->net_dst, AT_IPv4, 4, tvb_get_ptr(tvb, offset + IPH_DST, 4));
+ SET_ADDRESS(&pinfo->dst, AT_IPv4, 4, tvb_get_ptr(tvb, offset + IPH_DST, 4));
/* Skip over header + options */
offset += hlen;
- nxt = iph.ip_p;
- if (iph.ip_off & IP_OFFSET) {
- /* fragmented */
- if (check_col(fd, COL_PROTOCOL))
- col_add_str(fd, COL_PROTOCOL, "IP");
- if (check_col(fd, COL_INFO))
- col_add_fstr(fd, COL_INFO, "Fragmented IP protocol (proto=%s 0x%02x, off=%u)",
+ nxt = iph.ip_p; /* XXX - what if this isn't the same for all fragments? */
+
+ /* If ip_defragment is on, this is a fragment, we have all the data
+ * in the fragment, and the header checksum is valid, then just add
+ * the fragment to the hashtable.
+ */
+ save_fragmented = pinfo->fragmented;
+ if (ip_defragment && (iph.ip_off & (IP_MF|IP_OFFSET)) &&
+ tvb_reported_length(tvb) <= tvb_length(tvb) && ipsum == 0) {
+ ipfd_head = fragment_add(tvb, offset, pinfo, iph.ip_id,
+ ip_fragment_table,
+ (iph.ip_off & IP_OFFSET)*8,
+ pinfo->iplen - (pinfo->iphdrlen*4),
+ iph.ip_off & IP_MF);
+
+ if (ipfd_head != NULL) {
+ fragment_data *ipfd;
+ proto_tree *ft=NULL;
+ proto_item *fi=NULL;
+
+ /* OK, we have the complete reassembled payload.
+ Allocate a new tvbuff, referring to the reassembled payload. */
+ next_tvb = tvb_new_real_data(ipfd_head->data, ipfd_head->datalen,
+ ipfd_head->datalen);
+
+ /* Add the tvbuff to the list of tvbuffs to which the tvbuff we
+ were handed refers, so it'll get cleaned up when that tvbuff
+ is cleaned up. */
+ tvb_set_child_real_data_tvbuff(tvb, next_tvb);
+
+ /* Add the defragmented data to the data source list. */
+ add_new_data_source(pinfo->fd, next_tvb, "Reassembled IPv4");
+
+ /* It's not fragmented. */
+ pinfo->fragmented = FALSE;
+
+ /* show all fragments */
+ fi = proto_tree_add_item(ip_tree, hf_ip_fragments,
+ next_tvb, 0, -1, FALSE);
+ ft = proto_item_add_subtree(fi, ett_ip_fragments);
+ for (ipfd=ipfd_head->next; ipfd; ipfd=ipfd->next){
+ if (ipfd->flags & (FD_OVERLAP|FD_OVERLAPCONFLICT
+ |FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) {
+ /* this fragment has some flags set, create a subtree
+ * for it and display the flags.
+ */
+ proto_tree *fet=NULL;
+ proto_item *fei=NULL;
+ int hf;
+
+ if (ipfd->flags & (FD_OVERLAPCONFLICT
+ |FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) {
+ hf = hf_ip_fragment_error;
+ } else {
+ hf = hf_ip_fragment;
+ }
+ fei = proto_tree_add_none_format(ft, hf,
+ next_tvb, ipfd->offset, ipfd->len,
+ "Frame:%u payload:%u-%u",
+ ipfd->frame,
+ ipfd->offset,
+ ipfd->offset+ipfd->len-1
+ );
+ fet = proto_item_add_subtree(fei, ett_ip_fragment);
+ if (ipfd->flags&FD_OVERLAP) {
+ proto_tree_add_boolean(fet,
+ hf_ip_fragment_overlap, next_tvb, 0, 0,
+ TRUE);
+ }
+ if (ipfd->flags&FD_OVERLAPCONFLICT) {
+ proto_tree_add_boolean(fet,
+ hf_ip_fragment_overlap_conflict, next_tvb, 0, 0,
+ TRUE);
+ }
+ if (ipfd->flags&FD_MULTIPLETAILS) {
+ proto_tree_add_boolean(fet,
+ hf_ip_fragment_multiple_tails, next_tvb, 0, 0,
+ TRUE);
+ }
+ if (ipfd->flags&FD_TOOLONGFRAGMENT) {
+ proto_tree_add_boolean(fet,
+ hf_ip_fragment_too_long_fragment, next_tvb, 0, 0,
+ TRUE);
+ }
+ } else {
+ /* nothing of interest for this fragment */
+ proto_tree_add_none_format(ft, hf_ip_fragment,
+ next_tvb, ipfd->offset, ipfd->len,
+ "Frame:%u payload:%u-%u",
+ ipfd->frame,
+ ipfd->offset,
+ ipfd->offset+ipfd->len-1
+ );
+ }
+ }
+ if (ipfd_head->flags & (FD_OVERLAPCONFLICT
+ |FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) {
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_set_str(pinfo->cinfo, COL_INFO, "[Illegal fragments]");
+ update_col_info = FALSE;
+ }
+ }
+ } else {
+ /* We don't have the complete reassembled payload. */
+ next_tvb = NULL;
+ }
+ } else {
+ /* If this is the first fragment, dissect its contents, otherwise
+ just show it as a fragment.
+
+ XXX - if we eventually don't save the reassembled contents of all
+ fragmented datagrams, we may want to always reassemble. */
+ if (iph.ip_off & IP_OFFSET) {
+ /* Not the first fragment - don't dissect it. */
+ next_tvb = NULL;
+ } else {
+ /* First fragment, or not fragmented. Dissect what we have here. */
+
+ /* Get a tvbuff for the payload. */
+ next_tvb = tvb_new_subset(tvb, offset, -1, -1);
+
+ /*
+ * If this is the first fragment, but not the only fragment,
+ * tell the next protocol that.
+ */
+ if (iph.ip_off & IP_MF)
+ pinfo->fragmented = TRUE;
+ else
+ pinfo->fragmented = FALSE;
+ }
+ }
+
+ if (next_tvb == NULL) {
+ /* Just show this as a fragment. */
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_add_fstr(pinfo->cinfo, COL_INFO, "Fragmented IP protocol (proto=%s 0x%02x, off=%u)",
ipprotostr(iph.ip_p), iph.ip_p, (iph.ip_off & IP_OFFSET) * 8);
- dissect_data(pd, offset, fd, tree);
+ call_dissector(data_handle,tvb_new_subset(tvb, offset,-1,tvb_reported_length_remaining(tvb,offset)), pinfo, tree);
+ pinfo->fragmented = save_fragmented;
return;
}
-again:
- switch (nxt) {
- case IP_PROTO_AH:
- advance = dissect_ah(pd, offset, fd, tree);
- nxt = pd[offset];
- offset += advance;
- goto again;
- }
+ /* Hand off to the next protocol.
- /* do lookup with the subdissector table */
- if (!dissector_try_port(ip_dissector_table, nxt, pd, offset, fd, tree)) {
+ XXX - setting the columns only after trying various dissectors means
+ that if one of those dissectors throws an exception, the frame won't
+ even be labelled as an IP frame; ideally, if a frame being dissected
+ throws an exception, it'll be labelled as a mangled frame of the
+ type in question. */
+ if (!dissector_try_port(ip_dissector_table, nxt, next_tvb, pinfo, tree)) {
/* Unknown protocol */
- if (check_col(fd, COL_PROTOCOL))
- col_add_str(fd, COL_PROTOCOL, "IP");
- if (check_col(fd, COL_INFO))
- col_add_fstr(fd, COL_INFO, "%s (0x%02x)", ipprotostr(iph.ip_p), iph.ip_p);
- dissect_data(pd, offset, fd, tree);
+ if (update_col_info) {
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_add_fstr(pinfo->cinfo, COL_INFO, "%s (0x%02x)", ipprotostr(iph.ip_p), iph.ip_p);
+ }
+ call_dissector(data_handle,next_tvb, pinfo, tree);
}
+ pinfo->fragmented = save_fragmented;
}
+#define ICMP_MIP_EXTENSION_PAD 0
+#define ICMP_MIP_MOB_AGENT_ADV 16
+#define ICMP_MIP_PREFIX_LENGTHS 19
+#define ICMP_MIP_CHALLENGE 24
+
+static value_string mip_extensions[] = {
+ { ICMP_MIP_EXTENSION_PAD, "One byte padding extension"}, /* RFC 2002 */
+ { ICMP_MIP_MOB_AGENT_ADV, "Mobility Agent Advertisement Extension"},
+ /* RFC 2002 */
+ { ICMP_MIP_PREFIX_LENGTHS, "Prefix Lengths Extension"}, /* RFC 2002 */
+ { ICMP_MIP_CHALLENGE, "Challenge Extension"}, /* RFC 3012 */
+ { 0, NULL}
+};
+
+/*
+ * Dissect the mobile ip advertisement extensions.
+ */
+static void
+dissect_mip_extensions(tvbuff_t *tvb, size_t offset, proto_tree *tree)
+{
+ guint8 type;
+ guint8 length;
+ guint8 flags;
+ proto_item *ti;
+ proto_tree *mip_tree=NULL;
+ proto_tree *flags_tree=NULL;
+ gint numCOAs;
+ gint i;
+
+ /* Not much to do if we're not parsing everything */
+ if (!tree) return;
+
+ while (tvb_reported_length_remaining(tvb, offset) > 0) {
+
+ type = tvb_get_guint8(tvb, offset + 0);
+ if (type)
+ length = tvb_get_guint8(tvb, offset + 1);
+ else
+ length=0;
+
+ ti = proto_tree_add_text(tree, tvb, offset,
+ type?(length + 2):1,
+ "Ext: %s",
+ val_to_str(type, mip_extensions,
+ "Unknown ext %u"));
+ mip_tree = proto_item_add_subtree(ti, ett_icmp_mip);
+
+
+ switch (type) {
+ case ICMP_MIP_EXTENSION_PAD:
+ /* One byte padding extension */
+ /* Add our fields */
+ /* type */
+ proto_tree_add_item(mip_tree, hf_icmp_mip_type, tvb, offset,
+ 1, FALSE);
+ offset++;
+ break;
+ case ICMP_MIP_MOB_AGENT_ADV:
+ /* Mobility Agent Advertisement Extension (RFC 2002)*/
+ /* Add our fields */
+ /* type */
+ proto_tree_add_item(mip_tree, hf_icmp_mip_type, tvb, offset,
+ 1, FALSE);
+ offset++;
+ /* length */
+ proto_tree_add_item(mip_tree, hf_icmp_mip_length, tvb, offset,
+ 1, FALSE);
+ offset++;
+ /* sequence number */
+ proto_tree_add_item(mip_tree, hf_icmp_mip_seq, tvb, offset,
+ 2, FALSE);
+ offset+=2;
+ /* Registration Lifetime */
+ proto_tree_add_item(mip_tree, hf_icmp_mip_life, tvb, offset,
+ 2, FALSE);
+ offset+=2;
+ /* flags */
+ flags = tvb_get_guint8(tvb, offset);
+ ti = proto_tree_add_item(mip_tree, hf_icmp_mip_flags, tvb, offset,
+ 1, FALSE);
+ flags_tree = proto_item_add_subtree(ti, ett_icmp_mip_flags);
+ proto_tree_add_boolean(flags_tree, hf_icmp_mip_r, tvb, offset, 1, flags);
+ proto_tree_add_boolean(flags_tree, hf_icmp_mip_b, tvb, offset, 1, flags);
+ proto_tree_add_boolean(flags_tree, hf_icmp_mip_h, tvb, offset, 1, flags);
+ proto_tree_add_boolean(flags_tree, hf_icmp_mip_f, tvb, offset, 1, flags);
+ proto_tree_add_boolean(flags_tree, hf_icmp_mip_m, tvb, offset, 1, flags);
+ proto_tree_add_boolean(flags_tree, hf_icmp_mip_g, tvb, offset, 1, flags);
+ proto_tree_add_boolean(flags_tree, hf_icmp_mip_v, tvb, offset, 1, flags);
+ proto_tree_add_boolean(flags_tree, hf_icmp_mip_res, tvb, offset, 1, flags);
+ offset++;
+
+ /* Reserved */
+ proto_tree_add_item(mip_tree, hf_icmp_mip_reserved, tvb, offset,
+ 1, FALSE);
+ offset++;
+
+ /* COAs */
+ numCOAs = (length - 6) / 4;
+ for (i=0; i<numCOAs; i++) {
+ proto_tree_add_item(mip_tree, hf_icmp_mip_coa, tvb, offset,
+ 4, FALSE);
+ offset+=4;
+ }
+ break;
+ case ICMP_MIP_PREFIX_LENGTHS:
+ /* Prefix-Lengths Extension (RFC 2002)*/
+ /* Add our fields */
+ /* type */
+ proto_tree_add_item(mip_tree, hf_icmp_mip_type, tvb, offset,
+ 1, FALSE);
+ offset++;
+ /* length */
+ proto_tree_add_item(mip_tree, hf_icmp_mip_length, tvb, offset,
+ 1, FALSE);
+ offset++;
+
+ /* prefix lengths */
+ for(i=0; i<length; i++) {
+ proto_tree_add_item(mip_tree, hf_icmp_mip_prefix_length, tvb, offset,
+ 1, FALSE);
+ offset++;
+ }
+ break;
+ case ICMP_MIP_CHALLENGE:
+ /* Challenge Extension (RFC 3012)*/
+ /* type */
+ proto_tree_add_item(mip_tree, hf_icmp_mip_type, tvb, offset,
+ 1, FALSE);
+ offset++;
+ /* length */
+ proto_tree_add_item(mip_tree, hf_icmp_mip_length, tvb, offset,
+ 1, FALSE);
+ offset++;
+ /* challenge */
+ proto_tree_add_item(mip_tree, hf_icmp_mip_challenge, tvb, offset,
+ length, FALSE);
+ offset+=length;
+
+ break;
+ default:
+ g_warning("Unknown type(%u)! I hope the length is right (%u)",
+ type, length);
+ offset += length;
+ break;
+ } /* switch type */
+ } /* end while */
+
+} /* dissect_mip_extensions */
static const gchar *unreach_str[] = {"Network unreachable",
"Host unreachable",
#define N_PARAMPROB (sizeof par_str / sizeof par_str[0])
+/*
+ * RFC 792 for basic ICMP.
+ * RFC 1191 for ICMP_FRAG_NEEDED (with MTU of next hop).
+ * RFC 1256 for router discovery messages.
+ * RFC 2002 and 3012 for Mobile IP stuff.
+ */
static void
-dissect_icmp(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
- e_icmp ih;
+dissect_icmp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
+{
proto_tree *icmp_tree;
proto_item *ti;
- guint16 cksum;
+ guint8 icmp_type;
+ guint8 icmp_code;
+ guint length, reported_length;
+ guint16 cksum, computed_cksum;
gchar type_str[64], code_str[64] = "";
guint8 num_addrs = 0;
guint8 addr_entry_size = 0;
int i;
+ volatile address save_dl_src;
+ volatile address save_dl_dst;
+ volatile address save_net_src;
+ volatile address save_net_dst;
+ volatile address save_src;
+ volatile address save_dst;
+ gboolean save_in_error_pkt;
+ tvbuff_t *next_tvb;
+
+ if (check_col(pinfo->cinfo, COL_PROTOCOL))
+ col_set_str(pinfo->cinfo, COL_PROTOCOL, "ICMP");
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_clear(pinfo->cinfo, COL_INFO);
- /* Avoids alignment problems on many architectures. */
- memcpy(&ih, &pd[offset], sizeof(e_icmp));
/* To do: check for runts, errs, etc. */
- cksum = ntohs(ih.icmp_cksum);
-
- switch (ih.icmp_type) {
+ icmp_type = tvb_get_guint8(tvb, 0);
+ icmp_code = tvb_get_guint8(tvb, 1);
+ cksum = tvb_get_ntohs(tvb, 2);
+
+ switch (icmp_type) {
case ICMP_ECHOREPLY:
strcpy(type_str, "Echo (ping) reply");
break;
case ICMP_UNREACH:
strcpy(type_str, "Destination unreachable");
- if (ih.icmp_code < N_UNREACH) {
- sprintf(code_str, "(%s)", unreach_str[ih.icmp_code]);
+ if (icmp_code < N_UNREACH) {
+ sprintf(code_str, "(%s)", unreach_str[icmp_code]);
} else {
strcpy(code_str, "(Unknown - error?)");
}
break;
case ICMP_REDIRECT:
strcpy(type_str, "Redirect");
- if (ih.icmp_code < N_REDIRECT) {
- sprintf(code_str, "(%s)", redir_str[ih.icmp_code]);
+ if (icmp_code < N_REDIRECT) {
+ sprintf(code_str, "(%s)", redir_str[icmp_code]);
} else {
strcpy(code_str, "(Unknown - error?)");
}
strcpy(type_str, "Echo (ping) request");
break;
case ICMP_RTRADVERT:
- strcpy(type_str, "Router advertisement");
+ switch (icmp_code) {
+ case 16: /* Mobile-Ip */
+ strcpy(type_str, "Mobile IP Advertisement");
+ break;
+ default:
+ strcpy(type_str, "Router advertisement");
+ break;
+ } /* switch icmp_code */
break;
case ICMP_RTRSOLICIT:
strcpy(type_str, "Router solicitation");
break;
case ICMP_TIMXCEED:
strcpy(type_str, "Time-to-live exceeded");
- if (ih.icmp_code < N_TIMXCEED) {
- sprintf(code_str, "(%s)", ttl_str[ih.icmp_code]);
+ if (icmp_code < N_TIMXCEED) {
+ sprintf(code_str, "(%s)", ttl_str[icmp_code]);
} else {
strcpy(code_str, "(Unknown - error?)");
}
break;
case ICMP_PARAMPROB:
strcpy(type_str, "Parameter problem");
- if (ih.icmp_code < N_PARAMPROB) {
- sprintf(code_str, "(%s)", par_str[ih.icmp_code]);
+ if (icmp_code < N_PARAMPROB) {
+ sprintf(code_str, "(%s)", par_str[icmp_code]);
} else {
strcpy(code_str, "(Unknown - error?)");
}
break;
default:
strcpy(type_str, "Unknown ICMP (obsolete or malformed?)");
+ break;
}
- if (check_col(fd, COL_PROTOCOL))
- col_add_str(fd, COL_PROTOCOL, "ICMP");
- if (check_col(fd, COL_INFO))
- col_add_str(fd, COL_INFO, type_str);
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_add_str(pinfo->cinfo, COL_INFO, type_str);
if (tree) {
- ti = proto_tree_add_item(tree, proto_icmp, NullTVB, offset, 4, NULL);
+ length = tvb_length(tvb);
+ reported_length = tvb_reported_length(tvb);
+ ti = proto_tree_add_item(tree, proto_icmp, tvb, 0, length, FALSE);
icmp_tree = proto_item_add_subtree(ti, ett_icmp);
- proto_tree_add_uint_format(icmp_tree, hf_icmp_type, NullTVB, offset, 1,
- ih.icmp_type,
+ proto_tree_add_uint_format(icmp_tree, hf_icmp_type, tvb, 0, 1,
+ icmp_type,
"Type: %u (%s)",
- ih.icmp_type, type_str);
- proto_tree_add_uint_format(icmp_tree, hf_icmp_code, NullTVB, offset + 1, 1,
- ih.icmp_code,
+ icmp_type, type_str);
+ proto_tree_add_uint_format(icmp_tree, hf_icmp_code, tvb, 1, 1,
+ icmp_code,
"Code: %u %s",
- ih.icmp_code, code_str);
- proto_tree_add_item(icmp_tree, hf_icmp_checksum, NullTVB, offset + 2, 2,
- cksum);
+ icmp_code, code_str);
+
+ if (!pinfo->fragmented && length >= reported_length) {
+ /* The packet isn't part of a fragmented datagram and isn't
+ truncated, so we can checksum it. */
+
+ computed_cksum = ip_checksum(tvb_get_ptr(tvb, 0, reported_length),
+ reported_length);
+ if (computed_cksum == 0) {
+ proto_tree_add_uint_format(icmp_tree, hf_icmp_checksum, tvb, 2, 2,
+ cksum,
+ "Checksum: 0x%04x (correct)", cksum);
+ } else {
+ proto_tree_add_boolean_hidden(icmp_tree, hf_icmp_checksum_bad,
+ tvb, 2, 2, TRUE);
+ proto_tree_add_uint_format(icmp_tree, hf_icmp_checksum, tvb, 2, 2,
+ cksum,
+ "Checksum: 0x%04x (incorrect, should be 0x%04x)",
+ cksum, in_cksum_shouldbe(cksum, computed_cksum));
+ }
+ } else {
+ proto_tree_add_uint(icmp_tree, hf_icmp_checksum, tvb, 2, 2, cksum);
+ }
/* Decode the second 4 bytes of the packet. */
- switch (ih.icmp_type) {
+ switch (icmp_type) {
case ICMP_ECHOREPLY:
case ICMP_ECHO:
case ICMP_TSTAMP:
case ICMP_IREQREPLY:
case ICMP_MASKREQ:
case ICMP_MASKREPLY:
- proto_tree_add_text(icmp_tree, NullTVB, offset + 4, 2, "Identifier: 0x%04x",
- pntohs(&pd[offset + 4]));
- proto_tree_add_text(icmp_tree, NullTVB, offset + 6, 2, "Sequence number: %u",
- pntohs(&pd[offset + 6]));
+ proto_tree_add_text(icmp_tree, tvb, 4, 2, "Identifier: 0x%04x",
+ tvb_get_ntohs(tvb, 4));
+ proto_tree_add_text(icmp_tree, tvb, 6, 2, "Sequence number: %02x:%02x",
+ tvb_get_guint8(tvb, 6), tvb_get_guint8(tvb, 7));
break;
- case ICMP_UNREACH:
- switch (ih.icmp_code) {
- case ICMP_FRAG_NEEDED:
- proto_tree_add_text(icmp_tree, NullTVB, offset + 6, 2, "MTU of next hop: %u",
- pntohs(&pd[offset + 6]));
- break;
- }
- break;
+ case ICMP_UNREACH:
+ switch (icmp_code) {
+ case ICMP_FRAG_NEEDED:
+ proto_tree_add_text(icmp_tree, tvb, 6, 2, "MTU of next hop: %u",
+ tvb_get_ntohs(tvb, 6));
+ break;
+ }
+ break;
case ICMP_RTRADVERT:
- num_addrs = pd[offset + 4];
- proto_tree_add_text(icmp_tree, NullTVB, offset + 4, 1, "Number of addresses: %u",
+ num_addrs = tvb_get_guint8(tvb, 4);
+ proto_tree_add_text(icmp_tree, tvb, 4, 1, "Number of addresses: %u",
num_addrs);
- addr_entry_size = pd[offset + 5];
- proto_tree_add_text(icmp_tree, NullTVB, offset + 5, 1, "Address entry size: %u",
+ addr_entry_size = tvb_get_guint8(tvb, 5);
+ proto_tree_add_text(icmp_tree, tvb, 5, 1, "Address entry size: %u",
addr_entry_size);
- proto_tree_add_text(icmp_tree, NullTVB, offset + 6, 2, "Lifetime: %s",
- time_secs_to_str(pntohs(&pd[offset + 6])));
+ proto_tree_add_text(icmp_tree, tvb, 6, 2, "Lifetime: %s",
+ time_secs_to_str(tvb_get_ntohs(tvb, 6)));
break;
case ICMP_PARAMPROB:
- proto_tree_add_text(icmp_tree, NullTVB, offset + 4, 1, "Pointer: %u",
- pd[offset + 4]);
+ proto_tree_add_text(icmp_tree, tvb, 4, 1, "Pointer: %u",
+ tvb_get_guint8(tvb, 4));
break;
case ICMP_REDIRECT:
- proto_tree_add_text(icmp_tree, NullTVB, offset + 4, 4, "Gateway address: %s",
- ip_to_str((guint8 *)&pd[offset + 4]));
+ proto_tree_add_text(icmp_tree, tvb, 4, 4, "Gateway address: %s",
+ ip_to_str(tvb_get_ptr(tvb, 4, 4)));
break;
}
/* Decode the additional information in the packet. */
- switch (ih.icmp_type) {
+ switch (icmp_type) {
case ICMP_UNREACH:
case ICMP_TIMXCEED:
case ICMP_PARAMPROB:
/* Decode the IP header and first 64 bits of data from the
original datagram.
- XXX - for now, just display it as data; not all dissection
- routines can handle a short packet without exploding. */
- dissect_data(pd, offset + 8, fd, icmp_tree);
+ Set the columns non-writable, so that the packet list
+ shows this as an ICMP packet, not as the type of packet
+ for which the ICMP packet was generated. */
+ col_set_writable(pinfo->cinfo, FALSE);
+
+ /* Also, save the current values of the addresses, and restore
+ them when we're finished dissecting the contained packet, so
+ that the address columns in the summary don't reflect the
+ contained packet, but reflect this packet instead. */
+ save_dl_src = pinfo->dl_src;
+ save_dl_dst = pinfo->dl_dst;
+ save_net_src = pinfo->net_src;
+ save_net_dst = pinfo->net_dst;
+ save_src = pinfo->src;
+ save_dst = pinfo->dst;
+
+ /* Save the current value of the "we're inside an error packet"
+ flag, and set that flag; subdissectors may treat packets
+ that are the payload of error packets differently from
+ "real" packets. */
+ save_in_error_pkt = pinfo->in_error_pkt;
+ pinfo->in_error_pkt = TRUE;
+
+ /* Dissect the contained packet.
+ Catch ReportedBoundsError, and do nothing if we see it,
+ because it's not an error if the contained packet is short;
+ there's no guarantee that all of it was included.
+
+ XXX - should catch BoundsError, and re-throw it after cleaning
+ up. */
+ next_tvb = tvb_new_subset(tvb, 8, -1, -1);
+ TRY {
+ call_dissector(ip_handle, next_tvb, pinfo, icmp_tree);
+ }
+ CATCH(ReportedBoundsError) {
+ ; /* do nothing */
+ }
+ ENDTRY;
+
+ /* Restore the "we're inside an error packet" flag. */
+ pinfo->in_error_pkt = save_in_error_pkt;
+
+ /* Restore the addresses. */
+ pinfo->dl_src = save_dl_src;
+ pinfo->dl_dst = save_dl_dst;
+ pinfo->net_src = save_net_src;
+ pinfo->net_dst = save_net_dst;
+ pinfo->src = save_src;
+ pinfo->dst = save_dst;
break;
case ICMP_ECHOREPLY:
case ICMP_ECHO:
- dissect_data(pd, offset + 8, fd, icmp_tree);
+ call_dissector(data_handle,tvb_new_subset(tvb, 8,-1,tvb_reported_length_remaining(tvb,8)), pinfo, icmp_tree);
break;
case ICMP_RTRADVERT:
if (addr_entry_size == 2) {
for (i = 0; i < num_addrs; i++) {
- proto_tree_add_text(icmp_tree, NullTVB, offset + 8 + (i*8), 4,
+ proto_tree_add_text(icmp_tree, tvb, 8 + (i*8), 4,
"Router address: %s",
- ip_to_str((guint8 *)&pd[offset + 8 + (i*8)]));
- proto_tree_add_text(icmp_tree, NullTVB, offset + 12 + (i*8), 4,
- "Preference level: %u", pntohl(&pd[offset + 12 + (i*8)]));
+ ip_to_str(tvb_get_ptr(tvb, 8 + (i*8), 4)));
+ proto_tree_add_text(icmp_tree, tvb, 12 + (i*8), 4,
+ "Preference level: %d", tvb_get_ntohl(tvb, 12 + (i*8)));
+ }
+ if (icmp_code == 16) {
+ /* Mobile-Ip */
+ dissect_mip_extensions(tvb, 8 + i*8, icmp_tree);
}
} else
- dissect_data(pd, offset + 8, fd, icmp_tree);
+ call_dissector(data_handle,tvb_new_subset(tvb, 8,-1,tvb_reported_length_remaining(tvb,8)), pinfo, icmp_tree);
break;
case ICMP_TSTAMP:
case ICMP_TSTAMPREPLY:
- proto_tree_add_text(icmp_tree, NullTVB, offset + 8, 4, "Originate timestamp: %u",
- pntohl(&pd[offset + 8]));
- proto_tree_add_text(icmp_tree, NullTVB, offset + 12, 4, "Receive timestamp: %u",
- pntohl(&pd[offset + 12]));
- proto_tree_add_text(icmp_tree, NullTVB, offset + 16, 4, "Transmit timestamp: %u",
- pntohl(&pd[offset + 16]));
+ proto_tree_add_text(icmp_tree, tvb, 8, 4, "Originate timestamp: %u",
+ tvb_get_ntohl(tvb, 8));
+ proto_tree_add_text(icmp_tree, tvb, 12, 4, "Receive timestamp: %u",
+ tvb_get_ntohl(tvb, 12));
+ proto_tree_add_text(icmp_tree, tvb, 16, 4, "Transmit timestamp: %u",
+ tvb_get_ntohl(tvb, 16));
break;
case ICMP_MASKREQ:
case ICMP_MASKREPLY:
- proto_tree_add_text(icmp_tree, NullTVB, offset + 8, 4, "Address mask: %s (0x%8x)",
- ip_to_str((guint8 *)&pd[offset + 8]), pntohl(&pd[offset + 8]));
+ proto_tree_add_text(icmp_tree, tvb, 8, 4, "Address mask: %s (0x%08x)",
+ ip_to_str(tvb_get_ptr(tvb, 8, 4)), tvb_get_ntohl(tvb, 8));
break;
}
}
}
-static void
-dissect_igmp(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
- e_igmp ih;
- proto_tree *igmp_tree;
- proto_item *ti;
- guint16 cksum;
- gchar type_str[64] = "";
-
- /* Avoids alignment problems on many architectures. */
- memcpy(&ih, &pd[offset], sizeof(e_igmp));
- /* To do: check for runts, errs, etc. */
- cksum = ntohs(ih.igmp_cksum);
-
- switch (lo_nibble(ih.igmp_v_t)) {
- case IGMP_M_QRY:
- strcpy(type_str, "Router query");
- break;
- case IGMP_V1_M_RPT:
- strcpy(type_str, "Host response (v1)");
- break;
- case IGMP_V2_LV_GRP:
- strcpy(type_str, "Leave group (v2)");
- break;
- case IGMP_DVMRP:
- strcpy(type_str, "DVMRP");
- break;
- case IGMP_PIM:
- strcpy(type_str, "PIM");
- break;
- case IGMP_V2_M_RPT:
- strcpy(type_str, "Host response (v2)");
- break;
- case IGMP_MTRC_RESP:
- strcpy(type_str, "Traceroute response");
- break;
- case IGMP_MTRC:
- strcpy(type_str, "Traceroute message");
- break;
- default:
- strcpy(type_str, "Unknown IGMP");
- }
-
- if (check_col(fd, COL_PROTOCOL))
- col_add_str(fd, COL_PROTOCOL, "IGMP");
- if (check_col(fd, COL_INFO))
- col_add_str(fd, COL_INFO, type_str);
- if (tree) {
- ti = proto_tree_add_item(tree, proto_igmp, NullTVB, offset, 8, NULL);
- igmp_tree = proto_item_add_subtree(ti, ett_igmp);
- proto_tree_add_item(igmp_tree, hf_igmp_version, NullTVB, offset, 1,
- hi_nibble(ih.igmp_v_t));
- proto_tree_add_uint_format(igmp_tree, hf_igmp_type, NullTVB, offset , 1,
- lo_nibble(ih.igmp_v_t),
- "Type: %u (%s)",
- lo_nibble(ih.igmp_v_t), type_str);
- proto_tree_add_uint_format(igmp_tree, hf_igmp_unused, NullTVB, offset + 1, 1,
- ih.igmp_unused,
- "Unused: 0x%02x",
- ih.igmp_unused);
- proto_tree_add_item(igmp_tree, hf_igmp_checksum, NullTVB, offset + 2, 2,
- cksum);
- proto_tree_add_item(igmp_tree, hf_igmp_group, NullTVB, offset + 4, 4,
- ih.igmp_gaddr);
- }
-}
-
-void
-proto_register_igmp(void)
-{
- static hf_register_info hf[] = {
-
- { &hf_igmp_version,
- { "Version", "igmp.version", FT_UINT8, BASE_DEC, NULL, 0x0,
- "" }},
-
- { &hf_igmp_type,
- { "Type", "igmp.type", FT_UINT8, BASE_DEC, NULL, 0x0,
- "" }},
-
- { &hf_igmp_unused,
- { "Unused", "igmp.unused", FT_UINT8, BASE_DEC, NULL, 0x0,
- "" }},
-
- { &hf_igmp_checksum,
- { "Checksum", "igmp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
- "" }},
-
- { &hf_igmp_group,
- { "Group address", "igmp.group", FT_IPv4, BASE_NONE, NULL, 0x0,
- "" }},
- };
- static gint *ett[] = {
- &ett_igmp,
- };
-
- proto_igmp = proto_register_protocol ("Internet Group Management Protocol", "igmp");
- proto_register_field_array(proto_igmp, hf, array_length(hf));
- proto_register_subtree_array(ett, array_length(ett));
-}
-
-void
-proto_reg_handoff_igmp(void)
-{
- dissector_add("ip.proto", IP_PROTO_IGMP, dissect_igmp);
-}
-
void
proto_register_ip(void)
{
{ &hf_ip_version,
{ "Version", "ip.version", FT_UINT8, BASE_DEC, NULL, 0x0,
- "" }},
+ "", HFILL }},
{ &hf_ip_hdr_len,
{ "Header Length", "ip.hdr_len", FT_UINT8, BASE_DEC, NULL, 0x0,
- "" }},
+ "", HFILL }},
{ &hf_ip_dsfield,
{ "Differentiated Services field", "ip.dsfield", FT_UINT8, BASE_DEC, NULL, 0x0,
- "" }},
+ "", HFILL }},
{ &hf_ip_dsfield_dscp,
{ "Differentiated Services Codepoint", "ip.dsfield.dscp", FT_UINT8, BASE_HEX,
VALS(dscp_vals), IPDSFIELD_DSCP_MASK,
- "" }},
+ "", HFILL }},
+
+ { &hf_ip_dsfield_ect,
+ { "ECN-Capable Transport (ECT)", "ip.dsfield.ect", FT_UINT8, BASE_DEC, NULL,
+ IPDSFIELD_ECT_MASK,
+ "", HFILL }},
- { &hf_ip_dsfield_cu,
- { "Currently Unused", "ip.dsfield.cu", FT_UINT8, BASE_DEC, NULL,
- IPDSFIELD_CU_MASK,
- "" }},
+ { &hf_ip_dsfield_ce,
+ { "ECN-CE", "ip.dsfield.ce", FT_UINT8, BASE_DEC, NULL,
+ IPDSFIELD_CE_MASK,
+ "", HFILL }},
{ &hf_ip_tos,
{ "Type of Service", "ip.tos", FT_UINT8, BASE_DEC, NULL, 0x0,
- "" }},
+ "", HFILL }},
{ &hf_ip_tos_precedence,
{ "Precedence", "ip.tos.precedence", FT_UINT8, BASE_DEC, VALS(precedence_vals),
IPTOS_PREC_MASK,
- "" }},
+ "", HFILL }},
{ &hf_ip_tos_delay,
{ "Delay", "ip.tos.delay", FT_BOOLEAN, 8, TFS(&tos_set_low),
IPTOS_LOWDELAY,
- "" }},
+ "", HFILL }},
{ &hf_ip_tos_throughput,
{ "Throughput", "ip.tos.throughput", FT_BOOLEAN, 8, TFS(&tos_set_high),
IPTOS_THROUGHPUT,
- "" }},
+ "", HFILL }},
{ &hf_ip_tos_reliability,
{ "Reliability", "ip.tos.reliability", FT_BOOLEAN, 8, TFS(&tos_set_high),
IPTOS_RELIABILITY,
- "" }},
+ "", HFILL }},
{ &hf_ip_tos_cost,
{ "Cost", "ip.tos.cost", FT_BOOLEAN, 8, TFS(&tos_set_low),
IPTOS_LOWCOST,
- "" }},
+ "", HFILL }},
{ &hf_ip_len,
{ "Total Length", "ip.len", FT_UINT16, BASE_DEC, NULL, 0x0,
- "" }},
+ "", HFILL }},
{ &hf_ip_id,
{ "Identification", "ip.id", FT_UINT16, BASE_HEX, NULL, 0x0,
- "" }},
+ "", HFILL }},
{ &hf_ip_dst,
{ "Destination", "ip.dst", FT_IPv4, BASE_NONE, NULL, 0x0,
- "" }},
+ "", HFILL }},
{ &hf_ip_src,
{ "Source", "ip.src", FT_IPv4, BASE_NONE, NULL, 0x0,
- "" }},
+ "", HFILL }},
{ &hf_ip_addr,
{ "Source or Destination Address", "ip.addr", FT_IPv4, BASE_NONE, NULL, 0x0,
- "" }},
+ "", HFILL }},
{ &hf_ip_flags,
{ "Flags", "ip.flags", FT_UINT8, BASE_HEX, NULL, 0x0,
- "" }},
+ "", HFILL }},
{ &hf_ip_flags_df,
{ "Don't fragment", "ip.flags.df", FT_BOOLEAN, 4, TFS(&flags_set_truth), IP_DF>>12,
- "" }},
+ "", HFILL }},
{ &hf_ip_flags_mf,
{ "More fragments", "ip.flags.mf", FT_BOOLEAN, 4, TFS(&flags_set_truth), IP_MF>>12,
- "" }},
+ "", HFILL }},
{ &hf_ip_frag_offset,
{ "Fragment offset", "ip.frag_offset", FT_UINT16, BASE_DEC, NULL, 0x0,
- "" }},
+ "", HFILL }},
{ &hf_ip_ttl,
{ "Time to live", "ip.ttl", FT_UINT8, BASE_DEC, NULL, 0x0,
- "" }},
+ "", HFILL }},
{ &hf_ip_proto,
{ "Protocol", "ip.proto", FT_UINT8, BASE_HEX, NULL, 0x0,
- "" }},
+ "", HFILL }},
{ &hf_ip_checksum,
{ "Header checksum", "ip.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
- "" }},
+ "", HFILL }},
+
+ { &hf_ip_checksum_bad,
+ { "Bad Header checksum", "ip.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "", HFILL }},
+
+ { &hf_ip_fragment_overlap,
+ { "Fragment overlap", "ip.fragment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "Fragment overlaps with other fragments", HFILL }},
+
+ { &hf_ip_fragment_overlap_conflict,
+ { "Conflicting data in fragment overlap", "ip.fragment.overlap.conflict", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "Overlapping fragments contained conflicting data", HFILL }},
+
+ { &hf_ip_fragment_multiple_tails,
+ { "Multiple tail fragments found", "ip.fragment.multipletails", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "Several tails were found when defragmenting the packet", HFILL }},
+
+ { &hf_ip_fragment_too_long_fragment,
+ { "Fragment too long", "ip.fragment.toolongfragment", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "Fragment contained data past end of packet", HFILL }},
+
+ { &hf_ip_fragment_error,
+ { "Defragmentation error", "ip.fragment.error", FT_NONE, BASE_NONE, NULL, 0x0,
+ "Defragmentation error due to illegal fragments", HFILL }},
+
+ { &hf_ip_fragment,
+ { "IP Fragment", "ip.fragment", FT_NONE, BASE_NONE, NULL, 0x0,
+ "IP Fragment", HFILL }},
+
+ { &hf_ip_fragments,
+ { "IP Fragments", "ip.fragments", FT_NONE, BASE_NONE, NULL, 0x0,
+ "IP Fragments", HFILL }},
};
static gint *ett[] = {
&ett_ip,
&ett_ip_option_sec,
&ett_ip_option_route,
&ett_ip_option_timestamp,
+ &ett_ip_fragments,
+ &ett_ip_fragment,
};
+ module_t *ip_module;
- proto_ip = proto_register_protocol ("Internet Protocol", "ip");
+ proto_ip = proto_register_protocol("Internet Protocol", "IP", "ip");
proto_register_field_array(proto_ip, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* subdissector code */
- ip_dissector_table = register_dissector_table("ip.proto");
+ ip_dissector_table = register_dissector_table("ip.proto",
+ "IP protocol", FT_UINT8, BASE_DEC);
+
+ /* Register configuration options */
+ ip_module = prefs_register_protocol(proto_ip, NULL);
+ prefs_register_bool_preference(ip_module, "decode_tos_as_diffserv",
+ "Decode IPv4 TOS field as DiffServ field",
+ "Whether the IPv4 type-of-service field should be decoded as a Differentiated Services field",
+ &g_ip_dscp_actif);
+ prefs_register_bool_preference(ip_module, "defragment",
+ "Reassemble fragmented IP datagrams",
+ "Whether fragmented IP datagrams should be reassembled",
+ &ip_defragment);
+ prefs_register_bool_preference(ip_module, "ip_summary_in_tree",
+ "Show IP summary in protocol tree",
+ "Whether the IP summary line should be shown in the protocol tree",
+ &ip_summary_in_tree);
+
+ register_dissector("ip", dissect_ip, proto_ip);
+ register_init_routine(ip_defragment_init);
}
void
proto_reg_handoff_ip(void)
{
- dissector_add("ethertype", ETHERTYPE_IP, dissect_ip);
- dissector_add("ppp.protocol", PPP_IP, dissect_ip);
- dissector_add("llc.dsap", SAP_IP, dissect_ip);
- dissector_add("ip.proto", IP_PROTO_IPV4, dissect_ip);
- dissector_add("ip.proto", IP_PROTO_IPIP, dissect_ip);
+ dissector_handle_t ip_handle;
+
+ data_handle = find_dissector("data");
+ ip_handle = find_dissector("ip");
+ dissector_add("ethertype", ETHERTYPE_IP, ip_handle);
+ dissector_add("ppp.protocol", PPP_IP, ip_handle);
+ dissector_add("ppp.protocol", ETHERTYPE_IP, ip_handle);
+ dissector_add("gre.proto", ETHERTYPE_IP, ip_handle);
+ dissector_add("gre.proto", GRE_WCCP, ip_handle);
+ dissector_add("llc.dsap", SAP_IP, ip_handle);
+ dissector_add("ip.proto", IP_PROTO_IPIP, ip_handle);
+ dissector_add("null.type", BSD_AF_INET, ip_handle);
+ dissector_add("chdlctype", ETHERTYPE_IP, ip_handle);
+ dissector_add("fr.ietf", NLPID_IP, ip_handle);
+ dissector_add("x.25.spi", NLPID_IP, ip_handle);
}
void
{ &hf_icmp_type,
{ "Type", "icmp.type", FT_UINT8, BASE_DEC, NULL, 0x0,
- "" }},
+ "", HFILL }},
{ &hf_icmp_code,
{ "Code", "icmp.code", FT_UINT8, BASE_HEX, NULL, 0x0,
- "" }},
+ "", HFILL }},
{ &hf_icmp_checksum,
{ "Checksum", "icmp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
- "" }},
+ "", HFILL }},
+
+ { &hf_icmp_checksum_bad,
+ { "Bad Checksum", "icmp.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "", HFILL }},
+
+ { &hf_icmp_mip_type,
+ { "Extension Type", "icmp.mip.type", FT_UINT8, BASE_DEC,
+ VALS(mip_extensions), 0x0,"", HFILL}},
+
+ { &hf_icmp_mip_length,
+ { "Length", "icmp.mip.length", FT_UINT8, BASE_DEC, NULL, 0x0,
+ "", HFILL}},
+
+ { &hf_icmp_mip_prefix_length,
+ { "Prefix Length", "icmp.mip.prefixlength", FT_UINT8, BASE_DEC, NULL, 0x0,
+ "", HFILL}},
+
+ { &hf_icmp_mip_seq,
+ { "Sequence Number", "icmp.mip.seq", FT_UINT16, BASE_DEC, NULL, 0x0,
+ "", HFILL}},
+
+ { &hf_icmp_mip_life,
+ { "Registration Lifetime", "icmp.mip.life", FT_UINT16, BASE_DEC, NULL, 0x0,
+ "", HFILL}},
+
+ { &hf_icmp_mip_flags,
+ { "Flags", "icmp.mip.flags", FT_UINT8, BASE_HEX, NULL, 0x0,
+ "", HFILL}},
+
+ { &hf_icmp_mip_r,
+ { "Registration Required", "icmp.mip.r", FT_BOOLEAN, 8, NULL, 128,
+ "Registration with this FA is required", HFILL }},
+
+ { &hf_icmp_mip_b,
+ { "Busy", "icmp.mip.b", FT_BOOLEAN, 8, NULL, 64,
+ "This FA will not accept requests at this time", HFILL }},
+
+ { &hf_icmp_mip_h,
+ { "Home Agent", "icmp.mip.h", FT_BOOLEAN, 8, NULL, 32,
+ "Home Agent Services Offered", HFILL }},
+
+ { &hf_icmp_mip_f,
+ { "Foreign Agent", "icmp.mip.f", FT_BOOLEAN, 8, NULL, 16,
+ "Foreign Agent Services Offered", HFILL }},
+
+ { &hf_icmp_mip_m,
+ { "Minimal Encapsulation", "icmp.mip.m", FT_BOOLEAN, 8, NULL, 8,
+ "Minimal encapsulation tunneled datagram support", HFILL }},
+
+ { &hf_icmp_mip_g,
+ { "GRE", "icmp.mip.g", FT_BOOLEAN, 8, NULL, 4,
+ "GRE encapsulated tunneled datagram support", HFILL }},
+
+ { &hf_icmp_mip_v,
+ { "VJ Comp", "icmp.mip.v", FT_BOOLEAN, 8, NULL, 2,
+ "Van Jacobson Header Compression Support", HFILL }},
+
+ { &hf_icmp_mip_res,
+ { "Reserved", "icmp.mip.res", FT_BOOLEAN, 8, NULL, 1,
+ "Reserved", HFILL }},
+
+ { &hf_icmp_mip_reserved,
+ { "Reserved", "icmp.mip.reserved", FT_UINT8, BASE_HEX, NULL, 0x0,
+ "", HFILL}},
+
+ { &hf_icmp_mip_coa,
+ { "Care-Of-Address", "icmp.mip.coa", FT_IPv4, BASE_NONE, NULL, 0x0,
+ "", HFILL}},
+
+ { &hf_icmp_mip_challenge,
+ { "Challenge", "icmp.mip.challenge", FT_BYTES, BASE_NONE, NULL, 0x0,
+ "", HFILL}},
};
static gint *ett[] = {
&ett_icmp,
+ &ett_icmp_mip,
+ &ett_icmp_mip_flags
};
- proto_icmp = proto_register_protocol ("Internet Control Message Protocol",
- "icmp");
+ proto_icmp = proto_register_protocol("Internet Control Message Protocol",
+ "ICMP", "icmp");
proto_register_field_array(proto_icmp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
void
proto_reg_handoff_icmp(void)
{
- dissector_add("ip.proto", IP_PROTO_ICMP, dissect_icmp);
+ dissector_handle_t icmp_handle;
+
+ /*
+ * Get handle for the IP dissector.
+ */
+ ip_handle = find_dissector("ip");
+
+ icmp_handle = create_dissector_handle(dissect_icmp, proto_icmp);
+ dissector_add("ip.proto", IP_PROTO_ICMP, icmp_handle);
}
git.samba.org / obnox / wireshark / wip.git / blobdiff