/* packet-clnp.c
* Routines for ISO/OSI network and transport protocol packet disassembly
*
- * $Id: packet-clnp.c,v 1.53 2002/04/07 21:54:48 guy Exp $
- * Laurent Deniel <deniel@worldnet.fr>
+ * $Id: packet-clnp.c,v 1.83 2004/02/24 17:49:06 ulfl Exp $
+ * Laurent Deniel <laurent.deniel@free.fr>
* Ralf Schneider <Ralf.Schneider@t-online.de>
*
* Ethereal - Network traffic analyzer
* 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
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
-
-#ifdef HAVE_SYS_TYPES_H
-# include <sys/types.h>
-#endif
-
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "packet-isis.h"
#include "packet-esis.h"
#include "nlpid.h"
+#include "ipproto.h"
/* protocols and fields */
static gint ett_clnp_segments = -1;
static gint ett_clnp_segment = -1;
static gint ett_clnp_disc_pdu = -1;
-static int proto_cotp = -1;
-static gint ett_cotp = -1;
-static int proto_cltp = -1;
-static gint ett_cltp = -1;
static int hf_clnp_id = -1;
static int hf_clnp_length = -1;
static int hf_clnp_segment_multiple_tails = -1;
static int hf_clnp_segment_too_long_segment = -1;
static int hf_clnp_segment_error = -1;
+static int hf_clnp_reassembled_in = -1;
+
+static int proto_cotp = -1;
+static gint ett_cotp = -1;
+static gint ett_cotp_segments = -1;
+static gint ett_cotp_segment = -1;
+
+static int hf_cotp_srcref = -1;
+static int hf_cotp_destref = -1;
+static int hf_cotp_type = -1;
+static int hf_cotp_segments = -1;
+static int hf_cotp_segment = -1;
+static int hf_cotp_segment_overlap = -1;
+static int hf_cotp_segment_overlap_conflict = -1;
+static int hf_cotp_segment_multiple_tails = -1;
+static int hf_cotp_segment_too_long_segment = -1;
+static int hf_cotp_segment_error = -1;
+static int hf_cotp_reassembled_in = -1;
+static int proto_cltp = -1;
+static gint ett_cltp = -1;
+
+static int hf_cltp_type = -1;
+
+static const fragment_items clnp_frag_items = {
+ &ett_clnp_segment,
+ &ett_clnp_segments,
+ &hf_clnp_segments,
+ &hf_clnp_segment,
+ &hf_clnp_segment_overlap,
+ &hf_clnp_segment_overlap_conflict,
+ &hf_clnp_segment_multiple_tails,
+ &hf_clnp_segment_too_long_segment,
+ &hf_clnp_segment_error,
+ &hf_clnp_reassembled_in,
+ "segments"
+};
+
+static const fragment_items cotp_frag_items = {
+ &ett_cotp_segment,
+ &ett_cotp_segments,
+ &hf_cotp_segments,
+ &hf_cotp_segment,
+ &hf_cotp_segment_overlap,
+ &hf_cotp_segment_overlap_conflict,
+ &hf_cotp_segment_multiple_tails,
+ &hf_cotp_segment_too_long_segment,
+ &hf_cotp_segment_error,
+ &hf_cotp_reassembled_in,
+ "segments"
+};
+
+static dissector_handle_t clnp_handle;
static dissector_handle_t data_handle;
/*
/* Segmentation part */
struct clnp_segment {
- u_short cng_id; /* data unit identifier */
- u_short cng_off; /* segment offset */
- u_short cng_tot_len; /* total length */
+ gushort cng_id; /* data unit identifier */
+ gushort cng_off; /* segment offset */
+ gushort cng_tot_len; /* total length */
};
/* NSAP selector */
#define CR_TPDU 0xE /* COTP */
#define DT_TPDU 0xF /* COTP */
+static const value_string cotp_tpdu_type_abbrev_vals[] = {
+ { ED_TPDU, "ED" },
+ { EA_TPDU, "EA" },
+ { RJ_TPDU, "RJ" },
+ { AK_TPDU, "AK" },
+ { ER_TPDU, "ER" },
+ { DR_TPDU, "DR" },
+ { DC_TPDU, "DC" },
+ { CC_TPDU, "CC" },
+ { CR_TPDU, "CR" },
+ { DT_TPDU, "DT" },
+ { 0, NULL }
+};
+
+static const value_string cltp_tpdu_type_abbrev_vals[] = {
+ { UD_TPDU, "UD" },
+ { 0, NULL }
+};
+
/* field position */
#define P_LI 0
/* global variables */
-static u_char li, tpdu, cdt; /* common fields */
-static u_short dst_ref;
-
/* List of dissectors to call for COTP packets put atop the Inactive
Subset of CLNP. */
static heur_dissector_list_t cotp_is_heur_subdissector_list;
+/* List of dissectors to call for COTP packets put atop CLNP */
+static heur_dissector_list_t cotp_heur_subdissector_list;
+/* List of dissectors to call for CLNP packets */
+static heur_dissector_list_t clnp_heur_subdissector_list;
/*
* Reassembly of CLNP.
*/
static GHashTable *clnp_segment_table = NULL;
+static GHashTable *clnp_reassembled_table = NULL;
+
+/*
+ * Reassembly of COTP.
+ */
+static GHashTable *cotp_segment_table = NULL;
+static GHashTable *cotp_reassembled_table = NULL;
/* options */
static guint tp_nsap_selector = NSEL_TP;
static gboolean always_decode_transport = FALSE;
static gboolean clnp_reassemble = FALSE;
+static gboolean cotp_reassemble = FALSE;
/* function definitions */
#define MAX_TSAP_LEN 32
-static gchar *print_tsap(const u_char *tsap, int length)
+static gchar *print_tsap(const guchar *tsap, int length)
{
- static gchar str[3][MAX_TSAP_LEN * 2 + 1];
+ static gchar str[3][MAX_TSAP_LEN * 2 + 3]; /* TSAP in hex + '0x' + NULL */
static gchar *cur;
gchar tmp[3];
gboolean allprintable;
if (cur == &str[0][0]) {
cur = &str[1][0];
- } else if (cur == &str[1][0]) {
+ } else if (cur == &str[1][0]) {
cur = &str[2][0];
- } else {
+ } else {
cur = &str[0][0];
}
cur[0] = '\0';
- if (length <= 0 || length > MAX_TSAP_LEN)
+ if (length <= 0 || length > MAX_TSAP_LEN)
sprintf(cur, "<unsupported TSAP length>");
- else {
+ else {
allprintable=TRUE;
for (i=0;i<length;i++) {
/* If any byte is not printable ASCII, display the TSAP as a
if (!(isascii(tsap[i]) && isprint(tsap[i]))) {
allprintable=FALSE;
break;
- }
+ }
}
if (!allprintable){
strcat(cur,"0x");
} /* print_tsap */
-static gboolean osi_decode_tp_var_part(tvbuff_t *tvb, int offset,
+static gboolean ositp_decode_var_part(tvbuff_t *tvb, int offset,
int vp_length, int class_option,
proto_tree *tree)
{
case VP_ACK_TIME:
s = tvb_get_ntohs(tvb, offset);
- proto_tree_add_text(tree, tvb, offset, length,
+ proto_tree_add_text(tree, tvb, offset, length,
"Ack time (ms): %u", s);
offset += length;
vp_length -= length;
offset += length;
vp_length -= length;
break;
-
+
case VP_TRANSIT_DEL:
s1 = tvb_get_ntohs(tvb, offset);
proto_tree_add_text(tree, tvb, offset, 2,
vp_length -= length;
break;
- case VP_REASSIGNMENT:
+ case VP_REASSIGNMENT:
proto_tree_add_text(tree, tvb, offset, 2,
"Reassignment time: %u secs", tvb_get_ntohs(tvb, offset));
offset += length;
case VP_TPDU_SIZE:
c1 = tvb_get_guint8(tvb, offset) & 0x0F;
- proto_tree_add_text(tree, tvb, offset, length,
+ proto_tree_add_text(tree, tvb, offset, length,
"TPDU size: %u", 1 << c1);
offset += length;
vp_length -= length;
}
if (c1 & 0x1)
proto_tree_add_text(tree, tvb, offset, 1,
- "Use of transport expedited data transfer\n");
+ "Use of transport expedited data transfer");
else
proto_tree_add_text(tree, tvb, offset, 1,
"Non-use of transport expedited data transfer");
"Preferred maximum TPDU size: %u", pref_max_tpdu_size*128);
offset += length;
vp_length -= length;
- break;
+ break;
case VP_INACTIVITY_TIMER:
proto_tree_add_text(tree, tvb, offset, length,
offset += length;
vp_length -= length;
break;
-
+
case VP_PROTECTION: /* user-defined */
case VP_PROTO_CLASS: /* todo */
default: /* unknown, no decoding */
"Parameter value: <not shown>");
offset += length;
vp_length -= length;
- break;
+ break;
}
} /* while */
return TRUE;
}
-static int osi_decode_DR(tvbuff_t *tvb, int offset,
- packet_info *pinfo, proto_tree *tree)
+static int ositp_decode_DR(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
+ packet_info *pinfo, proto_tree *tree)
{
proto_tree *cotp_tree;
proto_item *ti;
- u_short src_ref;
- u_char reason;
+ guint16 dst_ref, src_ref;
+ guchar reason;
char *str;
-
- if (li < LI_MIN_DR)
+
+ if (li < LI_MIN_DR)
return -1;
-
+
+ dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
+
src_ref = tvb_get_ntohs(tvb, offset + P_SRC_REF);
+
reason = tvb_get_guint8(tvb, offset + P_REASON_IN_DR);
+ /* the settings of the TCP srcport and destport are currently disables,
+ * for the following reasons:
+ * a) only used for ISO conversation handling (which currently doesn't work)
+ * b) will prevent "ISO on TCP" (RFC1006) packets from using "follow TCP stream" correctly
+ *
+ * A future conversation handling might be able to handle different kinds of conversations
+ * (TCP, ISO, TCP on TCP, ...), but in that case this has to be fixed in any case.
+ */
+ /*pinfo->srcport = src_ref;*/
+ /*pinfo->destport = dst_ref;*/
switch(reason) {
case (128+0): str = "Normal Disconnect"; break;
case (128+1): str = "Remote transport entity congestion"; break;
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Length indicator: %u", li);
- proto_tree_add_text(cotp_tree, tvb, offset + 1, 1,
- "TPDU code: 0x%x (DR)", tpdu);
- proto_tree_add_text(cotp_tree, tvb, offset + 2, 2,
- "Destination reference: 0x%04x", dst_ref);
- proto_tree_add_text(cotp_tree, tvb, offset + 4, 2,
- "Source reference: 0x%04x", src_ref);
- proto_tree_add_text(cotp_tree, tvb, offset + 6, 1,
+ proto_tree_add_uint_format(cotp_tree, hf_cotp_type, tvb, offset + 1, 1, tpdu,
+ "TPDU code: 0x%x (DR)", tpdu);
+ proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset + 2, 2, dst_ref);
+ proto_tree_add_uint(cotp_tree, hf_cotp_srcref, tvb, offset + 4, 2, src_ref);
+ proto_tree_add_text(cotp_tree, tvb, offset + 6, 1,
"Cause: %s", str);
}
offset += li + 1;
/* User data */
- call_dissector(data_handle,tvb_new_subset(tvb, offset,-1,tvb_reported_length_remaining(tvb,offset)), pinfo, tree);
+ call_dissector(data_handle, tvb_new_subset(tvb, offset, -1, -1), pinfo, tree);
offset += tvb_length_remaining(tvb, offset);
/* we dissected all of the containing PDU */
return offset;
-} /* osi_decode_DR */
+} /* ositp_decode_DR */
-static int osi_decode_DT(tvbuff_t *tvb, int offset,
+static int ositp_decode_DT(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
packet_info *pinfo, proto_tree *tree,
gboolean uses_inactive_subset,
gboolean *subdissector_found)
proto_item *ti;
gboolean is_extended;
gboolean is_class_234;
- u_int tpdu_nr ;
- u_int fragment = 0;
+ guint16 dst_ref;
+ guint tpdu_nr;
+ guint fragment = 0;
+ guint32 fragment_length = 0;
tvbuff_t *next_tvb;
-
+ tvbuff_t *reassembled_tvb = NULL;
+ fragment_data *fd_head;
+
/* VP_CHECKSUM is the only parameter allowed in the variable part.
(This means we may misdissect this if the packet is bad and
contains other parameters.) */
fragment = 1;
is_extended = FALSE;
is_class_234 = TRUE;
+ dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
break;
case LI_EXTENDED_DT_WITH_CHECKSUM :
fragment = 1;
is_extended = TRUE;
is_class_234 = TRUE;
+ dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
break;
case LI_NORMAL_DT_CLASS_01 :
if ( tpdu_nr & 0x80 )
tpdu_nr = tpdu_nr & 0x7F;
else
- fragment = 1;
+ fragment = 1;
is_extended = FALSE;
is_class_234 = FALSE;
+ dst_ref = 0;
break;
default : /* bad TPDU */
break;
}
- if (check_col(pinfo->cinfo, COL_INFO))
- col_append_fstr(pinfo->cinfo, COL_INFO, "DT TPDU (%u) dst-ref: 0x%04x %s",
+ /* pinfo->destport = dst_ref; */
+ /* pinfo->srcport = 0; */
+ pinfo->fragmented = fragment;
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ if (is_class_234) {
+ col_append_fstr(pinfo->cinfo, COL_INFO, "DT TPDU (%u) dst-ref: 0x%04x %s",
tpdu_nr,
dst_ref,
(fragment)? "(fragment)" : "");
+ } else {
+ col_append_fstr(pinfo->cinfo, COL_INFO, "DT TPDU (%u) %s",
+ tpdu_nr,
+ (fragment)? "(fragment)" : "");
+ }
+ }
if (tree) {
ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
offset += 1;
if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 1,
- "TPDU code: 0x%x (DT)", tpdu);
-
+ proto_tree_add_uint_format(cotp_tree, hf_cotp_type, tvb, offset, 1, tpdu,
+ "TPDU code: 0x%x (DT)", tpdu);
}
offset += 1;
li -= 1;
if (is_class_234) {
- if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 2,
- "Destination reference: 0x%04x", dst_ref);
- }
+ if (tree)
+ proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset, 2, dst_ref);
offset += 2;
li -= 2;
}
if (is_extended) {
if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 4,
- "TPDU number: 0x%08x (%s)",
+ proto_tree_add_text(cotp_tree, tvb, offset, 4,
+ "TPDU number: 0x%08x (%s)",
tpdu_nr,
(fragment)? "fragment":"complete");
}
} else {
if (tree) {
proto_tree_add_text(cotp_tree, tvb, offset, 1,
- "TPDU number: 0x%02x (%s)",
+ "TPDU number: 0x%02x (%s)",
tpdu_nr,
(fragment)? "fragment":"complete");
}
}
if (tree)
- osi_decode_tp_var_part(tvb, offset, li, 4, cotp_tree);
+ ositp_decode_var_part(tvb, offset, li, 4, cotp_tree);
offset += li;
next_tvb = tvb_new_subset(tvb, offset, -1, -1);
- if (uses_inactive_subset){
- if (dissector_try_heuristic(cotp_is_heur_subdissector_list, next_tvb,
- pinfo, tree)) {
- *subdissector_found = TRUE;
- } else {
- /* Fill in other Dissectors using inactive subset here */
- call_dissector(data_handle,next_tvb, pinfo, tree);
- }
- } else
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ if (cotp_reassemble) {
+ fragment_length = tvb_length(next_tvb);
+ /*
+ * XXX - these sequence numbers are connection sequence number,
+ * not segment sequence numbers - the first segment of a
+ * segmented packet doesn't have a specific sequence number (e.g., 0
+ * or 1), it has whatever the appropriate sequence number is for
+ * it in the connection.
+ */
+ fd_head = fragment_add_seq_check(next_tvb, 0, pinfo, dst_ref,
+ cotp_segment_table,
+ cotp_reassembled_table,
+ tpdu_nr,
+ fragment_length, fragment);
+ if (fd_head) {
+ if (fd_head->next) {
+ /* This is the last packet */
+ reassembled_tvb = tvb_new_real_data(fd_head->data,
+ fd_head->len,
+ fd_head->len);
+ tvb_set_child_real_data_tvbuff(next_tvb, reassembled_tvb);
+ add_new_data_source(pinfo, reassembled_tvb, "Reassembled COTP");
+
+ show_fragment_seq_tree(fd_head,
+ &cotp_frag_items,
+ cotp_tree,
+ pinfo, reassembled_tvb);
+ pinfo->fragmented = fragment;
+ next_tvb = reassembled_tvb;
+ }
+ }
+ if (fragment && reassembled_tvb == NULL) {
+ proto_tree_add_text(cotp_tree, tvb, offset, -1,
+ "User data (%u byte%s)", fragment_length,
+ plurality(fragment_length, "", "s"));
+ }
+
+ }
+
+ if (uses_inactive_subset) {
+ if (dissector_try_heuristic(cotp_is_heur_subdissector_list, next_tvb,
+ pinfo, tree)) {
+ *subdissector_found = TRUE;
+ } else {
+ /* Fill in other Dissectors using inactive subset here */
+ call_dissector(data_handle,next_tvb, pinfo, tree);
+ }
+ } else {
+ /*
+ * We dissect payload if one of the following is TRUE:
+ *
+ * - Reassembly option for COTP in preferences is unchecked
+ * - Reassembly option is checked and this packet is the last fragment
+ */
+ if ( (!cotp_reassemble) ||
+ ((cotp_reassemble) && (!fragment))) {
+ if (dissector_try_heuristic(cotp_heur_subdissector_list, next_tvb,
+ pinfo, tree)) {
+ *subdissector_found = TRUE;
+ } else {
+ call_dissector(data_handle,next_tvb, pinfo, tree);
+ }
+ }
+ }
+
offset += tvb_length_remaining(tvb, offset);
/* we dissected all of the containing PDU */
return offset;
-} /* osi_decode_DT */
+} /* ositp_decode_DT */
-static int osi_decode_ED(tvbuff_t *tvb, int offset,
+static int ositp_decode_ED(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
packet_info *pinfo, proto_tree *tree)
{
proto_tree *cotp_tree = NULL;
proto_item *ti;
gboolean is_extended;
- u_int tpdu_nr ;
+ guint16 dst_ref;
+ guint tpdu_nr;
tvbuff_t *next_tvb;
/* ED TPDUs are never fragmented */
break;
} /* li */
+ dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
+
+ /* pinfo->destport = dst_ref; */
+ /* pinfo->srcport = 0; */
if (check_col(pinfo->cinfo, COL_INFO))
- col_append_fstr(pinfo->cinfo, COL_INFO, "ED TPDU (%u) dst-ref: 0x%04x",
+ col_append_fstr(pinfo->cinfo, COL_INFO, "ED TPDU (%u) dst-ref: 0x%04x",
tpdu_nr, dst_ref);
if (tree) {
offset += 1;
if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 1,
+ proto_tree_add_uint_format(cotp_tree, hf_cotp_type, tvb, offset, 1, tpdu,
"TPDU code: 0x%x (ED)", tpdu);
}
offset += 1;
li -= 1;
- if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 2,
- "Destination reference: 0x%04x", dst_ref);
- }
+ if (tree)
+ proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset, 2, dst_ref);
offset += 2;
li -= 2;
} else {
if (tree) {
proto_tree_add_text(cotp_tree, tvb, offset, 1,
- "TPDU number: 0x%02x", tpdu_nr);
+ "TPDU number: 0x%02x", tpdu_nr);
}
offset += 1;
li -= 1;
}
if (tree)
- osi_decode_tp_var_part(tvb, offset, li, 4, cotp_tree);
+ ositp_decode_var_part(tvb, offset, li, 4, cotp_tree);
offset += li;
next_tvb = tvb_new_subset(tvb, offset, -1, -1);
return offset;
-} /* osi_decode_ED */
+} /* ositp_decode_ED */
-static int osi_decode_RJ(tvbuff_t *tvb, int offset,
- packet_info *pinfo, proto_tree *tree)
+static int ositp_decode_RJ(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
+ guint8 cdt, packet_info *pinfo, proto_tree *tree)
{
proto_tree *cotp_tree;
proto_item *ti;
- u_int tpdu_nr ;
- u_short credit = 0;
+ guint16 dst_ref;
+ guint tpdu_nr;
+ gushort credit = 0;
switch(li) {
case LI_NORMAL_RJ :
break;
}
+ dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
+
+ /* pinfo->destport = dst_ref; */
+ /* pinfo->srcport = 0; */
if (check_col(pinfo->cinfo, COL_INFO))
- col_append_fstr(pinfo->cinfo, COL_INFO, "RJ TPDU (%u) dst-ref: 0x%04x",
+ col_append_fstr(pinfo->cinfo, COL_INFO, "RJ TPDU (%u) dst-ref: 0x%04x",
tpdu_nr, dst_ref);
if (tree) {
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Length indicator: %u", li);
- proto_tree_add_text(cotp_tree, tvb, offset + 1, 1,
- "TPDU code: 0x%x (RJ)", tpdu);
+ proto_tree_add_uint_format(cotp_tree, hf_cotp_type, tvb, offset + 1, 1, tpdu,
+ "TPDU code: 0x%x (RJ)", tpdu);
if (li == LI_NORMAL_RJ)
- proto_tree_add_text(cotp_tree, tvb, offset + 1, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset + 1, 1,
"Credit: %u", cdt);
- proto_tree_add_text(cotp_tree, tvb, offset + 2, 2,
- "Destination reference: 0x%04x", dst_ref);
+ proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset + 2, 2, dst_ref);
if (li == LI_NORMAL_RJ)
- proto_tree_add_text(cotp_tree, tvb, offset + 4, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset + 4, 1,
"Your TPDU number: 0x%02x", tpdu_nr);
else {
- proto_tree_add_text(cotp_tree, tvb, offset + 4, 4,
+ proto_tree_add_text(cotp_tree, tvb, offset + 4, 4,
"Your TPDU number: 0x%02x", tpdu_nr);
- proto_tree_add_text(cotp_tree, tvb, offset + 8, 2,
+ proto_tree_add_text(cotp_tree, tvb, offset + 8, 2,
"Credit: 0x%02x", credit);
}
}
return offset;
-} /* osi_decode_RJ */
+} /* ositp_decode_RJ */
-static int osi_decode_CC(tvbuff_t *tvb, int offset,
- packet_info *pinfo, proto_tree *tree)
+static int ositp_decode_CC(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
+ packet_info *pinfo, proto_tree *tree,
+ gboolean uses_inactive_subset,
+ gboolean *subdissector_found)
{
/* CC & CR decoding in the same function */
proto_tree *cotp_tree = NULL;
proto_item *ti;
- u_short src_ref;
- u_char class_option;
+ guint16 dst_ref, src_ref;
+ guchar class_option;
+ tvbuff_t *next_tvb;
src_ref = tvb_get_ntohs(tvb, offset + P_SRC_REF);
+
class_option = (tvb_get_guint8(tvb, offset + P_CLASS_OPTION) >> 4 ) & 0x0F;
if (class_option > 4)
return -1;
+ dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
+ /* pinfo->srcport = src_ref; */
+ /* pinfo->destport = dst_ref; */
if (check_col(pinfo->cinfo, COL_INFO))
col_append_fstr(pinfo->cinfo, COL_INFO,
"%s TPDU src-ref: 0x%04x dst-ref: 0x%04x",
offset += 1;
if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 1,
+ proto_tree_add_uint_format(cotp_tree, hf_cotp_type, tvb, offset, 1, tpdu,
"TPDU code: 0x%x (%s)", tpdu,
(tpdu == CR_TPDU) ? "CR" : "CC");
}
offset += 1;
li -= 1;
- if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 2,
- "Destination reference: 0x%04x", dst_ref);
- }
+ if (tree)
+ proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset, 2, dst_ref);
offset += 2;
li -= 2;
- if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 2,
- "Source reference: 0x%04x", src_ref);
- }
+ if (tree)
+ proto_tree_add_uint(cotp_tree, hf_cotp_srcref, tvb, offset, 2, src_ref);
offset += 2;
li -= 2;
li -= 1;
if (tree)
- osi_decode_tp_var_part(tvb, offset, li, class_option, cotp_tree);
+ ositp_decode_var_part(tvb, offset, li, class_option, cotp_tree);
offset += li;
- /* User data */
- call_dissector(data_handle,tvb_new_subset(tvb, offset,-1,tvb_reported_length_remaining(tvb,offset)), pinfo, tree);
+ next_tvb = tvb_new_subset(tvb, offset, -1, -1);
+ if (!uses_inactive_subset){
+ if (dissector_try_heuristic(cotp_heur_subdissector_list, next_tvb,
+ pinfo, tree)) {
+ *subdissector_found = TRUE;
+ } else {
+ call_dissector(data_handle,next_tvb, pinfo, tree);
+ }
+ }
+ else
+ call_dissector(data_handle, next_tvb, pinfo, tree);
offset += tvb_length_remaining(tvb, offset);
/* we dissected all of the containing PDU */
return offset;
-} /* osi_decode_CC */
+} /* ositp_decode_CC */
-static int osi_decode_DC(tvbuff_t *tvb, int offset,
+static int ositp_decode_DC(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
packet_info *pinfo, proto_tree *tree)
{
proto_tree *cotp_tree = NULL;
proto_item *ti;
- u_short src_ref;
+ guint16 dst_ref, src_ref;
- if (li > LI_MAX_DC)
+ if (li > LI_MAX_DC)
return -1;
+ dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
src_ref = tvb_get_ntohs(tvb, offset + P_SRC_REF);
+ /* pinfo->srcport = src_ref; */
+ /* pinfo->destport = dst_ref; */
if (check_col(pinfo->cinfo, COL_INFO))
col_append_fstr(pinfo->cinfo, COL_INFO,
- "DC TPDU src-ref: 0x%04x dst-ref: 0x%04x",
+ "DC TPDU src-ref: 0x%04x dst-ref: 0x%04x",
src_ref,
dst_ref);
offset += 1;
if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 1,
+ proto_tree_add_uint_format(cotp_tree, hf_cotp_type, tvb, offset, 1, tpdu,
"TPDU code: 0x%x (DC)", tpdu);
}
offset += 1;
li -= 1;
- if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 2,
- "Destination reference: 0x%04x", dst_ref);
- }
+ if (tree)
+ proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset, 2, dst_ref);
offset += 2;
li -= 2;
- if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 2,
- "Source reference: 0x%04x", src_ref);
- }
+ if (tree)
+ proto_tree_add_uint(cotp_tree, hf_cotp_srcref, tvb, offset, 2, src_ref);
offset += 2;
li -= 2;
if (tree)
- osi_decode_tp_var_part(tvb, offset, li, 4, cotp_tree);
+ ositp_decode_var_part(tvb, offset, li, 4, cotp_tree);
offset += li;
return offset;
-} /* osi_decode_DC */
+} /* ositp_decode_DC */
-static int osi_decode_AK(tvbuff_t *tvb, int offset,
- packet_info *pinfo, proto_tree *tree)
+static int ositp_decode_AK(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
+ guint8 cdt, packet_info *pinfo, proto_tree *tree)
{
proto_tree *cotp_tree = NULL;
proto_item *ti;
- u_int tpdu_nr;
- u_short cdt_in_ak;
+ guint16 dst_ref;
+ guint tpdu_nr;
+ gushort cdt_in_ak;
- if (li > LI_MAX_AK)
+ if (li > LI_MAX_AK)
return -1;
if (is_LI_NORMAL_AK(li)) {
+ dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
tpdu_nr = tvb_get_guint8(tvb, offset + P_TPDU_NR_234);
+ /* pinfo->srcport = 0; */
+ /* pinfo->destport = dst_ref; */
if (check_col(pinfo->cinfo, COL_INFO))
- col_append_fstr(pinfo->cinfo, COL_INFO, "AK TPDU (%u) dst-ref: 0x%04x",
+ col_append_fstr(pinfo->cinfo, COL_INFO, "AK TPDU (%u) dst-ref: 0x%04x",
tpdu_nr, dst_ref);
if (tree) {
offset += 1;
if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 1,
+ proto_tree_add_uint_format(cotp_tree, hf_cotp_type, tvb, offset, 1, tpdu,
"TPDU code: 0x%x (AK)", tpdu);
proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Credit: %u", cdt);
offset += 1;
li -= 1;
- if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 2,
- "Destination reference: 0x%04x", dst_ref);
- }
+ if (tree)
+ proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset, 2, dst_ref);
offset += 2;
li -= 2;
li -= 1;
if (tree)
- osi_decode_tp_var_part(tvb, offset, li, 4, cotp_tree);
+ ositp_decode_var_part(tvb, offset, li, 4, cotp_tree);
offset += li;
} else { /* extended format */
-
+
+ dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
tpdu_nr = tvb_get_ntohl(tvb, offset + P_TPDU_NR_234);
cdt_in_ak = tvb_get_ntohs(tvb, offset + P_CDT_IN_AK);
if (check_col(pinfo->cinfo, COL_INFO))
- col_append_fstr(pinfo->cinfo, COL_INFO, "AK TPDU (%u) dst-ref: 0x%04x",
+ col_append_fstr(pinfo->cinfo, COL_INFO, "AK TPDU (%u) dst-ref: 0x%04x",
tpdu_nr, dst_ref);
-
+
if (tree) {
ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
offset += 1;
if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 1,
+ proto_tree_add_uint_format(cotp_tree, hf_cotp_type, tvb, offset, 1, tpdu,
"TPDU code: 0x%x (AK)", tpdu);
}
offset += 1;
li -= 1;
- if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 2,
- "Destination reference: 0x%04x", dst_ref);
- }
+ if (tree)
+ proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset, 2, dst_ref);
offset += 2;
li -= 2;
}
offset += 2;
li -= 2;
-
+
if (tree)
- osi_decode_tp_var_part(tvb, offset, li, 4, cotp_tree);
+ ositp_decode_var_part(tvb, offset, li, 4, cotp_tree);
offset += li;
} /* is_LI_NORMAL_AK */
return offset;
-} /* osi_decode_AK */
+} /* ositp_decode_AK */
-static int osi_decode_EA(tvbuff_t *tvb, int offset,
+static int ositp_decode_EA(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
packet_info *pinfo, proto_tree *tree)
{
proto_tree *cotp_tree = NULL;
proto_item *ti;
gboolean is_extended;
- u_int tpdu_nr ;
+ guint16 dst_ref;
+ guint tpdu_nr;
- if (li > LI_MAX_EA)
+ if (li > LI_MAX_EA)
return -1;
/* VP_CHECKSUM is the only parameter allowed in the variable part.
break;
} /* li */
+ dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
+ /* pinfo->srcport = 0; */
+ /* pinfo->destport = dst_ref; */
if (check_col(pinfo->cinfo, COL_INFO))
- col_append_fstr(pinfo->cinfo, COL_INFO,
+ col_append_fstr(pinfo->cinfo, COL_INFO,
"EA TPDU (%u) dst-ref: 0x%04x", tpdu_nr, dst_ref);
if (tree) {
offset += 1;
if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 1,
+ proto_tree_add_uint_format(cotp_tree, hf_cotp_type, tvb, offset, 1, tpdu,
"TPDU code: 0x%x (EA)", tpdu);
}
offset += 1;
li -= 1;
- if (tree) {
- proto_tree_add_text(cotp_tree, tvb, offset, 2,
- "Destination reference: 0x%04x", dst_ref);
- }
+ if (tree)
+ proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset, 2, dst_ref);
offset += 2;
li -= 2;
}
if (tree)
- osi_decode_tp_var_part(tvb, offset, li, 4, cotp_tree);
+ ositp_decode_var_part(tvb, offset, li, 4, cotp_tree);
offset += li;
return offset;
-} /* osi_decode_EA */
+} /* ositp_decode_EA */
-static int osi_decode_ER(tvbuff_t *tvb, int offset,
+static int ositp_decode_ER(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
packet_info *pinfo, proto_tree *tree)
{
proto_tree *cotp_tree;
proto_item *ti;
- u_char *str;
+ guchar *str;
+ guint16 dst_ref;
- if (li > LI_MAX_ER)
+ if (li > LI_MAX_ER)
return -1;
switch(tvb_get_guint8(tvb, offset + P_REJECT_ER)) {
break;
}
+ dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
+ /* pinfo->srcport = 0; */
+ /* pinfo->destport = dst_ref; */
if (check_col(pinfo->cinfo, COL_INFO))
col_append_fstr(pinfo->cinfo, COL_INFO, "ER TPDU dst-ref: 0x%04x", dst_ref);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Length indicator: %u", li);
- proto_tree_add_text(cotp_tree, tvb, offset + 1, 1,
- "TPDU code: 0x%x (ER)", tpdu);
- proto_tree_add_text(cotp_tree, tvb, offset + 2, 2,
- "Destination reference: 0x%04x", dst_ref);
- proto_tree_add_text(cotp_tree, tvb, offset + 4, 1,
+ proto_tree_add_uint_format(cotp_tree, hf_cotp_type, tvb, offset + 1, 1, tpdu,
+ "TPDU code: 0x%x (ER)", tpdu);
+ proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset + 2, 2, dst_ref);
+ proto_tree_add_text(cotp_tree, tvb, offset + 4, 1,
"Reject cause: %s", str);
}
return offset;
-} /* osi_decode_ER */
+} /* ositp_decode_ER */
-static int osi_decode_UD(tvbuff_t *tvb, int offset,
+static int ositp_decode_UD(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
packet_info *pinfo, proto_tree *tree)
{
proto_item *ti;
offset += 1;
if (tree) {
- proto_tree_add_text(cltp_tree, tvb, offset, 1,
+ proto_tree_add_uint_format(cltp_tree, hf_cltp_type, tvb, offset, 1, tpdu,
"TPDU code: 0x%x (UD)", tpdu);
}
offset += 1;
li -= 1;
if (tree)
- osi_decode_tp_var_part(tvb, offset, li, 0, cltp_tree);
+ ositp_decode_var_part(tvb, offset, li, 0, cltp_tree);
offset += li;
next_tvb = tvb_new_subset(tvb, offset, -1, -1);
return offset;
-} /* osi_decode_UD */
+} /* ositp_decode_UD */
/* Returns TRUE if we found at least one valid COTP or CLTP PDU, FALSE
otherwise.
only valid CLTP PDU type is not a valid COTP PDU type, so we'll handle
both of them here. */
static gboolean dissect_ositp_internal(tvbuff_t *tvb, packet_info *pinfo,
- proto_tree *tree, gboolean uses_inactive_subset)
+ proto_tree *tree, gboolean uses_inactive_subset)
{
int offset = 0;
+ guint8 li, tpdu, cdt;
gboolean first_tpdu = TRUE;
int new_offset;
gboolean found_ositp = FALSE;
gboolean is_cltp = FALSE;
gboolean subdissector_found = FALSE;
- if (!proto_is_protocol_enabled(proto_cotp))
+ if (!proto_is_protocol_enabled(find_protocol_by_id(proto_cotp)))
return FALSE; /* COTP has been disabled */
/* XXX - what about CLTP? */
if (check_col(pinfo->cinfo, COL_INFO))
col_append_str(pinfo->cinfo, COL_INFO, "Length indicator is zero");
if (!first_tpdu)
- call_dissector(data_handle,tvb_new_subset(tvb, offset,-1,tvb_reported_length_remaining(tvb,offset)), pinfo, tree);
+ call_dissector(data_handle, tvb_new_subset(tvb, offset, -1, -1),
+ pinfo, tree);
return found_ositp;
}
if (tpdu == UD_TPDU)
pinfo->current_proto = "CLTP"; /* connectionless transport */
cdt = tvb_get_guint8(tvb, offset + P_CDT) & 0x0F;
- dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
switch (tpdu) {
case CC_TPDU :
case CR_TPDU :
- new_offset = osi_decode_CC(tvb, offset, pinfo, tree);
+ new_offset = ositp_decode_CC(tvb, offset, li, tpdu, pinfo, tree,
+ uses_inactive_subset, &subdissector_found);
break;
case DR_TPDU :
- new_offset = osi_decode_DR(tvb, offset, pinfo, tree);
+ new_offset = ositp_decode_DR(tvb, offset, li, tpdu, pinfo, tree);
break;
case DT_TPDU :
- new_offset = osi_decode_DT(tvb, offset, pinfo, tree,
+ new_offset = ositp_decode_DT(tvb, offset, li, tpdu, pinfo, tree,
uses_inactive_subset, &subdissector_found);
break;
case ED_TPDU :
- new_offset = osi_decode_ED(tvb, offset, pinfo, tree);
+ new_offset = ositp_decode_ED(tvb, offset, li, tpdu, pinfo, tree);
break;
case RJ_TPDU :
- new_offset = osi_decode_RJ(tvb, offset, pinfo, tree);
+ new_offset = ositp_decode_RJ(tvb, offset, li, tpdu, cdt, pinfo, tree);
break;
case DC_TPDU :
- new_offset = osi_decode_DC(tvb, offset, pinfo, tree);
+ new_offset = ositp_decode_DC(tvb, offset, li, tpdu, pinfo, tree);
break;
case AK_TPDU :
- new_offset = osi_decode_AK(tvb, offset, pinfo, tree);
+ new_offset = ositp_decode_AK(tvb, offset, li, tpdu, cdt, pinfo, tree);
break;
case EA_TPDU :
- new_offset = osi_decode_EA(tvb, offset, pinfo, tree);
+ new_offset = ositp_decode_EA(tvb, offset, li, tpdu, pinfo, tree);
break;
case ER_TPDU :
- new_offset = osi_decode_ER(tvb, offset, pinfo, tree);
+ new_offset = ositp_decode_ER(tvb, offset, li, tpdu, pinfo, tree);
break;
case UD_TPDU :
- new_offset = osi_decode_UD(tvb, offset, pinfo, tree);
+ new_offset = ositp_decode_UD(tvb, offset, li, tpdu, pinfo, tree);
is_cltp = TRUE;
break;
default :
if (new_offset == -1) { /* incorrect TPDU */
if (!first_tpdu)
- call_dissector(data_handle,tvb_new_subset(tvb, offset,-1,tvb_reported_length_remaining(tvb,offset)), pinfo, tree);
+ call_dissector(data_handle, tvb_new_subset(tvb, offset, -1, -1),
+ pinfo, tree);
break;
}
return found_ositp;
} /* dissect_ositp_internal */
-static void dissect_ositp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
+static void dissect_ositp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
if (!dissect_ositp_internal(tvb, pinfo, tree, FALSE))
call_dissector(data_handle,tvb, pinfo, tree);
}
-
/*
- * CLNP part / main entry point
+ * CLNP part / main entry point
*/
static void dissect_clnp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
guint16 cnf_cksum;
cksum_status_t cksum_status;
int offset;
- u_char src_len, dst_len, nsel, opt_len = 0;
+ guchar src_len, dst_len, nsel, opt_len = 0;
const guint8 *dst_addr, *src_addr;
gint len;
guint next_length;
proto_tree *discpdu_tree;
- 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;
fragment_data *fd_head;
- tvbuff_t *volatile next_tvb;
+ tvbuff_t *next_tvb;
gboolean update_col_info = TRUE;
gboolean save_fragmented;
if (tree) {
ti = proto_tree_add_item(tree, proto_clnp, tvb, P_CLNP_PROTO_ID, 1, FALSE);
clnp_tree = proto_item_add_subtree(ti, ett_clnp);
- proto_tree_add_uint_format(clnp_tree, hf_clnp_id, tvb, P_CLNP_PROTO_ID, 1,
+ proto_tree_add_uint_format(clnp_tree, hf_clnp_id, tvb, P_CLNP_PROTO_ID, 1,
cnf_proto_id,
"Inactive subset");
- }
+ }
next_tvb = tvb_new_subset(tvb, 1, -1, -1);
dissect_ositp_internal(next_tvb, pinfo, tree, TRUE);
return;
- }
-
+ }
+
/* return if version not known */
cnf_vers = tvb_get_guint8(tvb, P_CLNP_VERS);
if (cnf_vers != ISO8473_V1) {
if (tree) {
ti = proto_tree_add_item(tree, proto_clnp, tvb, 0, cnf_hdr_len, FALSE);
clnp_tree = proto_item_add_subtree(ti, ett_clnp);
- proto_tree_add_uint(clnp_tree, hf_clnp_id, tvb, P_CLNP_PROTO_ID, 1,
+ proto_tree_add_uint(clnp_tree, hf_clnp_id, tvb, P_CLNP_PROTO_ID, 1,
cnf_proto_id);
- proto_tree_add_uint(clnp_tree, hf_clnp_length, tvb, P_CLNP_HDR_LEN, 1,
- cnf_hdr_len);
- proto_tree_add_uint(clnp_tree, hf_clnp_version, tvb, P_CLNP_VERS, 1,
+ proto_tree_add_uint(clnp_tree, hf_clnp_length, tvb, P_CLNP_HDR_LEN, 1,
+ cnf_hdr_len);
+ proto_tree_add_uint(clnp_tree, hf_clnp_version, tvb, P_CLNP_VERS, 1,
cnf_vers);
cnf_ttl = tvb_get_guint8(tvb, P_CLNP_TTL);
- proto_tree_add_uint_format(clnp_tree, hf_clnp_ttl, tvb, P_CLNP_TTL, 1,
+ proto_tree_add_uint_format(clnp_tree, hf_clnp_ttl, tvb, P_CLNP_TTL, 1,
cnf_ttl,
- "Holding Time : %u (%u.%u secs)",
+ "Holding Time : %u (%u.%u secs)",
cnf_ttl, cnf_ttl / 2, (cnf_ttl % 2) * 5);
}
} /* tree */
/* address part */
-
+
offset = P_CLNP_ADDRESS_PART;
dst_len = tvb_get_guint8(tvb, offset);
dst_addr = tvb_get_ptr(tvb, offset + 1, dst_len);
src_addr = tvb_get_ptr(tvb, offset + dst_len + 2, src_len);
if (tree) {
- proto_tree_add_uint(clnp_tree, hf_clnp_dest_length, tvb, offset, 1,
+ proto_tree_add_uint(clnp_tree, hf_clnp_dest_length, tvb, offset, 1,
dst_len);
- proto_tree_add_bytes_format(clnp_tree, hf_clnp_dest, tvb, offset + 1 , dst_len,
+ proto_tree_add_bytes_format(clnp_tree, hf_clnp_dest, tvb, offset + 1 , dst_len,
dst_addr,
- " DA : %s",
+ " DA : %s",
print_nsap_net(dst_addr, dst_len));
- proto_tree_add_uint(clnp_tree, hf_clnp_src_length, tvb,
+ proto_tree_add_uint(clnp_tree, hf_clnp_src_length, tvb,
offset + 1 + dst_len, 1, src_len);
- proto_tree_add_bytes_format(clnp_tree, hf_clnp_src, tvb,
+ proto_tree_add_bytes_format(clnp_tree, hf_clnp_src, tvb,
offset + dst_len + 2, src_len,
src_addr,
- " SA : %s",
+ " SA : %s",
print_nsap_net(src_addr, src_len));
opt_len -= dst_len + src_len +2;
if (cnf_type & CNF_SEG_OK) {
struct clnp_segment seg; /* XXX - not used */
tvb_memcpy(tvb, (guint8 *)&seg, offset, sizeof(seg)); /* XXX - not used */
-
+
segment_offset = tvb_get_ntohs(tvb, offset + 2);
du_id = tvb_get_ntohs(tvb, offset);
if (tree) {
- proto_tree_add_text(clnp_tree, tvb, offset, 2,
+ proto_tree_add_text(clnp_tree, tvb, offset, 2,
"Data unit identifier: %06u",
du_id);
proto_tree_add_text(clnp_tree, tvb, offset + 2 , 2,
- "Segment offset : %6u",
+ "Segment offset : %6u",
segment_offset);
proto_tree_add_text(clnp_tree, tvb, offset + 4 , 2,
- "Total length : %6u",
+ "Total length : %6u",
tvb_get_ntohs(tvb, offset + 4));
}
-
+
offset += 6;
opt_len -= 6;
}
if (tree) {
/* To do : decode options */
/*
- proto_tree_add_text(clnp_tree, tvb, offset,
+ proto_tree_add_text(clnp_tree, tvb, offset,
cnf_hdr_len - offset,
"Options/Data: <not shown>");
*/
/* QUICK HACK Option Len:= PDU_Hd_length-( FixedPart+AddresPart+SegmentPart )*/
- dissect_osi_options( 0xff,
- opt_len,
- tvb, offset, clnp_tree );
+ dissect_osi_options( opt_len,
+ tvb, offset, clnp_tree );
}
/* Length of CLNP datagram plus headers above it. */
offset = cnf_hdr_len;
- /* If clnp_reassemble is on, and this is a segment, we have all the
+ /* If clnp_reassemble is on, this is a segment, we have all the
* data in the segment, and the checksum is valid, then just add the
* segment to the hashtable.
*/
save_fragmented = pinfo->fragmented;
if (clnp_reassemble && (cnf_type & CNF_SEG_OK) &&
((cnf_type & CNF_MORE_SEGS) || segment_offset != 0) &&
- (tvb_reported_length(tvb) <= tvb_length(tvb)) &&
+ tvb_bytes_exist(tvb, offset, segment_length - cnf_hdr_len) &&
cksum_status != CKSUM_NOT_OK) {
- fd_head = fragment_add(tvb, offset, pinfo, du_id, clnp_segment_table,
- segment_offset, segment_length - cnf_hdr_len,
+ fd_head = fragment_add_check(tvb, offset, pinfo, du_id, clnp_segment_table,
+ clnp_reassembled_table, segment_offset,
+ segment_length - cnf_hdr_len,
cnf_type & CNF_MORE_SEGS);
- if (fd_head != NULL) {
- fragment_data *fd;
- 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(fd_head->data, fd_head->datalen,
- fd_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 CLNP");
-
- /* It's not fragmented. */
- pinfo->fragmented = FALSE;
-
- /* show all segments */
- fi = proto_tree_add_item(clnp_tree, hf_clnp_segments,
- next_tvb, 0, -1, FALSE);
- ft = proto_item_add_subtree(fi, ett_clnp_segments);
- for (fd = fd_head->next; fd != NULL; fd = fd->next){
- if (fd->flags & (FD_OVERLAP|FD_OVERLAPCONFLICT
- |FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) {
- /* this segment has some flags set, create a subtree
- * for it and display the flags.
- */
- proto_tree *fet = NULL;
- proto_item *fei = NULL;
- int hf;
-
- if (fd->flags & (FD_OVERLAPCONFLICT
- |FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) {
- hf = hf_clnp_segment_error;
- } else {
- hf = hf_clnp_segment;
- }
- fei = proto_tree_add_none_format(ft, hf,
- next_tvb, fd->offset, fd->len,
- "Frame:%u payload:%u-%u",
- fd->frame,
- fd->offset,
- fd->offset+fd->len-1
- );
- fet = proto_item_add_subtree(fei, ett_clnp_segment);
- if (fd->flags&FD_OVERLAP) {
- proto_tree_add_boolean(fet,
- hf_clnp_segment_overlap, next_tvb, 0, 0,
- TRUE);
- }
- if (fd->flags&FD_OVERLAPCONFLICT) {
- proto_tree_add_boolean(fet,
- hf_clnp_segment_overlap_conflict, next_tvb, 0, 0,
- TRUE);
- }
- if (fd->flags&FD_MULTIPLETAILS) {
- proto_tree_add_boolean(fet,
- hf_clnp_segment_multiple_tails, next_tvb, 0, 0,
- TRUE);
- }
- if (fd->flags&FD_TOOLONGFRAGMENT) {
- proto_tree_add_boolean(fet,
- hf_clnp_segment_too_long_segment, next_tvb, 0, 0,
- TRUE);
- }
- } else {
- /* nothing of interest for this segment */
- proto_tree_add_none_format(ft, hf_clnp_segment,
- next_tvb, fd->offset, fd->len,
- "Frame:%u payload:%u-%u",
- fd->frame,
- fd->offset,
- fd->offset+fd->len-1
- );
- }
- }
- if (fd_head->flags & (FD_OVERLAPCONFLICT
- |FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) {
- if (check_col(pinfo->cinfo, COL_INFO)) {
- col_set_str(pinfo->cinfo, COL_INFO, "[Illegal segments]");
- update_col_info = FALSE;
- }
- }
- } else {
- /* We don't have the complete reassembled payload. */
- next_tvb = NULL;
- }
+ next_tvb = process_reassembled_data(tvb, offset, pinfo, "Reassembled CLNP",
+ fd_head, &clnp_frag_items, &update_col_info, clnp_tree);
} else {
/* If this is the first segment, dissect its contents, otherwise
just show it as a segment.
/* As we haven't reassembled anything, we haven't changed "pi", so
we don't have to restore it. */
- call_dissector(data_handle,tvb_new_subset(tvb, offset,-1,tvb_reported_length_remaining(tvb,offset)), pinfo, tree);
+ call_dissector(data_handle, tvb_new_subset(tvb, offset, -1, -1), pinfo,
+ tree);
pinfo->fragmented = save_fragmented;
return;
}
XXX - if this isn't the first Derived PDU of a segmented Initial
PDU, skip that? */
- if (nsel == (char)tp_nsap_selector || always_decode_transport) {
+ if (nsel == (char)tp_nsap_selector || always_decode_transport) {
if (dissect_ositp_internal(next_tvb, pinfo, tree, FALSE)) {
pinfo->fragmented = save_fragmented;
return; /* yes, it appears to be COTP or CLTP */
}
}
+ if (dissector_try_heuristic(clnp_heur_subdissector_list, next_tvb,
+ pinfo, tree)) {
+ pinfo->fragmented = save_fragmented;
+ return; /* yes, it appears to be COTP or CLTP */
+ }
+
break;
case ER_NPDU:
if (tree) {
next_length = tvb_length_remaining(tvb, offset);
if (next_length != 0) {
- /* We have payload; dissect it.
- Make the columns non-writable, so the packet isn't shown
- in the summary based on what the discarded PDU's contents
- are. */
- 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;
+ /* We have payload; dissect it. */
+ ti = proto_tree_add_text(clnp_tree, tvb, offset, next_length,
+ "Discarded PDU");
+ discpdu_tree = proto_item_add_subtree(ti, ett_clnp_disc_pdu);
/* Save the current value of the "we're inside an error packet"
flag, and set that flag; subdissectors may treat 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. */
- ti = proto_tree_add_text(clnp_tree, tvb, offset, next_length,
- "Discarded PDU");
- discpdu_tree = proto_item_add_subtree(ti, ett_clnp_disc_pdu);
- TRY {
- dissect_clnp(next_tvb, pinfo, discpdu_tree);
- }
- CATCH(ReportedBoundsError) {
- ; /* do nothing */
- }
- ENDTRY;
+ call_dissector(clnp_handle, next_tvb, pinfo, discpdu_tree);
/* 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;
}
}
pinfo->fragmented = save_fragmented;
clnp_reassemble_init(void)
{
fragment_table_init(&clnp_segment_table);
+ reassembled_table_init(&clnp_reassembled_table);
+}
+
+static void
+cotp_reassemble_init(void)
+{
+ fragment_table_init(&cotp_segment_table);
+ reassembled_table_init(&cotp_reassembled_table);
}
void proto_register_clnp(void)
{
static hf_register_info hf[] = {
{ &hf_clnp_id,
- { "Network Layer Protocol Identifier", "clnp.nlpi", FT_UINT8, BASE_HEX,
+ { "Network Layer Protocol Identifier", "clnp.nlpi", FT_UINT8, BASE_HEX,
VALS(nlpid_vals), 0x0, "", HFILL }},
{ &hf_clnp_length,
"Segment contained data past end of packet", HFILL }},
{ &hf_clnp_segment_error,
- { "Reassembly error", "clnp.segment.error", FT_NONE, BASE_DEC, NULL, 0x0,
+ { "Reassembly error", "clnp.segment.error", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
"Reassembly error due to illegal segments", HFILL }},
{ &hf_clnp_segment,
- { "CLNP Segment", "clnp.segment", FT_NONE, BASE_DEC, NULL, 0x0,
+ { "CLNP Segment", "clnp.segment", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
"CLNP Segment", HFILL }},
{ &hf_clnp_segments,
{ "CLNP Segments", "clnp.segments", FT_NONE, BASE_DEC, NULL, 0x0,
"CLNP Segments", HFILL }},
+
+ { &hf_clnp_reassembled_in,
+ { "Reassembled CLNP in frame", "clnp.reassembled_in", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
+ "This CLNP packet is reassembled in this frame", HFILL }}
};
static gint *ett[] = {
&ett_clnp,
proto_clnp = proto_register_protocol(PROTO_STRING_CLNP, "CLNP", "clnp");
proto_register_field_array(proto_clnp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
+ register_dissector("clnp", dissect_clnp, proto_clnp);
+ register_heur_dissector_list("clnp", &clnp_heur_subdissector_list);
+ register_init_routine(clnp_reassemble_init);
+ register_init_routine(cotp_reassemble_init);
clnp_module = prefs_register_protocol(proto_clnp, NULL);
prefs_register_uint_preference(clnp_module, "tp_nsap_selector",
- "NSAP selector for Transport Protocol (last byte in hexa)",
- "NSAP selector for Transport Protocol (last byte in hexa)",
+ "NSAP selector for Transport Protocol (last byte in hex)",
+ "NSAP selector for Transport Protocol (last byte in hex)",
16, &tp_nsap_selector);
prefs_register_bool_preference(clnp_module, "always_decode_transport",
"Always try to decode NSDU as transport PDUs",
&clnp_reassemble);
}
-void proto_register_cotp(void)
+void
+proto_reg_handoff_clnp(void)
{
- /* static hf_register_info hf[] = {
- { &variable,
- { "Name", "cotp.abbreviation", TYPE, VALS_POINTER }},
- };*/
- static gint *ett[] = {
- &ett_cotp,
- };
-
- proto_cotp = proto_register_protocol(PROTO_STRING_COTP, "COTP", "cotp");
- /* proto_register_field_array(proto_cotp, hf, array_length(hf));*/
- proto_register_subtree_array(ett, array_length(ett));
-
-/* subdissector code */
- register_heur_dissector_list("cotp_is", &cotp_is_heur_subdissector_list);
-
- /* XXX - what about CLTP? */
- register_dissector("ositp", dissect_ositp, proto_cotp);
+ data_handle = find_dissector("data");
+
+ clnp_handle = create_dissector_handle(dissect_clnp, proto_clnp);
+ dissector_add("osinl", NLPID_ISO8473_CLNP, clnp_handle);
+ dissector_add("osinl", NLPID_NULL, clnp_handle); /* Inactive subset */
+ dissector_add("x.25.spi", NLPID_ISO8473_CLNP, clnp_handle);
}
-void proto_register_cltp(void)
+void proto_register_cotp(void)
{
- /* static hf_register_info hf[] = {
- { &variable,
- { "Name", "cltp.abbreviation", TYPE, VALS_POINTER }},
- };*/
- static gint *ett[] = {
- &ett_cltp,
- };
-
- proto_cltp = proto_register_protocol(PROTO_STRING_CLTP, "CLTP", "cltp");
- /* proto_register_field_array(proto_cotp, hf, array_length(hf));*/
- proto_register_subtree_array(ett, array_length(ett));
- register_init_routine(clnp_reassemble_init);
+ static hf_register_info hf[] = {
+ { &hf_cotp_srcref,
+ { "Source reference", "cotp.srcref", FT_UINT16, BASE_HEX, NULL, 0x0,
+ "Source address reference", HFILL}},
+ { &hf_cotp_destref,
+ { "Destination reference", "cotp.destref", FT_UINT16, BASE_HEX, NULL, 0x0,
+ "Destination address reference", HFILL}},
+ { &hf_cotp_type,
+ { "COTP PDU Type", "cotp.type", FT_UINT8, BASE_HEX, VALS(cotp_tpdu_type_abbrev_vals), 0x0,
+ "COTP PDU Type", HFILL}},
+ { &hf_cotp_segment_overlap,
+ { "Segment overlap", "cotp.segment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "Segment overlaps with other segments", HFILL }},
+ { &hf_cotp_segment_overlap_conflict,
+ { "Conflicting data in segment overlap", "cotp.segment.overlap.conflict", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "Overlapping segments contained conflicting data", HFILL }},
+ { &hf_cotp_segment_multiple_tails,
+ { "Multiple tail segments found", "cotp.segment.multipletails", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "Several tails were found when reassembling the packet", HFILL }},
+ { &hf_cotp_segment_too_long_segment,
+ { "Segment too long", "cotp.segment.toolongsegment", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "Segment contained data past end of packet", HFILL }},
+ { &hf_cotp_segment_error,
+ { "Reassembly error", "cotp.segment.error", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
+ "Reassembly error due to illegal segments", HFILL }},
+ { &hf_cotp_segment,
+ { "COTP Segment", "cotp.segment", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
+ "COTP Segment", HFILL }},
+ { &hf_cotp_segments,
+ { "COTP Segments", "cotp.segments", FT_NONE, BASE_DEC, NULL, 0x0,
+ "COTP Segments", HFILL }},
+ { &hf_cotp_reassembled_in,
+ { "Reassembled COTP in frame", "cotp.reassembled_in", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
+ "This COTP packet is reassembled in this frame", HFILL }},
+
+ };
+ static gint *ett[] = {
+ &ett_cotp,
+ &ett_cotp_segment,
+ &ett_cotp_segments,
+ };
+
+ module_t *cotp_module;
+
+ proto_cotp = proto_register_protocol(PROTO_STRING_COTP, "COTP", "cotp");
+ proto_register_field_array(proto_cotp, hf, array_length(hf));
+ proto_register_subtree_array(ett, array_length(ett));
+ cotp_module = prefs_register_protocol(proto_cotp, NULL);
+
+ prefs_register_bool_preference(cotp_module, "reassemble",
+ "Reassemble segmented COTP datagrams",
+ "Whether segmented COTP datagrams should be reassembled",
+ &cotp_reassemble);
+
+ /* subdissector code in inactive subset */
+ register_heur_dissector_list("cotp_is", &cotp_is_heur_subdissector_list);
+
+ /* other COTP/ISO 8473 subdissectors */
+ register_heur_dissector_list("cotp", &cotp_heur_subdissector_list);
+
+ /* XXX - what about CLTP and proto_cltp? */
+ register_dissector("ositp", dissect_ositp, proto_cotp);
}
void
-proto_reg_handoff_clnp(void)
+proto_reg_handoff_cotp(void)
{
- dissector_handle_t clnp_handle;
+ dissector_handle_t ositp_handle;
- data_handle = find_dissector("data");
+ ositp_handle = find_dissector("ositp");
+ dissector_add("ip.proto", IP_PROTO_TP, ositp_handle);
+}
+
+void proto_register_cltp(void)
+{
+ static hf_register_info hf[] = {
+ { &hf_cltp_type,
+ { "CLTP PDU Type", "cltp.type", FT_UINT8, BASE_HEX, VALS(cltp_tpdu_type_abbrev_vals), 0x0,
+ "CLTP PDU Type", HFILL}},
+ };
+ static gint *ett[] = {
+ &ett_cltp,
+ };
- clnp_handle = create_dissector_handle(dissect_clnp, proto_clnp);
- dissector_add("osinl", NLPID_ISO8473_CLNP, clnp_handle);
- dissector_add("osinl", NLPID_NULL, clnp_handle); /* Inactive subset */
- dissector_add("x.25.spi", NLPID_ISO8473_CLNP, clnp_handle);
+ proto_cltp = proto_register_protocol(PROTO_STRING_CLTP, "CLTP", "cltp");
+ proto_register_field_array(proto_cltp, hf, array_length(hf));
+ proto_register_subtree_array(ett, array_length(ett));
}
git.samba.org / obnox / wireshark / wip.git / blobdiff