1999-08-02 02:26:22 +00:00
|
|
|
/* packet-x25.c
|
2003-01-06 02:24:57 +00:00
|
|
|
* Routines for X.25 packet disassembly
|
2002-09-01 14:30:34 +00:00
|
|
|
* Olivier Abad <oabad@noos.fr>
|
1999-08-02 02:26:22 +00:00
|
|
|
*
|
2004-07-18 00:24:25 +00:00
|
|
|
* $Id$
|
1999-08-05 02:26:21 +00:00
|
|
|
*
|
2006-05-21 04:49:01 +00:00
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
1999-08-02 02:26:22 +00:00
|
|
|
* Copyright 1998
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
1999-08-02 02:26:22 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
1999-08-02 02:26:22 +00:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
1999-08-02 02:26:22 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
2012-06-28 22:56:06 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
1999-08-02 02:26:22 +00:00
|
|
|
*/
|
|
|
|
|
2012-09-20 02:03:38 +00:00
|
|
|
#include "config.h"
|
1999-08-02 02:26:22 +00:00
|
|
|
|
|
|
|
#include <string.h>
|
2012-05-15 19:23:35 +00:00
|
|
|
|
|
|
|
#include <glib.h>
|
|
|
|
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/packet.h>
|
2012-08-03 01:58:12 +00:00
|
|
|
#include <epan/ax25_pids.h>
|
2012-05-15 19:23:35 +00:00
|
|
|
#include <epan/llcsaps.h>
|
2002-11-08 01:00:07 +00:00
|
|
|
#include <epan/circuit.h>
|
2005-02-09 23:38:00 +00:00
|
|
|
#include <epan/reassemble.h>
|
2004-09-27 22:55:15 +00:00
|
|
|
#include <epan/prefs.h>
|
2005-08-19 23:28:23 +00:00
|
|
|
#include <epan/emem.h>
|
2005-09-17 00:02:31 +00:00
|
|
|
#include <epan/nlpid.h>
|
|
|
|
#include <epan/x264_prt_id.h>
|
2012-07-24 11:47:23 +00:00
|
|
|
#include <epan/lapd_sapi.h>
|
1999-08-02 02:26:22 +00:00
|
|
|
|
2002-04-09 08:15:04 +00:00
|
|
|
/*
|
|
|
|
* Direction of packet.
|
|
|
|
*/
|
|
|
|
typedef enum {
|
|
|
|
X25_FROM_DCE, /* DCE->DTE */
|
|
|
|
X25_FROM_DTE, /* DTE->DCE */
|
|
|
|
X25_UNKNOWN /* direction unknown */
|
|
|
|
} x25_dir_t;
|
1999-08-04 06:11:17 +00:00
|
|
|
|
2003-01-08 08:43:09 +00:00
|
|
|
/*
|
|
|
|
* 0 for data packets, 1 for non-data packets.
|
|
|
|
*/
|
|
|
|
#define X25_NONDATA_BIT 0x01
|
|
|
|
|
1999-08-02 02:26:22 +00:00
|
|
|
#define X25_CALL_REQUEST 0x0B
|
|
|
|
#define X25_CALL_ACCEPTED 0x0F
|
|
|
|
#define X25_CLEAR_REQUEST 0x13
|
|
|
|
#define X25_CLEAR_CONFIRMATION 0x17
|
|
|
|
#define X25_INTERRUPT 0x23
|
|
|
|
#define X25_INTERRUPT_CONFIRMATION 0x27
|
|
|
|
#define X25_RESET_REQUEST 0x1B
|
|
|
|
#define X25_RESET_CONFIRMATION 0x1F
|
|
|
|
#define X25_RESTART_REQUEST 0xFB
|
|
|
|
#define X25_RESTART_CONFIRMATION 0xFF
|
|
|
|
#define X25_REGISTRATION_REQUEST 0xF3
|
|
|
|
#define X25_REGISTRATION_CONFIRMATION 0xF7
|
|
|
|
#define X25_DIAGNOSTIC 0xF1
|
|
|
|
#define X25_RR 0x01
|
|
|
|
#define X25_RNR 0x05
|
|
|
|
#define X25_REJ 0x09
|
|
|
|
#define X25_DATA 0x00
|
|
|
|
|
2003-01-08 08:43:09 +00:00
|
|
|
#define PACKET_IS_DATA(type) (!(type & X25_NONDATA_BIT))
|
|
|
|
#define PACKET_TYPE_FC(type) (type & 0x1F)
|
|
|
|
|
2003-03-05 01:12:11 +00:00
|
|
|
#define X25_MBIT_MOD8 0x10
|
|
|
|
#define X25_MBIT_MOD128 0x01
|
|
|
|
|
|
|
|
#define X25_ABIT 0x8000
|
|
|
|
|
|
|
|
#define X25_QBIT 0x8000
|
|
|
|
#define X25_DBIT 0x4000
|
|
|
|
|
1999-08-02 02:26:22 +00:00
|
|
|
#define X25_FAC_CLASS_MASK 0xC0
|
|
|
|
|
|
|
|
#define X25_FAC_CLASS_A 0x00
|
|
|
|
#define X25_FAC_CLASS_B 0x40
|
|
|
|
#define X25_FAC_CLASS_C 0x80
|
|
|
|
#define X25_FAC_CLASS_D 0xC0
|
|
|
|
|
|
|
|
#define X25_FAC_COMP_MARK 0x00
|
|
|
|
#define X25_FAC_REVERSE 0x01
|
|
|
|
#define X25_FAC_THROUGHPUT 0x02
|
|
|
|
#define X25_FAC_CUG 0x03
|
2008-04-12 13:41:53 +00:00
|
|
|
#define X25_FAC_CHARGING_INFO 0x04
|
1999-08-02 02:26:22 +00:00
|
|
|
#define X25_FAC_CALLED_MODIF 0x08
|
1999-08-04 06:11:17 +00:00
|
|
|
#define X25_FAC_CUG_OUTGOING_ACC 0x09
|
1999-08-02 02:26:22 +00:00
|
|
|
#define X25_FAC_THROUGHPUT_MIN 0x0A
|
|
|
|
#define X25_FAC_EXPRESS_DATA 0x0B
|
1999-08-04 06:11:17 +00:00
|
|
|
#define X25_FAC_BILATERAL_CUG 0x41
|
1999-08-02 02:26:22 +00:00
|
|
|
#define X25_FAC_PACKET_SIZE 0x42
|
|
|
|
#define X25_FAC_WINDOW_SIZE 0x43
|
1999-08-04 06:11:17 +00:00
|
|
|
#define X25_FAC_RPOA_SELECTION 0x44
|
2008-04-12 13:41:53 +00:00
|
|
|
#define X25_FAC_CUG_EXT 0x47
|
|
|
|
#define X25_FAC_CUG_OUTGOING_ACC_EXT 0x48
|
1999-08-02 02:26:22 +00:00
|
|
|
#define X25_FAC_TRANSIT_DELAY 0x49
|
2008-04-12 13:41:53 +00:00
|
|
|
#define X25_FAC_CALL_DURATION 0xC1
|
|
|
|
#define X25_FAC_SEGMENT_COUNT 0xC2
|
1999-08-02 02:26:22 +00:00
|
|
|
#define X25_FAC_CALL_TRANSFER 0xC3
|
2008-04-12 13:41:53 +00:00
|
|
|
#define X25_FAC_RPOA_SELECTION_EXT 0xC4
|
|
|
|
#define X25_FAC_MONETARY_UNIT 0xC5
|
|
|
|
#define X25_FAC_NUI 0xC6
|
1999-08-02 02:26:22 +00:00
|
|
|
#define X25_FAC_CALLED_ADDR_EXT 0xC9
|
|
|
|
#define X25_FAC_ETE_TRANSIT_DELAY 0xCA
|
1999-12-09 13:51:08 +00:00
|
|
|
#define X25_FAC_CALLING_ADDR_EXT 0xCB
|
1999-08-04 06:11:17 +00:00
|
|
|
#define X25_FAC_CALL_DEFLECT 0xD1
|
1999-12-09 13:51:08 +00:00
|
|
|
#define X25_FAC_PRIORITY 0xD2
|
1999-08-02 02:26:22 +00:00
|
|
|
|
1999-11-16 11:44:20 +00:00
|
|
|
static int proto_x25 = -1;
|
2012-09-27 04:05:01 +00:00
|
|
|
static int hf_x25_facility = -1;
|
|
|
|
static int hf_x25_facility_class = -1;
|
|
|
|
static int hf_x25_facility_classA = -1;
|
|
|
|
static int hf_x25_facility_classA_comp_mark = -1;
|
|
|
|
static int hf_x25_facility_classA_reverse = -1;
|
|
|
|
static int hf_x25_facility_classA_charging_info = -1;
|
|
|
|
static int hf_x25_reverse_charging = -1;
|
|
|
|
static int hf_x25_charging_info = -1;
|
|
|
|
static int hf_x25_throughput_called_dte = -1;
|
|
|
|
static int hf_x25_throughput_calling_dte = -1;
|
|
|
|
static int hf_x25_facility_classA_cug = -1;
|
|
|
|
static int hf_x25_facility_classA_called_motif = -1;
|
|
|
|
static int hf_x25_facility_classA_cug_outgoing_acc = -1;
|
|
|
|
static int hf_x25_facility_classA_throughput_min = -1;
|
|
|
|
static int hf_x25_facility_classA_express_data = -1;
|
|
|
|
static int hf_x25_facility_classA_unknown = -1;
|
|
|
|
static int hf_x25_facility_classB = -1;
|
|
|
|
static int hf_x25_facility_classB_bilateral_cug = -1;
|
|
|
|
static int hf_x25_facility_packet_size_called_dte = -1;
|
|
|
|
static int hf_x25_facility_packet_size_calling_dte = -1;
|
|
|
|
static int hf_x25_facility_data_network_id_code = -1;
|
|
|
|
static int hf_x25_facility_cug_ext = -1;
|
|
|
|
static int hf_x25_facility_cug_outgoing_acc_ext = -1;
|
|
|
|
static int hf_x25_facility_transit_delay = -1;
|
|
|
|
static int hf_x25_facility_classB_unknown = -1;
|
|
|
|
static int hf_x25_facility_classC = -1;
|
|
|
|
static int hf_x25_facility_classC_unknown = -1;
|
|
|
|
static int hf_x25_facility_classD = -1;
|
2001-01-03 23:30:50 +00:00
|
|
|
static int hf_x25_gfi = -1;
|
|
|
|
static int hf_x25_abit = -1;
|
1999-11-16 11:44:20 +00:00
|
|
|
static int hf_x25_qbit = -1;
|
|
|
|
static int hf_x25_dbit = -1;
|
|
|
|
static int hf_x25_mod = -1;
|
|
|
|
static int hf_x25_lcn = -1;
|
|
|
|
static int hf_x25_type = -1;
|
2003-01-08 08:43:09 +00:00
|
|
|
static int hf_x25_type_fc_mod8 = -1;
|
|
|
|
static int hf_x25_type_data = -1;
|
2012-09-27 04:05:01 +00:00
|
|
|
static int hf_x25_diagnostic = -1;
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
static int hf_x25_p_r_mod8 = -1;
|
|
|
|
static int hf_x25_p_r_mod128 = -1;
|
|
|
|
static int hf_x25_mbit_mod8 = -1;
|
|
|
|
static int hf_x25_mbit_mod128 = -1;
|
|
|
|
static int hf_x25_p_s_mod8 = -1;
|
|
|
|
static int hf_x25_p_s_mod128 = -1;
|
2012-09-27 04:05:01 +00:00
|
|
|
static int hf_x25_window_size_called_dte = -1;
|
|
|
|
static int hf_x25_window_size_calling_dte = -1;
|
|
|
|
static int hf_x25_dte_address_length = -1;
|
|
|
|
static int hf_x25_dce_address_length = -1;
|
|
|
|
static int hf_x25_calling_address_length = -1;
|
|
|
|
static int hf_x25_called_address_length = -1;
|
|
|
|
|
1999-11-16 11:44:20 +00:00
|
|
|
|
|
|
|
static gint ett_x25 = -1;
|
2001-01-03 23:30:50 +00:00
|
|
|
static gint ett_x25_gfi = -1;
|
1999-12-09 13:51:08 +00:00
|
|
|
static gint ett_x25_fac = -1;
|
2012-09-27 04:05:01 +00:00
|
|
|
static gint ett_x25_facility = -1;
|
1999-12-12 12:59:01 +00:00
|
|
|
static gint ett_x25_fac_unknown = -1;
|
|
|
|
static gint ett_x25_fac_mark = -1;
|
|
|
|
static gint ett_x25_fac_reverse = -1;
|
2008-04-12 13:41:53 +00:00
|
|
|
static gint ett_x25_fac_charging_info = -1;
|
1999-12-12 12:59:01 +00:00
|
|
|
static gint ett_x25_fac_throughput = -1;
|
|
|
|
static gint ett_x25_fac_cug = -1;
|
|
|
|
static gint ett_x25_fac_called_modif = -1;
|
|
|
|
static gint ett_x25_fac_cug_outgoing_acc = -1;
|
|
|
|
static gint ett_x25_fac_throughput_min = -1;
|
|
|
|
static gint ett_x25_fac_express_data = -1;
|
|
|
|
static gint ett_x25_fac_bilateral_cug = -1;
|
|
|
|
static gint ett_x25_fac_packet_size = -1;
|
|
|
|
static gint ett_x25_fac_window_size = -1;
|
|
|
|
static gint ett_x25_fac_rpoa_selection = -1;
|
2008-04-12 13:41:53 +00:00
|
|
|
static gint ett_x25_fac_cug_ext = -1;
|
|
|
|
static gint ett_x25_fac_cug_outgoing_acc_ext = -1;
|
1999-12-12 12:59:01 +00:00
|
|
|
static gint ett_x25_fac_transit_delay = -1;
|
2008-04-12 13:41:53 +00:00
|
|
|
static gint ett_x25_fac_call_duration = -1;
|
|
|
|
static gint ett_x25_fac_segment_count = -1;
|
1999-12-12 12:59:01 +00:00
|
|
|
static gint ett_x25_fac_call_transfer = -1;
|
2008-04-12 13:41:53 +00:00
|
|
|
static gint ett_x25_fac_rpoa_selection_ext = -1;
|
|
|
|
static gint ett_x25_fac_monetary_unit = -1;
|
|
|
|
static gint ett_x25_fac_nui = -1;
|
1999-12-12 12:59:01 +00:00
|
|
|
static gint ett_x25_fac_called_addr_ext = -1;
|
|
|
|
static gint ett_x25_fac_ete_transit_delay = -1;
|
|
|
|
static gint ett_x25_fac_calling_addr_ext = -1;
|
|
|
|
static gint ett_x25_fac_call_deflect = -1;
|
|
|
|
static gint ett_x25_fac_priority = -1;
|
2001-12-02 00:07:46 +00:00
|
|
|
static gint ett_x25_user_data = -1;
|
1999-10-18 01:51:34 +00:00
|
|
|
|
2003-03-04 19:50:23 +00:00
|
|
|
static gint ett_x25_segment = -1;
|
|
|
|
static gint ett_x25_segments = -1;
|
|
|
|
static gint hf_x25_segments = -1;
|
|
|
|
static gint hf_x25_segment = -1;
|
|
|
|
static gint hf_x25_segment_overlap = -1;
|
|
|
|
static gint hf_x25_segment_overlap_conflict = -1;
|
|
|
|
static gint hf_x25_segment_multiple_tails = -1;
|
|
|
|
static gint hf_x25_segment_too_long_segment = -1;
|
|
|
|
static gint hf_x25_segment_error = -1;
|
2011-01-30 21:01:07 +00:00
|
|
|
static gint hf_x25_segment_count = -1;
|
2010-02-02 16:01:52 +00:00
|
|
|
static gint hf_x25_reassembled_length = -1;
|
2012-04-28 17:34:23 +00:00
|
|
|
static gint hf_x25_fast_select = -1;
|
|
|
|
static gint hf_x25_icrd = -1;
|
2012-09-27 04:05:01 +00:00
|
|
|
static gint hf_x25_reg_confirm_cause = -1;
|
|
|
|
static gint hf_x25_reg_confirm_diagnostic = -1;
|
2003-03-04 19:50:23 +00:00
|
|
|
|
1999-10-18 01:51:34 +00:00
|
|
|
static const value_string vals_modulo[] = {
|
|
|
|
{ 1, "8" },
|
|
|
|
{ 2, "128" },
|
|
|
|
{ 0, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string vals_x25_type[] = {
|
|
|
|
{ X25_CALL_REQUEST, "Call" },
|
|
|
|
{ X25_CALL_ACCEPTED, "Call Accepted" },
|
|
|
|
{ X25_CLEAR_REQUEST, "Clear" },
|
|
|
|
{ X25_CLEAR_CONFIRMATION, "Clear Confirmation" },
|
|
|
|
{ X25_INTERRUPT, "Interrupt" },
|
|
|
|
{ X25_INTERRUPT_CONFIRMATION, "Interrupt Confirmation" },
|
|
|
|
{ X25_RESET_REQUEST, "Reset" },
|
|
|
|
{ X25_RESET_CONFIRMATION, "Reset Confirmation" },
|
|
|
|
{ X25_RESTART_REQUEST, "Restart" },
|
|
|
|
{ X25_RESTART_CONFIRMATION, "Restart Confirmation" },
|
|
|
|
{ X25_REGISTRATION_REQUEST, "Registration" },
|
|
|
|
{ X25_REGISTRATION_CONFIRMATION, "Registration Confirmation" },
|
|
|
|
{ X25_DIAGNOSTIC, "Diagnostic" },
|
|
|
|
{ X25_RR, "RR" },
|
|
|
|
{ X25_RNR, "RNR" },
|
|
|
|
{ X25_REJ, "REJ" },
|
2003-01-08 08:43:09 +00:00
|
|
|
{ X25_DATA, "Data" },
|
1999-10-18 01:51:34 +00:00
|
|
|
{ 0, NULL}
|
|
|
|
};
|
1999-08-02 02:26:22 +00:00
|
|
|
|
2003-01-08 08:43:09 +00:00
|
|
|
static struct true_false_string m_bit_tfs = {
|
|
|
|
"More data follows",
|
|
|
|
"End of data"
|
|
|
|
};
|
|
|
|
|
2012-04-28 17:34:23 +00:00
|
|
|
static const value_string x25_fast_select_vals[] = {
|
|
|
|
{ 0, "Not requested" },
|
|
|
|
{ 1, "Not requested" },
|
|
|
|
{ 2, "No restriction on response" },
|
|
|
|
{ 3, "Restriction on response" },
|
|
|
|
{ 0, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string x25_icrd_vals[] = {
|
|
|
|
{ 0, "Status not selected" },
|
|
|
|
{ 1, "Prevention requested" },
|
|
|
|
{ 2, "Allowance requested" },
|
|
|
|
{ 3, "Not allowed" },
|
|
|
|
{ 0, NULL}
|
|
|
|
};
|
|
|
|
|
2012-09-27 04:05:01 +00:00
|
|
|
static const value_string x25_clear_diag_vals[] = {
|
|
|
|
{ 0, "No additional information" },
|
|
|
|
{ 1, "Invalid P(S)" },
|
|
|
|
{ 2, "Invalid P(R)" },
|
|
|
|
{ 16, "Packet type invalid" },
|
|
|
|
{ 17, "Packet type invalid for state r1" },
|
|
|
|
{ 18, "Packet type invalid for state r2" },
|
|
|
|
{ 19, "Packet type invalid for state r3" },
|
|
|
|
{ 20, "Packet type invalid for state p1" },
|
|
|
|
{ 21, "Packet type invalid for state p2" },
|
|
|
|
{ 22, "Packet type invalid for state p3" },
|
|
|
|
{ 23, "Packet type invalid for state p4" },
|
|
|
|
{ 24, "Packet type invalid for state p5" },
|
|
|
|
{ 25, "Packet type invalid for state p6" },
|
|
|
|
{ 26, "Packet type invalid for state p7" },
|
|
|
|
{ 27, "Packet type invalid for state d1" },
|
|
|
|
{ 28, "Packet type invalid for state d2" },
|
|
|
|
{ 29, "Packet type invalid for state d3" },
|
|
|
|
{ 32, "Packet not allowed" },
|
|
|
|
{ 33, "Unidentifiable packet" },
|
|
|
|
{ 34, "Call on one-way logical channel" },
|
|
|
|
{ 35, "Invalid packet type on a PVC" },
|
|
|
|
{ 36, "Packet on unassigned LC" },
|
|
|
|
{ 37, "Reject not subscribed to" },
|
|
|
|
{ 38, "Packet too short" },
|
|
|
|
{ 39, "Packet too long" },
|
|
|
|
{ 40, "Invalid general format identifier" },
|
|
|
|
{ 41, "Restart/registration packet with nonzero bits" },
|
|
|
|
{ 42, "Packet type not compatible with facility" },
|
|
|
|
{ 43, "Unauthorised interrupt confirmation" },
|
|
|
|
{ 44, "Unauthorised interrupt" },
|
|
|
|
{ 45, "Unauthorised reject" },
|
|
|
|
{ 48, "Time expired" },
|
|
|
|
{ 49, "Time expired for incoming call" },
|
|
|
|
{ 50, "Time expired for clear indication" },
|
|
|
|
{ 51, "Time expired for reset indication" },
|
|
|
|
{ 52, "Time expired for restart indication" },
|
|
|
|
{ 53, "Time expired for call deflection" },
|
|
|
|
{ 64, "Call set-up/clearing or registration pb." },
|
|
|
|
{ 65, "Facility/registration code not allowed" },
|
|
|
|
{ 66, "Facility parameter not allowed" },
|
|
|
|
{ 67, "Invalid called DTE address" },
|
|
|
|
{ 68, "Invalid calling DTE address" },
|
|
|
|
{ 69, "Invalid facility/registration length" },
|
|
|
|
{ 70, "Incoming call barred" },
|
|
|
|
{ 71, "No logical channel available" },
|
|
|
|
{ 72, "Call collision" },
|
|
|
|
{ 73, "Duplicate facility requested" },
|
|
|
|
{ 74, "Non zero address length" },
|
|
|
|
{ 75, "Non zero facility length" },
|
|
|
|
{ 76, "Facility not provided when expected" },
|
|
|
|
{ 77, "Invalid CCITT-specified DTE facility" },
|
|
|
|
{ 78, "Max. nb of call redir/defl. exceeded" },
|
|
|
|
{ 80, "Miscellaneous" },
|
|
|
|
{ 81, "Improper cause code from DTE" },
|
|
|
|
{ 82, "Not aligned octet" },
|
|
|
|
{ 83, "Inconsistent Q bit setting" },
|
|
|
|
{ 84, "NUI problem" },
|
|
|
|
{ 112, "International problem" },
|
|
|
|
{ 113, "Remote network problem" },
|
|
|
|
{ 114, "International protocol problem" },
|
|
|
|
{ 115, "International link out of order" },
|
|
|
|
{ 116, "International link busy" },
|
|
|
|
{ 117, "Transit network facility problem" },
|
|
|
|
{ 118, "Remote network facility problem" },
|
|
|
|
{ 119, "International routing problem" },
|
|
|
|
{ 120, "Temporary routing problem" },
|
|
|
|
{ 121, "Unknown called DNIC" },
|
|
|
|
{ 122, "Maintenance action" },
|
|
|
|
{ 144, "Timer expired or retransmission count surpassed" },
|
|
|
|
{ 145, "Timer expired or retransmission count surpassed for INTERRUPT" },
|
|
|
|
{ 146, "Timer expired or retransmission count surpassed for DATA packet transmission" },
|
|
|
|
{ 147, "Timer expired or retransmission count surpassed for REJECT" },
|
|
|
|
{ 160, "DTE-specific signals" },
|
|
|
|
{ 161, "DTE operational" },
|
|
|
|
{ 162, "DTE not operational" },
|
|
|
|
{ 163, "DTE resource constraint" },
|
|
|
|
{ 164, "Fast select not subscribed" },
|
|
|
|
{ 165, "Invalid partially full DATA packet" },
|
|
|
|
{ 166, "D-bit procedure not supported" },
|
|
|
|
{ 167, "Registration/Cancellation confirmed" },
|
|
|
|
{ 224, "OSI network service problem" },
|
|
|
|
{ 225, "Disconnection (transient condition)" },
|
|
|
|
{ 226, "Disconnection (permanent condition)" },
|
|
|
|
{ 227, "Connection rejection - reason unspecified (transient condition)" },
|
|
|
|
{ 228, "Connection rejection - reason unspecified (permanent condition)" },
|
|
|
|
{ 229, "Connection rejection - quality of service not available (transient condition)" },
|
|
|
|
{ 230, "Connection rejection - quality of service not available (permanent condition)" },
|
|
|
|
{ 231, "Connection rejection - NSAP unreachable (transient condition)" },
|
|
|
|
{ 232, "Connection rejection - NSAP unreachable (permanent condition)" },
|
|
|
|
{ 233, "reset - reason unspecified" },
|
|
|
|
{ 234, "reset - congestion" },
|
|
|
|
{ 235, "Connection rejection - NSAP address unknown (permanent condition)" },
|
|
|
|
{ 240, "Higher layer initiated" },
|
|
|
|
{ 241, "Disconnection - normal" },
|
|
|
|
{ 242, "Disconnection - abnormal" },
|
|
|
|
{ 243, "Disconnection - incompatible information in user data" },
|
|
|
|
{ 244, "Connection rejection - reason unspecified (transient condition)" },
|
|
|
|
{ 245, "Connection rejection - reason unspecified (permanent condition)" },
|
|
|
|
{ 246, "Connection rejection - quality of service not available (transient condition)" },
|
|
|
|
{ 247, "Connection rejection - quality of service not available (permanent condition)" },
|
|
|
|
{ 248, "Connection rejection - incompatible information in user data" },
|
|
|
|
{ 249, "Connection rejection - unrecognizable protocol identifier in user data" },
|
|
|
|
{ 250, "Reset - user resynchronization" },
|
|
|
|
{ 0, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
value_string_ext x25_clear_diag_vals_ext = VALUE_STRING_EXT_INIT(x25_clear_diag_vals);
|
|
|
|
|
|
|
|
static const value_string x25_registration_code_vals[] = {
|
|
|
|
{ 0x03, "Invalid facility request" },
|
|
|
|
{ 0x05, "Network congestion" },
|
|
|
|
{ 0x13, "Local procedure error" },
|
|
|
|
{ 0x7F, "Registration/cancellation confirmed" },
|
|
|
|
{ 0, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string x25_facilities_class_vals[] = {
|
|
|
|
{ X25_FAC_CLASS_A>>6, "A" },
|
|
|
|
{ X25_FAC_CLASS_B>>6, "B" },
|
|
|
|
{ X25_FAC_CLASS_C>>6, "C" },
|
|
|
|
{ X25_FAC_CLASS_D>>6, "D" },
|
|
|
|
{ 0, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string x25_facilities_classA_vals[] = {
|
|
|
|
{ X25_FAC_COMP_MARK, "Marker" },
|
|
|
|
{ X25_FAC_REVERSE, "Reverse charging / Fast select" },
|
|
|
|
{ X25_FAC_CHARGING_INFO, "Charging information" },
|
|
|
|
{ X25_FAC_THROUGHPUT, "Throughput class negotiation" },
|
|
|
|
{ X25_FAC_CUG, "Closed user group selection" },
|
|
|
|
{ X25_FAC_CALLED_MODIF, "Called address modified" },
|
|
|
|
{ X25_FAC_CUG_OUTGOING_ACC, "Closed user group with outgoing access selection" },
|
|
|
|
{ X25_FAC_THROUGHPUT_MIN, "Minimum throughput class" },
|
|
|
|
{ X25_FAC_EXPRESS_DATA, "Negotiation of express data" },
|
|
|
|
{ 0, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string x25_facilities_classA_comp_mark_vals[] = {
|
|
|
|
{ 0x00, "Network complementary services - calling DTE" },
|
|
|
|
{ 0x0F, "DTE complementary services" },
|
|
|
|
{ 0xFF, "Network complementary services - called DTE" },
|
|
|
|
{ 0, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string x25_facilities_classA_throughput_vals[] = {
|
|
|
|
{ 3, "75 bps" },
|
|
|
|
{ 4, "150 bps" },
|
|
|
|
{ 5, "300 bps" },
|
|
|
|
{ 6, "600 bps" },
|
|
|
|
{ 7, "1200 bps" },
|
|
|
|
{ 8, "2400 bps" },
|
|
|
|
{ 9, "4800 bps" },
|
|
|
|
{ 10, "9600 bps" },
|
|
|
|
{ 11, "19200 bps" },
|
|
|
|
{ 12, "48000 bps" },
|
|
|
|
{ 13, "64000 bps" },
|
|
|
|
{ 0, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string x25_facilities_classB_vals[] = {
|
|
|
|
{ X25_FAC_BILATERAL_CUG, "Bilateral closed user group selection" },
|
|
|
|
{ X25_FAC_PACKET_SIZE, "Packet size" },
|
|
|
|
{ X25_FAC_WINDOW_SIZE, "Window size" },
|
|
|
|
{ X25_FAC_RPOA_SELECTION, "RPOA selection" },
|
|
|
|
{ X25_FAC_CUG_EXT, "Extended closed user group selection" },
|
|
|
|
{ X25_FAC_CUG_OUTGOING_ACC_EXT, "Extended closed user group with outgoing access selection" },
|
|
|
|
{ X25_FAC_TRANSIT_DELAY, "Transit delay selection and indication" },
|
|
|
|
{ 0, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string x25_facilities_classB_packet_size_vals[] = {
|
|
|
|
{ 0x04, "16" },
|
|
|
|
{ 0x05, "32" },
|
|
|
|
{ 0x06, "64" },
|
|
|
|
{ 0x07, "128" },
|
|
|
|
{ 0x08, "256" },
|
|
|
|
{ 0x09, "512" },
|
|
|
|
{ 0x0A, "1024" },
|
|
|
|
{ 0x0B, "2048" },
|
|
|
|
{ 0x0C, "4096" },
|
|
|
|
{ 0, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string x25_facilities_classC_vals[] = {
|
|
|
|
{ 0, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string x25_facilities_classD_vals[] = {
|
|
|
|
{ X25_FAC_CALL_DURATION, "Call duration" },
|
|
|
|
{ X25_FAC_SEGMENT_COUNT, "Segment count" },
|
|
|
|
{ X25_FAC_CALL_TRANSFER, "Call redirection or deflection notification" },
|
|
|
|
{ X25_FAC_RPOA_SELECTION_EXT, "Extended RPOA selection" },
|
|
|
|
{ X25_FAC_CALLING_ADDR_EXT, "Calling address extension" },
|
|
|
|
{ X25_FAC_MONETARY_UNIT, "Monetary Unit" },
|
|
|
|
{ X25_FAC_NUI, "Network User Identification selection" },
|
|
|
|
{ X25_FAC_CALLED_ADDR_EXT, "Called address extension" },
|
|
|
|
{ X25_FAC_ETE_TRANSIT_DELAY, "End to end transit delay" },
|
|
|
|
{ X25_FAC_CALL_DEFLECT, "Call deflection selection" },
|
|
|
|
{ X25_FAC_PRIORITY, "Priority" },
|
|
|
|
{ 0, NULL}
|
|
|
|
};
|
|
|
|
|
2012-04-28 17:34:23 +00:00
|
|
|
static struct true_false_string x25_reverse_charging_val = {
|
|
|
|
"Requested",
|
|
|
|
"Not requested"
|
|
|
|
};
|
|
|
|
|
2003-03-04 19:50:23 +00:00
|
|
|
static const fragment_items x25_frag_items = {
|
|
|
|
&ett_x25_segment,
|
|
|
|
&ett_x25_segments,
|
|
|
|
&hf_x25_segments,
|
|
|
|
&hf_x25_segment,
|
|
|
|
&hf_x25_segment_overlap,
|
|
|
|
&hf_x25_segment_overlap_conflict,
|
|
|
|
&hf_x25_segment_multiple_tails,
|
|
|
|
&hf_x25_segment_too_long_segment,
|
|
|
|
&hf_x25_segment_error,
|
2011-01-30 21:01:07 +00:00
|
|
|
&hf_x25_segment_count,
|
2003-04-20 11:36:16 +00:00
|
|
|
NULL,
|
2010-02-02 16:01:52 +00:00
|
|
|
&hf_x25_reassembled_length,
|
2012-09-07 02:09:59 +00:00
|
|
|
/* Reassembled data field */
|
|
|
|
NULL,
|
2003-03-04 19:50:23 +00:00
|
|
|
"segments"
|
|
|
|
};
|
|
|
|
|
2001-12-03 05:07:18 +00:00
|
|
|
static dissector_handle_t ip_handle;
|
2003-01-06 02:24:57 +00:00
|
|
|
static dissector_handle_t clnp_handle;
|
2000-11-19 04:14:26 +00:00
|
|
|
static dissector_handle_t ositp_handle;
|
2001-11-15 21:11:01 +00:00
|
|
|
static dissector_handle_t qllc_handle;
|
2001-11-25 22:19:25 +00:00
|
|
|
static dissector_handle_t data_handle;
|
2001-11-15 21:11:01 +00:00
|
|
|
|
|
|
|
/* Preferences */
|
2003-01-06 02:24:57 +00:00
|
|
|
static gboolean payload_is_qllc_sna = FALSE;
|
2008-03-16 10:19:51 +00:00
|
|
|
static gboolean call_request_nodata_is_cotp = FALSE;
|
|
|
|
static gboolean payload_check_data = FALSE;
|
2005-09-28 22:15:38 +00:00
|
|
|
static gboolean reassemble_x25 = TRUE;
|
2003-03-04 19:50:23 +00:00
|
|
|
|
|
|
|
/* Reassembly of X.25 */
|
|
|
|
|
|
|
|
static GHashTable *x25_segment_table = NULL;
|
|
|
|
static GHashTable *x25_reassembled_table = NULL;
|
2000-11-19 04:14:26 +00:00
|
|
|
|
2001-12-02 00:07:46 +00:00
|
|
|
static dissector_table_t x25_subdissector_table;
|
2001-12-05 08:43:26 +00:00
|
|
|
static heur_dissector_list_t x25_heur_subdissector_list;
|
2001-12-02 00:07:46 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
static void
|
2002-11-08 01:00:07 +00:00
|
|
|
x25_hash_add_proto_start(guint16 vc, guint32 frame, dissector_handle_t dissect)
|
1999-08-02 02:26:22 +00:00
|
|
|
{
|
2002-11-08 01:00:07 +00:00
|
|
|
circuit_t *circuit;
|
1999-08-02 02:26:22 +00:00
|
|
|
|
2002-11-08 01:00:07 +00:00
|
|
|
/*
|
|
|
|
* Is there already a circuit with this VC number?
|
|
|
|
*/
|
|
|
|
circuit = find_circuit(CT_X25, vc, frame);
|
|
|
|
if (circuit != NULL) {
|
|
|
|
/*
|
|
|
|
* Yes - close it, as we're creating a new one.
|
|
|
|
*/
|
|
|
|
close_circuit(circuit, frame - 1);
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
|
2002-11-08 01:00:07 +00:00
|
|
|
/*
|
|
|
|
* Set up a new circuit.
|
|
|
|
*/
|
|
|
|
circuit = circuit_new(CT_X25, vc, frame);
|
1999-08-02 02:26:22 +00:00
|
|
|
|
2002-11-08 01:00:07 +00:00
|
|
|
/*
|
|
|
|
* Set its dissector.
|
|
|
|
*/
|
|
|
|
circuit_set_dissector(circuit, dissect);
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
static void
|
2002-11-08 01:00:07 +00:00
|
|
|
x25_hash_add_proto_end(guint16 vc, guint32 frame)
|
1999-08-02 02:26:22 +00:00
|
|
|
{
|
2002-11-08 01:00:07 +00:00
|
|
|
circuit_t *circuit;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to find the circuit.
|
|
|
|
*/
|
|
|
|
circuit = find_circuit(CT_X25, vc, frame);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we succeeded, close it.
|
|
|
|
*/
|
|
|
|
if (circuit != NULL)
|
|
|
|
close_circuit(circuit, frame);
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
|
2005-08-05 13:10:58 +00:00
|
|
|
static const char *clear_code(unsigned char code)
|
1999-08-02 02:26:22 +00:00
|
|
|
{
|
2012-09-27 04:05:01 +00:00
|
|
|
if (code == 0x00 || (code & 0x80) == 0x80)
|
|
|
|
return "DTE Originated";
|
1999-08-02 02:26:22 +00:00
|
|
|
|
2012-09-27 04:05:01 +00:00
|
|
|
switch(code)
|
|
|
|
{
|
|
|
|
case 0x01:
|
|
|
|
return "Number Busy";
|
|
|
|
case 0x03:
|
|
|
|
return "Invalid Facility Requested";
|
|
|
|
case 0x05:
|
|
|
|
return "Network Congestion";
|
|
|
|
case 0x09:
|
|
|
|
return "Out Of Order";
|
|
|
|
case 0x0B:
|
|
|
|
return "Access Barred";
|
|
|
|
case 0x0D:
|
|
|
|
return "Not Obtainable";
|
|
|
|
case 0x11:
|
|
|
|
return "Remote Procedure Error";
|
|
|
|
case 0x13:
|
|
|
|
return "Local Procedure Error";
|
|
|
|
case 0x15:
|
|
|
|
return "RPOA Out Of Order";
|
|
|
|
case 0x19:
|
|
|
|
return "Reverse Charging Acceptance Not Subscribed";
|
|
|
|
case 0x21:
|
|
|
|
return "Incompatible Destination";
|
|
|
|
case 0x29:
|
|
|
|
return "Fast Select Acceptance Not Subscribed";
|
|
|
|
case 0x39:
|
|
|
|
return "Destination Absent";
|
|
|
|
}
|
|
|
|
|
|
|
|
return ep_strdup_printf("Unknown %02X", code);
|
1999-08-04 06:11:17 +00:00
|
|
|
}
|
|
|
|
|
2005-08-05 13:10:58 +00:00
|
|
|
static const char *reset_code(unsigned char code)
|
1999-08-02 02:26:22 +00:00
|
|
|
{
|
2012-09-27 04:05:01 +00:00
|
|
|
if (code == 0x00 || (code & 0x80) == 0x80)
|
|
|
|
return "DTE Originated";
|
|
|
|
|
|
|
|
switch(code)
|
|
|
|
{
|
|
|
|
case 0x01:
|
|
|
|
return "Out of order";
|
|
|
|
case 0x03:
|
|
|
|
return "Remote Procedure Error";
|
|
|
|
case 0x05:
|
|
|
|
return "Local Procedure Error";
|
|
|
|
case 0x07:
|
|
|
|
return "Network Congestion";
|
|
|
|
case 0x09:
|
|
|
|
return "Remote DTE operational";
|
|
|
|
case 0x0F:
|
|
|
|
return "Network operational";
|
|
|
|
case 0x11:
|
|
|
|
return "Incompatible Destination";
|
|
|
|
case 0x1D:
|
|
|
|
return "Network out of order";
|
|
|
|
}
|
|
|
|
|
|
|
|
return ep_strdup_printf("Unknown %02X", code);
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
|
2005-08-05 13:10:58 +00:00
|
|
|
static const char *restart_code(unsigned char code)
|
1999-08-02 02:26:22 +00:00
|
|
|
{
|
2012-09-27 04:05:01 +00:00
|
|
|
if (code == 0x00 || (code & 0x80) == 0x80)
|
|
|
|
return "DTE Originated";
|
1999-08-04 06:11:17 +00:00
|
|
|
|
2012-09-27 04:05:01 +00:00
|
|
|
switch(code)
|
|
|
|
{
|
|
|
|
case 0x01:
|
|
|
|
return "Local Procedure Error";
|
|
|
|
case 0x03:
|
|
|
|
return "Network Congestion";
|
|
|
|
case 0x07:
|
|
|
|
return "Network Operational";
|
|
|
|
case 0x7F:
|
|
|
|
return "Registration/cancellation confirmed";
|
|
|
|
}
|
|
|
|
|
|
|
|
return ep_strdup_printf("Unknown %02X", code);
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
static void
|
2000-05-25 21:34:58 +00:00
|
|
|
dump_facilities(proto_tree *tree, int *offset, tvbuff_t *tvb)
|
1999-08-02 02:26:22 +00:00
|
|
|
{
|
2012-09-27 04:05:01 +00:00
|
|
|
guint8 fac, byte1, byte2, byte3;
|
|
|
|
guint32 len; /* facilities length */
|
|
|
|
proto_item *ti = NULL;
|
|
|
|
proto_tree *fac_tree = NULL, *fac_tree2 = NULL;
|
|
|
|
proto_tree *fac_subtree;
|
|
|
|
|
|
|
|
|
|
|
|
len = tvb_get_guint8(tvb, *offset);
|
|
|
|
if (len && tree) {
|
|
|
|
ti = proto_tree_add_text(tree, tvb, *offset, len + 1,
|
|
|
|
"Facilities");
|
|
|
|
fac_tree2 = proto_item_add_subtree(ti, ett_x25_fac);
|
|
|
|
proto_tree_add_text(fac_tree2, tvb, *offset, 1,
|
|
|
|
"Facilities length: %d", len);
|
|
|
|
}
|
|
|
|
(*offset)++;
|
|
|
|
|
|
|
|
while (len > 0) {
|
|
|
|
ti = proto_tree_add_item(fac_tree2, hf_x25_facility, tvb, *offset, 1, ENC_NA);
|
|
|
|
fac_tree = proto_item_add_subtree(ti, ett_x25_facility);
|
|
|
|
proto_tree_add_item(fac_tree, hf_x25_facility_class, tvb, *offset, 1, ENC_NA);
|
|
|
|
fac = tvb_get_guint8(tvb, *offset);
|
|
|
|
switch(fac & X25_FAC_CLASS_MASK) {
|
|
|
|
case X25_FAC_CLASS_A:
|
|
|
|
ti = proto_tree_add_item(fac_tree, hf_x25_facility_classA, tvb, *offset, 1, ENC_NA);
|
|
|
|
if (fac_tree) {
|
|
|
|
switch (fac) {
|
|
|
|
case X25_FAC_COMP_MARK:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_mark);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_classA_comp_mark, tvb, *offset+1, 1, ENC_NA);
|
|
|
|
break;
|
|
|
|
case X25_FAC_REVERSE:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_reverse);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_classA_reverse, tvb, *offset+1, 1, ENC_NA);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_fast_select, tvb, *offset+1, 1, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_icrd, tvb, *offset+1, 1, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_reverse_charging, tvb, *offset+1, 1, ENC_BIG_ENDIAN);
|
|
|
|
break;
|
|
|
|
case X25_FAC_CHARGING_INFO:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_charging_info);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_classA_charging_info, tvb, *offset+1, 1, ENC_NA);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_charging_info, tvb, *offset+1, 1, ENC_NA);
|
|
|
|
break;
|
|
|
|
case X25_FAC_THROUGHPUT:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_throughput);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_throughput_called_dte, tvb, *offset+1, 1, ENC_NA);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_throughput_calling_dte, tvb, *offset+1, 1, ENC_NA);
|
|
|
|
break;
|
|
|
|
case X25_FAC_CUG:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_cug);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_classA_cug, tvb, *offset+1, 1, ENC_NA);
|
|
|
|
break;
|
|
|
|
case X25_FAC_CALLED_MODIF:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_called_modif);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_classA_called_motif, tvb, *offset+1, 1, ENC_NA);
|
|
|
|
break;
|
|
|
|
case X25_FAC_CUG_OUTGOING_ACC:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_cug_outgoing_acc);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_classA_cug_outgoing_acc, tvb, *offset+1, 1, ENC_NA);
|
|
|
|
break;
|
|
|
|
case X25_FAC_THROUGHPUT_MIN:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_throughput_min);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_classA_throughput_min, tvb, *offset+1, 1, ENC_NA);
|
|
|
|
break;
|
|
|
|
case X25_FAC_EXPRESS_DATA:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_express_data);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_classA_express_data, tvb, *offset+1, 1, ENC_NA);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_unknown);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_classA_unknown, tvb, *offset+1, 1, ENC_NA);
|
|
|
|
break;
|
|
|
|
}
|
2008-04-12 13:41:53 +00:00
|
|
|
}
|
2012-09-27 04:05:01 +00:00
|
|
|
(*offset) += 2;
|
|
|
|
len -= 2;
|
|
|
|
break;
|
|
|
|
case X25_FAC_CLASS_B:
|
|
|
|
ti = proto_tree_add_item(fac_tree, hf_x25_facility_classB, tvb, *offset, 1, ENC_NA);
|
|
|
|
if (fac_tree) {
|
|
|
|
switch (fac) {
|
|
|
|
case X25_FAC_BILATERAL_CUG:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_bilateral_cug);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_classB_bilateral_cug, tvb, *offset+1, 2, ENC_BIG_ENDIAN);
|
|
|
|
break;
|
|
|
|
case X25_FAC_PACKET_SIZE:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_packet_size);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_packet_size_called_dte, tvb, *offset+1, 1, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_packet_size_calling_dte, tvb, *offset+2, 1, ENC_BIG_ENDIAN);
|
|
|
|
break;
|
|
|
|
case X25_FAC_WINDOW_SIZE:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_window_size);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_window_size_called_dte, tvb, *offset+1, 1, ENC_NA);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_window_size_calling_dte, tvb, *offset+2, 1, ENC_NA);
|
|
|
|
break;
|
|
|
|
case X25_FAC_RPOA_SELECTION:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_rpoa_selection);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_data_network_id_code, tvb, *offset+1, 2, ENC_BIG_ENDIAN);
|
|
|
|
break;
|
|
|
|
case X25_FAC_CUG_EXT:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_cug_ext);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_cug_ext, tvb, *offset+1, 2, ENC_BIG_ENDIAN);
|
|
|
|
break;
|
|
|
|
case X25_FAC_CUG_OUTGOING_ACC_EXT:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_cug_outgoing_acc_ext);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_cug_outgoing_acc_ext, tvb, *offset+1, 2, ENC_BIG_ENDIAN);
|
|
|
|
break;
|
|
|
|
case X25_FAC_TRANSIT_DELAY:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_transit_delay);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_transit_delay, tvb, *offset+1, 2, ENC_BIG_ENDIAN);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_unknown);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_classB_unknown, tvb, *offset+1, 2, ENC_BIG_ENDIAN);
|
|
|
|
break;
|
|
|
|
}
|
1999-12-12 12:59:01 +00:00
|
|
|
}
|
2012-09-27 04:05:01 +00:00
|
|
|
(*offset) += 3;
|
|
|
|
len -= 3;
|
|
|
|
break;
|
|
|
|
case X25_FAC_CLASS_C:
|
|
|
|
ti = proto_tree_add_item(fac_tree, hf_x25_facility_classC, tvb, *offset, 1, ENC_NA);
|
|
|
|
if (fac_tree) {
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_unknown);
|
|
|
|
proto_tree_add_item(fac_subtree, hf_x25_facility_classC_unknown, tvb, *offset+1, 2, ENC_BIG_ENDIAN);
|
1999-12-12 12:59:01 +00:00
|
|
|
}
|
2012-09-27 04:05:01 +00:00
|
|
|
(*offset) += 4;
|
|
|
|
len -= 4;
|
|
|
|
break;
|
|
|
|
case X25_FAC_CLASS_D:
|
|
|
|
ti = proto_tree_add_item(fac_tree, hf_x25_facility_classD, tvb, *offset, 1, ENC_NA);
|
|
|
|
if (fac_tree) {
|
|
|
|
switch (fac) {
|
|
|
|
case X25_FAC_CALL_DURATION:
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_call_duration);
|
|
|
|
byte1 = tvb_get_guint8(tvb, *offset+1);
|
|
|
|
if ((byte1 < 4) || (byte1 % 4)) {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Bogus length : %d", byte1);
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Length : %u", byte1);
|
|
|
|
}
|
|
|
|
for (i = 0; (i<byte1); i+=4) {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2+i, 4,
|
|
|
|
"Call duration : %u Day(s) %02X:%02X:%02X Hour(s)",
|
|
|
|
tvb_get_guint8(tvb, *offset+2+i),
|
|
|
|
tvb_get_guint8(tvb, *offset+3+i),
|
|
|
|
tvb_get_guint8(tvb, *offset+4+i),
|
|
|
|
tvb_get_guint8(tvb, *offset+5+i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case X25_FAC_SEGMENT_COUNT:
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_segment_count);
|
|
|
|
byte1 = tvb_get_guint8(tvb, *offset+1);
|
|
|
|
if ((byte1 < 8) || (byte1 % 8)) {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Bogus length : %d", byte1);
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Length : %u", byte1);
|
|
|
|
}
|
|
|
|
for (i = 0; (i<byte1); i+=8) {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2+i, 4,
|
|
|
|
"Segments sent to DTE : %02X%02X%02X%02X",
|
|
|
|
tvb_get_guint8(tvb, *offset+2+i),
|
|
|
|
tvb_get_guint8(tvb, *offset+3+i),
|
|
|
|
tvb_get_guint8(tvb, *offset+4+i),
|
|
|
|
tvb_get_guint8(tvb, *offset+5+i));
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+6+i, 4,
|
|
|
|
"Segments received from DTE : %02X%02X%02X%02X",
|
|
|
|
tvb_get_guint8(tvb, *offset+6+i),
|
|
|
|
tvb_get_guint8(tvb, *offset+7+i),
|
|
|
|
tvb_get_guint8(tvb, *offset+8+i),
|
|
|
|
tvb_get_guint8(tvb, *offset+9+i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case X25_FAC_CALL_TRANSFER:
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
char *tmpbuf;
|
|
|
|
|
|
|
|
tmpbuf=ep_alloc(258);
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_call_transfer);
|
|
|
|
byte1 = tvb_get_guint8(tvb, *offset+1);
|
|
|
|
if (byte1 < 2) {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Bogus length : %d", byte1);
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Length : %u", byte1);
|
|
|
|
}
|
|
|
|
byte2 = tvb_get_guint8(tvb, *offset+2);
|
|
|
|
if ((byte2 & 0xC0) == 0xC0) {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2, 1,
|
|
|
|
"Reason : call deflection by the originally called DTE address");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
switch (byte2) {
|
|
|
|
case 0x01:
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2, 1,
|
|
|
|
"Reason : originally called DTE busy");
|
|
|
|
break;
|
|
|
|
case 0x07:
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2, 1,
|
|
|
|
"Reason : call dist. within a hunt group");
|
|
|
|
break;
|
|
|
|
case 0x09:
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2, 1,
|
|
|
|
"Reason : originally called DTE out of order");
|
|
|
|
break;
|
|
|
|
case 0x0F:
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2, 1,
|
|
|
|
"Reason : systematic call redirection");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2, 1,
|
|
|
|
"Reason : unknown");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
byte3 = tvb_get_guint8(tvb, *offset+3);
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+3, 1,
|
|
|
|
"Number of semi-octets in DTE address : %u",
|
|
|
|
byte3);
|
|
|
|
for (i = 0; (i<byte3)&&(i<256); i++) {
|
|
|
|
if (i % 2 == 0) {
|
|
|
|
tmpbuf[i] = ((tvb_get_guint8(tvb, *offset+4+i/2) >> 4)
|
|
|
|
& 0x0F) + '0';
|
|
|
|
/* if > 9, convert to the right hexadecimal letter */
|
|
|
|
if (tmpbuf[i] > '9') tmpbuf[i] += ('A' - '0' - 10);
|
|
|
|
} else {
|
|
|
|
tmpbuf[i] = (tvb_get_guint8(tvb, *offset+4+i/2)
|
|
|
|
& 0x0F) + '0';
|
|
|
|
/* if > 9, convert to the right hexadecimal letter */
|
|
|
|
if (tmpbuf[i] > '9') tmpbuf[i] += ('A' - '0' - 10);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
tmpbuf[i] = 0;
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+4, byte1 - 2,
|
|
|
|
"DTE address : %s", tmpbuf);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case X25_FAC_RPOA_SELECTION_EXT:
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
fac_subtree = proto_item_add_subtree(ti,
|
|
|
|
ett_x25_fac_rpoa_selection_ext);
|
|
|
|
byte1 = tvb_get_guint8(tvb, *offset+1);
|
|
|
|
if ((byte1 < 2) || (byte1 % 2)) {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Bogus length : %d", byte1);
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Length : %u", byte1);
|
|
|
|
}
|
|
|
|
for (i = 0; (i<byte1); i+=2) {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2+i, 2,
|
|
|
|
"Data network identification code : %04X",
|
|
|
|
tvb_get_ntohs(tvb, *offset+2+i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case X25_FAC_CALLING_ADDR_EXT:
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
char *tmpbuf;
|
|
|
|
|
|
|
|
tmpbuf=ep_alloc(258);
|
|
|
|
fac_subtree = proto_item_add_subtree(ti,
|
|
|
|
ett_x25_fac_calling_addr_ext);
|
|
|
|
byte1 = tvb_get_guint8(tvb, *offset+1);
|
|
|
|
if (byte1 < 1) {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Bogus length : %d", byte1);
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Length : %u", byte1);
|
|
|
|
}
|
|
|
|
byte2 = tvb_get_guint8(tvb, *offset+2) & 0x3F;
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2, 1,
|
|
|
|
"Number of semi-octets in DTE address : %u", byte2);
|
|
|
|
for (i = 0; (i<byte2)&&(i<256) ; i++) {
|
|
|
|
if (i % 2 == 0) {
|
|
|
|
tmpbuf[i] = ((tvb_get_guint8(tvb, *offset+3+i/2) >> 4)
|
|
|
|
& 0x0F) + '0';
|
|
|
|
/* if > 9, convert to the right hexadecimal letter */
|
|
|
|
if (tmpbuf[i] > '9') tmpbuf[i] += ('A' - '0' - 10);
|
|
|
|
} else {
|
|
|
|
tmpbuf[i] = (tvb_get_guint8(tvb, *offset+3+i/2)
|
|
|
|
& 0x0F) + '0';
|
|
|
|
/* if > 9, convert to the right hexadecimal letter */
|
|
|
|
if (tmpbuf[i] > '9') tmpbuf[i] += ('A' - '0' - 10);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
tmpbuf[i] = 0;
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+3, byte1 - 1,
|
|
|
|
"DTE address : %s", tmpbuf);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case X25_FAC_MONETARY_UNIT:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_monetary_unit);
|
|
|
|
byte1 = tvb_get_guint8(tvb, *offset+1);
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Length : %u", byte1);
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2, byte1, "Value");
|
|
|
|
break;
|
|
|
|
case X25_FAC_NUI:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_nui);
|
|
|
|
byte1 = tvb_get_guint8(tvb, *offset+1);
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Length : %u", byte1);
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2, byte1, "NUI");
|
|
|
|
break;
|
|
|
|
case X25_FAC_CALLED_ADDR_EXT:
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
char *tmpbuf;
|
|
|
|
|
|
|
|
tmpbuf=ep_alloc(258);
|
|
|
|
fac_subtree = proto_item_add_subtree(ti,
|
|
|
|
ett_x25_fac_called_addr_ext);
|
|
|
|
byte1 = tvb_get_guint8(tvb, *offset+1);
|
|
|
|
if (byte1 < 1) {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Bogus length : %d", byte1);
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Length : %u", byte1);
|
|
|
|
}
|
|
|
|
byte2 = tvb_get_guint8(tvb, *offset+2) & 0x3F;
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2, 1,
|
|
|
|
"Number of semi-octets in DTE address : %u", byte2);
|
|
|
|
for (i = 0; (i<byte2)&&(i<256) ; i++) {
|
|
|
|
if (i % 2 == 0) {
|
|
|
|
tmpbuf[i] = ((tvb_get_guint8(tvb, *offset+3+i/2) >> 4)
|
|
|
|
& 0x0F) + '0';
|
|
|
|
/* if > 9, convert to the right hexadecimal letter */
|
|
|
|
if (tmpbuf[i] > '9') tmpbuf[i] += ('A' - '0' - 10);
|
|
|
|
} else {
|
|
|
|
tmpbuf[i] = (tvb_get_guint8(tvb, *offset+3+i/2)
|
|
|
|
& 0x0F) + '0';
|
|
|
|
/* if > 9, convert to the right hexadecimal letter */
|
|
|
|
if (tmpbuf[i] > '9') tmpbuf[i] += ('A' - '0' - 10);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
tmpbuf[i] = 0;
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+3, byte1 - 1,
|
|
|
|
"DTE address : %s", tmpbuf);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case X25_FAC_ETE_TRANSIT_DELAY:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_ete_transit_delay);
|
|
|
|
byte1 = tvb_get_guint8(tvb, *offset+1);
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Length : %u", byte1);
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2, byte1, "Value");
|
|
|
|
break;
|
|
|
|
case X25_FAC_CALL_DEFLECT:
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
char *tmpbuf;
|
|
|
|
|
|
|
|
tmpbuf=ep_alloc(258);
|
|
|
|
fac_subtree = proto_item_add_subtree(ti,
|
|
|
|
ett_x25_fac_call_deflect);
|
|
|
|
byte1 = tvb_get_guint8(tvb, *offset+1);
|
|
|
|
if (byte1 < 2) {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Bogus length : %d", byte1);
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Length : %u", byte1);
|
|
|
|
}
|
|
|
|
byte2 = tvb_get_guint8(tvb, *offset+2);
|
|
|
|
if ((byte2 & 0xC0) == 0xC0)
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2, 1,
|
|
|
|
"Reason : call DTE originated");
|
|
|
|
else
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2, 1,
|
|
|
|
"Reason : unknown");
|
|
|
|
byte3 = tvb_get_guint8(tvb, *offset+3);
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+3, 1,
|
|
|
|
"Number of semi-octets in the alternative DTE address : %u",
|
|
|
|
byte3);
|
|
|
|
for (i = 0; (i<byte3)&&(i<256) ; i++) {
|
|
|
|
if (i % 2 == 0) {
|
|
|
|
tmpbuf[i] = ((tvb_get_guint8(tvb, *offset+4+i/2) >> 4)
|
|
|
|
& 0x0F) + '0';
|
|
|
|
/* if > 9, convert to the right hexadecimal letter */
|
|
|
|
if (tmpbuf[i] > '9') tmpbuf[i] += ('A' - '0' - 10);
|
|
|
|
} else {
|
|
|
|
tmpbuf[i] = (tvb_get_guint8(tvb, *offset+4+i/2)
|
|
|
|
& 0x0F) + '0';
|
|
|
|
/* if > 9, convert to the right hexadecimal letter */
|
|
|
|
if (tmpbuf[i] > '9') tmpbuf[i] += ('A' - '0' - 10);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
tmpbuf[i] = 0;
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+4, byte1 - 2,
|
|
|
|
"Alternative DTE address : %s", tmpbuf);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case X25_FAC_PRIORITY:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_priority);
|
|
|
|
byte1 = tvb_get_guint8(tvb, *offset+1);
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Length : %u", byte1);
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2, byte1, "Value");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
fac_subtree = proto_item_add_subtree(ti, ett_x25_fac_unknown);
|
|
|
|
byte1 = tvb_get_guint8(tvb, *offset+1);
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+1, 1,
|
|
|
|
"Length : %u", byte1);
|
|
|
|
proto_tree_add_text(fac_subtree, tvb, *offset+2, byte1, "Value");
|
|
|
|
}
|
1999-12-12 12:59:01 +00:00
|
|
|
}
|
2012-09-27 04:05:01 +00:00
|
|
|
byte1 = tvb_get_guint8(tvb, *offset+1);
|
|
|
|
(*offset) += byte1+2;
|
|
|
|
len -= byte1+2;
|
|
|
|
break;
|
1999-12-12 12:59:01 +00:00
|
|
|
}
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
static void
|
2000-05-25 21:34:58 +00:00
|
|
|
x25_ntoa(proto_tree *tree, int *offset, tvbuff_t *tvb,
|
2002-05-09 11:18:47 +00:00
|
|
|
packet_info *pinfo, gboolean is_registration)
|
1999-08-02 02:26:22 +00:00
|
|
|
{
|
1999-08-04 06:11:17 +00:00
|
|
|
int len1, len2;
|
1999-08-02 02:26:22 +00:00
|
|
|
int i;
|
2005-08-19 23:28:23 +00:00
|
|
|
char *addr1, *addr2;
|
1999-08-04 06:11:17 +00:00
|
|
|
char *first, *second;
|
2000-05-25 21:34:58 +00:00
|
|
|
guint8 byte;
|
|
|
|
int localoffset;
|
1999-08-02 02:26:22 +00:00
|
|
|
|
2005-08-19 23:28:23 +00:00
|
|
|
addr1=ep_alloc(16);
|
|
|
|
addr2=ep_alloc(16);
|
|
|
|
|
2000-05-25 21:34:58 +00:00
|
|
|
byte = tvb_get_guint8(tvb, *offset);
|
2002-05-09 11:18:47 +00:00
|
|
|
len1 = (byte >> 0) & 0x0F;
|
|
|
|
len2 = (byte >> 4) & 0x0F;
|
2002-05-09 05:49:28 +00:00
|
|
|
|
1999-08-02 02:26:22 +00:00
|
|
|
if (tree) {
|
2012-09-27 04:05:01 +00:00
|
|
|
if (is_registration) {
|
|
|
|
proto_tree_add_item(tree, hf_x25_dte_address_length, tvb, *offset, 1, ENC_NA);
|
|
|
|
proto_tree_add_item(tree, hf_x25_dce_address_length, tvb, *offset, 1, ENC_NA);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
proto_tree_add_item(tree, hf_x25_calling_address_length, tvb, *offset, 1, ENC_NA);
|
|
|
|
proto_tree_add_item(tree, hf_x25_called_address_length, tvb, *offset, 1, ENC_NA);
|
|
|
|
}
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
(*offset)++;
|
|
|
|
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset = *offset;
|
|
|
|
byte = tvb_get_guint8(tvb, localoffset);
|
1999-08-02 02:26:22 +00:00
|
|
|
|
1999-08-04 06:11:17 +00:00
|
|
|
first=addr1;
|
|
|
|
second=addr2;
|
|
|
|
for (i = 0; i < (len1 + len2); i++) {
|
|
|
|
if (i < len1) {
|
1999-08-02 02:26:22 +00:00
|
|
|
if (i % 2 != 0) {
|
2000-05-25 21:34:58 +00:00
|
|
|
*first++ = ((byte >> 0) & 0x0F) + '0';
|
|
|
|
localoffset++;
|
|
|
|
byte = tvb_get_guint8(tvb, localoffset);
|
1999-08-02 02:26:22 +00:00
|
|
|
} else {
|
2000-05-25 21:34:58 +00:00
|
|
|
*first++ = ((byte >> 4) & 0x0F) + '0';
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (i % 2 != 0) {
|
2000-05-25 21:34:58 +00:00
|
|
|
*second++ = ((byte >> 0) & 0x0F) + '0';
|
|
|
|
localoffset++;
|
|
|
|
byte = tvb_get_guint8(tvb, localoffset);
|
1999-08-02 02:26:22 +00:00
|
|
|
} else {
|
2000-05-25 21:34:58 +00:00
|
|
|
*second++ = ((byte >> 4) & 0x0F) + '0';
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-08-04 06:11:17 +00:00
|
|
|
*first = '\0';
|
|
|
|
*second = '\0';
|
1999-08-02 02:26:22 +00:00
|
|
|
|
1999-08-04 06:11:17 +00:00
|
|
|
if (len1) {
|
2010-01-13 20:32:01 +00:00
|
|
|
col_add_str(pinfo->cinfo, COL_RES_DL_DST, addr1);
|
1999-08-02 02:26:22 +00:00
|
|
|
if (tree)
|
2000-05-25 21:34:58 +00:00
|
|
|
proto_tree_add_text(tree, tvb, *offset,
|
1999-08-04 06:11:17 +00:00
|
|
|
(len1 + 1) / 2,
|
2002-05-09 11:18:47 +00:00
|
|
|
is_registration ?
|
|
|
|
"DCE address : %s" :
|
|
|
|
"Called address : %s",
|
1999-08-04 06:11:17 +00:00
|
|
|
addr1);
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
1999-08-04 06:11:17 +00:00
|
|
|
if (len2) {
|
2010-01-13 20:32:01 +00:00
|
|
|
col_add_str(pinfo->cinfo, COL_RES_DL_SRC, addr2);
|
2002-05-09 11:18:47 +00:00
|
|
|
if (tree)
|
|
|
|
proto_tree_add_text(tree, tvb, *offset + len1/2,
|
|
|
|
(len2+1)/2+(len1%2+(len2+1)%2)/2,
|
|
|
|
is_registration ?
|
|
|
|
"DTE address : %s" :
|
|
|
|
"Calling address : %s",
|
|
|
|
addr2);
|
|
|
|
}
|
|
|
|
(*offset) += ((len1 + len2 + 1) / 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
x25_toa(proto_tree *tree, int *offset, tvbuff_t *tvb,
|
|
|
|
packet_info *pinfo)
|
|
|
|
{
|
|
|
|
int len1, len2;
|
|
|
|
int i;
|
2005-08-19 23:28:23 +00:00
|
|
|
char *addr1, *addr2;
|
2002-05-09 11:18:47 +00:00
|
|
|
char *first, *second;
|
|
|
|
guint8 byte;
|
|
|
|
int localoffset;
|
|
|
|
|
2005-08-19 23:28:23 +00:00
|
|
|
addr1=ep_alloc(256);
|
|
|
|
addr2=ep_alloc(256);
|
|
|
|
|
2002-05-09 11:18:47 +00:00
|
|
|
len1 = tvb_get_guint8(tvb, *offset);
|
|
|
|
if (tree) {
|
|
|
|
proto_tree_add_text(tree, tvb, *offset, 1,
|
|
|
|
"Called address length : %u",
|
|
|
|
len1);
|
|
|
|
}
|
|
|
|
(*offset)++;
|
|
|
|
|
|
|
|
len2 = tvb_get_guint8(tvb, *offset);
|
|
|
|
if (tree) {
|
|
|
|
proto_tree_add_text(tree, tvb, *offset, 1,
|
|
|
|
"Calling address length : %u",
|
|
|
|
len2);
|
|
|
|
}
|
|
|
|
(*offset)++;
|
|
|
|
|
|
|
|
localoffset = *offset;
|
|
|
|
byte = tvb_get_guint8(tvb, localoffset);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX - the first two half-octets of the address are the TOA and
|
|
|
|
* NPI; process them as such and, if the TOA says an address is
|
|
|
|
* an alternative address, process it correctly (i.e., not as a
|
|
|
|
* sequence of half-octets containing digit values).
|
|
|
|
*/
|
|
|
|
first=addr1;
|
|
|
|
second=addr2;
|
|
|
|
for (i = 0; i < (len1 + len2); i++) {
|
|
|
|
if (i < len1) {
|
|
|
|
if (i % 2 != 0) {
|
|
|
|
*first++ = ((byte >> 0) & 0x0F) + '0';
|
|
|
|
localoffset++;
|
|
|
|
byte = tvb_get_guint8(tvb, localoffset);
|
|
|
|
} else {
|
|
|
|
*first++ = ((byte >> 4) & 0x0F) + '0';
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (i % 2 != 0) {
|
|
|
|
*second++ = ((byte >> 0) & 0x0F) + '0';
|
|
|
|
localoffset++;
|
|
|
|
byte = tvb_get_guint8(tvb, localoffset);
|
|
|
|
} else {
|
|
|
|
*second++ = ((byte >> 4) & 0x0F) + '0';
|
|
|
|
}
|
1999-12-12 12:59:01 +00:00
|
|
|
}
|
2002-05-09 11:18:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
*first = '\0';
|
|
|
|
*second = '\0';
|
|
|
|
|
|
|
|
if (len1) {
|
2010-01-13 20:32:01 +00:00
|
|
|
col_add_str(pinfo->cinfo, COL_RES_DL_DST, addr1);
|
2002-05-09 11:18:47 +00:00
|
|
|
if (tree)
|
|
|
|
proto_tree_add_text(tree, tvb, *offset,
|
|
|
|
(len1 + 1) / 2,
|
|
|
|
"Called address : %s",
|
|
|
|
addr1);
|
|
|
|
}
|
|
|
|
if (len2) {
|
2010-01-13 20:32:01 +00:00
|
|
|
col_add_str(pinfo->cinfo, COL_RES_DL_SRC, addr2);
|
1999-08-02 02:26:22 +00:00
|
|
|
if (tree)
|
2000-05-25 21:34:58 +00:00
|
|
|
proto_tree_add_text(tree, tvb, *offset + len1/2,
|
1999-08-04 06:11:17 +00:00
|
|
|
(len2+1)/2+(len1%2+(len2+1)%2)/2,
|
2002-05-09 11:18:47 +00:00
|
|
|
"Calling address : %s",
|
1999-08-04 06:11:17 +00:00
|
|
|
addr2);
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
1999-08-04 06:11:17 +00:00
|
|
|
(*offset) += ((len1 + len2 + 1) / 2);
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
static int
|
2000-05-25 21:34:58 +00:00
|
|
|
get_x25_pkt_len(tvbuff_t *tvb)
|
1999-08-02 02:26:22 +00:00
|
|
|
{
|
2001-07-05 22:10:09 +00:00
|
|
|
guint length, called_len, calling_len, dte_len, dce_len;
|
2000-05-25 21:34:58 +00:00
|
|
|
guint8 byte2, bytex;
|
1999-08-02 02:26:22 +00:00
|
|
|
|
2000-05-25 21:34:58 +00:00
|
|
|
byte2 = tvb_get_guint8(tvb, 2);
|
|
|
|
switch (byte2)
|
1999-08-02 02:26:22 +00:00
|
|
|
{
|
|
|
|
case X25_CALL_REQUEST:
|
2000-05-25 21:34:58 +00:00
|
|
|
bytex = tvb_get_guint8(tvb, 3);
|
|
|
|
called_len = (bytex >> 0) & 0x0F;
|
|
|
|
calling_len = (bytex >> 4) & 0x0F;
|
|
|
|
length = 4 + (called_len + calling_len + 1) / 2; /* addr */
|
2000-05-29 22:35:11 +00:00
|
|
|
if (length < tvb_reported_length(tvb))
|
2000-05-25 21:34:58 +00:00
|
|
|
length += (1 + tvb_get_guint8(tvb, length)); /* facilities */
|
|
|
|
|
2000-05-29 22:35:11 +00:00
|
|
|
return MIN(tvb_reported_length(tvb),length);
|
1999-08-02 02:26:22 +00:00
|
|
|
|
|
|
|
case X25_CALL_ACCEPTED:
|
2001-07-18 15:49:29 +00:00
|
|
|
/* The calling/called address length byte (following the packet type)
|
|
|
|
* is not mandatory, so we must check the packet length before trying
|
|
|
|
* to read it */
|
|
|
|
if (tvb_reported_length(tvb) == 3)
|
|
|
|
return(3);
|
2000-05-25 21:34:58 +00:00
|
|
|
bytex = tvb_get_guint8(tvb, 3);
|
|
|
|
called_len = (bytex >> 0) & 0x0F;
|
|
|
|
calling_len = (bytex >> 4) & 0x0F;
|
|
|
|
length = 4 + (called_len + calling_len + 1) / 2; /* addr */
|
2000-05-29 22:35:11 +00:00
|
|
|
if (length < tvb_reported_length(tvb))
|
2000-05-25 21:34:58 +00:00
|
|
|
length += (1 + tvb_get_guint8(tvb, length)); /* facilities */
|
|
|
|
|
2000-05-29 22:35:11 +00:00
|
|
|
return MIN(tvb_reported_length(tvb),length);
|
1999-08-02 02:26:22 +00:00
|
|
|
|
|
|
|
case X25_CLEAR_REQUEST:
|
1999-09-12 18:37:01 +00:00
|
|
|
case X25_RESET_REQUEST:
|
|
|
|
case X25_RESTART_REQUEST:
|
2000-05-29 22:35:11 +00:00
|
|
|
return MIN(tvb_reported_length(tvb),5);
|
1999-08-02 02:26:22 +00:00
|
|
|
|
|
|
|
case X25_DIAGNOSTIC:
|
2000-05-29 22:35:11 +00:00
|
|
|
return MIN(tvb_reported_length(tvb),4);
|
1999-08-02 02:26:22 +00:00
|
|
|
|
1999-09-12 18:37:01 +00:00
|
|
|
case X25_CLEAR_CONFIRMATION:
|
1999-08-02 02:26:22 +00:00
|
|
|
case X25_INTERRUPT:
|
|
|
|
case X25_INTERRUPT_CONFIRMATION:
|
|
|
|
case X25_RESET_CONFIRMATION:
|
|
|
|
case X25_RESTART_CONFIRMATION:
|
2000-05-29 22:35:11 +00:00
|
|
|
return MIN(tvb_reported_length(tvb),3);
|
1999-08-02 02:26:22 +00:00
|
|
|
|
|
|
|
case X25_REGISTRATION_REQUEST:
|
2000-05-25 21:34:58 +00:00
|
|
|
bytex = tvb_get_guint8(tvb, 3);
|
|
|
|
dce_len = (bytex >> 0) & 0x0F;
|
|
|
|
dte_len = (bytex >> 4) & 0x0F;
|
|
|
|
length = 4 + (dte_len + dce_len + 1) / 2; /* addr */
|
2000-05-29 22:35:11 +00:00
|
|
|
if (length < tvb_reported_length(tvb))
|
2000-05-25 21:34:58 +00:00
|
|
|
length += (1 + tvb_get_guint8(tvb, length)); /* registration */
|
|
|
|
|
2000-05-29 22:35:11 +00:00
|
|
|
return MIN(tvb_reported_length(tvb),length);
|
1999-09-12 18:37:01 +00:00
|
|
|
|
1999-08-02 02:26:22 +00:00
|
|
|
case X25_REGISTRATION_CONFIRMATION:
|
2000-05-25 21:34:58 +00:00
|
|
|
bytex = tvb_get_guint8(tvb, 5);
|
|
|
|
dce_len = (bytex >> 0) & 0x0F;
|
|
|
|
dte_len = (bytex >> 4) & 0x0F;
|
|
|
|
length = 6 + (dte_len + dce_len + 1) / 2; /* addr */
|
2000-05-29 22:35:11 +00:00
|
|
|
if (length < tvb_reported_length(tvb))
|
2000-05-25 21:34:58 +00:00
|
|
|
length += (1 + tvb_get_guint8(tvb, length)); /* registration */
|
|
|
|
|
2000-05-29 22:35:11 +00:00
|
|
|
return MIN(tvb_reported_length(tvb),length);
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
|
2003-01-08 08:43:09 +00:00
|
|
|
if (PACKET_IS_DATA(byte2))
|
|
|
|
return MIN(tvb_reported_length(tvb),3);
|
2000-05-25 21:34:58 +00:00
|
|
|
|
2003-01-08 08:43:09 +00:00
|
|
|
switch (PACKET_TYPE_FC(byte2))
|
1999-08-02 02:26:22 +00:00
|
|
|
{
|
|
|
|
case X25_RR:
|
2000-05-29 22:35:11 +00:00
|
|
|
return MIN(tvb_reported_length(tvb),3);
|
1999-08-02 02:26:22 +00:00
|
|
|
|
|
|
|
case X25_RNR:
|
2000-05-29 22:35:11 +00:00
|
|
|
return MIN(tvb_reported_length(tvb),3);
|
1999-08-02 02:26:22 +00:00
|
|
|
|
|
|
|
case X25_REJ:
|
2000-05-29 22:35:11 +00:00
|
|
|
return MIN(tvb_reported_length(tvb),3);
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2000-01-30 05:58:02 +00:00
|
|
|
static const value_string prt_id_vals[] = {
|
2001-12-02 00:38:54 +00:00
|
|
|
{PRT_ID_ISO_8073, "ISO 8073 COTP"},
|
|
|
|
{PRT_ID_ISO_8602, "ISO 8602 CLTP"},
|
|
|
|
{PRT_ID_ISO_10736_ISO_8073, "ISO 10736 in conjunction with ISO 8073 COTP"},
|
|
|
|
{PRT_ID_ISO_10736_ISO_8602, "ISO 10736 in conjunction with ISO 8602 CLTP"},
|
|
|
|
{0x00, NULL}
|
2000-01-30 05:58:02 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string sharing_strategy_vals[] = {
|
|
|
|
{0x00, "No sharing"},
|
|
|
|
{0x00, NULL}
|
|
|
|
};
|
|
|
|
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
static void
|
2002-04-09 08:15:04 +00:00
|
|
|
dissect_x25_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
2003-03-05 05:20:38 +00:00
|
|
|
x25_dir_t dir, gboolean side)
|
1999-08-02 02:26:22 +00:00
|
|
|
{
|
2001-12-02 00:07:46 +00:00
|
|
|
proto_tree *x25_tree=0, *gfi_tree=0, *userdata_tree=0;
|
2001-01-03 23:30:50 +00:00
|
|
|
proto_item *ti;
|
2001-07-05 22:10:09 +00:00
|
|
|
guint localoffset=0;
|
|
|
|
guint x25_pkt_len;
|
1999-08-02 02:26:22 +00:00
|
|
|
int modulo;
|
|
|
|
guint16 vc;
|
2003-02-28 00:48:06 +00:00
|
|
|
dissector_handle_t dissect = NULL;
|
1999-12-12 12:59:01 +00:00
|
|
|
gboolean toa; /* TOA/NPI address format */
|
2000-05-25 21:34:58 +00:00
|
|
|
guint16 bytes0_1;
|
|
|
|
guint8 pkt_type;
|
2005-08-05 13:10:58 +00:00
|
|
|
const char *short_name = NULL, *long_name = NULL;
|
2003-03-04 19:50:23 +00:00
|
|
|
tvbuff_t *next_tvb = NULL;
|
2001-11-15 21:11:01 +00:00
|
|
|
gboolean q_bit_set = FALSE;
|
2003-03-05 01:12:11 +00:00
|
|
|
gboolean m_bit_set;
|
|
|
|
gint payload_len;
|
2003-03-05 05:20:38 +00:00
|
|
|
guint32 frag_key;
|
2003-01-06 02:24:57 +00:00
|
|
|
void *saved_private_data;
|
2003-03-04 19:50:23 +00:00
|
|
|
fragment_data *fd_head;
|
2000-05-25 21:34:58 +00:00
|
|
|
|
2007-03-26 11:06:26 +00:00
|
|
|
|
|
|
|
guint8 spi;
|
|
|
|
int is_x_264;
|
|
|
|
guint8 prt_id;
|
2009-08-09 06:26:46 +00:00
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "X.25");
|
1999-08-02 02:26:22 +00:00
|
|
|
|
2000-05-25 21:34:58 +00:00
|
|
|
bytes0_1 = tvb_get_ntohs(tvb, 0);
|
1999-08-02 02:26:22 +00:00
|
|
|
|
2000-05-25 21:34:58 +00:00
|
|
|
modulo = ((bytes0_1 & 0x2000) ? 128 : 8);
|
|
|
|
vc = (int)(bytes0_1 & 0x0FFF);
|
1999-12-12 12:59:01 +00:00
|
|
|
|
2002-11-08 01:00:07 +00:00
|
|
|
pinfo->ctype = CT_X25;
|
|
|
|
pinfo->circuit_id = vc;
|
|
|
|
|
2003-03-05 01:12:11 +00:00
|
|
|
if (bytes0_1 & X25_ABIT) toa = TRUE;
|
1999-12-12 12:59:01 +00:00
|
|
|
else toa = FALSE;
|
|
|
|
|
2000-05-25 21:34:58 +00:00
|
|
|
x25_pkt_len = get_x25_pkt_len(tvb);
|
1999-09-12 18:37:01 +00:00
|
|
|
if (x25_pkt_len < 3) /* packet too short */
|
|
|
|
{
|
2009-08-09 07:01:26 +00:00
|
|
|
col_set_str(pinfo->cinfo, COL_INFO, "Invalid/short X.25 packet");
|
1999-09-12 18:37:01 +00:00
|
|
|
if (tree)
|
2002-01-24 09:20:54 +00:00
|
|
|
proto_tree_add_protocol_format(tree, proto_x25, tvb, 0, -1,
|
|
|
|
"Invalid/short X.25 packet");
|
1999-09-12 18:37:01 +00:00
|
|
|
return;
|
|
|
|
}
|
2001-01-03 23:30:50 +00:00
|
|
|
|
|
|
|
pkt_type = tvb_get_guint8(tvb, 2);
|
2003-01-08 08:43:09 +00:00
|
|
|
if (PACKET_IS_DATA(pkt_type)) {
|
2003-03-05 01:12:11 +00:00
|
|
|
if (bytes0_1 & X25_QBIT)
|
2003-01-06 02:24:57 +00:00
|
|
|
q_bit_set = TRUE;
|
|
|
|
}
|
2001-01-03 23:30:50 +00:00
|
|
|
|
1999-08-02 02:26:22 +00:00
|
|
|
if (tree) {
|
2011-10-21 02:10:19 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_x25, tvb, 0, x25_pkt_len, ENC_NA);
|
2001-11-15 21:11:01 +00:00
|
|
|
x25_tree = proto_item_add_subtree(ti, ett_x25);
|
2011-10-06 03:35:44 +00:00
|
|
|
ti = proto_tree_add_item(x25_tree, hf_x25_gfi, tvb, 0, 2, ENC_BIG_ENDIAN);
|
2001-11-15 21:11:01 +00:00
|
|
|
gfi_tree = proto_item_add_subtree(ti, ett_x25_gfi);
|
|
|
|
|
2003-01-08 08:43:09 +00:00
|
|
|
if (PACKET_IS_DATA(pkt_type)) {
|
2001-11-15 21:11:01 +00:00
|
|
|
proto_tree_add_boolean(gfi_tree, hf_x25_qbit, tvb, 0, 2,
|
|
|
|
bytes0_1);
|
|
|
|
}
|
|
|
|
else if (pkt_type == X25_CALL_REQUEST ||
|
|
|
|
pkt_type == X25_CALL_ACCEPTED ||
|
|
|
|
pkt_type == X25_CLEAR_REQUEST ||
|
|
|
|
pkt_type == X25_CLEAR_CONFIRMATION) {
|
|
|
|
proto_tree_add_boolean(gfi_tree, hf_x25_abit, tvb, 0, 2,
|
|
|
|
bytes0_1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pkt_type == X25_CALL_REQUEST || pkt_type == X25_CALL_ACCEPTED ||
|
2003-01-08 08:43:09 +00:00
|
|
|
PACKET_IS_DATA(pkt_type)) {
|
2001-11-15 21:11:01 +00:00
|
|
|
proto_tree_add_boolean(gfi_tree, hf_x25_dbit, tvb, 0, 2,
|
|
|
|
bytes0_1);
|
|
|
|
}
|
|
|
|
proto_tree_add_uint(gfi_tree, hf_x25_mod, tvb, 0, 2, bytes0_1);
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
2000-05-25 21:34:58 +00:00
|
|
|
|
|
|
|
switch (pkt_type) {
|
1999-08-02 02:26:22 +00:00
|
|
|
case X25_CALL_REQUEST:
|
2002-04-09 08:15:04 +00:00
|
|
|
switch (dir) {
|
|
|
|
|
|
|
|
case X25_FROM_DCE:
|
|
|
|
short_name = "Inc. call";
|
|
|
|
long_name = "Incoming call";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case X25_FROM_DTE:
|
|
|
|
short_name = "Call req.";
|
|
|
|
long_name = "Call request";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case X25_UNKNOWN:
|
|
|
|
short_name = "Inc. call/Call req.";
|
|
|
|
long_name = "Incoming call/Call request";
|
|
|
|
break;
|
|
|
|
}
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
2002-04-09 08:15:04 +00:00
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "%s VC:%d", short_name, vc);
|
1999-10-18 01:51:34 +00:00
|
|
|
if (x25_tree) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_lcn, tvb,
|
2000-05-25 21:34:58 +00:00
|
|
|
0, 2, bytes0_1);
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint_format(x25_tree, hf_x25_type, tvb, 2, 1,
|
2003-01-08 08:43:09 +00:00
|
|
|
X25_CALL_REQUEST, "Packet Type: %s", long_name);
|
1999-10-18 01:51:34 +00:00
|
|
|
}
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset = 3;
|
2002-05-09 11:18:47 +00:00
|
|
|
if (localoffset < x25_pkt_len) { /* calling/called addresses */
|
|
|
|
if (toa)
|
2007-03-26 11:06:26 +00:00
|
|
|
x25_toa(x25_tree, (gint*)&localoffset, tvb, pinfo);
|
2002-05-09 11:18:47 +00:00
|
|
|
else
|
2007-03-26 11:06:26 +00:00
|
|
|
x25_ntoa(x25_tree, (gint*)&localoffset, tvb, pinfo, FALSE);
|
2002-05-09 11:18:47 +00:00
|
|
|
}
|
1999-08-02 02:26:22 +00:00
|
|
|
|
2000-05-25 21:34:58 +00:00
|
|
|
if (localoffset < x25_pkt_len) /* facilities */
|
2007-03-26 11:06:26 +00:00
|
|
|
dump_facilities(x25_tree, (gint*)&localoffset, tvb);
|
1999-08-02 02:26:22 +00:00
|
|
|
|
2000-05-29 22:35:11 +00:00
|
|
|
if (localoffset < tvb_reported_length(tvb)) /* user data */
|
1999-08-02 02:26:22 +00:00
|
|
|
{
|
2000-01-30 05:58:02 +00:00
|
|
|
|
2001-12-02 00:07:46 +00:00
|
|
|
if (x25_tree) {
|
2002-01-24 09:20:54 +00:00
|
|
|
ti = proto_tree_add_text(x25_tree, tvb, localoffset, -1,
|
2001-12-02 00:07:46 +00:00
|
|
|
"User data");
|
|
|
|
userdata_tree = proto_item_add_subtree(ti, ett_x25_user_data);
|
|
|
|
}
|
2000-01-30 05:58:02 +00:00
|
|
|
|
2001-12-02 00:07:46 +00:00
|
|
|
/* X.263/ISO 9577 says that:
|
|
|
|
|
|
|
|
When CLNP or ESIS are run over X.25, the SPI
|
|
|
|
is 0x81 or 0x82, respectively; those are the
|
|
|
|
NLPIDs for those protocol.
|
|
|
|
|
|
|
|
When X.224/ISO 8073 COTP is run over X.25, and
|
|
|
|
when ISO 11570 explicit identification is being
|
|
|
|
used, the first octet of the user data field is
|
|
|
|
a TPDU length field, and the rest is "as defined
|
|
|
|
in ITU-T Rec. X.225 | ISO/IEC 8073, Annex B,
|
|
|
|
or ITU-T Rec. X.264 and ISO/IEC 11570".
|
|
|
|
|
|
|
|
When X.264/ISO 11570 default identification is
|
|
|
|
being used, there is no user data field in the
|
|
|
|
CALL REQUEST packet. This is for X.225/ISO 8073
|
|
|
|
COTP.
|
|
|
|
|
|
|
|
It also says that SPI values from 0x03 through 0x3f are
|
|
|
|
reserved and are in use by X.224/ISO 8073 Annex B and
|
|
|
|
X.264/ISO 11570. The note says that those values are
|
|
|
|
not NLPIDs, they're "used by the respective higher layer
|
|
|
|
protocol" and "not used for higher layer protocol
|
|
|
|
identification". I infer from this and from what
|
|
|
|
X.264/ISO 11570 says that this means that values in those
|
|
|
|
range are valid values for the first octet of an
|
|
|
|
X.224/ISO 8073 packet or for X.264/ISO 11570.
|
|
|
|
|
|
|
|
Annex B of X.225/ISO 8073 mentions some additional TPDU
|
|
|
|
types that can be put in what I presume is the user
|
|
|
|
data of connect requests. It says that:
|
|
|
|
|
|
|
|
The sending transport entity shall:
|
|
|
|
|
|
|
|
a) either not transmit any TPDU in the NS-user data
|
|
|
|
parameter of the N-CONNECT request primitive; or
|
|
|
|
|
|
|
|
b) transmit the UN-TPDU (see ITU-T Rec. X.264 and
|
|
|
|
ISO/IEC 11570) followed by the NCM-TPDU in the
|
|
|
|
NS-user data parameter of the N-CONNECT request
|
|
|
|
primitive.
|
|
|
|
|
|
|
|
I don't know if this means that the user data field
|
|
|
|
will contain a UN TPDU followed by an NCM TPDU or not.
|
|
|
|
|
|
|
|
X.264/ISO 11570 says that:
|
|
|
|
|
|
|
|
When default identification is being used,
|
|
|
|
X.225/ISO 8073 COTP is identified. No user data
|
|
|
|
is sent in the network-layer connection request.
|
|
|
|
|
|
|
|
When explicit identification is being used,
|
|
|
|
the user data is a UN TPDU ("Use of network
|
|
|
|
connection TPDU"), which specifies the transport
|
|
|
|
protocol to use over this network connection.
|
|
|
|
It also says that the length of a UN TPDU shall
|
|
|
|
not exceed 32 octets, i.e. shall not exceed 0x20;
|
|
|
|
it says this is "due to the desire not to conflict
|
|
|
|
with the protocol identifier field carried by X.25
|
|
|
|
CALL REQUEST/INCOMING CALL packets", and says that
|
|
|
|
field has values specified in X.244. X.244 has been
|
|
|
|
superseded by X.263/ISO 9577, so that presumably
|
|
|
|
means the goal is to allow a UN TPDU's length
|
|
|
|
field to be distinguished from an NLPID, allowing
|
|
|
|
you to tell whether X.264/ISO 11570 explicit
|
|
|
|
identification is being used or an NLPID is
|
|
|
|
being used as the SPI.
|
|
|
|
|
|
|
|
I read this as meaning that, if the ISO mechanisms are
|
|
|
|
used to identify the protocol being carried over X.25:
|
|
|
|
|
|
|
|
if there's no user data in the CALL REQUEST/
|
|
|
|
INCOMING CALL packet, it's COTP;
|
|
|
|
|
|
|
|
if there is user data, then:
|
|
|
|
|
|
|
|
if the first octet is less than or equal to
|
|
|
|
32, it might be a UN TPDU, and that identifies
|
|
|
|
the transport protocol being used, and
|
|
|
|
it may be followed by more data, such
|
|
|
|
as a COTP NCM TPDU if it's COTP;
|
|
|
|
|
|
|
|
if the first octet is greater than 32, it's
|
|
|
|
an NLPID, *not* a TPDU length, and the
|
|
|
|
stuff following it is *not* a TPDU.
|
|
|
|
|
|
|
|
Figure A.2 of X.263/ISO 9577 seems to say that the
|
|
|
|
first octet of the user data is a TPDU length field,
|
|
|
|
in the range 0x03 through 0x82, and says they are
|
|
|
|
for X.225/ISO 8073 Annex B or X.264/ISO 11570.
|
|
|
|
|
|
|
|
However, X.264/ISO 11570 seems to imply that the length
|
|
|
|
field would be that of a UN TPDU, which must be less
|
|
|
|
than or equal to 0x20, and X.225/ISO 8073 Annex B seems
|
|
|
|
to indicate that the user data must begin with
|
|
|
|
an X.264/ISO 11570 UN TPDU, so I'd say that A.2 should
|
|
|
|
have said "in the range 0x03 through 0x20", instead
|
|
|
|
(the length value doesn't include the length field,
|
|
|
|
and the minimum UN TPDU has length, type, PRT-ID,
|
|
|
|
and SHARE, so that's 3 bytes without the length). */
|
|
|
|
spi = tvb_get_guint8(tvb, localoffset);
|
|
|
|
if (spi > 32 || spi < 3) {
|
|
|
|
/* First octet is > 32, or < 3, so the user data isn't an
|
|
|
|
X.264/ISO 11570 UN TPDU */
|
|
|
|
is_x_264 = FALSE;
|
|
|
|
} else {
|
|
|
|
/* First octet is >= 3 and <= 32, so the user data *might*
|
|
|
|
be an X.264/ISO 11570 UN TPDU. Check whether we have
|
|
|
|
enough data to see if it is. */
|
|
|
|
if (tvb_bytes_exist(tvb, localoffset+1, 1)) {
|
|
|
|
/* We do; check whether the second octet is 1. */
|
|
|
|
if (tvb_get_guint8(tvb, localoffset+1) == 0x01) {
|
|
|
|
/* Yes, the second byte is 1, so it looks like
|
|
|
|
a UN TPDU. */
|
|
|
|
is_x_264 = TRUE;
|
|
|
|
} else {
|
|
|
|
/* No, the second byte is not 1, so it's not a
|
|
|
|
UN TPDU. */
|
|
|
|
is_x_264 = FALSE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* We can't see the second byte of the putative UN
|
|
|
|
TPDU, so we don't know if that's what it is. */
|
|
|
|
is_x_264 = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (is_x_264 == -1) {
|
|
|
|
/*
|
|
|
|
* We don't know what it is; just skip it.
|
|
|
|
*/
|
|
|
|
localoffset = tvb_length(tvb);
|
|
|
|
} else if (is_x_264) {
|
|
|
|
/* It looks like an X.264 UN TPDU, so show it as such. */
|
|
|
|
if (userdata_tree) {
|
|
|
|
proto_tree_add_text(userdata_tree, tvb, localoffset, 1,
|
2000-01-30 05:58:02 +00:00
|
|
|
"X.264 length indicator: %u",
|
2000-05-25 21:34:58 +00:00
|
|
|
spi);
|
2001-12-02 00:07:46 +00:00
|
|
|
proto_tree_add_text(userdata_tree, tvb, localoffset+1, 1,
|
|
|
|
"X.264 UN TPDU identifier: 0x%02X",
|
|
|
|
tvb_get_guint8(tvb, localoffset+1));
|
|
|
|
}
|
|
|
|
prt_id = tvb_get_guint8(tvb, localoffset+2);
|
|
|
|
if (userdata_tree) {
|
2003-10-07 18:19:59 +00:00
|
|
|
proto_tree_add_text(userdata_tree, tvb, localoffset+2, 1,
|
2001-12-02 00:07:46 +00:00
|
|
|
"X.264 protocol identifier: %s",
|
2000-05-25 21:34:58 +00:00
|
|
|
val_to_str(prt_id, prt_id_vals,
|
2001-12-02 00:07:46 +00:00
|
|
|
"Unknown (0x%02X)"));
|
2003-10-07 18:19:59 +00:00
|
|
|
proto_tree_add_text(userdata_tree, tvb, localoffset+3, 1,
|
2001-12-02 00:07:46 +00:00
|
|
|
"X.264 sharing strategy: %s",
|
2000-05-25 21:34:58 +00:00
|
|
|
val_to_str(tvb_get_guint8(tvb, localoffset+3),
|
2001-12-02 00:07:46 +00:00
|
|
|
sharing_strategy_vals, "Unknown (0x%02X)"));
|
|
|
|
}
|
2000-01-30 05:58:02 +00:00
|
|
|
|
2001-12-02 00:07:46 +00:00
|
|
|
/* XXX - dissect the variable part? */
|
2000-01-30 05:58:02 +00:00
|
|
|
|
2001-12-02 00:07:46 +00:00
|
|
|
/* The length doesn't include the length octet itself. */
|
|
|
|
localoffset += spi + 1;
|
2000-01-30 05:58:02 +00:00
|
|
|
|
2001-12-02 00:07:46 +00:00
|
|
|
switch (prt_id) {
|
2000-01-30 05:58:02 +00:00
|
|
|
|
2001-12-02 00:07:46 +00:00
|
|
|
case PRT_ID_ISO_8073:
|
|
|
|
/* ISO 8073 COTP */
|
2003-01-11 10:03:12 +00:00
|
|
|
if (!pinfo->fd->flags.visited)
|
|
|
|
x25_hash_add_proto_start(vc, pinfo->fd->num, ositp_handle);
|
2003-01-06 02:24:57 +00:00
|
|
|
/* XXX - dissect the rest of the user data as COTP?
|
2001-12-02 00:07:46 +00:00
|
|
|
That needs support for NCM TPDUs, etc. */
|
|
|
|
break;
|
2001-12-02 00:38:54 +00:00
|
|
|
|
|
|
|
case PRT_ID_ISO_8602:
|
|
|
|
/* ISO 8602 CLTP */
|
2003-01-11 10:03:12 +00:00
|
|
|
if (!pinfo->fd->flags.visited)
|
|
|
|
x25_hash_add_proto_start(vc, pinfo->fd->num, ositp_handle);
|
2001-12-02 00:38:54 +00:00
|
|
|
break;
|
2000-01-30 05:58:02 +00:00
|
|
|
}
|
2001-12-02 00:07:46 +00:00
|
|
|
} else if (is_x_264 == 0) {
|
|
|
|
/* It doesn't look like a UN TPDU, so compare the first
|
|
|
|
octet of the CALL REQUEST packet with various X.263/
|
2002-08-28 21:04:11 +00:00
|
|
|
ISO 9577 NLPIDs, as per Annex A of X.263/ISO 9577. */
|
2001-12-02 00:07:46 +00:00
|
|
|
|
|
|
|
if (userdata_tree) {
|
|
|
|
proto_tree_add_text(userdata_tree, tvb, localoffset, 1,
|
|
|
|
"X.263 secondary protocol ID: %s",
|
|
|
|
val_to_str(spi, nlpid_vals, "Unknown (0x%02x)"));
|
|
|
|
}
|
2003-02-28 00:48:06 +00:00
|
|
|
|
2003-03-01 08:50:46 +00:00
|
|
|
if (!pinfo->fd->flags.visited) {
|
|
|
|
/*
|
|
|
|
* Is there a dissector handle for this SPI?
|
|
|
|
* If so, assign it to this virtual circuit.
|
|
|
|
*/
|
2010-12-20 05:35:29 +00:00
|
|
|
dissect = dissector_get_uint_handle(x25_subdissector_table, spi);
|
2003-03-01 08:50:46 +00:00
|
|
|
if (dissect != NULL)
|
|
|
|
x25_hash_add_proto_start(vc, pinfo->fd->num, dissect);
|
|
|
|
}
|
|
|
|
|
2003-02-28 00:48:06 +00:00
|
|
|
/*
|
2003-03-01 08:50:46 +00:00
|
|
|
* If there's only one octet of user data, it's just
|
|
|
|
* an NLPID; don't try to dissect it.
|
|
|
|
*/
|
2003-03-04 19:50:23 +00:00
|
|
|
if (localoffset + 1 == tvb_reported_length(tvb))
|
2003-03-01 08:50:46 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* There's more than one octet of user data, so we'll
|
2003-02-28 00:48:06 +00:00
|
|
|
* dissect it; for some protocols, the NLPID is considered
|
|
|
|
* to be part of the PDU, so, for those cases, we don't
|
|
|
|
* skip past it. For other protocols, we skip the NLPID.
|
|
|
|
*/
|
|
|
|
switch (spi) {
|
|
|
|
|
|
|
|
case NLPID_ISO8473_CLNP:
|
|
|
|
case NLPID_ISO9542_ESIS:
|
|
|
|
case NLPID_ISO10589_ISIS:
|
|
|
|
case NLPID_ISO10747_IDRP:
|
|
|
|
case NLPID_SNDCF:
|
|
|
|
/*
|
|
|
|
* The NLPID is part of the PDU. Don't skip it.
|
2003-03-01 08:50:46 +00:00
|
|
|
* But if it's all there is to the PDU, don't
|
|
|
|
* bother dissecting it.
|
2003-02-28 00:48:06 +00:00
|
|
|
*/
|
|
|
|
break;
|
|
|
|
|
2003-03-01 10:02:35 +00:00
|
|
|
case NLPID_SPI_X_29:
|
|
|
|
/*
|
|
|
|
* The first 4 bytes of the call user data are
|
|
|
|
* the SPI plus 3 reserved bytes; they are not
|
|
|
|
* part of the data to be dissected as X.29 data.
|
|
|
|
*/
|
|
|
|
localoffset += 4;
|
|
|
|
break;
|
|
|
|
|
2003-02-28 00:48:06 +00:00
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* The NLPID isn't part of the PDU - skip it.
|
2003-03-01 08:50:46 +00:00
|
|
|
* If that means there's nothing to dissect
|
2003-02-28 00:48:06 +00:00
|
|
|
*/
|
|
|
|
localoffset++;
|
|
|
|
}
|
2001-12-02 00:07:46 +00:00
|
|
|
}
|
2007-03-14 17:28:55 +00:00
|
|
|
} else {
|
|
|
|
/* if there's no user data in the CALL REQUEST/
|
|
|
|
INCOMING CALL packet, it's COTP; */
|
|
|
|
|
2008-03-16 10:19:51 +00:00
|
|
|
if (call_request_nodata_is_cotp){
|
|
|
|
x25_hash_add_proto_start(vc, pinfo->fd->num, ositp_handle);
|
|
|
|
}
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case X25_CALL_ACCEPTED:
|
2002-04-09 08:15:04 +00:00
|
|
|
switch (dir) {
|
|
|
|
|
|
|
|
case X25_FROM_DCE:
|
|
|
|
short_name = "Call conn.";
|
|
|
|
long_name = "Call connected";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case X25_FROM_DTE:
|
|
|
|
short_name = "Call acc.";
|
|
|
|
long_name = "Call accepted";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case X25_UNKNOWN:
|
|
|
|
short_name = "Call conn./Call acc.";
|
|
|
|
long_name = "Call connected/Call accepted";
|
|
|
|
break;
|
|
|
|
}
|
2001-12-10 00:26:21 +00:00
|
|
|
if(check_col(pinfo->cinfo, COL_INFO))
|
2002-04-09 08:15:04 +00:00
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "%s VC:%d", short_name, vc);
|
1999-10-18 01:51:34 +00:00
|
|
|
if (x25_tree) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_lcn, tvb, 0, 2, bytes0_1);
|
|
|
|
proto_tree_add_uint_format(x25_tree, hf_x25_type, tvb, 2, 1,
|
2003-01-08 08:43:09 +00:00
|
|
|
X25_CALL_ACCEPTED, "Packet Type: %s", long_name);
|
1999-10-18 01:51:34 +00:00
|
|
|
}
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset = 3;
|
2002-05-09 11:18:47 +00:00
|
|
|
if (localoffset < x25_pkt_len) { /* calling/called addresses */
|
|
|
|
if (toa)
|
2007-03-26 11:06:26 +00:00
|
|
|
x25_toa(x25_tree, (gint*)&localoffset, tvb, pinfo);
|
2002-05-09 11:18:47 +00:00
|
|
|
else
|
2007-03-26 11:06:26 +00:00
|
|
|
x25_ntoa(x25_tree, (gint*)&localoffset, tvb, pinfo, FALSE);
|
2002-05-09 11:18:47 +00:00
|
|
|
}
|
1999-08-02 02:26:22 +00:00
|
|
|
|
2000-05-25 21:34:58 +00:00
|
|
|
if (localoffset < x25_pkt_len) /* facilities */
|
2007-03-26 11:06:26 +00:00
|
|
|
dump_facilities(x25_tree, (gint*)&localoffset, tvb);
|
1999-08-02 02:26:22 +00:00
|
|
|
break;
|
|
|
|
case X25_CLEAR_REQUEST:
|
2002-04-09 08:15:04 +00:00
|
|
|
switch (dir) {
|
|
|
|
|
|
|
|
case X25_FROM_DCE:
|
|
|
|
short_name = "Clear ind.";
|
|
|
|
long_name = "Clear indication";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case X25_FROM_DTE:
|
|
|
|
short_name = "Clear req.";
|
|
|
|
long_name = "Clear request";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case X25_UNKNOWN:
|
|
|
|
short_name = "Clear ind./Clear req.";
|
|
|
|
long_name = "Clear indication/Clear request";
|
|
|
|
break;
|
|
|
|
}
|
2001-12-10 00:26:21 +00:00
|
|
|
if(check_col(pinfo->cinfo, COL_INFO)) {
|
2002-04-09 08:15:04 +00:00
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "%s VC:%d %s - %s", short_name,
|
2000-05-25 21:34:58 +00:00
|
|
|
vc, clear_code(tvb_get_guint8(tvb, 3)),
|
2012-09-27 04:05:01 +00:00
|
|
|
val_to_str_ext(tvb_get_guint8(tvb, 4), &x25_clear_diag_vals_ext, "Unknown (0x%02x)"));
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
2002-11-08 01:00:07 +00:00
|
|
|
x25_hash_add_proto_end(vc, pinfo->fd->num);
|
1999-08-02 02:26:22 +00:00
|
|
|
if (x25_tree) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_lcn, tvb, 0, 2, bytes0_1);
|
|
|
|
proto_tree_add_uint_format(x25_tree, hf_x25_type, tvb,
|
2003-01-08 08:43:09 +00:00
|
|
|
localoffset+2, 1, X25_CLEAR_REQUEST, "Packet Type: %s",
|
|
|
|
long_name);
|
2000-05-25 21:34:58 +00:00
|
|
|
proto_tree_add_text(x25_tree, tvb, 3, 1,
|
|
|
|
"Cause : %s", clear_code(tvb_get_guint8(tvb, 3)));
|
2012-09-27 04:05:01 +00:00
|
|
|
proto_tree_add_item(x25_tree, hf_x25_diagnostic, tvb, 4, 1, ENC_NA);
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset = x25_pkt_len;
|
1999-08-02 02:26:22 +00:00
|
|
|
break;
|
|
|
|
case X25_CLEAR_CONFIRMATION:
|
2001-12-10 00:26:21 +00:00
|
|
|
if(check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "Clear Conf. VC:%d", vc);
|
1999-10-18 01:51:34 +00:00
|
|
|
if (x25_tree) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_lcn, tvb, 0, 2, bytes0_1);
|
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type, tvb, 2, 1,
|
|
|
|
X25_CLEAR_CONFIRMATION);
|
1999-10-18 01:51:34 +00:00
|
|
|
}
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset = x25_pkt_len;
|
1999-08-04 06:11:17 +00:00
|
|
|
|
2002-05-09 11:18:47 +00:00
|
|
|
if (localoffset < tvb_reported_length(tvb)) { /* extended clear conf format */
|
|
|
|
if (toa)
|
2007-03-26 11:06:26 +00:00
|
|
|
x25_toa(x25_tree, (gint*)&localoffset, tvb, pinfo);
|
2002-05-09 11:18:47 +00:00
|
|
|
else
|
2007-03-26 11:06:26 +00:00
|
|
|
x25_ntoa(x25_tree,(gint*)&localoffset, tvb, pinfo, FALSE);
|
2002-05-09 11:18:47 +00:00
|
|
|
}
|
1999-08-04 06:11:17 +00:00
|
|
|
|
2000-05-29 22:35:11 +00:00
|
|
|
if (localoffset < tvb_reported_length(tvb)) /* facilities */
|
2007-03-26 11:06:26 +00:00
|
|
|
dump_facilities(x25_tree, (gint*)&localoffset, tvb);
|
1999-08-02 02:26:22 +00:00
|
|
|
break;
|
|
|
|
case X25_DIAGNOSTIC:
|
2001-12-10 00:26:21 +00:00
|
|
|
if(check_col(pinfo->cinfo, COL_INFO)) {
|
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "Diag. %d",
|
2000-05-25 21:34:58 +00:00
|
|
|
(int)tvb_get_guint8(tvb, 3));
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
if (x25_tree) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type, tvb, 2, 1,
|
|
|
|
X25_DIAGNOSTIC);
|
2000-05-25 21:34:58 +00:00
|
|
|
proto_tree_add_text(x25_tree, tvb, 3, 1,
|
|
|
|
"Diagnostic : %d", (int)tvb_get_guint8(tvb, 3));
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset = x25_pkt_len;
|
1999-08-02 02:26:22 +00:00
|
|
|
break;
|
|
|
|
case X25_INTERRUPT:
|
2001-12-10 00:26:21 +00:00
|
|
|
if(check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "Interrupt VC:%d", vc);
|
1999-10-18 01:51:34 +00:00
|
|
|
if (x25_tree) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_lcn, tvb, 0, 2, bytes0_1);
|
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type, tvb, 2, 1,
|
|
|
|
X25_INTERRUPT);
|
1999-10-18 01:51:34 +00:00
|
|
|
}
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset = x25_pkt_len;
|
1999-08-02 02:26:22 +00:00
|
|
|
break;
|
|
|
|
case X25_INTERRUPT_CONFIRMATION:
|
2001-12-10 00:26:21 +00:00
|
|
|
if(check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "Interrupt Conf. VC:%d", vc);
|
1999-10-18 01:51:34 +00:00
|
|
|
if (x25_tree) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_lcn, tvb, 0, 2, bytes0_1);
|
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type, tvb, 2, 1,
|
|
|
|
X25_INTERRUPT_CONFIRMATION);
|
1999-10-18 01:51:34 +00:00
|
|
|
}
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset = x25_pkt_len;
|
1999-08-02 02:26:22 +00:00
|
|
|
break;
|
|
|
|
case X25_RESET_REQUEST:
|
2002-04-09 08:15:04 +00:00
|
|
|
switch (dir) {
|
|
|
|
|
|
|
|
case X25_FROM_DCE:
|
|
|
|
short_name = "Reset ind.";
|
|
|
|
long_name = "Reset indication";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case X25_FROM_DTE:
|
|
|
|
short_name = "Reset req.";
|
|
|
|
long_name = "Reset request";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case X25_UNKNOWN:
|
|
|
|
short_name = "Reset ind./Reset req.";
|
|
|
|
long_name = "Reset indication/Reset request";
|
|
|
|
break;
|
|
|
|
}
|
2001-12-10 00:26:21 +00:00
|
|
|
if(check_col(pinfo->cinfo, COL_INFO)) {
|
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "%s VC:%d %s - Diag.:%d",
|
2002-04-09 08:15:04 +00:00
|
|
|
short_name, vc, reset_code(tvb_get_guint8(tvb, 3)),
|
2000-05-25 21:34:58 +00:00
|
|
|
(int)tvb_get_guint8(tvb, 4));
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
2002-11-08 01:00:07 +00:00
|
|
|
x25_hash_add_proto_end(vc, pinfo->fd->num);
|
1999-08-02 02:26:22 +00:00
|
|
|
if (x25_tree) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_lcn, tvb, 0, 2, bytes0_1);
|
|
|
|
proto_tree_add_uint_format(x25_tree, hf_x25_type, tvb, 2, 1,
|
2003-01-08 08:43:09 +00:00
|
|
|
X25_RESET_REQUEST, "Packet Type: %s", long_name);
|
2000-05-25 21:34:58 +00:00
|
|
|
proto_tree_add_text(x25_tree, tvb, 3, 1,
|
|
|
|
"Cause : %s", reset_code(tvb_get_guint8(tvb, 3)));
|
|
|
|
proto_tree_add_text(x25_tree, tvb, 4, 1,
|
|
|
|
"Diagnostic : %d", (int)tvb_get_guint8(tvb, 4));
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset = x25_pkt_len;
|
1999-08-02 02:26:22 +00:00
|
|
|
break;
|
|
|
|
case X25_RESET_CONFIRMATION:
|
2001-12-10 00:26:21 +00:00
|
|
|
if(check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "Reset conf. VC:%d", vc);
|
1999-10-18 01:51:34 +00:00
|
|
|
if (x25_tree) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_lcn, tvb, 0, 2, bytes0_1);
|
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type, tvb, 2, 1,
|
|
|
|
X25_RESET_CONFIRMATION);
|
1999-10-18 01:51:34 +00:00
|
|
|
}
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset = x25_pkt_len;
|
1999-08-02 02:26:22 +00:00
|
|
|
break;
|
|
|
|
case X25_RESTART_REQUEST:
|
2002-04-09 08:15:04 +00:00
|
|
|
switch (dir) {
|
|
|
|
|
|
|
|
case X25_FROM_DCE:
|
|
|
|
short_name = "Restart ind.";
|
|
|
|
long_name = "Restart indication";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case X25_FROM_DTE:
|
|
|
|
short_name = "Restart req.";
|
|
|
|
long_name = "Restart request";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case X25_UNKNOWN:
|
|
|
|
short_name = "Restart ind./Restart req.";
|
|
|
|
long_name = "Restart indication/Restart request";
|
|
|
|
break;
|
|
|
|
}
|
2001-12-10 00:26:21 +00:00
|
|
|
if(check_col(pinfo->cinfo, COL_INFO)) {
|
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "%s %s - Diag.:%d",
|
2002-04-09 08:15:04 +00:00
|
|
|
short_name,
|
2000-05-25 21:34:58 +00:00
|
|
|
restart_code(tvb_get_guint8(tvb, 3)),
|
2007-08-18 22:56:44 +00:00
|
|
|
(int)tvb_get_guint8(tvb, 4));
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
if (x25_tree) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint_format(x25_tree, hf_x25_type, tvb, 2, 1,
|
2003-01-08 08:43:09 +00:00
|
|
|
X25_RESTART_REQUEST, "Packet Type: %s", long_name);
|
2000-05-25 21:34:58 +00:00
|
|
|
proto_tree_add_text(x25_tree, tvb, 3, 1,
|
|
|
|
"Cause : %s", restart_code(tvb_get_guint8(tvb, 3)));
|
|
|
|
proto_tree_add_text(x25_tree, tvb, 4, 1,
|
|
|
|
"Diagnostic : %d", (int)tvb_get_guint8(tvb, 4));
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset = x25_pkt_len;
|
1999-08-02 02:26:22 +00:00
|
|
|
break;
|
|
|
|
case X25_RESTART_CONFIRMATION:
|
2009-08-09 07:01:26 +00:00
|
|
|
col_set_str(pinfo->cinfo, COL_INFO, "Restart conf.");
|
1999-08-02 02:26:22 +00:00
|
|
|
if (x25_tree)
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type, tvb, 2, 1,
|
|
|
|
X25_RESTART_CONFIRMATION);
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset = x25_pkt_len;
|
1999-08-02 02:26:22 +00:00
|
|
|
break;
|
|
|
|
case X25_REGISTRATION_REQUEST:
|
2009-08-09 07:01:26 +00:00
|
|
|
col_set_str(pinfo->cinfo, COL_INFO, "Registration req.");
|
1999-08-02 02:26:22 +00:00
|
|
|
if (x25_tree)
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type, tvb, 2, 1,
|
|
|
|
X25_REGISTRATION_REQUEST);
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset = 3;
|
|
|
|
if (localoffset < x25_pkt_len)
|
2007-03-26 11:06:26 +00:00
|
|
|
x25_ntoa(x25_tree, (gint*)&localoffset, tvb, pinfo, TRUE);
|
1999-08-04 06:11:17 +00:00
|
|
|
|
|
|
|
if (x25_tree) {
|
2000-05-25 21:34:58 +00:00
|
|
|
if (localoffset < x25_pkt_len)
|
|
|
|
proto_tree_add_text(x25_tree, tvb, localoffset, 1,
|
|
|
|
"Registration length: %d",
|
|
|
|
tvb_get_guint8(tvb, localoffset) & 0x7F);
|
|
|
|
if (localoffset+1 < x25_pkt_len)
|
|
|
|
proto_tree_add_text(x25_tree, tvb, localoffset+1,
|
|
|
|
tvb_get_guint8(tvb, localoffset) & 0x7F,
|
|
|
|
"Registration");
|
1999-08-04 06:11:17 +00:00
|
|
|
}
|
2000-05-29 22:35:11 +00:00
|
|
|
localoffset = tvb_reported_length(tvb);
|
1999-08-02 02:26:22 +00:00
|
|
|
break;
|
|
|
|
case X25_REGISTRATION_CONFIRMATION:
|
2009-08-09 07:01:26 +00:00
|
|
|
col_set_str(pinfo->cinfo, COL_INFO, "Registration conf.");
|
1999-08-04 06:11:17 +00:00
|
|
|
if (x25_tree) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type, tvb, 2, 1,
|
|
|
|
X25_REGISTRATION_CONFIRMATION);
|
2012-09-27 04:05:01 +00:00
|
|
|
proto_tree_add_item(x25_tree, hf_x25_reg_confirm_cause, tvb, 3, 1, ENC_NA);
|
|
|
|
proto_tree_add_item(x25_tree, hf_x25_reg_confirm_diagnostic, tvb, 4, 1, ENC_NA);
|
1999-08-04 06:11:17 +00:00
|
|
|
}
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset = 5;
|
|
|
|
if (localoffset < x25_pkt_len)
|
2007-03-26 11:06:26 +00:00
|
|
|
x25_ntoa(x25_tree, (gint*)&localoffset, tvb, pinfo, TRUE);
|
1999-08-04 06:11:17 +00:00
|
|
|
|
|
|
|
if (x25_tree) {
|
2000-05-25 21:34:58 +00:00
|
|
|
if (localoffset < x25_pkt_len)
|
|
|
|
proto_tree_add_text(x25_tree, tvb, localoffset, 1,
|
|
|
|
"Registration length: %d",
|
|
|
|
tvb_get_guint8(tvb, localoffset) & 0x7F);
|
|
|
|
if (localoffset+1 < x25_pkt_len)
|
|
|
|
proto_tree_add_text(x25_tree, tvb, localoffset+1,
|
|
|
|
tvb_get_guint8(tvb, localoffset) & 0x7F,
|
|
|
|
"Registration");
|
1999-08-04 06:11:17 +00:00
|
|
|
}
|
2000-05-29 22:35:11 +00:00
|
|
|
localoffset = tvb_reported_length(tvb);
|
1999-08-02 02:26:22 +00:00
|
|
|
break;
|
|
|
|
default :
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset = 2;
|
2003-01-08 08:43:09 +00:00
|
|
|
if (PACKET_IS_DATA(pkt_type))
|
1999-08-02 02:26:22 +00:00
|
|
|
{
|
2001-12-10 00:26:21 +00:00
|
|
|
if(check_col(pinfo->cinfo, COL_INFO)) {
|
1999-08-04 06:11:17 +00:00
|
|
|
if (modulo == 8)
|
2001-12-10 00:26:21 +00:00
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO,
|
1999-08-04 06:11:17 +00:00
|
|
|
"Data VC:%d P(S):%d P(R):%d %s", vc,
|
2000-05-25 21:34:58 +00:00
|
|
|
(pkt_type >> 1) & 0x07,
|
|
|
|
(pkt_type >> 5) & 0x07,
|
2003-03-05 01:12:11 +00:00
|
|
|
(pkt_type & X25_MBIT_MOD8) ? " M" : "");
|
1999-08-04 06:11:17 +00:00
|
|
|
else
|
2001-12-10 00:26:21 +00:00
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO,
|
1999-08-04 06:11:17 +00:00
|
|
|
"Data VC:%d P(S):%d P(R):%d %s", vc,
|
2000-05-25 21:34:58 +00:00
|
|
|
tvb_get_guint8(tvb, localoffset+1) >> 1,
|
|
|
|
pkt_type >> 1,
|
2003-03-05 01:12:11 +00:00
|
|
|
(tvb_get_guint8(tvb, localoffset+1) & X25_MBIT_MOD128) ? " M" : "");
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
if (x25_tree) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_lcn, tvb, localoffset-2,
|
|
|
|
2, bytes0_1);
|
1999-08-04 06:11:17 +00:00
|
|
|
if (modulo == 8) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_p_r_mod8, tvb,
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset, 1, pkt_type);
|
2003-01-06 23:34:33 +00:00
|
|
|
proto_tree_add_boolean(x25_tree, hf_x25_mbit_mod8, tvb,
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
localoffset, 1, pkt_type);
|
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_p_s_mod8, tvb,
|
|
|
|
localoffset, 1, pkt_type);
|
2003-01-08 08:43:09 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type_data, tvb,
|
|
|
|
localoffset, 1, pkt_type);
|
1999-08-04 06:11:17 +00:00
|
|
|
}
|
|
|
|
else {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_p_r_mod128, tvb,
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset, 1, pkt_type);
|
2003-01-08 08:43:09 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type_data, tvb,
|
|
|
|
localoffset, 1, pkt_type);
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_p_s_mod128, tvb,
|
|
|
|
localoffset+1, 1,
|
|
|
|
tvb_get_guint8(tvb, localoffset+1));
|
2003-01-06 23:34:33 +00:00
|
|
|
proto_tree_add_boolean(x25_tree, hf_x25_mbit_mod128, tvb,
|
|
|
|
localoffset+1, 1,
|
|
|
|
tvb_get_guint8(tvb, localoffset+1));
|
1999-08-04 06:11:17 +00:00
|
|
|
}
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
2003-03-05 01:12:11 +00:00
|
|
|
if (modulo == 8) {
|
|
|
|
m_bit_set = pkt_type & X25_MBIT_MOD8;
|
|
|
|
localoffset += 1;
|
|
|
|
} else {
|
|
|
|
m_bit_set = tvb_get_guint8(tvb, localoffset+1) & X25_MBIT_MOD128;
|
|
|
|
localoffset += 2;
|
|
|
|
}
|
|
|
|
payload_len = tvb_reported_length_remaining(tvb, localoffset);
|
2003-03-05 05:20:38 +00:00
|
|
|
if (reassemble_x25) {
|
|
|
|
/*
|
|
|
|
* Reassemble received and sent traffic separately.
|
|
|
|
* We don't reassemble traffic with an unknown direction
|
|
|
|
* at all.
|
|
|
|
*/
|
|
|
|
frag_key = vc;
|
|
|
|
if (side) {
|
|
|
|
/*
|
|
|
|
* OR in an extra bit to distinguish from traffic
|
|
|
|
* in the other direction.
|
|
|
|
*/
|
|
|
|
frag_key |= 0x10000;
|
|
|
|
}
|
2011-10-21 02:10:19 +00:00
|
|
|
fd_head = fragment_add_seq_next(tvb, localoffset,
|
2003-03-05 05:20:38 +00:00
|
|
|
pinfo, frag_key,
|
|
|
|
x25_segment_table,
|
2003-03-04 19:50:23 +00:00
|
|
|
x25_reassembled_table,
|
2003-03-05 01:12:11 +00:00
|
|
|
payload_len, m_bit_set);
|
|
|
|
pinfo->fragmented = m_bit_set;
|
2008-07-30 14:50:17 +00:00
|
|
|
|
|
|
|
/* Fragment handling is not adapted to handle several x25
|
|
|
|
* packets in the same frame. This is common with XOT and
|
|
|
|
* shorter packet sizes.
|
|
|
|
* Therefore, fragment_add_seq_next seem to always return fd_head
|
|
|
|
* A fix to use m_bit_set to only show fragments for last pkt
|
|
|
|
*/
|
|
|
|
if (!m_bit_set && fd_head) {
|
2003-03-05 01:12:11 +00:00
|
|
|
if (fd_head->next) {
|
2005-06-02 20:55:58 +00:00
|
|
|
proto_item *frag_tree_item;
|
|
|
|
|
2003-03-05 01:12:11 +00:00
|
|
|
/* This is the last packet */
|
2011-10-21 02:10:19 +00:00
|
|
|
next_tvb = tvb_new_child_real_data(tvb, fd_head->data,
|
2003-03-05 01:12:11 +00:00
|
|
|
fd_head->len,
|
|
|
|
fd_head->len);
|
|
|
|
add_new_data_source(pinfo, next_tvb, "Reassembled X.25");
|
2008-07-30 14:50:17 +00:00
|
|
|
if (x25_tree) {
|
2011-10-21 02:10:19 +00:00
|
|
|
show_fragment_seq_tree(fd_head,
|
|
|
|
&x25_frag_items,
|
|
|
|
x25_tree,
|
2008-07-30 14:50:17 +00:00
|
|
|
pinfo, next_tvb, &frag_tree_item);
|
|
|
|
}
|
2003-03-05 05:20:38 +00:00
|
|
|
}
|
2003-03-05 01:12:11 +00:00
|
|
|
}
|
2003-03-05 05:20:38 +00:00
|
|
|
|
|
|
|
if (m_bit_set && next_tvb == NULL) {
|
|
|
|
/*
|
|
|
|
* This isn't the last packet, so just
|
|
|
|
* show it as X.25 user data.
|
|
|
|
*/
|
|
|
|
proto_tree_add_text(x25_tree, tvb, localoffset, -1,
|
|
|
|
"User data (%u byte%s)", payload_len,
|
|
|
|
plurality(payload_len, "", "s"));
|
|
|
|
return;
|
|
|
|
}
|
2003-03-05 01:12:11 +00:00
|
|
|
}
|
1999-08-02 02:26:22 +00:00
|
|
|
break;
|
|
|
|
}
|
2003-03-05 05:20:38 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Non-data packets (RR, RNR, REJ).
|
|
|
|
*/
|
2003-01-08 08:43:09 +00:00
|
|
|
switch (PACKET_TYPE_FC(pkt_type))
|
1999-08-02 02:26:22 +00:00
|
|
|
{
|
|
|
|
case X25_RR:
|
2001-12-10 00:26:21 +00:00
|
|
|
if(check_col(pinfo->cinfo, COL_INFO)) {
|
1999-08-04 06:11:17 +00:00
|
|
|
if (modulo == 8)
|
2001-12-10 00:26:21 +00:00
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "RR VC:%d P(R):%d",
|
2000-05-25 21:34:58 +00:00
|
|
|
vc, (pkt_type >> 5) & 0x07);
|
1999-08-04 06:11:17 +00:00
|
|
|
else
|
2001-12-10 00:26:21 +00:00
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "RR VC:%d P(R):%d",
|
2000-05-25 21:34:58 +00:00
|
|
|
vc, tvb_get_guint8(tvb, localoffset+1) >> 1);
|
1999-08-04 06:11:17 +00:00
|
|
|
}
|
|
|
|
if (x25_tree) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_lcn, tvb, localoffset-2,
|
|
|
|
2, bytes0_1);
|
1999-10-18 01:51:34 +00:00
|
|
|
if (modulo == 8) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_p_r_mod8, tvb,
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset, 1, pkt_type);
|
2003-01-08 08:43:09 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type_fc_mod8, tvb,
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset, 1, X25_RR);
|
1999-10-18 01:51:34 +00:00
|
|
|
}
|
|
|
|
else {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type, tvb,
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset, 1, X25_RR);
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_item(x25_tree, hf_x25_p_r_mod128, tvb,
|
2011-10-06 03:35:44 +00:00
|
|
|
localoffset+1, 1, ENC_BIG_ENDIAN);
|
1999-10-18 01:51:34 +00:00
|
|
|
}
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case X25_RNR:
|
2001-12-10 00:26:21 +00:00
|
|
|
if(check_col(pinfo->cinfo, COL_INFO)) {
|
1999-08-04 06:11:17 +00:00
|
|
|
if (modulo == 8)
|
2001-12-10 00:26:21 +00:00
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "RNR VC:%d P(R):%d",
|
2000-05-25 21:34:58 +00:00
|
|
|
vc, (pkt_type >> 5) & 0x07);
|
1999-08-04 06:11:17 +00:00
|
|
|
else
|
2001-12-10 00:26:21 +00:00
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "RNR VC:%d P(R):%d",
|
2000-05-25 21:34:58 +00:00
|
|
|
vc, tvb_get_guint8(tvb, localoffset+1) >> 1);
|
1999-08-04 06:11:17 +00:00
|
|
|
}
|
|
|
|
if (x25_tree) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_lcn, tvb, localoffset-2,
|
|
|
|
2, bytes0_1);
|
1999-10-18 01:51:34 +00:00
|
|
|
if (modulo == 8) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_p_r_mod8, tvb,
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset, 1, pkt_type);
|
2003-01-08 08:43:09 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type_fc_mod8, tvb,
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset, 1, X25_RNR);
|
1999-10-18 01:51:34 +00:00
|
|
|
}
|
|
|
|
else {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type, tvb,
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset, 1, X25_RNR);
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_item(x25_tree, hf_x25_p_r_mod128, tvb,
|
2011-10-06 03:35:44 +00:00
|
|
|
localoffset+1, 1, ENC_BIG_ENDIAN);
|
1999-10-18 01:51:34 +00:00
|
|
|
}
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case X25_REJ:
|
2001-12-10 00:26:21 +00:00
|
|
|
if(check_col(pinfo->cinfo, COL_INFO)) {
|
1999-08-04 06:11:17 +00:00
|
|
|
if (modulo == 8)
|
2001-12-10 00:26:21 +00:00
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "REJ VC:%d P(R):%d",
|
2000-05-25 21:34:58 +00:00
|
|
|
vc, (pkt_type >> 5) & 0x07);
|
1999-08-04 06:11:17 +00:00
|
|
|
else
|
2001-12-10 00:26:21 +00:00
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "REJ VC:%d P(R):%d",
|
2000-05-25 21:34:58 +00:00
|
|
|
vc, tvb_get_guint8(tvb, localoffset+1) >> 1);
|
1999-08-04 06:11:17 +00:00
|
|
|
}
|
|
|
|
if (x25_tree) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_lcn, tvb, localoffset-2,
|
|
|
|
2, bytes0_1);
|
1999-10-18 01:51:34 +00:00
|
|
|
if (modulo == 8) {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_p_r_mod8, tvb,
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset, 1, pkt_type);
|
2003-01-08 08:43:09 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type_fc_mod8, tvb,
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset, 1, X25_REJ);
|
1999-10-18 01:51:34 +00:00
|
|
|
}
|
|
|
|
else {
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_uint(x25_tree, hf_x25_type, tvb,
|
2000-05-25 21:34:58 +00:00
|
|
|
localoffset, 1, X25_REJ);
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_tree_add_item(x25_tree, hf_x25_p_r_mod128, tvb,
|
2011-10-06 03:35:44 +00:00
|
|
|
localoffset+1, 1, ENC_BIG_ENDIAN);
|
1999-10-18 01:51:34 +00:00
|
|
|
}
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
}
|
1999-08-04 06:11:17 +00:00
|
|
|
localoffset += (modulo == 8) ? 1 : 2;
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
|
2003-03-05 05:20:38 +00:00
|
|
|
if (localoffset >= tvb_reported_length(tvb))
|
|
|
|
return;
|
2003-03-04 19:50:23 +00:00
|
|
|
if (pinfo->fragmented)
|
|
|
|
return;
|
1999-08-02 02:26:22 +00:00
|
|
|
|
2003-03-04 19:50:23 +00:00
|
|
|
if (!next_tvb)
|
2009-08-16 12:36:22 +00:00
|
|
|
next_tvb = tvb_new_subset_remaining(tvb, localoffset);
|
2001-11-15 21:11:01 +00:00
|
|
|
|
2003-01-06 02:24:57 +00:00
|
|
|
saved_private_data = pinfo->private_data;
|
|
|
|
pinfo->private_data = &q_bit_set;
|
2001-11-15 21:11:01 +00:00
|
|
|
|
2002-11-08 01:00:07 +00:00
|
|
|
/* See if there's already a dissector for this circuit. */
|
2003-01-06 02:24:57 +00:00
|
|
|
if (try_circuit_dissector(CT_X25, vc, pinfo->fd->num, next_tvb, pinfo,
|
|
|
|
tree)) {
|
|
|
|
pinfo->private_data = saved_private_data;
|
|
|
|
return; /* found it and dissected it */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Did the user suggest QLLC/SNA? */
|
|
|
|
if (payload_is_qllc_sna) {
|
|
|
|
/* Yes - dissect it as QLLC/SNA. */
|
2003-01-11 10:03:12 +00:00
|
|
|
if (!pinfo->fd->flags.visited)
|
|
|
|
x25_hash_add_proto_start(vc, pinfo->fd->num, qllc_handle);
|
2003-01-06 02:24:57 +00:00
|
|
|
call_dissector(qllc_handle, next_tvb, pinfo, tree);
|
|
|
|
pinfo->private_data = saved_private_data;
|
2001-12-05 08:43:26 +00:00
|
|
|
return;
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
2001-12-05 08:43:26 +00:00
|
|
|
|
2008-03-16 10:19:51 +00:00
|
|
|
if (payload_check_data){
|
2003-01-06 02:24:57 +00:00
|
|
|
/* If the Call Req. has not been captured, let's look at the first
|
2007-08-18 22:56:44 +00:00
|
|
|
two bytes of the payload to see if this looks like COTP. */
|
|
|
|
if (tvb_get_guint8(tvb, localoffset) == tvb_length(next_tvb)-1) {
|
|
|
|
/* First byte contains the length of the remaining buffer */
|
|
|
|
if ((tvb_get_guint8(tvb, localoffset+1) & 0x0F) == 0) {
|
|
|
|
/* Second byte contains a valid COTP TPDU */
|
|
|
|
if (!pinfo->fd->flags.visited)
|
|
|
|
x25_hash_add_proto_start(vc, pinfo->fd->num, ositp_handle);
|
|
|
|
call_dissector(ositp_handle, next_tvb, pinfo, tree);
|
|
|
|
pinfo->private_data = saved_private_data;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Then let's look at the first byte of the payload to see if this
|
|
|
|
looks like IP or CLNP. */
|
2003-01-06 02:24:57 +00:00
|
|
|
switch (tvb_get_guint8(tvb, localoffset)) {
|
|
|
|
|
|
|
|
case 0x45:
|
|
|
|
/* Looks like an IP header */
|
2003-01-11 10:03:12 +00:00
|
|
|
if (!pinfo->fd->flags.visited)
|
|
|
|
x25_hash_add_proto_start(vc, pinfo->fd->num, ip_handle);
|
2001-12-05 08:43:26 +00:00
|
|
|
call_dissector(ip_handle, next_tvb, pinfo, tree);
|
2003-01-06 02:24:57 +00:00
|
|
|
pinfo->private_data = saved_private_data;
|
|
|
|
return;
|
|
|
|
|
|
|
|
case NLPID_ISO8473_CLNP:
|
2003-01-11 10:03:12 +00:00
|
|
|
if (!pinfo->fd->flags.visited)
|
|
|
|
x25_hash_add_proto_start(vc, pinfo->fd->num, clnp_handle);
|
2003-01-06 02:24:57 +00:00
|
|
|
call_dissector(clnp_handle, next_tvb, pinfo, tree);
|
|
|
|
pinfo->private_data = saved_private_data;
|
2001-12-05 08:43:26 +00:00
|
|
|
return;
|
|
|
|
}
|
2008-03-16 10:19:51 +00:00
|
|
|
}
|
2001-12-05 08:43:26 +00:00
|
|
|
|
|
|
|
/* Try the heuristic dissectors. */
|
|
|
|
if (dissector_try_heuristic(x25_heur_subdissector_list, next_tvb, pinfo,
|
2012-09-11 08:26:48 +00:00
|
|
|
tree, NULL)) {
|
2003-01-06 02:24:57 +00:00
|
|
|
pinfo->private_data = saved_private_data;
|
2001-12-05 08:43:26 +00:00
|
|
|
return;
|
2003-01-06 02:24:57 +00:00
|
|
|
}
|
2001-12-05 08:43:26 +00:00
|
|
|
|
|
|
|
/* All else failed; dissect it as raw data */
|
|
|
|
call_dissector(data_handle, next_tvb, pinfo, tree);
|
2003-01-06 02:24:57 +00:00
|
|
|
pinfo->private_data = saved_private_data;
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
|
|
|
|
2002-04-09 08:15:04 +00:00
|
|
|
/*
|
|
|
|
* X.25 dissector for use when "pinfo->pseudo_header" points to a
|
|
|
|
* "struct x25_phdr".
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
dissect_x25_dir(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
|
|
|
dissect_x25_common(tvb, pinfo, tree,
|
|
|
|
(pinfo->pseudo_header->x25.flags & FROM_DCE) ? X25_FROM_DCE :
|
2003-03-05 05:20:38 +00:00
|
|
|
X25_FROM_DTE,
|
|
|
|
pinfo->pseudo_header->x25.flags & FROM_DCE);
|
2002-04-09 08:15:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* X.25 dissector for use when "pinfo->pseudo_header" doesn't point to a
|
|
|
|
* "struct x25_phdr".
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
dissect_x25(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
2003-03-05 05:20:38 +00:00
|
|
|
int direction;
|
|
|
|
|
2002-04-09 08:15:04 +00:00
|
|
|
/*
|
|
|
|
* We don't know if this packet is DTE->DCE or DCE->DCE.
|
2003-03-05 05:20:38 +00:00
|
|
|
* However, we can, at least, distinguish between the two
|
|
|
|
* sides of the conversation, based on the addresses and
|
|
|
|
* ports.
|
2002-04-09 08:15:04 +00:00
|
|
|
*/
|
2003-03-05 05:20:38 +00:00
|
|
|
direction = CMP_ADDRESS(&pinfo->src, &pinfo->dst);
|
|
|
|
if (direction == 0)
|
|
|
|
direction = (pinfo->srcport > pinfo->destport)*2 - 1;
|
|
|
|
dissect_x25_common(tvb, pinfo, tree, X25_UNKNOWN, direction > 0);
|
2002-04-09 08:15:04 +00:00
|
|
|
}
|
|
|
|
|
2003-03-04 19:50:23 +00:00
|
|
|
static void
|
|
|
|
x25_reassemble_init(void)
|
|
|
|
{
|
|
|
|
fragment_table_init(&x25_segment_table);
|
|
|
|
reassembled_table_init(&x25_reassembled_table);
|
|
|
|
}
|
|
|
|
|
1999-08-02 02:26:22 +00:00
|
|
|
void
|
|
|
|
proto_register_x25(void)
|
|
|
|
{
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
static hf_register_info hf[] = {
|
2012-09-27 04:05:01 +00:00
|
|
|
{ &hf_x25_facility,
|
|
|
|
{ "Facility", "x25.facility", FT_UINT8, BASE_HEX, NULL, 0,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_x25_facility_class,
|
|
|
|
{ "Facility Class", "x25.facility.class", FT_UINT8, BASE_HEX, VALS(x25_facilities_class_vals), X25_FAC_CLASS_MASK,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_x25_facility_classA,
|
|
|
|
{ "Code", "x25.facility.classA", FT_UINT8, BASE_HEX, VALS(x25_facilities_classA_vals), 0,
|
|
|
|
"Facility ClassA Code", HFILL }},
|
|
|
|
{ &hf_x25_facility_classA_comp_mark,
|
|
|
|
{ "Parameter", "x25.facility.comp_mark", FT_UINT8, BASE_DEC, VALS(x25_facilities_classA_comp_mark_vals), 0,
|
|
|
|
"Facility Marker Parameter", HFILL }},
|
|
|
|
{ &hf_x25_facility_classA_reverse,
|
|
|
|
{ "Parameter", "x25.facility.reverse", FT_UINT8, BASE_HEX, NULL, 0,
|
|
|
|
"Facility Reverse Charging Parameter", HFILL }},
|
|
|
|
{ &hf_x25_facility_classA_charging_info,
|
|
|
|
{ "Parameter", "x25.facility.charging_info", FT_UINT8, BASE_HEX, NULL, 0,
|
|
|
|
"Facility Charging Information Parameter", HFILL }},
|
|
|
|
{ &hf_x25_reverse_charging,
|
|
|
|
{ "Reverse charging", "x25.reverse_charging", FT_BOOLEAN, 8, TFS(&x25_reverse_charging_val), 0x01,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_x25_charging_info,
|
|
|
|
{ "Charging information", "x25.charging_info", FT_BOOLEAN, 8, TFS(&tfs_requested_not_requested), 0x01,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_x25_throughput_called_dte,
|
|
|
|
{ "From the called DTE", "x25.facility.throughput.called_dte", FT_UINT8, BASE_DEC, VALS(x25_facilities_classA_throughput_vals), 0xF0,
|
|
|
|
"Facility Throughput called DTE", HFILL }},
|
|
|
|
{ &hf_x25_throughput_calling_dte,
|
|
|
|
{ "From the calling DTE", "x25.facility.throughput.called_dte", FT_UINT8, BASE_DEC, VALS(x25_facilities_classA_throughput_vals), 0x0F,
|
|
|
|
"Facility Throughput called DTE", HFILL }},
|
|
|
|
{ &hf_x25_facility_classA_cug,
|
|
|
|
{ "Closed user group", "x25.facility.cug", FT_UINT8, BASE_HEX, NULL, 0,
|
|
|
|
"Facility Closed user group", HFILL }},
|
|
|
|
{ &hf_x25_facility_classA_called_motif,
|
|
|
|
{ "Parameter", "x25.facility.called_motif", FT_UINT8, BASE_HEX, NULL, 0,
|
|
|
|
"Facility Called address modified parameter", HFILL }},
|
|
|
|
{ &hf_x25_facility_classA_cug_outgoing_acc,
|
|
|
|
{ "Closed user group", "x25.facility.cug_outgoing_acc", FT_UINT8, BASE_HEX, NULL, 0,
|
|
|
|
"Facility Closed user group with outgoing access selection", HFILL }},
|
|
|
|
{ &hf_x25_facility_classA_throughput_min,
|
|
|
|
{ "Parameter", "x25.facility.throughput_min", FT_UINT8, BASE_HEX, NULL, 0,
|
|
|
|
"Facility Minimum throughput class parameter", HFILL }},
|
|
|
|
{ &hf_x25_facility_classA_express_data,
|
|
|
|
{ "Parameter", "x25.facility.express_data", FT_UINT8, BASE_HEX, NULL, 0,
|
|
|
|
"Facility Negotiation of express data parameter", HFILL }},
|
|
|
|
{ &hf_x25_facility_classA_unknown,
|
|
|
|
{ "Parameter", "x25.facility.classA_unknown", FT_UINT8, BASE_HEX, NULL, 0,
|
|
|
|
"Facility Class A unknown parameter", HFILL }},
|
|
|
|
{ &hf_x25_facility_classB,
|
|
|
|
{ "Code", "x25.facility.classB", FT_UINT8, BASE_HEX, VALS(x25_facilities_classB_vals), 0,
|
|
|
|
"Facility ClassB Code", HFILL }},
|
|
|
|
{ &hf_x25_facility_classB_bilateral_cug,
|
|
|
|
{ "Bilateral CUG", "x25.facility.bilateral_cug", FT_UINT16, BASE_HEX, NULL, 0,
|
|
|
|
"Facility Bilateral CUG", HFILL }},
|
|
|
|
{ &hf_x25_facility_packet_size_called_dte,
|
|
|
|
{ "From the called DTE", "x25.facility.packet_size.called_dte", FT_UINT8, BASE_DEC, VALS(x25_facilities_classB_packet_size_vals), 0,
|
|
|
|
"Facility Packet size from the called DTE", HFILL }},
|
|
|
|
{ &hf_x25_facility_packet_size_calling_dte,
|
|
|
|
{ "From the calling DTE", "x25.facility.packet_size.calling_dte", FT_UINT8, BASE_DEC, VALS(x25_facilities_classB_packet_size_vals), 0,
|
|
|
|
"Facility Packet size from the calling DTE", HFILL }},
|
|
|
|
{ &hf_x25_facility_data_network_id_code,
|
|
|
|
{ "Data network identification code", "x25.facility.data_network_id_code", FT_UINT16, BASE_HEX, NULL, 0,
|
|
|
|
"Facility RPOA selection data network identification code", HFILL }},
|
|
|
|
{ &hf_x25_facility_cug_ext,
|
|
|
|
{ "Closed user group", "x25.facility.cug_ext", FT_UINT16, BASE_HEX, NULL, 0,
|
|
|
|
"Facility Extended closed user group selection", HFILL }},
|
|
|
|
{ &hf_x25_facility_cug_outgoing_acc_ext,
|
|
|
|
{ "Closed user group", "x25.facility.cug_outgoing_acc_ext", FT_UINT16, BASE_HEX, NULL, 0,
|
|
|
|
"Facility Extended closed user group with outgoing access selection", HFILL }},
|
|
|
|
{ &hf_x25_facility_transit_delay,
|
|
|
|
{ "Transit delay (ms)", "x25.facility.transit_delay", FT_UINT16, BASE_DEC, NULL, 0,
|
|
|
|
"Facility Transit delay selection and indication", HFILL }},
|
|
|
|
{ &hf_x25_facility_classB_unknown,
|
|
|
|
{ "Parameter", "x25.facility.classB_unknown", FT_UINT16, BASE_HEX, NULL, 0,
|
|
|
|
"Facility Class B unknown parameter", HFILL }},
|
|
|
|
{ &hf_x25_facility_classC_unknown,
|
|
|
|
{ "Parameter", "x25.facility.classC_unknown", FT_UINT24, BASE_HEX, NULL, 0,
|
|
|
|
"Facility Class C unknown parameter", HFILL }},
|
|
|
|
{ &hf_x25_facility_classC,
|
|
|
|
{ "Code", "x25.facility.classC", FT_UINT8, BASE_HEX, VALS(x25_facilities_classC_vals), 0,
|
|
|
|
"Facility ClassC Code", HFILL }},
|
|
|
|
{ &hf_x25_facility_classD,
|
|
|
|
{ "Code", "x25.facility.classD", FT_UINT8, BASE_HEX, VALS(x25_facilities_classD_vals), 0,
|
|
|
|
"Facility ClassD Code", HFILL }},
|
2001-01-03 23:30:50 +00:00
|
|
|
{ &hf_x25_gfi,
|
2009-03-03 22:00:10 +00:00
|
|
|
{ "GFI", "x25.gfi", FT_UINT16, BASE_DEC, NULL, 0xF000,
|
2001-06-18 02:18:27 +00:00
|
|
|
"General format identifier", HFILL }},
|
2001-01-03 23:30:50 +00:00
|
|
|
{ &hf_x25_abit,
|
2009-03-03 22:00:10 +00:00
|
|
|
{ "A Bit", "x25.a", FT_BOOLEAN, 16, NULL, X25_ABIT,
|
2001-06-18 02:18:27 +00:00
|
|
|
"Address Bit", HFILL }},
|
1999-10-18 01:51:34 +00:00
|
|
|
{ &hf_x25_qbit,
|
2009-03-03 22:00:10 +00:00
|
|
|
{ "Q Bit", "x25.q", FT_BOOLEAN, 16, NULL, X25_QBIT,
|
2001-06-18 02:18:27 +00:00
|
|
|
"Qualifier Bit", HFILL }},
|
2000-05-28 06:26:10 +00:00
|
|
|
{ &hf_x25_dbit,
|
2009-03-03 22:00:10 +00:00
|
|
|
{ "D Bit", "x25.d", FT_BOOLEAN, 16, NULL, X25_DBIT,
|
2001-06-18 02:18:27 +00:00
|
|
|
"Delivery Confirmation Bit", HFILL }},
|
1999-10-18 01:51:34 +00:00
|
|
|
{ &hf_x25_mod,
|
2009-03-03 22:00:10 +00:00
|
|
|
{ "Modulo", "x25.mod", FT_UINT16, BASE_DEC, VALS(vals_modulo), 0x3000,
|
2001-06-18 02:18:27 +00:00
|
|
|
"Specifies whether the frame is modulo 8 or 128", HFILL }},
|
1999-08-02 02:26:22 +00:00
|
|
|
{ &hf_x25_lcn,
|
2009-03-03 22:00:10 +00:00
|
|
|
{ "Logical Channel", "x25.lcn", FT_UINT16, BASE_DEC, NULL, 0x0FFF,
|
2001-06-18 02:18:27 +00:00
|
|
|
"Logical Channel Number", HFILL }},
|
1999-08-02 02:26:22 +00:00
|
|
|
{ &hf_x25_type,
|
2009-03-03 22:00:10 +00:00
|
|
|
{ "Packet Type", "x25.type", FT_UINT8, BASE_HEX, VALS(vals_x25_type), 0x0,
|
From Kovarththanan Rajaratnam via bug 3548:
(1) Trailing/leading spaces are removed from 'name's/'blurb's
(2) Duplicate 'blurb's are replaced with NULL
(3) Empty ("") 'blurb's are replaced with NULL
(4) BASE_NONE, NULL, 0x0 are used for 'display', 'strings' and 'bitmask' fields
for FT_NONE, FT_BYTES, FT_IPv4, FT_IPv6, FT_ABSOLUTE_TIME, FT_RELATIVE_TIME,
FT_PROTOCOL, FT_STRING and FT_STRINGZ field types
(5) Only allow non-zero value for 'display' if 'bitmask' is non-zero
svn path=/trunk/; revision=28770
2009-06-18 21:30:42 +00:00
|
|
|
NULL, HFILL }},
|
2003-01-08 08:43:09 +00:00
|
|
|
{ &hf_x25_type_fc_mod8,
|
2009-03-03 22:00:10 +00:00
|
|
|
{ "Packet Type", "x25.type", FT_UINT8, BASE_HEX, VALS(vals_x25_type), 0x1F,
|
From Kovarththanan Rajaratnam via bug 3548:
(1) Trailing/leading spaces are removed from 'name's/'blurb's
(2) Duplicate 'blurb's are replaced with NULL
(3) Empty ("") 'blurb's are replaced with NULL
(4) BASE_NONE, NULL, 0x0 are used for 'display', 'strings' and 'bitmask' fields
for FT_NONE, FT_BYTES, FT_IPv4, FT_IPv6, FT_ABSOLUTE_TIME, FT_RELATIVE_TIME,
FT_PROTOCOL, FT_STRING and FT_STRINGZ field types
(5) Only allow non-zero value for 'display' if 'bitmask' is non-zero
svn path=/trunk/; revision=28770
2009-06-18 21:30:42 +00:00
|
|
|
NULL, HFILL }},
|
2003-01-08 08:43:09 +00:00
|
|
|
{ &hf_x25_type_data,
|
2009-03-03 22:00:10 +00:00
|
|
|
{ "Packet Type", "x25.type", FT_UINT8, BASE_HEX, VALS(vals_x25_type), 0x01,
|
From Kovarththanan Rajaratnam via bug 3548:
(1) Trailing/leading spaces are removed from 'name's/'blurb's
(2) Duplicate 'blurb's are replaced with NULL
(3) Empty ("") 'blurb's are replaced with NULL
(4) BASE_NONE, NULL, 0x0 are used for 'display', 'strings' and 'bitmask' fields
for FT_NONE, FT_BYTES, FT_IPv4, FT_IPv6, FT_ABSOLUTE_TIME, FT_RELATIVE_TIME,
FT_PROTOCOL, FT_STRING and FT_STRINGZ field types
(5) Only allow non-zero value for 'display' if 'bitmask' is non-zero
svn path=/trunk/; revision=28770
2009-06-18 21:30:42 +00:00
|
|
|
NULL, HFILL }},
|
2012-09-27 04:05:01 +00:00
|
|
|
{ &hf_x25_diagnostic,
|
|
|
|
{ "Diagnostic", "x25.diagnostic", FT_UINT8, BASE_DEC|BASE_EXT_STRING, &x25_clear_diag_vals_ext, 0,
|
|
|
|
NULL, HFILL }},
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
{ &hf_x25_p_r_mod8,
|
2009-03-03 22:00:10 +00:00
|
|
|
{ "P(R)", "x25.p_r", FT_UINT8, BASE_DEC, NULL, 0xE0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"Packet Receive Sequence Number", HFILL }},
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
{ &hf_x25_p_r_mod128,
|
2009-03-03 22:00:10 +00:00
|
|
|
{ "P(R)", "x25.p_r", FT_UINT8, BASE_DEC, NULL, 0xFE,
|
2001-06-18 02:18:27 +00:00
|
|
|
"Packet Receive Sequence Number", HFILL }},
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
{ &hf_x25_mbit_mod8,
|
2009-03-03 22:00:10 +00:00
|
|
|
{ "M Bit", "x25.m", FT_BOOLEAN, 8, TFS(&m_bit_tfs), X25_MBIT_MOD8,
|
2001-06-18 02:18:27 +00:00
|
|
|
"More Bit", HFILL }},
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
{ &hf_x25_mbit_mod128,
|
2009-03-03 22:00:10 +00:00
|
|
|
{ "M Bit", "x25.m", FT_BOOLEAN, 8, TFS(&m_bit_tfs), X25_MBIT_MOD128,
|
2001-06-18 02:18:27 +00:00
|
|
|
"More Bit", HFILL }},
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
{ &hf_x25_p_s_mod8,
|
2009-03-03 22:00:10 +00:00
|
|
|
{ "P(S)", "x25.p_s", FT_UINT8, BASE_DEC, NULL, 0x0E,
|
2001-06-18 02:18:27 +00:00
|
|
|
"Packet Send Sequence Number", HFILL }},
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
{ &hf_x25_p_s_mod128,
|
2009-03-03 22:00:10 +00:00
|
|
|
{ "P(S)", "x25.p_s", FT_UINT8, BASE_DEC, NULL, 0xFE,
|
2001-06-18 02:18:27 +00:00
|
|
|
"Packet Send Sequence Number", HFILL }},
|
2012-09-27 04:05:01 +00:00
|
|
|
{ &hf_x25_window_size_called_dte,
|
|
|
|
{ "From the called DTE", "x25.window_size.called_dte", FT_UINT8, BASE_DEC, NULL, 0x7F,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_x25_window_size_calling_dte,
|
|
|
|
{ "From the calling DTE", "x25.window_size.calling_dte", FT_UINT8, BASE_DEC, NULL, 0x7F,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_x25_dte_address_length,
|
|
|
|
{ "DTE address length", "x25.dte_address_length", FT_UINT8, BASE_DEC, NULL, 0xF0,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_x25_dce_address_length,
|
|
|
|
{ "DCE address length", "x25.dce_address_length", FT_UINT8, BASE_DEC, NULL, 0x0F,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_x25_calling_address_length,
|
|
|
|
{ "Calling address length", "x25.calling_address_length", FT_UINT8, BASE_DEC, NULL, 0xF0,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_x25_called_address_length,
|
|
|
|
{ "Called address length", "x25.called_address_length", FT_UINT8, BASE_DEC, NULL, 0x0F,
|
|
|
|
NULL, HFILL }},
|
2003-03-04 19:50:23 +00:00
|
|
|
{ &hf_x25_segment_overlap,
|
|
|
|
{ "Fragment overlap", "x25.fragment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
|
|
|
|
"Fragment overlaps with other fragments", HFILL }},
|
2011-10-21 02:10:19 +00:00
|
|
|
|
2003-03-04 19:50:23 +00:00
|
|
|
{ &hf_x25_segment_overlap_conflict,
|
|
|
|
{ "Conflicting data in fragment overlap", "x25.fragment.overlap.conflict", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
|
|
|
|
"Overlapping fragments contained conflicting data", HFILL }},
|
2011-10-21 02:10:19 +00:00
|
|
|
|
2003-03-04 19:50:23 +00:00
|
|
|
{ &hf_x25_segment_multiple_tails,
|
|
|
|
{ "Multiple tail fragments found", "x25.fragment.multipletails", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
|
|
|
|
"Several tails were found when defragmenting the packet", HFILL }},
|
2011-10-21 02:10:19 +00:00
|
|
|
|
2003-03-04 19:50:23 +00:00
|
|
|
{ &hf_x25_segment_too_long_segment,
|
|
|
|
{ "Fragment too long", "x25.fragment.toolongfragment", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
|
|
|
|
"Fragment contained data past end of packet", HFILL }},
|
2011-10-21 02:10:19 +00:00
|
|
|
|
2003-03-04 19:50:23 +00:00
|
|
|
{ &hf_x25_segment_error,
|
|
|
|
{ "Defragmentation error", "x25.fragment.error", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
|
|
|
|
"Defragmentation error due to illegal fragments", HFILL }},
|
2011-10-21 02:10:19 +00:00
|
|
|
|
2011-01-30 21:01:07 +00:00
|
|
|
{ &hf_x25_segment_count,
|
|
|
|
{ "Fragment count", "x25.fragment.count", FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
|
|
NULL, HFILL }},
|
2011-10-21 02:10:19 +00:00
|
|
|
|
2010-02-02 16:01:52 +00:00
|
|
|
{ &hf_x25_reassembled_length,
|
2010-02-02 22:32:31 +00:00
|
|
|
{ "Reassembled X.25 length", "x25.reassembled.length", FT_UINT32, BASE_DEC, NULL, 0x0,
|
2010-02-02 16:01:52 +00:00
|
|
|
"The total length of the reassembled payload", HFILL }},
|
2011-10-21 02:10:19 +00:00
|
|
|
|
2003-03-04 19:50:23 +00:00
|
|
|
{ &hf_x25_segment,
|
|
|
|
{ "X.25 Fragment", "x25.fragment", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
|
|
|
|
"X25 Fragment", HFILL }},
|
2011-10-21 02:10:19 +00:00
|
|
|
|
2003-03-04 19:50:23 +00:00
|
|
|
{ &hf_x25_segments,
|
|
|
|
{ "X.25 Fragments", "x25.fragments", FT_NONE, BASE_NONE, NULL, 0x0,
|
From Kovarththanan Rajaratnam via bug 3548:
(1) Trailing/leading spaces are removed from 'name's/'blurb's
(2) Duplicate 'blurb's are replaced with NULL
(3) Empty ("") 'blurb's are replaced with NULL
(4) BASE_NONE, NULL, 0x0 are used for 'display', 'strings' and 'bitmask' fields
for FT_NONE, FT_BYTES, FT_IPv4, FT_IPv6, FT_ABSOLUTE_TIME, FT_RELATIVE_TIME,
FT_PROTOCOL, FT_STRING and FT_STRINGZ field types
(5) Only allow non-zero value for 'display' if 'bitmask' is non-zero
svn path=/trunk/; revision=28770
2009-06-18 21:30:42 +00:00
|
|
|
NULL, HFILL }},
|
2012-04-28 17:34:23 +00:00
|
|
|
|
|
|
|
{ &hf_x25_fast_select,
|
2012-04-28 17:42:55 +00:00
|
|
|
{ "Fast select", "x25.fast_select", FT_UINT8, BASE_DEC, VALS(x25_fast_select_vals), 0xC0,
|
2012-04-28 17:34:23 +00:00
|
|
|
NULL, HFILL }},
|
|
|
|
|
|
|
|
{ &hf_x25_icrd,
|
2012-04-28 17:42:55 +00:00
|
|
|
{ "ICRD", "x25.icrd", FT_UINT8, BASE_DEC, VALS(x25_icrd_vals), 0x30,
|
2012-04-28 17:34:23 +00:00
|
|
|
NULL, HFILL }},
|
|
|
|
|
2012-09-27 04:05:01 +00:00
|
|
|
{ &hf_x25_reg_confirm_cause,
|
|
|
|
{ "Cause", "x25.reg_confirm.cause", FT_UINT8, BASE_DEC, VALS(x25_registration_code_vals), 0,
|
2012-04-28 17:34:23 +00:00
|
|
|
NULL, HFILL }},
|
2012-09-23 00:12:14 +00:00
|
|
|
|
2012-09-27 04:05:01 +00:00
|
|
|
{ &hf_x25_reg_confirm_diagnostic,
|
|
|
|
{ "Diagnostic", "x25.reg_confirm.diagnostic", FT_UINT8, BASE_DEC, VALS(x25_registration_code_vals), 0,
|
2012-09-23 00:12:14 +00:00
|
|
|
NULL, HFILL }},
|
1999-08-02 02:26:22 +00:00
|
|
|
};
|
2012-09-27 04:05:01 +00:00
|
|
|
|
1999-11-16 11:44:20 +00:00
|
|
|
static gint *ett[] = {
|
|
|
|
&ett_x25,
|
2001-01-03 23:30:50 +00:00
|
|
|
&ett_x25_gfi,
|
1999-12-12 12:59:01 +00:00
|
|
|
&ett_x25_fac,
|
2012-09-27 04:05:01 +00:00
|
|
|
&ett_x25_facility,
|
1999-12-12 12:59:01 +00:00
|
|
|
&ett_x25_fac_unknown,
|
|
|
|
&ett_x25_fac_mark,
|
|
|
|
&ett_x25_fac_reverse,
|
2008-04-12 13:41:53 +00:00
|
|
|
&ett_x25_fac_charging_info,
|
1999-12-12 12:59:01 +00:00
|
|
|
&ett_x25_fac_throughput,
|
|
|
|
&ett_x25_fac_cug,
|
|
|
|
&ett_x25_fac_called_modif,
|
|
|
|
&ett_x25_fac_cug_outgoing_acc,
|
|
|
|
&ett_x25_fac_throughput_min,
|
|
|
|
&ett_x25_fac_express_data,
|
|
|
|
&ett_x25_fac_bilateral_cug,
|
|
|
|
&ett_x25_fac_packet_size,
|
|
|
|
&ett_x25_fac_window_size,
|
|
|
|
&ett_x25_fac_rpoa_selection,
|
2008-04-12 13:41:53 +00:00
|
|
|
&ett_x25_fac_cug_ext,
|
|
|
|
&ett_x25_fac_cug_outgoing_acc_ext,
|
1999-12-12 12:59:01 +00:00
|
|
|
&ett_x25_fac_transit_delay,
|
2008-04-12 13:41:53 +00:00
|
|
|
&ett_x25_fac_call_duration,
|
|
|
|
&ett_x25_fac_segment_count,
|
1999-12-12 12:59:01 +00:00
|
|
|
&ett_x25_fac_call_transfer,
|
2008-04-12 13:41:53 +00:00
|
|
|
&ett_x25_fac_rpoa_selection_ext,
|
|
|
|
&ett_x25_fac_monetary_unit,
|
|
|
|
&ett_x25_fac_nui,
|
1999-12-12 12:59:01 +00:00
|
|
|
&ett_x25_fac_called_addr_ext,
|
|
|
|
&ett_x25_fac_ete_transit_delay,
|
|
|
|
&ett_x25_fac_calling_addr_ext,
|
|
|
|
&ett_x25_fac_call_deflect,
|
2001-12-02 00:07:46 +00:00
|
|
|
&ett_x25_fac_priority,
|
2003-03-04 19:50:23 +00:00
|
|
|
&ett_x25_user_data,
|
|
|
|
&ett_x25_segment,
|
|
|
|
&ett_x25_segments
|
1999-11-16 11:44:20 +00:00
|
|
|
};
|
2001-11-15 21:11:01 +00:00
|
|
|
module_t *x25_module;
|
1999-08-02 02:26:22 +00:00
|
|
|
|
2009-03-03 22:00:10 +00:00
|
|
|
proto_x25 = proto_register_protocol ("X.25", "X.25", "x25");
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
proto_register_field_array (proto_x25, hf, array_length(hf));
|
1999-11-16 11:44:20 +00:00
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
|
2001-12-08 06:41:48 +00:00
|
|
|
x25_subdissector_table = register_dissector_table("x.25.spi",
|
|
|
|
"X.25 secondary protocol identifier", FT_UINT8, BASE_HEX);
|
2001-12-05 08:43:26 +00:00
|
|
|
register_heur_dissector_list("x.25", &x25_heur_subdissector_list);
|
2001-12-02 00:07:46 +00:00
|
|
|
|
2002-04-09 08:15:04 +00:00
|
|
|
register_dissector("x.25_dir", dissect_x25_dir, proto_x25);
|
If you register more than one field with the same name, the dfilter code
can now handle that; this allows us to register both the modulo-8 and
the modulo-128 versions of various X.25 bitfields with "x.25.XXX" names,
which lets us get rid of the "ex.25" protocol stuff completely and use
"x.25" for both modulo-8 and modulo-128 X.25. Do so. (Also, fix up
some cases where we appeared to be using the modulo-8 fields when
dissecting modulo-128 X.25.)
This, in turn, allows us to register the X.25 dissector, as there's now
only one protocol with which it's associated, and make it static and
have it called only through a handle, and to, when registering it with
the "llc.dsap" dissector table, associate it with "proto_x25".
That, in turn, allows us to get rid of the "CHECK_DISPLAY_AS_DATA()"
calls, and the code to set "pinfo->current_proto", in the X.25
dissector.
The code for the display filter expression dialog would, if there are
two fields with the same name registered under a protocol, list both of
them; have it list only one of them - the fields should have the same
type, the same radix, and the same value_string/true_false_string table
if any (if they don't, they're really not the same field...).
svn path=/trunk/; revision=3023
2001-02-12 09:06:19 +00:00
|
|
|
register_dissector("x.25", dissect_x25, proto_x25);
|
2001-11-15 21:11:01 +00:00
|
|
|
|
|
|
|
/* Preferences */
|
|
|
|
x25_module = prefs_register_protocol(proto_x25, NULL);
|
2003-01-06 02:24:57 +00:00
|
|
|
prefs_register_obsolete_preference(x25_module, "non_q_bit_is_sna");
|
|
|
|
prefs_register_bool_preference(x25_module, "payload_is_qllc_sna",
|
|
|
|
"Default to QLLC/SNA",
|
|
|
|
"If CALL REQUEST not seen or didn't specify protocol, dissect as QLLC/SNA",
|
|
|
|
&payload_is_qllc_sna);
|
2008-03-16 10:19:51 +00:00
|
|
|
prefs_register_bool_preference(x25_module, "call_request_nodata_is_cotp",
|
|
|
|
"Assume COTP for Call Request without data",
|
|
|
|
"If CALL REQUEST has no data, assume the protocol handled is COTP",
|
|
|
|
&call_request_nodata_is_cotp);
|
|
|
|
prefs_register_bool_preference(x25_module, "payload_check_data",
|
|
|
|
"Check data for COTP/IP/CLNP",
|
|
|
|
"If CALL REQUEST not seen or didn't specify protocol, check user data before checking heuristic dissectors",
|
|
|
|
&payload_check_data);
|
2003-03-05 01:12:11 +00:00
|
|
|
prefs_register_bool_preference(x25_module, "reassemble",
|
2003-03-04 19:50:23 +00:00
|
|
|
"Reassemble fragmented X.25 packets",
|
|
|
|
"Reassemble fragmented X.25 packets",
|
|
|
|
&reassemble_x25);
|
|
|
|
register_init_routine(&x25_reassemble_init);
|
1999-08-02 02:26:22 +00:00
|
|
|
}
|
2000-11-19 04:14:26 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
proto_reg_handoff_x25(void)
|
|
|
|
{
|
2001-12-03 04:00:26 +00:00
|
|
|
dissector_handle_t x25_handle;
|
|
|
|
|
2000-11-19 04:14:26 +00:00
|
|
|
/*
|
2001-12-02 00:07:46 +00:00
|
|
|
* Get handles for various dissectors.
|
2000-11-19 04:14:26 +00:00
|
|
|
*/
|
2001-12-03 05:07:18 +00:00
|
|
|
ip_handle = find_dissector("ip");
|
2003-01-06 02:24:57 +00:00
|
|
|
clnp_handle = find_dissector("clnp");
|
2000-11-19 04:14:26 +00:00
|
|
|
ositp_handle = find_dissector("ositp");
|
2001-11-15 21:11:01 +00:00
|
|
|
qllc_handle = find_dissector("qllc");
|
2001-11-25 22:19:25 +00:00
|
|
|
data_handle = find_dissector("data");
|
2001-01-05 19:07:38 +00:00
|
|
|
|
2001-12-03 04:00:26 +00:00
|
|
|
x25_handle = find_dissector("x.25");
|
2010-12-20 05:35:29 +00:00
|
|
|
dissector_add_uint("llc.dsap", SAP_X25, x25_handle);
|
2012-07-24 11:47:23 +00:00
|
|
|
dissector_add_uint("lapd.sapi", LAPD_SAPI_X25, x25_handle);
|
2012-08-03 01:58:12 +00:00
|
|
|
dissector_add_uint("ax25.pid", AX25_P_ROSE, x25_handle);
|
2000-11-19 04:14:26 +00:00
|
|
|
}
|