2000-04-15 22:11:26 +00:00
|
|
|
/* packet-clnp.c
|
|
|
|
* Routines for ISO/OSI network and transport protocol packet disassembly
|
|
|
|
*
|
2004-07-18 00:24:25 +00:00
|
|
|
* $Id$
|
2003-01-26 19:35:31 +00:00
|
|
|
* Laurent Deniel <laurent.deniel@free.fr>
|
2000-04-15 22:11:26 +00:00
|
|
|
* Ralf Schneider <Ralf.Schneider@t-online.de>
|
|
|
|
*
|
|
|
|
* Ethereal - Network traffic analyzer
|
2001-06-05 09:06:19 +00:00
|
|
|
* By Gerald Combs <gerald@ethereal.com>
|
2000-04-15 22:11:26 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2000-04-15 22:11:26 +00:00
|
|
|
* 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.
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2000-04-15 22:11:26 +00:00
|
|
|
* 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.
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2000-04-15 22:11:26 +00:00
|
|
|
* 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
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <glib.h>
|
2004-09-27 22:55:15 +00:00
|
|
|
#include <epan/prefs.h>
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/packet.h>
|
2005-02-09 23:38:00 +00:00
|
|
|
#include <epan/reassemble.h>
|
2005-08-17 09:25:04 +00:00
|
|
|
#include <epan/emem.h>
|
2005-12-16 00:32:12 +00:00
|
|
|
#include "packet-frame.h"
|
2000-04-15 22:11:26 +00:00
|
|
|
#include "packet-osi.h"
|
|
|
|
#include "packet-osi-options.h"
|
|
|
|
#include "packet-isis.h"
|
|
|
|
#include "packet-esis.h"
|
2005-09-17 00:02:31 +00:00
|
|
|
#include <epan/nlpid.h>
|
2004-09-29 00:52:45 +00:00
|
|
|
#include <epan/ipproto.h>
|
2005-09-11 16:55:34 +00:00
|
|
|
#include <epan/expert.h>
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
/* protocols and fields */
|
|
|
|
|
|
|
|
static int proto_clnp = -1;
|
|
|
|
static gint ett_clnp = -1;
|
2000-12-23 21:40:22 +00:00
|
|
|
static gint ett_clnp_type = -1;
|
2001-06-08 06:27:16 +00:00
|
|
|
static gint ett_clnp_segments = -1;
|
|
|
|
static gint ett_clnp_segment = -1;
|
2000-12-23 19:34:46 +00:00
|
|
|
static gint ett_clnp_disc_pdu = -1;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
static int hf_clnp_id = -1;
|
|
|
|
static int hf_clnp_length = -1;
|
|
|
|
static int hf_clnp_version = -1;
|
|
|
|
static int hf_clnp_ttl = -1;
|
|
|
|
static int hf_clnp_type = -1;
|
|
|
|
static int hf_clnp_pdu_length = -1;
|
|
|
|
static int hf_clnp_checksum = -1;
|
|
|
|
static int hf_clnp_dest_length = -1;
|
|
|
|
static int hf_clnp_dest = -1;
|
|
|
|
static int hf_clnp_src_length = -1;
|
|
|
|
static int hf_clnp_src = -1;
|
2001-06-08 06:27:16 +00:00
|
|
|
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;
|
2003-04-20 08:06:01 +00:00
|
|
|
static int hf_clnp_reassembled_in = -1;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-04-15 21:33:26 +00:00
|
|
|
static int proto_cotp = -1;
|
|
|
|
static gint ett_cotp = -1;
|
2003-05-28 22:58:46 +00:00
|
|
|
static gint ett_cotp_segments = -1;
|
|
|
|
static gint ett_cotp_segment = -1;
|
|
|
|
|
|
|
|
static int hf_cotp_srcref = -1;
|
|
|
|
static int hf_cotp_destref = -1;
|
2004-08-20 08:15:11 +00:00
|
|
|
static int hf_cotp_tpdu_number = -1;
|
|
|
|
static int hf_cotp_tpdu_number_extended = -1;
|
|
|
|
static int hf_cotp_next_tpdu_number = -1;
|
|
|
|
static int hf_cotp_next_tpdu_number_extended = -1;
|
|
|
|
static int hf_cotp_eot = -1;
|
|
|
|
static int hf_cotp_eot_extended = -1;
|
|
|
|
|
2005-07-12 21:21:14 +00:00
|
|
|
static int hf_cotp_li = -1;
|
2003-05-28 22:58:46 +00:00
|
|
|
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;
|
2003-04-15 10:25:55 +00:00
|
|
|
|
2004-08-20 08:15:11 +00:00
|
|
|
static const true_false_string fragment_descriptions = {
|
|
|
|
"Yes",
|
|
|
|
"No"
|
|
|
|
};
|
|
|
|
|
2003-04-15 21:33:26 +00:00
|
|
|
static int proto_cltp = -1;
|
|
|
|
static gint ett_cltp = -1;
|
|
|
|
|
2005-07-12 21:21:14 +00:00
|
|
|
static int hf_cltp_li = -1;
|
2003-04-15 21:33:26 +00:00
|
|
|
static int hf_cltp_type = -1;
|
|
|
|
|
2002-10-24 06:17:36 +00:00
|
|
|
static const fragment_items clnp_frag_items = {
|
2002-06-07 10:11:41 +00:00
|
|
|
&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,
|
2003-04-20 11:36:16 +00:00
|
|
|
&hf_clnp_reassembled_in,
|
2002-06-07 10:11:41 +00:00
|
|
|
"segments"
|
|
|
|
};
|
|
|
|
|
2003-05-28 22:58:46 +00:00
|
|
|
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"
|
|
|
|
};
|
|
|
|
|
2003-01-20 05:42:37 +00:00
|
|
|
static dissector_handle_t clnp_handle;
|
2001-11-26 04:52:51 +00:00
|
|
|
static dissector_handle_t data_handle;
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
/*
|
|
|
|
* ISO 8473 OSI CLNP definition (see RFC994)
|
|
|
|
*
|
|
|
|
* _________________________________
|
|
|
|
* | Fixed Part |
|
|
|
|
* |_________________________________|
|
|
|
|
* | Address Part |
|
|
|
|
* |_________________________________|
|
|
|
|
* | Segmentation Part (optional) |
|
|
|
|
* |_________________________________|
|
|
|
|
* | Options Part (optional) |
|
|
|
|
* |_________________________________|
|
|
|
|
* | Data (optional) |
|
|
|
|
* |_________________________________|
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define ISO8473_V1 0x01 /* CLNP version 1 */
|
|
|
|
|
|
|
|
/* Fixed part */
|
|
|
|
|
|
|
|
#define CNF_TYPE 0x1f
|
|
|
|
#define CNF_ERR_OK 0x20
|
|
|
|
#define CNF_MORE_SEGS 0x40
|
|
|
|
#define CNF_SEG_OK 0x80
|
|
|
|
|
|
|
|
#define DT_NPDU 0x1C
|
|
|
|
#define MD_NPDU 0x1D
|
|
|
|
#define ER_NPDU 0x01
|
|
|
|
#define ERQ_NPDU 0x1E
|
|
|
|
#define ERP_NPDU 0x1F
|
|
|
|
|
2000-12-23 23:06:50 +00:00
|
|
|
static const value_string npdu_type_abbrev_vals[] = {
|
2000-04-15 22:11:26 +00:00
|
|
|
{ DT_NPDU, "DT" },
|
|
|
|
{ MD_NPDU, "MD" },
|
|
|
|
{ ER_NPDU, "ER" },
|
|
|
|
{ ERQ_NPDU, "ERQ" },
|
|
|
|
{ ERP_NPDU, "ERP" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
2000-12-23 23:06:50 +00:00
|
|
|
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 }
|
|
|
|
};
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
/* field position */
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
#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
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
/* Segmentation part */
|
|
|
|
|
|
|
|
struct clnp_segment {
|
2002-08-02 23:36:07 +00:00
|
|
|
gushort cng_id; /* data unit identifier */
|
|
|
|
gushort cng_off; /* segment offset */
|
|
|
|
gushort cng_tot_len; /* total length */
|
2000-04-15 22:11:26 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* NSAP selector */
|
|
|
|
|
|
|
|
#define NSEL_NET 0x00
|
|
|
|
#define NSEL_NP 0x20
|
|
|
|
#define NSEL_TP 0x21
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ISO8073 OSI COTP definition (see RFC905)
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* don't use specific TPDU types to avoid alignment problems & copy overhead */
|
|
|
|
|
|
|
|
/* TPDU definition */
|
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
#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 */
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-04-15 21:33:26 +00:00
|
|
|
static const value_string cotp_tpdu_type_abbrev_vals[] = {
|
2005-07-12 21:21:14 +00:00
|
|
|
{ ED_TPDU, "ED Expedited Data" },
|
|
|
|
{ EA_TPDU, "EA Expedited Data Acknowledgement" },
|
|
|
|
{ RJ_TPDU, "RJ Reject" },
|
|
|
|
{ AK_TPDU, "AK Data Acknowledgement" },
|
|
|
|
{ ER_TPDU, "ER TPDU Error" },
|
|
|
|
{ DR_TPDU, "DR Disconnect Request" },
|
|
|
|
{ DC_TPDU, "DC Disconnect Confirm" },
|
|
|
|
{ CC_TPDU, "CC Connect Confirm" },
|
|
|
|
{ CR_TPDU, "CR Connect Request" },
|
|
|
|
{ DT_TPDU, "DT Data" },
|
2003-04-15 10:25:55 +00:00
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
2003-04-15 21:33:26 +00:00
|
|
|
static const value_string cltp_tpdu_type_abbrev_vals[] = {
|
|
|
|
{ UD_TPDU, "UD" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
/* field position */
|
|
|
|
|
|
|
|
#define P_LI 0
|
|
|
|
#define P_TPDU 1
|
|
|
|
#define P_CDT 1
|
|
|
|
#define P_DST_REF 2
|
|
|
|
#define P_SRC_REF 4
|
|
|
|
#define P_TPDU_NR_0_1 2
|
|
|
|
#define P_TPDU_NR_234 4
|
|
|
|
#define P_VAR_PART_NDT 5
|
|
|
|
#define P_VAR_PART_EDT 8
|
|
|
|
#define P_VAR_PART_DC 6
|
|
|
|
#define P_CDT_IN_AK 8
|
|
|
|
#define P_CDT_IN_RJ 8
|
|
|
|
#define P_REJECT_ER 4
|
|
|
|
#define P_REASON_IN_DR 6
|
|
|
|
#define P_CLASS_OPTION 6
|
|
|
|
|
|
|
|
/* TPDU length indicator */
|
|
|
|
|
|
|
|
#define LI_NORMAL_DT_CLASS_01 2
|
|
|
|
#define LI_NORMAL_DT_WITH_CHECKSUM 8
|
|
|
|
#define LI_NORMAL_DT_WITHOUT_CHECKSUM 4
|
|
|
|
#define LI_EXTENDED_DT_WITH_CHECKSUM 11
|
|
|
|
#define LI_EXTENDED_DT_WITHOUT_CHECKSUM 7
|
|
|
|
#define LI_NORMAL_EA_WITH_CHECKSUM 8
|
|
|
|
#define LI_NORMAL_EA_WITHOUT_CHECKSUM 4
|
|
|
|
#define LI_EXTENDED_EA_WITH_CHECKSUM 11
|
|
|
|
#define LI_EXTENDED_EA_WITHOUT_CHECKSUM 7
|
|
|
|
#define LI_NORMAL_RJ 4
|
|
|
|
#define LI_EXTENDED_RJ 9
|
|
|
|
#define LI_MIN_DR 6
|
|
|
|
#define LI_MAX_DC 9
|
|
|
|
#define LI_MAX_AK 27
|
|
|
|
#define LI_MAX_EA 11
|
|
|
|
#define LI_MAX_ER 8
|
2000-07-01 08:55:28 +00:00
|
|
|
/* 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 )
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
/* variant part */
|
|
|
|
|
|
|
|
#define VP_ACK_TIME 0x85
|
|
|
|
#define VP_RES_ERROR 0x86
|
|
|
|
#define VP_PRIORITY 0x87
|
|
|
|
#define VP_TRANSIT_DEL 0x88
|
|
|
|
#define VP_THROUGHPUT 0x89
|
|
|
|
#define VP_SEQ_NR 0x8A /* in AK */
|
|
|
|
#define VP_REASSIGNMENT 0x8B
|
|
|
|
#define VP_FLOW_CNTL 0x8C /* in AK */
|
|
|
|
#define VP_TPDU_SIZE 0xC0
|
|
|
|
#define VP_SRC_TSAP 0xC1 /* in CR/CC */
|
|
|
|
#define VP_DST_TSAP 0xC2
|
|
|
|
#define VP_CHECKSUM 0xC3
|
|
|
|
#define VP_VERSION_NR 0xC4
|
|
|
|
#define VP_PROTECTION 0xC5
|
|
|
|
#define VP_OPT_SEL 0xC6
|
|
|
|
#define VP_PROTO_CLASS 0xC7
|
2000-07-01 08:55:28 +00:00
|
|
|
#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 }
|
|
|
|
};
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2005-10-17 20:05:18 +00:00
|
|
|
static int hf_cotp_vp_src_tsap = -1;
|
2004-05-23 23:07:17 +00:00
|
|
|
static int hf_cotp_vp_dst_tsap = -1;
|
2005-10-17 20:05:18 +00:00
|
|
|
static int hf_cotp_vp_src_tsap_bytes = -1;
|
2004-05-23 23:07:17 +00:00
|
|
|
static int hf_cotp_vp_dst_tsap_bytes = -1;
|
|
|
|
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
/* misc */
|
|
|
|
|
|
|
|
#define EXTRACT_SHORT(p) pntohs(p)
|
|
|
|
#define EXTRACT_LONG(p) pntohl(p)
|
|
|
|
|
|
|
|
/* global variables */
|
|
|
|
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
/* 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;
|
2003-02-04 21:43:56 +00:00
|
|
|
/* List of dissectors to call for COTP packets put atop CLNP */
|
|
|
|
static heur_dissector_list_t cotp_heur_subdissector_list;
|
2003-02-25 18:59:47 +00:00
|
|
|
/* List of dissectors to call for CLNP packets */
|
|
|
|
static heur_dissector_list_t clnp_heur_subdissector_list;
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
|
2001-06-08 06:27:16 +00:00
|
|
|
/*
|
|
|
|
* Reassembly of CLNP.
|
|
|
|
*/
|
|
|
|
static GHashTable *clnp_segment_table = NULL;
|
Use "fragment_add_check()" for IPv6 and CLNP reassembly. (Possibly an
issue for CLNP, with its 16-bit IDs, which could be duplicated in a
sufficiently large capture even if CLNP implementations don't
deliberately reuse IDs; less of an issue for IPv6, with its 32-bit IDs
and with its prohibition on reuse:
For every packet that is to be fragmented, the source node generates
an Identification value. The Identification must be different than
that of any other fragmented packet sent recently* with the same
Source Address and Destination Address. If a Routing header is
present, the Destination Address of concern is that of the final
destination.
* "recently" means within the maximum likely lifetime of a packet,
including transit time from source to destination and time spent
awaiting reassembly with other fragments of the same packet.
However, it is not required that a source node know the maximum
packet lifetime. Rather, it is assumed that the requirement can
be met by maintaining the Identification value as a simple, 32-
bit, "wrap-around" counter, incremented each time a packet must
be fragmented. It is an implementation choice whether to
maintain a single counter for the node or multiple counters,
e.g., one for each of the node's possible source addresses, or
one for each active (source address, destination address)
combination.
but perhaps we'll ultimately be able to get rid of the old
"fragment_add()" entirely and rename "fragment_add_check()" to
"fragment_add()").
svn path=/trunk/; revision=7507
2003-04-20 00:21:17 +00:00
|
|
|
static GHashTable *clnp_reassembled_table = NULL;
|
2001-06-08 06:27:16 +00:00
|
|
|
|
2003-05-28 22:58:46 +00:00
|
|
|
/*
|
|
|
|
* Reassembly of COTP.
|
|
|
|
*/
|
|
|
|
static GHashTable *cotp_segment_table = NULL;
|
|
|
|
static GHashTable *cotp_reassembled_table = NULL;
|
2005-12-16 00:32:12 +00:00
|
|
|
static guint16 cotp_dst_ref = 0;
|
2003-05-28 22:58:46 +00:00
|
|
|
|
2004-05-23 23:07:17 +00:00
|
|
|
#define TSAP_DISPLAY_AUTO 0
|
|
|
|
#define TSAP_DISPLAY_STRING 1
|
|
|
|
#define TSAP_DISPLAY_BYTES 2
|
|
|
|
|
|
|
|
|
2000-08-06 15:54:42 +00:00
|
|
|
/* options */
|
|
|
|
static guint tp_nsap_selector = NSEL_TP;
|
|
|
|
static gboolean always_decode_transport = FALSE;
|
2005-09-28 22:15:38 +00:00
|
|
|
static gboolean clnp_reassemble = TRUE;
|
|
|
|
static gboolean cotp_reassemble = TRUE;
|
2004-05-23 23:07:17 +00:00
|
|
|
static gint32 tsap_display = TSAP_DISPLAY_AUTO;
|
|
|
|
|
|
|
|
const enum_val_t tsap_display_options[] = {
|
2004-05-24 02:25:21 +00:00
|
|
|
{"auto", "As strings if printable", TSAP_DISPLAY_AUTO},
|
|
|
|
{"string", "As strings", TSAP_DISPLAY_STRING},
|
|
|
|
{"bytes", "As bytes", TSAP_DISPLAY_BYTES},
|
|
|
|
{NULL, NULL, -1}
|
2004-05-23 23:07:17 +00:00
|
|
|
};
|
|
|
|
|
2000-08-06 15:54:42 +00:00
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
/* function definitions */
|
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
#define MAX_TSAP_LEN 32
|
2005-12-16 00:32:12 +00:00
|
|
|
|
|
|
|
static void cotp_frame_end(void)
|
|
|
|
{
|
|
|
|
cotp_dst_ref = 0;
|
|
|
|
}
|
|
|
|
|
2004-05-23 23:07:17 +00:00
|
|
|
static gboolean is_all_printable(const guchar *stringtocheck, int length)
|
|
|
|
{
|
|
|
|
gboolean allprintable;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
allprintable=TRUE;
|
|
|
|
for (i=0;i<length;i++) {
|
|
|
|
if (!(isascii(stringtocheck[i]) && isprint(stringtocheck[i]))) {
|
|
|
|
allprintable=FALSE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2005-10-17 20:05:18 +00:00
|
|
|
return allprintable;
|
2004-05-23 23:07:17 +00:00
|
|
|
} /* is_all_printable */
|
|
|
|
|
|
|
|
|
2002-08-02 23:36:07 +00:00
|
|
|
static gchar *print_tsap(const guchar *tsap, int length)
|
2000-07-01 08:55:28 +00:00
|
|
|
{
|
|
|
|
|
2006-01-16 07:59:44 +00:00
|
|
|
gchar *cur;
|
2000-07-01 08:55:28 +00:00
|
|
|
gboolean allprintable;
|
2006-01-16 07:59:44 +00:00
|
|
|
size_t index = 0, returned_length;
|
2000-07-01 08:55:28 +00:00
|
|
|
|
2005-08-17 09:25:04 +00:00
|
|
|
cur=ep_alloc(MAX_TSAP_LEN * 2 + 3);
|
2000-07-01 08:55:28 +00:00
|
|
|
cur[0] = '\0';
|
2002-08-28 21:04:11 +00:00
|
|
|
if (length <= 0 || length > MAX_TSAP_LEN)
|
2005-08-18 19:31:15 +00:00
|
|
|
g_snprintf(cur, MAX_TSAP_LEN * 2 + 3, "<unsupported TSAP length>");
|
2002-08-28 21:04:11 +00:00
|
|
|
else {
|
2004-05-23 23:07:17 +00:00
|
|
|
allprintable = is_all_printable(tsap,length);
|
2006-01-28 22:34:22 +00:00
|
|
|
if (!allprintable) {
|
2006-01-16 07:59:44 +00:00
|
|
|
returned_length = g_snprintf(cur, MAX_TSAP_LEN * 2 + 3, "0x");
|
|
|
|
index += MIN(returned_length, MAX_TSAP_LEN * 2 + 3 - 1);
|
2006-01-28 22:34:22 +00:00
|
|
|
}
|
2000-07-01 08:55:28 +00:00
|
|
|
while (length != 0) {
|
2006-01-16 07:59:44 +00:00
|
|
|
if (allprintable) {
|
|
|
|
returned_length = g_snprintf(&cur[index], MAX_TSAP_LEN * 2 + 3 - index, "%c", *tsap ++);
|
|
|
|
index += MIN(returned_length, MAX_TSAP_LEN * 2 + 3 - index - 1 );
|
|
|
|
} else {
|
|
|
|
returned_length = g_snprintf(&cur[index], MAX_TSAP_LEN * 2 + 3 - index, "%02x", *tsap ++);
|
|
|
|
index += MIN(returned_length, MAX_TSAP_LEN * 2 + 3 - index - 1);
|
|
|
|
}
|
2000-07-01 08:55:28 +00:00
|
|
|
length --;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return cur;
|
|
|
|
|
|
|
|
} /* print_tsap */
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
static gboolean ositp_decode_var_part(tvbuff_t *tvb, int offset,
|
2000-07-01 08:55:28 +00:00
|
|
|
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) {
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
code = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 1,
|
2000-07-01 08:55:28 +00:00
|
|
|
"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;
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
length = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 1,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Parameter length: %u", length);
|
|
|
|
offset += 1;
|
|
|
|
vp_length -= 1;
|
|
|
|
|
|
|
|
switch (code) {
|
|
|
|
|
|
|
|
case VP_ACK_TIME:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
s = tvb_get_ntohs(tvb, offset);
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, length,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Ack time (ms): %u", s);
|
|
|
|
offset += length;
|
|
|
|
vp_length -= length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VP_RES_ERROR:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1,
|
|
|
|
"Residual error rate, target value: 10^%u",
|
|
|
|
tvb_get_guint8(tvb, offset));
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 1;
|
|
|
|
length -= 1;
|
|
|
|
vp_length -= 1;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1,
|
|
|
|
"Residual error rate, minimum acceptable: 10^%u",
|
|
|
|
tvb_get_guint8(tvb, offset));
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 1;
|
|
|
|
length -= 1;
|
|
|
|
vp_length -= 1;
|
|
|
|
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1,
|
|
|
|
"Residual error rate, TSDU size of interest: %u",
|
|
|
|
1<<tvb_get_guint8(tvb, offset));
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 1;
|
|
|
|
length -= 1;
|
|
|
|
vp_length -= 1;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VP_PRIORITY:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
s = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, length,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Priority: %u", s);
|
|
|
|
offset += length;
|
|
|
|
vp_length -= length;
|
|
|
|
break;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
case VP_TRANSIT_DEL:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
s1 = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 2,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Transit delay, target value, calling-called: %u ms", s1);
|
|
|
|
offset += 2;
|
|
|
|
length -= 2;
|
|
|
|
vp_length -= 2;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
s2 = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 2,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Transit delay, maximum acceptable, calling-called: %u ms", s2);
|
|
|
|
offset += 2;
|
|
|
|
length -= 2;
|
|
|
|
vp_length -= 2;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
s3 = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 2,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Transit delay, target value, called-calling: %u ms", s3);
|
|
|
|
offset += 2;
|
|
|
|
length -= 2;
|
|
|
|
vp_length -= 2;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
s4 = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 2,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Transit delay, maximum acceptable, called-calling: %u ms", s4);
|
|
|
|
offset += 2;
|
|
|
|
length -= 2;
|
|
|
|
vp_length -= 2;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VP_THROUGHPUT:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
t1 = tvb_get_ntoh24(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 3,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Maximum throughput, target value, calling-called: %u o/s", t1);
|
|
|
|
offset += 3;
|
|
|
|
length -= 3;
|
|
|
|
vp_length -= 3;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
t2 = tvb_get_ntoh24(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 3,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Maximum throughput, minimum acceptable, calling-called: %u o/s", t2);
|
|
|
|
offset += 3;
|
|
|
|
length -= 3;
|
|
|
|
vp_length -= 3;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
t3 = tvb_get_ntoh24(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 3,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Maximum throughput, target value, called-calling: %u o/s", t3);
|
|
|
|
offset += 3;
|
|
|
|
length -= 3;
|
|
|
|
vp_length -= 3;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
t4 = tvb_get_ntoh24(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 3,
|
2000-07-01 08:55:28 +00:00
|
|
|
"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 */
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
t1 = tvb_get_ntoh24(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 3,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Average throughput, target value, calling-called: %u o/s", t1);
|
|
|
|
offset += 3;
|
|
|
|
length -= 3;
|
|
|
|
vp_length -= 3;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
t2 = tvb_get_ntoh24(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 3,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Average throughput, minimum acceptable, calling-called: %u o/s", t2);
|
|
|
|
offset += 3;
|
|
|
|
length -= 3;
|
|
|
|
vp_length -= 3;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
t3 = tvb_get_ntoh24(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 3,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Average throughput, target value, called-calling: %u o/s", t3);
|
|
|
|
offset += 3;
|
|
|
|
length -= 3;
|
|
|
|
vp_length -= 3;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
t4 = tvb_get_ntoh24(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 3,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Average throughput, minimum acceptable, called-calling: %u o/s", t4);
|
|
|
|
offset += 3;
|
|
|
|
length -= 3;
|
|
|
|
vp_length -= 3;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VP_SEQ_NR:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 2,
|
|
|
|
"Sequence number: 0x%04x", tvb_get_ntohs(tvb, offset));
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += length;
|
|
|
|
vp_length -= length;
|
|
|
|
break;
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
case VP_REASSIGNMENT:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 2,
|
|
|
|
"Reassignment time: %u secs", tvb_get_ntohs(tvb, offset));
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += length;
|
|
|
|
vp_length -= length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VP_FLOW_CNTL:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 4,
|
|
|
|
"Lower window edge: 0x%08x", tvb_get_ntohl(tvb, offset));
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 4;
|
|
|
|
length -= 4;
|
|
|
|
vp_length -= 4;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 2,
|
|
|
|
"Sequence number: 0x%04x", tvb_get_ntohs(tvb, offset));
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 2;
|
|
|
|
length -= 2;
|
|
|
|
vp_length -= 2;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 2,
|
|
|
|
"Credit: 0x%04x", tvb_get_ntohs(tvb, offset));
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 2;
|
|
|
|
length -= 2;
|
|
|
|
vp_length -= 2;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VP_TPDU_SIZE:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
c1 = tvb_get_guint8(tvb, offset) & 0x0F;
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, length,
|
2001-11-09 02:04:35 +00:00
|
|
|
"TPDU size: %u", 1 << c1);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += length;
|
|
|
|
vp_length -= length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VP_SRC_TSAP:
|
2005-10-17 20:05:18 +00:00
|
|
|
/* if our preference is set to STRING or the
|
2004-05-23 23:07:17 +00:00
|
|
|
TSAP is not printable, add as bytes and hidden as string;
|
|
|
|
otherwise vice-versa */
|
|
|
|
if (tsap_display==TSAP_DISPLAY_STRING ||
|
|
|
|
(tsap_display==TSAP_DISPLAY_AUTO && is_all_printable(tvb_get_ptr(tvb,offset,length),length))) {
|
2005-10-17 20:05:18 +00:00
|
|
|
proto_tree_add_string(tree, hf_cotp_vp_src_tsap, tvb, offset, length,
|
2004-05-23 23:07:17 +00:00
|
|
|
print_tsap(tvb_get_ptr(tvb, offset, length),length));
|
|
|
|
proto_tree_add_item_hidden(tree, hf_cotp_vp_src_tsap_bytes, tvb, offset, length, TRUE);
|
|
|
|
} else {
|
2005-10-17 20:05:18 +00:00
|
|
|
proto_tree_add_string_hidden(tree, hf_cotp_vp_src_tsap, tvb, offset, length,
|
2004-05-23 23:07:17 +00:00
|
|
|
print_tsap(tvb_get_ptr(tvb, offset, length),length));
|
|
|
|
proto_tree_add_item(tree, hf_cotp_vp_src_tsap_bytes, tvb, offset, length, TRUE);
|
|
|
|
}
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += length;
|
|
|
|
vp_length -= length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VP_DST_TSAP:
|
2005-10-17 20:05:18 +00:00
|
|
|
/* if our preference is set to STRING or the
|
2004-05-23 23:07:17 +00:00
|
|
|
TSAP is not printable, add as bytes and hidden as string;
|
2005-10-17 20:05:18 +00:00
|
|
|
otherwise vice-versa */
|
2004-05-23 23:07:17 +00:00
|
|
|
if (tsap_display==TSAP_DISPLAY_STRING ||
|
|
|
|
(tsap_display==TSAP_DISPLAY_AUTO && is_all_printable(tvb_get_ptr(tvb,offset,length),length))) {
|
2005-10-17 20:05:18 +00:00
|
|
|
proto_tree_add_string(tree, hf_cotp_vp_dst_tsap, tvb, offset, length,
|
2004-05-23 23:07:17 +00:00
|
|
|
print_tsap(tvb_get_ptr(tvb, offset, length),length));
|
|
|
|
proto_tree_add_item_hidden(tree, hf_cotp_vp_dst_tsap_bytes, tvb, offset, length, TRUE);
|
|
|
|
} else {
|
2005-10-17 20:05:18 +00:00
|
|
|
proto_tree_add_string_hidden(tree, hf_cotp_vp_dst_tsap, tvb, offset, length,
|
2004-05-23 23:07:17 +00:00
|
|
|
print_tsap(tvb_get_ptr(tvb, offset, length),length));
|
|
|
|
proto_tree_add_item(tree, hf_cotp_vp_dst_tsap_bytes, tvb, offset, length, TRUE);
|
|
|
|
}
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += length;
|
|
|
|
vp_length -= length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VP_CHECKSUM:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, length,
|
|
|
|
"Checksum: 0x%04x", tvb_get_ntohs(tvb, offset));
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += length;
|
|
|
|
vp_length -= length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VP_VERSION_NR:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
c1 = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, length,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Version: %u", c1);
|
|
|
|
offset += length;
|
|
|
|
vp_length -= length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VP_OPT_SEL:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
c1 = tvb_get_guint8(tvb, offset) & 0x0F;
|
2000-07-01 08:55:28 +00:00
|
|
|
switch (class_option) {
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
if (c1 & 0x8)
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Use of network expedited data");
|
|
|
|
else
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Non use of network expedited data");
|
|
|
|
if (c1 & 0x4)
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Use of Receipt confirmation");
|
|
|
|
else
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Use of explicit AK variant");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 4:
|
|
|
|
if (c1 & 0x2)
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Non-use 16 bit checksum in class 4");
|
|
|
|
else
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Use 16 bit checksum ");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (c1 & 0x1)
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1,
|
2002-11-01 08:17:03 +00:00
|
|
|
"Use of transport expedited data transfer");
|
2000-07-01 08:55:28 +00:00
|
|
|
else
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Non-use of transport expedited data transfer");
|
|
|
|
offset += length;
|
|
|
|
vp_length -= length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VP_PREF_MAX_TPDU_SIZE:
|
|
|
|
switch (length) {
|
|
|
|
|
|
|
|
case 1:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
pref_max_tpdu_size = tvb_get_guint8(tvb, offset);
|
2000-07-01 08:55:28 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
pref_max_tpdu_size = tvb_get_ntohs(tvb, offset);
|
2000-07-01 08:55:28 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 3:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
pref_max_tpdu_size = tvb_get_ntoh24(tvb, offset);
|
2000-07-01 08:55:28 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 4:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
pref_max_tpdu_size = tvb_get_ntohl(tvb, offset);
|
2000-07-01 08:55:28 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, length,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Preferred maximum TPDU size: bogus length %u (not 1, 2, 3, or 4)",
|
|
|
|
length);
|
|
|
|
return FALSE;
|
|
|
|
}
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, length,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Preferred maximum TPDU size: %u", pref_max_tpdu_size*128);
|
|
|
|
offset += length;
|
|
|
|
vp_length -= length;
|
2002-08-28 21:04:11 +00:00
|
|
|
break;
|
2000-07-01 08:55:28 +00:00
|
|
|
|
|
|
|
case VP_INACTIVITY_TIMER:
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, length,
|
|
|
|
"Inactivity timer: %u ms", tvb_get_ntohl(tvb, offset));
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += length;
|
|
|
|
vp_length -= length;
|
|
|
|
break;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
case VP_PROTECTION: /* user-defined */
|
|
|
|
case VP_PROTO_CLASS: /* todo */
|
|
|
|
default: /* unknown, no decoding */
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, length,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Parameter value: <not shown>");
|
|
|
|
offset += length;
|
|
|
|
vp_length -= length;
|
2002-08-28 21:04:11 +00:00
|
|
|
break;
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
} /* while */
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
static int ositp_decode_DR(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
|
2002-08-28 21:04:11 +00:00
|
|
|
packet_info *pinfo, proto_tree *tree)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
|
|
|
proto_tree *cotp_tree;
|
2005-09-11 16:55:34 +00:00
|
|
|
proto_item *ti = NULL;
|
2003-01-05 02:50:23 +00:00
|
|
|
guint16 dst_ref, src_ref;
|
2002-08-02 23:36:07 +00:00
|
|
|
guchar reason;
|
2005-07-26 08:01:16 +00:00
|
|
|
const char *str;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
|
|
|
if (li < LI_MIN_DR)
|
2000-04-15 22:11:26 +00:00
|
|
|
return -1;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
|
2003-04-15 10:25:55 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
src_ref = tvb_get_ntohs(tvb, offset + P_SRC_REF);
|
2003-04-15 10:25:55 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
reason = tvb_get_guint8(tvb, offset + P_REASON_IN_DR);
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2004-01-28 22:14:19 +00:00
|
|
|
/* 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;*/
|
2000-04-15 22:11:26 +00:00
|
|
|
switch(reason) {
|
|
|
|
case (128+0): str = "Normal Disconnect"; break;
|
|
|
|
case (128+1): str = "Remote transport entity congestion"; break;
|
|
|
|
case (128+2): str = "Connection negotiation failed"; break;
|
|
|
|
case (128+3): str = "Duplicate source reference"; break;
|
|
|
|
case (128+4): str = "Mismatched references"; break;
|
|
|
|
case (128+5): str = "Protocol error"; break;
|
|
|
|
case (128+7): str = "Reference overflow"; break;
|
|
|
|
case (128+8): str = "Connection requestion refused"; break;
|
|
|
|
case (128+10):str = "Header or parameter length invalid"; break;
|
|
|
|
case (0): str = "Reason not specified"; break;
|
|
|
|
case (1): str = "Congestion at TSAP"; break;
|
|
|
|
case (2): str = "Session entity not attached to TSAP"; break;
|
|
|
|
case (3): str = "Address unknown"; break;
|
|
|
|
default: return -1;
|
|
|
|
/*NOTREACHED*/
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->cinfo, COL_INFO,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
"DR TPDU src-ref: 0x%04x dst-ref: 0x%04x",
|
2000-04-15 22:11:26 +00:00
|
|
|
src_ref, dst_ref);
|
|
|
|
|
|
|
|
if (tree) {
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
|
2000-04-15 22:11:26 +00:00
|
|
|
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
|
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_type, tvb, offset + 1, 1, tpdu);
|
2003-04-15 21:33:26 +00:00
|
|
|
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);
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset + 6, 1,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Cause: %s", str);
|
|
|
|
}
|
|
|
|
|
|
|
|
offset += li + 1;
|
|
|
|
|
2005-09-11 16:55:34 +00:00
|
|
|
expert_add_info_format(pinfo, ti, PI_SEQUENCE, PI_CHAT,
|
|
|
|
"Disconnect Request(DR): 0x%x -> 0x%x", src_ref, dst_ref);
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
/* User data */
|
2002-05-30 01:56:55 +00:00
|
|
|
call_dissector(data_handle, tvb_new_subset(tvb, offset, -1, -1), pinfo, tree);
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
offset += tvb_length_remaining(tvb, offset);
|
|
|
|
/* we dissected all of the containing PDU */
|
|
|
|
|
|
|
|
return offset;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
} /* ositp_decode_DR */
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
static int ositp_decode_DT(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
packet_info *pinfo, proto_tree *tree,
|
|
|
|
gboolean uses_inactive_subset,
|
|
|
|
gboolean *subdissector_found)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
2000-07-01 08:55:28 +00:00
|
|
|
proto_tree *cotp_tree = NULL;
|
2000-04-15 22:11:26 +00:00
|
|
|
proto_item *ti;
|
2000-07-01 08:55:28 +00:00
|
|
|
gboolean is_extended;
|
|
|
|
gboolean is_class_234;
|
2003-01-05 02:50:23 +00:00
|
|
|
guint16 dst_ref;
|
|
|
|
guint tpdu_nr;
|
2004-08-20 08:15:11 +00:00
|
|
|
gboolean fragment = FALSE;
|
2003-05-28 22:58:46 +00:00
|
|
|
guint32 fragment_length = 0;
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tvbuff_t *next_tvb;
|
2003-05-28 22:58:46 +00:00
|
|
|
tvbuff_t *reassembled_tvb = NULL;
|
|
|
|
fragment_data *fd_head;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
/* 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.) */
|
2000-04-15 22:11:26 +00:00
|
|
|
switch (li) {
|
2000-07-01 08:55:28 +00:00
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
case LI_NORMAL_DT_WITH_CHECKSUM :
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
if (tvb_get_guint8(tvb, offset + P_VAR_PART_NDT) != VP_CHECKSUM)
|
2000-04-15 22:11:26 +00:00
|
|
|
return -1;
|
2000-07-01 08:55:28 +00:00
|
|
|
/* FALLTHROUGH */
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
case LI_NORMAL_DT_WITHOUT_CHECKSUM :
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tpdu_nr = tvb_get_guint8(tvb, offset + P_TPDU_NR_234);
|
2000-04-15 22:11:26 +00:00
|
|
|
if ( tpdu_nr & 0x80 )
|
|
|
|
tpdu_nr = tpdu_nr & 0x7F;
|
|
|
|
else
|
2004-08-20 08:15:11 +00:00
|
|
|
fragment = TRUE;
|
2000-07-01 08:55:28 +00:00
|
|
|
is_extended = FALSE;
|
|
|
|
is_class_234 = TRUE;
|
2003-01-05 02:50:23 +00:00
|
|
|
dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
2000-07-01 08:55:28 +00:00
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
case LI_EXTENDED_DT_WITH_CHECKSUM :
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
if (tvb_get_guint8(tvb, offset + P_VAR_PART_EDT) != VP_CHECKSUM)
|
2000-04-15 22:11:26 +00:00
|
|
|
return -1;
|
2000-07-01 08:55:28 +00:00
|
|
|
/* FALLTHROUGH */
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
case LI_EXTENDED_DT_WITHOUT_CHECKSUM :
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tpdu_nr = tvb_get_ntohl(tvb, offset + P_TPDU_NR_234);
|
2000-04-15 22:11:26 +00:00
|
|
|
if ( tpdu_nr & 0x80000000 )
|
|
|
|
tpdu_nr = tpdu_nr & 0x7FFFFFFF;
|
|
|
|
else
|
2004-08-20 08:15:11 +00:00
|
|
|
fragment = TRUE;
|
2000-07-01 08:55:28 +00:00
|
|
|
is_extended = TRUE;
|
|
|
|
is_class_234 = TRUE;
|
2003-01-05 02:50:23 +00:00
|
|
|
dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
2000-07-01 08:55:28 +00:00
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
case LI_NORMAL_DT_CLASS_01 :
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tpdu_nr = tvb_get_guint8(tvb, offset + P_TPDU_NR_0_1);
|
2000-04-15 22:11:26 +00:00
|
|
|
if ( tpdu_nr & 0x80 )
|
|
|
|
tpdu_nr = tpdu_nr & 0x7F;
|
|
|
|
else
|
2004-08-20 08:15:11 +00:00
|
|
|
fragment = TRUE;
|
2000-07-01 08:55:28 +00:00
|
|
|
is_extended = FALSE;
|
|
|
|
is_class_234 = FALSE;
|
2005-12-16 00:32:12 +00:00
|
|
|
dst_ref = cotp_dst_ref;
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
2000-07-01 08:55:28 +00:00
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
default : /* bad TPDU */
|
|
|
|
return -1;
|
|
|
|
/*NOTREACHED*/
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2004-01-28 22:14:19 +00:00
|
|
|
/* pinfo->destport = dst_ref; */
|
|
|
|
/* pinfo->srcport = 0; */
|
2003-05-28 22:58:46 +00:00
|
|
|
pinfo->fragmented = fragment;
|
2003-01-05 02:50:23 +00:00
|
|
|
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",
|
2000-04-15 22:11:26 +00:00
|
|
|
tpdu_nr,
|
|
|
|
dst_ref,
|
2006-01-15 13:51:58 +00:00
|
|
|
(fragment)? "[COTP Fragment]" : "EOT");
|
2003-01-05 02:50:23 +00:00
|
|
|
} else {
|
|
|
|
col_append_fstr(pinfo->cinfo, COL_INFO, "DT TPDU (%u) %s",
|
|
|
|
tpdu_nr,
|
2006-01-15 13:51:58 +00:00
|
|
|
(fragment)? "[COTP Fragment]" : "EOT");
|
2003-01-05 02:50:23 +00:00
|
|
|
}
|
|
|
|
}
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
if (tree) {
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
|
2000-04-15 22:11:26 +00:00
|
|
|
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
if (tree) {
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_type, tvb, offset, 1, tpdu);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
|
|
|
if (is_class_234) {
|
2003-04-15 21:33:26 +00:00
|
|
|
if (tree)
|
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset, 2, dst_ref);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 2;
|
|
|
|
li -= 2;
|
|
|
|
}
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
if (is_extended) {
|
|
|
|
if (tree) {
|
2004-08-20 08:15:11 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_tpdu_number_extended, tvb, offset, 4,
|
|
|
|
tpdu_nr);
|
|
|
|
proto_tree_add_item(cotp_tree, hf_cotp_eot_extended, tvb, offset, 4,
|
2005-02-02 21:13:52 +00:00
|
|
|
FALSE);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 4;
|
|
|
|
li -= 4;
|
|
|
|
} else {
|
|
|
|
if (tree) {
|
2004-08-20 08:15:11 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_tpdu_number, tvb, offset, 1,
|
|
|
|
tpdu_nr);
|
2005-02-02 21:13:52 +00:00
|
|
|
proto_tree_add_item(cotp_tree, hf_cotp_eot, tvb, offset, 1, FALSE);
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tree)
|
2003-01-05 02:50:23 +00:00
|
|
|
ositp_decode_var_part(tvb, offset, li, 4, cotp_tree);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += li;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
next_tvb = tvb_new_subset(tvb, offset, -1, -1);
|
2003-05-28 22:58:46 +00:00
|
|
|
if (cotp_reassemble) {
|
|
|
|
fragment_length = tvb_length(next_tvb);
|
2003-12-27 02:01:13 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
2004-06-20 01:05:07 +00:00
|
|
|
*
|
|
|
|
* For now, we assume segments arrive in order, and just supply
|
|
|
|
* the negation of the EOT flag as the "more flags" argument.
|
|
|
|
* We should probably handle out-of-order packets separately,
|
|
|
|
* so that we can deliver them in order even when *not*
|
|
|
|
* reassembling.
|
|
|
|
*
|
|
|
|
* Note also that TP0 has no sequence number, and relies on
|
|
|
|
* the protocol atop which it runs to guarantee in-order delivery.
|
2003-12-27 02:01:13 +00:00
|
|
|
*/
|
2004-06-20 01:05:07 +00:00
|
|
|
fd_head = fragment_add_seq_next(next_tvb, 0, pinfo, dst_ref,
|
|
|
|
cotp_segment_table,
|
2003-05-28 22:58:46 +00:00
|
|
|
cotp_reassembled_table,
|
|
|
|
fragment_length, fragment);
|
|
|
|
if (fd_head) {
|
2005-08-26 23:13:43 +00:00
|
|
|
if (fd_head->next && !fragment) {
|
2003-05-28 22:58:46 +00:00
|
|
|
/* 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");
|
2005-10-17 20:05:18 +00:00
|
|
|
|
2003-05-28 22:58:46 +00:00
|
|
|
show_fragment_seq_tree(fd_head,
|
|
|
|
&cotp_frag_items,
|
2005-08-26 23:13:43 +00:00
|
|
|
tree,
|
2005-06-02 20:55:58 +00:00
|
|
|
pinfo, reassembled_tvb, &ti);
|
2003-05-28 22:58:46 +00:00
|
|
|
pinfo->fragmented = fragment;
|
|
|
|
next_tvb = reassembled_tvb;
|
2005-12-16 00:32:12 +00:00
|
|
|
|
|
|
|
cotp_dst_ref++;
|
|
|
|
register_frame_end_routine(cotp_frame_end);
|
2003-05-28 22:58:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (fragment && reassembled_tvb == NULL) {
|
2005-08-26 18:42:12 +00:00
|
|
|
/* don't use -1 if fragment length is zero (throws Exception) */
|
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset, (fragment_length) ? -1 : 0,
|
2003-05-28 22:58:46 +00:00
|
|
|
"User data (%u byte%s)", fragment_length,
|
|
|
|
plurality(fragment_length, "", "s"));
|
2005-10-17 20:05:18 +00:00
|
|
|
}
|
2003-05-28 22:58:46 +00:00
|
|
|
|
2005-10-17 20:05:18 +00:00
|
|
|
}
|
2003-05-28 22:58:46 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2003-02-04 21:43:56 +00:00
|
|
|
} else {
|
2003-05-28 22:58:46 +00:00
|
|
|
/*
|
2005-10-17 20:05:18 +00:00
|
|
|
* We dissect payload if one of the following is TRUE:
|
2003-05-28 22:58:46 +00:00
|
|
|
*
|
2005-10-17 20:05:18 +00:00
|
|
|
* - Reassembly option for COTP in preferences is unchecked
|
2003-05-28 22:58:46 +00:00
|
|
|
* - 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);
|
|
|
|
}
|
|
|
|
}
|
2005-10-17 20:05:18 +00:00
|
|
|
}
|
2003-05-28 22:58:46 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
offset += tvb_length_remaining(tvb, offset);
|
|
|
|
/* we dissected all of the containing PDU */
|
|
|
|
|
|
|
|
return offset;
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
} /* ositp_decode_DT */
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
static int ositp_decode_ED(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
packet_info *pinfo, proto_tree *tree)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
2000-07-01 08:55:28 +00:00
|
|
|
proto_tree *cotp_tree = NULL;
|
2000-04-15 22:11:26 +00:00
|
|
|
proto_item *ti;
|
2000-07-01 08:55:28 +00:00
|
|
|
gboolean is_extended;
|
2003-01-05 02:50:23 +00:00
|
|
|
guint16 dst_ref;
|
|
|
|
guint tpdu_nr;
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tvbuff_t *next_tvb;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
/* ED TPDUs are never fragmented */
|
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
/* 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.) */
|
2000-04-15 22:11:26 +00:00
|
|
|
switch (li) {
|
2000-07-01 08:55:28 +00:00
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
case LI_NORMAL_DT_WITH_CHECKSUM :
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
if (tvb_get_guint8(tvb, offset + P_VAR_PART_NDT) != VP_CHECKSUM)
|
2000-04-15 22:11:26 +00:00
|
|
|
return -1;
|
2000-07-01 08:55:28 +00:00
|
|
|
/* FALLTHROUGH */
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
case LI_NORMAL_DT_WITHOUT_CHECKSUM :
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tpdu_nr = tvb_get_guint8(tvb, offset + P_TPDU_NR_234);
|
2000-04-15 22:11:26 +00:00
|
|
|
if ( tpdu_nr & 0x80 )
|
|
|
|
tpdu_nr = tpdu_nr & 0x7F;
|
|
|
|
else
|
|
|
|
return -1;
|
2000-07-01 08:55:28 +00:00
|
|
|
is_extended = FALSE;
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
2000-07-01 08:55:28 +00:00
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
case LI_EXTENDED_DT_WITH_CHECKSUM :
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
if (tvb_get_guint8(tvb, offset + P_VAR_PART_EDT) != VP_CHECKSUM)
|
2000-04-15 22:11:26 +00:00
|
|
|
return -1;
|
2000-07-01 08:55:28 +00:00
|
|
|
/* FALLTHROUGH */
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
case LI_EXTENDED_DT_WITHOUT_CHECKSUM :
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tpdu_nr = tvb_get_ntohl(tvb, offset + P_TPDU_NR_234);
|
2000-04-15 22:11:26 +00:00
|
|
|
if ( tpdu_nr & 0x80000000 )
|
|
|
|
tpdu_nr = tpdu_nr & 0x7FFFFFFF;
|
|
|
|
else
|
|
|
|
return -1;
|
2000-07-01 08:55:28 +00:00
|
|
|
is_extended = TRUE;
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
2000-07-01 08:55:28 +00:00
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
default : /* bad TPDU */
|
|
|
|
return -1;
|
|
|
|
/*NOTREACHED*/
|
|
|
|
break;
|
|
|
|
} /* li */
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
|
2003-05-28 22:58:46 +00:00
|
|
|
|
2004-01-28 22:14:19 +00:00
|
|
|
/* pinfo->destport = dst_ref; */
|
|
|
|
/* pinfo->srcport = 0; */
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
2002-08-28 21:04:11 +00:00
|
|
|
col_append_fstr(pinfo->cinfo, COL_INFO, "ED TPDU (%u) dst-ref: 0x%04x",
|
2000-04-15 22:11:26 +00:00
|
|
|
tpdu_nr, dst_ref);
|
|
|
|
|
|
|
|
if (tree) {
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
|
2000-04-15 22:11:26 +00:00
|
|
|
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
if (tree) {
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_type, tvb, offset, 1, tpdu);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
2003-04-15 21:33:26 +00:00
|
|
|
if (tree)
|
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset, 2, dst_ref);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 2;
|
|
|
|
li -= 2;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
if (is_extended) {
|
|
|
|
if (tree) {
|
2004-08-20 08:15:11 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_tpdu_number_extended, tvb,
|
|
|
|
offset, 4, tpdu_nr);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 4;
|
|
|
|
li -= 4;
|
|
|
|
} else {
|
|
|
|
if (tree) {
|
2004-08-20 08:15:11 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_tpdu_number, tvb, offset, 1,
|
|
|
|
tpdu_nr);
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tree)
|
2003-01-05 02:50:23 +00:00
|
|
|
ositp_decode_var_part(tvb, offset, li, 4, cotp_tree);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += li;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
next_tvb = tvb_new_subset(tvb, offset, -1, -1);
|
2001-11-26 04:52:51 +00:00
|
|
|
call_dissector(data_handle,next_tvb, pinfo, tree);
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
|
|
|
|
offset += tvb_length_remaining(tvb, offset);
|
|
|
|
/* we dissected all of the containing PDU */
|
2000-04-15 22:11:26 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
return offset;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
} /* ositp_decode_ED */
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
static int ositp_decode_RJ(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
|
|
|
|
guint8 cdt, packet_info *pinfo, proto_tree *tree)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
|
|
|
proto_tree *cotp_tree;
|
|
|
|
proto_item *ti;
|
2005-09-11 16:55:34 +00:00
|
|
|
proto_item *item = NULL;
|
2003-01-05 02:50:23 +00:00
|
|
|
guint16 dst_ref;
|
|
|
|
guint tpdu_nr;
|
2002-08-02 23:36:07 +00:00
|
|
|
gushort credit = 0;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
switch(li) {
|
|
|
|
case LI_NORMAL_RJ :
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tpdu_nr = tvb_get_guint8(tvb, offset + P_TPDU_NR_234);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case LI_EXTENDED_RJ :
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tpdu_nr = tvb_get_ntohl(tvb, offset + P_TPDU_NR_234);
|
|
|
|
credit = tvb_get_ntohs(tvb, offset + P_CDT_IN_RJ);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
default :
|
|
|
|
return -1;
|
|
|
|
/*NOTREACHED*/
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
|
2003-05-28 22:58:46 +00:00
|
|
|
|
2004-01-28 22:14:19 +00:00
|
|
|
/* pinfo->destport = dst_ref; */
|
|
|
|
/* pinfo->srcport = 0; */
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
2002-08-28 21:04:11 +00:00
|
|
|
col_append_fstr(pinfo->cinfo, COL_INFO, "RJ TPDU (%u) dst-ref: 0x%04x",
|
2000-04-15 22:11:26 +00:00
|
|
|
tpdu_nr, dst_ref);
|
|
|
|
|
|
|
|
if (tree) {
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
|
2000-04-15 22:11:26 +00:00
|
|
|
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
|
2005-09-11 16:55:34 +00:00
|
|
|
item = proto_tree_add_uint(cotp_tree, hf_cotp_type, tvb, offset + 1, 1, tpdu);
|
2000-04-15 22:11:26 +00:00
|
|
|
if (li == LI_NORMAL_RJ)
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset + 1, 1,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Credit: %u", cdt);
|
2003-04-15 21:33:26 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset + 2, 2, dst_ref);
|
2000-04-15 22:11:26 +00:00
|
|
|
if (li == LI_NORMAL_RJ)
|
2004-08-20 08:15:11 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_next_tpdu_number, tvb, offset + 4,
|
|
|
|
1, tpdu_nr);
|
2000-04-15 22:11:26 +00:00
|
|
|
else {
|
2004-08-20 08:15:11 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_next_tpdu_number_extended, tvb,
|
|
|
|
offset + 4, 4, tpdu_nr);
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset + 8, 2,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Credit: 0x%02x", credit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
offset += li + 1;
|
|
|
|
|
2005-09-11 16:55:34 +00:00
|
|
|
expert_add_info_format(pinfo, item, PI_SEQUENCE, PI_NOTE,
|
|
|
|
"Reject(RJ): -> 0x%x", dst_ref);
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
return offset;
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
} /* ositp_decode_RJ */
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
static int ositp_decode_CC(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
|
2003-02-25 18:59:47 +00:00
|
|
|
packet_info *pinfo, proto_tree *tree,
|
|
|
|
gboolean uses_inactive_subset,
|
|
|
|
gboolean *subdissector_found)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
/* CC & CR decoding in the same function */
|
|
|
|
|
|
|
|
proto_tree *cotp_tree = NULL;
|
|
|
|
proto_item *ti;
|
2005-09-11 16:55:34 +00:00
|
|
|
proto_item *item = NULL;
|
2003-01-05 02:50:23 +00:00
|
|
|
guint16 dst_ref, src_ref;
|
2002-08-02 23:36:07 +00:00
|
|
|
guchar class_option;
|
2003-02-25 18:59:47 +00:00
|
|
|
tvbuff_t *next_tvb;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
src_ref = tvb_get_ntohs(tvb, offset + P_SRC_REF);
|
2005-10-17 20:05:18 +00:00
|
|
|
|
2006-01-18 21:41:34 +00:00
|
|
|
class_option = tvb_get_guint8(tvb, offset + P_CLASS_OPTION);
|
|
|
|
if (((class_option & 0xF0) >> 4) > 4) /* class 0..4 allowed */
|
2000-04-15 22:11:26 +00:00
|
|
|
return -1;
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
|
2004-01-28 22:14:19 +00:00
|
|
|
/* pinfo->srcport = src_ref; */
|
|
|
|
/* pinfo->destport = dst_ref; */
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->cinfo, COL_INFO,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
"%s TPDU src-ref: 0x%04x dst-ref: 0x%04x",
|
2000-04-15 22:11:26 +00:00
|
|
|
(tpdu == CR_TPDU) ? "CR" : "CC",
|
|
|
|
src_ref,
|
|
|
|
dst_ref);
|
|
|
|
|
|
|
|
if (tree) {
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
|
2000-04-15 22:11:26 +00:00
|
|
|
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
if (tree) {
|
2005-09-11 16:55:34 +00:00
|
|
|
item = proto_tree_add_uint(cotp_tree, hf_cotp_type, tvb, offset, 1, tpdu);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
2003-04-15 21:33:26 +00:00
|
|
|
if (tree)
|
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset, 2, dst_ref);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 2;
|
|
|
|
li -= 2;
|
|
|
|
|
2003-04-15 21:33:26 +00:00
|
|
|
if (tree)
|
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_srcref, tvb, offset, 2, src_ref);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 2;
|
|
|
|
li -= 2;
|
|
|
|
|
2005-09-11 16:55:34 +00:00
|
|
|
/* expert info, but only if not encapsulated in TCP/SMB */
|
|
|
|
/* XXX - the best way to detect seems to be if we have a port set */
|
|
|
|
if (pinfo->destport == 0) {
|
|
|
|
expert_add_info_format(pinfo, item, PI_SEQUENCE, PI_CHAT,
|
|
|
|
tpdu == CR_TPDU ? "Connection Request(CR): 0x%x -> 0x%x" : "Connection Confirm(CC): 0x%x -> 0x%x",
|
|
|
|
src_ref, dst_ref);
|
|
|
|
}
|
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
if (tree) {
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset, 1,
|
2006-01-18 21:41:34 +00:00
|
|
|
"Class: %1u", (class_option & 0xF0) >> 4);
|
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset, 1,
|
|
|
|
"Option: %1u", (class_option & 0x0F));
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
if (tree)
|
2003-01-05 02:50:23 +00:00
|
|
|
ositp_decode_var_part(tvb, offset, li, class_option, cotp_tree);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += li;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-02-25 18:59:47 +00:00
|
|
|
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);
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
offset += tvb_length_remaining(tvb, offset);
|
|
|
|
/* we dissected all of the containing PDU */
|
2000-04-15 22:11:26 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
return offset;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
} /* ositp_decode_CC */
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
static int ositp_decode_DC(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
packet_info *pinfo, proto_tree *tree)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
2000-07-01 08:55:28 +00:00
|
|
|
proto_tree *cotp_tree = NULL;
|
2000-04-15 22:11:26 +00:00
|
|
|
proto_item *ti;
|
2005-09-11 16:55:34 +00:00
|
|
|
proto_item *item = NULL;
|
2003-01-05 02:50:23 +00:00
|
|
|
guint16 dst_ref, src_ref;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
if (li > LI_MAX_DC)
|
2000-04-15 22:11:26 +00:00
|
|
|
return -1;
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
src_ref = tvb_get_ntohs(tvb, offset + P_SRC_REF);
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2004-01-28 22:14:19 +00:00
|
|
|
/* pinfo->srcport = src_ref; */
|
|
|
|
/* pinfo->destport = dst_ref; */
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->cinfo, COL_INFO,
|
2002-08-28 21:04:11 +00:00
|
|
|
"DC TPDU src-ref: 0x%04x dst-ref: 0x%04x",
|
2000-04-15 22:11:26 +00:00
|
|
|
src_ref,
|
|
|
|
dst_ref);
|
|
|
|
|
|
|
|
if (tree) {
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
|
2000-04-15 22:11:26 +00:00
|
|
|
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
if (tree) {
|
2005-09-11 16:55:34 +00:00
|
|
|
item = proto_tree_add_uint(cotp_tree, hf_cotp_type, tvb, offset, 1, tpdu);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
2003-04-15 21:33:26 +00:00
|
|
|
if (tree)
|
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset, 2, dst_ref);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 2;
|
|
|
|
li -= 2;
|
|
|
|
|
2003-04-15 21:33:26 +00:00
|
|
|
if (tree)
|
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_srcref, tvb, offset, 2, src_ref);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 2;
|
|
|
|
li -= 2;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
if (tree)
|
2003-01-05 02:50:23 +00:00
|
|
|
ositp_decode_var_part(tvb, offset, li, 4, cotp_tree);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += li;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2005-09-11 16:55:34 +00:00
|
|
|
expert_add_info_format(pinfo, item, PI_SEQUENCE, PI_CHAT,
|
|
|
|
"Disconnect Confirm(DC): 0x%x -> 0x%x", src_ref, dst_ref);
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
return offset;
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
} /* ositp_decode_DC */
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
static int ositp_decode_AK(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
|
|
|
|
guint8 cdt, packet_info *pinfo, proto_tree *tree)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
|
|
|
proto_tree *cotp_tree = NULL;
|
|
|
|
proto_item *ti;
|
2003-01-05 02:50:23 +00:00
|
|
|
guint16 dst_ref;
|
2002-08-02 23:36:07 +00:00
|
|
|
guint tpdu_nr;
|
|
|
|
gushort cdt_in_ak;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
if (li > LI_MAX_AK)
|
2000-04-15 22:11:26 +00:00
|
|
|
return -1;
|
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
if (is_LI_NORMAL_AK(li)) {
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tpdu_nr = tvb_get_guint8(tvb, offset + P_TPDU_NR_234);
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2004-01-28 22:14:19 +00:00
|
|
|
/* pinfo->srcport = 0; */
|
|
|
|
/* pinfo->destport = dst_ref; */
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
2002-08-28 21:04:11 +00:00
|
|
|
col_append_fstr(pinfo->cinfo, COL_INFO, "AK TPDU (%u) dst-ref: 0x%04x",
|
2000-04-15 22:11:26 +00:00
|
|
|
tpdu_nr, dst_ref);
|
2000-07-01 08:55:28 +00:00
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
if (tree) {
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
|
2000-04-15 22:11:26 +00:00
|
|
|
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
if (tree) {
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_type, tvb, offset, 1, tpdu);
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset, 1,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Credit: %u", cdt);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
2003-04-15 21:33:26 +00:00
|
|
|
if (tree)
|
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset, 2, dst_ref);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 2;
|
|
|
|
li -= 2;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
if (tree) {
|
2004-08-20 08:15:11 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_next_tpdu_number, tvb, offset, 1,
|
|
|
|
tpdu_nr);
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
|
|
|
if (tree)
|
2003-01-05 02:50:23 +00:00
|
|
|
ositp_decode_var_part(tvb, offset, li, 4, cotp_tree);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += li;
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
} else { /* extended format */
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tpdu_nr = tvb_get_ntohl(tvb, offset + P_TPDU_NR_234);
|
|
|
|
cdt_in_ak = tvb_get_ntohs(tvb, offset + P_CDT_IN_AK);
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
2005-02-02 21:13:52 +00:00
|
|
|
col_append_fstr(pinfo->cinfo, COL_INFO, "AK TPDU (%u) dst-ref: 0x%04x Credit: %u",
|
|
|
|
tpdu_nr, dst_ref, cdt_in_ak);
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
if (tree) {
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
|
2000-04-15 22:11:26 +00:00
|
|
|
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
if (tree) {
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_type, tvb, offset, 1, tpdu);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
2003-04-15 21:33:26 +00:00
|
|
|
if (tree)
|
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset, 2, dst_ref);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 2;
|
|
|
|
li -= 2;
|
|
|
|
|
|
|
|
if (tree) {
|
2004-08-20 08:15:11 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_next_tpdu_number_extended, tvb,
|
|
|
|
offset, 4, tpdu_nr);
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 4;
|
|
|
|
li -= 4;
|
|
|
|
|
|
|
|
if (tree) {
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset, 2,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Credit: 0x%04x", cdt_in_ak);
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 2;
|
|
|
|
li -= 2;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
if (tree)
|
2003-01-05 02:50:23 +00:00
|
|
|
ositp_decode_var_part(tvb, offset, li, 4, cotp_tree);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += li;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
} /* is_LI_NORMAL_AK */
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
return offset;
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
} /* ositp_decode_AK */
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
static int ositp_decode_EA(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
packet_info *pinfo, proto_tree *tree)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
2000-07-01 08:55:28 +00:00
|
|
|
proto_tree *cotp_tree = NULL;
|
2000-04-15 22:11:26 +00:00
|
|
|
proto_item *ti;
|
2000-07-01 08:55:28 +00:00
|
|
|
gboolean is_extended;
|
2003-01-05 02:50:23 +00:00
|
|
|
guint16 dst_ref;
|
|
|
|
guint tpdu_nr;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
if (li > LI_MAX_EA)
|
2000-04-15 22:11:26 +00:00
|
|
|
return -1;
|
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
/* 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.) */
|
2000-04-15 22:11:26 +00:00
|
|
|
switch (li) {
|
2000-07-01 08:55:28 +00:00
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
case LI_NORMAL_EA_WITH_CHECKSUM :
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
if (tvb_get_guint8(tvb, offset + P_VAR_PART_NDT) != VP_CHECKSUM ||
|
|
|
|
tvb_get_guint8(tvb, offset + P_VAR_PART_NDT + 1) != 2)
|
2000-04-15 22:11:26 +00:00
|
|
|
return -1;
|
2000-07-01 08:55:28 +00:00
|
|
|
/* FALLTHROUGH */
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
case LI_NORMAL_EA_WITHOUT_CHECKSUM :
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tpdu_nr = tvb_get_guint8(tvb, offset + P_TPDU_NR_234);
|
2000-07-01 08:55:28 +00:00
|
|
|
is_extended = FALSE;
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
2000-07-01 08:55:28 +00:00
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
case LI_EXTENDED_EA_WITH_CHECKSUM :
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
if (tvb_get_guint8(tvb, offset + P_VAR_PART_EDT) != VP_CHECKSUM ||
|
|
|
|
tvb_get_guint8(tvb, offset + P_VAR_PART_EDT + 1) != 2)
|
2000-04-15 22:11:26 +00:00
|
|
|
return -1;
|
2000-07-01 08:55:28 +00:00
|
|
|
/* FALLTHROUGH */
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
case LI_EXTENDED_EA_WITHOUT_CHECKSUM :
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tpdu_nr = tvb_get_ntohl(tvb, offset + P_TPDU_NR_234);
|
2000-07-01 08:55:28 +00:00
|
|
|
is_extended = TRUE;
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
2000-07-01 08:55:28 +00:00
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
default : /* bad TPDU */
|
|
|
|
return -1;
|
|
|
|
/*NOTREACHED*/
|
|
|
|
break;
|
|
|
|
} /* li */
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
|
2004-01-28 22:14:19 +00:00
|
|
|
/* pinfo->srcport = 0; */
|
|
|
|
/* pinfo->destport = dst_ref; */
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
2002-08-28 21:04:11 +00:00
|
|
|
col_append_fstr(pinfo->cinfo, COL_INFO,
|
2000-04-15 22:11:26 +00:00
|
|
|
"EA TPDU (%u) dst-ref: 0x%04x", tpdu_nr, dst_ref);
|
|
|
|
|
|
|
|
if (tree) {
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
|
2000-04-15 22:11:26 +00:00
|
|
|
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
if (tree) {
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_type, tvb, offset, 1, tpdu);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
2003-04-15 21:33:26 +00:00
|
|
|
if (tree)
|
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset, 2, dst_ref);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 2;
|
|
|
|
li -= 2;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
if (is_extended) {
|
|
|
|
if (tree) {
|
2004-08-20 08:15:11 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_next_tpdu_number_extended, tvb,
|
|
|
|
offset, 4, tpdu_nr);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 4;
|
|
|
|
li -= 4;
|
|
|
|
} else {
|
|
|
|
if (tree) {
|
2004-08-20 08:15:11 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_next_tpdu_number, tvb, offset, 1,
|
|
|
|
tpdu_nr);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
}
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
if (tree)
|
2003-01-05 02:50:23 +00:00
|
|
|
ositp_decode_var_part(tvb, offset, li, 4, cotp_tree);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += li;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
return offset;
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
} /* ositp_decode_EA */
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
static int ositp_decode_ER(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
packet_info *pinfo, proto_tree *tree)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
|
|
|
proto_tree *cotp_tree;
|
|
|
|
proto_item *ti;
|
2005-07-26 08:01:16 +00:00
|
|
|
const char *str;
|
2003-01-05 02:50:23 +00:00
|
|
|
guint16 dst_ref;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
if (li > LI_MAX_ER)
|
2000-04-15 22:11:26 +00:00
|
|
|
return -1;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
switch(tvb_get_guint8(tvb, offset + P_REJECT_ER)) {
|
2000-04-15 22:11:26 +00:00
|
|
|
case 0 :
|
|
|
|
str = "Reason not specified";
|
|
|
|
break;
|
|
|
|
case 1 :
|
|
|
|
str = "Invalid parameter code";
|
|
|
|
break;
|
|
|
|
case 2 :
|
|
|
|
str = "Invalid TPDU type";
|
|
|
|
break;
|
|
|
|
case 3 :
|
|
|
|
str = "Invalid parameter value";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
/*NOTREACHED*/
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
|
2004-01-28 22:14:19 +00:00
|
|
|
/* pinfo->srcport = 0; */
|
|
|
|
/* pinfo->destport = dst_ref; */
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->cinfo, COL_INFO, "ER TPDU dst-ref: 0x%04x", dst_ref);
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
if (tree) {
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, FALSE);
|
2000-04-15 22:11:26 +00:00
|
|
|
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
|
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_type, tvb, offset + 1, 1, tpdu);
|
2003-04-15 21:33:26 +00:00
|
|
|
proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset + 2, 2, dst_ref);
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset + 4, 1,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Reject cause: %s", str);
|
|
|
|
}
|
|
|
|
|
|
|
|
offset += li + 1;
|
|
|
|
|
|
|
|
return offset;
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
} /* ositp_decode_ER */
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
static int ositp_decode_UD(tvbuff_t *tvb, int offset, guint8 li, guint8 tpdu,
|
2002-03-31 21:36:05 +00:00
|
|
|
packet_info *pinfo, proto_tree *tree)
|
2000-07-01 08:55:28 +00:00
|
|
|
{
|
|
|
|
proto_item *ti;
|
|
|
|
proto_tree *cltp_tree = NULL;
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tvbuff_t *next_tvb;
|
2000-07-01 08:55:28 +00:00
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_append_str(pinfo->cinfo, COL_INFO, "UD TPDU");
|
2000-07-01 08:55:28 +00:00
|
|
|
|
|
|
|
if (tree) {
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_cltp, tvb, offset, li + 1, FALSE);
|
2000-07-01 08:55:28 +00:00
|
|
|
cltp_tree = proto_item_add_subtree(ti, ett_cltp);
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cltp_tree, hf_cltp_li, tvb, offset, 1,li);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
if (tree) {
|
2005-07-12 21:21:14 +00:00
|
|
|
proto_tree_add_uint(cltp_tree, hf_cltp_type, tvb, offset, 1, tpdu);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
|
|
|
if (tree)
|
2003-01-05 02:50:23 +00:00
|
|
|
ositp_decode_var_part(tvb, offset, li, 0, cltp_tree);
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += li;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
next_tvb = tvb_new_subset(tvb, offset, -1, -1);
|
2001-11-26 04:52:51 +00:00
|
|
|
call_dissector(data_handle,next_tvb, pinfo, tree);
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
offset += tvb_length_remaining(tvb, offset);
|
|
|
|
/* we dissected all of the containing PDU */
|
|
|
|
|
|
|
|
return offset;
|
|
|
|
|
2003-01-05 02:50:23 +00:00
|
|
|
} /* ositp_decode_UD */
|
2000-07-01 08:55:28 +00:00
|
|
|
|
|
|
|
/* 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. */
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
static gboolean dissect_ositp_internal(tvbuff_t *tvb, packet_info *pinfo,
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree *tree, gboolean uses_inactive_subset)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
int offset = 0;
|
2003-01-05 02:50:23 +00:00
|
|
|
guint8 li, tpdu, cdt;
|
2000-04-15 22:11:26 +00:00
|
|
|
gboolean first_tpdu = TRUE;
|
|
|
|
int new_offset;
|
2000-07-01 08:55:28 +00:00
|
|
|
gboolean found_ositp = FALSE;
|
|
|
|
gboolean is_cltp = FALSE;
|
2000-04-15 22:11:26 +00:00
|
|
|
gboolean subdissector_found = FALSE;
|
|
|
|
|
2003-11-16 23:17:27 +00:00
|
|
|
if (!proto_is_protocol_enabled(find_protocol_by_id(proto_cotp)))
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
return FALSE; /* COTP has been disabled */
|
|
|
|
/* XXX - what about CLTP? */
|
|
|
|
|
|
|
|
pinfo->current_proto = "COTP";
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
/* Initialize the COL_INFO field; each of the TPDUs will have its
|
|
|
|
information appended. */
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_add_str(pinfo->cinfo, COL_INFO, "");
|
2000-04-15 22:11:26 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
while (tvb_offset_exists(tvb, offset)) {
|
2000-04-15 22:11:26 +00:00
|
|
|
if (!first_tpdu) {
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_append_str(pinfo->cinfo, COL_INFO, ", ");
|
2005-09-11 22:31:36 +00:00
|
|
|
expert_add_info_format(pinfo, NULL, PI_SEQUENCE, PI_NOTE, "Multiple TPDUs in one packet");
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
if ((li = tvb_get_guint8(tvb, offset + P_LI)) == 0) {
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_append_str(pinfo->cinfo, COL_INFO, "Length indicator is zero");
|
2000-04-15 22:11:26 +00:00
|
|
|
if (!first_tpdu)
|
2002-05-30 01:56:55 +00:00
|
|
|
call_dissector(data_handle, tvb_new_subset(tvb, offset, -1, -1),
|
|
|
|
pinfo, tree);
|
2000-07-01 08:55:28 +00:00
|
|
|
return found_ositp;
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
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;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
switch (tpdu) {
|
|
|
|
case CC_TPDU :
|
|
|
|
case CR_TPDU :
|
2003-02-25 18:59:47 +00:00
|
|
|
new_offset = ositp_decode_CC(tvb, offset, li, tpdu, pinfo, tree,
|
|
|
|
uses_inactive_subset, &subdissector_found);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case DR_TPDU :
|
2003-01-05 02:50:23 +00:00
|
|
|
new_offset = ositp_decode_DR(tvb, offset, li, tpdu, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case DT_TPDU :
|
2003-01-05 02:50:23 +00:00
|
|
|
new_offset = ositp_decode_DT(tvb, offset, li, tpdu, pinfo, tree,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
uses_inactive_subset, &subdissector_found);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case ED_TPDU :
|
2003-01-05 02:50:23 +00:00
|
|
|
new_offset = ositp_decode_ED(tvb, offset, li, tpdu, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case RJ_TPDU :
|
2003-01-05 02:50:23 +00:00
|
|
|
new_offset = ositp_decode_RJ(tvb, offset, li, tpdu, cdt, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case DC_TPDU :
|
2003-01-05 02:50:23 +00:00
|
|
|
new_offset = ositp_decode_DC(tvb, offset, li, tpdu, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case AK_TPDU :
|
2003-01-05 02:50:23 +00:00
|
|
|
new_offset = ositp_decode_AK(tvb, offset, li, tpdu, cdt, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case EA_TPDU :
|
2003-01-05 02:50:23 +00:00
|
|
|
new_offset = ositp_decode_EA(tvb, offset, li, tpdu, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case ER_TPDU :
|
2003-01-05 02:50:23 +00:00
|
|
|
new_offset = ositp_decode_ER(tvb, offset, li, tpdu, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
2000-07-01 08:55:28 +00:00
|
|
|
case UD_TPDU :
|
2003-01-05 02:50:23 +00:00
|
|
|
new_offset = ositp_decode_UD(tvb, offset, li, tpdu, pinfo, tree);
|
2000-07-01 08:55:28 +00:00
|
|
|
is_cltp = TRUE;
|
|
|
|
break;
|
2000-04-15 22:11:26 +00:00
|
|
|
default :
|
2001-12-10 00:26:21 +00:00
|
|
|
if (first_tpdu && check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->cinfo, COL_INFO, "Unknown TPDU type (0x%x)", tpdu);
|
2000-04-15 22:11:26 +00:00
|
|
|
new_offset = -1; /* bad PDU type */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (new_offset == -1) { /* incorrect TPDU */
|
|
|
|
if (!first_tpdu)
|
2002-05-30 01:56:55 +00:00
|
|
|
call_dissector(data_handle, tvb_new_subset(tvb, offset, -1, -1),
|
|
|
|
pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (first_tpdu) {
|
2000-07-01 08:55:28 +00:00
|
|
|
/* Well, we found at least one valid COTP or CLTP PDU, so I guess this
|
|
|
|
is either COTP or CLTP. */
|
2001-12-10 00:26:21 +00:00
|
|
|
if (!subdissector_found && check_col(pinfo->cinfo, COL_PROTOCOL))
|
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, is_cltp ? "CLTP" : "COTP");
|
2000-07-01 08:55:28 +00:00
|
|
|
found_ositp = TRUE;
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
offset = new_offset;
|
|
|
|
first_tpdu = FALSE;
|
|
|
|
}
|
2000-07-01 08:55:28 +00:00
|
|
|
return found_ositp;
|
|
|
|
} /* dissect_ositp_internal */
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
static void dissect_ositp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
if (!dissect_ositp_internal(tvb, pinfo, tree, FALSE))
|
2001-11-26 04:52:51 +00:00
|
|
|
call_dissector(data_handle,tvb, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2002-08-28 21:04:11 +00:00
|
|
|
* CLNP part / main entry point
|
2000-04-15 22:11:26 +00:00
|
|
|
*/
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
static void dissect_clnp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
|
|
|
proto_tree *clnp_tree = NULL;
|
|
|
|
proto_item *ti;
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
guint8 cnf_proto_id;
|
|
|
|
guint8 cnf_hdr_len;
|
|
|
|
guint8 cnf_vers;
|
|
|
|
guint8 cnf_ttl;
|
|
|
|
guint8 cnf_type;
|
|
|
|
char flag_string[6+1];
|
2005-06-26 19:56:52 +00:00
|
|
|
const char *pdu_type_string;
|
2000-12-23 21:40:22 +00:00
|
|
|
proto_tree *type_tree;
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
guint16 segment_length;
|
2001-06-08 06:27:16 +00:00
|
|
|
guint16 du_id = 0;
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
guint16 segment_offset = 0;
|
|
|
|
guint16 cnf_cksum;
|
2001-06-08 06:27:16 +00:00
|
|
|
cksum_status_t cksum_status;
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
int offset;
|
2002-08-02 23:36:07 +00:00
|
|
|
guchar src_len, dst_len, nsel, opt_len = 0;
|
2001-03-13 21:34:28 +00:00
|
|
|
const guint8 *dst_addr, *src_addr;
|
2001-06-18 01:49:17 +00:00
|
|
|
gint len;
|
2000-12-23 19:34:46 +00:00
|
|
|
guint next_length;
|
|
|
|
proto_tree *discpdu_tree;
|
Have a flag in the "packet_info" structure, which indicates whether the
stuff currently being dissected is part of a packet included in an error
packet (e.g., an ICMP Unreachable packet). Have the TCP dissector not
bother doing reassembly if the TCP segment is part of an error packet,
rather than an actual TCP transmission; other dissectors might want to
treat those packets specially as well.
Add to the "tcpinfo" structure a flag indicating whether the URG flag
was set, rather than having the zero or non-zero value of the urgent
pointer indicate that. (Yes, at least as I read RFC 793, a zero urgent
pointer value isn't useful, as it means "the stuff before this segment
is urgent", but it's certainly possible to put onto the wire a TCP
segment with URG set and a zero urgent pointer.)
Don't dissect the TCP header by grabbing the entire header with
"tvb_memcpy()" and then pulling stuff out of it - extract stuff with
individual tvbuff calls, and put stuff into the protocol tree and the
Info column as we extract it, so that we can dissect a partial header.
This lets us, for example, get the source and destination ports from the
TCP header of the part of a TCP segment included in a minimum-length
ICMPv4 error packet.
svn path=/trunk/; revision=3986
2001-10-01 08:29:37 +00:00
|
|
|
gboolean save_in_error_pkt;
|
2001-06-08 06:27:16 +00:00
|
|
|
fragment_data *fd_head;
|
2003-01-20 05:42:37 +00:00
|
|
|
tvbuff_t *next_tvb;
|
Use the "fragmented" field of the "packet_info" structure in
"dissect_frame()" to indicate whether a ReportedBoundsError was due to
the packet being malformed (i.e., the packet was shorter than it's
supposed to be, so the dissector went past the end trying to extract
fields that were supposed to be there) or due to it not being
reassembled (i.e., the packet was fragmented, and we didn't reassemble
it, but just treated the first fragment as the entire packet, so the
dissector went past the end trying to extract fields that were partially
or completely in fragments after that). Mark the latter as being
unreasembled rather than malformed.
Properly initialize, save, and restore that field, and properly set it,
so that works.
svn path=/trunk/; revision=4555
2002-01-17 06:29:20 +00:00
|
|
|
gboolean update_col_info = TRUE;
|
|
|
|
gboolean save_fragmented;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
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);
|
2000-04-15 22:11:26 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
cnf_proto_id = tvb_get_guint8(tvb, P_CLNP_PROTO_ID);
|
|
|
|
if (cnf_proto_id == NLPID_NULL) {
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_set_str(pinfo->cinfo, COL_INFO, "Inactive subset");
|
2000-04-15 22:11:26 +00:00
|
|
|
if (tree) {
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_clnp, tvb, P_CLNP_PROTO_ID, 1, FALSE);
|
2000-04-15 22:11:26 +00:00
|
|
|
clnp_tree = proto_item_add_subtree(ti, ett_clnp);
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_uint_format(clnp_tree, hf_clnp_id, tvb, P_CLNP_PROTO_ID, 1,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
cnf_proto_id,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Inactive subset");
|
2002-08-28 21:04:11 +00:00
|
|
|
}
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
next_tvb = tvb_new_subset(tvb, 1, -1, -1);
|
|
|
|
dissect_ositp_internal(next_tvb, pinfo, tree, TRUE);
|
2000-04-15 22:11:26 +00:00
|
|
|
return;
|
2002-08-28 21:04:11 +00:00
|
|
|
}
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
/* return if version not known */
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
cnf_vers = tvb_get_guint8(tvb, P_CLNP_VERS);
|
|
|
|
if (cnf_vers != ISO8473_V1) {
|
2001-11-26 04:52:51 +00:00
|
|
|
call_dissector(data_handle,tvb, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fixed part decoding */
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
cnf_hdr_len = tvb_get_guint8(tvb, P_CLNP_HDR_LEN);
|
|
|
|
opt_len = cnf_hdr_len;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
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);
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_uint(clnp_tree, hf_clnp_id, tvb, P_CLNP_PROTO_ID, 1,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
cnf_proto_id);
|
2002-08-28 21:04:11 +00:00
|
|
|
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,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
cnf_vers);
|
|
|
|
cnf_ttl = tvb_get_guint8(tvb, P_CLNP_TTL);
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_uint_format(clnp_tree, hf_clnp_ttl, tvb, P_CLNP_TTL, 1,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
cnf_ttl,
|
2002-08-28 21:04:11 +00:00
|
|
|
"Holding Time : %u (%u.%u secs)",
|
2000-12-23 23:06:50 +00:00
|
|
|
cnf_ttl, cnf_ttl / 2, (cnf_ttl % 2) * 5);
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
cnf_type = tvb_get_guint8(tvb, P_CLNP_TYPE);
|
2000-12-23 23:06:50 +00:00
|
|
|
pdu_type_string = val_to_str(cnf_type & CNF_TYPE, npdu_type_abbrev_vals,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
"Unknown (0x%02x)");
|
2000-04-15 22:11:26 +00:00
|
|
|
flag_string[0] = '\0';
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
if (cnf_type & CNF_SEG_OK)
|
2000-04-15 22:11:26 +00:00
|
|
|
strcat(flag_string, "S ");
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
if (cnf_type & CNF_MORE_SEGS)
|
2000-04-15 22:11:26 +00:00
|
|
|
strcat(flag_string, "M ");
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
if (cnf_type & CNF_ERR_OK)
|
2000-04-15 22:11:26 +00:00
|
|
|
strcat(flag_string, "E ");
|
|
|
|
if (tree) {
|
2000-12-23 21:40:22 +00:00
|
|
|
ti = proto_tree_add_uint_format(clnp_tree, hf_clnp_type, tvb, P_CLNP_TYPE, 1,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
cnf_type,
|
2000-04-15 22:11:26 +00:00
|
|
|
"PDU Type : 0x%02x (%s%s)",
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
cnf_type,
|
2000-04-15 22:11:26 +00:00
|
|
|
flag_string,
|
|
|
|
pdu_type_string);
|
2000-12-23 21:40:22 +00:00
|
|
|
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"));
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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)) {
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "%s NPDU %s", pdu_type_string, flag_string);
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
segment_length = tvb_get_ntohs(tvb, P_CLNP_SEGLEN);
|
2001-06-08 06:27:16 +00:00
|
|
|
cnf_cksum = tvb_get_ntohs(tvb, P_CLNP_CKSUM);
|
|
|
|
cksum_status = calc_checksum(tvb, 0, cnf_hdr_len, cnf_cksum);
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
if (tree) {
|
|
|
|
proto_tree_add_uint(clnp_tree, hf_clnp_pdu_length, tvb, P_CLNP_SEGLEN, 2,
|
2000-04-15 22:11:26 +00:00
|
|
|
segment_length);
|
2001-06-08 06:27:16 +00:00
|
|
|
switch (cksum_status) {
|
2001-06-05 09:06:19 +00:00
|
|
|
|
|
|
|
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,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
cnf_cksum,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Checksum : 0x%04x",
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
cnf_cksum);
|
2001-06-05 09:06:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2000-04-15 22:11:26 +00:00
|
|
|
opt_len -= 9; /* Fixed part of Hesder */
|
|
|
|
} /* tree */
|
|
|
|
|
|
|
|
/* address part */
|
2002-08-28 21:04:11 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
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);
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
if (tree) {
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_uint(clnp_tree, hf_clnp_dest_length, tvb, offset, 1,
|
2000-04-15 22:11:26 +00:00
|
|
|
dst_len);
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_bytes_format(clnp_tree, hf_clnp_dest, tvb, offset + 1 , dst_len,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
dst_addr,
|
2002-08-28 21:04:11 +00:00
|
|
|
" DA : %s",
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
print_nsap_net(dst_addr, dst_len));
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_uint(clnp_tree, hf_clnp_src_length, tvb,
|
2000-04-15 22:11:26 +00:00
|
|
|
offset + 1 + dst_len, 1, src_len);
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_bytes_format(clnp_tree, hf_clnp_src, tvb,
|
2000-04-15 22:11:26 +00:00
|
|
|
offset + dst_len + 2, src_len,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
src_addr,
|
2002-08-28 21:04:11 +00:00
|
|
|
" SA : %s",
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
print_nsap_net(src_addr, src_len));
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
opt_len -= dst_len + src_len +2;
|
|
|
|
}
|
|
|
|
|
2001-03-15 06:41:13 +00:00
|
|
|
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);
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
/* Segmentation Part */
|
|
|
|
|
|
|
|
offset += dst_len + src_len + 2;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
if (cnf_type & CNF_SEG_OK) {
|
2000-04-15 22:11:26 +00:00
|
|
|
struct clnp_segment seg; /* XXX - not used */
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tvb_memcpy(tvb, (guint8 *)&seg, offset, sizeof(seg)); /* XXX - not used */
|
2002-08-28 21:04:11 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
segment_offset = tvb_get_ntohs(tvb, offset + 2);
|
2001-06-08 06:27:16 +00:00
|
|
|
du_id = tvb_get_ntohs(tvb, offset);
|
2000-04-15 22:11:26 +00:00
|
|
|
if (tree) {
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_text(clnp_tree, tvb, offset, 2,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Data unit identifier: %06u",
|
2001-06-08 06:27:16 +00:00
|
|
|
du_id);
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(clnp_tree, tvb, offset + 2 , 2,
|
2002-08-28 21:04:11 +00:00
|
|
|
"Segment offset : %6u",
|
2000-04-15 22:11:26 +00:00
|
|
|
segment_offset);
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
proto_tree_add_text(clnp_tree, tvb, offset + 4 , 2,
|
2002-08-28 21:04:11 +00:00
|
|
|
"Total length : %6u",
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
tvb_get_ntohs(tvb, offset + 4));
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
offset += 6;
|
|
|
|
opt_len -= 6;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tree) {
|
|
|
|
/* To do : decode options */
|
|
|
|
/*
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_text(clnp_tree, tvb, offset,
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
cnf_hdr_len - offset,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Options/Data: <not shown>");
|
|
|
|
*/
|
|
|
|
/* QUICK HACK Option Len:= PDU_Hd_length-( FixedPart+AddresPart+SegmentPart )*/
|
|
|
|
|
2002-04-30 23:56:58 +00:00
|
|
|
dissect_osi_options( opt_len,
|
2002-08-28 21:04:11 +00:00
|
|
|
tvb, offset, clnp_tree );
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Length of CLNP datagram plus headers above it. */
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
len = segment_length;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
offset = cnf_hdr_len;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-03-04 06:47:10 +00:00
|
|
|
/* If clnp_reassemble is on, this is a segment, we have all the
|
2002-01-20 01:04:18 +00:00
|
|
|
* data in the segment, and the checksum is valid, then just add the
|
|
|
|
* segment to the hashtable.
|
2001-06-08 06:27:16 +00:00
|
|
|
*/
|
Use the "fragmented" field of the "packet_info" structure in
"dissect_frame()" to indicate whether a ReportedBoundsError was due to
the packet being malformed (i.e., the packet was shorter than it's
supposed to be, so the dissector went past the end trying to extract
fields that were supposed to be there) or due to it not being
reassembled (i.e., the packet was fragmented, and we didn't reassemble
it, but just treated the first fragment as the entire packet, so the
dissector went past the end trying to extract fields that were partially
or completely in fragments after that). Mark the latter as being
unreasembled rather than malformed.
Properly initialize, save, and restore that field, and properly set it,
so that works.
svn path=/trunk/; revision=4555
2002-01-17 06:29:20 +00:00
|
|
|
save_fragmented = pinfo->fragmented;
|
2001-06-08 06:27:16 +00:00
|
|
|
if (clnp_reassemble && (cnf_type & CNF_SEG_OK) &&
|
2002-01-20 01:04:18 +00:00
|
|
|
((cnf_type & CNF_MORE_SEGS) || segment_offset != 0) &&
|
2003-03-04 06:47:10 +00:00
|
|
|
tvb_bytes_exist(tvb, offset, segment_length - cnf_hdr_len) &&
|
2005-10-17 20:05:18 +00:00
|
|
|
segment_length > cnf_hdr_len &&
|
2002-01-20 01:04:18 +00:00
|
|
|
cksum_status != CKSUM_NOT_OK) {
|
Use "fragment_add_check()" for IPv6 and CLNP reassembly. (Possibly an
issue for CLNP, with its 16-bit IDs, which could be duplicated in a
sufficiently large capture even if CLNP implementations don't
deliberately reuse IDs; less of an issue for IPv6, with its 32-bit IDs
and with its prohibition on reuse:
For every packet that is to be fragmented, the source node generates
an Identification value. The Identification must be different than
that of any other fragmented packet sent recently* with the same
Source Address and Destination Address. If a Routing header is
present, the Destination Address of concern is that of the final
destination.
* "recently" means within the maximum likely lifetime of a packet,
including transit time from source to destination and time spent
awaiting reassembly with other fragments of the same packet.
However, it is not required that a source node know the maximum
packet lifetime. Rather, it is assumed that the requirement can
be met by maintaining the Identification value as a simple, 32-
bit, "wrap-around" counter, incremented each time a packet must
be fragmented. It is an implementation choice whether to
maintain a single counter for the node or multiple counters,
e.g., one for each of the node's possible source addresses, or
one for each active (source address, destination address)
combination.
but perhaps we'll ultimately be able to get rid of the old
"fragment_add()" entirely and rename "fragment_add_check()" to
"fragment_add()").
svn path=/trunk/; revision=7507
2003-04-20 00:21:17 +00:00
|
|
|
fd_head = fragment_add_check(tvb, offset, pinfo, du_id, clnp_segment_table,
|
|
|
|
clnp_reassembled_table, segment_offset,
|
|
|
|
segment_length - cnf_hdr_len,
|
2002-01-20 01:04:18 +00:00
|
|
|
cnf_type & CNF_MORE_SEGS);
|
2003-04-20 11:36:16 +00:00
|
|
|
|
2003-08-28 04:19:29 +00:00
|
|
|
next_tvb = process_reassembled_data(tvb, offset, pinfo, "Reassembled CLNP",
|
|
|
|
fd_head, &clnp_frag_items, &update_col_info, clnp_tree);
|
2001-06-08 06:27:16 +00:00
|
|
|
} 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. */
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "Fragmented %s NPDU %s(off=%u)",
|
2000-04-15 22:11:26 +00:00
|
|
|
pdu_type_string, flag_string, segment_offset);
|
2001-06-08 06:27:16 +00:00
|
|
|
|
|
|
|
/* As we haven't reassembled anything, we haven't changed "pi", so
|
|
|
|
we don't have to restore it. */
|
2002-05-30 01:56:55 +00:00
|
|
|
call_dissector(data_handle, tvb_new_subset(tvb, offset, -1, -1), pinfo,
|
|
|
|
tree);
|
Use the "fragmented" field of the "packet_info" structure in
"dissect_frame()" to indicate whether a ReportedBoundsError was due to
the packet being malformed (i.e., the packet was shorter than it's
supposed to be, so the dissector went past the end trying to extract
fields that were supposed to be there) or due to it not being
reassembled (i.e., the packet was fragmented, and we didn't reassemble
it, but just treated the first fragment as the entire packet, so the
dissector went past the end trying to extract fields that were partially
or completely in fragments after that). Mark the latter as being
unreasembled rather than malformed.
Properly initialize, save, and restore that field, and properly set it,
so that works.
svn path=/trunk/; revision=4555
2002-01-17 06:29:20 +00:00
|
|
|
pinfo->fragmented = save_fragmented;
|
2000-04-15 22:11:26 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
if (tvb_offset_exists(tvb, offset)) {
|
|
|
|
switch (cnf_type & CNF_TYPE) {
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
case DT_NPDU:
|
|
|
|
case MD_NPDU:
|
|
|
|
/* Continue with COTP if any data.
|
|
|
|
XXX - if this isn't the first Derived PDU of a segmented Initial
|
|
|
|
PDU, skip that? */
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
if (nsel == (char)tp_nsap_selector || always_decode_transport) {
|
Use the "fragmented" field of the "packet_info" structure in
"dissect_frame()" to indicate whether a ReportedBoundsError was due to
the packet being malformed (i.e., the packet was shorter than it's
supposed to be, so the dissector went past the end trying to extract
fields that were supposed to be there) or due to it not being
reassembled (i.e., the packet was fragmented, and we didn't reassemble
it, but just treated the first fragment as the entire packet, so the
dissector went past the end trying to extract fields that were partially
or completely in fragments after that). Mark the latter as being
unreasembled rather than malformed.
Properly initialize, save, and restore that field, and properly set it,
so that works.
svn path=/trunk/; revision=4555
2002-01-17 06:29:20 +00:00
|
|
|
if (dissect_ositp_internal(next_tvb, pinfo, tree, FALSE)) {
|
|
|
|
pinfo->fragmented = save_fragmented;
|
2000-07-01 08:55:28 +00:00
|
|
|
return; /* yes, it appears to be COTP or CLTP */
|
Use the "fragmented" field of the "packet_info" structure in
"dissect_frame()" to indicate whether a ReportedBoundsError was due to
the packet being malformed (i.e., the packet was shorter than it's
supposed to be, so the dissector went past the end trying to extract
fields that were supposed to be there) or due to it not being
reassembled (i.e., the packet was fragmented, and we didn't reassemble
it, but just treated the first fragment as the entire packet, so the
dissector went past the end trying to extract fields that were partially
or completely in fragments after that). Mark the latter as being
unreasembled rather than malformed.
Properly initialize, save, and restore that field, and properly set it,
so that works.
svn path=/trunk/; revision=4555
2002-01-17 06:29:20 +00:00
|
|
|
}
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
2003-02-25 18:59:47 +00:00
|
|
|
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 */
|
|
|
|
}
|
2005-10-17 20:05:18 +00:00
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
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;
|
2000-12-23 19:34:46 +00:00
|
|
|
dissect it as a CLNP PDU. */
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "%s NPDU %s", pdu_type_string, flag_string);
|
2000-12-23 19:34:46 +00:00
|
|
|
if (tree) {
|
|
|
|
next_length = tvb_length_remaining(tvb, offset);
|
|
|
|
if (next_length != 0) {
|
2003-01-20 05:42:37 +00:00
|
|
|
/* 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);
|
2001-05-27 04:14:53 +00:00
|
|
|
|
Have a flag in the "packet_info" structure, which indicates whether the
stuff currently being dissected is part of a packet included in an error
packet (e.g., an ICMP Unreachable packet). Have the TCP dissector not
bother doing reassembly if the TCP segment is part of an error packet,
rather than an actual TCP transmission; other dissectors might want to
treat those packets specially as well.
Add to the "tcpinfo" structure a flag indicating whether the URG flag
was set, rather than having the zero or non-zero value of the urgent
pointer indicate that. (Yes, at least as I read RFC 793, a zero urgent
pointer value isn't useful, as it means "the stuff before this segment
is urgent", but it's certainly possible to put onto the wire a TCP
segment with URG set and a zero urgent pointer.)
Don't dissect the TCP header by grabbing the entire header with
"tvb_memcpy()" and then pulling stuff out of it - extract stuff with
individual tvbuff calls, and put stuff into the protocol tree and the
Info column as we extract it, so that we can dissect a partial header.
This lets us, for example, get the source and destination ports from the
TCP header of the part of a TCP segment included in a minimum-length
ICMPv4 error packet.
svn path=/trunk/; revision=3986
2001-10-01 08:29:37 +00:00
|
|
|
/* 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;
|
|
|
|
|
2003-01-20 05:42:37 +00:00
|
|
|
call_dissector(clnp_handle, next_tvb, pinfo, discpdu_tree);
|
2001-05-27 04:14:53 +00:00
|
|
|
|
Have a flag in the "packet_info" structure, which indicates whether the
stuff currently being dissected is part of a packet included in an error
packet (e.g., an ICMP Unreachable packet). Have the TCP dissector not
bother doing reassembly if the TCP segment is part of an error packet,
rather than an actual TCP transmission; other dissectors might want to
treat those packets specially as well.
Add to the "tcpinfo" structure a flag indicating whether the URG flag
was set, rather than having the zero or non-zero value of the urgent
pointer indicate that. (Yes, at least as I read RFC 793, a zero urgent
pointer value isn't useful, as it means "the stuff before this segment
is urgent", but it's certainly possible to put onto the wire a TCP
segment with URG set and a zero urgent pointer.)
Don't dissect the TCP header by grabbing the entire header with
"tvb_memcpy()" and then pulling stuff out of it - extract stuff with
individual tvbuff calls, and put stuff into the protocol tree and the
Info column as we extract it, so that we can dissect a partial header.
This lets us, for example, get the source and destination ports from the
TCP header of the part of a TCP segment included in a minimum-length
ICMPv4 error packet.
svn path=/trunk/; revision=3986
2001-10-01 08:29:37 +00:00
|
|
|
/* Restore the "we're inside an error packet" flag. */
|
|
|
|
pinfo->in_error_pkt = save_in_error_pkt;
|
2000-12-23 19:34:46 +00:00
|
|
|
}
|
|
|
|
}
|
Use the "fragmented" field of the "packet_info" structure in
"dissect_frame()" to indicate whether a ReportedBoundsError was due to
the packet being malformed (i.e., the packet was shorter than it's
supposed to be, so the dissector went past the end trying to extract
fields that were supposed to be there) or due to it not being
reassembled (i.e., the packet was fragmented, and we didn't reassemble
it, but just treated the first fragment as the entire packet, so the
dissector went past the end trying to extract fields that were partially
or completely in fragments after that). Mark the latter as being
unreasembled rather than malformed.
Properly initialize, save, and restore that field, and properly set it,
so that works.
svn path=/trunk/; revision=4555
2002-01-17 06:29:20 +00:00
|
|
|
pinfo->fragmented = save_fragmented;
|
2001-06-08 07:44:36 +00:00
|
|
|
return; /* we're done with this PDU */
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
case ERQ_NPDU:
|
|
|
|
case ERP_NPDU:
|
|
|
|
/* XXX - dissect this */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "%s NPDU %s", pdu_type_string, flag_string);
|
2001-11-26 04:52:51 +00:00
|
|
|
call_dissector(data_handle,next_tvb, pinfo, tree);
|
Use the "fragmented" field of the "packet_info" structure in
"dissect_frame()" to indicate whether a ReportedBoundsError was due to
the packet being malformed (i.e., the packet was shorter than it's
supposed to be, so the dissector went past the end trying to extract
fields that were supposed to be there) or due to it not being
reassembled (i.e., the packet was fragmented, and we didn't reassemble
it, but just treated the first fragment as the entire packet, so the
dissector went past the end trying to extract fields that were partially
or completely in fragments after that). Mark the latter as being
unreasembled rather than malformed.
Properly initialize, save, and restore that field, and properly set it,
so that works.
svn path=/trunk/; revision=4555
2002-01-17 06:29:20 +00:00
|
|
|
pinfo->fragmented = save_fragmented;
|
2000-04-15 22:11:26 +00:00
|
|
|
} /* dissect_clnp */
|
|
|
|
|
2001-06-08 06:27:16 +00:00
|
|
|
static void
|
|
|
|
clnp_reassemble_init(void)
|
|
|
|
{
|
|
|
|
fragment_table_init(&clnp_segment_table);
|
Use "fragment_add_check()" for IPv6 and CLNP reassembly. (Possibly an
issue for CLNP, with its 16-bit IDs, which could be duplicated in a
sufficiently large capture even if CLNP implementations don't
deliberately reuse IDs; less of an issue for IPv6, with its 32-bit IDs
and with its prohibition on reuse:
For every packet that is to be fragmented, the source node generates
an Identification value. The Identification must be different than
that of any other fragmented packet sent recently* with the same
Source Address and Destination Address. If a Routing header is
present, the Destination Address of concern is that of the final
destination.
* "recently" means within the maximum likely lifetime of a packet,
including transit time from source to destination and time spent
awaiting reassembly with other fragments of the same packet.
However, it is not required that a source node know the maximum
packet lifetime. Rather, it is assumed that the requirement can
be met by maintaining the Identification value as a simple, 32-
bit, "wrap-around" counter, incremented each time a packet must
be fragmented. It is an implementation choice whether to
maintain a single counter for the node or multiple counters,
e.g., one for each of the node's possible source addresses, or
one for each active (source address, destination address)
combination.
but perhaps we'll ultimately be able to get rid of the old
"fragment_add()" entirely and rename "fragment_add_check()" to
"fragment_add()").
svn path=/trunk/; revision=7507
2003-04-20 00:21:17 +00:00
|
|
|
reassembled_table_init(&clnp_reassembled_table);
|
2005-12-16 00:32:12 +00:00
|
|
|
cotp_dst_ref = 0;
|
2001-06-08 06:27:16 +00:00
|
|
|
}
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-05-28 22:58:46 +00:00
|
|
|
static void
|
|
|
|
cotp_reassemble_init(void)
|
|
|
|
{
|
|
|
|
fragment_table_init(&cotp_segment_table);
|
|
|
|
reassembled_table_init(&cotp_reassembled_table);
|
|
|
|
}
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
void proto_register_clnp(void)
|
|
|
|
{
|
|
|
|
static hf_register_info hf[] = {
|
|
|
|
{ &hf_clnp_id,
|
2002-08-28 21:04:11 +00:00
|
|
|
{ "Network Layer Protocol Identifier", "clnp.nlpi", FT_UINT8, BASE_HEX,
|
2001-06-18 02:18:27 +00:00
|
|
|
VALS(nlpid_vals), 0x0, "", HFILL }},
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_length,
|
2001-06-18 02:18:27 +00:00
|
|
|
{ "HDR Length ", "clnp.len", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_version,
|
2001-06-18 02:18:27 +00:00
|
|
|
{ "Version ", "clnp.version", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_ttl,
|
2001-06-18 02:18:27 +00:00
|
|
|
{ "Holding Time ", "clnp.ttl", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_type,
|
2001-06-18 02:18:27 +00:00
|
|
|
{ "PDU Type ", "clnp.type", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_pdu_length,
|
2001-06-18 02:18:27 +00:00
|
|
|
{ "PDU length ", "clnp.pdu.len", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_checksum,
|
2001-06-18 02:18:27 +00:00
|
|
|
{ "Checksum ", "clnp.checksum", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_dest_length,
|
2001-06-18 02:18:27 +00:00
|
|
|
{ "DAL ", "clnp.dsap.len", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_dest,
|
2001-06-18 02:18:27 +00:00
|
|
|
{ " DA ", "clnp.dsap", FT_BYTES, BASE_NONE, NULL, 0x0, "", HFILL }},
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_src_length,
|
2001-06-18 02:18:27 +00:00
|
|
|
{ "SAL ", "clnp.ssap.len", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_src,
|
2001-06-18 02:18:27 +00:00
|
|
|
{ " SA ", "clnp.ssap", FT_BYTES, BASE_NONE, NULL, 0x0, "", HFILL }},
|
2001-06-08 06:27:16 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_segment_overlap,
|
|
|
|
{ "Segment overlap", "clnp.segment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"Segment overlaps with other segments", HFILL }},
|
2001-06-08 06:27:16 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_segment_overlap_conflict,
|
|
|
|
{ "Conflicting data in segment overlap", "clnp.segment.overlap.conflict", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"Overlapping segments contained conflicting data", HFILL }},
|
2001-06-08 06:27:16 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_segment_multiple_tails,
|
|
|
|
{ "Multiple tail segments found", "clnp.segment.multipletails", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"Several tails were found when reassembling the packet", HFILL }},
|
2001-06-08 06:27:16 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_segment_too_long_segment,
|
|
|
|
{ "Segment too long", "clnp.segment.toolongsegment", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"Segment contained data past end of packet", HFILL }},
|
2001-06-08 06:27:16 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_segment_error,
|
2002-12-19 11:22:38 +00:00
|
|
|
{ "Reassembly error", "clnp.segment.error", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"Reassembly error due to illegal segments", HFILL }},
|
2001-06-08 06:27:16 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_segment,
|
2002-12-19 11:22:38 +00:00
|
|
|
{ "CLNP Segment", "clnp.segment", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"CLNP Segment", HFILL }},
|
2001-06-08 06:27:16 +00:00
|
|
|
|
|
|
|
{ &hf_clnp_segments,
|
|
|
|
{ "CLNP Segments", "clnp.segments", FT_NONE, BASE_DEC, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"CLNP Segments", HFILL }},
|
2003-04-20 08:06:01 +00:00
|
|
|
|
|
|
|
{ &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 }}
|
2000-04-15 22:11:26 +00:00
|
|
|
};
|
|
|
|
static gint *ett[] = {
|
|
|
|
&ett_clnp,
|
2000-12-23 21:40:22 +00:00
|
|
|
&ett_clnp_type,
|
2001-06-08 06:27:16 +00:00
|
|
|
&ett_clnp_segments,
|
|
|
|
&ett_clnp_segment,
|
2000-12-23 19:34:46 +00:00
|
|
|
&ett_clnp_disc_pdu,
|
2000-04-15 22:11:26 +00:00
|
|
|
};
|
|
|
|
|
2000-08-06 15:54:42 +00:00
|
|
|
module_t *clnp_module;
|
|
|
|
|
2001-01-03 06:56:03 +00:00
|
|
|
proto_clnp = proto_register_protocol(PROTO_STRING_CLNP, "CLNP", "clnp");
|
2000-04-15 22:11:26 +00:00
|
|
|
proto_register_field_array(proto_clnp, hf, array_length(hf));
|
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
2003-01-05 02:50:23 +00:00
|
|
|
register_dissector("clnp", dissect_clnp, proto_clnp);
|
2005-10-17 20:05:18 +00:00
|
|
|
register_heur_dissector_list("clnp", &clnp_heur_subdissector_list);
|
2003-04-15 21:33:26 +00:00
|
|
|
register_init_routine(clnp_reassemble_init);
|
2003-05-28 22:58:46 +00:00
|
|
|
register_init_routine(cotp_reassemble_init);
|
2000-08-06 15:54:42 +00:00
|
|
|
|
2001-01-03 07:53:48 +00:00
|
|
|
clnp_module = prefs_register_protocol(proto_clnp, NULL);
|
2000-08-06 15:54:42 +00:00
|
|
|
prefs_register_uint_preference(clnp_module, "tp_nsap_selector",
|
2004-02-24 17:49:07 +00:00
|
|
|
"NSAP selector for Transport Protocol (last byte in hex)",
|
|
|
|
"NSAP selector for Transport Protocol (last byte in hex)",
|
2000-08-06 15:54:42 +00:00
|
|
|
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);
|
2001-06-08 06:27:16 +00:00
|
|
|
prefs_register_bool_preference(clnp_module, "reassemble",
|
|
|
|
"Reassemble segmented CLNP datagrams",
|
|
|
|
"Whether segmented CLNP datagrams should be reassembled",
|
|
|
|
&clnp_reassemble);
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
|
|
|
|
2003-04-15 21:33:26 +00:00
|
|
|
void
|
|
|
|
proto_reg_handoff_clnp(void)
|
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
void proto_register_cotp(void)
|
|
|
|
{
|
2003-04-15 10:25:55 +00:00
|
|
|
static hf_register_info hf[] = {
|
|
|
|
{ &hf_cotp_srcref,
|
2003-04-15 21:33:26 +00:00
|
|
|
{ "Source reference", "cotp.srcref", FT_UINT16, BASE_HEX, NULL, 0x0,
|
2003-04-15 10:25:55 +00:00
|
|
|
"Source address reference", HFILL}},
|
|
|
|
{ &hf_cotp_destref,
|
2003-04-15 21:33:26 +00:00
|
|
|
{ "Destination reference", "cotp.destref", FT_UINT16, BASE_HEX, NULL, 0x0,
|
2005-10-17 20:05:18 +00:00
|
|
|
"Destination address reference", HFILL}},
|
2005-07-12 21:21:14 +00:00
|
|
|
{ &hf_cotp_li,
|
|
|
|
{ "Length", "cotp.li", FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length Indicator, length of this header", HFILL}},
|
2003-04-15 10:25:55 +00:00
|
|
|
{ &hf_cotp_type,
|
2005-07-12 21:21:14 +00:00
|
|
|
{ "PDU Type", "cotp.type", FT_UINT8, BASE_HEX, VALS(cotp_tpdu_type_abbrev_vals), 0x0,
|
|
|
|
"PDU Type - upper nibble of byte", HFILL}},
|
2004-08-20 08:15:11 +00:00
|
|
|
{ &hf_cotp_tpdu_number,
|
2005-07-12 21:21:14 +00:00
|
|
|
{ "TPDU number", "cotp.tpdu-number", FT_UINT8, BASE_HEX, NULL, 0x7f,
|
2004-08-20 08:15:11 +00:00
|
|
|
"TPDU number", HFILL}},
|
|
|
|
{ &hf_cotp_tpdu_number_extended,
|
2005-07-12 21:21:14 +00:00
|
|
|
{ "TPDU number", "cotp.tpdu-number", FT_UINT32, BASE_HEX, NULL, 0x0 /* XXX - 0x7fff? */,
|
2004-08-20 08:15:11 +00:00
|
|
|
"TPDU number", HFILL}},
|
|
|
|
{ &hf_cotp_next_tpdu_number,
|
|
|
|
{ "Your TPDU number", "cotp.next-tpdu-number", FT_UINT8, BASE_HEX, NULL, 0x0,
|
|
|
|
"Your TPDU number", HFILL}},
|
|
|
|
{ &hf_cotp_next_tpdu_number_extended,
|
|
|
|
{ "Your TPDU number", "cotp.next-tpdu-number", FT_UINT32, BASE_HEX, NULL, 0x0,
|
|
|
|
"Your TPDU number", HFILL}},
|
|
|
|
{ &hf_cotp_eot,
|
|
|
|
{ "Last data unit", "cotp.eot", FT_BOOLEAN, 8, TFS(&fragment_descriptions), 0x80,
|
2005-02-02 21:13:52 +00:00
|
|
|
"Is current TPDU the last data unit of a complete DT TPDU sequence (End of TSDU)?", HFILL}},
|
2004-08-20 08:15:11 +00:00
|
|
|
{ &hf_cotp_eot_extended,
|
|
|
|
{ "Last data unit", "cotp.eot", FT_BOOLEAN, 32, TFS(&fragment_descriptions), 0x80000000,
|
2005-02-02 21:13:52 +00:00
|
|
|
"Is current TPDU the last data unit of a complete DT TPDU sequence (End of TSDU)?", HFILL}},
|
2003-05-28 22:58:46 +00:00
|
|
|
{ &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 }},
|
2004-05-23 23:07:17 +00:00
|
|
|
/* ISO DP 8073 i13.3.4(a) Source and destination TSAPs are defined as
|
|
|
|
identifiers of unspecified type and length.
|
|
|
|
Some implementations of COTP use printable strings, others use raw bytes.
|
|
|
|
We always add both representations to the tree; one will always be hidden
|
|
|
|
depending on the tsap display preference */
|
|
|
|
{ &hf_cotp_vp_src_tsap,
|
|
|
|
{ "Source TSAP", "cotp.src-tsap", FT_STRING, BASE_NONE, NULL, 0x0,
|
|
|
|
"Calling TSAP", HFILL }},
|
|
|
|
{ &hf_cotp_vp_src_tsap_bytes,
|
|
|
|
{ "Source TSAP", "cotp.src-tsap-bytes", FT_BYTES, BASE_NONE, NULL, 0x0,
|
|
|
|
"Calling TSAP (bytes representation)", HFILL }},
|
|
|
|
{ &hf_cotp_vp_dst_tsap,
|
|
|
|
{ "Destination TSAP", "cotp.dst-tsap", FT_STRING, BASE_NONE, NULL, 0x0,
|
|
|
|
"Called TSAP", HFILL }},
|
|
|
|
{ &hf_cotp_vp_dst_tsap_bytes,
|
|
|
|
{ "Destination TSAP", "cotp.dst-tsap-bytes", FT_BYTES, BASE_NONE, NULL, 0x0,
|
|
|
|
"Called TSAP (bytes representation)", HFILL }},
|
2003-05-28 22:58:46 +00:00
|
|
|
|
2003-04-15 10:25:55 +00:00
|
|
|
};
|
|
|
|
static gint *ett[] = {
|
|
|
|
&ett_cotp,
|
2003-05-28 22:58:46 +00:00
|
|
|
&ett_cotp_segment,
|
|
|
|
&ett_cotp_segments,
|
2003-04-15 10:25:55 +00:00
|
|
|
};
|
2000-04-15 22:11:26 +00:00
|
|
|
|
2003-05-28 22:58:46 +00:00
|
|
|
module_t *cotp_module;
|
|
|
|
|
2003-04-15 10:25:55 +00:00
|
|
|
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));
|
2003-05-28 22:58:46 +00:00
|
|
|
cotp_module = prefs_register_protocol(proto_cotp, NULL);
|
|
|
|
|
|
|
|
prefs_register_bool_preference(cotp_module, "reassemble",
|
|
|
|
"Reassemble segmented COTP datagrams",
|
2004-08-21 09:02:52 +00:00
|
|
|
"Whether segmented COTP datagrams should be reassembled."
|
|
|
|
" To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.",
|
2003-05-28 22:58:46 +00:00
|
|
|
&cotp_reassemble);
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
|
2004-05-23 23:07:17 +00:00
|
|
|
prefs_register_enum_preference(cotp_module, "tsap_display",
|
|
|
|
"Display TSAPs as strings or bytes",
|
|
|
|
"How TSAPs should be displayed",
|
|
|
|
&tsap_display,
|
|
|
|
tsap_display_options,
|
|
|
|
FALSE);
|
|
|
|
|
2003-04-15 10:25:55 +00:00
|
|
|
/* subdissector code in inactive subset */
|
|
|
|
register_heur_dissector_list("cotp_is", &cotp_is_heur_subdissector_list);
|
2000-11-19 04:14:26 +00:00
|
|
|
|
2003-04-15 10:25:55 +00:00
|
|
|
/* other COTP/ISO 8473 subdissectors */
|
|
|
|
register_heur_dissector_list("cotp", &cotp_heur_subdissector_list);
|
2003-02-04 21:43:56 +00:00
|
|
|
|
2003-04-15 10:25:55 +00:00
|
|
|
/* XXX - what about CLTP and proto_cltp? */
|
|
|
|
register_dissector("ositp", dissect_ositp, proto_cotp);
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
2000-04-17 01:36:31 +00:00
|
|
|
|
2004-02-18 06:51:13 +00:00
|
|
|
void
|
|
|
|
proto_reg_handoff_cotp(void)
|
|
|
|
{
|
|
|
|
dissector_handle_t ositp_handle;
|
|
|
|
|
|
|
|
ositp_handle = find_dissector("ositp");
|
|
|
|
dissector_add("ip.proto", IP_PROTO_TP, ositp_handle);
|
|
|
|
}
|
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
void proto_register_cltp(void)
|
|
|
|
{
|
2003-04-15 21:33:26 +00:00
|
|
|
static hf_register_info hf[] = {
|
2005-07-12 21:21:14 +00:00
|
|
|
{ &hf_cltp_li,
|
|
|
|
{ "Length", "cltp.li", FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length Indicator, length of this header", HFILL}},
|
2003-04-15 21:33:26 +00:00
|
|
|
{ &hf_cltp_type,
|
2005-07-12 21:21:14 +00:00
|
|
|
{ "PDU Type", "cltp.type", FT_UINT8, BASE_HEX, VALS(cltp_tpdu_type_abbrev_vals), 0x0,
|
|
|
|
"PDU Type", HFILL}},
|
2003-04-15 21:33:26 +00:00
|
|
|
};
|
|
|
|
static gint *ett[] = {
|
|
|
|
&ett_cltp,
|
|
|
|
};
|
2001-12-03 04:00:26 +00:00
|
|
|
|
2003-04-15 21:33:26 +00:00
|
|
|
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));
|
2000-04-17 01:36:31 +00:00
|
|
|
}
|