/* packet-clnp.c
* Routines for ISO/OSI network and transport protocol packet disassembly
*
- * $Id: packet-clnp.c,v 1.2 2000/04/16 09:10:53 deniel Exp $
+ * $Id: packet-clnp.c,v 1.57 2002/06/07 10:11:38 guy Exp $
* Laurent Deniel <deniel@worldnet.fr>
* Ralf Schneider <Ralf.Schneider@t-online.de>
*
* 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
* 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 <string.h>
#include <ctype.h>
#include <glib.h>
-#include "packet.h"
+#include "prefs.h"
+#include <epan/packet.h>
+#include "reassemble.h"
#include "packet-osi.h"
#include "packet-osi-options.h"
-#include "packet-clnp.h"
#include "packet-isis.h"
#include "packet-esis.h"
-#include "packet-h1.h"
#include "nlpid.h"
/* protocols and fields */
static int proto_clnp = -1;
-static int proto_cotp = -1;
static gint ett_clnp = -1;
+static gint ett_clnp_type = -1;
+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_dest = -1;
static int hf_clnp_src_length = -1;
static int hf_clnp_src = -1;
+static int hf_clnp_segments = -1;
+static int hf_clnp_segment = -1;
+static int hf_clnp_segment_overlap = -1;
+static int hf_clnp_segment_overlap_conflict = -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;
+
+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,
+ "segments"
+};
-
+static dissector_handle_t data_handle;
/*
* ISO 8473 OSI CLNP definition (see RFC994)
/* Fixed part */
-struct clnp_header {
- u_char cnf_proto_id; /* network layer protocol identifier */
- u_char cnf_hdr_len; /* length indicator (octets) */
- u_char cnf_vers; /* version/protocol identifier extension */
- u_char cnf_ttl; /* lifetime (500 milliseconds) */
- u_char cnf_type; /* type code */
- u_char cnf_seglen_msb; /* pdu segment length (octets) high byte */
- u_char cnf_seglen_lsb; /* pdu segment length (octets) low byte */
- u_char cnf_cksum_msb; /* checksum high byte */
- u_char cnf_cksum_lsb; /* checksum low byte */
-};
-
#define CNF_TYPE 0x1f
#define CNF_ERR_OK 0x20
#define CNF_MORE_SEGS 0x40
#define ERQ_NPDU 0x1E
#define ERP_NPDU 0x1F
-static const value_string npdu_type_vals[] = {
+static const value_string npdu_type_abbrev_vals[] = {
{ DT_NPDU, "DT" },
{ MD_NPDU, "MD" },
{ ER_NPDU, "ER" },
{ 0, NULL }
};
+static const value_string npdu_type_vals[] = {
+ { DT_NPDU, "Data" },
+ { MD_NPDU, "Multicast Data" },
+ { ER_NPDU, "Error Report" },
+ { ERQ_NPDU, "Echo Request" },
+ { ERP_NPDU, "Echo Response" },
+ { 0, NULL }
+};
+
/* field position */
-#define P_ADDRESS_PART 9
+#define P_CLNP_PROTO_ID 0
+#define P_CLNP_HDR_LEN 1
+#define P_CLNP_VERS 2
+#define P_CLNP_TTL 3
+#define P_CLNP_TYPE 4
+#define P_CLNP_SEGLEN 5
+#define P_CLNP_CKSUM 7
+#define P_CLNP_ADDRESS_PART 9
/* Segmentation part */
/* TPDU definition */
-#define ED_TPDU 0x1
-#define EA_TPDU 0x2
-#define RJ_TPDU 0x5
-#define AK_TPDU 0x6
-#define ER_TPDU 0x7
-#define DR_TPDU 0x8
-#define DC_TPDU 0xC
-#define CC_TPDU 0xD
-#define CR_TPDU 0xE
-#define DT_TPDU 0xF
+#define ED_TPDU 0x1 /* COTP */
+#define EA_TPDU 0x2 /* COTP */
+#define UD_TPDU 0x4 /* CLTP */
+#define RJ_TPDU 0x5 /* COTP */
+#define AK_TPDU 0x6 /* COTP */
+#define ER_TPDU 0x7 /* COTP */
+#define DR_TPDU 0x8 /* COTP */
+#define DC_TPDU 0xC /* COTP */
+#define CC_TPDU 0xD /* COTP */
+#define CR_TPDU 0xE /* COTP */
+#define DT_TPDU 0xF /* COTP */
/* field position */
#define P_TPDU_NR_234 4
#define P_VAR_PART_NDT 5
#define P_VAR_PART_EDT 8
-#define P_VAR_PART_NAK 5
-#define P_VAR_PART_CC 7
-#define P_VAR_PART_EAK 10
#define P_VAR_PART_DC 6
-#define P_VAR_PART_DR 7
#define P_CDT_IN_AK 8
#define P_CDT_IN_RJ 8
#define P_REJECT_ER 4
#define LI_MAX_AK 27
#define LI_MAX_EA 11
#define LI_MAX_ER 8
-#define LI_DC_WITH_CHECKSUM 9
-#define LI_DC_WITHOUT_CHECKSUM 5
-#define is_LI_NORMAL_AK(p) ( p & 0x01 )
+/* XXX - can we always decide this based on whether the length
+ indicator is odd or not? What if the variable part has an odd
+ number of octets? */
+#define is_LI_NORMAL_AK(p) ( ( p & 0x01 ) == 0 )
/* variant part */
#define VP_PROTECTION 0xC5
#define VP_OPT_SEL 0xC6
#define VP_PROTO_CLASS 0xC7
+#define VP_PREF_MAX_TPDU_SIZE 0xF0
+#define VP_INACTIVITY_TIMER 0xF2
+
+static const value_string tp_vpart_type_vals[] = {
+ { VP_ACK_TIME, "ack time" },
+ { VP_RES_ERROR, "res error" },
+ { VP_PRIORITY, "priority" },
+ { VP_TRANSIT_DEL, "transit delay" },
+ { VP_THROUGHPUT, "throughput" },
+ { VP_SEQ_NR, "seq number" },
+ { VP_REASSIGNMENT, "reassignment" },
+ { VP_FLOW_CNTL, "flow control" },
+ { VP_TPDU_SIZE, "tpdu-size" },
+ { VP_SRC_TSAP, "src-tsap" },
+ { VP_DST_TSAP, "dst-tsap" },
+ { VP_CHECKSUM, "checksum" },
+ { VP_VERSION_NR, "version" },
+ { VP_PROTECTION, "protection" },
+ { VP_OPT_SEL, "options" },
+ { VP_PROTO_CLASS, "proto class" },
+ { VP_PREF_MAX_TPDU_SIZE, "preferred max TPDU size" },
+ { 0, NULL }
+};
/* misc */
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;
+
+/*
+ * Reassembly of CLNP.
+ */
+static GHashTable *clnp_segment_table = NULL;
+
+/* options */
+static guint tp_nsap_selector = NSEL_TP;
+static gboolean always_decode_transport = FALSE;
+static gboolean clnp_reassemble = FALSE;
+
/* function definitions */
-static int osi_decode_DR(const u_char *pd, int offset,
- frame_data *fd, proto_tree *tree)
+#define MAX_TSAP_LEN 32
+static gchar *print_tsap(const u_char *tsap, int length)
+{
+
+ static gchar str[3][MAX_TSAP_LEN * 2 + 1];
+ static gchar *cur;
+ gchar tmp[3];
+ gboolean allprintable;
+ int i;
+
+ if (cur == &str[0][0]) {
+ cur = &str[1][0];
+ } else if (cur == &str[1][0]) {
+ cur = &str[2][0];
+ } else {
+ cur = &str[0][0];
+ }
+
+
+ cur[0] = '\0';
+ if (length <= 0 || length > MAX_TSAP_LEN)
+ sprintf(cur, "<unsupported TSAP length>");
+ else {
+ allprintable=TRUE;
+ for (i=0;i<length;i++) {
+ /* If any byte is not printable ASCII, display the TSAP as a
+ series of hex byte values rather than as a string; this
+ means that, for example, accented letters will cause it
+ to be displayed as hex, but it also means that byte values
+ such as 0xff and 0xfe, which *are* printable ISO 8859/x
+ characters, won't be treated as printable - 0xfffffffe
+ is probably binary, not text. */
+ if (!(isascii(tsap[i]) && isprint(tsap[i]))) {
+ allprintable=FALSE;
+ break;
+ }
+ }
+ if (!allprintable){
+ strcat(cur,"0x");
+ }
+ while (length != 0) {
+ if (allprintable)
+ sprintf(tmp, "%c", *tsap ++);
+ else
+ sprintf(tmp, "%02x", *tsap ++);
+ strcat(cur, tmp);
+ length --;
+ }
+ }
+ return cur;
+
+} /* print_tsap */
+
+static gboolean osi_decode_tp_var_part(tvbuff_t *tvb, int offset,
+ int vp_length, int class_option,
+ proto_tree *tree)
+{
+ guint8 code, length;
+ guint8 c1;
+ guint16 s, s1,s2,s3,s4;
+ guint32 t1, t2, t3, t4;
+ guint32 pref_max_tpdu_size;
+
+ while (vp_length != 0) {
+ code = tvb_get_guint8(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, 1,
+ "Parameter code: 0x%02x (%s)",
+ code,
+ val_to_str(code, tp_vpart_type_vals, "Unknown"));
+ offset += 1;
+ vp_length -= 1;
+
+ if (vp_length == 0)
+ break;
+ length = tvb_get_guint8(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, 1,
+ "Parameter length: %u", length);
+ offset += 1;
+ vp_length -= 1;
+
+ switch (code) {
+
+ case VP_ACK_TIME:
+ s = tvb_get_ntohs(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, length,
+ "Ack time (ms): %u", s);
+ offset += length;
+ vp_length -= length;
+ break;
+
+ case VP_RES_ERROR:
+ proto_tree_add_text(tree, tvb, offset, 1,
+ "Residual error rate, target value: 10^%u",
+ tvb_get_guint8(tvb, offset));
+ offset += 1;
+ length -= 1;
+ vp_length -= 1;
+
+ proto_tree_add_text(tree, tvb, offset, 1,
+ "Residual error rate, minimum acceptable: 10^%u",
+ tvb_get_guint8(tvb, offset));
+ offset += 1;
+ length -= 1;
+ vp_length -= 1;
+
+
+ proto_tree_add_text(tree, tvb, offset, 1,
+ "Residual error rate, TSDU size of interest: %u",
+ 1<<tvb_get_guint8(tvb, offset));
+ offset += 1;
+ length -= 1;
+ vp_length -= 1;
+
+ break;
+
+ case VP_PRIORITY:
+ s = tvb_get_ntohs(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, length,
+ "Priority: %u", s);
+ offset += length;
+ vp_length -= length;
+ break;
+
+ case VP_TRANSIT_DEL:
+ s1 = tvb_get_ntohs(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, 2,
+ "Transit delay, target value, calling-called: %u ms", s1);
+ offset += 2;
+ length -= 2;
+ vp_length -= 2;
+
+ s2 = tvb_get_ntohs(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, 2,
+ "Transit delay, maximum acceptable, calling-called: %u ms", s2);
+ offset += 2;
+ length -= 2;
+ vp_length -= 2;
+
+ s3 = tvb_get_ntohs(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, 2,
+ "Transit delay, target value, called-calling: %u ms", s3);
+ offset += 2;
+ length -= 2;
+ vp_length -= 2;
+
+ s4 = tvb_get_ntohs(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, 2,
+ "Transit delay, maximum acceptable, called-calling: %u ms", s4);
+ offset += 2;
+ length -= 2;
+ vp_length -= 2;
+ break;
+
+ case VP_THROUGHPUT:
+ t1 = tvb_get_ntoh24(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, 3,
+ "Maximum throughput, target value, calling-called: %u o/s", t1);
+ offset += 3;
+ length -= 3;
+ vp_length -= 3;
+
+ t2 = tvb_get_ntoh24(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, 3,
+ "Maximum throughput, minimum acceptable, calling-called: %u o/s", t2);
+ offset += 3;
+ length -= 3;
+ vp_length -= 3;
+
+ t3 = tvb_get_ntoh24(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, 3,
+ "Maximum throughput, target value, called-calling: %u o/s", t3);
+ offset += 3;
+ length -= 3;
+ vp_length -= 3;
+
+ t4 = tvb_get_ntoh24(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, 3,
+ "Maximum throughput, minimum acceptable, called-calling: %u o/s", t4);
+ offset += 3;
+ length -= 3;
+ vp_length -= 3;
+
+ if (length != 0) { /* XXX - should be 0 or 12 */
+ t1 = tvb_get_ntoh24(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, 3,
+ "Average throughput, target value, calling-called: %u o/s", t1);
+ offset += 3;
+ length -= 3;
+ vp_length -= 3;
+
+ t2 = tvb_get_ntoh24(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, 3,
+ "Average throughput, minimum acceptable, calling-called: %u o/s", t2);
+ offset += 3;
+ length -= 3;
+ vp_length -= 3;
+
+ t3 = tvb_get_ntoh24(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, 3,
+ "Average throughput, target value, called-calling: %u o/s", t3);
+ offset += 3;
+ length -= 3;
+ vp_length -= 3;
+
+ t4 = tvb_get_ntoh24(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, 3,
+ "Average throughput, minimum acceptable, called-calling: %u o/s", t4);
+ offset += 3;
+ length -= 3;
+ vp_length -= 3;
+ }
+ break;
+
+ case VP_SEQ_NR:
+ proto_tree_add_text(tree, tvb, offset, 2,
+ "Sequence number: 0x%04x", tvb_get_ntohs(tvb, offset));
+ offset += length;
+ vp_length -= length;
+ break;
+
+ case VP_REASSIGNMENT:
+ proto_tree_add_text(tree, tvb, offset, 2,
+ "Reassignment time: %u secs", tvb_get_ntohs(tvb, offset));
+ offset += length;
+ vp_length -= length;
+ break;
+
+ case VP_FLOW_CNTL:
+ proto_tree_add_text(tree, tvb, offset, 4,
+ "Lower window edge: 0x%08x", tvb_get_ntohl(tvb, offset));
+ offset += 4;
+ length -= 4;
+ vp_length -= 4;
+
+ proto_tree_add_text(tree, tvb, offset, 2,
+ "Sequence number: 0x%04x", tvb_get_ntohs(tvb, offset));
+ offset += 2;
+ length -= 2;
+ vp_length -= 2;
+
+ proto_tree_add_text(tree, tvb, offset, 2,
+ "Credit: 0x%04x", tvb_get_ntohs(tvb, offset));
+ offset += 2;
+ length -= 2;
+ vp_length -= 2;
+
+ break;
+
+ case VP_TPDU_SIZE:
+ c1 = tvb_get_guint8(tvb, offset) & 0x0F;
+ proto_tree_add_text(tree, tvb, offset, length,
+ "TPDU size: %u", 1 << c1);
+ offset += length;
+ vp_length -= length;
+ break;
+
+ case VP_SRC_TSAP:
+ proto_tree_add_text(tree, tvb, offset, length,
+ "Calling TSAP: %s",
+ print_tsap(tvb_get_ptr(tvb, offset, length), length));
+ offset += length;
+ vp_length -= length;
+ break;
+
+ case VP_DST_TSAP:
+ proto_tree_add_text(tree, tvb, offset, length,
+ "Called TSAP: %s",
+ print_tsap(tvb_get_ptr(tvb, offset, length), length));
+ offset += length;
+ vp_length -= length;
+ break;
+
+ case VP_CHECKSUM:
+ proto_tree_add_text(tree, tvb, offset, length,
+ "Checksum: 0x%04x", tvb_get_ntohs(tvb, offset));
+ offset += length;
+ vp_length -= length;
+ break;
+
+ case VP_VERSION_NR:
+ c1 = tvb_get_guint8(tvb, offset);
+ proto_tree_add_text(tree, tvb, offset, length,
+ "Version: %u", c1);
+ offset += length;
+ vp_length -= length;
+ break;
+
+ case VP_OPT_SEL:
+ c1 = tvb_get_guint8(tvb, offset) & 0x0F;
+ switch (class_option) {
+
+ case 1:
+ if (c1 & 0x8)
+ proto_tree_add_text(tree, tvb, offset, 1,
+ "Use of network expedited data");
+ else
+ proto_tree_add_text(tree, tvb, offset, 1,
+ "Non use of network expedited data");
+ if (c1 & 0x4)
+ proto_tree_add_text(tree, tvb, offset, 1,
+ "Use of Receipt confirmation");
+ else
+ proto_tree_add_text(tree, tvb, offset, 1,
+ "Use of explicit AK variant");
+ break;
+
+ case 4:
+ if (c1 & 0x2)
+ proto_tree_add_text(tree, tvb, offset, 1,
+ "Non-use 16 bit checksum in class 4");
+ else
+ proto_tree_add_text(tree, tvb, offset, 1,
+ "Use 16 bit checksum ");
+ break;
+ }
+ if (c1 & 0x1)
+ proto_tree_add_text(tree, tvb, offset, 1,
+ "Use of transport expedited data transfer\n");
+ else
+ proto_tree_add_text(tree, tvb, offset, 1,
+ "Non-use of transport expedited data transfer");
+ offset += length;
+ vp_length -= length;
+ break;
+
+ case VP_PREF_MAX_TPDU_SIZE:
+ switch (length) {
+
+ case 1:
+ pref_max_tpdu_size = tvb_get_guint8(tvb, offset);
+ break;
+
+ case 2:
+ pref_max_tpdu_size = tvb_get_ntohs(tvb, offset);
+ break;
+
+ case 3:
+ pref_max_tpdu_size = tvb_get_ntoh24(tvb, offset);
+ break;
+
+ case 4:
+ pref_max_tpdu_size = tvb_get_ntohl(tvb, offset);
+ break;
+
+ default:
+ proto_tree_add_text(tree, tvb, offset, length,
+ "Preferred maximum TPDU size: bogus length %u (not 1, 2, 3, or 4)",
+ length);
+ return FALSE;
+ }
+ proto_tree_add_text(tree, tvb, offset, length,
+ "Preferred maximum TPDU size: %u", pref_max_tpdu_size*128);
+ offset += length;
+ vp_length -= length;
+ break;
+
+ case VP_INACTIVITY_TIMER:
+ proto_tree_add_text(tree, tvb, offset, length,
+ "Inactivity timer: %u ms", tvb_get_ntohl(tvb, offset));
+ offset += length;
+ vp_length -= length;
+ break;
+
+ case VP_PROTECTION: /* user-defined */
+ case VP_PROTO_CLASS: /* todo */
+ default: /* unknown, no decoding */
+ proto_tree_add_text(tree, tvb, offset, length,
+ "Parameter value: <not shown>");
+ offset += length;
+ vp_length -= length;
+ break;
+ }
+ } /* while */
+
+ return TRUE;
+}
+
+static int osi_decode_DR(tvbuff_t *tvb, int offset,
+ packet_info *pinfo, proto_tree *tree)
{
proto_tree *cotp_tree;
proto_item *ti;
if (li < LI_MIN_DR)
return -1;
- src_ref = EXTRACT_SHORT(&pd[offset + P_SRC_REF]);
- reason = pd[offset + P_REASON_IN_DR];
+ src_ref = tvb_get_ntohs(tvb, offset + P_SRC_REF);
+ reason = tvb_get_guint8(tvb, offset + P_REASON_IN_DR);
switch(reason) {
case (128+0): str = "Normal Disconnect"; break;
break;
}
- if (check_col(fd, COL_INFO))
- col_append_fstr(fd, COL_INFO, "DR TPDU src-ref: 0x%04x dst-ref: 0x%04x",
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_fstr(pinfo->cinfo, COL_INFO,
+ "DR TPDU src-ref: 0x%04x dst-ref: 0x%04x",
src_ref, dst_ref);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, offset, li + 1, NULL);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
- proto_tree_add_text(cotp_tree, offset, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Length indicator: %u", li);
- proto_tree_add_text(cotp_tree, offset + 1, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset + 1, 1,
"TPDU code: 0x%x (DR)", tpdu);
- proto_tree_add_text(cotp_tree, offset + 2, 2,
+ proto_tree_add_text(cotp_tree, tvb, offset + 2, 2,
"Destination reference: 0x%04x", dst_ref);
- proto_tree_add_text(cotp_tree, offset + 4, 2,
+ proto_tree_add_text(cotp_tree, tvb, offset + 4, 2,
"Source reference: 0x%04x", src_ref);
- proto_tree_add_text(cotp_tree, offset + 6, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset + 6, 1,
"Cause: %s", str);
}
offset += li + 1;
- dissect_data(pd, offset, fd, tree);
- return pi.captured_len; /* we dissected all of the containing PDU */
+ /* User data */
+ 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 */
-/* Returns TRUE if we called a sub-dissector, FALSE if not. */
-static gboolean osi_decode_DT(const u_char *pd, int offset,
- frame_data *fd, proto_tree *tree,
- gboolean uses_inactive_subset)
+static int osi_decode_DT(tvbuff_t *tvb, int offset,
+ packet_info *pinfo, proto_tree *tree,
+ gboolean uses_inactive_subset,
+ gboolean *subdissector_found)
{
- proto_tree *cotp_tree;
+ proto_tree *cotp_tree = NULL;
proto_item *ti;
+ gboolean is_extended;
+ gboolean is_class_234;
u_int tpdu_nr ;
- u_short checksum = 0;
- u_char code = 0, length = 0;
u_int fragment = 0;
+ tvbuff_t *next_tvb;
+ /* 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.) */
switch (li) {
+
case LI_NORMAL_DT_WITH_CHECKSUM :
- tpdu_nr = pd[offset + P_TPDU_NR_234];
- if ( tpdu_nr & 0x80 )
- tpdu_nr = tpdu_nr & 0x7F;
- else
- fragment = 1;
- code = pd[offset + P_VAR_PART_NDT];
- if (code == VP_CHECKSUM)
- checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_NDT + 2]);
- else
+ if (tvb_get_guint8(tvb, offset + P_VAR_PART_NDT) != VP_CHECKSUM)
return -1;
- break;
+ /* FALLTHROUGH */
+
case LI_NORMAL_DT_WITHOUT_CHECKSUM :
- tpdu_nr = pd[offset + P_TPDU_NR_234];
+ tpdu_nr = tvb_get_guint8(tvb, offset + P_TPDU_NR_234);
if ( tpdu_nr & 0x80 )
tpdu_nr = tpdu_nr & 0x7F;
else
fragment = 1;
+ is_extended = FALSE;
+ is_class_234 = TRUE;
break;
+
case LI_EXTENDED_DT_WITH_CHECKSUM :
- tpdu_nr = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
- if ( tpdu_nr & 0x80000000 )
- tpdu_nr = tpdu_nr & 0x7FFFFFFF;
- else
- fragment = 1;
- code = pd[offset + P_VAR_PART_EDT];
- if (code == VP_CHECKSUM)
- checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_EDT + 2]);
- else
+ if (tvb_get_guint8(tvb, offset + P_VAR_PART_EDT) != VP_CHECKSUM)
return -1;
- break;
+ /* FALLTHROUGH */
+
case LI_EXTENDED_DT_WITHOUT_CHECKSUM :
- tpdu_nr = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
+ tpdu_nr = tvb_get_ntohl(tvb, offset + P_TPDU_NR_234);
if ( tpdu_nr & 0x80000000 )
tpdu_nr = tpdu_nr & 0x7FFFFFFF;
else
fragment = 1;
+ is_extended = TRUE;
+ is_class_234 = TRUE;
break;
+
case LI_NORMAL_DT_CLASS_01 :
- tpdu_nr = pd[offset + P_TPDU_NR_0_1];
+ tpdu_nr = tvb_get_guint8(tvb, offset + P_TPDU_NR_0_1);
if ( tpdu_nr & 0x80 )
tpdu_nr = tpdu_nr & 0x7F;
else
fragment = 1;
+ is_extended = FALSE;
+ is_class_234 = FALSE;
break;
+
default : /* bad TPDU */
return -1;
/*NOTREACHED*/
break;
}
- if (check_col(fd, COL_INFO))
- col_append_fstr(fd, COL_INFO, "DT TPDU (%u) dst-ref: 0x%04x %s",
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_fstr(pinfo->cinfo, COL_INFO, "DT TPDU (%u) dst-ref: 0x%04x %s",
tpdu_nr,
dst_ref,
(fragment)? "(fragment)" : "");
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, offset, li + 1, NULL);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
- proto_tree_add_text(cotp_tree, offset, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Length indicator: %u", li);
- proto_tree_add_text(cotp_tree, offset + 1, 1,
+ }
+ offset += 1;
+
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"TPDU code: 0x%x (DT)", tpdu);
- if (li != LI_NORMAL_DT_CLASS_01)
- proto_tree_add_text(cotp_tree, offset + 2, 2,
+ }
+ 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);
+ }
+ offset += 2;
+ li -= 2;
+ }
- switch (li) {
- case LI_NORMAL_DT_WITH_CHECKSUM :
- proto_tree_add_text(cotp_tree, offset + 4, 1,
- "TPDU number: 0x%02x (%s)",
- tpdu_nr,
- (fragment)? "fragment":"complete");
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NDT, 1,
- "Parameter code: 0x%02x (checksum)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NDT + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NDT + 2, length,
- "Checksum: 0x%04x", checksum);
- break;
- case LI_NORMAL_DT_WITHOUT_CHECKSUM :
- proto_tree_add_text(cotp_tree, offset + 4, 1,
- "TPDU number: 0x%02x (%s)",
- tpdu_nr,
- (fragment)? "fragment":"complete");
- break;
- case LI_EXTENDED_DT_WITH_CHECKSUM :
- proto_tree_add_text(cotp_tree, offset + 4, 4,
- "TPDU number: 0x%08x (%s)",
- tpdu_nr,
- (fragment)? "fragment":"complete");
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EDT, 1,
- "Parameter code: 0x%02x (checksum)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EDT + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EDT + 2, length,
- "Checksum: 0x%04x", checksum);
- break;
- case LI_EXTENDED_DT_WITHOUT_CHECKSUM :
- proto_tree_add_text(cotp_tree, offset + 4, 4,
+ if (is_extended) {
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 4,
"TPDU number: 0x%08x (%s)",
tpdu_nr,
(fragment)? "fragment":"complete");
- break;
- case LI_NORMAL_DT_CLASS_01 :
- proto_tree_add_text(cotp_tree, offset + 2, 1,
+ }
+ offset += 4;
+ li -= 4;
+ } else {
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"TPDU number: 0x%02x (%s)",
tpdu_nr,
(fragment)? "fragment":"complete");
- break;
}
- } /* tree */
+ offset += 1;
+ li -= 1;
+ }
- offset += li + 1;
+ if (tree)
+ osi_decode_tp_var_part(tvb, offset, li, 4, cotp_tree);
+ offset += li;
+
+ next_tvb = tvb_new_subset(tvb, offset, -1, -1);
if (uses_inactive_subset){
- dissect_h1(pd, offset, fd, tree);
- return TRUE;
- }
- else {
- dissect_data(pd, offset, fd, tree);
- return FALSE;
+ 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);
+ offset += tvb_length_remaining(tvb, offset);
+ /* we dissected all of the containing PDU */
+
+ return offset;
+
} /* osi_decode_DT */
-static int osi_decode_ED(const u_char *pd, int offset,
- frame_data *fd, proto_tree *tree)
+static int osi_decode_ED(tvbuff_t *tvb, int offset,
+ packet_info *pinfo, proto_tree *tree)
{
- proto_tree *cotp_tree;
+ proto_tree *cotp_tree = NULL;
proto_item *ti;
+ gboolean is_extended;
u_int tpdu_nr ;
- u_short checksum = 0;
- u_char code = 0, length = 0;
+ tvbuff_t *next_tvb;
/* ED TPDUs are never fragmented */
+ /* 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.) */
switch (li) {
+
case LI_NORMAL_DT_WITH_CHECKSUM :
- tpdu_nr = pd[offset + P_TPDU_NR_234];
- if ( tpdu_nr & 0x80 )
- tpdu_nr = tpdu_nr & 0x7F;
- else
- return -1;
- code = pd[offset + P_VAR_PART_NDT];
- length = pd[offset + P_VAR_PART_NDT + 1];
- if (code == VP_CHECKSUM)
- checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_NDT + 2]);
- else
+ if (tvb_get_guint8(tvb, offset + P_VAR_PART_NDT) != VP_CHECKSUM)
return -1;
- break;
+ /* FALLTHROUGH */
+
case LI_NORMAL_DT_WITHOUT_CHECKSUM :
- tpdu_nr = pd[offset + P_TPDU_NR_234];
+ tpdu_nr = tvb_get_guint8(tvb, offset + P_TPDU_NR_234);
if ( tpdu_nr & 0x80 )
tpdu_nr = tpdu_nr & 0x7F;
else
return -1;
+ is_extended = FALSE;
break;
+
case LI_EXTENDED_DT_WITH_CHECKSUM :
- tpdu_nr = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
- if ( tpdu_nr & 0x80000000 )
- tpdu_nr = tpdu_nr & 0x7FFFFFFF;
- else
- return -1;
- code = pd[offset + P_VAR_PART_EDT];
- length = pd[offset + P_VAR_PART_EDT + 1];
- if (code == VP_CHECKSUM)
- checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_EDT + 2]);
- else
+ if (tvb_get_guint8(tvb, offset + P_VAR_PART_EDT) != VP_CHECKSUM)
return -1;
- break;
+ /* FALLTHROUGH */
+
case LI_EXTENDED_DT_WITHOUT_CHECKSUM :
- tpdu_nr = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
+ tpdu_nr = tvb_get_ntohl(tvb, offset + P_TPDU_NR_234);
if ( tpdu_nr & 0x80000000 )
tpdu_nr = tpdu_nr & 0x7FFFFFFF;
else
return -1;
+ is_extended = TRUE;
break;
+
default : /* bad TPDU */
return -1;
/*NOTREACHED*/
break;
} /* li */
- if (check_col(fd, COL_INFO))
- col_append_fstr(fd, COL_INFO, "ED TPDU (%u) dst-ref: 0x%04x",
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_fstr(pinfo->cinfo, COL_INFO, "ED TPDU (%u) dst-ref: 0x%04x",
tpdu_nr, dst_ref);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, offset, li + 1, NULL);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
- proto_tree_add_text(cotp_tree, offset, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Length indicator: %u", li);
- proto_tree_add_text(cotp_tree, offset + 1, 1,
- "TPDU code: 0x%x (ED)", tpdu);
- proto_tree_add_text(cotp_tree, offset + 2, 2,
+ }
+ offset += 1;
+
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
+ "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);
+ }
+ offset += 2;
+ li -= 2;
- switch (li) {
- case LI_NORMAL_DT_WITH_CHECKSUM :
- proto_tree_add_text(cotp_tree, offset + 4, 1,
- "TPDU number: 0x%02x", tpdu_nr);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NDT, 1,
- "Parameter code: 0x%02x (checksum)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NDT + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NDT + 2, length,
- "Checksum: 0x%04x", checksum);
- break;
- case LI_NORMAL_DT_WITHOUT_CHECKSUM :
- proto_tree_add_text(cotp_tree, offset + 4, 1,
+ if (is_extended) {
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 4,
"TPDU number: 0x%02x", tpdu_nr);
- break;
- case LI_EXTENDED_DT_WITH_CHECKSUM :
- proto_tree_add_text(cotp_tree, offset + 4, 4,
+ }
+ offset += 4;
+ li -= 4;
+ } else {
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"TPDU number: 0x%02x", tpdu_nr);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EDT, 1,
- "Parameter code: 0x%02x (checksum)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EDT + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EDT + 2, length,
- "Checksum: 0x%04x", checksum);
- break;
- case LI_EXTENDED_DT_WITHOUT_CHECKSUM :
- proto_tree_add_text(cotp_tree, offset + 4, 4,
- "TPDU number: 0x%02x", tpdu_nr);
- break;
}
- } /* tree */
+ offset += 1;
+ li -= 1;
+ }
- offset += li + 1;
- dissect_data(pd, offset, fd, tree);
+ if (tree)
+ osi_decode_tp_var_part(tvb, offset, li, 4, cotp_tree);
+ offset += li;
- return pi.captured_len; /* we dissected all of the containing PDU */
+ next_tvb = tvb_new_subset(tvb, offset, -1, -1);
+ 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_ED */
-static int osi_decode_RJ(const u_char *pd, int offset,
- frame_data *fd, proto_tree *tree)
+static int osi_decode_RJ(tvbuff_t *tvb, int offset,
+ packet_info *pinfo, proto_tree *tree)
{
proto_tree *cotp_tree;
proto_item *ti;
switch(li) {
case LI_NORMAL_RJ :
- tpdu_nr = pd[offset + P_TPDU_NR_234];
+ tpdu_nr = tvb_get_guint8(tvb, offset + P_TPDU_NR_234);
break;
case LI_EXTENDED_RJ :
- tpdu_nr = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
- credit = EXTRACT_SHORT(&pd[offset + P_CDT_IN_RJ]);
+ tpdu_nr = tvb_get_ntohl(tvb, offset + P_TPDU_NR_234);
+ credit = tvb_get_ntohs(tvb, offset + P_CDT_IN_RJ);
break;
default :
return -1;
break;
}
- if (check_col(fd, COL_INFO))
- col_append_fstr(fd, COL_INFO, "RJ TPDU (%u) dst-ref: 0x%04x",
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_fstr(pinfo->cinfo, COL_INFO, "RJ TPDU (%u) dst-ref: 0x%04x",
tpdu_nr, dst_ref);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, offset, li + 1, NULL);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
- proto_tree_add_text(cotp_tree, offset, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Length indicator: %u", li);
- proto_tree_add_text(cotp_tree, offset + 1, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset + 1, 1,
"TPDU code: 0x%x (RJ)", tpdu);
if (li == LI_NORMAL_RJ)
- proto_tree_add_text(cotp_tree, offset + 1, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset + 1, 1,
"Credit: %u", cdt);
- proto_tree_add_text(cotp_tree, offset + 2, 2,
+ proto_tree_add_text(cotp_tree, tvb, offset + 2, 2,
"Destination reference: 0x%04x", dst_ref);
if (li == LI_NORMAL_RJ)
- proto_tree_add_text(cotp_tree, 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, 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, offset + 8, 2,
+ proto_tree_add_text(cotp_tree, tvb, offset + 8, 2,
"Credit: 0x%02x", credit);
}
}
} /* osi_decode_RJ */
-#define MAX_TSAP_LEN 32
-
-static gchar *print_tsap(const u_char *tsap, int length)
-{
-
- static gchar str[3][MAX_TSAP_LEN * 2 + 1];
- static gchar *cur;
- gchar tmp[3];
- gboolean allprintable;
- int i;
-
- if (cur == &str[0][0]) {
- cur = &str[1][0];
- } else if (cur == &str[1][0]) {
- cur = &str[2][0];
- } else {
- cur = &str[0][0];
- }
-
-
- cur[0] = '\0';
- if (length <= 0 || length > MAX_TSAP_LEN)
- sprintf(cur, "<unsupported TSAP length>");
- else {
- allprintable=TRUE;
- for (i=0;i<length;i++) {
- if (!isprint(tsap[i])) { /* if any byte is not printable */
- allprintable=FALSE; /* switch to hexdump */
- break;
- }
- }
- if (!allprintable){
- strcat(cur,"0x");
- }
- while (length != 0) {
- if (allprintable)
- sprintf(tmp, "%c", *tsap ++);
- else
- sprintf(tmp, "%02x", *tsap ++);
- strcat(cur, tmp);
- length --;
- }
- }
- return cur;
-
-} /* print_tsap */
-
-static int osi_decode_CC(const u_char *pd, int offset,
- frame_data *fd, proto_tree *tree)
+static int osi_decode_CC(tvbuff_t *tvb, int offset,
+ packet_info *pinfo, proto_tree *tree)
{
/* CC & CR decoding in the same function */
proto_tree *cotp_tree = NULL;
proto_item *ti;
- u_short src_ref, checksum;
- u_char class_option, code, length;
- u_int i = 0;
+ u_short src_ref;
+ u_char class_option;
- src_ref = EXTRACT_SHORT(&pd[offset + P_SRC_REF]);
- class_option = (pd[offset + P_CLASS_OPTION] >> 4 ) & 0x0F;
+ 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;
- if (check_col(fd, COL_INFO))
- col_append_fstr(fd, COL_INFO, "%s TPDU src-ref: 0x%04x dst-ref: 0x%04x",
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_fstr(pinfo->cinfo, COL_INFO,
+ "%s TPDU src-ref: 0x%04x dst-ref: 0x%04x",
(tpdu == CR_TPDU) ? "CR" : "CC",
src_ref,
dst_ref);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, offset, li + 1, NULL);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
- proto_tree_add_text(cotp_tree, offset, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Length indicator: %u", li);
- proto_tree_add_text(cotp_tree, offset + 1, 1,
+ }
+ offset += 1;
+
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"TPDU code: 0x%x (%s)", tpdu,
- (tpdu == CR_TPDU) ? "CR" : "CC");
- proto_tree_add_text(cotp_tree, offset + 2, 2,
+ (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);
- proto_tree_add_text(cotp_tree, offset + 4, 2,
+ }
+ offset += 2;
+ li -= 2;
+
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 2,
"Source reference: 0x%04x", src_ref);
- proto_tree_add_text(cotp_tree, offset + 6, 1,
+ }
+ offset += 2;
+ li -= 2;
+
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Class option: 0x%02x", class_option);
}
+ offset += 1;
+ li -= 1;
if (tree)
- while(li > P_VAR_PART_CC + i - 1) {
-
- u_char c1;
- u_short s, s1,s2,s3,s4;
- u_int t1,t2,t3,t4;
-
- switch( (code = pd[offset + P_VAR_PART_CC + i]) ) {
- case VP_CHECKSUM :
- length = pd[offset + P_VAR_PART_CC + i + 1];
- checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_CC + i + 2]);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i, 1,
- "Parameter code: 0x%02x (checksum)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, length,
- "Checksum: 0x%04x", checksum);
- i += length + 2;
- break;
- case VP_SRC_TSAP :
- length = pd[offset + P_VAR_PART_CC + i + 1];
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i, 1,
- "Parameter code: 0x%02x (src-tsap)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, length,
- "Calling TSAP: %s",
- print_tsap(&pd[offset + P_VAR_PART_CC + i + 2],
- length));
- i += length + 2;
- break;
- case VP_DST_TSAP :
- length = pd[offset + P_VAR_PART_CC + i + 1];
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i, 1,
- "Parameter code: 0x%02x (dst-tsap)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, length,
- "Called TSAP: %s",
- print_tsap(&pd[offset + P_VAR_PART_CC + i + 2],
- length));
- i += length + 2;
- break;
- case VP_TPDU_SIZE :
- length = pd[offset + P_VAR_PART_CC + i + 1];
- c1 = pd[offset + P_VAR_PART_CC + i + 2] & 0x0F;
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i, 1,
- "Parameter code: 0x%02x (tpdu-size)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, length,
- "TPDU size: %u", 2 << c1);
- i += length + 2;
- break;
- case VP_OPT_SEL :
- length = pd[offset + P_VAR_PART_CC + i + 1];
- c1 = pd[offset + P_VAR_PART_CC + i + 2] & 0x0F;
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i, 1,
- "Parameter code: 0x%02x (options)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 1, 1,
- "Parameter length: %u", length);
- if (class_option == 1) {
- if (c1 & 0x8)
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, 1,
- "Use of network expedited data");
- else
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, 1,
- "Non use of network expedited data");
- if (c1 & 0x4)
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, 1,
- "Use of Receipt confirmation");
- else
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, 1,
- "Use of explicit AK variant");
- } else if (class_option == 4) {
- if (c1 & 0x2)
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, 1,
- "Use 16 bit checksum ");
- else
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, 1,
- "Non-use 16 bit checksum in class 4");
- }
- if (c1 & 0x1)
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, 1,
- "Use of transport expedited data transfer\n");
- else
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, 1,
- "Non-use of transport expedited data transfer");
- i += length + 2;
- break;
- case VP_ACK_TIME :
- length = pd[offset + P_VAR_PART_CC + i + 1];
- s = EXTRACT_SHORT(&pd[offset + P_VAR_PART_CC + i + 2]);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i, 1,
- "Parameter code: 0x%02x (ack time)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, length,
- "Ack time (ms): %u", s);
- i += length + 2;
- break;
- case VP_THROUGHPUT :
- length = pd[offset + P_VAR_PART_CC + i + 1];
- t1 = EXTRACT_LONG(&pd[offset + P_VAR_PART_CC + i + 1]);
- t2 = EXTRACT_LONG(&pd[offset + P_VAR_PART_CC + i + 4]);
- t3 = EXTRACT_LONG(&pd[offset + P_VAR_PART_CC + i + 7]);
- t4 = EXTRACT_LONG(&pd[offset + P_VAR_PART_CC + i + 10]);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i, 1,
- "Parameter code: 0x%02x (throughput)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, 4,
- "Target value / calling-called: %u o/s", t1);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 6, 4,
- "Minimum / calling-called: %u o/s", t2);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 10, 4,
- "Target value / called-calling: %u o/s", t3);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 14, 4,
- "Minimum / called-calling: %u o/s", t4);
- i += length + 2;
- break;
- case VP_TRANSIT_DEL :
- length = pd[offset + P_VAR_PART_CC + i + 1];
- s1 = EXTRACT_SHORT(&pd[offset + P_VAR_PART_CC + i + 2]);
- s2 = EXTRACT_SHORT(&pd[offset + P_VAR_PART_CC + i + 4]);
- s3 = EXTRACT_SHORT(&pd[offset + P_VAR_PART_CC + i + 6]);
- s4 = EXTRACT_SHORT(&pd[offset + P_VAR_PART_CC + i + 8]);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i, 1,
- "Parameter code: 0x%02x (transit delay)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, 2,
- "Target value / calling-called: %u ms", s1);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 4, 2,
- "Minimum / calling-called: %u ms", s2);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 6, 2,
- "Target value / called-calling: %u ms", s3);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 8, 2,
- "Minimum / called-calling: %u ms", s4);
- i += length + 2;
- break;
- case VP_PRIORITY :
- length = pd[offset + P_VAR_PART_CC + i + 1];
- s = EXTRACT_SHORT(&pd[offset + P_VAR_PART_CC + i + 2]);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i, 1,
- "Parameter code: 0x%02x (priority)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, length,
- "Priority: %u", s);
- i += length + 2;
- break;
-
- case VP_VERSION_NR :
- length = pd[offset + P_VAR_PART_CC + i + 1];
- c1 = pd[offset + P_VAR_PART_CC + i + 2];
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i, 1,
- "Parameter code: 0x%02x (version)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, length,
- "Version: %u", c1);
- i += length + 2;
- break;
+ osi_decode_tp_var_part(tvb, offset, li, class_option, cotp_tree);
+ offset += li;
- case VP_REASSIGNMENT: /* todo */
- case VP_RES_ERROR :
- case VP_PROTECTION :
- case VP_PROTO_CLASS :
- default : /* no decoding */
- length = pd[offset + P_VAR_PART_CC + i + 1];
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 0, 1,
- "Parameter code: 0x%02x", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_CC + i + 2, length,
- "Parameter value: <not shown>");
- i += length + 2;
- break;
- }
- } /* while */
+ /* User data */
+ 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 */
- offset += li + 1;
- dissect_data(pd, offset, fd, tree);
-
- return pi.captured_len; /* we dissected all of the containing PDU */
+ return offset;
} /* osi_decode_CC */
-static int osi_decode_DC(const u_char *pd, int offset,
- frame_data *fd, proto_tree *tree)
+static int osi_decode_DC(tvbuff_t *tvb, int offset,
+ packet_info *pinfo, proto_tree *tree)
{
- proto_tree *cotp_tree;
+ proto_tree *cotp_tree = NULL;
proto_item *ti;
- u_short src_ref, checksum = 0;
- u_char length = 0, code = 0;
+ u_short src_ref;
if (li > LI_MAX_DC)
return -1;
- src_ref = EXTRACT_SHORT(&pd[offset + P_SRC_REF]);
-
- switch(li) {
- case LI_DC_WITHOUT_CHECKSUM :
- break;
- case LI_DC_WITH_CHECKSUM :
- if ((code = pd[offset + P_VAR_PART_DC]) != VP_CHECKSUM)
- return -1;
- length = pd[offset + P_VAR_PART_DC + 1];
- checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_DC + 2]);
- break;
- default :
- return -1;
- /*NOTREACHED*/
- break;
- } /* li */
+ src_ref = tvb_get_ntohs(tvb, offset + P_SRC_REF);
- if (check_col(fd, COL_INFO))
- col_append_fstr(fd, COL_INFO, "DC TPDU src-ref: 0x%04x dst-ref: 0x%04x",
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_fstr(pinfo->cinfo, COL_INFO,
+ "DC TPDU src-ref: 0x%04x dst-ref: 0x%04x",
src_ref,
dst_ref);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, offset, li + 1, NULL);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
- proto_tree_add_text(cotp_tree, offset, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Length indicator: %u", li);
- proto_tree_add_text(cotp_tree, offset + 1, 1,
- "TPDU code: 0x%x (DC)", tpdu);
- proto_tree_add_text(cotp_tree, offset + 2, 2,
+ }
+ offset += 1;
+
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
+ "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);
- proto_tree_add_text(cotp_tree, offset + 4, 2,
+ }
+ offset += 2;
+ li -= 2;
+
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 2,
"Source reference: 0x%04x", src_ref);
- if (code) {
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_DC + 0, 1,
- "Parameter code: 0x%02x (checksum)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_DC + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_DC + 2, 2,
- "Checksum: 0x%04x", checksum);
- }
}
+ offset += 2;
+ li -= 2;
- offset += li + 1;
+ if (tree)
+ osi_decode_tp_var_part(tvb, offset, li, 4, cotp_tree);
+ offset += li;
return offset;
} /* osi_decode_DC */
-static int osi_decode_AK(const u_char *pd, int offset,
- frame_data *fd, proto_tree *tree)
+static int osi_decode_AK(tvbuff_t *tvb, int offset,
+ packet_info *pinfo, proto_tree *tree)
{
proto_tree *cotp_tree = NULL;
proto_item *ti;
- u_int tpdu_nr,i =0, r_lower_window_edge ;
+ u_int tpdu_nr;
u_short cdt_in_ak;
- u_short checksum, seq_nr, r_seq_nr, r_cdt;
- u_char code, length;
if (li > LI_MAX_AK)
return -1;
- if (!is_LI_NORMAL_AK(li)) {
- tpdu_nr = pd[offset + P_TPDU_NR_234];
+ if (is_LI_NORMAL_AK(li)) {
+
+ tpdu_nr = tvb_get_guint8(tvb, offset + P_TPDU_NR_234);
- if (check_col(fd, COL_INFO))
- col_append_fstr(fd, COL_INFO, "AK TPDU (%u) dst-ref: 0x%04x",
+ if (check_col(pinfo->cinfo, COL_INFO))
+ 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, offset, li + 1, NULL);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
- proto_tree_add_text(cotp_tree, offset, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Length indicator: %u", li);
- proto_tree_add_text(cotp_tree, offset + 1, 1,
- "TPDU code: 0x%x (AK)", tpdu);
- proto_tree_add_text(cotp_tree, offset + 1, 1,
+ }
+ offset += 1;
+
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
+ "TPDU code: 0x%x (AK)", tpdu);
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Credit: %u", cdt);
- proto_tree_add_text(cotp_tree, offset + 2, 2,
+ }
+ offset += 1;
+ li -= 1;
+
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 2,
"Destination reference: 0x%04x", dst_ref);
- proto_tree_add_text(cotp_tree, offset + 4, 1,
- "Your TPDU number: 0x%02x", tpdu_nr);
}
+ offset += 2;
+ li -= 2;
- while(li > P_VAR_PART_NAK + i - 1) {
- switch( (code = pd[offset + P_VAR_PART_NAK + i]) ) {
- case VP_CHECKSUM :
- length = pd[offset + P_VAR_PART_NAK + i + 1];
- checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_NAK + i + 2]);
- if (tree) {
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NAK + i + 0, 1,
- "Parameter code: 0x%02x (checksum)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NAK + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NAK + i + 2, 2,
- "Checksum: 0x%04x", checksum);
- }
- i += length + 2;
- break;
- case VP_FLOW_CNTL :
- length = pd[offset + P_VAR_PART_NAK + i + 1];
- r_lower_window_edge =
- EXTRACT_LONG(&pd[offset + P_VAR_PART_NAK + i + 2]);
- r_seq_nr = EXTRACT_SHORT(&pd[offset + P_VAR_PART_NAK + i + 6]);
- r_cdt = EXTRACT_SHORT(&pd[offset + P_VAR_PART_NAK + i + 8]);
- if (tree) {
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NAK + i + 0, 1,
- "Parameter code: 0x%02x (flow control)",
- code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NAK + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NAK + i + 2, 4,
- "Lower window edge: 0x%08x",
- r_lower_window_edge);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NAK + i + 6, 2,
- "Sequence number: 0x%04x",
- r_seq_nr);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NAK + i + 8, 2,
- "Credit: 0x%04x",
- r_cdt);
- }
- i += length + 2;
- break;
- case VP_SEQ_NR :
- length = pd[offset + P_VAR_PART_NAK + i + 1];
- seq_nr = EXTRACT_SHORT(&pd[offset + P_VAR_PART_NAK + i + 2]);
- if (tree) {
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NAK + i + 0, 1,
- "Parameter code: 0x%02x (seq number)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NAK + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NAK + i + 2, 2,
- "Sequence number: 0x%04x", seq_nr);
- }
- i += length + 2;
- break;
- default :
- length = pd[offset + P_VAR_PART_NAK + i + 1];
- if (tree) {
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NAK + i + 0, 1,
- "Parameter code: 0x%02x (unknown)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NAK + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_NAK + i + 2, length,
- "Parameter value: <not shown>");
- }
- i += length + 2;
- break;
- } /* code */
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
+ "Your TPDU number: 0x%02x", tpdu_nr);
}
+ offset += 1;
+ li -= 1;
+
+ if (tree)
+ osi_decode_tp_var_part(tvb, offset, li, 4, cotp_tree);
+ offset += li;
+
} else { /* extended format */
- tpdu_nr = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
- cdt_in_ak = EXTRACT_SHORT(&pd[offset + P_CDT_IN_AK]);
+ 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(fd, COL_INFO))
- col_append_fstr(fd, COL_INFO, "AK TPDU (%u) dst-ref: 0x%04x",
+ if (check_col(pinfo->cinfo, COL_INFO))
+ 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, offset, li + 1, NULL);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
- proto_tree_add_text(cotp_tree, offset, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Length indicator: %u", li);
- proto_tree_add_text(cotp_tree, offset + 1, 1,
- "TPDU code: 0x%x (AK)", tpdu);
- proto_tree_add_text(cotp_tree, offset + 2, 2,
+ }
+ offset += 1;
+
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
+ "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);
- proto_tree_add_text(cotp_tree, offset + 4, 4,
+ }
+ offset += 2;
+ li -= 2;
+
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 4,
"Your TPDU number: 0x%08x", tpdu_nr);
- proto_tree_add_text(cotp_tree, offset + 8, 2,
- "Credit: 0x%04x", cdt_in_ak);
}
-
- while(li > P_VAR_PART_EAK + i - 1) {
- switch( (code = pd[offset + P_VAR_PART_EAK + i]) ) {
- case VP_CHECKSUM :
- length = pd[offset + P_VAR_PART_EAK + i + 1];
- checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_EAK + i + 2]);
- if (tree) {
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EAK + i + 0, 1,
- "Parameter code: 0x%02x (checksum)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EAK + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EAK + i + 2, 2,
- "Checksum: 0x%04x", checksum);
- }
- i += length + 2;
- break;
- case VP_FLOW_CNTL :
- length = pd[offset + P_VAR_PART_EAK + i + 1];
- r_lower_window_edge =
- EXTRACT_LONG(&pd[offset + P_VAR_PART_EAK + i + 2]);
- r_seq_nr = EXTRACT_SHORT(&pd[offset + P_VAR_PART_EAK + i + 6]);
- r_cdt = EXTRACT_SHORT(&pd[offset + P_VAR_PART_EAK + i + 8]);
- if (tree) {
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EAK + i + 0, 1,
- "Parameter code: 0x%02x (flow control)",
- code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EAK + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EAK + i + 2, 4,
- "Lower window edge: 0x%08x",
- r_lower_window_edge);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EAK + i + 6, 2,
- "Sequence number: 0x%04x",
- r_seq_nr);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EAK + i + 8, 2,
- "Credit: 0x%04x",
- r_cdt);
- }
- i += length + 2;
- break;
- case VP_SEQ_NR :
- length = pd[offset + P_VAR_PART_EAK + i + 1];
- seq_nr = EXTRACT_SHORT(&pd[offset + P_VAR_PART_EAK + i + 2]);
- if (tree) {
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EAK + i + 0, 1,
- "Parameter code: 0x%02x (seq number)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EAK + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EAK + i + 2, 2,
- "Sequence number: 0x%04x", seq_nr);
- }
- i += length + 2;
- break;
- default :
- length = pd[offset + P_VAR_PART_EAK + i + 1];
- if (tree) {
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EAK + i + 0, 1,
- "Parameter code: 0x%02x (unknown)", code);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EAK + i + 1, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree,
- offset + P_VAR_PART_EAK + i + 2, length,
- "Parameter value: <not shown>");
- }
- i += length + 2;
- break;
- } /* code */
+ offset += 4;
+ li -= 4;
+
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 2,
+ "Credit: 0x%04x", cdt_in_ak);
}
+ offset += 2;
+ li -= 2;
- } /* is_LI_NORMAL_AK */
+ if (tree)
+ osi_decode_tp_var_part(tvb, offset, li, 4, cotp_tree);
+ offset += li;
- offset += li + 1;
+ } /* is_LI_NORMAL_AK */
return offset;
} /* osi_decode_AK */
-static int osi_decode_EA(const u_char *pd, int offset,
- frame_data *fd, proto_tree *tree)
+static int osi_decode_EA(tvbuff_t *tvb, int offset,
+ packet_info *pinfo, proto_tree *tree)
{
- proto_tree *cotp_tree;
+ proto_tree *cotp_tree = NULL;
proto_item *ti;
+ gboolean is_extended;
u_int tpdu_nr ;
- u_short checksum = 0;
- u_char code = 0;
- u_char length = 0;
if (li > LI_MAX_EA)
return -1;
+ /* 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.) */
switch (li) {
+
case LI_NORMAL_EA_WITH_CHECKSUM :
- tpdu_nr = pd[offset + P_TPDU_NR_234];
- code = pd[offset + P_VAR_PART_NDT];
- length = pd[offset + P_VAR_PART_NDT + 1];
- if (code != VP_CHECKSUM || length != 1)
+ if (tvb_get_guint8(tvb, offset + P_VAR_PART_NDT) != VP_CHECKSUM ||
+ tvb_get_guint8(tvb, offset + P_VAR_PART_NDT + 1) != 2)
return -1;
- checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_NDT + 2]);
- break;
+ /* FALLTHROUGH */
+
case LI_NORMAL_EA_WITHOUT_CHECKSUM :
- tpdu_nr = pd[offset + P_TPDU_NR_234];
+ tpdu_nr = tvb_get_guint8(tvb, offset + P_TPDU_NR_234);
+ is_extended = FALSE;
break;
+
case LI_EXTENDED_EA_WITH_CHECKSUM :
- tpdu_nr = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
- code = pd[offset + P_VAR_PART_EDT];
- length = pd[offset + P_VAR_PART_EDT + 1];
- if (code != VP_CHECKSUM || length != 1)
+ if (tvb_get_guint8(tvb, offset + P_VAR_PART_EDT) != VP_CHECKSUM ||
+ tvb_get_guint8(tvb, offset + P_VAR_PART_EDT + 1) != 2)
return -1;
- checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_EDT + 2]);
- break;
+ /* FALLTHROUGH */
+
case LI_EXTENDED_EA_WITHOUT_CHECKSUM :
- tpdu_nr = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
+ tpdu_nr = tvb_get_ntohl(tvb, offset + P_TPDU_NR_234);
+ is_extended = TRUE;
break;
+
default : /* bad TPDU */
return -1;
/*NOTREACHED*/
break;
} /* li */
- if (check_col(fd, COL_INFO))
- col_append_fstr(fd, COL_INFO,
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_fstr(pinfo->cinfo, COL_INFO,
"EA TPDU (%u) dst-ref: 0x%04x", tpdu_nr, dst_ref);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, offset, li + 1, NULL);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
- proto_tree_add_text(cotp_tree, offset, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Length indicator: %u", li);
- proto_tree_add_text(cotp_tree, offset + 1, 1,
- "TPDU code: 0x%x (EA)", tpdu);
- proto_tree_add_text(cotp_tree, offset + 2, 2,
+ }
+ offset += 1;
+
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
+ "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);
+ }
+ offset += 2;
+ li -= 2;
- switch (li) {
- case LI_NORMAL_EA_WITH_CHECKSUM :
- proto_tree_add_text(cotp_tree, offset + 4, 1,
- "Your TPDU number: 0x%02x", tpdu_nr);
- proto_tree_add_text(cotp_tree, offset + 5, 1,
- "Parameter code: 0x%02x (checksum)", code);
- proto_tree_add_text(cotp_tree, offset + 6, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree, offset + 7, 2,
- "Checksum: 0x%04x", checksum);
- break;
- case LI_NORMAL_EA_WITHOUT_CHECKSUM :
- proto_tree_add_text(cotp_tree, offset + 4, 1,
- "Your TPDU number: 0x%02x", tpdu_nr);
- break;
- case LI_EXTENDED_EA_WITH_CHECKSUM :
- proto_tree_add_text(cotp_tree, offset + 4, 4,
- "Your TPDU number: 0x%08x", tpdu_nr);
- proto_tree_add_text(cotp_tree, offset + 8, 1,
- "Parameter code: 0x%02x (checksum)", code);
- proto_tree_add_text(cotp_tree, offset + 9, 1,
- "Parameter length: %u", length);
- proto_tree_add_text(cotp_tree, offset + 10, 2,
- "Checksum: 0x%04x", checksum);
- break;
- case LI_EXTENDED_EA_WITHOUT_CHECKSUM :
- proto_tree_add_text(cotp_tree, offset + 4, 4,
+ if (is_extended) {
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 4,
"Your TPDU number: 0x%08x", tpdu_nr);
- break;
- default :
- break;
- } /* li */
- } /* tree */
+ }
+ offset += 4;
+ li -= 4;
+ } else {
+ if (tree) {
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
+ "Your TPDU number: 0x%02x", tpdu_nr);
+ }
+ offset += 1;
+ li -= 1;
+ }
- offset += li + 1;
+ if (tree)
+ osi_decode_tp_var_part(tvb, offset, li, 4, cotp_tree);
+ offset += li;
return offset;
} /* osi_decode_EA */
-static int osi_decode_ER(const u_char *pd, int offset,
- frame_data *fd, proto_tree *tree)
+static int osi_decode_ER(tvbuff_t *tvb, int offset,
+ packet_info *pinfo, proto_tree *tree)
{
proto_tree *cotp_tree;
proto_item *ti;
if (li > LI_MAX_ER)
return -1;
- switch(pd[offset + P_REJECT_ER]) {
+ switch(tvb_get_guint8(tvb, offset + P_REJECT_ER)) {
case 0 :
str = "Reason not specified";
break;
break;
}
- if (check_col(fd, COL_INFO))
- col_append_fstr(fd, COL_INFO, "ER TPDU dst-ref: 0x%04x", dst_ref);
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_fstr(pinfo->cinfo, COL_INFO, "ER TPDU dst-ref: 0x%04x", dst_ref);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, offset, li + 1, NULL);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
- proto_tree_add_text(cotp_tree, offset, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset, 1,
"Length indicator: %u", li);
- proto_tree_add_text(cotp_tree, offset + 1, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset + 1, 1,
"TPDU code: 0x%x (ER)", tpdu);
- proto_tree_add_text(cotp_tree, offset + 2, 2,
+ proto_tree_add_text(cotp_tree, tvb, offset + 2, 2,
"Destination reference: 0x%04x", dst_ref);
- proto_tree_add_text(cotp_tree, offset + 4, 1,
+ proto_tree_add_text(cotp_tree, tvb, offset + 4, 1,
"Reject cause: %s", str);
}
} /* osi_decode_ER */
-/* Returns TRUE if we found at least one valid COTP PDU, FALSE
- otherwise. */
-static gboolean dissect_cotp_internal(const u_char *pd, int offset,
- frame_data *fd, proto_tree *tree,
- gboolean uses_inactive_subset)
+static int osi_decode_UD(tvbuff_t *tvb, int offset,
+ packet_info *pinfo, proto_tree *tree)
{
+ proto_item *ti;
+ proto_tree *cltp_tree = NULL;
+ tvbuff_t *next_tvb;
+
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_str(pinfo->cinfo, COL_INFO, "UD TPDU");
+
+ if (tree) {
+ ti = proto_tree_add_item(tree, proto_cltp, tvb, offset, li + 1, FALSE);
+ cltp_tree = proto_item_add_subtree(ti, ett_cltp);
+ proto_tree_add_text(cltp_tree, tvb, offset, 1,
+ "Length indicator: %u", li);
+ }
+ offset += 1;
+
+ if (tree) {
+ proto_tree_add_text(cltp_tree, tvb, offset, 1,
+ "TPDU code: 0x%x (UD)", tpdu);
+ }
+ offset += 1;
+ li -= 1;
+
+ if (tree)
+ osi_decode_tp_var_part(tvb, offset, li, 0, cltp_tree);
+ offset += li;
+
+ next_tvb = tvb_new_subset(tvb, offset, -1, -1);
+ 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_UD */
+
+/* Returns TRUE if we found at least one valid COTP or CLTP PDU, FALSE
+ otherwise.
+
+ There doesn't seem to be any way in which the OSI network layer protocol
+ distinguishes between COTP and CLTP, but the first two octets of both
+ protocols' headers mean the same thing - length and PDU type - and the
+ 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)
+{
+ int offset = 0;
gboolean first_tpdu = TRUE;
int new_offset;
- gboolean found_cotp = FALSE;
+ gboolean found_ositp = FALSE;
+ gboolean is_cltp = FALSE;
gboolean subdissector_found = FALSE;
+ if (!proto_is_protocol_enabled(proto_cotp))
+ return FALSE; /* COTP has been disabled */
+ /* XXX - what about CLTP? */
+
+ pinfo->current_proto = "COTP";
+
/* Initialize the COL_INFO field; each of the TPDUs will have its
information appended. */
- if (check_col(fd, COL_INFO))
- col_add_str(fd, COL_INFO, "");
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_add_str(pinfo->cinfo, COL_INFO, "");
- while (IS_DATA_IN_FRAME(offset)) {
+ while (tvb_offset_exists(tvb, offset)) {
if (!first_tpdu) {
- if (check_col(fd, COL_INFO))
- col_append_str(fd, COL_INFO, ", ");
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_str(pinfo->cinfo, COL_INFO, ", ");
}
- if ((li = pd[offset + P_LI]) == 0) {
- if (check_col(fd, COL_INFO))
- col_append_str(fd, COL_INFO, "Length indicator is zero");
+ if ((li = tvb_get_guint8(tvb, offset + P_LI)) == 0) {
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_str(pinfo->cinfo, COL_INFO, "Length indicator is zero");
if (!first_tpdu)
- dissect_data(pd, offset, fd, tree);
- return found_cotp;
- }
- if (!BYTES_ARE_IN_FRAME(offset, P_LI + li + 1)) {
- if (check_col(fd, COL_INFO))
- col_append_str(fd, COL_INFO, "Captured data in frame doesn't include entire frame");
- if (!first_tpdu)
- dissect_data(pd, offset, fd, tree);
- return found_cotp;
+ call_dissector(data_handle, tvb_new_subset(tvb, offset, -1, -1),
+ pinfo, tree);
+ return found_ositp;
}
- tpdu = (pd[offset + P_TPDU] >> 4) & 0x0F;
- cdt = pd[offset + P_CDT] & 0x0F;
- dst_ref = EXTRACT_SHORT(&pd[offset + P_DST_REF]);
+ tpdu = (tvb_get_guint8(tvb, offset + P_TPDU) >> 4) & 0x0F;
+ 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(pd, offset, fd, tree);
+ new_offset = osi_decode_CC(tvb, offset, pinfo, tree);
break;
case DR_TPDU :
- new_offset = osi_decode_DR(pd, offset, fd, tree);
+ new_offset = osi_decode_DR(tvb, offset, pinfo, tree);
break;
case DT_TPDU :
- if (osi_decode_DT(pd, offset, fd, tree, uses_inactive_subset))
- subdissector_found = TRUE;
- new_offset = pi.captured_len; /* DT PDUs run to the end of the packet */
+ new_offset = osi_decode_DT(tvb, offset, pinfo, tree,
+ uses_inactive_subset, &subdissector_found);
break;
case ED_TPDU :
- new_offset = osi_decode_ED(pd, offset, fd, tree);
+ new_offset = osi_decode_ED(tvb, offset, pinfo, tree);
break;
case RJ_TPDU :
- new_offset = osi_decode_RJ(pd, offset, fd, tree);
+ new_offset = osi_decode_RJ(tvb, offset, pinfo, tree);
break;
case DC_TPDU :
- new_offset = osi_decode_DC(pd, offset, fd, tree);
+ new_offset = osi_decode_DC(tvb, offset, pinfo, tree);
break;
case AK_TPDU :
- new_offset = osi_decode_AK(pd, offset, fd, tree);
+ new_offset = osi_decode_AK(tvb, offset, pinfo, tree);
break;
case EA_TPDU :
- new_offset = osi_decode_EA(pd, offset, fd, tree);
+ new_offset = osi_decode_EA(tvb, offset, pinfo, tree);
break;
case ER_TPDU :
- new_offset = osi_decode_ER(pd, offset, fd, tree);
+ new_offset = osi_decode_ER(tvb, offset, pinfo, tree);
+ break;
+ case UD_TPDU :
+ new_offset = osi_decode_UD(tvb, offset, pinfo, tree);
+ is_cltp = TRUE;
break;
default :
- if (first_tpdu && check_col(fd, COL_INFO))
- col_append_fstr(fd, COL_INFO, "Unknown TPDU type (0x%x)", tpdu);
+ if (first_tpdu && check_col(pinfo->cinfo, COL_INFO))
+ col_append_fstr(pinfo->cinfo, COL_INFO, "Unknown TPDU type (0x%x)", tpdu);
new_offset = -1; /* bad PDU type */
break;
}
if (new_offset == -1) { /* incorrect TPDU */
if (!first_tpdu)
- dissect_data(pd, offset, fd, tree);
+ call_dissector(data_handle, tvb_new_subset(tvb, offset, -1, -1),
+ pinfo, tree);
break;
}
if (first_tpdu) {
- /* Well, we found at least one valid COTP PDU, so I guess this
- is COTP. */
- if (!subdissector_found && check_col(fd, COL_PROTOCOL))
- col_add_str(fd, COL_PROTOCOL, "COTP");
- found_cotp = TRUE;
+ /* Well, we found at least one valid COTP or CLTP PDU, so I guess this
+ is either COTP or CLTP. */
+ if (!subdissector_found && check_col(pinfo->cinfo, COL_PROTOCOL))
+ col_set_str(pinfo->cinfo, COL_PROTOCOL, is_cltp ? "CLTP" : "COTP");
+ found_ositp = TRUE;
}
offset = new_offset;
first_tpdu = FALSE;
}
- return found_cotp;
-} /* dissect_cotp_internal */
+ return found_ositp;
+} /* dissect_ositp_internal */
-void dissect_cotp(const u_char *pd, int offset, frame_data *fd,
- proto_tree *tree)
+static void dissect_ositp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
- if (!dissect_cotp_internal(pd, offset, fd, tree, FALSE))
- dissect_data(pd, offset, fd, tree);
+ if (!dissect_ositp_internal(tvb, pinfo, tree, FALSE))
+ call_dissector(data_handle,tvb, pinfo, tree);
}
* CLNP part / main entry point
*/
-void dissect_clnp(const u_char *pd, int offset, frame_data *fd,
- proto_tree *tree)
+static void dissect_clnp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
-
- struct clnp_header clnp;
proto_tree *clnp_tree = NULL;
proto_item *ti;
+ guint8 cnf_proto_id;
+ guint8 cnf_hdr_len;
+ guint8 cnf_vers;
+ guint8 cnf_ttl;
+ guint8 cnf_type;
+ char flag_string[6+1];
+ char *pdu_type_string;
+ proto_tree *type_tree;
+ guint16 segment_length;
+ guint16 du_id = 0;
+ guint16 segment_offset = 0;
+ guint16 cnf_cksum;
+ cksum_status_t cksum_status;
+ int offset;
u_char src_len, dst_len, nsel, opt_len = 0;
- u_int first_offset = offset;
- char flag_string[6+1];
- char *pdu_type_string;
- guint16 segment_length;
- guint16 segment_offset = 0;
- guint len;
-
- if (check_col(fd, COL_PROTOCOL))
- col_add_str(fd, COL_PROTOCOL, "CLNP");
-
- /* avoid alignment problem */
- memcpy(&clnp, &pd[offset], sizeof(clnp));
-
- if (clnp.cnf_proto_id == NLPID_NULL) {
- if (check_col(fd, COL_INFO))
- col_add_str(fd, COL_INFO, "Inactive subset");
+ 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;
+ gboolean update_col_info = TRUE;
+ gboolean save_fragmented;
+
+ if (check_col(pinfo->cinfo, COL_PROTOCOL))
+ col_set_str(pinfo->cinfo, COL_PROTOCOL, "CLNP");
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_clear(pinfo->cinfo, COL_INFO);
+
+ cnf_proto_id = tvb_get_guint8(tvb, P_CLNP_PROTO_ID);
+ if (cnf_proto_id == NLPID_NULL) {
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_set_str(pinfo->cinfo, COL_INFO, "Inactive subset");
if (tree) {
- ti = proto_tree_add_item(tree, proto_clnp, offset, 1, NULL);
+ 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, offset, 1,
- clnp.cnf_proto_id,
+ proto_tree_add_uint_format(clnp_tree, hf_clnp_id, tvb, P_CLNP_PROTO_ID, 1,
+ cnf_proto_id,
"Inactive subset");
}
- dissect_cotp_internal(pd, offset+1, fd, tree, TRUE);
+ next_tvb = tvb_new_subset(tvb, 1, -1, -1);
+ dissect_ositp_internal(next_tvb, pinfo, tree, TRUE);
return;
}
- if (!BYTES_ARE_IN_FRAME(offset, sizeof(clnp))) {
- dissect_data(pd, offset, fd, tree);
- return;
- }
-
/* return if version not known */
- if (clnp.cnf_vers != ISO8473_V1) {
- dissect_data(pd, offset, fd, tree);
+ cnf_vers = tvb_get_guint8(tvb, P_CLNP_VERS);
+ if (cnf_vers != ISO8473_V1) {
+ call_dissector(data_handle,tvb, pinfo, tree);
return;
}
/* fixed part decoding */
- opt_len = clnp.cnf_hdr_len;
+ cnf_hdr_len = tvb_get_guint8(tvb, P_CLNP_HDR_LEN);
+ opt_len = cnf_hdr_len;
- segment_length = EXTRACT_SHORT(&clnp.cnf_seglen_msb);
+ 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,
+ 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,
+ 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,
+ cnf_ttl,
+ "Holding Time : %u (%u.%u secs)",
+ cnf_ttl, cnf_ttl / 2, (cnf_ttl % 2) * 5);
+ }
+
+ cnf_type = tvb_get_guint8(tvb, P_CLNP_TYPE);
+ pdu_type_string = val_to_str(cnf_type & CNF_TYPE, npdu_type_abbrev_vals,
+ "Unknown (0x%02x)");
flag_string[0] = '\0';
- if (clnp.cnf_type & CNF_SEG_OK)
+ if (cnf_type & CNF_SEG_OK)
strcat(flag_string, "S ");
- if (clnp.cnf_type & CNF_MORE_SEGS)
+ if (cnf_type & CNF_MORE_SEGS)
strcat(flag_string, "M ");
- if (clnp.cnf_type & CNF_ERR_OK)
+ if (cnf_type & CNF_ERR_OK)
strcat(flag_string, "E ");
- pdu_type_string = val_to_str(clnp.cnf_type & CNF_TYPE, npdu_type_vals,
- "Unknown (0x%02x)");
if (tree) {
- ti = proto_tree_add_item(tree, proto_clnp, offset, clnp.cnf_hdr_len, NULL);
- clnp_tree = proto_item_add_subtree(ti, ett_clnp);
- proto_tree_add_item(clnp_tree, hf_clnp_id, offset, 1,
- clnp.cnf_proto_id);
- proto_tree_add_item(clnp_tree, hf_clnp_length, offset + 1, 1,
- clnp.cnf_hdr_len);
- proto_tree_add_item(clnp_tree, hf_clnp_version, offset + 2, 1,
- clnp.cnf_vers);
- proto_tree_add_uint_format(clnp_tree, hf_clnp_ttl, offset + 3, 1,
- clnp.cnf_ttl,
- "Holding Time : %u (%u secs)",
- clnp.cnf_ttl, clnp.cnf_ttl / 2);
- proto_tree_add_uint_format(clnp_tree, hf_clnp_type, offset + 4, 1,
- clnp.cnf_type,
+ ti = proto_tree_add_uint_format(clnp_tree, hf_clnp_type, tvb, P_CLNP_TYPE, 1,
+ cnf_type,
"PDU Type : 0x%02x (%s%s)",
- clnp.cnf_type,
+ cnf_type,
flag_string,
pdu_type_string);
- proto_tree_add_item(clnp_tree, hf_clnp_pdu_length, offset + 5, 2,
+ type_tree = proto_item_add_subtree(ti, ett_clnp_type);
+ proto_tree_add_text(type_tree, tvb, P_CLNP_TYPE, 1, "%s",
+ decode_boolean_bitfield(cnf_type, CNF_SEG_OK, 8,
+ "Segmentation permitted",
+ "Segmentation not permitted"));
+ proto_tree_add_text(type_tree, tvb, P_CLNP_TYPE, 1, "%s",
+ decode_boolean_bitfield(cnf_type, CNF_MORE_SEGS, 8,
+ "More segments",
+ "Last segment"));
+ proto_tree_add_text(type_tree, tvb, P_CLNP_TYPE, 1, "%s",
+ decode_boolean_bitfield(cnf_type, CNF_ERR_OK, 8,
+ "Report error if PDU discarded",
+ "Don't report error if PDU discarded"));
+ proto_tree_add_text(type_tree, tvb, P_CLNP_TYPE, 1, "%s",
+ decode_enumerated_bitfield(cnf_type, CNF_TYPE, 8,
+ npdu_type_vals, "%s"));
+ }
+
+ /* If we don't have the full header - i.e., not enough to see the
+ segmentation part and determine whether this datagram is segmented
+ or not - set the Info column now; we'll get an exception before
+ we set it otherwise. */
+
+ if (!tvb_bytes_exist(tvb, 0, cnf_hdr_len)) {
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_add_fstr(pinfo->cinfo, COL_INFO, "%s NPDU %s", pdu_type_string, flag_string);
+ }
+
+ segment_length = tvb_get_ntohs(tvb, P_CLNP_SEGLEN);
+ cnf_cksum = tvb_get_ntohs(tvb, P_CLNP_CKSUM);
+ cksum_status = calc_checksum(tvb, 0, cnf_hdr_len, cnf_cksum);
+ if (tree) {
+ proto_tree_add_uint(clnp_tree, hf_clnp_pdu_length, tvb, P_CLNP_SEGLEN, 2,
segment_length);
- proto_tree_add_uint_format(clnp_tree, hf_clnp_checksum, offset + 7, 2,
- EXTRACT_SHORT(&clnp.cnf_cksum_msb),
+ switch (cksum_status) {
+
+ default:
+ /*
+ * No checksum present, or not enough of the header present to
+ * checksum it.
+ */
+ proto_tree_add_uint_format(clnp_tree, hf_clnp_checksum, tvb,
+ P_CLNP_CKSUM, 2,
+ cnf_cksum,
"Checksum : 0x%04x",
- EXTRACT_SHORT(&clnp.cnf_cksum_msb));
- opt_len -= 9; /* Fixed part of Hesder */
- } /* tree */
+ cnf_cksum);
+ break;
- /* stop here if header is not complete */
+ case CKSUM_OK:
+ /*
+ * Checksum is correct.
+ */
+ proto_tree_add_uint_format(clnp_tree, hf_clnp_checksum, tvb,
+ P_CLNP_CKSUM, 2,
+ cnf_cksum,
+ "Checksum : 0x%04x (correct)",
+ cnf_cksum);
+ break;
- if (!BYTES_ARE_IN_FRAME(offset, clnp.cnf_hdr_len)) {
- if (check_col(fd, COL_INFO))
- col_add_fstr(fd, COL_INFO, "%s NPDU %s", pdu_type_string, flag_string);
- dissect_data(pd, offset, fd, tree);
- return;
- }
+ case CKSUM_NOT_OK:
+ /*
+ * Checksum is not correct.
+ */
+ proto_tree_add_uint_format(clnp_tree, hf_clnp_checksum, tvb,
+ P_CLNP_CKSUM, 2,
+ cnf_cksum,
+ "Checksum : 0x%04x (incorrect)",
+ cnf_cksum);
+ break;
+ }
+ opt_len -= 9; /* Fixed part of Hesder */
+ } /* tree */
/* address part */
- offset += P_ADDRESS_PART;
- dst_len = pd[offset];
- nsel = pd[offset + dst_len];
- src_len = pd[offset + dst_len + 1];
+ offset = P_CLNP_ADDRESS_PART;
+ dst_len = tvb_get_guint8(tvb, offset);
+ dst_addr = tvb_get_ptr(tvb, offset + 1, dst_len);
+ nsel = tvb_get_guint8(tvb, offset + dst_len);
+ src_len = tvb_get_guint8(tvb, offset + dst_len + 1);
+ src_addr = tvb_get_ptr(tvb, offset + dst_len + 2, src_len);
if (tree) {
- proto_tree_add_item(clnp_tree, hf_clnp_dest_length, 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, offset + 1 , dst_len,
- &pd[offset + 1],
+ proto_tree_add_bytes_format(clnp_tree, hf_clnp_dest, tvb, offset + 1 , dst_len,
+ dst_addr,
" DA : %s",
- print_nsap_net(&pd[offset + 1], dst_len));
- proto_tree_add_item(clnp_tree, hf_clnp_src_length,
+ print_nsap_net(dst_addr, dst_len));
+ 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,
+ proto_tree_add_bytes_format(clnp_tree, hf_clnp_src, tvb,
offset + dst_len + 2, src_len,
- &pd[offset + dst_len + 2],
+ src_addr,
" SA : %s",
- print_nsap_net(&pd[offset + dst_len + 2], src_len));
+ print_nsap_net(src_addr, src_len));
opt_len -= dst_len + src_len +2;
}
- if (check_col(fd, COL_RES_NET_SRC))
- col_add_fstr(fd, COL_RES_NET_SRC, "%s",
- print_nsap_net(&pd[offset + dst_len + 2], src_len));
- if (check_col(fd, COL_RES_NET_DST))
- col_add_fstr(fd, COL_RES_NET_DST, "%s",
- print_nsap_net(&pd[offset + 1], dst_len));
+ SET_ADDRESS(&pinfo->net_src, AT_OSI, src_len, src_addr);
+ SET_ADDRESS(&pinfo->src, AT_OSI, src_len, src_addr);
+ SET_ADDRESS(&pinfo->net_dst, AT_OSI, dst_len, dst_addr);
+ SET_ADDRESS(&pinfo->dst, AT_OSI, dst_len, dst_addr);
/* Segmentation Part */
offset += dst_len + src_len + 2;
- if (clnp.cnf_type & CNF_SEG_OK) {
+ if (cnf_type & CNF_SEG_OK) {
struct clnp_segment seg; /* XXX - not used */
- memcpy(&seg, &pd[offset], sizeof(seg)); /* XXX - not used */
+ tvb_memcpy(tvb, (guint8 *)&seg, offset, sizeof(seg)); /* XXX - not used */
- segment_offset = EXTRACT_SHORT(&pd[offset + 2]);
+ segment_offset = tvb_get_ntohs(tvb, offset + 2);
+ du_id = tvb_get_ntohs(tvb, offset);
if (tree) {
- proto_tree_add_text(clnp_tree, offset, 2,
+ proto_tree_add_text(clnp_tree, tvb, offset, 2,
"Data unit identifier: %06u",
- EXTRACT_SHORT(&pd[offset]));
- proto_tree_add_text(clnp_tree, offset + 2 , 2,
+ du_id);
+ proto_tree_add_text(clnp_tree, tvb, offset + 2 , 2,
"Segment offset : %6u",
segment_offset);
- proto_tree_add_text(clnp_tree, offset + 4 , 2,
+ proto_tree_add_text(clnp_tree, tvb, offset + 4 , 2,
"Total length : %6u",
- EXTRACT_SHORT(&pd[offset + 4]));
+ tvb_get_ntohs(tvb, offset + 4));
}
offset += 6;
if (tree) {
/* To do : decode options */
/*
- proto_tree_add_text(clnp_tree, offset,
- clnp.cnf_hdr_len + first_offset - 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,
- pd, offset, fd, clnp_tree );
+ dissect_osi_options( opt_len,
+ tvb, offset, clnp_tree );
}
/* Length of CLNP datagram plus headers above it. */
- len = segment_length + first_offset;
-
- /* Set the payload and captured-payload lengths to the minima of (the
- datagram 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;
-
- offset = first_offset + clnp.cnf_hdr_len;
-
- /* For now, dissect the payload of segments other than the initial
- segment as data, rather than handing them off to the transport
- protocol, just as we do with fragments other than the first
- fragment in a fragmented IP datagram; in the future, we will
- probably reassemble fragments for IP, and may reassemble segments
- for CLNP. */
- if ((clnp.cnf_type & CNF_SEG_OK) && segment_offset != 0) {
- if (check_col(fd, COL_INFO))
- col_add_fstr(fd, COL_INFO, "Fragmented %s NPDU %s(off=%u)",
+ len = segment_length;
+
+ offset = cnf_hdr_len;
+
+ /* If clnp_reassemble is on, and 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)) &&
+ cksum_status != CKSUM_NOT_OK) {
+ fd_head = fragment_add(tvb, offset, pinfo, du_id, clnp_segment_table,
+ segment_offset, segment_length - cnf_hdr_len,
+ cnf_type & CNF_MORE_SEGS);
+
+ if (fd_head != 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, next_tvb, "Reassembled CLNP");
+
+ update_col_info = !show_fragment_tree(fd_head, &clnp_frag_items,
+ clnp_tree, pinfo, next_tvb);
+ } else {
+ /* We don't have the complete reassembled payload. */
+ next_tvb = NULL;
+ }
+ } else {
+ /* If this is the first segment, dissect its contents, otherwise
+ just show it as a segment.
+
+ XXX - if we eventually don't save the reassembled contents of all
+ segmented datagrams, we may want to always reassemble. */
+ if ((cnf_type & CNF_SEG_OK) && segment_offset != 0) {
+ /* Not the first segment - don't dissect it. */
+ next_tvb = NULL;
+ } else {
+ /* First segment, or not segmented. 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 segment, but not the only segment,
+ * tell the next protocol that.
+ */
+ if ((cnf_type & (CNF_SEG_OK|CNF_MORE_SEGS)) == (CNF_SEG_OK|CNF_MORE_SEGS))
+ pinfo->fragmented = TRUE;
+ else
+ pinfo->fragmented = FALSE;
+ }
+ }
+
+ if (next_tvb == NULL) {
+ /* Just show this as a segment. */
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_add_fstr(pinfo->cinfo, COL_INFO, "Fragmented %s NPDU %s(off=%u)",
pdu_type_string, flag_string, segment_offset);
- dissect_data(pd, offset, fd, tree);
+
+ /* 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, -1), pinfo,
+ tree);
+ pinfo->fragmented = save_fragmented;
return;
}
- if (IS_DATA_IN_FRAME(offset)) {
- switch (clnp.cnf_type & CNF_TYPE) {
+ if (tvb_offset_exists(tvb, offset)) {
+ switch (cnf_type & CNF_TYPE) {
case DT_NPDU:
case MD_NPDU:
XXX - if this isn't the first Derived PDU of a segmented Initial
PDU, skip that? */
- if (nsel == NSEL_TP) { /* just guessing here - valid for DECNet-OSI */
- if (dissect_cotp_internal(pd, offset, fd, tree, FALSE))
- return; /* yes, it appears to be COTP */
+ 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 */
+ }
}
break;
case ER_NPDU:
/* The payload is the header and "none, some, or all of the data
part of the discarded PDU", i.e. it's like an ICMP error;
- just as we don't yet trust ourselves to be able to dissect
- the payload of an ICMP error packet, we don't yet trust
- ourselves to dissect the payload of a CLNP ER packet. */
- break;
+ dissect it as a CLNP PDU. */
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_add_fstr(pinfo->cinfo, COL_INFO, "%s NPDU %s", pdu_type_string, flag_string);
+ 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;
+
+ /* 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. */
+ 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;
+
+ /* 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;
+ return; /* we're done with this PDU */
case ERQ_NPDU:
case ERP_NPDU:
break;
}
}
- if (check_col(fd, COL_INFO))
- col_add_fstr(fd, COL_INFO, "%s NPDU %s", pdu_type_string, flag_string);
- dissect_data(pd, offset, fd, tree);
-
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_add_fstr(pinfo->cinfo, COL_INFO, "%s NPDU %s", pdu_type_string, flag_string);
+ call_dissector(data_handle,next_tvb, pinfo, tree);
+ pinfo->fragmented = save_fragmented;
} /* dissect_clnp */
+static void
+clnp_reassemble_init(void)
+{
+ fragment_table_init(&clnp_segment_table);
+}
void proto_register_clnp(void)
{
static hf_register_info hf[] = {
{ &hf_clnp_id,
{ "Network Layer Protocol Identifier", "clnp.nlpi", FT_UINT8, BASE_HEX,
- VALS(nlpid_vals), 0x0, "" }},
+ VALS(nlpid_vals), 0x0, "", HFILL }},
{ &hf_clnp_length,
- { "HDR Length ", "clnp.len", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+ { "HDR Length ", "clnp.len", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_version,
- { "Version ", "clnp.version", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+ { "Version ", "clnp.version", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_ttl,
- { "Holding Time ", "clnp.ttl", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+ { "Holding Time ", "clnp.ttl", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_type,
- { "PDU Type ", "clnp.type", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+ { "PDU Type ", "clnp.type", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_pdu_length,
- { "PDU length ", "clnp.pdu.len", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
+ { "PDU length ", "clnp.pdu.len", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_checksum,
- { "Checksum ", "clnp.checksum", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
+ { "Checksum ", "clnp.checksum", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_dest_length,
- { "DAL ", "clnp.dsap.len", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+ { "DAL ", "clnp.dsap.len", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_dest,
- { " DA ", "clnp.dsap", FT_BYTES, BASE_NONE, NULL, 0x0, "" }},
+ { " DA ", "clnp.dsap", FT_BYTES, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_clnp_src_length,
- { "SAL ", "clnp.ssap.len", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+ { "SAL ", "clnp.ssap.len", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_src,
- { " SA ", "clnp.ssap", FT_BYTES, BASE_NONE, NULL, 0x0, "" }},
+ { " SA ", "clnp.ssap", FT_BYTES, BASE_NONE, NULL, 0x0, "", HFILL }},
+
+ { &hf_clnp_segment_overlap,
+ { "Segment overlap", "clnp.segment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "Segment overlaps with other segments", HFILL }},
+
+ { &hf_clnp_segment_overlap_conflict,
+ { "Conflicting data in segment overlap", "clnp.segment.overlap.conflict", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "Overlapping segments contained conflicting data", HFILL }},
+
+ { &hf_clnp_segment_multiple_tails,
+ { "Multiple tail segments found", "clnp.segment.multipletails", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "Several tails were found when reassembling the packet", HFILL }},
+
+ { &hf_clnp_segment_too_long_segment,
+ { "Segment too long", "clnp.segment.toolongsegment", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "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 due to illegal segments", HFILL }},
+
+ { &hf_clnp_segment,
+ { "CLNP Segment", "clnp.segment", FT_NONE, BASE_DEC, NULL, 0x0,
+ "CLNP Segment", HFILL }},
+
+ { &hf_clnp_segments,
+ { "CLNP Segments", "clnp.segments", FT_NONE, BASE_DEC, NULL, 0x0,
+ "CLNP Segments", HFILL }},
};
static gint *ett[] = {
&ett_clnp,
+ &ett_clnp_type,
+ &ett_clnp_segments,
+ &ett_clnp_segment,
+ &ett_clnp_disc_pdu,
};
- proto_clnp = proto_register_protocol(PROTO_STRING_CLNP, "clnp");
+ module_t *clnp_module;
+
+ 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));
+
+ 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)",
+ 16, &tp_nsap_selector);
+ prefs_register_bool_preference(clnp_module, "always_decode_transport",
+ "Always try to decode NSDU as transport PDUs",
+ "Always try to decode NSDU as transport PDUs",
+ &always_decode_transport);
+ prefs_register_bool_preference(clnp_module, "reassemble",
+ "Reassemble segmented CLNP datagrams",
+ "Whether segmented CLNP datagrams should be reassembled",
+ &clnp_reassemble);
}
void proto_register_cotp(void)
&ett_cotp,
};
- proto_cotp = proto_register_protocol(PROTO_STRING_COTP, "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);
+}
+
+void proto_register_cltp(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);
+}
+
+void
+proto_reg_handoff_clnp(void)
+{
+ dissector_handle_t clnp_handle;
+
+ 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);
}
git.samba.org / obnox / wireshark / wip.git / blobdiff