2000-04-15 22:11:26 +00:00
|
|
|
/* packet-clnp.c
|
|
|
|
* Routines for ISO/OSI network and transport protocol packet disassembly
|
|
|
|
*
|
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
|
|
|
* $Id: packet-clnp.c,v 1.35 2001/10/01 08:29:34 guy Exp $
|
2000-04-15 22:11:26 +00:00
|
|
|
* Laurent Deniel <deniel@worldnet.fr>
|
|
|
|
* 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
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
|
|
# include <sys/types.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <glib.h>
|
2000-08-06 15:54:42 +00:00
|
|
|
#include "prefs.h"
|
2000-04-15 22:11:26 +00:00
|
|
|
#include "packet.h"
|
2001-06-08 06:27:16 +00:00
|
|
|
#include "reassemble.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"
|
|
|
|
#include "nlpid.h"
|
|
|
|
|
|
|
|
/* 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-07-01 08:55:28 +00:00
|
|
|
static int proto_cotp = -1;
|
2000-04-15 22:11:26 +00:00
|
|
|
static gint ett_cotp = -1;
|
2000-07-01 08:55:28 +00:00
|
|
|
static int proto_cltp = -1;
|
|
|
|
static gint ett_cltp = -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;
|
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 {
|
|
|
|
u_short cng_id; /* data unit identifier */
|
|
|
|
u_short cng_off; /* segment offset */
|
|
|
|
u_short cng_tot_len; /* total length */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* 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
|
|
|
|
|
|
|
/* 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
|
|
|
|
|
|
|
/* misc */
|
|
|
|
|
|
|
|
#define EXTRACT_SHORT(p) pntohs(p)
|
|
|
|
#define EXTRACT_LONG(p) pntohl(p)
|
|
|
|
|
|
|
|
/* global variables */
|
|
|
|
|
|
|
|
static u_char li, tpdu, cdt; /* common fields */
|
|
|
|
static u_short dst_ref;
|
|
|
|
|
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;
|
|
|
|
|
2001-06-08 06:27:16 +00:00
|
|
|
/*
|
|
|
|
* Reassembly of CLNP.
|
|
|
|
*/
|
|
|
|
static GHashTable *clnp_segment_table = NULL;
|
|
|
|
|
2000-08-06 15:54:42 +00:00
|
|
|
/* options */
|
|
|
|
static guint tp_nsap_selector = NSEL_TP;
|
|
|
|
static gboolean always_decode_transport = FALSE;
|
2001-06-08 06:27:16 +00:00
|
|
|
static gboolean clnp_reassemble = FALSE;
|
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
|
|
|
|
static gchar *print_tsap(const u_char *tsap, int length)
|
|
|
|
{
|
|
|
|
|
|
|
|
static gchar str[3][MAX_TSAP_LEN * 2 + 1];
|
|
|
|
static gchar *cur;
|
|
|
|
gchar tmp[3];
|
|
|
|
gboolean allprintable;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (cur == &str[0][0]) {
|
|
|
|
cur = &str[1][0];
|
|
|
|
} else if (cur == &str[1][0]) {
|
|
|
|
cur = &str[2][0];
|
|
|
|
} else {
|
|
|
|
cur = &str[0][0];
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
cur[0] = '\0';
|
|
|
|
if (length <= 0 || length > MAX_TSAP_LEN)
|
|
|
|
sprintf(cur, "<unsupported TSAP length>");
|
|
|
|
else {
|
|
|
|
allprintable=TRUE;
|
|
|
|
for (i=0;i<length;i++) {
|
2000-07-10 06:52:29 +00:00
|
|
|
/* If any byte is not printable ASCII, display the TSAP as a
|
|
|
|
series of hex byte values rather than as a string; this
|
|
|
|
means that, for example, accented letters will cause it
|
|
|
|
to be displayed as hex, but it also means that byte values
|
|
|
|
such as 0xff and 0xfe, which *are* printable ISO 8859/x
|
|
|
|
characters, won't be treated as printable - 0xfffffffe
|
|
|
|
is probably binary, not text. */
|
|
|
|
if (!(isascii(tsap[i]) && isprint(tsap[i]))) {
|
|
|
|
allprintable=FALSE;
|
2000-07-01 08:55:28 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!allprintable){
|
|
|
|
strcat(cur,"0x");
|
|
|
|
}
|
|
|
|
while (length != 0) {
|
|
|
|
if (allprintable)
|
|
|
|
sprintf(tmp, "%c", *tsap ++);
|
|
|
|
else
|
|
|
|
sprintf(tmp, "%02x", *tsap ++);
|
|
|
|
strcat(cur, tmp);
|
|
|
|
length --;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return cur;
|
|
|
|
|
|
|
|
} /* print_tsap */
|
|
|
|
|
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 osi_decode_tp_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);
|
|
|
|
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;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
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;
|
|
|
|
proto_tree_add_text(tree, tvb, offset, length,
|
2000-07-01 08:55:28 +00:00
|
|
|
"TPDU size: %u", 2 << c1);
|
|
|
|
offset += length;
|
|
|
|
vp_length -= length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VP_SRC_TSAP:
|
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,
|
|
|
|
"Calling TSAP: %s",
|
|
|
|
print_tsap(tvb_get_ptr(tvb, offset, length), length));
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += length;
|
|
|
|
vp_length -= length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VP_DST_TSAP:
|
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,
|
|
|
|
"Called TSAP: %s",
|
|
|
|
print_tsap(tvb_get_ptr(tvb, offset, length), length));
|
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,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Use of transport expedited data transfer\n");
|
|
|
|
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;
|
|
|
|
break;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
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;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} /* while */
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
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 int osi_decode_DR(tvbuff_t *tvb, int offset,
|
|
|
|
packet_info *pinfo, proto_tree *tree)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
|
|
|
proto_tree *cotp_tree;
|
|
|
|
proto_item *ti;
|
|
|
|
u_short src_ref;
|
|
|
|
u_char reason;
|
|
|
|
char *str;
|
|
|
|
|
|
|
|
if (li < LI_MIN_DR)
|
|
|
|
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
|
|
|
src_ref = tvb_get_ntohs(tvb, offset + P_SRC_REF);
|
|
|
|
reason = tvb_get_guint8(tvb, offset + P_REASON_IN_DR);
|
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;
|
|
|
|
}
|
|
|
|
|
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 (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->fd, COL_INFO,
|
|
|
|
"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);
|
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
|
|
|
"Length indicator: %u", 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
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset + 1, 1,
|
2000-04-15 22:11:26 +00:00
|
|
|
"TPDU code: 0x%x (DR)", 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 + 2, 2,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Destination reference: 0x%04x", 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
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset + 4, 2,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Source reference: 0x%04x", src_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
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset + 6, 1,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Cause: %s", str);
|
|
|
|
}
|
|
|
|
|
|
|
|
offset += li + 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
|
|
|
/* User data */
|
|
|
|
dissect_data(tvb, offset, pinfo, tree);
|
|
|
|
offset += tvb_length_remaining(tvb, offset);
|
|
|
|
/* we dissected all of the containing PDU */
|
|
|
|
|
|
|
|
return offset;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
} /* osi_decode_DR */
|
|
|
|
|
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 int osi_decode_DT(tvbuff_t *tvb, int offset,
|
|
|
|
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;
|
2000-04-15 22:11:26 +00:00
|
|
|
u_int tpdu_nr ;
|
|
|
|
u_int fragment = 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;
|
2000-04-15 22:11:26 +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
|
|
|
|
fragment = 1;
|
2000-07-01 08:55:28 +00:00
|
|
|
is_extended = FALSE;
|
|
|
|
is_class_234 = 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
|
|
|
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
|
|
|
|
fragment = 1;
|
2000-07-01 08:55:28 +00:00
|
|
|
is_extended = TRUE;
|
|
|
|
is_class_234 = 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
|
|
|
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
|
|
|
|
fragment = 1;
|
2000-07-01 08:55:28 +00:00
|
|
|
is_extended = FALSE;
|
|
|
|
is_class_234 = 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
|
|
|
default : /* bad TPDU */
|
|
|
|
return -1;
|
|
|
|
/*NOTREACHED*/
|
|
|
|
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
|
|
|
if (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->fd, COL_INFO, "DT TPDU (%u) dst-ref: 0x%04x %s",
|
2000-04-15 22:11:26 +00:00
|
|
|
tpdu_nr,
|
|
|
|
dst_ref,
|
|
|
|
(fragment)? "(fragment)" : "");
|
|
|
|
|
|
|
|
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);
|
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
|
|
|
"Length indicator: %u", li);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
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,
|
2000-04-15 22:11:26 +00:00
|
|
|
"TPDU code: 0x%x (DT)", tpdu);
|
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
|
|
|
if (is_class_234) {
|
|
|
|
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-04-15 22:11:26 +00:00
|
|
|
"Destination reference: 0x%04x", 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) {
|
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, 4,
|
2000-04-15 22:11:26 +00:00
|
|
|
"TPDU number: 0x%08x (%s)",
|
|
|
|
tpdu_nr,
|
|
|
|
(fragment)? "fragment":"complete");
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 4;
|
|
|
|
li -= 4;
|
|
|
|
} else {
|
|
|
|
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,
|
2000-04-15 22:11:26 +00:00
|
|
|
"TPDU number: 0x%02x (%s)",
|
|
|
|
tpdu_nr,
|
|
|
|
(fragment)? "fragment":"complete");
|
|
|
|
}
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
osi_decode_tp_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);
|
2000-04-15 22:11:26 +00:00
|
|
|
if (uses_inactive_subset){
|
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 (dissector_try_heuristic(cotp_is_heur_subdissector_list, next_tvb,
|
|
|
|
pinfo, tree)) {
|
|
|
|
*subdissector_found = TRUE;
|
|
|
|
} else {
|
|
|
|
/* Fill in other Dissectors using inactive subset here */
|
|
|
|
dissect_data(next_tvb, 0, pinfo, 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
|
|
|
} else
|
|
|
|
dissect_data(next_tvb, 0, pinfo, tree);
|
|
|
|
offset += tvb_length_remaining(tvb, offset);
|
|
|
|
/* we dissected all of the containing PDU */
|
|
|
|
|
|
|
|
return offset;
|
|
|
|
|
2000-04-15 22:11:26 +00:00
|
|
|
} /* osi_decode_DT */
|
|
|
|
|
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 int osi_decode_ED(tvbuff_t *tvb, int offset,
|
|
|
|
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;
|
2000-04-15 22:11:26 +00:00
|
|
|
u_int 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 */
|
|
|
|
|
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 (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->fd, 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);
|
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
|
|
|
"Length indicator: %u", li);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
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,
|
2000-07-01 08:55:28 +00:00
|
|
|
"TPDU code: 0x%x (ED)", tpdu);
|
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
|
|
|
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-04-15 22:11:26 +00:00
|
|
|
"Destination reference: 0x%04x", 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) {
|
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, 4,
|
2000-04-15 22:11:26 +00:00
|
|
|
"TPDU number: 0x%02x", tpdu_nr);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 4;
|
|
|
|
li -= 4;
|
|
|
|
} else {
|
|
|
|
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,
|
2000-04-15 22:11:26 +00:00
|
|
|
"TPDU number: 0x%02x", tpdu_nr);
|
|
|
|
}
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
osi_decode_tp_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);
|
|
|
|
dissect_data(next_tvb, 0, pinfo, tree);
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
} /* osi_decode_ED */
|
|
|
|
|
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 int osi_decode_RJ(tvbuff_t *tvb, int offset,
|
|
|
|
packet_info *pinfo, proto_tree *tree)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
|
|
|
proto_tree *cotp_tree;
|
|
|
|
proto_item *ti;
|
|
|
|
u_int tpdu_nr ;
|
|
|
|
u_short credit = 0;
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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 (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->fd, 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);
|
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
|
|
|
"Length indicator: %u", 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
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset + 1, 1,
|
2000-04-15 22:11:26 +00:00
|
|
|
"TPDU code: 0x%x (RJ)", tpdu);
|
|
|
|
if (li == 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
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset + 1, 1,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Credit: %u", cdt);
|
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, 2,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Destination reference: 0x%04x", dst_ref);
|
|
|
|
if (li == 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
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset + 4, 1,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Your TPDU number: 0x%02x", tpdu_nr);
|
|
|
|
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(cotp_tree, tvb, offset + 4, 4,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Your TPDU number: 0x%02x", 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
|
|
|
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;
|
|
|
|
|
|
|
|
return offset;
|
|
|
|
|
|
|
|
} /* osi_decode_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
|
|
|
static int osi_decode_CC(tvbuff_t *tvb, int offset,
|
|
|
|
packet_info *pinfo, proto_tree *tree)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
/* CC & CR decoding in the same function */
|
|
|
|
|
|
|
|
proto_tree *cotp_tree = NULL;
|
|
|
|
proto_item *ti;
|
2000-07-01 08:55:28 +00:00
|
|
|
u_short src_ref;
|
|
|
|
u_char class_option;
|
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);
|
|
|
|
class_option = (tvb_get_guint8(tvb, offset + P_CLASS_OPTION) >> 4 ) & 0x0F;
|
2000-04-15 22:11:26 +00:00
|
|
|
if (class_option > 4)
|
|
|
|
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
|
|
|
if (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->fd, COL_INFO,
|
|
|
|
"%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);
|
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
|
|
|
"Length indicator: %u", li);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
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,
|
2000-04-15 22:11:26 +00:00
|
|
|
"TPDU code: 0x%x (%s)", tpdu,
|
2000-07-01 08:55:28 +00:00
|
|
|
(tpdu == CR_TPDU) ? "CR" : "CC");
|
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
|
|
|
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-04-15 22:11:26 +00:00
|
|
|
"Destination reference: 0x%04x", dst_ref);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 2;
|
|
|
|
li -= 2;
|
|
|
|
|
|
|
|
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-04-15 22:11:26 +00:00
|
|
|
"Source reference: 0x%04x", src_ref);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 2;
|
|
|
|
li -= 2;
|
|
|
|
|
|
|
|
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,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Class option: 0x%02x", class_option);
|
|
|
|
}
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
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
|
|
|
osi_decode_tp_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
|
|
|
|
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 */
|
|
|
|
dissect_data(tvb, offset, pinfo, tree);
|
|
|
|
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
|
|
|
|
|
|
|
} /* osi_decode_CC */
|
|
|
|
|
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 int osi_decode_DC(tvbuff_t *tvb, int offset,
|
|
|
|
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
|
|
|
u_short src_ref;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
if (li > LI_MAX_DC)
|
|
|
|
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
|
|
|
src_ref = tvb_get_ntohs(tvb, offset + P_SRC_REF);
|
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 (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->fd, COL_INFO,
|
|
|
|
"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);
|
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
|
|
|
"Length indicator: %u", li);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
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,
|
2000-07-01 08:55:28 +00:00
|
|
|
"TPDU code: 0x%x (DC)", tpdu);
|
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
|
|
|
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-04-15 22:11:26 +00:00
|
|
|
"Destination reference: 0x%04x", dst_ref);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 2;
|
|
|
|
li -= 2;
|
|
|
|
|
|
|
|
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-04-15 22:11:26 +00:00
|
|
|
"Source reference: 0x%04x", 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)
|
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
|
|
|
osi_decode_tp_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;
|
|
|
|
|
|
|
|
} /* osi_decode_DC */
|
|
|
|
|
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 int osi_decode_AK(tvbuff_t *tvb, int offset,
|
|
|
|
packet_info *pinfo, proto_tree *tree)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
|
|
|
proto_tree *cotp_tree = NULL;
|
|
|
|
proto_item *ti;
|
2000-07-01 08:55:28 +00:00
|
|
|
u_int tpdu_nr;
|
2000-04-15 22:11:26 +00:00
|
|
|
u_short cdt_in_ak;
|
|
|
|
|
|
|
|
if (li > LI_MAX_AK)
|
|
|
|
return -1;
|
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
if (is_LI_NORMAL_AK(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
|
|
|
tpdu_nr = tvb_get_guint8(tvb, offset + P_TPDU_NR_234);
|
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 (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->fd, 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);
|
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
|
|
|
"Length indicator: %u", li);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
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,
|
2000-07-01 08:55:28 +00:00
|
|
|
"TPDU code: 0x%x (AK)", 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;
|
|
|
|
|
|
|
|
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-04-15 22:11:26 +00:00
|
|
|
"Destination reference: 0x%04x", 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) {
|
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-07-01 08:55:28 +00:00
|
|
|
"Your TPDU number: 0x%02x", tpdu_nr);
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
2000-07-01 08:55:28 +00:00
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
|
|
|
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
|
|
|
osi_decode_tp_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 */
|
|
|
|
|
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
|
|
|
|
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 (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->fd, COL_INFO, "AK 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);
|
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
|
|
|
"Length indicator: %u", li);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
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,
|
2000-07-01 08:55:28 +00:00
|
|
|
"TPDU code: 0x%x (AK)", tpdu);
|
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
|
|
|
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-04-15 22:11:26 +00:00
|
|
|
"Destination reference: 0x%04x", dst_ref);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 2;
|
|
|
|
li -= 2;
|
|
|
|
|
|
|
|
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, 4,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Your TPDU number: 0x%08x", tpdu_nr);
|
|
|
|
}
|
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;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
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
|
|
|
osi_decode_tp_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;
|
|
|
|
|
|
|
|
} /* osi_decode_AK */
|
|
|
|
|
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 int osi_decode_EA(tvbuff_t *tvb, int offset,
|
|
|
|
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;
|
2000-04-15 22:11:26 +00:00
|
|
|
u_int tpdu_nr ;
|
|
|
|
|
|
|
|
if (li > LI_MAX_EA)
|
|
|
|
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 */
|
|
|
|
|
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 (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->fd, 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);
|
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
|
|
|
"Length indicator: %u", li);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
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,
|
2000-07-01 08:55:28 +00:00
|
|
|
"TPDU code: 0x%x (EA)", tpdu);
|
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
|
|
|
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-04-15 22:11:26 +00:00
|
|
|
"Destination reference: 0x%04x", 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) {
|
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, 4,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Your TPDU number: 0x%08x", tpdu_nr);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
offset += 4;
|
|
|
|
li -= 4;
|
|
|
|
} else {
|
|
|
|
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,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Your TPDU number: 0x%02x", tpdu_nr);
|
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
}
|
2000-04-15 22:11:26 +00:00
|
|
|
|
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
|
|
|
osi_decode_tp_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;
|
|
|
|
|
|
|
|
} /* osi_decode_EA */
|
|
|
|
|
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 int osi_decode_ER(tvbuff_t *tvb, int offset,
|
|
|
|
packet_info *pinfo, proto_tree *tree)
|
2000-04-15 22:11:26 +00:00
|
|
|
{
|
|
|
|
proto_tree *cotp_tree;
|
|
|
|
proto_item *ti;
|
|
|
|
u_char *str;
|
|
|
|
|
|
|
|
if (li > LI_MAX_ER)
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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 (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->fd, 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);
|
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
|
|
|
"Length indicator: %u", 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
|
|
|
proto_tree_add_text(cotp_tree, tvb, offset + 1, 1,
|
2000-04-15 22:11:26 +00:00
|
|
|
"TPDU code: 0x%x (ER)", 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 + 2, 2,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Destination reference: 0x%04x", 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
|
|
|
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;
|
|
|
|
|
|
|
|
} /* osi_decode_ER */
|
|
|
|
|
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 int osi_decode_UD(tvbuff_t *tvb, int offset,
|
|
|
|
packet_info *pinfo, proto_tree *tree,
|
|
|
|
gboolean *subdissector_found)
|
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
|
|
|
|
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 (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_append_str(pinfo->fd, 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);
|
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(cltp_tree, tvb, offset, 1,
|
2000-07-01 08:55:28 +00:00
|
|
|
"Length indicator: %u", li);
|
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
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(cltp_tree, tvb, offset, 1,
|
2000-07-01 08:55:28 +00:00
|
|
|
"TPDU code: 0x%x (UD)", tpdu);
|
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
li -= 1;
|
|
|
|
|
|
|
|
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
|
|
|
osi_decode_tp_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);
|
|
|
|
dissect_data(next_tvb, 0, pinfo, tree);
|
|
|
|
offset += tvb_length_remaining(tvb, offset);
|
|
|
|
/* we dissected all of the containing PDU */
|
|
|
|
|
|
|
|
return offset;
|
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
} /* osi_decode_UD */
|
|
|
|
|
|
|
|
/* Returns TRUE if we found at least one valid COTP or CLTP PDU, FALSE
|
|
|
|
otherwise.
|
|
|
|
|
|
|
|
There doesn't seem to be any way in which the OSI network layer protocol
|
|
|
|
distinguishes between COTP and CLTP, but the first two octets of both
|
|
|
|
protocols' headers mean the same thing - length and PDU type - and the
|
|
|
|
only valid CLTP PDU type is not a valid COTP PDU type, so we'll handle
|
|
|
|
both of them here. */
|
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,
|
|
|
|
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;
|
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;
|
|
|
|
|
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 (!proto_is_protocol_enabled(proto_cotp))
|
|
|
|
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. */
|
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 (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_add_str(pinfo->fd, 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) {
|
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 (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_append_str(pinfo->fd, 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
|
|
|
if ((li = tvb_get_guint8(tvb, offset + P_LI)) == 0) {
|
|
|
|
if (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_append_str(pinfo->fd, COL_INFO, "Length indicator is zero");
|
2000-04-15 22:11:26 +00:00
|
|
|
if (!first_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
|
|
|
dissect_data(tvb, offset, 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;
|
|
|
|
dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
switch (tpdu) {
|
|
|
|
case CC_TPDU :
|
|
|
|
case CR_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
|
|
|
new_offset = osi_decode_CC(tvb, offset, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case DR_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
|
|
|
new_offset = osi_decode_DR(tvb, offset, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case DT_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
|
|
|
new_offset = osi_decode_DT(tvb, offset, pinfo, tree,
|
|
|
|
uses_inactive_subset, &subdissector_found);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case ED_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
|
|
|
new_offset = osi_decode_ED(tvb, offset, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case RJ_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
|
|
|
new_offset = osi_decode_RJ(tvb, offset, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case DC_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
|
|
|
new_offset = osi_decode_DC(tvb, offset, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case AK_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
|
|
|
new_offset = osi_decode_AK(tvb, offset, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case EA_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
|
|
|
new_offset = osi_decode_EA(tvb, offset, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
|
|
|
case ER_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
|
|
|
new_offset = osi_decode_ER(tvb, offset, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
break;
|
2000-07-01 08:55:28 +00:00
|
|
|
case UD_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
|
|
|
new_offset = osi_decode_UD(tvb, offset, pinfo, tree,
|
|
|
|
&subdissector_found);
|
2000-07-01 08:55:28 +00:00
|
|
|
is_cltp = TRUE;
|
|
|
|
break;
|
2000-04-15 22:11:26 +00:00
|
|
|
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
|
|
|
if (first_tpdu && check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->fd, 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)
|
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
|
|
|
dissect_data(tvb, offset, 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. */
|
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 (!subdissector_found && check_col(pinfo->fd, COL_PROTOCOL))
|
2000-11-19 08:54:37 +00:00
|
|
|
col_set_str(pinfo->fd, 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
|
|
|
|
2000-11-19 04:14:26 +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))
|
|
|
|
dissect_data(tvb, 0, pinfo, tree);
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* CLNP part / main entry point
|
|
|
|
*/
|
|
|
|
|
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];
|
|
|
|
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;
|
2000-04-15 22:11:26 +00:00
|
|
|
u_char 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;
|
2001-05-27 04:14:53 +00:00
|
|
|
address save_dl_src;
|
|
|
|
address save_dl_dst;
|
|
|
|
address save_net_src;
|
|
|
|
address save_net_dst;
|
|
|
|
address save_src;
|
|
|
|
address save_dst;
|
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;
|
2001-09-27 10:35:40 +00:00
|
|
|
tvbuff_t *volatile next_tvb;
|
2001-06-08 06:27:16 +00:00
|
|
|
packet_info save_pi;
|
|
|
|
gboolean must_restore_pi = FALSE;
|
|
|
|
gboolean update_col_info = TRUE;
|
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 (check_col(pinfo->fd, COL_PROTOCOL))
|
2000-11-19 08:54:37 +00:00
|
|
|
col_set_str(pinfo->fd, COL_PROTOCOL, "CLNP");
|
Remove more "CHECK_DISPLAY_AS_DATA()" calls and "pinfo->current_proto ="
statements.
Move the setting of the Protocol column in various dissectors before
anything is fetched from the packet, and also clear the Info column at
that point in those and some other dissectors, so that if an exception
is thrown, the columns don't reflect the previous protocol.
Don't use
col_add_fstr(..., "%s", string);
Use
col_add_str(..., string);
as it does the same thing, but doesn't drag all the heavy *printf
machinery in.
Fix the DDTP dissector to set the Info column regardless of whether
we're building a protocol tree or not, and to set it to "Encrypted
payload" if the payload is encrypted. Also fix a typo in a field name.
Register the FTP data dissector as being associated with the FTP data
protocol, not the FTP protocol (the removed "CHECK_DISPLAY_AS_DATA()"
call checked "proto_ftp_data", and the removed "pinfo->current_proto ="
line set it to "FTP-DATA", so it should be associated with
"proto_ftp_data").
Make the H1 dissector check whether the frame has at least 2 bytes in it
before checking the first two bytes; heuristic dissectors must not throw
exceptions until they've accepted the packet as one of theirs.
Use "tvb_format_text()" rather than "tvb_get_ptr()" and "format_text()"
in some dissectors where the result of "tvb_get_ptr()" is used only in
the "format_text()" call.
In the Quake dissector, don't check whether there are at least 4 bytes
in the packet - if we return, the packet won't be dissected at all (it's
not as if some other dissector will get to handle it), and, if we don't
return, we'll throw an exception if there aren't at least 4 bytes in the
packet, so the packet will be marked as short or malformed, as
appropriate.
In the RIPng dissector, associate the table of strings for the command
field with the command field, so that the dissector doesn't have to
format the string for the protocol tree entry itself, and so that the
filter construction dialog box can let you select "Request" or
"Response" from a list rather than requiring you to know the values for
"Request" and "Response".
Make "dissect_rpc()" static, as it's called only through a heuristic
dissector list.
Use "col_set_str()" to set the COL_PROTOCOL column for RPC protocols;
the string used is from a table provided by the dissector, and is a
string constant.
Don't format the Info column for WSP into a buffer and then format that
buffer into the column with "%s" - "col_add_fstr()" can do the
formatting for you, without having to allocate your own buffer (or run
through the *printf machinery twice).
Don't fetch fields from the WTP packet until you're ready to use them,
so that you don't throw an exception before you even set the Protocol
column or clear the Info column.
Use "pinfo->destport", not "pi.destport", in the Zebra dissector when
checking whether the packet is a request or reply, and do the check by
comparing with "pinfo->match_port" rather than TCP_PORT_ZEBRA (so that
if the dissector is ever registered on another port, it still correctly
determines whether the packet is a request or reply - the Network
Monitor HTTP dissector has port 80 wired into its brain, which is a bit
irritating if you're trying to get it to dissect HTTP proxy traffic on
port 3128 or proxy administration UI traffic on port 3132).
svn path=/trunk/; revision=2931
2001-01-22 08:03:46 +00:00
|
|
|
if (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_clear(pinfo->fd, 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) {
|
|
|
|
if (check_col(pinfo->fd, COL_INFO))
|
2000-11-19 08:54:37 +00:00
|
|
|
col_set_str(pinfo->fd, 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);
|
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_uint_format(clnp_tree, hf_clnp_id, tvb, P_CLNP_PROTO_ID, 1,
|
|
|
|
cnf_proto_id,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Inactive subset");
|
|
|
|
}
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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) {
|
|
|
|
dissect_data(tvb, 0, 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);
|
|
|
|
proto_tree_add_uint(clnp_tree, hf_clnp_id, tvb, P_CLNP_PROTO_ID, 1,
|
|
|
|
cnf_proto_id);
|
|
|
|
proto_tree_add_uint(clnp_tree, hf_clnp_length, tvb, P_CLNP_HDR_LEN, 1,
|
|
|
|
cnf_hdr_len);
|
|
|
|
proto_tree_add_uint(clnp_tree, hf_clnp_version, tvb, P_CLNP_VERS, 1,
|
|
|
|
cnf_vers);
|
|
|
|
cnf_ttl = tvb_get_guint8(tvb, P_CLNP_TTL);
|
|
|
|
proto_tree_add_uint_format(clnp_tree, hf_clnp_ttl, tvb, P_CLNP_TTL, 1,
|
|
|
|
cnf_ttl,
|
2000-12-23 23:06:50 +00:00
|
|
|
"Holding Time : %u (%u.%u secs)",
|
|
|
|
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)) {
|
|
|
|
if (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_add_fstr(pinfo->fd, COL_INFO, "%s NPDU %s", pdu_type_string, flag_string);
|
|
|
|
}
|
|
|
|
|
|
|
|
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 */
|
|
|
|
|
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) {
|
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_uint(clnp_tree, hf_clnp_dest_length, tvb, offset, 1,
|
2000-04-15 22:11:26 +00:00
|
|
|
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
|
|
|
proto_tree_add_bytes_format(clnp_tree, hf_clnp_dest, tvb, offset + 1 , dst_len,
|
|
|
|
dst_addr,
|
2000-04-15 22:11:26 +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));
|
|
|
|
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);
|
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_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,
|
2000-04-15 22:11:26 +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 */
|
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
|
|
|
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) {
|
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,
|
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,
|
2000-04-15 22:11:26 +00:00
|
|
|
"Segment offset : %6u",
|
|
|
|
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,
|
2000-04-15 22:11:26 +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
|
|
|
}
|
|
|
|
|
|
|
|
offset += 6;
|
|
|
|
opt_len -= 6;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tree) {
|
|
|
|
/* To do : decode options */
|
|
|
|
/*
|
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,
|
|
|
|
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 )*/
|
|
|
|
|
|
|
|
dissect_osi_options( 0xff,
|
|
|
|
opt_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
|
|
|
tvb, offset, pinfo, 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
|
|
|
|
|
|
|
/* Set the payload and captured-payload lengths to the minima of (the
|
|
|
|
datagram length plus the length of the headers above it) and the
|
|
|
|
frame lengths. */
|
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 (pinfo->len > len)
|
|
|
|
pinfo->len = len;
|
|
|
|
if (pinfo->captured_len > len)
|
|
|
|
pinfo->captured_len = 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
|
|
|
offset = cnf_hdr_len;
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
/* For now, dissect the payload of segments other than the initial
|
|
|
|
segment as data, rather than handing them off to the transport
|
|
|
|
protocol, just as we do with fragments other than the first
|
|
|
|
fragment in a fragmented IP datagram; in the future, we will
|
|
|
|
probably reassemble fragments for IP, and may reassemble segments
|
|
|
|
for CLNP. */
|
2001-06-08 06:27:16 +00:00
|
|
|
/* If clnp_reassemble is on and this is a segment, then just add the segment
|
|
|
|
* to the hashtable.
|
|
|
|
*/
|
|
|
|
if (clnp_reassemble && (cnf_type & CNF_SEG_OK) &&
|
|
|
|
((cnf_type & CNF_MORE_SEGS) || segment_offset != 0)) {
|
|
|
|
/* We're reassembling, and this is part of a segmented datagram.
|
|
|
|
Add the segment to the hash table if the checksum is ok
|
|
|
|
and the frame isn't truncated. */
|
|
|
|
if (cksum_status != CKSUM_NOT_OK &&
|
|
|
|
(tvb_reported_length(tvb) <= tvb_length(tvb))) {
|
|
|
|
fd_head = fragment_add(tvb, offset, pinfo, du_id, clnp_segment_table,
|
|
|
|
segment_offset, segment_length - cnf_hdr_len,
|
|
|
|
cnf_type & CNF_MORE_SEGS);
|
|
|
|
} else {
|
|
|
|
fd_head=NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fd_head != NULL) {
|
|
|
|
fragment_data *fd;
|
|
|
|
proto_tree *ft=NULL;
|
|
|
|
proto_item *fi=NULL;
|
|
|
|
|
|
|
|
/* OK, we have the complete reassembled payload. */
|
|
|
|
/* show all segments */
|
|
|
|
fi = proto_tree_add_item(clnp_tree, hf_clnp_segments,
|
|
|
|
tvb, 0, 0, FALSE);
|
|
|
|
ft = proto_item_add_subtree(fi, ett_clnp_segments);
|
|
|
|
for (fd = fd_head->next; fd != NULL; fd = fd->next){
|
|
|
|
if (fd->flags & (FD_OVERLAP|FD_OVERLAPCONFLICT
|
|
|
|
|FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) {
|
|
|
|
/* this segment has some flags set, create a subtree
|
|
|
|
* for it and display the flags.
|
|
|
|
*/
|
|
|
|
proto_tree *fet = NULL;
|
|
|
|
proto_item *fei = NULL;
|
|
|
|
int hf;
|
|
|
|
|
|
|
|
if (fd->flags & (FD_OVERLAPCONFLICT
|
|
|
|
|FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) {
|
|
|
|
hf = hf_clnp_segment_error;
|
|
|
|
} else {
|
|
|
|
hf = hf_clnp_segment;
|
|
|
|
}
|
|
|
|
fei = proto_tree_add_none_format(ft, hf,
|
|
|
|
tvb, 0, 0,
|
|
|
|
"Frame:%d payload:%d-%d",
|
|
|
|
fd->frame,
|
|
|
|
fd->offset,
|
|
|
|
fd->offset+fd->len-1
|
|
|
|
);
|
|
|
|
fet = proto_item_add_subtree(fei, ett_clnp_segment);
|
|
|
|
if (fd->flags&FD_OVERLAP) {
|
|
|
|
proto_tree_add_boolean(fet,
|
|
|
|
hf_clnp_segment_overlap, tvb, 0, 0,
|
|
|
|
TRUE);
|
|
|
|
}
|
|
|
|
if (fd->flags&FD_OVERLAPCONFLICT) {
|
|
|
|
proto_tree_add_boolean(fet,
|
|
|
|
hf_clnp_segment_overlap_conflict, tvb, 0, 0,
|
|
|
|
TRUE);
|
|
|
|
}
|
|
|
|
if (fd->flags&FD_MULTIPLETAILS) {
|
|
|
|
proto_tree_add_boolean(fet,
|
|
|
|
hf_clnp_segment_multiple_tails, tvb, 0, 0,
|
|
|
|
TRUE);
|
|
|
|
}
|
|
|
|
if (fd->flags&FD_TOOLONGFRAGMENT) {
|
|
|
|
proto_tree_add_boolean(fet,
|
|
|
|
hf_clnp_segment_too_long_segment, tvb, 0, 0,
|
|
|
|
TRUE);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* nothing of interest for this segment */
|
|
|
|
proto_tree_add_none_format(ft, hf_clnp_segment,
|
|
|
|
tvb, 0, 0,
|
|
|
|
"Frame:%d payload:%d-%d",
|
|
|
|
fd->frame,
|
|
|
|
fd->offset,
|
|
|
|
fd->offset+fd->len-1
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (fd_head->flags & (FD_OVERLAPCONFLICT
|
|
|
|
|FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) {
|
|
|
|
if (check_col(pinfo->fd, COL_INFO)) {
|
|
|
|
col_set_str(pinfo->fd, COL_INFO, "[Illegal segments]");
|
|
|
|
update_col_info = FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate a new tvbuff, referring to the reassembled payload. */
|
|
|
|
next_tvb = tvb_new_real_data(fd_head->data, fd_head->datalen,
|
|
|
|
fd_head->datalen, "Reassembled");
|
|
|
|
|
|
|
|
/* Add the tvbuff to the list of tvbuffs to which the tvbuff we
|
|
|
|
were handed refers, so it'll get cleaned up when that tvbuff
|
|
|
|
is cleaned up. */
|
|
|
|
tvb_set_child_real_data_tvbuff(tvb, next_tvb);
|
|
|
|
|
|
|
|
/* Add the defragmented data to the data source list. */
|
|
|
|
pinfo->fd->data_src = g_slist_append(pinfo->fd->data_src, next_tvb);
|
|
|
|
|
|
|
|
/* It's not fragmented. */
|
|
|
|
pinfo->fragmented = FALSE;
|
|
|
|
|
|
|
|
/* Save the current value of "pi", and adjust certain fields to
|
|
|
|
reflect the new tvbuff. */
|
|
|
|
save_pi = pi;
|
|
|
|
pi.compat_top_tvb = next_tvb;
|
|
|
|
pi.len = tvb_reported_length(next_tvb);
|
|
|
|
pi.captured_len = tvb_length(next_tvb);
|
|
|
|
must_restore_pi = TRUE;
|
|
|
|
} else {
|
|
|
|
/* We don't have the complete reassembled payload. */
|
|
|
|
next_tvb = NULL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* If this is the first segment, dissect its contents, otherwise
|
|
|
|
just show it as a segment.
|
|
|
|
|
|
|
|
XXX - if we eventually don't save the reassembled contents of all
|
|
|
|
segmented datagrams, we may want to always reassemble. */
|
|
|
|
if ((cnf_type & CNF_SEG_OK) && segment_offset != 0) {
|
|
|
|
/* Not the first segment - don't dissect it. */
|
|
|
|
next_tvb = NULL;
|
|
|
|
} else {
|
|
|
|
/* First segment, or not segmented. Dissect what we have here. */
|
|
|
|
|
|
|
|
/* Get a tvbuff for the payload. */
|
|
|
|
next_tvb = tvb_new_subset(tvb, offset, -1, -1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is the first segment, but not the only segment,
|
|
|
|
* tell the next protocol that.
|
|
|
|
*/
|
|
|
|
if ((cnf_type & (CNF_SEG_OK|CNF_MORE_SEGS)) == (CNF_SEG_OK|CNF_MORE_SEGS))
|
|
|
|
pinfo->fragmented = TRUE;
|
|
|
|
else
|
|
|
|
pinfo->fragmented = FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (next_tvb == NULL) {
|
|
|
|
/* Just show this as a segment. */
|
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 (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_add_fstr(pinfo->fd, 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. */
|
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
|
|
|
dissect_data(tvb, offset, pinfo, tree);
|
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? */
|
|
|
|
|
2000-08-06 15:54:42 +00:00
|
|
|
if (nsel == (char)tp_nsap_selector || always_decode_transport) {
|
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(next_tvb, pinfo, tree, FALSE))
|
2000-07-01 08:55:28 +00:00
|
|
|
return; /* yes, it appears to be COTP or CLTP */
|
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-06-08 07:44:36 +00:00
|
|
|
if (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_add_fstr(pinfo->fd, 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) {
|
|
|
|
/* We have payload; dissect it.
|
|
|
|
Make the columns non-writable, so the packet isn't shown
|
|
|
|
in the summary based on what the discarded PDU's contents
|
|
|
|
are. */
|
|
|
|
col_set_writable(pinfo->fd, FALSE);
|
2001-05-27 04:14:53 +00:00
|
|
|
|
|
|
|
/* Also, save the current values of the addresses, and restore
|
|
|
|
them when we're finished dissecting the contained packet, so
|
|
|
|
that the address columns in the summary don't reflect the
|
|
|
|
contained packet, but reflect this packet instead. */
|
|
|
|
save_dl_src = pinfo->dl_src;
|
|
|
|
save_dl_dst = pinfo->dl_dst;
|
|
|
|
save_net_src = pinfo->net_src;
|
|
|
|
save_net_dst = pinfo->net_dst;
|
|
|
|
save_src = pinfo->src;
|
|
|
|
save_dst = pinfo->dst;
|
|
|
|
|
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;
|
|
|
|
|
2001-09-27 10:35:40 +00:00
|
|
|
/* Dissect the contained packet.
|
|
|
|
Catch ReportedBoundsError, and do nothing if we see it,
|
|
|
|
because it's not an error if the contained packet is short;
|
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
|
|
|
there's no guarantee that all of it was included.
|
|
|
|
|
|
|
|
XXX - should catch BoundsError, and re-throw it after cleaning
|
|
|
|
up. */
|
2000-12-23 19:34:46 +00:00
|
|
|
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-09-27 10:35:40 +00:00
|
|
|
TRY {
|
|
|
|
dissect_clnp(next_tvb, pinfo, discpdu_tree);
|
|
|
|
}
|
|
|
|
CATCH(ReportedBoundsError) {
|
|
|
|
; /* do nothing */
|
|
|
|
}
|
|
|
|
ENDTRY;
|
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;
|
|
|
|
|
2001-05-27 04:14:53 +00:00
|
|
|
/* Restore the addresses. */
|
|
|
|
pinfo->dl_src = save_dl_src;
|
|
|
|
pinfo->dl_dst = save_dl_dst;
|
|
|
|
pinfo->net_src = save_net_src;
|
|
|
|
pinfo->net_dst = save_net_dst;
|
|
|
|
pinfo->src = save_src;
|
|
|
|
pinfo->dst = save_dst;
|
2000-12-23 19:34:46 +00:00
|
|
|
}
|
|
|
|
}
|
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;
|
|
|
|
}
|
|
|
|
}
|
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 (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_add_fstr(pinfo->fd, COL_INFO, "%s NPDU %s", pdu_type_string, flag_string);
|
|
|
|
dissect_data(next_tvb, 0, pinfo, tree);
|
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);
|
|
|
|
}
|
2000-04-15 22:11:26 +00:00
|
|
|
|
|
|
|
void proto_register_clnp(void)
|
|
|
|
{
|
|
|
|
static hf_register_info hf[] = {
|
|
|
|
{ &hf_clnp_id,
|
|
|
|
{ "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,
|
|
|
|
{ "Reassembly error", "clnp.segment.error", FT_NONE, BASE_DEC, 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,
|
|
|
|
{ "CLNP Segment", "clnp.segment", FT_NONE, BASE_DEC, 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 }},
|
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));
|
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",
|
|
|
|
"NSAP selector for Transport Protocol (last byte in hexa)",
|
|
|
|
"NSAP selector for Transport Protocol (last byte in hexa)",
|
|
|
|
16, &tp_nsap_selector);
|
|
|
|
prefs_register_bool_preference(clnp_module, "always_decode_transport",
|
|
|
|
"Always try to decode NSDU as transport PDUs",
|
|
|
|
"Always try to decode NSDU as transport PDUs",
|
|
|
|
&always_decode_transport);
|
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
|
|
|
}
|
|
|
|
|
|
|
|
void proto_register_cotp(void)
|
|
|
|
{
|
|
|
|
/* static hf_register_info hf[] = {
|
|
|
|
{ &variable,
|
|
|
|
{ "Name", "cotp.abbreviation", TYPE, VALS_POINTER }},
|
|
|
|
};*/
|
|
|
|
static gint *ett[] = {
|
|
|
|
&ett_cotp,
|
|
|
|
};
|
|
|
|
|
2001-01-03 06:56:03 +00:00
|
|
|
proto_cotp = proto_register_protocol(PROTO_STRING_COTP, "COTP", "cotp");
|
2000-04-15 22:11:26 +00:00
|
|
|
/* proto_register_field_array(proto_cotp, hf, array_length(hf));*/
|
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
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
|
|
|
|
|
|
|
/* subdissector code */
|
|
|
|
register_heur_dissector_list("cotp_is", &cotp_is_heur_subdissector_list);
|
2000-11-19 04:14:26 +00:00
|
|
|
|
2001-01-09 06:32:10 +00:00
|
|
|
/* XXX - what about CLTP? */
|
|
|
|
register_dissector("ositp", dissect_ositp, proto_cotp);
|
2000-04-15 22:11:26 +00:00
|
|
|
}
|
2000-04-17 01:36:31 +00:00
|
|
|
|
2000-07-01 08:55:28 +00:00
|
|
|
void proto_register_cltp(void)
|
|
|
|
{
|
|
|
|
/* static hf_register_info hf[] = {
|
|
|
|
{ &variable,
|
|
|
|
{ "Name", "cltp.abbreviation", TYPE, VALS_POINTER }},
|
|
|
|
};*/
|
|
|
|
static gint *ett[] = {
|
|
|
|
&ett_cltp,
|
|
|
|
};
|
|
|
|
|
2001-01-03 06:56:03 +00:00
|
|
|
proto_cltp = proto_register_protocol(PROTO_STRING_CLTP, "CLTP", "cltp");
|
2000-07-01 08:55:28 +00:00
|
|
|
/* proto_register_field_array(proto_cotp, hf, array_length(hf));*/
|
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
2001-06-08 06:27:16 +00:00
|
|
|
register_init_routine(clnp_reassemble_init);
|
2000-07-01 08:55:28 +00:00
|
|
|
}
|
|
|
|
|
2000-04-17 01:36:31 +00:00
|
|
|
void
|
|
|
|
proto_reg_handoff_clnp(void)
|
|
|
|
{
|
2001-01-09 06:32:10 +00:00
|
|
|
dissector_add("osinl", NLPID_ISO8473_CLNP, dissect_clnp,
|
|
|
|
proto_clnp);
|
|
|
|
dissector_add("osinl", NLPID_NULL, dissect_clnp,
|
|
|
|
proto_clnp); /* Inactive subset */
|
2000-04-17 01:36:31 +00:00
|
|
|
}
|