This saves many dissectors the need to find the data dissector and store a handle to it.
There were also some that were finding it, but not using it.
For others this was the only reason for their handoff function, so it could be eliminated.
Change-Id: I5d3f951ee1daa3d30c060d21bd12bbc881a8027b
Reviewed-on: https://code.wireshark.org/review/14530
Petri-Dish: Michael Mann <mmann78@netscape.net>
Reviewed-by: Michael Mann <mmann78@netscape.net>
bytes_to_str@Base 1.99.2
bytestring_to_str@Base 1.9.1
call_ber_oid_callback@Base 1.9.1
+ call_data_dissector@Base 2.1.0
call_dissector@Base 1.9.1
call_dissector_only@Base 1.9.1
call_dissector_with_data@Base 1.9.1
switch (content_type) {
case CDT_UNDEFINED:
- call_dissector (data_handle, next_tvb, actx->pinfo, top_tree);
+ call_data_dissector(next_tvb, actx->pinfo, top_tree);
break;
case CDT_EXTERNAL:
dissect_unknown_ber (actx->pinfo, next_tvb, 0, top_tree);
dissect_p1_mts_apdu (next_tvb, actx->pinfo, top_tree, NULL);
break;
default:
- call_dissector (data_handle, next_tvb, actx->pinfo, top_tree);
+ call_data_dissector(next_tvb, actx->pinfo, top_tree);
break;
}
static int proto_cdt = -1;
#include "packet-cdt-hf.c"
-static dissector_handle_t data_handle = NULL;
-
/* Initialize the subtree pointers */
#include "packet-cdt-ett.c"
/*--- proto_reg_handoff_cdt ---------------------------------------*/
void proto_reg_handoff_cdt (void) {
#include "packet-cdt-dis-tab.c"
-
- data_handle = find_dissector ("data");
}
if (actx->external.direct_ref_present){
offset=call_ber_oid_callback(actx->external.direct_reference, tvb, offset, actx->pinfo, ext_tree, NULL);
}else{
- call_dissector(data_handle, tvb, actx->pinfo, ext_tree);
+ call_data_dissector(tvb, actx->pinfo, ext_tree);
offset = tvb_reported_length_remaining(tvb,offset);
}
static expert_field ei_gsm_map_undecoded = EI_INIT;
static dissector_handle_t gsm_sms_handle; /* SMS TPDU */
-static dissector_handle_t data_handle;
static dissector_handle_t ranap_handle;
static dissector_handle_t dtap_handle;
static dissector_handle_t map_handle;
if (!map_prefs_initialized) {
map_prefs_initialized = TRUE;
- data_handle = find_dissector("data");
ranap_handle = find_dissector_add_dependency("ranap", proto_gsm_map);
dtap_handle = find_dissector_add_dependency("gsm_a_dtap", proto_gsm_map);
gsm_sms_handle = find_dissector_add_dependency("gsm_sms", proto_gsm_map);
if (obj_id){
offset=call_ber_oid_callback(obj_id, tvb, offset, actx->pinfo, ext_tree, NULL);
}else{
- call_dissector(data_handle, tvb, actx->pinfo, ext_tree);
+ call_data_dissector(tvb, actx->pinfo, ext_tree);
offset = tvb_reported_length_remaining(tvb,offset);
}
static range_t *global_ssn_range;
static dissector_handle_t inap_handle;
-static dissector_handle_t data_handle;
/* Global variables */
static guint32 opcode=0;
if (!inap_prefs_initialized) {
inap_prefs_initialized = TRUE;
inap_handle = find_dissector("inap");
- data_handle = find_dissector("data");
oid_add_from_string("Core-INAP-CS1-Codes","0.4.0.1.1.0.3.0");
oid_add_from_string("iso(1) identified-organization(3) icd-ecma(12) member-company(2) 1107 oen(3) inap(3) extensions(2)","1.3.12.2.1107.3.3.2");
oid_add_from_string("alcatel(1006)","1.3.12.2.1006.64");
/* Wireshark ID of the tetra protocol */
static int proto_tetra = -1;
-/* These are the handles of our subdissectors */
-static dissector_handle_t data_handle = NULL;
-
static dissector_handle_t tetra_handle;
static int global_tetra_port = 7074;
static gboolean initialized=FALSE;
if (!initialized) {
- data_handle = find_dissector("data");
tetra_handle = create_dissector_handle(dissect_tetra, proto_tetra);
dissector_add_uint("udp.port", global_tetra_port, tetra_handle);
}
#include "file-file.h"
void proto_register_file(void);
-void proto_reg_handoff_file(void);
static int proto_file = -1;
static int hf_file_record_number = -1;
static int file_tap = -1;
-static dissector_handle_t data_handle;
-
dissector_table_t file_encap_dissector_table;
/*
col_set_str(pinfo->cinfo, COL_PROTOCOL, "UNKNOWN");
col_add_fstr(pinfo->cinfo, COL_INFO, "FTAP_ENCAP = %d",
pinfo->pkt_encap);
- call_dissector(data_handle,tvb, pinfo, parent_tree);
+ call_data_dissector(tvb, pinfo, parent_tree);
}
#ifdef _MSC_VER
} __except(EXCEPTION_EXECUTE_HANDLER /* handle all exceptions */) {
file_tap=register_tap("file");
}
-void
-proto_reg_handoff_file(void)
-{
- data_handle = find_dissector("data");
-}
-
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
static dissector_table_t ethertype_subdissector_table;
static dissector_handle_t retix_bpdu_handle;
-static dissector_handle_t data_handle;
/*
* Apparently 3Com had some scheme for encapsulating XNS in 802.2 LLC,
tvb, 0, 2, type);
if (!dissector_try_uint(ethertype_subdissector_table,
type, next_tvb, pinfo, tree))
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
dissector_handle_t our_xns_handle;
retix_bpdu_handle = find_dissector_add_dependency("rbpdu", proto_3com_xns);
- data_handle = find_dissector("data");
ethertype_subdissector_table = find_dissector_table("ethertype");
/* Subdissector handles. */
static dissector_handle_t handle_6lowpan;
-static dissector_handle_t data_handle;
static dissector_handle_t ipv6_handle;
/* Value Strings */
*/
if (!tvb_bytes_exist(tvb, offset, ext_len)) {
/* Call the data dissector for the remainder. */
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo, nhc_tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, nhc_tree);
/* Copy the remainder, and truncate the real buffer length. */
nhdr->length = tvb_captured_length_remaining(tvb, offset) + ext_hlen;
if (ext_proto == IP_PROTO_FRAGMENT) {
/* Display the extension header using the data dissector. */
- call_dissector(data_handle, tvb_new_subset_length(tvb, offset+1, ext_len-1), pinfo, nhc_tree);
+ call_data_dissector(tvb_new_subset_length(tvb, offset+1, ext_len-1), pinfo, nhc_tree);
} else {
/* Display the extension header using the data dissector. */
- call_dissector(data_handle, tvb_new_subset_length(tvb, offset, ext_len), pinfo, nhc_tree);
+ call_data_dissector(tvb_new_subset_length(tvb, offset, ext_len), pinfo, nhc_tree);
}
/* Copy the extension header into the struct. */
/* Reassembly was unsuccessful; show this fragment. This may
just mean that we don't yet have all the fragments, so
we should not just continue dissecting. */
- call_dissector(data_handle, frag_tvb, pinfo, proto_tree_get_root(tree));
+ call_data_dissector(frag_tvb, pinfo, proto_tree_get_root(tree));
return NULL;
}
} /* dissect_6lowpan_frag_first */
/* If reassembly failed, display the payload fragment using the data dissector. */
else {
new_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, new_tvb, pinfo, proto_tree_get_root(tree));
+ call_data_dissector(new_tvb, pinfo, proto_tree_get_root(tree));
return NULL;
}
} /* dissect_6lowpan_frag_middle */
/* Create a tvbuff subset for the remaining data. */
data_tvb = tvb_new_subset_remaining(tvb, 1);
- call_dissector(data_handle, data_tvb, pinfo, proto_tree_get_root(tree));
+ call_data_dissector(data_tvb, pinfo, proto_tree_get_root(tree));
} /* dissect_6lowpan_unknown */
/*FUNCTION:------------------------------------------------------
void
proto_reg_handoff_6lowpan(void)
{
- data_handle = find_dissector("data");
ipv6_handle = find_dissector_add_dependency("ipv6", proto_6lowpan);
/* Register the 6LoWPAN dissector with IEEE 802.15.4 */
static int hf_9P_lock_status = -1;
static int hf_9P_unknown_message = -1;
-/*handle for dissecting data in 9P msgs*/
-static dissector_handle_t data_handle;
-
/* subtree pointers */
static gint ett_9P = -1;
static gint ett_9P_omode = -1;
len = tvb_reported_length_remaining(tvb, offset);
reportedlen = ((gint)u32&0xffff) > len ? len : (gint)u32&0xffff;
next_tvb = tvb_new_subset(tvb, offset, len, reportedlen);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
offset += len;
conv_free_tag(pinfo, tag);
len = tvb_reported_length_remaining(tvb, offset);
reportedlen = ((gint)u32&0xffff) > len ? len : (gint)u32&0xffff;
next_tvb = tvb_new_subset(tvb, offset, len, reportedlen);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
offset += len;
conv_set_tag(pinfo, tag, ninemsg, _9P_NOFID, NULL);
{
dissector_handle_t ninep_handle;
- data_handle = find_dissector("data");
-
ninep_handle = create_dissector_handle(dissect_9P, proto_9P);
dissector_add_uint("tcp.port", NINEPORT, ninep_handle);
static dissector_handle_t adb_cs_handle;
static dissector_handle_t adb_service_handle;
-static dissector_handle_t data_handle;
static wmem_tree_t *client_requests = NULL;
PROTO_ITEM_SET_GENERATED(p_item);
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, main_tree);
+ call_data_dissector(next_tvb, pinfo, main_tree);
offset += tvb_captured_length_remaining(tvb, offset);
}
void
proto_reg_handoff_adb_cs(void)
{
- data_handle = find_dissector("data");
adb_service_handle = find_dissector_add_dependency("adb_service", proto_adb_cs);
dissector_add_for_decode_as("tcp.port", adb_cs_handle);
static gint ett_adwin = -1;
static gint ett_adwin_debug = -1;
-static dissector_handle_t data_handle;
-
/* response/request tracking */
typedef struct _adwin_transaction_t {
guint32 req_frame;
proto_tree_add_item(adwin_tree, hf_adwin_packet_index, tvb, 4, 4, ENC_LITTLE_ENDIAN);
if (! global_adwin_dissect_data) {
- call_dissector(data_handle, tvb_new_subset_length(tvb, 8, 250*4), pinfo, adwin_debug_tree);
+ call_data_dissector(tvb_new_subset_length(tvb, 8, 250*4), pinfo, adwin_debug_tree);
return;
}
proto_tree_add_item(adwin_tree, hf_adwin_packet_no, tvb, 4, 4, ENC_LITTLE_ENDIAN);
if (! global_adwin_dissect_data) {
- call_dissector(data_handle, tvb_new_subset_length(tvb, 8, 350*4), pinfo, adwin_debug_tree);
+ call_data_dissector(tvb_new_subset_length(tvb, 8, 350*4), pinfo, adwin_debug_tree);
return;
}
data_type = tvb_get_letohl(tvb, 1412);
if (! global_adwin_dissect_data) {
- call_dissector(data_handle, tvb_new_subset_length(tvb, 8, 350*4), pinfo, adwin_debug_tree);
+ call_data_dissector(tvb_new_subset_length(tvb, 8, 350*4), pinfo, adwin_debug_tree);
return;
}
proto_tree_add_item(adwin_tree, hf_adwin_unused, tvb, 8, 4, ENC_NA);
if (! global_adwin_dissect_data) {
- call_dissector(data_handle, tvb_new_subset_length(tvb, 12, 336*4), pinfo, adwin_debug_tree);
+ call_data_dissector(tvb_new_subset_length(tvb, 12, 336*4), pinfo, adwin_debug_tree);
return;
}
if (! adwin_prefs_initialized) {
adwin_handle = create_dissector_handle(dissect_adwin, proto_adwin);
- data_handle = find_dissector("data");
adwin_prefs_initialized = TRUE;
} else {
dissector_delete_uint("udp.port", udp_port, adwin_handle);
/* Dissector handles */
static dissector_handle_t aeron_dissector_handle;
-static dissector_handle_t aeron_data_dissector_handle;
static heur_dissector_list_t aeron_heuristic_subdissector_list;
/*----------------------------------------------------------------------------*/
}
if (!dissector_found)
{
- call_dissector(aeron_data_dissector_handle, data_tvb, pinfo, subtree);
+ call_data_dissector(data_tvb, pinfo, subtree);
}
}
aeron_sequence_report(tvb, pinfo, subtree, transport, &pktinfo, finfo);
aeron_dissector_handle = create_dissector_handle(dissect_aeron, proto_aeron);
dissector_add_for_decode_as("udp.port", aeron_dissector_handle);
heur_dissector_add("udp", test_aeron_packet, "Aeron over UDP", "aeron_udp", proto_aeron, HEURISTIC_DISABLE);
- aeron_data_dissector_handle = find_dissector("data");
}
/*
static int afp_tap = -1;
-static dissector_handle_t data_handle;
static dissector_handle_t spotlight_handle;
static const value_string vol_signature_vals[] = {
}
}
if (offset < len) {
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset),
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset),
pinfo, afp_tree);
}
void
proto_reg_handoff_afp(void)
{
- data_handle = find_dissector("data");
spotlight_handle = find_dissector_add_dependency("afp_spotlight", proto_afp);
}
static expert_field ei_ansi_a_unknown_bsmap_msg = EI_INIT;
static expert_field ei_ansi_a_undecoded = EI_INIT;
-static dissector_handle_t data_handle;
static dissector_handle_t dtap_handle;
static dissector_table_t is637_dissector_table; /* IS-637-A Transport Layer (SMS) */
static dissector_table_t is683_dissector_table; /* IS-683-A (OTA) */
/*
* too short to be DTAP
*/
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return;
}
bsmap_handle = create_dissector_handle(dissect_bsmap, proto_a_bsmap);
dtap_handle = create_dissector_handle(dissect_dtap, proto_a_dtap);
sip_dtap_bsmap_handle = create_dissector_handle(dissect_sip_dtap_bsmap, proto_a_dtap);
- data_handle = find_dissector("data");
dissector_add_uint("bsap.pdu_type", BSSAP_PDU_TYPE_BSMAP, bsmap_handle);
dissector_add_uint("bsap.pdu_type", BSSAP_PDU_TYPE_DTAP, dtap_handle);
static dissector_table_t ethertype_subdissector_table;
-static dissector_handle_t data_handle;
-
static gboolean
capture_ap1394(const guchar *pd, int offset, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header _U_)
{
if (!dissector_try_uint(ethertype_subdissector_table, etype, next_tvb,
pinfo, tree))
{
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
{
dissector_handle_t ap1394_handle;
- data_handle = find_dissector("data");
-
ethertype_subdissector_table = find_dissector_table("ethertype");
ap1394_handle = create_dissector_handle(dissect_ap1394, proto_ap1394);
static int arcnet_address_type = -1;
static dissector_table_t arcnet_dissector_table;
-static dissector_handle_t data_handle;
/* Cache protocol for packet counting */
static int proto_ipx = -1;
next_tvb, pinfo, tree))
{
col_add_fstr (pinfo->cinfo, COL_PROTOCOL, "0x%04x", protID);
- call_dissector (data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
register_capture_dissector("wtap_encap", WTAP_ENCAP_ARCNET_LINUX, capture_arcnet, proto_arcnet);
register_capture_dissector("wtap_encap", WTAP_ENCAP_ARCNET, capture_arcnet_has_exception, proto_arcnet);
- data_handle = find_dissector ("data");
}
/*
static dissector_handle_t wlan_withfcs_handle;
static dissector_handle_t peek_handle;
static dissector_handle_t ppi_handle;
-static dissector_handle_t data_handle;
static dissector_table_t aruba_erm_subdissector_table;
dissect_aruba_erm_common(tvb, pinfo, tree, &offset);
/* Add Expert info how decode...*/
proto_tree_add_expert(tree, pinfo, &ei_aruba_erm_decode, tvb, offset, -1);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
/* Not (yet) supported launch data dissector */
proto_tree_add_expert(tree, pinfo, &ei_aruba_erm_airmagnet, tvb, offset, -1);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
wlan_withfcs_handle = find_dissector_add_dependency("wlan_withfcs", proto_aruba_erm);
ppi_handle = find_dissector_add_dependency("ppi", proto_aruba_erm);
peek_handle = find_dissector_add_dependency("peekremote", proto_aruba_erm);
- data_handle = find_dissector("data");
aruba_erm_handle = create_dissector_handle(dissect_aruba_erm, proto_aruba_erm);
aruba_erm_handle_type0 = create_dissector_handle(dissect_aruba_erm_type0, proto_aruba_erm_type0);
aruba_erm_handle_type1 = create_dissector_handle(dissect_aruba_erm_type1, proto_aruba_erm_type1);
/* Global PAPI Debug Preference */
static gboolean g_papi_debug = FALSE;
-static dissector_handle_t data_handle;
-
/* Initialize the subtree pointers */
static gint ett_papi = -1;
}
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return(TRUE);
}
papi_handle = create_dissector_handle(dissect_papi, proto_papi);
dissector_add_uint("udp.port", UDP_PORT_PAPI, papi_handle);
- data_handle = find_dissector("data");
}
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
static int hf_asf_integrity_alg = -1;
static int hf_asf_reserved = -1;
-static dissector_handle_t data_handle;
static gint ett_asf = -1;
static gint ett_asf_payload = -1;
static gint ett_asf_alg_payload = -1;
default:
next_tvb = tvb_new_subset_length(tvb, 8, len);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
}
}
{
dissector_handle_t asf_handle;
- data_handle = find_dissector("data");
-
asf_handle = create_dissector_handle(dissect_asf, proto_asf);
dissector_add_uint("rmcp.class", RMCP_CLASS_ASF, asf_handle);
}
static dissector_table_t ddp_dissector_table;
-static dissector_handle_t data_handle;
-
#define DDP_SHORT_HEADER_SIZE 5
/*
}
else if (!try_conversation_dissector(&pinfo->src, &pinfo->dst, pinfo->ptype,
pinfo->srcport, pinfo->destport, new_tvb,pinfo, tree, &aspinfo)) {
- call_dissector(data_handle, new_tvb, pinfo, tree);
+ call_data_dissector(new_tvb, pinfo, tree);
}
}
else {
/* Just show this as a fragment. */
new_tvb = tvb_new_subset_remaining (tvb, ATP_HDRSIZE -1);
- call_dissector(data_handle, new_tvb, pinfo, tree);
+ call_data_dissector(new_tvb, pinfo, tree);
}
pinfo->fragmented = save_fragmented;
return tvb_captured_length(tvb);
offset++;
PAD(1);
/* follow by data */
- call_dissector(data_handle,tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
break;
case PAPTickle:
default:
proto_item_set_len(asp_tree, 4);
offset += 3;
- call_dissector(data_handle,tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
break;
}
}
default:
proto_item_set_len(asp_tree, 4);
offset += 4;
- call_dissector(data_handle,tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
break;
}
}
new_tvb = tvb_new_subset_remaining(tvb, DDP_SHORT_HEADER_SIZE);
if (!dissector_try_uint(ddp_dissector_table, type, new_tvb, pinfo, tree))
- call_dissector(data_handle,new_tvb, pinfo, tree);
+ call_data_dissector(new_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
if (!dissector_try_uint(ddp_dissector_table, ddp.type, new_tvb, pinfo, tree))
{
- call_dissector(data_handle,new_tvb, pinfo, tree);
+ call_data_dissector(new_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
return tvb_captured_length(tvb);
break;
}
- call_dissector(data_handle,new_tvb, pinfo, tree);
+ call_data_dissector(new_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
afp_handle = find_dissector_add_dependency("afp", proto_asp);
afp_server_status_handle = find_dissector_add_dependency("afp_server_status", proto_asp);
- data_handle = find_dissector("data");
}
/*
static dissector_handle_t ppp_handle;
static dissector_handle_t eth_maybefcs_handle;
static dissector_handle_t ip_handle;
-static dissector_handle_t data_handle;
static gboolean dissect_lanesscop = FALSE;
/* Dump it as raw data. */
col_set_str(pinfo->cinfo, COL_INFO, "Unknown LANE traffic type");
next_tvb = tvb_new_subset_remaining(tvb, 0);
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
}
return tvb_captured_length(tvb);
if (!decoded) {
/* Dump it as raw data. */
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
default:
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
}
}
ppp_handle = find_dissector_add_dependency("ppp", proto_atm);
eth_maybefcs_handle = find_dissector_add_dependency("eth_maybefcs", proto_atm);
ip_handle = find_dissector_add_dependency("ip", proto_atm);
- data_handle = find_dissector("data");
dissector_add_uint("wtap_encap", WTAP_ENCAP_ATM_PDUS, atm_handle);
dissector_add_uint("atm.aal5.type", TRAF_LANE, create_dissector_handle(dissect_lane, proto_atm_lane));
static gint ett_atmtcp = -1;
-static dissector_handle_t data_handle;
-
#define ATMTCP_HDR_MAGIC (~0) /* this length indicates a command */
#define ATMTCP_CTRL_OPEN 1 /* request/reply */
#define ATMTCP_CTRL_CLOSE 2 /* request/reply */
/* Data (for the moment...) */
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return tvb_reported_length(tvb);
}
if (!initialized) {
atmtcp_handle = create_dissector_handle(dissect_atmtcp, proto_atmtcp);
- data_handle = find_dissector("data");
initialized = TRUE;
} else {
dissector_delete_uint("tcp.port", current_port, atmtcp_handle);
/* Dissector handles - all the possibles are listed */
static dissector_handle_t aprs_handle;
-static dissector_handle_t default_handle;
/* Initialize the protocol and registered fields */
static int proto_ax25_nol3 = -1;
}
}
if ( ! dissected )
- call_dissector( default_handle , next_tvb, pinfo, ax25_nol3_tree );
+ call_data_dissector(next_tvb, pinfo, ax25_nol3_tree );
return tvb_captured_length(tvb);
}
/*
*/
aprs_handle = find_dissector_add_dependency( "aprs", proto_ax25_nol3 );
- default_handle = find_dissector( "data" );
-
}
/*
static dissector_handle_t ax25_handle;
-static dissector_handle_t data_handle;
-
static int
dissect_ax25( tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void* data _U_ )
{
if (!dissector_try_uint(ax25_dissector_table, pid, next_tvb, pinfo, parent_tree))
{
- call_dissector(data_handle, next_tvb, pinfo, parent_tree);
+ call_data_dissector(next_tvb, pinfo, parent_tree);
}
}
else
dissector_add_uint("ip.proto", IP_PROTO_AX25, ax25_handle);
register_capture_dissector("wtap_encap", WTAP_ENCAP_AX25, capture_ax25, proto_ax25);
-
- data_handle = find_dissector( "data" );
-
}
/*
void proto_reg_handoff_bacnet(void);
static dissector_handle_t bacapp_handle;
-static dissector_handle_t data_handle;
/* Defined to allow vendor identifier registration of private transfer dissectors */
static dissector_table_t bacnet_dissector_table;
next_tvb = tvb_new_subset_remaining(tvb,offset);
if (bacnet_control & BAC_CONTROL_NET) {
/* Unknown function - dissect the payload as data */
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
} else {
/* APDU - call the APDU dissector */
call_dissector(bacapp_handle, next_tvb, pinfo, tree);
dissector_add_uint("bvlc.function", 0x0b, bacnet_handle);
dissector_add_uint("llc.dsap", SAP_BACNET, bacnet_handle);
bacapp_handle = find_dissector_add_dependency("bacapp", proto_bacnet);
- data_handle = find_dissector("data");
}
/*
/* other dissectors */
static dissector_handle_t ip_handle;
-static dissector_handle_t data_handle;
static int proto_bat_plugin = -1;
static int proto_bat_gw = -1;
break;
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
return tvb_captured_length(tvb);
if (gw_packeth->type == TUNNEL_DATA) {
call_dissector(ip_handle, next_tvb, pinfo, tree);
} else {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
return tvb_captured_length(tvb);
break;
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
return tvb_captured_length(tvb);
tap_queue_packet(bat_follow_tap, pinfo, next_tvb);
}
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
tap_queue_packet(bat_follow_tap, pinfo, next_tvb);
}
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
vis_handle = create_dissector_handle(dissect_bat_vis, proto_bat_vis);
ip_handle = find_dissector_add_dependency("ip", proto_bat_gw);
- data_handle = find_dissector("data");
inited = TRUE;
} else {
/* other dissectors */
-static dissector_handle_t data_handle;
static dissector_handle_t eth_handle;
static int proto_batadv_plugin = -1;
length_remaining = tvb_reported_length_remaining(tvb, 0);
if (length_remaining > 0) {
next_tvb = tvb_new_subset_remaining(tvb, 0);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
break;
}
length_remaining = tvb_captured_length_remaining(tvb, 0);
if (length_remaining > 0) {
next_tvb = tvb_new_subset_remaining(tvb, 0);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
break;
}
break;
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
}
length_remaining = tvb_reported_length_remaining(tvb, offset);
if (length_remaining > 0) {
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return offset;
break;
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
}
break;
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
}
break;
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
}
if (length_remaining > 0) {
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
length_remaining = tvb_reported_length_remaining(tvb, offset);
if (length_remaining > 0) {
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
length_remaining = tvb_reported_length_remaining(tvb, offset);
if (length_remaining > 0) {
next_tvb = tvb_new_subset(tvb, offset, length_remaining, -1);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
length_remaining = tvb_captured_length_remaining(tvb, offset);
if (length_remaining > 0) {
next_tvb = tvb_new_subset(tvb, offset, length_remaining, -1);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
break;
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
}
break;
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
}
break;
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
}
break;
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
}
tap_queue_packet(batadv_follow_tap, pinfo, next_tvb);
}
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
tap_queue_packet(batadv_follow_tap, pinfo, next_tvb);
}
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
tap_queue_packet(batadv_follow_tap, pinfo, next_tvb);
}
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
break;
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
}
tap_queue_packet(batadv_follow_tap, pinfo, next_tvb);
}
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
break;
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
}
tap_queue_packet(batadv_follow_tap, pinfo, next_tvb);
}
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
break;
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
}
tap_queue_packet(batadv_follow_tap, pinfo, next_tvb);
}
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d",
version);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
}
version);
break;
default:
- call_dissector(data_handle, next_tvb, pinfo,
+ call_data_dissector(next_tvb, pinfo,
batadv_tvlv_tree);
break;
}
if (!inited) {
batman_handle = create_dissector_handle(dissect_batadv_plugin, proto_batadv_plugin);
- data_handle = find_dissector("data");
eth_handle = find_dissector_add_dependency("eth_withoutfcs", proto_batadv_plugin);
batadv_tap = register_tap("batman");
static gint ett_bctp = -1;
static dissector_table_t bctp_dissector_table;
-static dissector_handle_t data_handle;
static dissector_handle_t text_handle;
/*
if (!dissector_try_uint(bctp_dissector_table, tpi, sub_tvb, pinfo, tree) ) {
if (tpi <= 0x22) {
- call_dissector(data_handle,sub_tvb, pinfo, tree);
+ call_data_dissector(sub_tvb, pinfo, tree);
} else {
/* tpi > 0x22 */
call_dissector(text_handle,sub_tvb, pinfo, tree);
void
proto_reg_handoff_bctp(void)
{
- data_handle = find_dissector("data");
text_handle = find_dissector_add_dependency("data-text-lines", proto_bctp);
}
static dissector_handle_t btle_handle;
static dissector_handle_t hci_usb_handle;
-static dissector_handle_t data_handle;
static dissector_table_t bluetooth_table;
static dissector_table_t hci_vendor_table;
bluetooth_data->previous_protocol_data.none = NULL;
if (!dissector_try_uint_new(bluetooth_table, pinfo->phdr->pkt_encap, tvb, pinfo, tree, TRUE, bluetooth_data)) {
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
bluetooth_data->previous_protocol_data.bthci = (struct bthci_phdr *)data;
if (!dissector_try_uint_new(bluetooth_table, pinfo->phdr->pkt_encap, tvb, pinfo, tree, TRUE, bluetooth_data)) {
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
bluetooth_data->previous_protocol_data.btmon = (struct btmon_phdr *)data;
if (!dissector_try_uint_new(bluetooth_table, pinfo->phdr->pkt_encap, tvb, pinfo, tree, TRUE, bluetooth_data)) {
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
dissector_handle_t btl2cap_handle;
btle_handle = find_dissector_add_dependency("btle", proto_bluetooth);
- data_handle = find_dissector("data");
hci_usb_handle = find_dissector_add_dependency("hci_usb", proto_bluetooth);
dissector_add_uint("wtap_encap", WTAP_ENCAP_BLUETOOTH_HCI, bluetooth_bthci_handle);
static expert_field ei_bssap_mandatory_ie = EI_INIT;
-static dissector_handle_t data_handle;
static dissector_handle_t rrlp_handle;
static dissector_table_t bssap_dissector_table;
}
/* No sub-dissection occurred, treat it as raw data */
- call_dissector(data_handle, tvb, pinfo, bssap_tree);
+ call_data_dissector(tvb, pinfo, bssap_tree);
}
static void
if ((prot_disc == 2)&&(rrlp_handle))
call_dissector(rrlp_handle, next_tvb, pinfo, ie_tree);
else
- call_dissector(data_handle, next_tvb, pinfo, ie_tree);
+ call_data_dissector(next_tvb, pinfo, ie_tree);
return offset + ie_len;
if ((prot_disc == 2)&&(rrlp_handle))
call_dissector(rrlp_handle, next_tvb, pinfo, ie_tree);
else
- call_dissector(data_handle, next_tvb, pinfo, ie_tree);
+ call_data_dissector(next_tvb, pinfo, ie_tree);
return offset + ie_len;
/* BSSAP+ */
bssap_plus_handle = create_dissector_handle(dissect_bssap_plus, proto_bssap);
- data_handle = find_dissector("data");
rrlp_handle = find_dissector_add_dependency("rrlp", proto_bssap_plus);
gsm_bssmap_le_dissector_handle = find_dissector_add_dependency("gsm_bssmap_le", proto_bssap);
gsm_a_bssmap_dissector_handle = find_dissector_add_dependency("gsm_a_bssmap", proto_bssap);
static proto_tree *gparent_tree;
static dissector_handle_t llc_handle;
static dissector_handle_t rrlp_handle;
-static dissector_handle_t data_handle;
static module_t *bssgp_module;
static dissector_table_t diameter_3gpp_avp_dissector_table;
if(next_tvb){
if (llc_handle) {
call_dissector(llc_handle, next_tvb, pinfo, gparent_tree);
- }
- else if (data_handle) {
- call_dissector(data_handle, next_tvb, pinfo, gparent_tree);
+ } else {
+ call_data_dissector(next_tvb, pinfo, gparent_tree);
}
}
if(next_tvb){
if (rrlp_handle) {
call_dissector(rrlp_handle, next_tvb, pinfo, gparent_tree);
- }else if (data_handle) {
- call_dissector(data_handle, next_tvb, pinfo, gparent_tree);
+ } else {
+ call_data_dissector(next_tvb, pinfo, gparent_tree);
}
}
return(len);
{
llc_handle = find_dissector("llcgprs");
rrlp_handle = find_dissector("rrlp");
- data_handle = find_dissector("data");
diameter_3gpp_avp_dissector_table = find_dissector_table("diameter.3gpp");
}
static expert_field ei_btavctp_invalid_profile = EI_INIT;
static dissector_handle_t btavctp_handle;
-static dissector_handle_t data_handle = NULL;
typedef struct _fragment_t {
guint length;
uuid.data[1] = pid & 0xFF;
if (!dissector_try_string(bluetooth_uuid_table, print_numeric_uuid(&uuid), next_tvb, pinfo, tree, avctp_data)) {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
} else {
fragments = NULL;
}
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
} else if (packet_type == PACKET_TYPE_CONTINUE) {
fragments = (fragments_t *)wmem_tree_lookup32_array_le(reassembling, key);
wmem_tree_insert32_array(reassembling, key, fragments);
}
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
} else if (packet_type == PACKET_TYPE_END) {
guint i_length = 0;
length = 0;
if (!fragments || fragments->count != fragments->number_of_packets) {
expert_add_info(pinfo, pitem, &ei_btavctp_unexpected_frame);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
} else {
guint8 *reassembled;
bluetooth_uuid_t uuid;
uuid.data[1] = fragments->pid & 0xFF;
if (!dissector_try_string(bluetooth_uuid_table, print_numeric_uuid(&uuid), next_tvb, pinfo, tree, avctp_data)) {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
fragments = NULL;
} else {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
void
proto_reg_handoff_btavctp(void)
{
- data_handle = find_dissector("data");
-
dissector_add_string("bluetooth.uuid", "17", btavctp_handle);
dissector_add_uint("btl2cap.psm", BTL2CAP_PSM_AVCTP_CTRL, btavctp_handle);
static dissector_handle_t llc_handle;
static dissector_handle_t ipx_handle;
-static dissector_handle_t data_handle;
static dissector_handle_t ethertype_handle;
static const true_false_string ig_tfs = {
tvbuff_t *next_tvb;
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
} else {
/*
* Valid Ethertype.
tvbuff_t *next_tvb;
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
{
ipx_handle = find_dissector_add_dependency("ipx", proto_btbnep);
llc_handle = find_dissector_add_dependency("llc", proto_btbnep);
- data_handle = find_dissector("data");
ethertype_handle = find_dissector_add_dependency("ethertype", proto_btbnep);
dissector_add_string("bluetooth.uuid", "1115", btbnep_handle);
static expert_field ei_bthcrp_unexpected_data = EI_INIT;
static dissector_handle_t bthcrp_handle;
-static dissector_handle_t data_handle;
static gint force_client = FORCE_CLIENT_DEFAULT;
static gint psm_control = 0;
col_append_str(pinfo->cinfo, COL_INFO, "HCRP data stream");
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
offset += tvb_reported_length_remaining(tvb, offset);
void
proto_reg_handoff_bthcrp(void)
{
- data_handle = find_dissector("data");
-
dissector_add_string("bluetooth.uuid", "12", bthcrp_handle);
dissector_add_string("bluetooth.uuid", "14", bthcrp_handle);
dissector_add_string("bluetooth.uuid", "16", bthcrp_handle);
UAT_END_FIELDS
};
-static dissector_handle_t data_handle;
static dissector_handle_t ppp_handle;
static const value_string vs_ctl_pn_i[] = {
call_dissector_with_data(decode_by_dissector, next_tvb, pinfo, tree, rfcomm_data);
} else {
/* unknown service, let the data dissector handle it */
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
}
{
dissector_add_uint("btl2cap.psm", BTL2CAP_PSM_RFCOMM, btrfcomm_handle);
dissector_add_for_decode_as("btl2cap.cid", btrfcomm_handle);
-
- data_handle = find_dissector("data");
}
/* Bluetooth Dial-Up Networking (DUN) profile dissection */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PPP");
col_add_fstr(pinfo->cinfo, COL_INFO, "%s <PPP frame>", (pinfo->p2p_dir == P2P_DIR_SENT) ? "Sent" : "Rcvd");
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
}
static int hf_bvlc_fwd_ip = -1;
static int hf_bvlc_fwd_port = -1;
-static dissector_handle_t data_handle;
-
static dissector_table_t bvlc_dissector_table;
static const value_string bvlc_function_names[] = {
if (!dissector_try_uint(bvlc_dissector_table,
bvlc_function, next_tvb, pinfo, tree)) {
/* Unknown function - dissect the paylod as data */
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_reported_length(tvb);
}
{
bvlc_handle = find_dissector("bvlc");
dissector_add_uint("udp.port", 0xBAC0, bvlc_handle);
- data_handle = find_dissector("data");
bvlc_initialized = TRUE;
}
else
static dissector_handle_t ieee8023_handle;
static dissector_handle_t ieee80211_handle;
static dissector_handle_t ieee80211_bsfc_handle;
-static dissector_handle_t data_handle;
static gint ett_capwap = -1;
static gint ett_capwap_control = -1;
if (next_tvb == NULL)
{ /* make a new subset */
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
col_append_fstr(pinfo->cinfo, COL_INFO, " (Fragment ID: %u, Fragment Offset: %u)", fragment_id, fragment_offset);
}
else
if (next_tvb == NULL)
{ /* make a new subset */
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
col_append_fstr(pinfo->cinfo, COL_INFO, " (Fragment ID: %u, Fragment Offset: %u)", fragment_id, fragment_offset);
return tvb_captured_length(tvb);
}
switch (payload_wbid) {
case 0: /* Reserved - Cisco seems to use this instead of 1 */
/* It seems that just calling ieee80211_handle is not
- * quite enough to get this right, so call data_handle
+ * quite enough to get this right, so call data dissector
* for now:
*/
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
case 1: /* IEEE 802.11 */
call_dissector(global_capwap_swap_frame_control ? ieee80211_bsfc_handle : ieee80211_handle, next_tvb, pinfo, tree);
break;
default: /* Unknown Data */
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
}
}
ieee8023_handle = find_dissector_add_dependency("eth_withoutfcs", proto_capwap_data);
ieee80211_handle = find_dissector_add_dependency("wlan_withoutfcs", proto_capwap_data);
ieee80211_bsfc_handle = find_dissector_add_dependency("wlan_bsfc", proto_capwap_data);
- data_handle = find_dissector("data");
inited = TRUE;
} else {
/* desegmentation of SCCP */
static gboolean cast_desegment = TRUE;
-static dissector_handle_t data_handle;
-
/* Dissect a single CAST PDU */
static int
dissect_cast_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
dissector_handle_t cast_handle;
- data_handle = find_dissector("data");
cast_handle = create_dissector_handle(dissect_cast, proto_cast);
dissector_add_uint("tcp.port", TCP_PORT_CAST, cast_handle);
}
static int hf_cattp_eaklen = -1;
static int hf_cattp_eaks = -1;
-static dissector_handle_t data_handle;
-
/* Preference to control whether to check the CATTP checksum */
static gboolean cattp_check_checksum = TRUE;
if (plen > 0) { /* Call generic data handle if data exists. */
col_append_fstr(pinfo->cinfo, COL_INFO, " DataLen=%u", plen);
tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
/* Create dissector handle */
cattp_handle = create_dissector_handle(dissect_cattp, proto_cattp);
- /* find data handle */
- data_handle = find_dissector("data");
-
heur_dissector_add("udp", dissect_cattp_heur, "CAT-TP over UDP", "cattp_udp", proto_cattp, HEURISTIC_ENABLE);
dissector_add_for_decode_as("udp.port", cattp_handle);
initialized = TRUE;
/* Dissectot table */
static dissector_table_t ccsds_dissector_table;
-/* Generic data handle */
-static dissector_handle_t data_handle;
-
static const enum_val_t dissect_checkword[] = {
{ "hdr", "Use header flag", 2 },
{ "no", "Override header flag to be false", 0 },
}
/* Give the data dissector any bytes past the CCSDS packet length */
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
return tvb_captured_length(tvb);
}
proto_reg_handoff_ccsds(void)
{
dissector_add_for_decode_as ( "udp.port", find_dissector("ccsds") );
- data_handle = find_dissector("data");
}
/*
static expert_field ei_cdp_invalid_data = EI_INIT;
static expert_field ei_cdp_nrgyz_tlvlength = EI_INIT;
-static dissector_handle_t data_handle;
-
static int
dissect_address_tlv(tvbuff_t *tvb, int offset, int length, proto_tree *tree);
static void
offset += length;
}
}
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo, cdp_tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, cdp_tree);
return tvb_captured_length(tvb);
}
{
dissector_handle_t cdp_handle;
- data_handle = find_dissector("data");
cdp_handle = create_dissector_handle(dissect_cdp, proto_cdp);
dissector_add_uint("llc.cisco_pid", 0x2000, cdp_handle);
dissector_add_uint("chdlc.protocol", 0x2000, cdp_handle);
/*--- End of included file: packet-cdt-hf.c ---*/
#line 61 "./asn1/cdt/packet-cdt-template.c"
-static dissector_handle_t data_handle = NULL;
-
/* Initialize the subtree pointers */
/*--- Included file: packet-cdt-ett.c ---*/
static gint ett_cdt_T_contentType = -1;
/*--- End of included file: packet-cdt-ett.c ---*/
-#line 66 "./asn1/cdt/packet-cdt-template.c"
+#line 64 "./asn1/cdt/packet-cdt-template.c"
static expert_field ei_cdt_unable_compress_content = EI_INIT;
static expert_field ei_cdt_unable_uncompress_content = EI_INIT;
switch (content_type) {
case CDT_UNDEFINED:
- call_dissector (data_handle, next_tvb, actx->pinfo, top_tree);
+ call_data_dissector(next_tvb, actx->pinfo, top_tree);
break;
case CDT_EXTERNAL:
dissect_unknown_ber (actx->pinfo, next_tvb, 0, top_tree);
dissect_p1_mts_apdu (next_tvb, actx->pinfo, top_tree, NULL);
break;
default:
- call_dissector (data_handle, next_tvb, actx->pinfo, top_tree);
+ call_data_dissector(next_tvb, actx->pinfo, top_tree);
break;
}
/*--- End of included file: packet-cdt-fn.c ---*/
-#line 71 "./asn1/cdt/packet-cdt-template.c"
+#line 69 "./asn1/cdt/packet-cdt-template.c"
/*--- proto_register_cdt -------------------------------------------*/
NULL, HFILL }},
/*--- End of included file: packet-cdt-hfarr.c ---*/
-#line 103 "./asn1/cdt/packet-cdt-template.c"
+#line 101 "./asn1/cdt/packet-cdt-template.c"
};
/* List of subtrees */
&ett_cdt_T_contentType,
/*--- End of included file: packet-cdt-ettarr.c ---*/
-#line 108 "./asn1/cdt/packet-cdt-template.c"
+#line 106 "./asn1/cdt/packet-cdt-template.c"
};
static ei_register_info ei[] = {
/*--- End of included file: packet-cdt-dis-tab.c ---*/
-#line 131 "./asn1/cdt/packet-cdt-template.c"
-
- data_handle = find_dissector ("data");
+#line 129 "./asn1/cdt/packet-cdt-template.c"
}
static dissector_handle_t cfdp_handle;
-/* Generic data handle */
-static dissector_handle_t data_handle;
/* Some parameters */
#define CFDP_HEADER_FIXED_FIELDS_LEN 4
proto_item_set_end(cfdp_crc, tvb, offset);
}
/* Give the data dissector any bytes past the CFDP packet length */
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
return tvb_captured_length(tvb);
}
{
dissector_add_uint("ccsds.apid", CFDP_APID, cfdp_handle);
dissector_add_for_decode_as("udp.port", cfdp_handle);
- data_handle = find_dissector("data");
}
/*
static expert_field ei_slarp_reliability = EI_INIT;
static gint ett_slarp = -1;
-static dissector_handle_t data_handle;
-
/*
* Protocol types for the Cisco HDLC format.
*
/* do lookup with the subdissector table */
if (!dissector_try_uint(subdissector_table, chdlc_type, next_tvb, pinfo, tree)) {
col_add_fstr(pinfo->cinfo, COL_PROTOCOL, "0x%04x", chdlc_type);
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
{
dissector_handle_t chdlc_handle;
- data_handle = find_dissector("data");
chdlc_handle = find_dissector("chdlc");
dissector_add_uint("wtap_encap", WTAP_ENCAP_CHDLC, chdlc_handle);
dissector_add_uint("wtap_encap", WTAP_ENCAP_CHDLC_WITH_PHDR, chdlc_handle);
col_add_fstr(pinfo->cinfo, COL_INFO, "Unknown packet type 0x%08X", code);
proto_tree_add_uint(slarp_tree, hf_slarp_ptype, tvb, 0, 4, code);
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, 4), pinfo,
- slarp_tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, 4), pinfo, slarp_tree);
break;
}
return tvb_captured_length(tvb);
static dissector_handle_t sdp_handle;
static dissector_handle_t mtp3_handle;
static dissector_handle_t q931_handle;
-static dissector_handle_t data_handle;
/* Code to actually dissect the packets */
static int
if ((msg_type == PDU_MTP3_TO_SLT || msg_type == PDU_MTP3_FROM_SLT)) {
call_dissector(q931_handle, next_tvb, pinfo, tree);
} else {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
/* This should be the EISUP dissector but we haven't got one
* right now - so decode it as data for now ... */
next_tvb = tvb_new_subset_length(tvb, offset, length);
- call_dissector(data_handle, next_tvb, pinfo, sm_tree);
+ call_data_dissector(next_tvb, pinfo, sm_tree);
break;
case SM_PROTOCOL_X101:
proto_tree_add_item(sm_tree, hf_sm_stat_request_type, tvb, offset, 4, ENC_BIG_ENDIAN);
break;
default:
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
}
sdp_handle = find_dissector_add_dependency("sdp", proto_sm);
mtp3_handle = find_dissector_add_dependency("mtp3", proto_sm);
q931_handle = find_dissector_add_dependency("q931", proto_sm);
- data_handle = find_dissector("data");
}
/*
static dissector_handle_t ositp_handle;
static dissector_handle_t ositp_inactive_handle;
static dissector_handle_t idrp_handle;
-static dissector_handle_t data_handle;
/*
* ISO 8473 OSI CLNP definition (see RFC994)
proto_tree_add_uint_format(clnp_tree, hf_clnp_id, tvb, P_CLNP_PROTO_ID, 1,
cnf_proto_id, "Inactive subset");
next_tvb = tvb_new_subset_remaining(tvb, 1);
- if (call_dissector(ositp_inactive_handle, next_tvb, pinfo, tree) == 0)
- call_dissector(data_handle,tvb, pinfo, tree);
+ call_dissector(ositp_inactive_handle, next_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
/* return if version not known */
cnf_vers = tvb_get_guint8(tvb, P_CLNP_VERS);
if (cnf_vers != ISO8473_V1) {
- call_dissector(data_handle,tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
/* As we haven't reassembled anything, we haven't changed "pi", so
we don't have to restore it. */
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo,
- tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
pinfo->fragmented = save_fragmented;
return tvb_captured_length(tvb);
}
}
}
col_add_fstr(pinfo->cinfo, COL_INFO, "%s NPDU %s", pdu_type_string, flag_string);
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
pinfo->fragmented = save_fragmented;
return tvb_captured_length(tvb);
} /* dissect_clnp */
ositp_handle = find_dissector_add_dependency("ositp", proto_clnp);
ositp_inactive_handle = find_dissector_add_dependency("ositp_inactive", proto_clnp);
idrp_handle = find_dissector_add_dependency("idrp", proto_clnp);
- data_handle = find_dissector("data");
dissector_add_uint("osinl.incl", NLPID_ISO8473_CLNP, clnp_handle);
dissector_add_uint("osinl.incl", NLPID_NULL, clnp_handle); /* Inactive subset */
static expert_field ei_cnip_type_unknown = EI_INIT;
static dissector_table_t cnip_dissector_table;
-static dissector_handle_t data_handle;
static int dissect_cnip (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
"This dissector doesn't yet decode packets of type %s (0x%x)",
val_to_str_const(type, type_tuple, "Unknown"), type);
}
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
dissector_handle_t cnip_handle;
cnip_handle = create_dissector_handle(dissect_cnip, proto_cnip);
- data_handle = find_dissector("data");
dissector_add_uint ("udp.port", 1628, cnip_handle);
dissector_add_uint ("udp.port", 1629, cnip_handle);
static dissector_handle_t llc_handle;
static dissector_handle_t chdlc_handle;
static dissector_handle_t fr_handle;
-static dissector_handle_t data_handle;
static int
dissect_cosine(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
break;
case COSINE_ENCAP_TEST:
case COSINE_ENCAP_UNKNOWN:
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
default:
break;
llc_handle = find_dissector_add_dependency("llc", proto_cosine);
chdlc_handle = find_dissector_add_dependency("chdlc", proto_cosine);
fr_handle = find_dissector_add_dependency("fr", proto_cosine);
- data_handle = find_dissector("data");
cosine_handle = create_dissector_handle(dissect_cosine, proto_cosine);
dissector_add_uint("wtap_encap", WTAP_ENCAP_COSINE, cosine_handle);
static dissector_table_t dccp_subdissector_table;
static heur_dissector_list_t heur_subdissector_list;
-static dissector_handle_t data_handle;
/* preferences */
static gboolean dccp_summary_in_tree = TRUE;
}
/* Oh, well, we don't know this; dissect it as data. */
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
/*
dccp_handle = create_dissector_handle(dissect_dccp, proto_dccp);
dissector_add_uint("ip.proto", IP_PROTO_DCCP, dccp_handle);
- data_handle = find_dissector("data");
dccp_tap = register_tap("dccp");
}
static expert_field ei_distcc_short_pdu = EI_INIT;
-static dissector_handle_t data_handle;
-
static gboolean distcc_desegment = TRUE;
} else if(!strncmp(buf, "DOTO", 4)){
offset=dissect_distcc_doto(tvb, pinfo, tree, offset, parameter);
} else {
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
}
*/
distcc_handle = create_dissector_handle(dissect_distcc,
proto_distcc);
- data_handle = find_dissector("data");
registered_dissector = TRUE;
} else {
/*
static dissector_table_t dmx_dissector_table;
static dissector_handle_t dmx_text_handle;
-static dissector_handle_t data_handle;
/*
* Here are the global variables associated with the preferences for DMX
if (!dissector_try_uint_new(dmx_dissector_table, start_code, tvb, pinfo,
tree, TRUE, NULL)) {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
dissector_add_uint("dmx", DMX_SC_SIP, create_dissector_handle(dissect_dmx_sip, proto_dmx_sip));
dissector_add_uint("dmx", DMX_SC_TEST, create_dissector_handle(dissect_dmx_test, proto_dmx_test));
dissector_add_uint("dmx", DMX_SC_TEXT, create_dissector_handle(dissect_dmx_text, proto_dmx_text));
-
- data_handle = find_dissector("data");
}
/*
/* desegmentation of DSI */
static gboolean dsi_desegment = TRUE;
-static dissector_handle_t data_handle;
static dissector_handle_t afp_handle;
static dissector_handle_t afp_server_status_handle;
}
break;
default:
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, DSI_BLOCKSIZ),
+ call_data_dissector(tvb_new_subset_remaining(tvb, DSI_BLOCKSIZ),
pinfo, dsi_tree);
break;
}
dsi_handle = create_dissector_handle(dissect_dsi, proto_dsi);
dissector_add_uint("tcp.port", TCP_PORT_DSI, dsi_handle);
- data_handle = find_dissector("data");
afp_handle = find_dissector_add_dependency("afp", proto_dsi);
afp_server_status_handle = find_dissector_add_dependency("afp_server_status", proto_dsi);
}
void proto_reg_handoff_dsr(void);
void proto_register_dsr(void);
-static dissector_handle_t data_handle;
static dissector_table_t ip_dissector_table;
/* Initialize the protocol and registered fields */
/* Call other dissectors if needed */
next_tvb = tvb_new_subset_remaining(tvb, offset);
if (!dissector_try_uint(ip_dissector_table, nexthdr, next_tvb, pinfo, tree)) {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return offset+4;
{
dissector_handle_t dsr_handle;
- data_handle = find_dissector("data");
-
ip_dissector_table = find_dissector_table("ip.proto");
dsr_handle = create_dissector_handle(dissect_dsr, proto_dsr);
static dissector_handle_t bundle_handle;
-static dissector_handle_t data_handle;
static guint bundle_tcp_port = 4556;
static guint bundle_udp_port = 4556;
if (bundle_size == 0) {
/*Couldn't parse bundle, treat as raw data */
- call_dissector(data_handle, new_tvb, pinfo, sub_tree);
+ call_data_dissector(new_tvb, pinfo, sub_tree);
return tvb_captured_length(tvb);
}
}
if (!Initialized) {
tcpcl_handle = create_dissector_handle(dissect_tcpcl, proto_bundle);
- data_handle = find_dissector("data");
Initialized = TRUE;
}
else {
static dissector_handle_t dtpt_conversation_handle;
/** static dissector_handle_t dtpt_data_handle; **/
-static dissector_handle_t data_handle;
/* Server port */
/* Handle any remaining bytes ... */
if (tvb_reported_length_remaining(tvb, offset) > 0) {
/* ... as data. */
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
}
return tvb_reported_length(tvb);
}
dtpt_conversation_handle = create_dissector_handle(dissect_dtpt_conversation, proto_dtpt);
/** dtpt_data_handle = create_dissector_handle(dissect_dtpt_data, proto_dtpt); **/
- data_handle = find_dissector("data");
Initialized=TRUE;
} else {
dissector_delete_uint("tcp.port", ServerPort, dtpt_handle);
static gint ett_dua = -1;
static gint ett_dua_parameter = -1;
-static dissector_handle_t data_handle;
static dissector_handle_t dpnss_handle;
#define ADD_PADDING(x) ((((x) + 3) >> 2) << 2)
return;
}
- call_dissector(data_handle, protocol_data_tvb, pinfo, tree);
+ call_data_dissector(protocol_data_tvb, pinfo, tree);
proto_item_append_text(parameter_item, " (%u byte%s)", protocol_data_length, plurality(protocol_data_length, "", "s"));
}
dissector_handle_t dua_handle;
dua_handle = find_dissector("dua");
- data_handle = find_dissector("data");
dpnss_handle = find_dissector_add_dependency("dpnss", proto_dua);
dissector_add_uint("sctp.ppi", DUA_PAYLOAD_PROTOCOL_ID, dua_handle);
}
static dissector_handle_t eap_handle;
static dissector_handle_t mka_handle;
-static dissector_handle_t data_handle;
#define EAPOL_HDR_LEN 4
case EAPOL_ENCAP_ASF_ALERT: /* XXX - is this an SNMP trap? */
default:
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, eapol_tree);
+ call_data_dissector(next_tvb, pinfo, eapol_tree);
break;
}
return tvb_captured_length(tvb);
*/
eap_handle = find_dissector_add_dependency("eap", proto_eapol);
mka_handle = find_dissector_add_dependency("mka", proto_eapol);
- data_handle = find_dissector("data");
dissector_add_uint("ethertype", ETHERTYPE_EAPOL, eapol_handle);
dissector_add_uint("ethertype", ETHERTYPE_RSN_PREAUTH, eapol_handle);
static int proto_egd = -1;
-static dissector_handle_t data_handle;
-
static int hf_egd_ver = -1;
static int hf_egd_type = -1;
static int hf_egd_rid = -1;
if (data_length > 0)
{
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, egd_tree);
+ call_data_dissector(next_tvb, pinfo, egd_tree);
}
}
return tvb_captured_length(tvb);
egd_handle = create_dissector_handle(dissect_egd, proto_egd);
dissector_add_uint("udp.port", EGD_PORT, egd_handle);
-
- /* find data dissector */
- data_handle = find_dissector("data");
}
/*
void proto_reg_handoff_eiss(void);
static int proto_eiss = -1;
-static dissector_handle_t data_handle;
static int hf_eiss_reserved2 = -1;
static int hf_eiss_section_number = -1;
offset += 4;
payload = tvb_new_subset_length(tvb, offset, tmp-4);
- call_dissector(data_handle, payload, pinfo, sub_tree);
+ call_data_dissector(payload, pinfo, sub_tree);
return (3+tmp);
} else {
eiss_handle = create_dissector_handle(dissect_eiss, proto_eiss);
dissector_add_uint("mpeg_sect.tid", EISS_SECTION_TID, eiss_handle);
- data_handle = find_dissector("data");
}
/*
#define BSD_ENC_M_AUTH_AH 0x2000 /* header authenticated */
static dissector_table_t enc_dissector_table;
-static dissector_handle_t data_handle;
/* header fields */
static int proto_enc = -1;
/* Set the tvbuff for the payload after the header */
next_tvb = tvb_new_subset_remaining(tvb, BSD_ENC_HDRLEN);
if (!dissector_try_uint(enc_dissector_table, ench.af, next_tvb, pinfo, tree))
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
{
dissector_handle_t enc_handle;
- data_handle = find_dissector("data");
-
enc_handle = create_dissector_handle(dissect_enc, proto_enc);
dissector_add_uint("wtap_encap", WTAP_ENCAP_ENC, enc_handle);
static dissector_table_t subdissector_io_table;
static dissector_table_t subdissector_class_table;
-static dissector_handle_t data_handle;
static dissector_handle_t arp_handle;
static dissector_handle_t cipsafety_handle;
static dissector_handle_t cipmotion_handle;
{
/* Show the undissected payload */
if ( tvb_reported_length_remaining(tvb, offset) > 0 )
- call_dissector( data_handle, next_tvb, pinfo, dissector_tree);
+ call_data_dissector(next_tvb, pinfo, dissector_tree);
}
/* Check if this is a ForwardOpen packet, because special handling is needed
if (!dissector_try_uint(subdissector_sud_table, ifacehndl, next_tvb, pinfo, dissector_tree) )
{
/* Show the undissected payload */
- call_dissector( data_handle, next_tvb, pinfo, dissector_tree );
+ call_data_dissector(next_tvb, pinfo, dissector_tree );
}
p_remove_proto_data(wmem_file_scope(), pinfo, proto_enip, ENIP_REQUEST_INFO);
}
ssl_dissector_add(ENIP_SECURE_PORT, enip_tcp_handle);
dtls_dissector_add(ENIP_SECURE_PORT, enipio_handle);
- /* Find dissector for data packet */
- data_handle = find_dissector("data");
-
/* Find ARP dissector for TCP/IP object */
arp_handle = find_dissector_add_dependency("arp", proto_enip);
static const gchar* addr_str_cn = " (Controlled Node)";
static const gchar* addr_str_res = " (reserved)";
-static dissector_handle_t data_dissector = NULL;
-
static gint dissect_epl_payload ( proto_tree *epl_tree, tvbuff_t *tvb, packet_info *pinfo, gint offset, gint len, guint8 msgType );
static gint dissect_epl_soc(proto_tree *epl_tree, tvbuff_t *tvb, packet_info *pinfo, gint offset);
}
if ( ! dissector_try_heuristic(heur_epl_data_subdissector_list, payload_tvb, pinfo, epl_tree, &hdtbl_entry, &msgType))
- call_dissector(data_dissector, payload_tvb, pinfo, epl_tree);
+ call_data_dissector(payload_tvb, pinfo, epl_tree);
off += len;
}
{
dissector_handle_t epl_udp_handle = create_dissector_handle( dissect_epludp, proto_epl );
- /* Store a pointer to the data_dissector */
- if ( data_dissector == NULL )
- data_dissector = find_dissector ( "data" );
-
dissector_add_uint("ethertype", ETHERTYPE_EPL_V2, epl_handle);
dissector_add_uint("udp.port", UDP_PORT_EPL, epl_udp_handle);
static expert_field ei_erf_packet_loss = EI_INIT;
static expert_field ei_erf_checksum_error = EI_INIT;
-/* Default subdissector, display raw hex data */
-static dissector_handle_t data_handle;
-
typedef enum {
ERF_HDLC_CHDLC = 0,
ERF_HDLC_PPP = 1,
call_dissector(sdh_handle, tvb, pinfo, tree);
}
else{
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
break;
case ERF_TYPE_INFINIBAND:
case ERF_TYPE_INFINIBAND_LINK:
if (!dissector_try_uint(erf_dissector_table, erf_type, tvb, pinfo, tree)) {
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
break;
case ERF_TYPE_MC_RAW:
dissect_mc_raw_header(tvb, pinfo, erf_tree);
- if (data_handle)
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
case ERF_TYPE_MC_RAW_CHANNEL:
dissect_mc_rawlink_header(tvb, pinfo, erf_tree);
- if (data_handle)
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
case ERF_TYPE_MC_ATM:
case ERF_TYPE_META:
/* use data dissector for now */
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
default:
{
dissector_add_uint("wtap_encap", WTAP_ENCAP_ERF, erf_handle);
- /* Dissector called to dump raw data, or unknown protocol */
- data_handle = find_dissector("data");
-
/* Get handles for serial line protocols */
chdlc_handle = find_dissector_add_dependency("chdlc", proto_erf);
ppp_handle = find_dissector_add_dependency("ppp_hdlc", proto_erf);
static dissector_handle_t fw1_handle;
static dissector_handle_t ethertype_handle;
-static dissector_handle_t data_handle;
static heur_dissector_list_t heur_subdissector_list;
static heur_dissector_list_t eth_trailer_subdissector_list;
expert_add_info_format(pinfo, ti, &ei_eth_invalid_lentype,
"Invalid length/type: 0x%04x (%d)", ehdr->type, ehdr->type);
next_tvb = tvb_new_subset_remaining(tvb, 14);
- call_dissector(data_handle, next_tvb, pinfo, parent_tree);
+ call_data_dissector(next_tvb, pinfo, parent_tree);
return fh_tree;
}
/* Get a handle for the ethertype dissector. */
ethertype_handle = find_dissector_add_dependency("ethertype", proto_eth);
- /* Get a handle for the generic data dissector. */
- data_handle = find_dissector("data");
-
eth_handle = create_dissector_handle(dissect_eth, proto_eth);
dissector_add_uint("wtap_encap", WTAP_ENCAP_ETHERNET, eth_handle);
#include "packet-eth.h"
void proto_register_ethertype(void);
-void proto_reg_handoff_ethertype(void);
static dissector_table_t ethertype_dissector_table;
-static dissector_handle_t data_handle;
-
static int proto_ethertype = -1;
const value_string etype_vals[] = {
if (!dissector_found) {
/* No sub-dissector found.
Label rest of packet as "Data" */
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
/* Label protocol */
col_add_fstr(pinfo->cinfo, COL_PROTOCOL, "0x%04x", ethertype_data->etype);
register_decode_as(ðertype_da);
}
-void
-proto_reg_handoff_ethertype(void)
-{
- data_handle = find_dissector("data");
-}
-
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
static dissector_handle_t fc_handle, fcsof_handle;
static dissector_table_t fcftype_dissector_table;
-static dissector_handle_t data_handle;
-
static int fc_tap = -1;
typedef struct _fc_conv_data_t {
tvb, offset+9, 1, 0);
PROTO_ITEM_SET_HIDDEN(hidden_item);
next_tvb = tvb_new_subset_remaining (tvb, next_offset);
- call_dissector (data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return;
}
}
/* If relative offset is used, only dissect the pdu with
* offset 0 (param) */
if( (fchdr->fctl&FC_FCTL_REL_OFFSET) && param ){
- call_dissector (data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
} else {
if (!dissector_try_uint_new (fcftype_dissector_table, ftype,
next_tvb, pinfo, tree, FALSE, fchdr)) {
- call_dissector (data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
} else if (ftype == FC_FTYPE_BLS) {
create_dissector_handle(dissect_fc_wtap, proto_fc));
dissector_add_uint("wtap_encap", WTAP_ENCAP_FIBRE_CHANNEL_FC2_WITH_FRAME_DELIMS, fcsof_handle);
-
- data_handle = find_dissector("data");
}
/*
};
static dissector_table_t fcct_gserver_table;
-static dissector_handle_t data_handle;
guint8
get_gs_server (guint8 gstype, guint8 gssubtype)
next_tvb = tvb_new_subset_remaining (tvb, 0);
if (!dissector_try_uint_new(fcct_gserver_table, server, next_tvb, pinfo,
tree, TRUE, data)) {
- call_dissector (data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
fcct_handle = create_dissector_handle (dissect_fcct, proto_fcct);
dissector_add_uint("fc.ftype", FC_FTYPE_FCCT, fcct_handle);
-
- data_handle = find_dissector ("data");
}
/*
static GHashTable *fcels_req_hash = NULL;
-static dissector_handle_t data_handle, fcsp_handle;
+static dissector_handle_t fcsp_handle;
/*
* Hash Functions
dissect_fcels_unbind (tvb, pinfo, tree, ti);
break;
default:
- call_dissector (data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
els_handle = create_dissector_handle (dissect_fcels, proto_fcels);
dissector_add_uint("fc.ftype", FC_FTYPE_ELS, els_handle);
- data_handle = find_dissector ("data");
fcsp_handle = find_dissector_add_dependency ("fcsp", proto_fcels);
}
static GHashTable *fcfcs_req_hash = NULL;
-static dissector_handle_t data_handle;
-
/*
* Hash Functions
*/
dissect_fcfcs_gcap (tvb, fcfcs_tree, isreq);
break;
default:
- call_dissector (data_handle, tvb, pinfo, fcfcs_tree);
+ call_data_dissector(tvb, pinfo, fcfcs_tree);
break;
}
fcs_handle = create_dissector_handle (dissect_fcfcs, proto_fcfcs);
dissector_add_uint("fcct.server", FCCT_GSRVR_FCS, fcs_handle);
-
- data_handle = find_dissector ("data");
}
/*
static GHashTable *fcfzs_req_hash = NULL;
-static dissector_handle_t data_handle;
-
/*
* Hash Functions
*/
dissect_fcfzs_arzs(tvb, fcfzs_tree, isreq);
break;
default:
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
fzs_handle = create_dissector_handle(dissect_fcfzs, proto_fcfzs);
dissector_add_uint("fcct.server", FCCT_GSRVR_FZS, fzs_handle);
-
- data_handle = find_dissector("data");
}
/*
static guint fcip_port = 3225;
static gboolean fcip_desegment = TRUE;
-static dissector_handle_t data_handle;
static dissector_handle_t fc_handle;
/* This routine attempts to locate the position of the next header in the
fc_data.ethertype = 0;
call_dissector_with_data(fc_handle, next_tvb, pinfo, tree, &fc_data);
}
- else if (data_handle) {
- call_dissector (data_handle, next_tvb, pinfo, tree);
+ else {
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
else {
fcip_handle = create_dissector_handle(dissect_fcip_handle, proto_fcip);
dissector_add_for_decode_as("tcp.port", fcip_handle);
- data_handle = find_dissector("data");
fc_handle = find_dissector_add_dependency("fc", proto_fcip);
}
static expert_field ei_fcoe_crc = EI_INIT;
-static dissector_handle_t data_handle;
static dissector_handle_t fc_handle;
static int
if (fc_handle) {
call_dissector_with_data(fc_handle, next_tvb, pinfo, tree, &fc_data);
- } else if (data_handle) {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ } else {
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
fcoe_handle = create_dissector_handle(dissect_fcoe, proto_fcoe);
dissector_add_uint("ethertype", ETHERTYPE_FCOE, fcoe_handle);
- data_handle = find_dissector("data");
fc_handle = find_dissector_add_dependency("fc", proto_fcoe);
}
static expert_field ei_fcoib_crc = EI_INIT;
-static dissector_handle_t data_handle;
static dissector_handle_t fc_handle;
/* global preferences */
if (fc_handle) {
call_dissector_with_data(fc_handle, next_tvb, pinfo, tree, &fc_data);
- } else if (data_handle) {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ } else {
+ call_data_dissector(next_tvb, pinfo, tree);
}
return TRUE;
if (!initialized) {
heur_dissector_add("infiniband.payload", dissect_fcoib, "Fibre Channel over Infiniband", "fc_infiniband", proto_fcoib, HEURISTIC_ENABLE);
- data_handle = find_dissector("data");
fc_handle = find_dissector_add_dependency("fc", proto_fcoib);
initialized = TRUE;
itlq_nexus_t *itlq;
} fcp_request_data_t;
-static dissector_handle_t data_handle;
-
/* Information Categories based on lower 4 bits of R_CTL */
#define FCP_IU_DATA 0x1
#define FCP_IU_UNSOL_CTL 0x2
dissect_fcp_srr(tvb, pinfo, tree, fchdr);
break;
default:
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
}
dissect_fcp_rsp(tvb, pinfo, tree, fcp_tree, fc_conv, fchdr, request_data);
break;
default:
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
/*xxx once the subdissectors return bytes consumed: proto_item_set_end(ti, tvb, offset);*/
fcp_handle = create_dissector_handle(dissect_fcp, proto_fcp);
dissector_add_uint("fc.ftype", FC_FTYPE_SCSI, fcp_handle);
-
- data_handle = find_dissector("data");
}
/*
static gint ett_sbccs_dib_ctlparam = -1;
static gint ett_sbccs_dib_linkctlinfo = -1;
-static dissector_handle_t data_handle;
-
#if 0
typedef struct {
guint32 conv_id;
if (supp_status_cnt) {
next_tvb = tvb_new_subset_remaining (tvb, offset+FC_SBCCS_DIB_LRC_HDR_SIZE);
- call_dissector (data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
break;
default:
next_tvb = tvb_new_subset_remaining (tvb, offset);
- call_dissector (data_handle, next_tvb, pinfo, dib_tree);
+ call_data_dissector(next_tvb, pinfo, dib_tree);
break;
}
if ((get_fc_sbccs_iu_type (tvb, 0) != FC_SBCCS_IU_CTL) &&
(get_fc_sbccs_iu_type (tvb, 0) != FC_SBCCS_IU_CMD_LINK_CTL)) {
next_tvb = tvb_new_subset_remaining (tvb, offset+FC_SBCCS_DIB_LRC_HDR_SIZE);
- call_dissector (data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
proto_fc_sbccs);
dissector_add_uint("fc.ftype", FC_FTYPE_SBCCS, fc_sbccs_handle);
-
- data_handle = find_dissector ("data");
}
/*
fcswils_dissector_t func;
} fcswils_func_table_t;
-static dissector_handle_t data_handle, fcsp_handle;
+static dissector_handle_t fcsp_handle;
static gint get_zoneobj_len(tvbuff_t *tvb, gint offset);
} else {
/* data dissector */
next_tvb = tvb_new_subset_remaining(tvb, offset+4);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
swils_handle = create_dissector_handle(dissect_fcswils, proto_fcswils);
dissector_add_uint("fc.ftype", FC_FTYPE_SWILS, swils_handle);
- data_handle = find_dissector("data");
fcsp_handle = find_dissector_add_dependency("fcsp", proto_fcswils);
}
#define FDDI_P_SHOST 7
static dissector_handle_t llc_handle;
-static dissector_handle_t data_handle;
static void
swap_mac_addr(guint8 *swapped_addr, tvbuff_t *tvb, gint offset)
return;
default :
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return;
} /* fc */
* Get a handle for the LLC dissector.
*/
llc_handle = find_dissector_add_dependency("llc", proto_fddi);
- data_handle = find_dissector("data");
dissector_add_uint("wtap_encap", WTAP_ENCAP_FDDI_BITSWAPPED,
fddi_bitswapped_handle);
static gint ett_fefd_flags = -1;
static gint ett_fefd_tlv = -1;
-static dissector_handle_t data_handle;
-
#define TYPE_DEVICE_ID 0x0001
#define TYPE_PORT_ID 0x0002
#define TYPE_ECHO 0x0003
}
}
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo, fefd_tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, fefd_tree);
return tvb_captured_length(tvb);
}
{
dissector_handle_t fefd_handle;
- data_handle = find_dissector("data");
fefd_handle = create_dissector_handle(dissect_fefd, proto_fefd);
dissector_add_uint("llc.force10_pid", 0x0111, fefd_handle);
}
#define FLEXNET_CTLLEN 15
#define FLEXNET_HDRLEN (FLEXNET_ADRLEN + FLEXNET_ADRLEN + FLEXNET_CTLLEN)
-static dissector_handle_t default_handle;
-
static int proto_flexnet = -1;
static int hf_flexnet_dst = -1;
static int hf_flexnet_src = -1;
/* Call sub-dissectors here */
next_tvb = tvb_new_subset_remaining(tvb, FLEXNET_HDRLEN);
- call_dissector( default_handle , next_tvb, pinfo, parent_tree );
+ call_data_dissector(next_tvb, pinfo, parent_tree );
return tvb_captured_length(tvb);
}
proto_reg_handoff_flexnet(void)
{
dissector_add_uint( "ax25.pid", AX25_P_FLEXNET, create_dissector_handle( dissect_flexnet, proto_flexnet ) );
-
- /*
- */
- default_handle = find_dissector( "data" );
-
}
/*
static expert_field ei_flexray_error_flag = EI_INIT;
static expert_field ei_flexray_stfi_flag = EI_INIT;
-static dissector_handle_t data_handle;
static dissector_table_t subdissector_table;
#define FLEXRAY_FRAME 0x01
if (call_subdissector) {
if (!dissector_try_uint_new(subdissector_table, 0, next_tvb, pinfo, tree, FALSE, &flexray_id))
{
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
else {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
}
flexray_handle = create_dissector_handle( dissect_flexray, proto_flexray );
dissector_add_uint("wtap_encap", WTAP_ENCAP_FLEXRAY, flexray_handle);
-
- data_handle = find_dissector("data");
}
/*
static dissector_table_t subdissector_table;
-static dissector_handle_t data_handle = NULL;
-
static gint ett_flip = -1;
static gint ett_flip_basic = -1;
static gint ett_flip_chksum = -1;
data_len = dissector_try_uint(subdissector_table, 0, payload_tvb, pinfo, tree);
if (data_len <= 0)
{
- data_len = call_dissector(data_handle, payload_tvb, pinfo, tree);
+ data_len = call_data_dissector(payload_tvb, pinfo, tree);
}
bytes_dissected += data_len;
flip_handle = create_dissector_handle(dissect_flip, proto_flip);
dissector_add_uint("ethertype", ETHERTYPE_FLIP, flip_handle);
-
- data_handle = find_dissector("data");
} /* proto_reg_handoff_flip() */
/*
#define INFO_STR_SIZE 1024
-static dissector_handle_t data_handle;
-
static const value_string packet_type_names[] = {
{ FMTP_TYP_OPERATIONAL, "Operational message" },
{ FMTP_TYP_OPERATOR, "Operator message" },
proto_tree_add_item(fmtp_tree, hf_fmtp_pdu_type, tvb, 4, 1, ENC_BIG_ENDIAN);
next_tvb = tvb_new_subset_remaining(tvb, FMTP_HEADER_LEN);
- call_dissector(data_handle, next_tvb, pinfo, fmtp_tree);
+ call_data_dissector(next_tvb, pinfo, fmtp_tree);
}
return tvb_captured_length(tvb);
{
/* Register as heuristic dissector for TCP */
heur_dissector_add("tcp", dissect_fmtp, "FMTP over TCP", "fmtp_tcp", proto_fmtp, HEURISTIC_ENABLE);
- data_handle = find_dissector("data");
}
/*
static int frame_tap = -1;
-static dissector_handle_t data_handle;
static dissector_handle_t docsis_handle;
/* Preferences */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "UNKNOWN");
col_add_fstr(pinfo->cinfo, COL_INFO, "WTAP_ENCAP = %d",
pinfo->pkt_encap);
- call_dissector_with_data(data_handle,
- tvb, pinfo, parent_tree,
- (void *)pinfo->pseudo_header);
+ call_data_dissector(tvb, pinfo, parent_tree);
}
}
break;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "UNKNOWN");
col_add_fstr(pinfo->cinfo, COL_INFO, "WTAP_ENCAP = %d",
file_type_subtype);
- call_dissector(data_handle,tvb, pinfo, parent_tree);
+ call_data_dissector(tvb, pinfo, parent_tree);
}
}
break;
void
proto_reg_handoff_frame(void)
{
- data_handle = find_dissector("data");
docsis_handle = find_dissector_add_dependency("docsis", proto_frame);
}
static expert_field ei_geneve_opt_len_invalid = EI_INIT;
static dissector_table_t ethertype_dissector_table;
-static dissector_handle_t data_handle;
static void
print_flags(guint8 flags, proto_item *flag_item)
next_tvb = tvb_new_subset_remaining(tvb, offset);
if (!dissector_try_uint(ethertype_dissector_table, proto_type, next_tvb, pinfo, tree))
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
dissector_add_for_decode_as("udp.port", geneve_handle);
ethertype_dissector_table = find_dissector_table("ethertype");
- data_handle = find_dissector("data");
}
/*
static gint ett_gfp_ehec = -1;
static gint ett_gfp_fcs = -1;
-static dissector_handle_t data_handle;
static dissector_table_t gfp_dissector_table;
/* ITU-T G.7041 6.1.1, 6.2 */
guint pti, pfi, exi, upi;
guint fcs, fcs_calc;
guint fcs_len = 0;
- dissector_handle_t handle;
/* G.7041 6.1.2.3 Payload area scrambling
* Note that payload when sent on the wire is scrambled as per ATM
switch (pti) {
case GFP_USER_DATA:
case GFP_MANAGEMENT_COMMUNICATIONS:
- handle = dissector_get_uint_handle(gfp_dissector_table, upi);
- if (handle == NULL) {
+ if (!dissector_try_uint(gfp_dissector_table, upi, payload_tvb, pinfo, tree)) {
expert_add_info_format(pinfo, type_ti, &ei_gfp_payload_undecoded, "Payload type 0x%02x (%s) unsupported", upi, rval_to_str_const(upi, gfp_upi_data_rvals, "UNKNOWN"));
- handle = data_handle;
- }
- if (!call_dissector(handle, payload_tvb, pinfo, tree)) {
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
}
break;
case GFP_CLIENT_MANAGEMENT:
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
break;
default:
gfp_handle = create_dissector_handle(dissect_gfp,
proto_gfp);
- data_handle = find_dissector("data");
-
dissector_add_uint("wtap_encap", WTAP_ENCAP_GFP_T, gfp_handle);
dissector_add_uint("wtap_encap", WTAP_ENCAP_GFP_F, gfp_handle);
NULL
};
-static dissector_handle_t data_handle;
static dissector_handle_t giop_tcp_handle;
#define GIOP_MESSAGE_FLAGS_ZIOP_ENABLED 0x08
header.GIOP_version.major, header.GIOP_version.minor);
payload_tvb = tvb_new_subset_remaining (tvb, GIOP_HEADER_SIZE);
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
void proto_reg_handoff_giop (void) {
- data_handle = find_dissector("data");
heur_dissector_add("tcp", dissect_giop_heur, "GIOP over TCP", "giop_tcp", proto_giop, HEURISTIC_ENABLE);
/* Support DIOP (GIOP/UDP) */
heur_dissector_add("udp", dissect_giop_heur, "DIOP (GIOP/UDP)", "giop_udp", proto_giop, HEURISTIC_ENABLE);
void proto_register_gmr1_rach(void);
-void proto_reg_handoff_gmr1_rach(void);
/* GMR-1 RACH proto */
static int proto_gmr1_rach = -1;
static gint ett_rach_gps_pos = -1;
static gint ett_rach_gmprs_req_type = -1;
-/* Handoffs */
-static dissector_handle_t data_handle;
-
/* Fields */
static int hf_rach_prio = -1;
static int hf_rach_est_cause = -1;
if (!ies) {
col_append_str(pinfo->cinfo, COL_INFO, "(Invalid)");
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
register_dissector("gmr1_rach", dissect_gmr1_rach, proto_gmr1_rach);
}
-void
-proto_reg_handoff_gmr1_rach(void)
-{
- data_handle = find_dissector("data");
-}
-
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
static gint ett_rr_pd = -1;
-/* Handoffs */
-static dissector_handle_t data_handle;
-
/* ------------------------------------------------------------------------ */
/* Error handling */
err:
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
register_dissector("gmr1_ccch", dissect_gmr1_ccch, proto_gmr1_ccch);
}
-void
-proto_reg_handoff_gmr1_rr(void)
-{
- data_handle = find_dissector("data");
-}
-
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
#include <epan/llcsaps.h>
void proto_register_gmrp(void);
-void proto_reg_handoff_gmrp(void);
/* Initialize the protocol and registered fields */
static int proto_gmrp = -1;
static expert_field ei_gmrp_proto_id = EI_INIT;
-static dissector_handle_t data_handle;
-
/* Constant definitions */
#define GARP_DEFAULT_PROTOCOL_ID 0x0001
#define GARP_END_OF_MARK 0x00
if (protocol_id != GARP_DEFAULT_PROTOCOL_ID)
{
expert_add_info(pinfo, ti, &ei_gmrp_proto_id);
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, GARP_PROTOCOL_ID + 2),
+ call_data_dissector(tvb_new_subset_remaining(tvb, GARP_PROTOCOL_ID + 2),
pinfo, tree);
return tvb_captured_length(tvb);
}
}
else
{
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset),
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset),
pinfo, tree);
return tvb_captured_length(tvb);
}
/* GMRP supports Group Membership and Service Requirement as attribute types */
if ( (octet != GMRP_ATTRIBUTE_TYPE_GROUP_MEMBERSHIP) && (octet != GMRP_ATTRIBUTE_TYPE_SERVICE_REQUIREMENT) )
{
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset), pinfo,
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo,
tree);
return tvb_captured_length(tvb);
}
}
else
{
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset),
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset),
pinfo, tree);
return tvb_captured_length(tvb);
}
case GMRP_EVENT_LEAVEALL:
if (octet != GMRP_LENGTH_LEAVEALL)
{
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset),
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset),
pinfo, tree);
return tvb_captured_length(tvb);
}
if ( (octet != GMRP_GROUP_MEMBERSHIP_NON_LEAVEALL) &&
(octet != GMRP_SERVICE_REQUIREMENT_NON_LEAVEALL) )
{
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset),
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset),
pinfo, tree);
return tvb_captured_length(tvb);
}
}
else
{
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset),
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset),
pinfo, tree);
return tvb_captured_length(tvb);
}
break;
default:
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset),
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset),
pinfo, tree);
return tvb_captured_length(tvb);
}
}
-void
-proto_reg_handoff_gmrp(void){
- data_handle = find_dissector("data");
-}
-
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
static expert_field ei_llcgprs_no_info_field = EI_INIT;
-static dissector_handle_t data_handle;
static dissector_handle_t sndcp_xid_handle;
static gboolean ignore_cipher_bit = FALSE;
if (!dissector_try_uint(llcgprs_subdissector_table, sapi, next_tvb, pinfo, tree))
/* if no subdissector is found, call the data dissector */
{
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
break;
next_tvb = tvb_new_subset_length(tvb, offset, (llc_data_length-offset));
if (!dissector_try_uint(llcgprs_subdissector_table, sapi, next_tvb, pinfo, tree))
{
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
break;
/* otherwise - call a subdissector */
if (!dissector_try_uint(llcgprs_subdissector_table, sapi, next_tvb, pinfo, tree))
{
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
}
else
{
/* ciphered information - just parse it as data */
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
break;
gprs_llc_handle = find_dissector("llcgprs");
dissector_add_uint("wtap_encap", WTAP_ENCAP_GPRS_LLC, gprs_llc_handle);
- data_handle = find_dissector("data");
sndcp_xid_handle = find_dissector_add_dependency("sndcpxid", proto_llcgprs);
}
static expert_field ei_gre_checksum_incorrect = EI_INIT;
static dissector_table_t gre_dissector_table;
-static dissector_handle_t data_handle;
/* bit positions for flags in header */
#define GRE_CHECKSUM 0x8000
next_tvb = tvb_new_subset_remaining(tvb, offset);
pinfo->flags.in_gre_pkt = TRUE;
if (!dissector_try_uint(gre_dissector_table, type, next_tvb, pinfo, tree))
- call_dissector(data_handle,next_tvb, pinfo, gre_tree);
+ call_data_dissector(next_tvb, pinfo, gre_tree);
}
return tvb_captured_length(tvb);
}
dissector_add_uint("ip.proto", IP_PROTO_GRE, gre_handle);
register_capture_dissector("ip.proto", IP_PROTO_GRE, capture_gre, proto_gre);
register_capture_dissector("ipv6.nxt", IP_PROTO_GRE, capture_gre, proto_gre);
- data_handle = find_dissector("data");
}
/*
static dissector_table_t u2u_dissector_table;
-static dissector_handle_t data_handle;
static dissector_handle_t gsm_map_handle;
static dissector_handle_t rp_handle;
/*
* too short to be DTAP
*/
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return len;
}
dissector_add_uint("lapdm.sapi", 0 , dtap_handle); /* LAPDm: CC/RR/MM */
dissector_add_uint("lapdm.sapi", 3 , dtap_handle); /* LAPDm: SMS/SS */
- data_handle = find_dissector("data");
gsm_map_handle = find_dissector_add_dependency("gsm_map", proto_a_dtap);
rp_handle = find_dissector_add_dependency("gsm_a_rp", proto_a_dtap);
}
static expert_field ei_gsm_a_gm_not_enough_data = EI_INIT;
static expert_field ei_gsm_a_gm_undecoded = EI_INIT;
-static dissector_handle_t data_handle;
static dissector_handle_t rrc_irat_ho_info_handle;
static dissector_handle_t lte_rrc_ue_eutra_cap_handle;
/*
* dissect the embedded DATA message
*/
- call_dissector(data_handle, l3_tvb, pinfo, pco_tree);
+ call_data_dissector(l3_tvb, pinfo, pco_tree);
}
}
}
void
proto_reg_handoff_gsm_a_gm(void)
{
- data_handle = find_dissector("data");
rrc_irat_ho_info_handle = find_dissector_add_dependency("rrc.irat.irat_ho_info", proto_a_gm);
lte_rrc_ue_eutra_cap_handle = find_dissector_add_dependency("lte-rrc.ue_eutra_cap", proto_a_gm);
}
static expert_field ei_gsm_a_rr_unknown_version = EI_INIT;
static expert_field ei_gsm_a_rr_extraneous_data = EI_INIT;
-static dissector_handle_t data_handle;
static dissector_handle_t rrlp_dissector;
/*
* too short to be CCCH
*/
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
void
proto_reg_handoff_gsm_a_rr(void)
{
- data_handle = find_dissector("data");
rrc_irat_ho_info_handle = find_dissector_add_dependency("rrc.irat.irat_ho_info", proto_a_rr);
rrc_irat_ho_to_utran_cmd_handle = find_dissector_add_dependency("rrc.irat.ho_to_utran_cmd", proto_a_rr);
rrlp_dissector = find_dissector("rrlp");
static expert_field ei_gsm_cbch_seq_num_reserved = EI_INIT;
static expert_field ei_gsm_cbch_lpd = EI_INIT;
-static dissector_handle_t data_handle;
static dissector_handle_t cbs_handle;
/* reassembly of CHCH blocks */
case 0x0F:
expert_add_info(pinfo, seq_item, &ei_gsm_cbch_seq_num_null);
- call_dissector(data_handle, tvb, pinfo, cbch_tree);
+ call_data_dissector(tvb, pinfo, cbch_tree);
break;
default:
expert_add_info(pinfo, seq_item, &ei_gsm_cbch_seq_num_reserved);
- call_dissector(data_handle, tvb, pinfo, cbch_tree);
+ call_data_dissector(tvb, pinfo, cbch_tree);
break;
}
if (reass_tvb)
else
{
expert_add_info(pinfo, lpd_item, &ei_gsm_cbch_lpd);
- call_dissector(data_handle, tvb, pinfo, cbch_tree);
+ call_data_dissector(tvb, pinfo, cbch_tree);
}
return tvb_captured_length(tvb);
}
void
proto_reg_handoff_gsm_cbch(void)
{
- data_handle = find_dissector("data");
cbs_handle = find_dissector_add_dependency("gsm_cbs", proto_cbch);
}
static expert_field ei_gsm_map_undecoded = EI_INIT;
static dissector_handle_t gsm_sms_handle; /* SMS TPDU */
-static dissector_handle_t data_handle;
static dissector_handle_t ranap_handle;
static dissector_handle_t dtap_handle;
static dissector_handle_t map_handle;
if (actx->external.direct_ref_present){
offset=call_ber_oid_callback(actx->external.direct_reference, tvb, offset, actx->pinfo, ext_tree, NULL);
}else{
- call_dissector(data_handle, tvb, actx->pinfo, ext_tree);
+ call_data_dissector(tvb, actx->pinfo, ext_tree);
offset = tvb_reported_length_remaining(tvb,offset);
}
/*--- End of included file: packet-gsm_map-fn.c ---*/
-#line 831 "./asn1/gsm_map/packet-gsm_map-template.c"
+#line 830 "./asn1/gsm_map/packet-gsm_map-template.c"
/* Specific translation for MAP V3 */
const value_string gsm_map_V1V2_opr_code_strings[] = {
/* Unknown or empty loop list OPERATION */
/*--- End of included file: packet-gsm_map-table.c ---*/
-#line 842 "./asn1/gsm_map/packet-gsm_map-template.c"
+#line 841 "./asn1/gsm_map/packet-gsm_map-template.c"
{ 0, NULL }
};
/* Unknown or empty loop list OPERATION */
/*--- End of included file: packet-gsm_map-table.c ---*/
-#line 848 "./asn1/gsm_map/packet-gsm_map-template.c"
+#line 847 "./asn1/gsm_map/packet-gsm_map-template.c"
{ 0, NULL }
};
#endif
if (!map_prefs_initialized) {
map_prefs_initialized = TRUE;
- data_handle = find_dissector("data");
ranap_handle = find_dissector_add_dependency("ranap", proto_gsm_map);
dtap_handle = find_dissector_add_dependency("gsm_a_dtap", proto_gsm_map);
gsm_sms_handle = find_dissector_add_dependency("gsm_sms", proto_gsm_map);
NULL, HFILL }},
/*--- End of included file: packet-gsm_map-hfarr.c ---*/
-#line 3056 "./asn1/gsm_map/packet-gsm_map-template.c"
+#line 3054 "./asn1/gsm_map/packet-gsm_map-template.c"
};
/* List of subtrees */
&ett_NokiaMAP_Extensions_AllowedServiceData,
/*--- End of included file: packet-gsm_map-ettarr.c ---*/
-#line 3090 "./asn1/gsm_map/packet-gsm_map-template.c"
+#line 3088 "./asn1/gsm_map/packet-gsm_map-template.c"
};
static ei_register_info ei[] = {
/*--- End of included file: packet-gsm_map-dis-tab.c ---*/
-#line 3146 "./asn1/gsm_map/packet-gsm_map-template.c"
+#line 3144 "./asn1/gsm_map/packet-gsm_map-template.c"
oid_add_from_string("ericsson-gsm-Map-Ext","1.2.826.0.1249.58.1.0" );
oid_add_from_string("accessTypeNotAllowed-id","1.3.12.2.1107.3.66.1.2");
/*oid_add_from_string("map-ac networkLocUp(1) version3(3)","0.4.0.0.1.0.1.3" );
#include "packet-gsm_rlcmac.h"
void proto_register_gsm_rlcmac(void);
-void proto_reg_handoff_gsm_rlcmac(void);
/* private typedefs */
typedef struct
static expert_field ei_gsm_rlcmac_unknown_pacch_access_burst = EI_INIT;
static expert_field ei_gsm_rlcmac_stream_not_supported = EI_INIT;
-static dissector_handle_t data_handle;
-
/* Payload type as defined in TS 44.060 / 10.4.7 */
#define PAYLOAD_TYPE_DATA 0
#define PAYLOAD_TYPE_CTRL_NO_OPT_OCTET 1
i, li);
}
data_tvb = tvb_new_subset_length(tvb, octet_offset, octet_length - octet_offset);
- call_dissector(data_handle, data_tvb, pinfo, subtree);
+ call_data_dissector(data_tvb, pinfo, subtree);
octet_offset = octet_length;
break;
"data segment: LI[%d]=%d indicates: (Last segment of) LLC frame (%d octets)",
i, li, li);
data_tvb = tvb_new_subset_length(tvb, octet_offset, li);
- call_dissector(data_handle, data_tvb, pinfo, subtree);
+ call_data_dissector(data_tvb, pinfo, subtree);
octet_offset += li;
break;
}
subtree = proto_tree_add_subtree(tree, tvb, octet_offset, octet_length - octet_offset, ett_data_segments, NULL, "Padding Octets");
}
data_tvb = tvb_new_subset_length(tvb, octet_offset, octet_length - octet_offset);
- call_dissector(data_handle, data_tvb, pinfo, subtree);
+ call_data_dissector(data_tvb, pinfo, subtree);
octet_offset = octet_length;
}
return (octet_offset - initial_offset);
i, li);
}
data_tvb = tvb_new_subset_length(tvb, octet_offset, octet_length - octet_offset);
- call_dissector(data_handle, data_tvb, pinfo, subtree);
+ call_data_dissector(data_tvb, pinfo, subtree);
octet_offset = octet_length;
break;
"data segment: LI[%d]=%d indicates: (Last segment of) LLC frame (%d octets)",
i, li, li);
data_tvb = tvb_new_subset_length(tvb, octet_offset, li);
- call_dissector(data_handle, data_tvb, pinfo, subtree);
+ call_data_dissector(data_tvb, pinfo, subtree);
octet_offset += li;
break;
}
subtree = proto_tree_add_subtree(tree, tvb, octet_offset, octet_length - octet_offset, ett_data_segments, NULL,
"data segment: LI not present: \n The Upper Layer PDU in the current RLC data block either fills the current RLC data block precisely \nor continues in the following in-sequence RLC data block");
data_tvb = tvb_new_subset_length(tvb, octet_offset, octet_length - octet_offset);
- call_dissector(data_handle, data_tvb, pinfo, subtree);
+ call_data_dissector(data_tvb, pinfo, subtree);
octet_offset = octet_length;
}
return (octet_offset - initial_offset);
else
{
proto_tree_add_expert(tree, pinfo, &ei_gsm_rlcmac_unknown_pacch_access_burst, tvb, 0, -1);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
}
register_dissector("gsm_rlcmac_dl", dissect_gsm_rlcmac_downlink, proto_gsm_rlcmac);
}
-void
-proto_reg_handoff_gsm_rlcmac(void)
-{
- data_handle = find_dissector("data");
-}
-
/*
* Editor modelines
static dissector_handle_t lapdm_handle;
static dissector_handle_t dtap_handle;
-static dissector_handle_t data_handle;
static gboolean dcs1800_gsm = TRUE;
}
else {
/* Either RACH, or something invalid */
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
break;
case GSM_UM_CHANNEL_SACCH:
call_dissector(lapdm_handle, tvb, pinfo, tree);
break;
default:
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
return tvb_captured_length(tvb);
lapdm_handle = find_dissector_add_dependency("lapdm", proto_gsm_um);
dtap_handle = find_dissector_add_dependency("gsm_a_dtap", proto_gsm_um);
- data_handle = find_dissector("data");
gsm_um_handle = create_dissector_handle(dissect_gsm_um, proto_gsm_um);
static dissector_handle_t sync_handle;
static dissector_handle_t gtpcdr_handle;
static dissector_handle_t sndcpxid_handle;
-static dissector_handle_t data_handle;
static dissector_handle_t gtpv2_handle;
static dissector_handle_t bssgp_handle;
static dissector_table_t bssap_pdu_type_table;
if (sndcpxid_handle)
call_dissector(sndcpxid_handle, next_tvb, pinfo, tree);
else
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return 4 + length;
sync_handle = find_dissector_add_dependency("sync", proto_gtp);
gtpcdr_handle = find_dissector_add_dependency("gtpcdr", proto_gtp);
sndcpxid_handle = find_dissector_add_dependency("sndcpxid", proto_gtp);
- data_handle = find_dissector("data");
gtpv2_handle = find_dissector_add_dependency("gtpv2", proto_gtp);
bssgp_handle = find_dissector_add_dependency("bssgp", proto_gtp);
bssap_pdu_type_table = find_dissector_table("bssap.pdu_type");
#include <epan/expert.h>
void proto_register_gvrp(void);
-void proto_reg_handoff_gvrp(void);
/* Initialize the protocol and registered fields */
static int proto_gvrp = -1;
static expert_field ei_gvrp_proto_id = EI_INIT;
-static dissector_handle_t data_handle;
-
/* Constant definitions */
#define GARP_DEFAULT_PROTOCOL_ID 0x0001
#define GARP_END_OF_MARK 0x00
if (protocol_id != GARP_DEFAULT_PROTOCOL_ID)
{
expert_add_info(pinfo, id_item, &ei_gvrp_proto_id);
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, GARP_PROTOCOL_ID + 2),
+ call_data_dissector(tvb_new_subset_remaining(tvb, GARP_PROTOCOL_ID + 2),
pinfo, tree);
return tvb_captured_length(tvb);
}
}
else
{
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
return tvb_captured_length(tvb);
}
}
/* GVRP only supports one attribute type. */
if (octet != GVRP_ATTRIBUTE_TYPE)
{
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset),
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset),
pinfo, tree);
return tvb_captured_length(tvb);
}
}
else
{
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
return tvb_captured_length(tvb);
}
}
case GVRP_EVENT_LEAVEALL:
if (octet != GVRP_LENGTH_LEAVEALL)
{
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset), pinfo,
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo,
tree);
return tvb_captured_length(tvb);
}
case GVRP_EVENT_EMPTY:
if (octet != GVRP_LENGTH_NON_LEAVEALL)
{
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset),pinfo,
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset),pinfo,
tree);
return tvb_captured_length(tvb);
}
break;
default:
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
return tvb_captured_length(tvb);
}
}
register_dissector("gvrp", dissect_gvrp, proto_gvrp);
}
-void
-proto_reg_handoff_gvrp(void){
- data_handle = find_dissector("data");
-}
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
static int hf_h1_org = -1;
static int hf_h1_response_value = -1;
-static dissector_handle_t data_handle;
-
#define EMPTY_BLOCK 0xFF
#define OPCODE_BLOCK 0x01
if (tvb_reported_length_remaining(tvb, offset) > 0) {
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return TRUE;
"Sinec H1 over COTP (inactive subset)", "hi_cotp_is", proto_h1, HEURISTIC_ENABLE);
heur_dissector_add("tcp", dissect_h1,
"Sinec H1 over TCP", "hi_tcp", proto_h1, HEURISTIC_ENABLE);
-
- data_handle = find_dissector("data");
}
/*
static dissector_table_t hci_h1_table;
static dissector_handle_t hci_h1_handle;
-static dissector_handle_t data_handle;
static const value_string hci_h1_type_vals[] = {
{BTHCI_CHANNEL_COMMAND, "HCI Command"},
next_tvb = tvb_new_subset_remaining(tvb, 0);
if (!dissector_try_uint_new(hci_h1_table, type, next_tvb, pinfo, tree, TRUE, bluetooth_data)) {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_reported_length(tvb);
void
proto_reg_handoff_hci_h1(void)
{
- data_handle = find_dissector("data");
-
dissector_add_uint("bluetooth.encap", WTAP_ENCAP_BLUETOOTH_HCI, hci_h1_handle);
}
static dissector_handle_t hci_h4_handle;
static dissector_table_t hci_h4_table;
-static dissector_handle_t data_handle;
static const value_string hci_h4_type_vals[] = {
{HCI_H4_TYPE_CMD, "HCI Command"},
next_tvb = tvb_new_subset_remaining(tvb, 1);
if (!dissector_try_uint_new(hci_h4_table, type, next_tvb, pinfo, tree, TRUE, bluetooth_data)) {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return 1;
void
proto_reg_handoff_hci_h4(void)
{
- data_handle = find_dissector("data");
-
dissector_add_uint("bluetooth.encap", WTAP_ENCAP_BLUETOOTH_H4, hci_h4_handle);
dissector_add_uint("bluetooth.encap", WTAP_ENCAP_BLUETOOTH_H4_WITH_PHDR, hci_h4_handle);
}
static gint ett_hpext = -1;
-static dissector_handle_t data_handle;
-
static int
dissect_hpext(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
next_tvb = tvb_new_subset_remaining(tvb, 7);
if (!dissector_try_uint(subdissector_table,
dxsap, next_tvb, pinfo, tree)) {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
return tvb_captured_length(tvb);
void
proto_reg_handoff_hpext(void)
{
- data_handle = find_dissector("data");
-
dissector_add_uint("llc.dsap", SAP_HPEXT, hpext_handle);
}
/* Initialize the subtree pointers */
static gint ett_hsr_frame = -1;
-static dissector_handle_t data_handle;
-
/* Code to actually dissect the packets */
static int
dissect_hsr_frame(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
etype = tvb_get_ntohs(tvb, HSR_TOTAL_LENGTH);
if (!dissector_try_uint(ethertype_subdissector_table, etype, next_tvb, pinfo, tree))
- call_dissector(data_handle, next_tvb, pinfo, hsr_tree);
+ call_data_dissector(next_tvb, pinfo, hsr_tree);
return tvb_captured_length(tvb);
}
dissector_add_uint("ethertype", ETHERTYPE_HSR, hsr_frame_handle);
ethertype_subdissector_table = find_dissector_table("ethertype");
- data_handle = find_dissector("data");
}
/*
void proto_reg_handoff_hsrp(void);
static gint proto_hsrp = -1;
-static dissector_handle_t data_handle;
static gint hf_hsrp_version = -1;
static gint hf_hsrp_opcode = -1;
/* offset += 4; */
} else {
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, hsrp_tree);
+ call_data_dissector(next_tvb, pinfo, hsrp_tree);
}
/* is MD5 authentication being used with HSRPv1? */
if (tvb_captured_length(tvb) == 50) { /* 20 bytes of regular HSRP data + 30 bytes of authentication payload */
} else {
/* Unknown protocol */
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, hsrp_tree);
+ call_data_dissector(next_tvb, pinfo, hsrp_tree);
break;
}
/* offset+=16; */
}
} else {
/* Undefined TLV */
- if (tree) {
- next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, hsrp_tree);
- }
+ next_tvb = tvb_new_subset_remaining(tvb, offset);
+ call_data_dissector(next_tvb, pinfo, hsrp_tree);
break;
}
offset = offset2+len+2;
{
dissector_handle_t hsrp_handle;
- data_handle = find_dissector("data");
hsrp_handle = create_dissector_handle(dissect_hsrp, proto_hsrp);
dissector_add_uint("udp.port", UDP_PORT_HSRP, hsrp_handle);
dissector_add_uint("udp.port", UDP_PORT_HSRP2_V6, hsrp_handle);
static dissector_handle_t http_handle;
-static dissector_handle_t data_handle;
static dissector_handle_t media_handle;
static dissector_handle_t websocket_handle;
static dissector_handle_t http2_handle;
if (headers.transfer_encoding_chunked) {
if (!http_dechunk_body) {
/* Chunking disabled, cannot dissect further. */
- call_dissector(data_handle, next_tvb, pinfo,
- http_tree);
+ call_data_dissector(next_tvb, pinfo, http_tree);
goto body_dissected;
}
* "compress", or "deflate" as *transfer* encodings;
* just handle them as data for now.
*/
- call_dissector(data_handle, next_tvb, pinfo, http_tree);
+ call_data_dissector(next_tvb, pinfo, http_tree);
goto body_dissected;
default:
/* Nothing to do for "identity" or when header is
"Uncompressed entity body");
} else {
proto_item_append_text(e_ti, " [Error: Decompression failed]");
- call_dissector(data_handle, next_tvb, pinfo,
- e_tree);
+ call_data_dissector(next_tvb, pinfo, e_tree);
goto body_dissected;
}
call_dissector_with_data(media_handle, next_tvb, pinfo, tree, media_str);
} else {
/* Call the default data dissector */
- call_dissector(data_handle, next_tvb, pinfo, http_tree);
+ call_data_dissector(next_tvb, pinfo, http_tree);
}
}
* dissection is done on the reassembled data.
*/
data_tvb = tvb_new_subset_length(tvb, chunk_offset, chunk_size);
- call_dissector(data_handle, data_tvb, pinfo,
- chunk_subtree);
+ call_data_dissector(data_tvb, pinfo, chunk_subtree);
proto_tree_add_item(chunk_subtree, hf_http_chunked_boundary, tvb,
chunk_offset + chunk_size, 2, ENC_NA);
* dissection is done on the reassembled data.
*/
data_tvb = tvb_new_subset_length(tvb, chunk_offset, chunk_size);
- call_dissector(data_handle, data_tvb, pinfo,
- chunk_subtree);
+ call_data_dissector(data_tvb, pinfo, chunk_subtree);
proto_tree_add_item(chunk_subtree, hf_http_chunk_boundary, tvb,
chunk_offset + chunk_size, 2, ENC_NA);
* dissector directly.
*/
if (value_is_in_range(http_tcp_range, uri_port) || (conv && conversation_get_dissector(conv, pinfo->num) == http_handle)) {
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
} else {
/* set pinfo->{src/dst port} and call the TCP sub-dissector lookup */
if (!from_server)
{
dissector_handle_t ssdp_handle;
- data_handle = find_dissector("data");
media_handle = find_dissector_add_dependency("media", proto_http);
websocket_handle = find_dissector_add_dependency("websocket", proto_http);
http2_handle = find_dissector("http2");
/* Header name_length + name + value_length + value */
static char *http2_header_pstr = NULL;
-static dissector_handle_t data_handle;
static dissector_handle_t http2_handle;
#define FRAME_HEADER_LENGTH 9
void
proto_reg_handoff_http2(void)
{
- data_handle = find_dissector("data");
-
dissector_add_for_decode_as("tcp.port", http2_handle);
heur_dissector_add("ssl", dissect_http2_heur_ssl, "HTTP2 over SSL", "http2_ssl", proto_http2, HEURISTIC_ENABLE);
static gint ett_i2c = -1;
-static dissector_handle_t data_handle;
static dissector_table_t subdissector_table;
/* I2C packet flags. */
have a unique identifier to determine subdissector */
if (!dissector_try_uint(subdissector_table, 0, tvb, pinfo, tree))
{
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
}
return tvb_captured_length(tvb);
{
dissector_handle_t i2c_handle;
- data_handle = find_dissector("data");
-
i2c_handle = create_dissector_handle(dissect_i2c, proto_i2c);
dissector_add_uint("wtap_encap", WTAP_ENCAP_I2C, i2c_handle);
register_capture_dissector("wtap_encap", WTAP_ENCAP_I2C, capture_i2c, proto_i2c);
"iax2 fragments"
};
-static dissector_handle_t data_handle;
-
/* data-call subdissectors, AST_DATAFORMAT_* */
static dissector_table_t iax2_dataformat_dissector_table;
/* voice/video call subdissectors, AST_FORMAT_* */
/* codec dissector handled our data */
} else {
/* we don't know how to dissect our data: dissect it as data */
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
#ifdef DEBUG_DESEGMENT
v110_handle = find_dissector("v110");
if (v110_handle)
dissector_add_uint("iax2.dataformat", AST_DATAFORMAT_V110, v110_handle);
- data_handle = find_dissector("data");
}
/*
static gint ett_icap = -1;
-static dissector_handle_t data_handle;
static dissector_handle_t http_handle;
#define TCP_PORT_ICAP 1344
{
dissector_handle_t icap_handle;
- data_handle = find_dissector("data");
http_handle = find_dissector_add_dependency("http", proto_icap);
icap_handle = create_dissector_handle(dissect_icap, proto_icap);
#define ICMP_MIP_CHALLENGE 24
static dissector_handle_t ip_handle;
-static dissector_handle_t data_handle;
static const value_string icmp_type_str[] = {
{ICMP_ECHOREPLY, "Echo (ping) reply"},
* malformed packets as we try to access data that isn't there. */
if (tvb_captured_length_remaining(tvb, 8) < 8) {
if (tvb_captured_length_remaining(tvb, 8) > 0) {
- call_dissector(data_handle,
- tvb_new_subset_remaining
+ call_data_dissector(tvb_new_subset_remaining
(tvb, 8), pinfo, icmp_tree);
}
break;
tvb, 8, 8,
&time_relative);
PROTO_ITEM_SET_GENERATED(ti);
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb,
+ call_data_dissector(tvb_new_subset_remaining(tvb,
8 + 8),
pinfo, icmp_tree);
} else {
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, 8),
+ call_data_dissector(tvb_new_subset_remaining(tvb, 8),
pinfo, icmp_tree);
}
break;
icmp_tree);
}
} else {
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, 8),
+ call_data_dissector(tvb_new_subset_remaining(tvb, 8),
pinfo, icmp_tree);
}
break;
*/
ip_handle = find_dissector_add_dependency("ip", proto_icmp);
icmp_handle = find_dissector("icmp");
- data_handle = find_dissector("data");
dissector_add_uint("ip.proto", IP_PROTO_ICMP, icmp_handle);
register_capture_dissector("ip.proto", IP_PROTO_ICMP, capture_icmp, proto_icmp);
static dissector_handle_t icmpv6_handle;
static dissector_handle_t ipv6_handle;
-static dissector_handle_t data_handle;
#define ICMP6_DST_UNREACH 1
#define ICMP6_PACKET_TOO_BIG 2
/* The contained packet is an IPv6 datagram; dissect it. */
offset += call_dissector(ipv6_handle, next_tvb, pinfo, tree);
} else
- offset += call_dissector(data_handle, next_tvb, pinfo, tree);
+ offset += call_data_dissector(next_tvb, pinfo, tree);
/* Restore the "we're inside an error packet" flag. */
pinfo->flags.in_error_pkt = save_in_error_pkt;
}
}
next_tvb = tvb_new_subset_remaining(tvb, offset);
- offset += call_dissector(data_handle, next_tvb, pinfo, icmp6_tree);
+ offset += call_data_dissector(next_tvb, pinfo, icmp6_tree);
}
}
* Get a handle for the IPv6 dissector.
*/
ipv6_handle = find_dissector_add_dependency("ipv6", proto_icmpv6);
- data_handle = find_dissector("data");
}
/*
static gint ett_idp = -1;
-static dissector_handle_t data_handle;
-
static dissector_table_t idp_type_dissector_table;
/*
if (!dissector_try_uint(idp_type_dissector_table, type, next_tvb,
pinfo, tree))
{
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
idp_handle = create_dissector_handle(dissect_idp, proto_idp);
dissector_add_uint("ethertype", ETHERTYPE_XNS_IDP, idp_handle);
dissector_add_uint("chdlc.protocol", ETHERTYPE_XNS_IDP, idp_handle);
-
- data_handle = find_dissector("data");
}
/*
static dissector_handle_t llc_handle;
static dissector_handle_t ipx_handle;
static dissector_handle_t eth_withoutfcs_handle;
-static dissector_handle_t data_handle;
static int wlan_tap = -1;
/* check protocol activation */
if (!proto_is_protocol_enabled(find_protocol_by_id(proto_wlan_mgt))) {
- call_dissector(data_handle,tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return;
}
PROTO_ITEM_SET_GENERATED(item);
}
next_tvb = tvb_new_subset (tvb, hdr_len, len, reported_len);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
goto end_of_wlan;
}
}
if ((!is_centrino) && (wlan_ignore_wep == WLAN_IGNORE_WEP_NO)) {
/* Some wireless drivers (such as Centrino) WEP payload already decrypted */
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
goto end_of_wlan;
}
} else {
/* Just show this as an incomplete fragment. */
col_set_str(pinfo->cinfo, COL_INFO, "Fragmented IEEE 802.11 frame");
next_tvb = tvb_new_subset (tvb, hdr_len, len, reported_len);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
pinfo->fragmented = save_fragmented;
goto end_of_wlan;
}
llc_handle = find_dissector_add_dependency("llc", proto_wlan);
ipx_handle = find_dissector_add_dependency("ipx", proto_wlan);
eth_withoutfcs_handle = find_dissector_add_dependency("eth_withoutfcs", proto_wlan);
- data_handle = find_dissector("data");
ieee80211_handle = find_dissector("wlan");
dissector_add_uint("wtap_encap", WTAP_ENCAP_IEEE_802_11, ieee80211_handle);
* - the PANID table is for stateful dissectors only (ie: Decode-As)
* - otherwise, data dissectors fall back to the heuristic dissectors.
*/
-static dissector_handle_t data_handle;
static dissector_table_t panid_dissector_table;
static heur_dissector_list_t ieee802154_beacon_subdissector_list;
static heur_dissector_list_t ieee802154_heur_subdissector_list;
case DECRYPT_VERSION_UNSUPPORTED:
/* We don't support decryption with that version of the protocol */
expert_add_info_format(pinfo, proto_root, &ei_ieee802154_decrypt_error, "We don't support decryption with protocol version %u", packet->version);
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
goto dissect_ieee802154_fcs;
case DECRYPT_PACKET_TOO_SMALL:
expert_add_info_format(pinfo, proto_root, &ei_ieee802154_decrypt_error, "Packet was too small to include the CRC and MIC");
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
goto dissect_ieee802154_fcs;
case DECRYPT_PACKET_NO_EXT_SRC_ADDR:
expert_add_info_format(pinfo, proto_root, &ei_ieee802154_decrypt_error, "No extended source address - can't decrypt");
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
goto dissect_ieee802154_fcs;
case DECRYPT_PACKET_NO_KEY:
expert_add_info_format(pinfo, proto_root, &ei_ieee802154_decrypt_error, "No encryption key set - can't decrypt");
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
goto dissect_ieee802154_fcs;
case DECRYPT_PACKET_DECRYPT_FAILED:
expert_add_info_format(pinfo, proto_root, &ei_ieee802154_decrypt_error, "Decrypt failed");
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
goto dissect_ieee802154_fcs;
case DECRYPT_PACKET_MIC_CHECK_FAILED:
* probably didn't decrypt the packet right (eg: wrong key).
*/
if (IEEE802154_IS_ENCRYPTED(packet->security_level)) {
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
goto dissect_ieee802154_fcs;
}
break;
case IEEE802154_FCF_BEACON:
if (!dissector_try_heuristic(ieee802154_beacon_subdissector_list, payload_tvb, pinfo, tree, &hdtbl_entry, packet)) {
/* Could not subdissect, call the data dissector instead. */
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
}
break;
case IEEE802154_FCF_DATA:
/* Sanity-check. */
if ((!fcs_ok && ieee802154_fcs_ok) || !tvb_reported_length(payload_tvb)) {
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
break;
}
/* Try the PANID dissector table for stateful dissection. */
/* Fall-through to dump undissectable payloads. */
default:
/* Could not subdissect, call the data dissector instead. */
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
} /* switch */
}
CATCH_ALL {
/* Call the data dissector for any leftover bytes. */
if (tvb_reported_length(tvb) > 1) {
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, 1), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, 1), pinfo, tree);
}
} /* dissect_ieee802154_assoc_req */
/* Call the data dissector for any leftover bytes. */
if (tvb_captured_length(tvb) > offset) {
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
}
} /* dissect_ieee802154_assoc_rsp */
/* Call the data dissector for any leftover bytes. */
if (tvb_captured_length(tvb) > 1) {
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, 1), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, 1), pinfo, tree);
}
} /* dissect_ieee802154_disassoc */
/* Call the data dissector for any leftover bytes. */
if (tvb_captured_length(tvb) > offset) {
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
}
} /* dissect_ieee802154_realign */
/* Call the data dissector for any leftover bytes. */
if (tvb_reported_length(tvb) > 1) {
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, 1), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, 1), pinfo, tree);
}
} /* dissect_ieee802154_gtsreq */
/* TODO add support for these commands, for now
* if anything remains other than the FCS, dump it */
if (tvb_captured_length_remaining(tvb, 0) > 2) {
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
return;
ieee802154_handle = find_dissector(IEEE802154_PROTOABBREV_WPAN);
ieee802154_nonask_phy_handle = find_dissector("wpan-nonask-phy");
ieee802154_nofcs_handle = find_dissector("wpan_nofcs");
- data_handle = find_dissector("data");
dissector_add_uint("wtap_encap", WTAP_ENCAP_IEEE802_15_4, ieee802154_handle);
dissector_add_uint("wtap_encap", WTAP_ENCAP_IEEE802_15_4_NONASK_PHY, ieee802154_nonask_phy_handle);
static gint ett_ieee802a = -1;
-static dissector_handle_t data_handle;
-
/*
* Hash table for translating OUIs to a dissector table/field info pair;
* the dissector table maps PID values to dissectors, and the field
if ((subdissector_table == NULL) ||
/* do lookup with the subdissector table */
(!dissector_try_uint(subdissector_table, pid, next_tvb, pinfo, tree))) {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
{
dissector_handle_t ieee802a_handle;
- data_handle = find_dissector("data");
-
ieee802a_handle = create_dissector_handle(dissect_ieee802a,
proto_ieee802a);
dissector_add_uint("ethertype", ETHERTYPE_IEEE802_OUI_EXTENDED,
static gboolean ifcp_desegment = TRUE;
static dissector_handle_t ifcp_handle = NULL;
-static dissector_handle_t data_handle = NULL;
static dissector_handle_t fc_handle = NULL;
if(fc_handle){
call_dissector_with_data(fc_handle, next_tvb, pinfo, parent_tree, &fc_data);
- } else if(data_handle){
- call_dissector(data_handle, next_tvb, pinfo, parent_tree);
+ } else {
+ call_data_dissector(next_tvb, pinfo, parent_tree);
}
return tvb_captured_length(tvb);
ifcp_handle = create_dissector_handle(dissect_ifcp_handle, proto_ifcp);
dissector_add_for_decode_as("tcp.port", ifcp_handle);
- data_handle = find_dissector("data");
fc_handle = find_dissector_add_dependency("fc_ifcp", proto_ifcp);
}
static range_t *global_ssn_range;
static dissector_handle_t inap_handle;
-static dissector_handle_t data_handle;
/* Global variables */
static guint32 opcode=0;
static gint ett_inap_InvokeId = -1;
/*--- End of included file: packet-inap-ett.c ---*/
-#line 87 "./asn1/inap/packet-inap-template.c"
+#line 86 "./asn1/inap/packet-inap-template.c"
static expert_field ei_inap_unknown_invokeData = EI_INIT;
static expert_field ei_inap_unknown_returnResultData = EI_INIT;
/*--- End of included file: packet-inap-table.c ---*/
-#line 93 "./asn1/inap/packet-inap-template.c"
+#line 92 "./asn1/inap/packet-inap-template.c"
const value_string inap_general_problem_strings[] = {
{0,"General Problem Unrecognized Component"},
if (obj_id){
offset=call_ber_oid_callback(obj_id, tvb, offset, actx->pinfo, ext_tree, NULL);
}else{
- call_dissector(data_handle, tvb, actx->pinfo, ext_tree);
+ call_data_dissector(tvb, actx->pinfo, ext_tree);
offset = tvb_reported_length_remaining(tvb,offset);
}
/*--- End of included file: packet-inap-fn.c ---*/
-#line 107 "./asn1/inap/packet-inap-template.c"
+#line 106 "./asn1/inap/packet-inap-template.c"
/*
TC-Invokable OPERATION ::=
{activateServiceFiltering | activityTest | analysedInformation |
/*--- End of included file: packet-inap-table2.c ---*/
-#line 128 "./asn1/inap/packet-inap-template.c"
+#line 127 "./asn1/inap/packet-inap-template.c"
static guint8 inap_pdu_type = 0;
if (!inap_prefs_initialized) {
inap_prefs_initialized = TRUE;
inap_handle = find_dissector("inap");
- data_handle = find_dissector("data");
oid_add_from_string("Core-INAP-CS1-Codes","0.4.0.1.1.0.3.0");
oid_add_from_string("iso(1) identified-organization(3) icd-ecma(12) member-company(2) 1107 oen(3) inap(3) extensions(2)","1.3.12.2.1107.3.3.2");
oid_add_from_string("alcatel(1006)","1.3.12.2.1006.64");
"InvokeId_present", HFILL }},
/*--- End of included file: packet-inap-hfarr.c ---*/
-#line 213 "./asn1/inap/packet-inap-template.c"
+#line 211 "./asn1/inap/packet-inap-template.c"
};
&ett_inap_InvokeId,
/*--- End of included file: packet-inap-ettarr.c ---*/
-#line 228 "./asn1/inap/packet-inap-template.c"
+#line 226 "./asn1/inap/packet-inap-template.c"
};
static ei_register_info ei[] = {
/* Subdissectors Declarations */
static dissector_handle_t ipv6_handle;
-static dissector_handle_t data_handle;
static dissector_handle_t eth_handle;
static dissector_table_t ethertype_dissector_table;
if (operand > 1) {
proto_item_set_text(operand_item, "%s", "Reserved");
- call_dissector(data_handle, tvb, pinfo, link_tree);
+ call_data_dissector(tvb, pinfo, link_tree);
} else {
proto_tree_add_item(link_tree, hf_infiniband_link_fctbs, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2;
if (!dissector_found) {
/* No sub-dissector found.
Label rest of packet as "Data" */
- call_dissector(data_handle, next_tvb, pinfo, top_tree);
+ call_data_dissector(next_tvb, pinfo, top_tree);
}
next_tvb = tvb_new_subset_length(tvb, *offset, reported_length);
if (!dissector_try_uint(ethertype_dissector_table, ether_type,
next_tvb, pinfo, top_tree))
- call_dissector(data_handle, next_tvb, pinfo, top_tree);
+ call_data_dissector(next_tvb, pinfo, top_tree);
*offset = tvb_reported_length(tvb) - 2;
/* Display the VCRC */
if (seg_offset || ms) {
/* this is a fragment of an encapsulated Ethernet jumbo frame, parse as data */
- call_dissector(data_handle, encap_tvb, pinfo, top_tree);
+ call_data_dissector(encap_tvb, pinfo, top_tree);
} else {
/* non-fragmented frames can be fully parsed */
call_dissector(eth_handle, encap_tvb, pinfo, top_tree);
dissector_handle_t roce_handle, rroce_handle;
ipv6_handle = find_dissector_add_dependency("ipv6", proto_infiniband);
- data_handle = find_dissector("data");
/*
* I haven't found an official spec for EoIB, but slide 10
static dissector_table_t ip_dissector_table;
static dissector_handle_t ipv6_handle;
-static dissector_handle_t data_handle;
/* IP structs and definitions */
ipfd_head->reassembled_in);
}
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo,
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo,
parent_tree);
pinfo->fragmented = save_fragmented;
return tvb_captured_length(tvb);
col_add_fstr(pinfo->cinfo, COL_INFO, "%s (%u)",
ipprotostr(iph->ip_p), iph->ip_p);
}
- call_dissector(data_handle,next_tvb, pinfo, parent_tree);
+ call_data_dissector(next_tvb, pinfo, parent_tree);
}
}
pinfo->fragmented = save_fragmented;
ip_handle = find_dissector("ip");
ipv6_handle = find_dissector("ipv6");
- data_handle = find_dissector("data");
ipv4_handle = create_dissector_handle(dissect_ip_v4, proto_ip);
dissector_add_uint("ethertype", ETHERTYPE_IP, ipv4_handle);
static int hf_ipmi_session_trailer = -1;
static dissector_handle_t ipmi_handle;
-static dissector_handle_t data_handle;
#define IPMI_AUTH_NONE 0x00
#define IPMI_AUTH_MD2 0x01
open packet in the capture we parse), we cannot even
decipher where a message starts. Just print them as data.
*/
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
} else if (authtype != IPMI_AUTH_RMCPP || payloadtype == IPMI_IPMI_MESSAGE) {
/* This is an IPMI message, either v1.5 or v2.0+. For now,
we don't need to distinguish these kinds. */
/* All other RMCP+ payload types fall here: session open/close
requests, RAKP messages, SOL. We cannot parse them yet, thus
just output as data. */
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
if (tree) {
ipmi_session_handle = create_dissector_handle(dissect_ipmi_session, proto_ipmi_session);
dissector_add_uint("rmcp.class", RMCP_CLASS_IPMI, ipmi_session_handle);
- data_handle = find_dissector("data");
ipmi_handle = find_dissector_add_dependency("ipmi", proto_ipmi_session);
}
static int proto_ipmi_trace = -1;
-static dissector_handle_t data_dissector_handle;
static dissector_table_t proto_dissector_table;
static gint ett_ipmi_trace = -1;
if (tvb_captured_length(tvb) < 11) {
/* TODO: add expert info */
- call_dissector(data_dissector_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
if (!dissector_try_uint_new(proto_dissector_table,
data_type, next_tvb, pinfo, tree, TRUE, &arg)) {
- call_dissector(data_dissector_handle, next_tvb,
- pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
} else if (block_type == HPM2_CHN_STATE_NOTIFY
&& data_type == IPMI_PROTO_IPMB_1_0) {
dissect_ipmb_state_notify(next_tvb, tree);
} else {
- call_dissector(data_dissector_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
ipmi_trace_handle = create_dissector_handle(dissect_ipmi_trace,
proto_ipmi_trace);
- data_dissector_handle = find_dissector("data");
-
dissector_add_uint("wtap_encap", WTAP_ENCAP_IPMI_TRACE, ipmi_trace_handle);
dissector_add_uint("ipmi.protocol", IPMI_PROTO_IPMB_1_0,
/* Maximum nest level where it worth caching data */
#define MAX_NEST_LEVEL 3
-static dissector_handle_t data_dissector;
-
gint proto_ipmi = -1;
static gint proto_ipmb = -1;
static gint proto_kcs = -1;
if (tvb_captured_length(tvb) < ctx->hdr_len + siglen + is_resp
+ !(ctx->flags & IPMI_D_NO_CKS)) {
/* don bother with anything */
- return call_dissector(data_dissector, tvb, pinfo, tree);
+ return call_data_dissector(tvb, pinfo, tree);
}
/* save nest level */
register_dissector("kcs", dissect_kcs, proto_kcs);
register_dissector("tmode", dissect_tmode, proto_tmode);
- data_dissector = find_dissector("data");
-
m = prefs_register_protocol(proto_ipmi, NULL);
prefs_register_bool_preference(m, "fru_langcode_is_english", "FRU Language Code is English",
"FRU Language Code is English; strings are ASCII+LATIN1 (vs. Unicode)",
static dissector_handle_t ipos_handle;
static dissector_handle_t redback_handle;
-static dissector_handle_t data_handle;
static int proto_ipos = -1;
static int hf_ipos_protocol = -1;
{
ipos_handle = find_dissector("ipos");
redback_handle = find_dissector_add_dependency("redback", proto_ipos);
- data_handle = find_dissector("data");
/*dissector_add_uint("wtap_encap", WTAP_ENCAP_IPOS, ipos_handle); */
dissector_add_uint("sll.ltype", LINUX_SLL_P_IPOS_NETIPC, ipos_handle);
static gint ett_ipp_as = -1;
static gint ett_ipp_attr = -1;
-static dissector_handle_t data_handle;
-
#define PRINT_JOB 0x0002
#define PRINT_URI 0x0003
#define VALIDATE_JOB 0x0004
offset = parse_attributes(tvb, offset, ipp_tree);
if (tvb_offset_exists(tvb, offset)) {
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset), pinfo,
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo,
ipp_tree);
}
return tvb_captured_length(tvb);
ipp_handle = create_dissector_handle(dissect_ipp, proto_ipp);
http_dissector_add(631, ipp_handle);
dissector_add_string("media_type", "application/ipp", ipp_handle);
- data_handle = find_dissector("data");
}
/*
"IPv6 fragments"
};
-static dissector_handle_t data_handle;
-
static dissector_table_t ip_dissector_table;
static dissector_table_t ipv6_next_header_dissector_table;
if (show_data) {
/* COL_INFO already set */
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
else {
/* First fragment and not reassembling, not fragmented, or already reassembled. */
if (!ip_try_dissect(try_heuristic_first, next_tvb, pinfo, tree, &iph)) {
/* Unknown protocol. */
col_add_fstr(pinfo->cinfo, COL_INFO, "%s (%u)", ipprotostr(nxt), nxt);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
pinfo->fragmented = save_fragmented;
dissector_handle_t ipv6_hopopts_handle, ipv6_routing_handle,
ipv6_shim6_handle, ipv6_dstopts_handle;
- data_handle = find_dissector("data");
ipv6_handle = find_dissector("ipv6");
dissector_add_uint("ethertype", ETHERTYPE_IPv6, ipv6_handle);
dissector_add_uint("erf.types.type", ERF_TYPE_IPV6, ipv6_handle);
static int hf_msg_conn = -1;
static int hf_msg_sigchar = -1;
-static dissector_handle_t data_handle;
-
#define UDP_PORT_IPX 213 /* RFC 1234 */
#define IPX_HEADER_LEN 30 /* It's *always* 30 bytes */
pinfo, tree, FALSE, ipxh))
return tvb_captured_length(tvb);
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
/* ================================================================= */
{
return tvb_captured_length(tvb);
}
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
register_capture_dissector("sll.ltype", LINUX_SLL_P_802_3, capture_ipx, proto_ipx);
register_capture_dissector("llc.dsap", SAP_NETWARE1, capture_ipx, proto_ipx);
register_capture_dissector("llc.dsap", SAP_NETWARE2, capture_ipx, proto_ipx);
- data_handle = find_dissector("data");
}
/*
static dissector_handle_t dpnss_link_handle;
static dissector_handle_t ppp_hdlc_handle;
static dissector_handle_t v120_handle;
-static dissector_handle_t data_handle;
static const value_string channel_vals[] = {
{ 0, "D" },
if (!try_circuit_dissector(CT_ISDN, pinfo->pseudo_header->isdn.channel,
pinfo->num, tvb, pinfo, tree, NULL))
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
dpnss_link_handle = find_dissector("dpnss_link");
ppp_hdlc_handle = find_dissector("ppp_hdlc");
v120_handle = find_dissector("v120");
- data_handle = find_dissector("data");
isdn_handle = create_dissector_handle(dissect_isdn, proto_isdn);
void proto_register_isi(void);
void proto_reg_handoff_isi(void);
-/* These are the handles of our subdissectors */
-static dissector_handle_t data_handle=NULL;
-
/* Dissector table for the isi resource */
static dissector_table_t isi_resource_dissector_table;
/* Call subdissector depending on the resource ID */
if (!dissector_try_uint(isi_resource_dissector_table, resource, content_tvb, pinfo, isi_tree))
- call_dissector(data_handle, content_tvb, pinfo, isi_tree);
+ call_data_dissector(content_tvb, pinfo, isi_tree);
return tvb_captured_length(tvb);
}
static gboolean initialized=FALSE;
if(!initialized) {
- data_handle = find_dissector("data");
dissector_add_uint("sll.ltype", LINUX_SLL_P_ISI, create_dissector_handle(dissect_isi, proto_isi));
heur_dissector_add("usb.bulk", dissect_usb_isi, "ISI bulk endpoint", "usb_bulk_isi", proto_isi, HEURISTIC_DISABLE);
static dissector_handle_t eth_withfcs_handle;
static dissector_handle_t tr_handle;
-static dissector_handle_t data_handle;
gboolean
capture_isl(const guchar *pd, int offset, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header _U_)
default:
next_tvb = tvb_new_subset_remaining(payload_tvb, 12);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
}
}
*/
eth_withfcs_handle = find_dissector_add_dependency("eth_withfcs", proto_isl);
tr_handle = find_dissector_add_dependency("tr", proto_isl);
- data_handle = find_dissector("data");
}
/*
static guint gbl_ItdmMPLSLabel = 0x99887;
static guint gbl_ItdmCTLFlowNo = 0;
-static dissector_handle_t data_handle;
-
/* I-TDM 125usec mode commands for data flows */
#define ITDM_CMD_NEW_CHAN 1
#define ITDM_CMD_CLOSE_CHAN 2
}
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
static void
}
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
static int
if (!Initialized) {
itdm_handle = create_dissector_handle( dissect_itdm, proto_itdm );
- data_handle = find_dissector("data");
Initialized=TRUE;
} else {
dissector_delete_uint("mpls.label", ItdmMPLSLabel, itdm_handle);
static module_t *iua_module;
-static dissector_handle_t data_handle;
static dissector_table_t lapd_gsm_sapi_dissector_table;
/* Whether to use GSM SAPI vals or not */
}
if(global_iua_gsm_sapis) {
if (!dissector_try_uint(lapd_gsm_sapi_dissector_table, sapi_val, protocol_data_tvb, pinfo, tree))
- call_dissector(data_handle, protocol_data_tvb, pinfo, tree);
+ call_data_dissector(protocol_data_tvb, pinfo, tree);
return;
}
dissector_add_uint("sctp.ppi", IUA_PAYLOAD_PROTOCOL_ID, iua_handle);
lapd_gsm_sapi_dissector_table = find_dissector_table("lapd.gsm.sapi");
- data_handle = find_dissector("data");
-
}
/*
static GHashTable* circuits = NULL;
-static dissector_handle_t data_handle = NULL;
static gboolean dissect_fields = FALSE;
static gboolean two_byte_pseudoheader = FALSE;
static guint global_dynamic_payload_type = 0;
len--;
}
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
if (!iuup_prefs_initialized) {
iuup_handle = find_dissector("iuup");
dissector_add_string("rtp_dyn_payload_type","VND.3GPP.IUFP", iuup_handle);
- data_handle = find_dissector("data");
iuup_prefs_initialized = TRUE;
} else {
if ( saved_dynamic_payload_type > 95 ) {
#include "packet-iwarp-ddp-rdmap.h"
void proto_register_iwarp_ddp_rdmap(void);
-void proto_reg_handoff_iwarp_ddp_rdmap(void);
/* DEFINES */
static gint proto_iwarp_ddp_rdmap = -1;
static gint ett_iwarp_ddp_rdmap = -1;
-static dissector_handle_t data_handle;
-
/*
* DDP: initialize the protocol and registered fields
*/
if (!dissector_try_heuristic(rdmap_heur_subdissector_list,
tvb, pinfo, tree, &hdtbl_entry, info)) {
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
}
proto_iwarp_ddp_rdmap);
}
-void
-proto_reg_handoff_iwarp_ddp_rdmap(void)
-{
- data_handle = find_dissector("data");
-}
-
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
static gint ett_juniper = -1;
static dissector_handle_t ipv4_handle;
-static dissector_handle_t data_handle;
static dissector_table_t payload_table;
/* XXX - left in for posterity, dissection was never done */
/* case JUNIPER_PROTO_OAM: FIXME call OAM dissector without leading HEC byte */
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
/* could not figure what it is */
ti = proto_tree_add_uint_format_value(juniper_subtree, hf_juniper_payload_type, tvb, offset, 0, 0xFFFF, "Unknown");
proto_item_set_len(ti, tvb_reported_length_remaining(tvb, offset));
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
dissector_handle_t juniper_svcs_handle;
ipv4_handle = find_dissector_add_dependency("ip", proto_juniper);
- data_handle = find_dissector("data");
juniper_atm2_handle = create_dissector_handle(dissect_juniper_atm2, proto_juniper);
juniper_atm1_handle = create_dissector_handle(dissect_juniper_atm1, proto_juniper);
static dissector_table_t media_type_dissector_table = NULL;
static dissector_handle_t media_handle = NULL;
-static dissector_handle_t data_handle = NULL;
static dissector_handle_t stream_jxta_handle = NULL;
static dissector_handle_t ssl_handle = NULL;
if(0 == dissected) {
/* display it as raw data */
- dissected = call_dissector(data_handle, tvb, pinfo, tree);
+ dissected = call_data_dissector(tvb, pinfo, tree);
}
return dissected;
media_type_dissector_table = find_dissector_table("media_type");
ssl_handle = find_dissector_add_dependency("ssl", proto_jxta);
- data_handle = find_dissector("data");
media_handle = find_dissector_add_dependency("media", proto_jxta);
init_done = TRUE;
static gint ett_kismet = -1;
static gint ett_kismet_reqresp = -1;
-static dissector_handle_t data_handle;
-
#define TCP_PORT_KISMET 2501
static guint global_kismet_tcp_port = TCP_PORT_KISMET;
/*
* Put the whole packet into the tree as data.
*/
- call_dissector(data_handle, tvb, pinfo, kismet_tree);
+ call_data_dissector(tvb, pinfo, kismet_tree);
return tvb_captured_length(tvb);
}
if (!kismet_prefs_initialized) {
kismet_handle = create_dissector_handle(dissect_kismet, proto_kismet);
- data_handle = find_dissector("data");
kismet_prefs_initialized = TRUE;
} else {
dissector_delete_uint("tcp.port", tcp_port, kismet_handle);
static dissector_handle_t atm_oam_handle;
static dissector_handle_t llc_handle;
-static dissector_handle_t data_handle;
static dissector_handle_t l2tp_udp_handle;
static dissector_handle_t l2tp_ip_handle;
if (!dissector_try_uint_new(pw_type_table, pw_type, next_tvb, pinfo, tree, FALSE, GUINT_TO_POINTER(oam_cell)))
{
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
*/
atm_oam_handle = find_dissector_add_dependency("atm_oam_cell", proto_l2tp);
llc_handle = find_dissector_add_dependency("llc", proto_l2tp);
- data_handle = find_dissector("data");
atm_oam_llc_handle = create_dissector_handle( dissect_atm_oam_llc, proto_l2tp );
dissector_add_uint("l2tp.pw_type", L2TPv3_PROTOCOL_AAL5, atm_oam_llc_handle);
/* Initialize the subtree pointer */
static gint ett_lanforge = -1;
-/* data dissector handle */
-static dissector_handle_t data_handle;
-
/* entry point */
static gboolean dissect_lanforge(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
{
proto_tree_add_time(lanforge_tree, hf_lanforge_timestamp, tvb, offset - 8, 8, &tstamp);
if(tvb_reported_length_remaining(tvb, offset) > 0) /* random data */
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo,
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo,
lanforge_tree);
}
/* Register as a heuristic UDP dissector */
heur_dissector_add("udp", dissect_lanforge, "LANforge over UDP", "lanforge_udp", proto_lanforge, HEURISTIC_ENABLE);
heur_dissector_add("tcp", dissect_lanforge, "LANforge over TCP", "lanforge_tcp", proto_lanforge, HEURISTIC_ENABLE);
-
- /* Find data dissector handle */
- data_handle = find_dissector("data");
}
/*
/* Whether to use GSM SAPI vals or not */
static gboolean global_lapd_gsm_sapis = FALSE;
-static dissector_handle_t data_handle;
-
/*
* Bits in the address field.
*/
if(global_lapd_gsm_sapis){
if (!dissector_try_uint(lapd_gsm_sapi_dissector_table, sapi,
next_tvb, pinfo, tree))
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}else{
if (!dissector_try_uint(lapd_sapi_dissector_table, sapi,
next_tvb, pinfo, tree))
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
} else
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
static gboolean
register_dissector("lapd-bitstream", dissect_lapd_bitstream, proto_lapd);
lapd_bitstream_handle = find_dissector("lapd-bitstream");
- data_handle = find_dissector("data");
-
init = TRUE;
} else {
#include <epan/reassemble.h>
void proto_register_lapdm(void);
-void proto_reg_handoff_lapdm(void);
static int proto_lapdm = -1;
static int hf_lapdm_address = -1;
static dissector_table_t lapdm_sapi_dissector_table;
-static dissector_handle_t data_handle;
-
static gboolean reassemble_lapdm = TRUE;
/*
if (fd_m && pinfo->num == fd_m->reassembled_in) {
if (!dissector_try_uint(lapdm_sapi_dissector_table, sapi,
reassembled, pinfo, tree))
- call_dissector(data_handle, reassembled, pinfo, tree);
+ call_data_dissector(reassembled, pinfo, tree);
}
else {
col_append_str(pinfo->cinfo, COL_INFO, " (Fragment)");
*/
if (!dissector_try_uint(lapdm_sapi_dissector_table, sapi,
payload, pinfo, tree))
- call_dissector(data_handle,payload, pinfo, tree);
+ call_data_dissector(payload, pinfo, tree);
}
return tvb_captured_length(tvb);
}
register_cleanup_routine (lapdm_defragment_cleanup);
}
-void
-proto_reg_handoff_lapdm(void)
-{
- data_handle = find_dissector("data");
-}
-
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
#include <epan/packet.h>
#include <epan/reassemble.h>
+
void proto_register_lapsat(void);
-void proto_reg_handoff_lapsat(void);
static int proto_lapsat = -1;
static dissector_table_t lapsat_sapi_dissector_table;
-static dissector_handle_t data_handle;
-
static gint ett_lapsat = -1;
static gint ett_lapsat_address = -1;
static gint ett_lapsat_control = -1;
/* Yes, so handoff to upper layers */
if (!dissector_try_uint(lapsat_sapi_dissector_table, sapi,
reassembled, pinfo, tree))
- call_dissector(data_handle, reassembled, pinfo, tree);
+ call_data_dissector(reassembled, pinfo, tree);
} else {
/* No, just add infos */
col_append_str(pinfo->cinfo, COL_INFO, " (Fragment)");
* Whole frame
*/
if (!dissector_try_uint(lapsat_sapi_dissector_table, sapi, payload, pinfo, tree))
- call_dissector(data_handle, payload, pinfo, tree);
+ call_data_dissector(payload, pinfo, tree);
}
return tvb_captured_length(tvb);
}
register_cleanup_routine (lapsat_defragment_cleanup);
}
-void
-proto_reg_handoff_lapsat(void)
-{
- data_handle = find_dissector("data");
-}
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
static gint ett_lat = -1;
-static dissector_handle_t data_handle;
-
/* LAT commands. */
#define LAT_CCMD_RUN 0
#define LAT_CCMD_START 1
{
dissector_handle_t lat_handle;
- data_handle = find_dissector("data");
lat_handle = create_dissector_handle(dissect_lat, proto_lat);
dissector_add_uint("ethertype", ETHERTYPE_LAT, lat_handle);
}
static gboolean lbmc_reassemble_fragments = FALSE;
static gboolean lbmc_dissect_lbmpdm = FALSE;
static heur_dissector_list_t lbmc_heuristic_subdissector_list;
-static dissector_handle_t lbmc_data_dissector_handle;
/*----------------------------------------------------------------------------*/
/* Handles of all types. */
}
else
{
- call_dissector(lbmc_data_dissector_handle, data_tvb, pinfo, subtree);
+ call_data_dissector(data_tvb, pinfo, subtree);
}
}
}
else
{
- call_dissector(lbmc_data_dissector_handle, data_tvb, pinfo, subtree);
+ call_data_dissector(data_tvb, pinfo, subtree);
}
}
if (msgprop_tvb != NULL)
/* The registration hand-off routine */
void proto_reg_handoff_lbmc(void)
{
- lbmc_data_dissector_handle = find_dissector("data");
lbmc_uim_tap_handle = register_tap("lbm_uim");
lbmc_stream_tap_handle = register_tap("lbm_stream");
}
static dissector_handle_t ipv4_handle;
static dissector_handle_t ipv6_handle;
-static dissector_handle_t data_handle;
static gboolean encapsulated = FALSE;
static gboolean ddt_originated = FALSE;
expert_add_info_format(pinfo, lisp_tree, &ei_lisp_unexpected_field,
"Unexpected Source EID AFI (%d), cannot decode", src_eid_afi);
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, lisp_tree);
+ call_data_dissector(next_tvb, pinfo, lisp_tree);
return;
}
expert_add_info_format(pinfo, lisp_tree, &ei_lisp_unexpected_field,
"Unexpected ITR-RLOC-AFI (%d), cannot decode", itr_afi);
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, lisp_tree);
+ call_data_dissector(next_tvb, pinfo, lisp_tree);
return;
}
}
expert_add_info_format(pinfo, lisp_tree, &ei_lisp_unexpected_field,
"Unexpected EID prefix AFI (%d), cannot decode", prefix_afi);
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, lisp_tree);
+ call_data_dissector(next_tvb, pinfo, lisp_tree);
return;
}
}
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, lisp_tree);
+ call_data_dissector(next_tvb, pinfo, lisp_tree);
}
}
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, lisp_tree);
+ call_data_dissector(next_tvb, pinfo, lisp_tree);
}
}
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, lisp_tree);
+ call_data_dissector(next_tvb, pinfo, lisp_tree);
}
}
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, lisp_tree);
+ call_data_dissector(next_tvb, pinfo, lisp_tree);
}
/*
}
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, lisp_tree);
+ call_data_dissector(next_tvb, pinfo, lisp_tree);
}
expert_add_info_format(pinfo, lisp_tree, &ei_lisp_unexpected_field,
"Unexpected EID prefix AFI (%d), cannot decode", prefix_afi);
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, lisp_tree);
+ call_data_dissector(next_tvb, pinfo, lisp_tree);
return;
}
}
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, lisp_tree);
+ call_data_dissector(next_tvb, pinfo, lisp_tree);
}
call_dissector(ipv6_handle, next_tvb, pinfo, tree);
break;
default:
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
}
encapsulated = FALSE;
dissect_lisp_ecm(tvb, pinfo, tree, lisp_tree);
break;
default:
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
dissector_add_uint("udp.port", LISP_CONTROL_PORT, lisp_handle);
ipv4_handle = find_dissector_add_dependency("ip", proto_lisp);
ipv6_handle = find_dissector_add_dependency("ipv6", proto_lisp);
- data_handle = find_dissector("data");
}
/*
static dissector_handle_t tr_handle;
static dissector_handle_t turbo_handle;
static dissector_handle_t mesh_handle;
-static dissector_handle_t data_handle;
/*
* Group/Individual bit, in the DSAP.
*/
if (!dissector_try_uint(dsap_subdissector_table,
dsap, next_tvb, pinfo, tree)) {
- call_dissector(data_handle, next_tvb,
- pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
} else if ((control & (XDLC_U_MODIFIER_MASK|XDLC_U))
== (XDLC_XID|XDLC_U)) {
if (!dissector_try_uint(
xid_subdissector_table, dsap, next_tvb,
pinfo, tree)) {
- call_dissector(data_handle,
- next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
} else {
- call_dissector(data_handle, next_tvb, pinfo,
- tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
}
next_tvb = tvb_new_subset_remaining(tvb, offset+5);
if(!dissector_try_uint(hpteam_subdissector_table,etype, next_tvb, pinfo, tree))
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
case OUI_ENCAP_ETHER:
next_tvb = tvb_new_subset_remaining(tvb, offset+5);
if (!dissector_try_uint(ethertype_subdissector_table,
etype, next_tvb, pinfo, tree))
- call_dissector(data_handle, next_tvb, pinfo,
- tree);
+ call_data_dissector(next_tvb, pinfo, tree);
} else {
next_tvb = tvb_new_subset_remaining(tvb, offset+5);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
break;
default:
next_tvb = tvb_new_subset_remaining(tvb, offset+5);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
}
break;
next_tvb = tvb_new_subset_remaining(tvb, offset+5+mesh_header_len);
if (!dissector_try_uint(ethertype_subdissector_table,
etype, next_tvb, pinfo, tree))
- call_dissector(data_handle, next_tvb, pinfo,
- tree);
+ call_data_dissector(next_tvb, pinfo, tree);
} else {
next_tvb = tvb_new_subset_remaining(tvb, offset+5);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
break;
break;
}
}
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
}
}
tr_handle = find_dissector_add_dependency("tr", proto_llc);
turbo_handle = find_dissector_add_dependency("turbocell", proto_llc);
mesh_handle = find_dissector_add_dependency("mesh", proto_llc);
- data_handle = find_dissector("data");
/*
* Get the Ethertype dissector table.
static expert_field ei_lon_tpdu_authpdu_type_unknown = EI_INIT;
static expert_field ei_lon_tpdu_apdu_dest_type = EI_INIT;
-static dissector_handle_t data_handle;
-
static gint dissect_apdu(proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb,
gint offset);
next_tvb = tvb_new_subset_remaining(tvb, offset);
- return offset - old_offset + call_dissector(data_handle, next_tvb, pinfo, tree);
+ return offset - old_offset + call_data_dissector(next_tvb, pinfo, tree);
}
void
dissector_handle_t lon_handle;
lon_handle = create_dissector_handle(dissect_lon, proto_lon);
- data_handle = find_dissector("data");
dissector_add_uint("cnip.protocol", 0, lon_handle);
}
static gint ett_loop = -1;
-static dissector_handle_t data_handle;
-
#define FUNC_REPLY 1
#define FUNC_FORWARD_DATA 2
if (tvb_reported_length_remaining(tvb, offset) > 0)
{
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
loop_handle = create_dissector_handle(dissect_loop, proto_loop);
dissector_add_uint("ethertype", ETHERTYPE_LOOP, loop_handle);
-
- data_handle = find_dissector("data");
}
/*
static gint find_printer_string(tvbuff_t *tvb, int offset);
-static dissector_handle_t data_handle;
-
/* This information comes from the LPRng HOWTO, which also describes
RFC 1179. http://www.astart.com/lprng/LPRng-HOWTO.html */
static const value_string lpd_client_code[] = {
proto_tree_add_item(lpd_tree, hf_lpd_printer_option, tvb, 1, printer_len, ENC_ASCII|ENC_NA);
}
else {
- call_dissector(data_handle,tvb, pinfo, lpd_tree);
+ call_data_dissector(tvb, pinfo, lpd_tree);
}
}
else if (lpr_packet_type == response) {
proto_tree_add_item(lpd_tree, hf_lpd_response_code, tvb, 0, 1, ENC_BIG_ENDIAN);
}
else {
- call_dissector(data_handle,tvb, pinfo, lpd_tree);
+ call_data_dissector(tvb, pinfo, lpd_tree);
}
}
else {
- call_dissector(data_handle,tvb, pinfo, lpd_tree);
+ call_data_dissector(tvb, pinfo, lpd_tree);
}
return tvb_captured_length(tvb);
lpd_handle = create_dissector_handle(dissect_lpd, proto_lpd);
dissector_add_uint("tcp.port", TCP_PORT_PRINTER, lpd_handle);
- data_handle = find_dissector("data");
}
/*
static dissector_handle_t eth_withoutfcs_handle;
static dissector_handle_t wlan_handle;
static dissector_handle_t wlan_bsfc_handle;
-static dissector_handle_t data_handle;
/* Set by preferences */
static gboolean swap_frame_control;
/* Dissect rest of packet as data */
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
} /* dissect_control */
eth_withoutfcs_handle = find_dissector_add_dependency("eth_withoutfcs", proto_lwapp);
wlan_handle = find_dissector_add_dependency("wlan_withoutfcs", proto_lwapp);
wlan_bsfc_handle = find_dissector_add_dependency("wlan_bsfc", proto_lwapp);
- data_handle = find_dissector("data");
/* This dissector assumes lwapp packets in an 802.3 frame */
lwapp_l3_handle = create_dissector_handle(dissect_lwapp_l3, proto_lwapp_l3);
void proto_register_lwm(void);
void proto_reg_handoff_lwm(void);
-/* Dissector handles */
-static dissector_handle_t data_handle;
-
/* User string with the decryption key. */
static const gchar *lwmes_key_str = NULL;
static gboolean lwmes_key_valid;
tvb_reported_length(new_tvb) - LWM_MIC_LEN);
expert_add_info(pinfo, lwm_tree, &ei_lwm_decryption_failed);
tvb_set_reported_length(new_tvb, tvb_reported_length(new_tvb) - LWM_MIC_LEN);
- call_dissector(data_handle, new_tvb, pinfo, lwm_tree);
+ call_data_dissector(new_tvb, pinfo, lwm_tree);
}
text_dec = &text[payload_offset];
if(vmic == lwm_mic)
{
decrypted_tvb = tvb_new_real_data(text,length, length);
- call_dissector(data_handle, decrypted_tvb, pinfo, lwm_tree);
+ call_data_dissector(decrypted_tvb, pinfo, lwm_tree);
/* XXX - needed?
tvb_set_free_cb(decrypted_tvb, g_free);
add_new_data_source(pinfo, decrypted_tvb, "Decrypted LWmesh Payload"); */
"Encrypted data (%i byte(s)) MIC FAILURE",
tvb_reported_length(new_tvb) - LWM_MIC_LEN);
tvb_set_reported_length(new_tvb, tvb_reported_length(new_tvb) - LWM_MIC_LEN);
- call_dissector(data_handle, new_tvb, pinfo, lwm_tree);
+ call_data_dissector(new_tvb, pinfo, lwm_tree);
}
}
else
expert_add_info(pinfo, lwm_tree, &ei_lwm_no_decryption_key);
tvb_set_reported_length(new_tvb, tvb_reported_length(new_tvb) - LWM_MIC_LEN);
- call_dissector(data_handle, new_tvb, pinfo, lwm_tree);
+ call_data_dissector(new_tvb, pinfo, lwm_tree);
}
#else /* ! HAVE_LIBGCRYPT */
col_add_fstr(pinfo->cinfo, COL_INFO,
expert_add_info(pinfo, lwm_tree, &ei_lwm_no_decryption_key);
tvb_set_reported_length(new_tvb, tvb_reported_length(new_tvb) - LWM_MIC_LEN);
- call_dissector(data_handle, new_tvb, pinfo, lwm_tree);
+ call_data_dissector(new_tvb, pinfo, lwm_tree);
#endif /* ! HAVE_LIBGCRYPT */
}
/*stack command endpoint 0 and not secured*/
default:
/*Unknown command*/
expert_add_info_format(pinfo, lwm_cmd_tree, &ei_lwm_mal_error, "Unknown command");
- call_dissector(data_handle, new_tvb, pinfo, lwm_cmd_tree);
+ call_data_dissector(new_tvb, pinfo, lwm_cmd_tree);
return tvb_captured_length(tvb);
}
"Size is %i byte(s), instead of %i bytes", tvb_reported_length(new_tvb), len);
new_tvb = tvb_new_subset_remaining(new_tvb, len);
- call_dissector(data_handle, new_tvb, pinfo, lwm_tree);
+ call_data_dissector(new_tvb, pinfo, lwm_tree);
}
}
else{
/*unknown data*/
- call_dissector(data_handle, new_tvb, pinfo, lwm_tree);
+ call_data_dissector(new_tvb, pinfo, lwm_tree);
}
return tvb_captured_length(tvb);
} /* dissect_lwm */
GByteArray *bytes;
gboolean res;
- data_handle = find_dissector("data");
-
/* Convert key to raw bytes */
bytes = g_byte_array_new();
res = hex_str_to_bytes(lwmes_key_str, bytes, FALSE);
static gint ett_q708_dpc = -1;
static module_t *m3ua_module;
-static dissector_handle_t mtp3_handle, data_handle;
+static dissector_handle_t mtp3_handle;
static dissector_table_t si_dissector_table;
/* stuff for supporting multiple versions */
payload_tvb = tvb_new_subset_length(parameter_tvb, DATA_ULP_OFFSET, ulp_length);
if (!dissector_try_uint(si_dissector_table, tvb_get_guint8(parameter_tvb, DATA_SI_OFFSET), payload_tvb, pinfo, tree))
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
mtp3_standard = m3ua_pref_mtp3_standard;
}
* Get a handle for the MTP3 dissector.
*/
mtp3_handle = find_dissector_add_dependency("mtp3", proto_m3ua);
- data_handle = find_dissector("data");
m3ua_handle = find_dissector("m3ua");
dissector_add_uint("sctp.ppi", M3UA_PAYLOAD_PROTOCOL_ID, m3ua_handle);
dissector_add_uint("sctp.port", SCTP_PORT_M3UA, m3ua_handle);
#define TCI_AN_MASK 0x03
-static dissector_handle_t data_handle;
-
static int proto_macsec = -1;
static int hf_macsec_TCI = -1;
static int hf_macsec_TCI_V = -1;
sectag_offset + 12, 2, ENC_BIG_ENDIAN);
}
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
proto_tree_add_item(macsec_tree, hf_macsec_ICV, tvb, icv_offset,
icv_length, ENC_NA);
proto_reg_handoff_macsec(void)
{
dissector_handle_t macsec_handle;
- data_handle = find_dissector("data");
macsec_handle = create_dissector_handle(dissect_macsec, proto_macsec);
dissector_add_uint("ethertype", ETHERTYPE_MACSEC, macsec_handle);
}
static gint ett_mactelnet = -1;
static gint ett_mactelnet_control = -1;
-static dissector_handle_t data_handle;
-
/* Packet types */
static const value_string packettypenames[] = {
{ 0, "Start session" },
} else {
/* Data packet, let wireshark handle it */
tvbuff_t *next_client = tvb_new_subset_remaining(tvb, offset);
- return call_dissector(data_handle, next_client, pinfo, mactelnet_tree);
+ return call_data_dissector(next_client, pinfo, mactelnet_tree);
}
}
} else if ((type == 4) || (type == 5)) {
/* Data packet, let wireshark handle it */
tvbuff_t *next_client = tvb_new_subset_remaining(tvb, offset);
- return call_dissector(data_handle, next_client, pinfo, mactelnet_tree);
+ return call_data_dissector(next_client, pinfo, mactelnet_tree);
}
if (!initialized) {
mactelnet_handle = create_dissector_handle(dissect_mactelnet, proto_mactelnet);
- data_handle = find_dissector("data");
initialized = TRUE;
} else {
dissector_delete_uint("udp.port", current_port, mactelnet_handle);
static gint ett_mdshdr_hdr = -1;
static gint ett_mdshdr_trlr = -1;
-static dissector_handle_t data_handle, fc_dissector_handle;
+static dissector_handle_t fc_dissector_handle;
static gboolean decode_if_zero_etype = FALSE;
call_dissector_with_data(fc_dissector_handle, next_tvb, pinfo, tree, &fc_data);
}
else {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
*/
mdshdr_handle = create_dissector_handle(dissect_mdshdr, proto_mdshdr);
dissector_add_uint("ethertype", ETHERTYPE_FCFT, mdshdr_handle);
- data_handle = find_dissector("data");
fc_dissector_handle = find_dissector_add_dependency("fc", proto_mdshdr);
mdshdr_prefs_initialized = TRUE;
}
static int proto_mime_encap = -1;
static heur_dissector_list_t heur_subdissector_list;
-static dissector_handle_t data_handle;
static int
dissect_mime_encap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
if (!dissector_try_heuristic(heur_subdissector_list, tvb, pinfo, tree, &hdtbl_entry, NULL)) {
proto_item_append_text(item, " (Unhandled)");
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
{
dissector_handle_t mime_encap_handle;
- data_handle = find_dissector("data");
mime_encap_handle = find_dissector("mime_dlt");
dissector_add_uint("wtap_encap", WTAP_ENCAP_MIME, mime_encap_handle);
}
static dissector_handle_t docsis_handle;
static dissector_handle_t mpeg_pes_handle;
static dissector_handle_t mpeg_sect_handle;
-static dissector_handle_t data_handle;
static heur_dissector_list_t heur_subdissector_list;
if (handle)
call_dissector(handle, tvb, pinfo, tree);
else
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
static guint
docsis_handle = find_dissector("docsis");
mpeg_pes_handle = find_dissector("mpeg-pes");
mpeg_sect_handle = find_dissector("mpeg_sect");
- data_handle = find_dissector("data");
}
/*
static int proto_dsmcc = -1;
-static dissector_handle_t data_handle;
static gboolean dsmcc_sect_check_crc = FALSE;
/* NOTE: Please add values numerically according to 13818-6 so it is easier to
offset, 2, ENC_BIG_ENDIAN);
offset += 2;
sub_tvb = tvb_new_subset_length(tvb, offset, ca_len);
- call_dissector(data_handle, sub_tvb, pinfo, tree);
+ call_data_dissector(sub_tvb, pinfo, tree);
} else if (2 == type) {
sub_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_dsmcc_adaptation_header, NULL, "Adaptation Header");
proto_tree_add_item(sub_tree, hf_dsmcc_adaptation_type, tvb,
offset += 2;
sub_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, sub_tvb, pinfo, top_tree);
+ call_data_dissector(sub_tvb, pinfo, top_tree);
}
dissector_add_uint("mpeg_sect.tid", DSMCC_TID_PRIVATE, dsmcc_ts_handle);
dissector_add_uint("tcp.port", DSMCC_TCP_PORT, dsmcc_tcp_handle);
-
- data_handle = find_dissector("data");
}
/*
static expert_field ei_mpls_y1711_unknown_pdu = EI_INIT;
static dissector_handle_t mpls_y1711_handle;
-static dissector_handle_t data_handle;
static const value_string y1711_function_type_vals[] = {
{0x00, "Reserved" },
*/
proto_tree_add_expert(tree, pinfo, &ei_mpls_y1711_minimum_payload, tvb, offset, -1);
data_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, data_tvb, pinfo, tree);
+ call_data_dissector(data_tvb, pinfo, tree);
return tvb_reported_length(tvb);
}
dissector_add_uint("mpls.label",
MPLS_LABEL_OAM_ALERT /* 14 */,
mpls_y1711_handle);
-
- data_handle = find_dissector("data");
}
/*
static dissector_table_t pw_ach_subdissector_table;
-static dissector_handle_t dissector_data;
static dissector_handle_t dissector_ipv6;
static dissector_handle_t dissector_ip;
static dissector_handle_t dissector_pw_ach;
if (!dissector_try_uint(pw_ach_subdissector_table, channel_type, next_tvb, pinfo, tree))
{
- call_dissector(dissector_data, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
if (channel_type == ACH_TYPE_BFD_CV)
tvb, 2, 2, ENC_BIG_ENDIAN);
}
next_tvb = tvb_new_subset_remaining(tvb, 4);
- call_dissector(dissector_data, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
call_dissector(dissector_pw_eth_heuristic, next_tvb, pinfo, tree);
break;
default:
- call_dissector(dissector_data, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
}
return tvb_captured_length(tvb);
mpls_pwcw_handle = create_dissector_handle( dissect_pw_mcw, proto_pw_mcw );
dissector_add_uint( "mpls.label", MPLS_LABEL_INVALID, mpls_pwcw_handle );
- dissector_data = find_dissector("data");
dissector_ipv6 = find_dissector_add_dependency("ipv6", proto_pw_mcw );
dissector_ip = find_dissector_add_dependency("ip", proto_pw_mcw );
dissector_pw_eth_heuristic = find_dissector_add_dependency("pw_eth_heuristic", proto_pw_mcw);
static dissector_handle_t mq_handle;
static dissector_handle_t mq_spx_handle;
-static dissector_handle_t data_handle;
static dissector_handle_t mqpcf_handle;
static heur_dissector_list_t mq_heur_subdissector_list;
next_tvb = tvb_new_subset_remaining(tvb, offset);
if (!dissector_try_heuristic(mq_heur_subdissector_list, next_tvb, pinfo, mqroot_tree, &hdtbl_entry, p_mq_parm))
- call_dissector(data_handle, next_tvb, pinfo, mqroot_tree);
+ call_data_dissector(next_tvb, pinfo, mqroot_tree);
}
else
{
tvbuff_t *next_tvb;
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, mqroot_tree);
+ call_data_dissector(next_tvb, pinfo, mqroot_tree);
}
}
offset = tvb_reported_length(tvb);
{
/* This is a MQ segment continuation (if MQ reassembly is not enabled) */
col_append_str(pinfo->cinfo, COL_INFO, " [Unreassembled MQ]");
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
}
}
}
{
proto_tree_add_item(tree, proto_mq, tvb, offset, -1, ENC_NA);
}
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
}
}
}
heur_dissector_add("http", dissect_mq_heur_nontcp, "WebSphere MQ over HTTP", "mq_http", proto_mq, HEURISTIC_ENABLE);
heur_dissector_add("ssl", dissect_mq_heur_ssl, "WebSphere MQ over SSL", "mq_ssl", proto_mq, HEURISTIC_ENABLE);
dissector_add_uint("spx.socket", MQ_SOCKET_SPX, mq_spx_handle);
- data_handle = find_dissector("data");
mqpcf_handle = find_dissector("mqpcf");
}
{0, NULL }
};
-static dissector_handle_t data_handle;
static dissector_table_t subdissector_table;
static int proto_mstp = -1;
if (!(dissector_try_uint(subdissector_table, (vendorid<<16) + mstp_frame_type,
next_tvb, pinfo, tree))) {
/* Unknown function - dissect the payload as data */
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
#if defined(BACNET_MSTP_CHECKSUM_VALIDATE)
/* 16-bit checksum - calculate to validate */
dissector_add_uint("wtap_encap", WTAP_ENCAP_BACNET_MS_TP_WITH_PHDR, mstp_handle);
bacnet_handle = find_dissector("bacnet");
- data_handle = find_dissector("data");
dissector_add_uint("mstp.vendor_frame_type", (0/*VendorID ASHRAE*/ << 16) + MSTP_BACNET_DATA_EXPECTING_REPLY, bacnet_handle);
dissector_add_uint("mstp.vendor_frame_type", (0/*VendorID ASHRAE*/ << 16) + MSTP_BACNET_DATA_NOT_EXPECTING_REPLY, bacnet_handle);
{ 0, NULL }
};
-static dissector_handle_t data_handle;
-
/*
* helper routine to format a point code in structured form
col_set_str(pinfo->cinfo, COL_INFO, "DATA ");
if (!dissector_try_uint(mtp3_sio_dissector_table, service_indicator, payload_tvb, pinfo, tree))
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
}
static guint
{
dissector_add_uint("wtap_encap", WTAP_ENCAP_MTP3, mtp3_handle);
dissector_add_string("tali.opcode", "mtp3", mtp3_handle);
-
- data_handle = find_dissector("data");
}
/*
static dissector_table_t media_type_dissector_table;
/* Data and media dissector handles */
-static dissector_handle_t data_handle;
static dissector_handle_t media_handle;
static dissector_handle_t gssapi_handle;
}
parameters = NULL; /* Shares same memory as content_type_str */
} else {
- call_dissector(data_handle, tmp_tvb, pinfo, subtree);
+ call_data_dissector(tmp_tvb, pinfo, subtree);
}
proto_item_set_len(ti, boundary_start - start);
if (*last_boundary == TRUE) {
* We can't get the required multipart information
*/
proto_tree_add_expert(tree, pinfo, &ei_multipart_no_required_parameter, tvb, 0, -1);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return tvb_reported_length(tvb);
}
/* Clean up the memory if an exception is thrown */
*/
header_start = process_preamble(subtree, tvb, m_info, &last_boundary);
if (header_start == -1) {
- call_dissector(data_handle, tvb, pinfo, subtree);
+ call_data_dissector(tvb, pinfo, subtree);
/* Clean up the dynamically allocated memory */
cleanup_multipart_info(m_info);
return tvb_reported_length(tvb);
* When we cannot display the data, call the data dissector.
* When there is no dissector for the given media, call the media dissector.
*/
- data_handle = find_dissector("data");
media_handle = find_dissector_add_dependency("media", proto_multipart);
gssapi_handle = find_dissector_add_dependency("gssapi", proto_multipart);
static heur_dissector_list_t netbios_heur_subdissector_list;
-static dissector_handle_t data_handle;
-
/* There is no RFC or public specification of Netware or Microsoft
* NetBIOS over IPX packets. I have had to decode the protocol myself,
* so there are holes and perhaps errors in this code. (gram)
*/
if (!dissector_try_heuristic(netbios_heur_subdissector_list,
tvb, pinfo, tree, &hdtbl_entry, NULL))
- call_dissector(data_handle,tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
static int
nbipx_handle = create_dissector_handle(dissect_nbipx, proto_nbipx);
dissector_add_uint("ipx.socket", IPX_SOCKET_NETBIOS, nbipx_handle);
netbios_heur_subdissector_list = find_heur_dissector_list("netbios");
- data_handle = find_dissector("data");
}
/*
static heur_dissector_list_t netbios_heur_subdissector_list;
-static dissector_handle_t data_handle;
-
static void
dissect_netbios_payload(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
*/
if (!dissector_try_heuristic(netbios_heur_subdissector_list,
tvb, pinfo, tree, &hdtbl_entry, NULL))
- call_dissector(data_handle,tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
/* NetBIOS datagram packet, from RFC 1002, page 32 */
dissector_add_uint("tcp.port", TCP_PORT_CIFS, nbss_handle);
netbios_heur_subdissector_list = find_heur_dissector_list("netbios");
- data_handle = find_dissector("data");
}
/*
/* desegmentation of NCP over TCP */
static gboolean ncp_desegment = TRUE;
-static dissector_handle_t data_handle;
-
#define TCP_PORT_NCP 524
#define UDP_PORT_NCP 524
* Display the rest of the packet as data.
*/
if (tvb_offset_exists(tvb, commhdr + 10)) {
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, commhdr + 10),
+ call_data_dissector(tvb_new_subset_remaining(tvb, commhdr + 10),
pinfo, ncp_tree);
}
break;
if (length_remaining > data_len)
length_remaining = data_len;
if (data_len != 0) {
- call_dissector(data_handle,
- tvb_new_subset(tvb, offset,
+ call_data_dissector(tvb_new_subset(tvb, offset,
length_remaining, data_len),
pinfo, ncp_tree);
}
dissector_add_uint("udp.port", UDP_PORT_NCP, ncp_handle);
dissector_add_uint("ipx.packet_type", IPX_PACKET_TYPE_NCP, ncp_handle);
dissector_add_uint("ipx.socket", IPX_SOCKET_NCP, ncp_handle);
-
- data_handle = find_dissector("data");
}
/*
"segments"
};
-static dissector_handle_t ndps_data_handle;
-
/* NDPS packets come in request/reply pairs. The request packets tell the
* Function and Program numbers. The response, unfortunately, only
* identifies itself via the Exchange ID; you have to know what type of NDPS
{
/* This is a fragment packet */
next_tvb = tvb_new_subset_remaining (tvb, 0);
- call_dissector(ndps_data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
else
{
dissector_add_uint("tcp.port", TCP_PORT_ENS, ndps_tcp_handle);
dissector_add_uint("tcp.port", TCP_PORT_RMS, ndps_tcp_handle);
dissector_add_uint("tcp.port", TCP_PORT_NOTIFY_LISTENER, ndps_tcp_handle);
- ndps_data_handle = find_dissector("data");
}
/*
static dissector_handle_t eth_dissector_handle;
-static dissector_handle_t data_dissector_handle;
static gint proto_netanalyzer = -1;
transparent_payload_tree = proto_tree_add_subtree(tree, tvb, 4, tvb_captured_length(tvb)-4,
ett_netanalyzer_transparent, NULL, "Raw packet data");
next_tvb = tvb_new_subset_remaining(tvb, 4);
- call_dissector(data_dissector_handle, next_tvb, pinfo, transparent_payload_tree);
+ call_data_dissector(next_tvb, pinfo, transparent_payload_tree);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "netANALYZER");
col_set_str(pinfo->cinfo, COL_INFO, "Frame captured in transparent mode");
dissector_handle_t netana_handle_transparent;
eth_dissector_handle = find_dissector_add_dependency("eth_withfcs", proto_netanalyzer);
- data_dissector_handle = find_dissector("data");
netana_handle = create_dissector_handle(dissect_netanalyzer, proto_netanalyzer);
netana_handle_transparent = create_dissector_handle(dissect_netanalyzer_transparent, proto_netanalyzer);
"fragments"
};
-static dissector_handle_t data_handle;
-
/* The strings for the station type, used by get_netbios_name function;
many of them came from the file "NetBIOS.txt" in the Zip archive at
*/
if (!dissector_try_heuristic(netbios_heur_subdissector_list,
tvb, pinfo, tree, &hdtbl_entry, NULL))
- call_dissector(data_handle,tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
static int
dissect_netbios_payload(next_tvb, pinfo, tree);
else {
next_tvb = tvb_new_subset_remaining (tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo,
- tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
break;
}
proto_netbios);
dissector_add_uint("llc.dsap", SAP_NETBIOS, netbios_handle);
register_capture_dissector("llc.dsap", SAP_NETBIOS, capture_netbios, proto_netbios);
- data_handle = find_dissector("data");
}
static gint ett_netlink_hdr_flags = -1;
static dissector_table_t netlink_dissector_table;
-static dissector_handle_t data_handle;
static const int *netlink_header_get_flags[] = {
next_tvb = tvb_new_subset_length(tvb, offset, pkt_len-16);
if (!dissector_try_uint_new(netlink_dissector_table, protocol, next_tvb, pinfo, fh_msg, TRUE, &data))
- call_dissector(data_handle, next_tvb, pinfo, fh_msg);
+ call_data_dissector(next_tvb, pinfo, fh_msg);
} else if (pkt_len != 16) {
/* XXX, expert info */
void
proto_reg_handoff_netlink(void)
{
- data_handle = find_dissector("data");
-
dissector_add_uint("wtap_encap", WTAP_ENCAP_NETLINK, netlink_handle);
}
/* Dissector handles */
static dissector_handle_t ip_handle;
-static dissector_handle_t data_handle;
/* Initialize the protocol and registered fields */
static int proto_netrom = -1;
if ( cct_index == NETROM_PROTO_IP && cct_id == NETROM_PROTO_IP )
call_dissector( ip_handle , next_tvb, pinfo, tree );
else
- call_dissector( data_handle , next_tvb, pinfo, tree );
+ call_data_dissector(next_tvb, pinfo, tree );
break;
case NETROM_INFO :
default :
- call_dissector( data_handle , next_tvb, pinfo, tree );
+ call_data_dissector(next_tvb, pinfo, tree );
break;
}
}
next_tvb = tvb_new_subset_remaining(tvb, 7);
- call_dissector( data_handle , next_tvb, pinfo, tree );
+ call_data_dissector(next_tvb, pinfo, tree );
}
/* Code to actually dissect the packets */
register_capture_dissector("ax25.pid", AX25_P_NETROM, capture_netrom, proto_netrom);
ip_handle = find_dissector_add_dependency( "ip", proto_netrom );
- data_handle = find_dissector( "data" );
-
}
/*
static dissector_handle_t x25_handle;
static dissector_handle_t sctp_handle;
static dissector_handle_t raw_ip_handle;
-static dissector_handle_t data_handle;
static dissector_table_t ip_proto_dissector_table;
static dissector_table_t tcp_subdissector_table;
case WTAP_ENCAP_NETTL_RAW_IP:
if ( (pinfo->pseudo_header->nettl.kind & NETTL_HDR_PDU_MASK) == 0 )
/* not actually a data packet (PDU) trace record */
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
else if (pinfo->pseudo_header->nettl.subsys == NETTL_SUBSYS_NS_LS_SCTP )
call_dissector(sctp_handle, tvb, pinfo, tree);
else
case WTAP_ENCAP_NETTL_RAW_ICMP:
if (!dissector_try_uint(ip_proto_dissector_table,
IP_PROTO_ICMP, tvb, pinfo, tree))
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
case WTAP_ENCAP_NETTL_RAW_ICMPV6:
if (!dissector_try_uint(ip_proto_dissector_table,
IP_PROTO_ICMPV6, tvb, pinfo, tree))
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
case WTAP_ENCAP_NETTL_X25:
if (pinfo->pseudo_header->nettl.kind == NETTL_HDR_PDUIN)
case WTAP_ENCAP_NETTL_RAW_TELNET:
if (!dissector_try_uint(tcp_subdissector_table,
TCP_PORT_TELNET, tvb, pinfo, tree))
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
default:
col_set_str(pinfo->cinfo, COL_PROTOCOL, "UNKNOWN");
col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported nettl subsytem: %d (%s)",
pinfo->pseudo_header->nettl.subsys,
val_to_str_ext_const(pinfo->pseudo_header->nettl.subsys, &subsystem_ext, "Unknown"));
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
x25_handle = find_dissector_add_dependency("x.25", proto_nettl);
sctp_handle = find_dissector_add_dependency("sctp", proto_nettl);
raw_ip_handle = find_dissector_add_dependency("raw_ip", proto_nettl);
- data_handle = find_dissector("data");
ip_proto_dissector_table = find_dissector_table("ip.proto");
tcp_subdissector_table = find_dissector_table("tcp.port");
static dissector_handle_t ip_handle;
static dissector_handle_t ip6_handle;
-static dissector_handle_t data_handle;
static int
dissect_nflog(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
call_dissector(ip6_handle, next_tvb, pinfo, tree);
break;
default:
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
}
}
ip_handle = find_dissector_add_dependency("ip", hfi_nflog->id);
ip6_handle = find_dissector_add_dependency("ipv6", hfi_nflog->id);
- data_handle = find_dissector("data");
nflog_handle = find_dissector("nflog");
dissector_add_uint("wtap_encap", WTAP_ENCAP_NFLOG, nflog_handle);
static dissector_table_t osinl_excl_subdissector_table;
static dissector_table_t ethertype_subdissector_table;
-static dissector_handle_t data_handle;
-
typedef struct _e_nhrp {
guint16 ar_afn;
guint16 ar_pro_type;
hdr->ar_pro_type, sub_tvb, pinfo, ind_tree);
}
if (!dissected) {
- call_dissector(data_handle, sub_tvb, pinfo,
- ind_tree);
+ call_data_dissector(sub_tvb, pinfo, ind_tree);
}
}
pinfo->flags.in_error_pkt = save_in_error_pkt;
{
dissector_handle_t nhrp_handle;
- data_handle = find_dissector("data");
-
osinl_incl_subdissector_table = find_dissector_table("osinl.incl");
osinl_excl_subdissector_table = find_dissector_table("osinl.excl");
ethertype_subdissector_table = find_dissector_table("ethertype");
};
static dissector_handle_t ppp_hdlc_handle;
-static dissector_handle_t data_handle;
static gboolean
capture_null( const guchar *pd, int offset _U_, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header _U_ )
next_tvb = tvb_new_subset_remaining(tvb, 4);
if (!dissector_try_uint(ethertype_dissector_table,
(guint16) null_header, next_tvb, pinfo, tree))
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
} else {
/* populate a tree in the second pane with the status of the link
layer (ie none) */
if (!dissector_try_uint(null_dissector_table, null_header,
next_tvb, pinfo, tree)) {
/* No sub-dissector found. Label rest of packet as "Data" */
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
}
if (!dissector_try_uint(null_dissector_table, loop_family,
next_tvb, pinfo, tree)) {
/* No sub-dissector found. Label rest of packet as "Data" */
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
* the "I don't know what this is" dissector.
*/
ppp_hdlc_handle = find_dissector_add_dependency("ppp_hdlc", proto_null);
- data_handle = find_dissector("data");
ethertype_dissector_table = find_dissector_table("ethertype");
static int hf_dlm_flags = -1;
static int hf_dlm_payload = -1;
-static dissector_handle_t data_handle;
-
#define O2NM_MAX_NAME_LEN 64
#define O2NM_NODE_MAP_IN_BYTES 32
}
} else {
next_tvb = tvb_new_subset_length(tvb, offset, len);
- call_dissector( data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_reported_length(tvb);
ocfs2_handle = create_dissector_handle(dissect_ocfs2, proto_ocfs2);
dissector_add_for_decode_as("tcp.port", ocfs2_handle);
-
- /* Find dissector for data packet */
- data_handle = find_dissector("data");
}
static dissector_table_t osinl_incl_subdissector_table;
static dissector_table_t osinl_excl_subdissector_table;
-static dissector_handle_t data_handle, ppp_handle;
+static dissector_handle_t ppp_handle;
/* Dissect OSI over TCP over TPKT */
static int
case NLPID_ISO9542X25_ESIS:
col_set_str(pinfo->cinfo, COL_PROTOCOL, "ESIS (X.25)");
- call_dissector(data_handle,tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
case NLPID_ISO10747_IDRP:
col_set_str(pinfo->cinfo, COL_PROTOCOL, "IDRP");
- call_dissector(data_handle,tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
default:
col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISO");
col_add_fstr(pinfo->cinfo, COL_INFO, "Unknown ISO protocol (%02x)", nlpid);
- call_dissector(data_handle,tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
return tvb_captured_length(tvb);
dissector_add_uint("juniper.proto", JUNIPER_PROTO_CLNP, osi_juniper_handle);
dissector_add_uint("juniper.proto", JUNIPER_PROTO_MPLS_CLNP, osi_juniper_handle);
- data_handle = find_dissector("data");
ppp_handle = find_dissector("ppp");
static dissector_handle_t rdp_cr_handle;
static dissector_handle_t rdp_cc_handle;
-static dissector_handle_t data_handle;
/*
* ISO8073 OSI COTP definition
expert_add_info_format(pinfo, ti, &ei_cotp_disconnect_request, "Disconnect Request(DR): 0x%x -> 0x%x", src_ref, dst_ref);
/* User data */
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo,
- tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
offset += tvb_captured_length_remaining(tvb, offset);
/* we dissected all of the containing PDU */
*subdissector_found = TRUE;
} else {
/* Fill in other Dissectors using inactive subset here */
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
} else {
/*
tree, &hdtbl_entry, NULL)) {
*subdissector_found = TRUE;
} else {
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
}
* in an ED packet?
*/
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
offset += tvb_captured_length_remaining(tvb, offset);
/* we dissected all of the containing PDU */
tree, &hdtbl_entry, NULL)) {
*subdissector_found = TRUE;
} else {
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
else
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector( next_tvb, pinfo, tree);
offset += tvb_captured_length_remaining(tvb, offset);
/* we dissected all of the containing PDU */
pinfo, tree, &hdtbl_entry, NULL)) {
*subdissector_found = TRUE;
} else {
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
- /*call_dissector(data_handle,next_tvb, pinfo, tree); */
+ /*call_data_dissector(next_tvb, pinfo, tree); */
offset += tvb_captured_length_remaining(tvb, offset);
/* we dissected all of the containing PDU */
if ((li = tvb_get_guint8(tvb, offset + P_LI)) == 0) {
col_append_str(pinfo->cinfo, COL_INFO, "Length indicator is zero");
if (!first_tpdu)
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset),
+ call_data_dissector( tvb_new_subset_remaining(tvb, offset),
pinfo, tree);
return found_ositp;
}
if (new_offset == -1) { /* incorrect TPDU */
if (!first_tpdu)
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset),
+ call_data_dissector( tvb_new_subset_remaining(tvb, offset),
pinfo, tree);
break;
}
ositp_handle = find_dissector("ositp");
dissector_add_uint("ip.proto", IP_PROTO_TP, ositp_handle);
- data_handle = find_dissector("data");
rdp_cr_handle = find_dissector("rdp_cr");
rdp_cc_handle = find_dissector("rdp_cc");
}
}
-static dissector_handle_t data_handle;
-
static void dissect_ospf_hello(tvbuff_t*, int, proto_tree*, guint8, guint16);
static void dissect_ospf_db_desc(tvbuff_t*, packet_info*, int, proto_tree*, guint8, guint16, guint8);
static void dissect_ospf_ls_req(tvbuff_t*, packet_info*, int, proto_tree*, guint8, guint16);
break;
default:
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, ospf_header_length), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, ospf_header_length), pinfo, tree);
break;
}
dissector_add_uint("ip.proto", IP_PROTO_OSPF, ospf_handle);
register_capture_dissector("ip.proto", IP_PROTO_OSPF, capture_ospf, proto_ospf);
register_capture_dissector("ipv6.nxt", IP_PROTO_OSPF, capture_ospf, proto_ospf);
- data_handle = find_dissector("data");
}
/*
static expert_field ei_esmc_tlv_length_bad = EI_INIT;
static expert_field ei_esmc_reserved_not_zero = EI_INIT;
-static dissector_handle_t dh_data;
-
static void
dissect_esmc_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *treex);
{
proto_tree* tree_b;
tree_b = proto_item_add_subtree(item_b, ett_esmc);
- call_dissector(dh_data, tvb_next, pinfo, tree_b);
+ call_data_dissector(tvb_next, pinfo, tree_b);
}
}
}
ossp_handle = create_dissector_handle(dissect_ossp_pdu, proto_ossp);
dissector_add_uint("slow.subtype", OSSP_SUBTYPE, ossp_handle);
-
- dh_data = find_dissector("data");
}
/*
static dissector_handle_t p_mul_handle = NULL;
-static dissector_handle_t data_handle = NULL;
-
typedef struct _p_mul_id_key {
guint32 id;
guint16 seq;
dissect_cdt (tvb, pinfo, tree);
break;
default:
- call_dissector (data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
}
if (!p_mul_prefs_initialized) {
p_mul_prefs_initialized = TRUE;
- data_handle = find_dissector ("data");
dissector_add_uint ("s5066sis.ctl.appid", S5066_CLIENT_S4406_ANNEX_E_TMI_1_P_MUL, p_mul_handle);
} else {
dissector_delete_uint_range ("udp.port", p_mul_port_range, p_mul_handle);
static dissector_handle_t packetlogger_handle;
static dissector_table_t hci_h1_table;
-static dissector_handle_t data_handle;
-
#define PKT_HCI_COMMAND 0x00
#define PKT_HCI_EVENT 0x01
#define PKT_SENT_ACL_DATA 0x02
col_add_fstr (pinfo->cinfo, COL_INFO, "%s", val_to_str(pl_type, type_vals, "Unknown 0x%02x"));
if (!dissector_try_uint_new(hci_h1_table, bthci.channel,
next_tvb, pinfo, tree, TRUE, bluetooth_data)) {
- call_dissector (data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
} else {
/* PacketLogger data */
col_add_fstr (pinfo->cinfo, COL_INFO, "%s", tvb_format_stringzpad_wsp (next_tvb, 0, len));
break;
default:
- call_dissector (data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
col_add_fstr (pinfo->cinfo, COL_INFO, "Unknown 0x%02x", pl_type);
break;
}
void proto_reg_handoff_packetlogger (void)
{
hci_h1_table = find_dissector_table("hci_h1.type");
- data_handle = find_dissector("data");
dissector_add_uint ("bluetooth.encap", WTAP_ENCAP_PACKETLOGGER, packetlogger_handle);
}
static gboolean pcli_summary_in_tree = TRUE;
-static dissector_handle_t data_handle;
-
static dissector_table_t pcli_subdissector_table;
static proto_tree *
* have a unique identifier to determine subdissector
*/
if (!dissector_try_uint(pcli_subdissector_table, 0, next_tvb, pinfo, tree)) {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
pcli_handle8 = create_dissector_handle(dissect_pcli8, proto_pcli8);
pcli_handle12 = create_dissector_handle(dissect_pcli12, proto_pcli12);
pcli_handle20 = create_dissector_handle(dissect_pcli20, proto_pcli20);
- data_handle = find_dissector("data");
pcli_initialized = TRUE;
}
static dissector_handle_t ip_handle;
static dissector_handle_t ipv6_handle;
static dissector_handle_t rohc_handle;
-static dissector_handle_t data_handle;
#define SEQUENCE_ANALYSIS_RLC_ONLY 1
call_dissector_only(ipv6_handle, ip_payload_tvb, pinfo, pdcp_tree, NULL);
break;
default:
- call_dissector_only(data_handle, ip_payload_tvb, pinfo, pdcp_tree, NULL);
+ call_data_dissector(ip_payload_tvb, pinfo, pdcp_tree);
break;
}
ip_handle = find_dissector_add_dependency("ip", proto_pdcp_lte);
ipv6_handle = find_dissector_add_dependency("ipv6", proto_pdcp_lte);
rohc_handle = find_dissector_add_dependency("rohc", proto_pdcp_lte);
- data_handle = find_dissector("data");
}
/*
void proto_register_old_pflog(void);
void proto_reg_handoff_old_pflog(void);
-static dissector_handle_t data_handle, ip_handle, ipv6_handle;
+static dissector_handle_t ip_handle, ipv6_handle;
/* header fields */
static int proto_pflog = -1;
break;
default:
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
}
ip_handle = find_dissector_add_dependency("ip", proto_pflog);
ipv6_handle = find_dissector_add_dependency("ipv6", proto_pflog);
- data_handle = find_dissector("data");
pflog_handle = create_dissector_handle(dissect_pflog, proto_pflog);
dissector_add_uint("wtap_encap", WTAP_ENCAP_PFLOG, pflog_handle);
break;
default:
- offset += call_dissector(data_handle, next_tvb, pinfo, tree);
+ offset += call_data_dissector(next_tvb, pinfo, tree);
break;
}
ip_handle = find_dissector("ip");
ipv6_handle = find_dissector("ipv6");
- data_handle = find_dissector("data");
pflog_handle = create_dissector_handle(dissect_old_pflog, proto_old_pflog);
dissector_add_uint("wtap_encap", WTAP_ENCAP_OLD_PFLOG, pflog_handle);
static dissector_table_t subdissector_table;
static heur_dissector_list_t heur_subdissector_list;
-static dissector_handle_t data_handle;
static const char *
return;
/* Oh, well, we don't know this; dissect it as data. */
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
/*
pgm_handle = create_dissector_handle(dissect_pgm, proto_pgm);
dissector_add_for_decode_as("udp.port", pgm_handle);
dissector_add_uint("ip.proto", IP_PROTO_PGM, pgm_handle);
- data_handle = find_dissector("data");
initialized = TRUE;
} else {
if (old_udp_encap_ucast_port != 0) {
/* Initialize the subtree pointer */
static gint ett_pktgen = -1;
-/* data dissector handle */
-static dissector_handle_t data_handle;
-
/* entry point */
static gboolean dissect_pktgen(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
{
proto_tree_add_time(pktgen_tree, hf_pktgen_timestamp, tvb, offset - 8, 8, &tstamp);
if (tvb_reported_length_remaining(tvb, offset)) /* random data */
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo,
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo,
pktgen_tree);
}
{
/* Register as a heuristic UDP dissector */
heur_dissector_add("udp", dissect_pktgen, "Linux Kernel Packet Generator over UDP", "pktgen_udp", proto_pktgen, HEURISTIC_ENABLE);
-
- /* Find data dissector handle */
- data_handle = find_dissector("data");
}
static gint ett_pop_data_fragments = -1;
static dissector_handle_t pop_handle;
-static dissector_handle_t data_handle;
static dissector_handle_t imf_handle;
static dissector_handle_t ssl_handle;
/*
* Put the whole packet into the tree as data.
*/
- call_dissector(data_handle,tvb, pinfo, pop_tree);
+ call_data_dissector(tvb, pinfo, pop_tree);
}
return tvb_captured_length(tvb);
pop_handle = find_dissector("pop");
dissector_add_uint("tcp.port", TCP_PORT_POP, pop_handle);
ssl_dissector_add(TCP_PORT_SSL_POP, pop_handle);
- data_handle = find_dissector("data");
/* find the IMF dissector */
imf_handle = find_dissector_add_dependency("imf", proto_pop);
static dissector_handle_t sccp_handle; /* SCCP handle */
static dissector_handle_t sgsap_handle; /* SGSAP handle */
static dissector_handle_t gtpv2_handle; /* GTPv2 handle */
-static dissector_handle_t data_handle; /* DATA handle */
static dissector_table_t sccp_ssn_dissector_table;
call_dissector(gtpv2_handle, next_tvb, pinfo, tree); /* calling the GTPv2 handle */
break;
default:
- call_dissector(data_handle, next_tvb, pinfo, tree); /* calling the DATA handle */
+ call_data_dissector(next_tvb, pinfo, tree); /* calling the DATA handle */
break;
}
sccp_handle = find_dissector_add_dependency("sccp", proto_ppcap); /* calling the protocol SCCP */
sgsap_handle = find_dissector_add_dependency("sgsap", proto_ppcap); /* calling the protocol SGSAP */
gtpv2_handle = find_dissector_add_dependency("gtpv2", proto_ppcap); /* calling the protocol GTPv2 */
- data_handle = find_dissector("data"); /* calling the protocol DATA */
sccp_ssn_dissector_table = find_dissector_table("sccp.ssn");
static dissector_handle_t ppi_handle;
-static dissector_handle_t data_handle;
static dissector_handle_t ieee80211_radio_handle;
static dissector_handle_t pcap_pktdata_handle;
static dissector_handle_t ppi_gps_handle, ppi_vector_handle, ppi_sensor_handle, ppi_antenna_handle;
next_tvb = tvb_new_subset_remaining(tvb, offset);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "IEEE 802.11n");
col_set_str(pinfo->cinfo, COL_INFO, "Unreassembled A-MPDU data");
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
void
proto_reg_handoff_ppi(void)
{
- data_handle = find_dissector("data");
ieee80211_radio_handle = find_dissector_add_dependency("wlan_radio", proto_ppi);
pcap_pktdata_handle = find_dissector_add_dependency("pcap_pktdata", proto_ppi);
ppi_gps_handle = find_dissector_add_dependency("ppi_gps", proto_ppi);
static dissector_table_t ppp_subdissector_table;
static dissector_handle_t chdlc_handle;
-static dissector_handle_t data_handle;
static dissector_handle_t eth_withfcs_handle;
static dissector_handle_t eth_withoutfcs_handle;
next_tvb = tvb_new_subset_length(tvb, offset, length);
if (!dissector_try_uint(ppp_subdissector_table, protocol, next_tvb,
pinfo, fh_tree)) {
- call_dissector(data_handle, next_tvb, pinfo, fh_tree);
+ call_data_dissector(next_tvb, pinfo, fh_tree);
}
/* Restore the "we're inside an error packet" flag. */
col_add_fstr(pinfo->cinfo, COL_INFO, "PPP %s (0x%04x)",
val_to_str_ext_const(ppp_prot, &ppp_vals_ext, "Unknown"),
ppp_prot);
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
col_add_fstr(pinfo->cinfo, COL_PROTOCOL, "0x%04x", PPP_IP);
col_add_fstr(pinfo->cinfo, COL_INFO, "PPP %s (0x%04x)",
val_to_str_ext_const(PPP_IP, &ppp_vals_ext, "Unknown"), PPP_IP);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
break;
default:
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
}
}
if (!dissector_try_uint(ppp_subdissector_table, pid, next_tvb, pinfo,
info_tree)) {
- call_dissector(data_handle, next_tvb, pinfo, info_tree);
+ call_data_dissector(next_tvb, pinfo, info_tree);
}
offset += length;
length_remaining -= length;
if (!dissector_try_uint(ppp_subdissector_table, PPP_IP, next_tvb, pinfo,
info_tree)) {
- call_dissector_only(data_handle, next_tvb, pinfo, info_tree, NULL);
+ call_data_dissector(next_tvb, pinfo, info_tree);
}
return tvb_captured_length(tvb);
}
ppp_tvb = remove_escape_chars(tvb, pinfo, offset,length);
if (ppp_tvb != NULL) {
add_new_data_source(pinfo, ppp_tvb, "PPP Fragment");
- call_dissector(data_handle, ppp_tvb, pinfo, tree);
+ call_data_dissector(ppp_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
ppp_tvb = remove_escape_chars(tvb, pinfo, 0, length - 1);
if (ppp_tvb != NULL) {
add_new_data_source(pinfo, ppp_tvb, "PPP Fragment");
- call_dissector(data_handle, ppp_tvb, pinfo, tree);
+ call_data_dissector(ppp_tvb, pinfo, tree);
}
}
}
ppp_tvb = remove_escape_chars(tvb, pinfo, offset, length);
if (ppp_tvb != NULL) {
add_new_data_source(pinfo, ppp_tvb, "PPP Fragment");
- call_dissector(data_handle, ppp_tvb, pinfo, tree);
+ call_data_dissector(ppp_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
* Get a handle for the CHDLC dissector.
*/
chdlc_handle = find_dissector_add_dependency("chdlc", proto_ppp);
- data_handle = find_dissector("data");
ppp_handle = find_dissector("ppp");
dissector_add_uint("fr.nlpid", NLPID_PPP, ppp_handle);
static expert_field ei_pptp_incorrect_magic_cookie = EI_INIT;
-static dissector_handle_t data_handle;
-
#define TCP_PORT_PPTP 1723
#define MAGIC_COOKIE 0x1A2B3C4D
static void
dissect_unknown(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
- call_dissector(data_handle,tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
}
static void
pptp_handle = create_dissector_handle(dissect_pptp, proto_pptp);
dissector_add_uint("tcp.port", TCP_PORT_PPTP, pptp_handle);
- data_handle = find_dissector("data");
}
/*
static dissector_handle_t dh_atm_untruncated;
static dissector_handle_t dh_atm_oam_cell;
static dissector_handle_t dh_padding;
-static dissector_handle_t dh_data;
#define PTI_IS_ADMIN(pti) ((pti) == 4 || (pti) == 5 || (pti) == 6) /*see atm_pt_vals[]*/
tvbuff_t* tvb_d;
tree2 = proto_item_add_subtree(item, ett_cell);
tvb_d = tvb_new_subset(tvb, 0, dissect_size, -1);
- call_dissector(dh_data, tvb_d, pinfo, tree2);
+ call_data_dissector(tvb_d, pinfo, tree2);
item = proto_tree_add_int(tree2, hf_cell_payload_len, tvb, 0, 0, dissect_size);
PROTO_ITEM_SET_HIDDEN(item);
}
dh_atm_untruncated = find_dissector("atm_pw_untruncated");
dh_atm_oam_cell = find_dissector("atm_pw_oam_cell");
dh_padding = find_dissector("pw_padding");
- dh_data = find_dissector("data");
}
/*
static expert_field ei_cw_lm = EI_INIT;
static expert_field ei_packet_size_too_small = EI_INIT;
-static dissector_handle_t data_handle;
static dissector_handle_t pw_padding_handle;
const char pwc_longname_pw_cesopsn[] = "CESoPSN basic NxDS0 mode (no RTP support)";
"CESoPSN packet payload size must be multiple of 8");
}
tree2 = proto_item_add_subtree(item2, ett);
- call_dissector(data_handle, tvb, pinfo, tree2);
+ call_data_dissector(tvb, pinfo, tree2);
item2 = proto_tree_add_int(tree2, hf_payload_l, tvb, 0, 0
,(int)payload_size); /* allow filtering */
PROTO_ITEM_SET_HIDDEN(item2);
{
dissector_handle_t pw_cesopsn_mpls_handle;
- data_handle = find_dissector("data");
pw_padding_handle = find_dissector_add_dependency("pw_padding", proto);
/* For Decode As */
static gint proto_pw_padding = -1;
static gint ett = -1;
static int hf_padding_len = -1;
-static dissector_handle_t dh_data;
static
int dissect_pw_padding(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void* data _U_)
pwc_item_append_text_n_items(item,size,"byte");
tree_p = proto_item_add_subtree(item, ett);
- call_dissector(dh_data, tvb, pinfo, tree_p);
+ call_data_dissector(tvb, pinfo, tree_p);
item = proto_tree_add_int(tree_p, hf_padding_len, tvb, 0, 0, size);
PROTO_ITEM_SET_HIDDEN(item); /*allow filtering*/
}
-void proto_reg_handoff_pw_padding(void)
-{
- dh_data = find_dissector("data");
-}
-
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
static expert_field ei_cw_bits03 = EI_INIT;
static expert_field ei_cw_packet_size_too_small = EI_INIT;
-static dissector_handle_t data_handle;
static dissector_handle_t pw_padding_handle;
const char pwc_longname_pw_satop[] = "SAToP (no RTP support)";
}
proto_item_append_text(item2, "%s", s);
tree3 = proto_item_add_subtree(item2, ett);
- call_dissector(data_handle, tvb, pinfo, tree3);
+ call_data_dissector(tvb, pinfo, tree3);
item2 = proto_tree_add_int(tree3, hf_payload_l, tvb, 0, 0
,(int)payload_size); /* allow filtering */
PROTO_ITEM_SET_HIDDEN(item2);
{
dissector_handle_t pw_satop_mpls_handle;
- data_handle = find_dissector("data");
pw_padding_handle = find_dissector_add_dependency("pw_padding", proto);
/* For Decode As */
static dissector_handle_t h225_handle;
static dissector_handle_t q931_tpkt_handle;
static dissector_handle_t q931_tpkt_pdu_handle;
-static dissector_handle_t data_handle = NULL;
static heur_dissector_list_t q931_user_heur_subdissector_list;
next_tvb = tvb_new_subset_length(tvb, offset, len);
proto_tree_add_uint_format_value(tree, hf_q931_user_information_len, tvb, offset, len, len, "%d octets", len);
if (!dissector_try_heuristic(q931_user_heur_subdissector_list, next_tvb, pinfo, tree, &hdtbl_entry, NULL)) {
- call_dissector_only(data_handle, next_tvb, pinfo, tree, NULL);
+ call_data_dissector(next_tvb, pinfo, tree);
}
break;
*/
h225_handle = find_dissector_add_dependency("h225", proto_q931);
- data_handle = find_dissector("data");
-
/*
* For H.323.
*/
static gint ett_quake_flags = -1;
static dissector_handle_t quake_handle;
-static dissector_handle_t data_handle;
/* I took these names directly out of the Q1 source. */
#define NET_HEADERSIZE 8
(next_tvb, control_tree);
break;
default:
- call_dissector(data_handle,next_tvb, pinfo, control_tree);
+ call_data_dissector(next_tvb, pinfo, control_tree);
break;
}
}
tvb, 4, 4, sequence);
next_tvb = tvb_new_subset_remaining(tvb, 8);
- call_dissector(data_handle,next_tvb, pinfo, quake_tree);
+ call_data_dissector(next_tvb, pinfo, quake_tree);
return tvb_captured_length(tvb);
}
if (!Initialized) {
quake_handle = create_dissector_handle(dissect_quake, proto_quake);
- data_handle = find_dissector("data");
Initialized=TRUE;
} else {
dissector_delete_uint("udp.port", ServerPort, quake_handle);
static gint ett_quake2_game_clc_cmd_move_moves = -1;
-static dissector_handle_t data_handle;
-
#define PORT_MASTER 27910
static guint gbl_quake2ServerPort=PORT_MASTER;
default:
break;
}
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
if (!Initialized) {
quake2_handle = create_dissector_handle(dissect_quake2,
proto_quake2);
- data_handle = find_dissector("data");
Initialized=TRUE;
} else {
dissector_delete_uint("udp.port", ServerPort, quake2_handle);
static gint ett_quake3_game_clc = -1;
static gint ett_quake3_game_svc = -1;
-static dissector_handle_t data_handle;
-
#define QUAKE3_SERVER_PORT 27960
#define QUAKE3_MASTER_PORT 27950
static guint gbl_quake3_server_port=QUAKE3_SERVER_PORT;
proto_tree *tree)
{
/* this shouldn't be too difficult */
- call_dissector(data_handle,tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
{
/* It is totally forbidden to decode this any further,
I won't do it. */
- call_dissector(data_handle,tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
if (!initialized) {
quake3_handle = create_dissector_handle(dissect_quake3,
proto_quake3);
- data_handle = find_dissector("data");
initialized=TRUE;
} else {
for (i=0;i<4;i++)
static gint ett_quakeworld_game_clc = -1;
static gint ett_quakeworld_game_svc = -1;
-static dissector_handle_t data_handle;
-
/*
helper functions, they may ave to go somewhere else
they are mostly copied without change from
the information from my QWD specs:
http://www.planetquake.com/demospecs/qwd/
*/
- call_dissector(data_handle,tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
the information from my QWD specs:
http://www.planetquake.com/demospecs/qwd/
*/
- call_dissector(data_handle,tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
}
if (!Initialized) {
quakeworld_handle = create_dissector_handle(dissect_quakeworld,
proto_quakeworld);
- data_handle = find_dissector("data");
Initialized=TRUE;
} else {
dissector_delete_uint("udp.port", ServerPort, quakeworld_handle);
static dissector_handle_t raw_handle;
static dissector_handle_t ip_handle;
static dissector_handle_t ipv6_handle;
-static dissector_handle_t data_handle;
static dissector_handle_t ppp_hdlc_handle;
static gboolean
default:
/* None of the above. */
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
}
}
*/
ip_handle = find_dissector_add_dependency("ip", proto_raw);
ipv6_handle = find_dissector_add_dependency("ipv6", proto_raw);
- data_handle = find_dissector("data");
ppp_hdlc_handle = find_dissector_add_dependency("ppp_hdlc", proto_raw);
dissector_add_uint("wtap_encap", WTAP_ENCAP_RAW_IP, raw_handle);
register_capture_dissector("wtap_encap", WTAP_ENCAP_RAW_IP, capture_raw, proto_raw);
static dissector_handle_t arp_handle;
static dissector_handle_t ppp_handle;
static dissector_handle_t ppphdlc_handle;
-static dissector_handle_t data_handle;
static header_field_info *hfi_redback = NULL;
if(dissector_try_uint(osinl_excl_subdissector_table, nlpid, next_tvb, pinfo, tree))
break;
next_tvb = tvb_new_subset_remaining(tvb, dataoff);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
break;
case 0x06: {
ipv4_handle = find_dissector_add_dependency("ip", hfi_redback->id);
ipv6_handle = find_dissector_add_dependency("ipv6", hfi_redback->id);
- data_handle = find_dissector("data");
ethnofcs_handle = find_dissector_add_dependency("eth_withoutfcs", hfi_redback->id);
clnp_handle = find_dissector_add_dependency("clnp", hfi_redback->id);
arp_handle = find_dissector_add_dependency("arp", hfi_redback->id);
static int hf_reload_leavereq = -1;
static int hf_reload_leavereq_leaving_peer_id = -1;
-static dissector_handle_t data_handle;
static dissector_handle_t xml_handle;
}
save_fragmented = pinfo->fragmented;
pinfo->fragmented = TRUE;
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
pinfo->fragmented = save_fragmented;
return effective_length;
}
void
proto_reg_handoff_reload(void)
{
-
- data_handle = find_dissector("data");
xml_handle = find_dissector_add_dependency("xml", proto_reload);
heur_dissector_add("udp", dissect_reload_heur, "RELOAD over UDP", "reload_udp", proto_reload, HEURISTIC_ENABLE);
#include <epan/packet.h>
void proto_register_felica(void);
-void proto_reg_handoff_felica(void);
static int proto_felica = -1;
{0x00, NULL}
};
-static dissector_handle_t data_handle=NULL;
-
/* Subtree handles: set by register_subtree_array */
static gint ett_felica = -1;
proto_tree_add_item(felica_tree, hf_felica_nbr_of_blocks, tvb, 11, 1, ENC_BIG_ENDIAN);
}
rwe_resp_data_tvb = tvb_new_subset_remaining(tvb, 12);
- call_dissector(data_handle, rwe_resp_data_tvb, pinfo, tree);
+ call_data_dissector(rwe_resp_data_tvb, pinfo, tree);
break;
case CMD_WRITE_WO_ENCRYPTION:
register_dissector("felica", dissect_felica, proto_felica);
}
-/* Handler registration */
-void
-proto_reg_handoff_felica(void)
-{
- data_handle = find_dissector("data");
-}
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
static gint ett_rsp = -1;
-static dissector_handle_t data_handle;
static dissector_table_t rmcp_dissector_table;
#define UDP_PORT_RMCP 623
if (!dissector_try_uint(rmcp_dissector_table, rmcp_class, next_tvb, pinfo,
tree)) {
- len = call_dissector(data_handle, next_tvb, pinfo, tree);
+ len = call_data_dissector(next_tvb, pinfo, tree);
if (len < tvb_reported_length(next_tvb)) {
proto_tree_add_item(tree, hf_rmcp_trailer, tvb, 4 + len, -1, ENC_NA);
}
{
dissector_handle_t rmcp_handle;
- data_handle = find_dissector("data");
-
rmcp_handle = create_dissector_handle(dissect_rmcp, proto_rmcp);
dissector_add_uint("udp.port", UDP_PORT_RMCP, rmcp_handle);
}
void proto_register_rmp(void);
void proto_reg_handoff_rmp(void);
-static dissector_handle_t data_handle;
-
static int proto_rmp = -1;
static int hf_rmp_type = -1;
proto_tree_add_item(rmp_tree,
hf_rmp_filename, tvb, 30, 1, ENC_ASCII|ENC_BIG_ENDIAN);
if(tvb_offset_exists(tvb, len+31))
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, len+31),
+ call_data_dissector(tvb_new_subset_remaining(tvb, len+31),
pinfo, tree);
break;
proto_tree_add_item(rmp_tree,
hf_rmp_filename, tvb, 10, 1, ENC_ASCII|ENC_BIG_ENDIAN);
if(tvb_offset_exists(tvb, len+11))
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, len+11),
+ call_data_dissector(tvb_new_subset_remaining(tvb, len+11),
pinfo, tree);
break;
proto_tree_add_item(rmp_tree,
hf_rmp_size, tvb, 8, 2, ENC_BIG_ENDIAN);
if(tvb_offset_exists(tvb, 10))
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, 10),
+ call_data_dissector(tvb_new_subset_remaining(tvb, 10),
pinfo, tree);
break;
hf_rmp_offset, tvb, 2, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(rmp_tree,
hf_rmp_sessionid, tvb, 6, 2, ENC_BIG_ENDIAN);
- call_dissector(data_handle, tvb_new_subset_remaining(tvb,
+ call_data_dissector(tvb_new_subset_remaining(tvb,
8), pinfo, rmp_tree);
break;
proto_tree_add_item(rmp_tree,
hf_rmp_sessionid, tvb, 6, 2, ENC_BIG_ENDIAN);
if(tvb_offset_exists(tvb, 8))
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, 6),
+ call_data_dissector(tvb_new_subset_remaining(tvb, 6),
pinfo, tree);
break;
default:
- call_dissector(data_handle, tvb_new_subset_remaining(tvb,
- 1), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, 1), pinfo, tree);
}
return tvb_captured_length(tvb);
}
{
dissector_handle_t rmp_handle;
- data_handle = find_dissector("data");
-
rmp_handle = find_dissector("rmp");
dissector_add_uint("hpext.dxsap", HPEXT_DXSAP, rmp_handle);
dissector_add_uint("hpext.dxsap", HPEXT_SXSAP, rmp_handle);
static dissector_handle_t ip_handle;
static dissector_handle_t ipv6_handle;
-static dissector_handle_t data_handle;
typedef struct _rohc_cid_context_t
{
}
payload_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector_only(data_handle, payload_tvb, pinfo, rohc_tree, NULL);
+ call_data_dissector(payload_tvb, pinfo, rohc_tree);
return tvb_captured_length(tvb);
}
if((oct&0xff) == 0xf8){
}
payload_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector_only(data_handle, payload_tvb, pinfo, rohc_tree, NULL);
+ call_data_dissector(payload_tvb, pinfo, rohc_tree);
return tvb_captured_length(tvb);
}
call_dissector(ipv6_handle, next_tvb, pinfo, tree);
}
else {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
col_prepend_fstr(pinfo->cinfo, COL_PROTOCOL, "ROHC <");
col_append_str(pinfo->cinfo, COL_PROTOCOL, ">");
}
payload_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector_only(data_handle, payload_tvb, pinfo, tree, NULL);
+ call_data_dissector(payload_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
ip_handle = find_dissector_add_dependency("ip", proto_rohc);
ipv6_handle = find_dissector_add_dependency("ipv6", proto_rohc);
- data_handle = find_dissector("data");
}
/*
static expert_field ei_caplen_too_big = EI_INIT;
static dissector_handle_t pcap_pktdata_handle;
-static dissector_handle_t data_handle;
/* User definable values */
static gboolean rpcap_desegment = TRUE;
if (linktype == -1) {
proto_item_append_text (ti, ", Unknown link-layer type");
}
- call_dissector (data_handle, new_tvb, pinfo, top_tree);
+ call_data_dissector(new_tvb, pinfo, top_tree);
}
}
/* Yet unknown, dump as data */
proto_item_set_len (ti, 8);
new_tvb = tvb_new_subset_remaining (tvb, offset);
- call_dissector (data_handle, new_tvb, pinfo, top_tree);
+ call_data_dissector(new_tvb, pinfo, top_tree);
}
break;
}
if (!rpcap_prefs_initialized) {
pcap_pktdata_handle = find_dissector_add_dependency("pcap_pktdata", proto_rpcap);
- data_handle = find_dissector ("data");
rpcap_prefs_initialized = TRUE;
heur_dissector_add ("tcp", dissect_rpcap_heur_tcp, "RPCAP over TCP", "rpcap_tcp", proto_rpcap, HEURISTIC_ENABLE);
static int proto_rpcordma = -1;
static dissector_handle_t ib_handler;
-static dissector_handle_t data_handler;
static dissector_handle_t rpc_handler;
static dissector_handle_t rpcordma_handler;
static int proto_ib = -1;
default:
next_tvb = tvb_new_subset_remaining(tvb, offset);
- return call_dissector(data_handler, next_tvb, pinfo, tree);
+ return call_data_dissector(next_tvb, pinfo, tree);
}
break;
}
manual_addr_data[0] = wmem_alloc(wmem_epan_scope(), GID_SIZE);
manual_addr_data[1] = wmem_alloc(wmem_epan_scope(), GID_SIZE);
- data_handler = find_dissector("data");
rpc_handler = find_dissector_add_dependency("rpc", proto_rpcordma);
ib_handler = find_dissector_add_dependency("infiniband", proto_rpcordma);
proto_ib = dissector_handle_get_protocol_index(ib_handler);
{ 0x0, NULL }
};
-static dissector_handle_t data_handle;
-
static void
dissect_rpl_container(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
break;
default:
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, 4), pinfo,
+ call_data_dissector(tvb_new_subset_remaining(tvb, 4), pinfo,
tree);
break;
}
if (tvb_reported_length(tvb) > offset)
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
}
static int
dissect_rpl_container(next_tvb, pinfo, rpl_tree);
if (tvb_reported_length(tvb) > rpl_len)
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, rpl_len), pinfo,
+ call_data_dissector(tvb_new_subset_remaining(tvb, rpl_len), pinfo,
tree);
return tvb_captured_length(tvb);
{
dissector_handle_t rpl_handle;
- data_handle = find_dissector("data");
rpl_handle = find_dissector("rpl");
dissector_add_uint("llc.dsap", SAP_RPL, rpl_handle);
}
static dissector_handle_t rtacser_handle;
static dissector_table_t subdissector_table;
-static dissector_handle_t data_handle;
#define RTACSER_HEADER_LEN 12
/* Functionality for choosing subdissector is controlled through Decode As as CAN doesn't
have a unique identifier to determine subdissector */
if (!dissector_try_uint(subdissector_table, 0, payload_tvb, pinfo, tree)){
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
}
}
}
proto_reg_handoff_rtacser(void)
{
dissector_add_uint("wtap_encap", WTAP_ENCAP_RTAC_SERIAL, rtacser_handle);
-
- data_handle = find_dissector("data");
}
/*
};
static gint global_rtp_version0_type = 0;
-static dissector_handle_t data_handle;
-
/* Forward declaration we need below */
void proto_register_rtp(void);
void proto_reg_handoff_rtp(void);
if (p_conv_data->bta2dp_info->codec_dissector)
call_dissector_with_data(p_conv_data->bta2dp_info->codec_dissector, nexttvb, pinfo, tree, p_conv_data->bta2dp_info);
else
- call_dissector(data_handle, nexttvb, pinfo, tree);
+ call_data_dissector(nexttvb, pinfo, tree);
} else if (p_conv_data && p_conv_data->btvdp_info) {
tvbuff_t *nexttvb;
gint suboffset = 0;
if (p_conv_data->btvdp_info->codec_dissector)
call_dissector_with_data(p_conv_data->btvdp_info->codec_dissector, nexttvb, pinfo, tree, p_conv_data->btvdp_info);
else
- call_dissector(data_handle, nexttvb, pinfo, tree);
+ call_data_dissector(nexttvb, pinfo, tree);
}
/* if we don't found, it is static OR could be set static from the preferences */
* item.
*/
proto_tree_add_expert(rtp_tree, pinfo, &ei_rtp_padding_missing, tvb, 0, 0);
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset),
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset),
pinfo, rtp_tree);
return tvb_captured_length(tvb);
}
rtcp_handle = find_dissector_add_dependency("rtcp", proto_rtp);
- data_handle = find_dissector("data");
stun_handle = find_dissector_add_dependency("stun-udp", proto_rtp);
classicstun_handle = find_dissector_add_dependency("classicstun", proto_rtp);
classicstun_heur_handle = find_dissector_add_dependency("classicstun-heur", proto_rtp);
static gint ett_rudp_flags = -1;
static dissector_handle_t sm_handle = NULL;
-static dissector_handle_t data_handle = NULL;
-
static int
dissect_rudp(tvbuff_t *tvb, packet_info *pinfo _U_ , proto_tree *tree, void* data _U_)
* in live captures */
if (hlen > 6) {
next_tvb = tvb_new_subset_length(tvb, 6, hlen-6);
- call_dissector(data_handle, next_tvb, pinfo, rudp_tree);
+ call_data_dissector(next_tvb, pinfo, rudp_tree);
}
next_tvb = tvb_new_subset_remaining(tvb, hlen);
rudp_handle = create_dissector_handle(dissect_rudp, proto_rudp);
dissector_add_for_decode_as("udp.port", rudp_handle);
sm_handle = find_dissector_add_dependency("sm", proto_rudp);
- data_handle = find_dissector("data");
initialized = TRUE;
} else {
if (saved_udp_port != 0) {
static guint dissect_s5066_27(tvbuff_t *tvb, guint offset, proto_tree *tree, guint *client_app_id);
static gint proto_s5066 = -1;
-static dissector_handle_t data_handle;
static dissector_table_t s5066sis_dissector_table;
next_tvb = tvb_new_subset(tvb, offset, MIN(available_length, reported_length), reported_length);
if(dissector_try_uint(s5066sis_dissector_table, client_app_id, next_tvb, pinfo, tree) == 0) {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
if (!Initialized) {
s5066_tcp_handle = create_dissector_handle(dissect_s5066_tcp, proto_s5066);
- data_handle = find_dissector("data");
Initialized = TRUE;
} else {
dissector_delete_uint("tcp.port", saved_s5066_port, s5066_tcp_handle);
static guint32 gPREF_scop_port_secured = SCOP_DEFAULT_PORT_SECURED;
/* Dissector handle */
-static dissector_handle_t data_handle;
static dissector_handle_t ieee802154_handle;
/*FUNCTION:------------------------------------------------------
/* Nothing yet defined for the gateway. Fall-Through. */
default:
/* Unknown Service Type. */
- call_dissector(data_handle, tvb_new_subset_remaining(next_tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(next_tvb, offset), pinfo, tree);
break;
}
if (offset < tvb_reported_length(tvb)) {
tvbuff_t *payload_tvb = tvb_new_subset_remaining(tvb, offset);
proto_tree *root = proto_tree_get_root(tree);
- call_dissector(data_handle, payload_tvb, pinfo, root);
+ call_data_dissector(payload_tvb, pinfo, root);
}
} /* dissect_scop_zip() */
scop_udp_handle = find_dissector("scop.udp");
scop_tcp_handle = find_dissector("scop.tcp");
ieee802154_handle = find_dissector_add_dependency("wpan_nofcs", proto_scop);
- data_handle = find_dissector("data");
inited = TRUE;
} else {
dissector_delete_uint("udp.port", lastPort, scop_udp_handle);
#include "packet-scsi-smc.h"
void proto_register_scsi(void);
-void proto_reg_handoff_scsi(void);
static int proto_scsi = -1;
static int hf_scsi_inq_control_vendor_specific = -1;
static cmdset_t *get_cmdset_data(itlq_nexus_t *itlq, itl_nexus_t *itl);
-static dissector_handle_t data_handle;
-
static void
dissect_naa_designator(proto_tree *tree, tvbuff_t *tvb, guint offset, guint len)
{
spc[opcode].func(tvb, pinfo, scsi_tree, offset+1,
TRUE, TRUE, 0, cdata);
} else {
- call_dissector(data_handle, tvb, pinfo, scsi_tree);
+ call_data_dissector(tvb, pinfo, scsi_tree);
}
pinfo->current_proto = old_proto;
* dissect the data.
*/
if ( !itlq->first_exchange_frame ) {
- call_dissector(data_handle, tvb, pinfo, scsi_tree);
+ call_data_dissector(tvb, pinfo, scsi_tree);
goto end_of_payload;
}
*/
if (!scsi_defragment) {
if (relative_offset) {
- call_dissector(data_handle, tvb, pinfo, scsi_tree);
+ call_data_dissector(tvb, pinfo, scsi_tree);
goto end_of_payload;
} else {
goto dissect_the_payload;
*/
if (tvb_captured_length_remaining(tvb, offset) != tvb_reported_length_remaining(tvb, offset)) {
if (relative_offset) {
- call_dissector(data_handle, tvb, pinfo, scsi_tree);
+ call_data_dissector(tvb, pinfo, scsi_tree);
goto end_of_payload;
} else {
goto dissect_the_payload;
spc[opcode].func(next_tvb, pinfo, scsi_tree, offset,
isreq, FALSE, payload_len, cdata);
} else { /* don't know this CDB */
- call_dissector(data_handle, next_tvb, pinfo, scsi_tree);
+ call_data_dissector(next_tvb, pinfo, scsi_tree);
}
}
register_cleanup_routine(scsi_defragment_cleanup);
register_srt_table(proto_scsi, NULL, 1, scsistat_packet, scsistat_init, scsistat_param);
-}
-void
-proto_reg_handoff_scsi(void)
-{
scsi_tap = register_tap("scsi");
- data_handle = find_dissector("data");
}
-
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
static expert_field ei_sctp_sack_chunk_gap_block_malformed = EI_INIT;
static expert_field ei_sctp_sack_chunk_number_tsns_gap_acked_100 = EI_INIT;
-static dissector_handle_t data_handle;
-
WS_DLL_PUBLIC_DEF const value_string chunk_type_values[] = {
{ SCTP_DATA_CHUNK_ID, "DATA" },
{ SCTP_INIT_CHUNK_ID, "INIT" },
}
}
/* Oh, well, we don't know this; dissect it as data. */
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
return TRUE;
}
{
dissector_handle_t sctp_handle;
- data_handle = find_dissector("data");
sctp_handle = find_dissector("sctp");
dissector_add_uint("wtap_encap", WTAP_ENCAP_SCTP, sctp_handle);
dissector_add_uint("ip.proto", IP_PROTO_SCTP, sctp_handle);
static gint ett_sdlc_control = -1;
static dissector_handle_t sna_handle;
-static dissector_handle_t data_handle;
static const xdlc_cf_items sdlc_cf_items = {
&hf_sdlc_n_r,
/* call the SNA dissector */
call_dissector(sna_handle, next_tvb, pinfo, tree);
} else
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
* Get handle for the SNA dissector.
*/
sna_handle = find_dissector_add_dependency("sna", proto_sdlc);
- data_handle = find_dissector("data");
sdlc_handle = create_dissector_handle(dissect_sdlc, proto_sdlc);
dissector_add_uint("wtap_encap", WTAP_ENCAP_SDLC, sdlc_handle);
static guint ses_pres_ctx_id = 0;
static gboolean ses_rtse_reassemble = FALSE;
-/* find the dissector for data */
-static dissector_handle_t data_handle;
-
static void
call_pres_dissector(tvbuff_t *tvb, int offset, guint16 param_len,
packet_info *pinfo, proto_tree *tree,
if (has_user_information && next_tvb) {
if (!pres_handle) {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
} else {
/* Pass the session pdu to the presentation dissector */
call_dissector_with_data(pres_handle, next_tvb, pinfo, tree, &session);
void
proto_reg_handoff_ses(void)
{
- /* find data dissector */
- data_handle = find_dissector("data");
-
/* define sub dissector */
pres_handle = find_dissector_add_dependency("pres", proto_ses);
static expert_field ei_sflow_invalid_address_type = EI_INIT;
static dissector_table_t header_subdissector_table;
-static dissector_handle_t data_handle;
void proto_reg_handoff_sflow_245(void);
if ((global_dissect_samp_headers == FALSE) ||
!dissector_try_uint(header_subdissector_table, header_proto, next_tvb, pinfo, sflow_245_header_tree))
{
- call_dissector(data_handle, next_tvb, pinfo, sflow_245_header_tree);
+ call_data_dissector(next_tvb, pinfo, sflow_245_header_tree);
}
}
if (!sflow_245_prefs_initialized) {
sflow_handle = create_dissector_handle(dissect_sflow_245, proto_sflow);
- data_handle = find_dissector("data");
sflow_245_prefs_initialized = TRUE;
} else {
dissector_delete_uint_range("udp.port", sflow_ports, sflow_handle);
void proto_reg_handoff_sita(void);
static dissector_table_t sita_dissector_table;
-static dissector_handle_t data_handle;
static gint ett_sita = -1;
static gint ett_sita_flags = -1;
static gint ett_sita_signals = -1;
and give them the details then */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "UNKNOWN");
col_add_fstr(pinfo->cinfo, COL_INFO, "IOP protocol number: %u", pinfo->pseudo_header->sita.sita_proto);
- call_dissector(data_handle, tvb, pinfo, tree); /* call the generic (hex display) decoder instead */
+ call_data_dissector(tvb, pinfo, tree); /* call the generic (hex display) decoder instead */
}
return tvb_captured_length(tvb);
}
uts_handle = find_dissector("uts");
ipars_handle = find_dissector("ipars");
sita_handle = find_dissector("sita");
- data_handle = find_dissector("data");
dissector_add_uint("sita.proto", SITA_PROTO_BOP_LAPB, lapb_handle);
dissector_add_uint("sita.proto", SITA_PROTO_BOP_FRL, frame_relay_handle);
static dissector_table_t sll_linux_dissector_table;
static dissector_table_t gre_dissector_table;
-static dissector_handle_t data_handle;
static void sll_prompt(packet_info *pinfo, gchar* result)
{
if(!dissector_try_uint(sll_linux_dissector_table, protocol,
next_tvb, pinfo, tree)) {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
} else {
switch (hatype) {
* Get handles for the IPX and LLC dissectors.
*/
gre_dissector_table = find_dissector_table("gre.proto");
- data_handle = find_dissector("data");
ethertype_handle = find_dissector_add_dependency("ethertype", proto_sll);
netlink_handle = find_dissector_add_dependency("netlink", proto_sll);
static gint ett_slow = -1;
-static dissector_handle_t dh_data;
-
/*
* Name: dissect_slow_protocols
*
next_tvb = tvb_new_subset_remaining(tvb, 1);
if (!dissector_try_uint_new(slow_protocols_dissector_table, subtype,
next_tvb, pinfo, tree, TRUE, NULL))
- call_dissector(dh_data, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
slow_protocols_handle = create_dissector_handle(dissect_slow_protocols, proto_slow);
dissector_add_uint("ethertype", ETHERTYPE_SLOW_PROTOCOLS, slow_protocols_handle);
-
- dh_data = find_dissector("data");
}
/*
#define SMB_DIRECT_RESPONSE_REQUESTED 0x0001
static heur_dissector_list_t smb_direct_heur_subdissector_list;
-static dissector_handle_t data_handle;
static gboolean smb_direct_reassemble = TRUE;
static reassembly_table smb_direct_reassembly_table;
pinfo->fragmented = FALSE;
if (!dissector_try_heuristic(smb_direct_heur_subdissector_list,
payload_tvb, pinfo, tree, &hdtbl_entry, NULL)) {
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
}
done:
pinfo->fragmented = save_fragmented;
void
proto_reg_handoff_smb_direct(void)
{
- data_handle = find_dissector("data");
heur_dissector_add("iwarp_ddp_rdmap",
dissect_smb_direct_iwarp_heur,
"SMB Direct over iWARP", "smb_direct_iwarp",
static dissector_handle_t mailslot_browse_handle;
static dissector_handle_t mailslot_lanman_handle;
static dissector_handle_t netlogon_handle;
-static dissector_handle_t data_handle;
#define MAILSLOT_UNKNOWN 0
#define MAILSLOT_BROWSE 1
* but indicate that we successfully dissected the mailslot
* stuff.
*/
- call_dissector(data_handle ,tvb, pinfo, parent_tree);
+ call_data_dissector(tvb, pinfo, parent_tree);
break;
}
return TRUE;
mailslot_browse_handle = find_dissector_add_dependency("mailslot_browse", proto_smb_msp);
mailslot_lanman_handle = find_dissector_add_dependency("mailslot_lanman", proto_smb_msp);
netlogon_handle = find_dissector_add_dependency("smb_netlogon", proto_smb_msp);
- data_handle = find_dissector("data");
}
/*
void proto_register_pipe_lanman(void);
void proto_register_smb_pipe(void);
-void proto_reg_handoff_smb_pipe(void);
static int proto_smb_pipe = -1;
static int hf_smb_pipe_function = -1;
static expert_field ei_smb_pipe_bogus_netwkstauserlogon = EI_INIT;
static expert_field ei_smb_pipe_bad_type = EI_INIT;
-static dissector_handle_t data_handle;
-
/*
* See
*
pinfo->desegment_len = 0;
if (!result)
- call_dissector(data_handle, d_tvb, pinfo, parent_tree);
+ call_data_dissector(d_tvb, pinfo, parent_tree);
pinfo->fragmented = save_fragmented;
return TRUE;
register_cleanup_routine(smb_dcerpc_reassembly_cleanup);
}
-void
-proto_reg_handoff_smb_pipe(void)
-{
- data_handle = find_dissector("data");
-}
-
-
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
static dissector_handle_t gssapi_handle = NULL;
static dissector_handle_t ntlmssp_handle = NULL;
static dissector_handle_t rsvd_handle = NULL;
-static dissector_handle_t data_handle = NULL;
static heur_dissector_list_t smb2_pipe_subdissector_list;
pinfo->desegment_len = 0;
if (!result) {
- call_dissector(data_handle, tvb, pinfo, top_tree);
+ call_data_dissector(tvb, pinfo, top_tree);
}
pinfo->fragmented = save_fragmented;
gssapi_handle = find_dissector_add_dependency("gssapi", proto_smb2);
ntlmssp_handle = find_dissector_add_dependency("ntlmssp", proto_smb2);
rsvd_handle = find_dissector_add_dependency("rsvd", proto_smb2);
- data_handle = find_dissector("data");
heur_dissector_add("netbios", dissect_smb2_heur, "SMB2 over Netbios", "smb2_netbios", proto_smb2, HEURISTIC_ENABLE);
heur_dissector_add("smb_direct", dissect_smb2_heur, "SMB2 over SMB Direct", "smb2_smb_direct", proto_smb2, HEURISTIC_ENABLE);
}
static gint ett_sna_control_05hpr_type = -1;
static gint ett_sna_control_0e = -1;
-static dissector_handle_t data_handle;
-
static int sna_address_type = -1;
/* Defragment fragmented SNA BIUs*/
proto_tree_add_item(tree, hf_sna_reserved, tvb, 12, 8, ENC_NA);
if (tvb_offset_exists(tvb, offset))
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, 4), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, 4), pinfo, tree);
if (bits & 0x40) {
col_set_str(pinfo->cinfo, COL_INFO, "HPR Idle Message");
{
proto_tree_add_item(tree, hf_sna_nlp_opti_0f_bits, tvb, 2, 2, ENC_BIG_ENDIAN);
if (tvb_offset_exists(tvb, 4))
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, 4), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, 4), pinfo, tree);
}
static void
proto_tree_add_item(tree, hf_sna_reserved, tvb, 2, 2, ENC_NA);
proto_tree_add_item(tree, hf_sna_nlp_opti_10_tcid, tvb, 4, 8, ENC_NA);
if (tvb_offset_exists(tvb, 12))
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, 12), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, 12), pinfo, tree);
}
static void
if ((type != 0x83) || (len <= 16)) {
/* Invalid */
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
return;
}
sub_tree = proto_tree_add_subtree(tree, tvb, offset, len,
if ((type != 0x85) || ( len < 4)) {
/* Invalid */
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
return;
}
sub_tree = proto_tree_add_subtree(tree, tvb, offset, len,
dissect_control(tvb, offset, sublen, sub_tree, 1, LT);
} else {
/* Invalid */
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
return;
}
/* No padding here */
tvb, 16, 4, ENC_BIG_ENDIAN);
if (tvb_offset_exists(tvb, 20))
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, 20), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, 20), pinfo, tree);
} else {
if (tvb_offset_exists(tvb, 12))
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, 12), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, 12), pinfo, tree);
}
}
/* Prevent loop for invalid crap in packet */
if (len == 0) {
- if (tree)
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset), pinfo, tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);
return;
}
len << 2, -1), pinfo, sub_tree);
break;
default:
- call_dissector(data_handle,
- tvb_new_subset(tvb, offset,
+ call_data_dissector(tvb_new_subset(tvb, offset,
len << 2, -1), pinfo, sub_tree);
}
offset += (len << 2);
indx ++;
if (tvb_offset_exists(tvb, indx))
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, indx),
+ call_data_dissector(tvb_new_subset_remaining(tvb, indx),
pinfo, parent_tree);
return;
}
if (tvb_get_guint8(tvb, indx+subindx+1) == 5)
dissect_control(tvb, indx + subindx, counter+2, nlp_tree, 1, LT);
else
- call_dissector(data_handle,
- tvb_new_subset(tvb, indx + subindx, counter+2,
+ call_data_dissector(tvb_new_subset(tvb, indx + subindx, counter+2,
-1), pinfo, nlp_tree);
subindx += (counter+2);
if (((thdr_8 & 0x20) == 0) && thdr_dlf) {
col_set_str(pinfo->cinfo, COL_INFO, "HPR Fragment");
if (tvb_offset_exists(tvb, indx)) {
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, indx), pinfo,
+ call_data_dissector(tvb_new_subset_remaining(tvb, indx), pinfo,
parent_tree);
}
return;
dissect_gds(tvb_new_subset_remaining(tvb, indx),
pinfo, tree, parent_tree);
} else
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, indx),
+ call_data_dissector(tvb_new_subset_remaining(tvb, indx),
pinfo, parent_tree);
}
}
break;
default:
/* external standards organizations */
- call_dissector(data_handle,
- tvb_new_subset(tvb, 6, len-6, -1),
+ call_data_dissector(tvb_new_subset(tvb, 6, len-6, -1),
pinfo, tree);
}
}
len = 6;
if (tvb_offset_exists(tvb, len))
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, len), pinfo, parent_tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, len), pinfo, parent_tree);
}
/* --------------------------------------------------------------------
th_header_len = dissect_fidf(tvb, th_tree);
break;
default:
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, 1), pinfo, parent_tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, 1), pinfo, parent_tree);
return;
}
return;
}
- call_dissector(data_handle,
- tvb_new_subset_remaining(rh_tvb, rh_offset),
+ call_data_dissector(tvb_new_subset_remaining(rh_tvb, rh_offset),
pinfo, parent_tree);
}
}
} while(cont);
if (tvb_offset_exists(tvb, offset))
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset), pinfo, parent_tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, parent_tree);
}
/* --------------------------------------------------------------------
dissector_add_uint("llc.xid_dsap", SAP_SNA3, sna_xid_handle);
/* RFC 2043 */
dissector_add_uint("ppp.protocol", PPP_SNA, sna_handle);
- data_handle = find_dissector("data");
-
}
/*
/* dissectors for the data portion of this protocol
*/
-static dissector_handle_t data_handle;
static dissector_handle_t ip_handle;
/* reassembly of N-PDU
call_dissector(ip_handle, next_tvb, pinfo, tree);
}
else {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
else {
/* Find IP and data handle for upper layer dissectors
*/
ip_handle = find_dissector_add_dependency("ip", proto_sndcp);
- data_handle = find_dissector("data");
}
/*
static int proto_can = -1;
-static dissector_handle_t data_handle;
-
#define LINUX_CAN_STD 0
#define LINUX_CAN_EXT 1
#define LINUX_CAN_RTR 2
have a unique identifier to determine subdissector */
if (!dissector_try_uint_new(subdissector_table, 0, next_tvb, pinfo, tree, FALSE, &can_id))
{
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
can_handle = create_dissector_handle(dissect_socketcan, proto_can);
dissector_add_uint("wtap_encap", WTAP_ENCAP_SOCKETCAN, can_handle);
dissector_add_uint("sll.ltype", LINUX_SLL_P_CAN, can_handle);
-
- data_handle = find_dissector("data");
}
/*
static expert_field ei_spdy_invalid_frame_type = EI_INIT;
static expert_field ei_spdy_reassembly_info = EI_INIT;
-static dissector_handle_t data_handle;
static dissector_handle_t media_handle;
static dissector_handle_t spdy_handle;
static dissector_table_t media_type_subdissector_table;
if (spdy_decompress_body) {
proto_item_append_text(e_ti, " [Error: Decompression failed]");
}
- call_dissector(data_handle, data_tvb, pinfo, e_tree);
+ call_data_dissector(data_tvb, pinfo, e_tree);
goto body_dissected;
}
call_dissector_with_data(media_handle, next_tvb, pinfo, spdy_tree, media_str);
} else {
/* Call the default data dissector */
- call_dissector(data_handle, next_tvb, pinfo, spdy_tree);
+ call_data_dissector(next_tvb, pinfo, spdy_tree);
}
body_dissected:
/* Use "0" to avoid overwriting HTTPS port and still offer support over SSL */
ssl_dissector_add(0, spdy_handle);
- data_handle = find_dissector("data");
media_handle = find_dissector_add_dependency("media", proto_spdy);
port_subdissector_table = find_dissector_table("http.port");
media_type_subdissector_table = find_dissector_table("media_type");
static gint ett_spp = -1;
static gint ett_spp_connctrl = -1;
-static dissector_handle_t data_handle;
-
static dissector_table_t spp_socket_dissector_table;
/*
next_tvb, pinfo, tree))
return tvb_captured_length(tvb);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
spp_handle = create_dissector_handle(dissect_spp, proto_spp);
dissector_add_uint("idp.packet_type", IDP_PACKET_TYPE_SPP, spp_handle);
-
- data_handle = find_dissector("data");
}
/*
static expert_field ei_stt_mss = EI_INIT;
static dissector_handle_t eth_handle;
-static dissector_handle_t data_handle;
/* From Table G-2 of IEEE standard 802.1Q-2005 */
static const value_string pri_vals[] = {
if (!is_seg) {
call_dissector(eth_handle, next_tvb, pinfo, tree);
} else {
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
pinfo->fragmented = frag_save;
* captures attached to bug 10282.
*/
eth_handle = find_dissector_add_dependency("eth_withoutfcs", proto_stt);
- data_handle = find_dissector("data");
heur_dissector_add("ip", dissect_stt_heur, "Stateless Transport Tunneling over IP", "stt_ip", proto_stt, HEURISTIC_ENABLE);
}
static gchar *sua_source_gt;
static gchar *sua_destination_gt;
-static dissector_handle_t data_handle;
static dissector_handle_t sua_info_str_handle;
static dissector_table_t sua_parameter_table;
static dissector_table_t sccp_ssn_dissector_table;
return;
}
/* No sub-dissection occurred, treat it as raw data */
- call_dissector(data_handle, data_tvb, pinfo, tree);
+ call_data_dissector(data_tvb, pinfo, tree);
}
}
}
dissector_add_uint("sctp.ppi", SUA_PAYLOAD_PROTOCOL_ID, sua_handle);
dissector_add_uint("sctp.port", SCTP_PORT_SUA, sua_handle);
- data_handle = find_dissector("data");
sccp_ssn_dissector_table = find_dissector_table("sccp.ssn");
}
static dissector_table_t tali_dissector_table;
-static dissector_handle_t data_handle;
-
/* Desegment TALI messages */
static gboolean tali_desegment = TRUE;
if (length > 0) {
payload_tvb = tvb_new_subset_remaining(tvb, TALI_HEADER_LENGTH);
if (payload_tvb != NULL && !dissector_try_string(tali_dissector_table, opcode, payload_tvb, pinfo, tree, NULL)) {
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
}
}
proto_reg_handoff_tali(void)
{
heur_dissector_add("tcp", dissect_tali_heur, "Tali over TCP", "tali_tcp", hfi_tali->id, HEURISTIC_ENABLE);
-
- data_handle = find_dissector("data");
}
/*
static gint ett_tdmoe_flags = -1;
static dissector_handle_t lapd_handle;
-static dissector_handle_t data_handle;
static gint pref_tdmoe_d_channel = 24;
if (chan == pref_tdmoe_d_channel) {
call_dissector(lapd_handle, next_client, pinfo, tree);
} else {
- call_dissector(data_handle, next_client, pinfo, tree);
+ call_data_dissector(next_client, pinfo, tree);
}
}
return 1;
dissector_add_uint("ethertype", ETHERTYPE_TDMOE, tdmoe_handle);
lapd_handle = find_dissector_add_dependency("lapd-bitstream", proto_tdmoe);
- data_handle = find_dissector("data");
}
/*
static int hf_tdmop_Compression_mask = -1;
static dissector_handle_t lapd_handle = NULL;
-static dissector_handle_t data_handle = NULL;
static gint pref_tdmop_d_channel = 16;
static guint32 pref_tdmop_mask = 0xFFFFFFFFUL;
}
} else
{
- call_dissector(data_handle, cdata, pinfo, subtree);
+ call_data_dissector(cdata, pinfo, subtree);
}
offset += 4;
}
dissector_add_uint("ethertype", pref_tdmop_ethertype, tdmop_handle);
}
lapd_handle = find_dissector_add_dependency("lapd-bitstream", proto_tdmop);
- data_handle = find_dissector("data");
current_tdmop_ethertype = pref_tdmop_ethertype;
current_tdmop_udpport = pref_tdmop_udpport;
init = TRUE;
static dissector_handle_t tds_tcp_handle;
static dissector_handle_t ntlmssp_handle;
static dissector_handle_t gssapi_handle;
-static dissector_handle_t data_handle;
typedef struct {
gint tds7_version;
}
} else {
next_tvb = tvb_new_subset_remaining (tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tds_tree);
+ call_data_dissector(next_tvb, pinfo, tds_tree);
}
pinfo->fragmented = save_fragmented;
}
ntlmssp_handle = find_dissector_add_dependency("ntlmssp", proto_tds);
gssapi_handle = find_dissector_add_dependency("gssapi", proto_tds);
- data_handle = find_dissector("data");
}
/*
/* Wireshark ID of the tetra protocol */
static int proto_tetra = -1;
-/* These are the handles of our subdissectors */
-static dissector_handle_t data_handle = NULL;
-
static dissector_handle_t tetra_handle;
static int global_tetra_port = 7074;
static int hf_tetra_simplex_duplex_selection_06 = -1; /* T_simplex_duplex_selection_05 */
/*--- End of included file: packet-tetra-hf.c ---*/
-#line 82 "./asn1/tetra/packet-tetra-template.c"
+#line 79 "./asn1/tetra/packet-tetra-template.c"
/* Initialize the subtree pointers */
/* These are the ids of the subtrees that we may be creating */
static gint ett_tetra_Modify_type = -1;
/*--- End of included file: packet-tetra-ett.c ---*/
-#line 92 "./asn1/tetra/packet-tetra-template.c"
+#line 89 "./asn1/tetra/packet-tetra-template.c"
static expert_field ei_tetra_channels_incorrect = EI_INIT;
/*--- End of included file: packet-tetra-fn.c ---*/
-#line 96 "./asn1/tetra/packet-tetra-template.c"
+#line 93 "./asn1/tetra/packet-tetra-template.c"
static const value_string channeltypenames[] = {
{ 0, "Reserved" },
static gboolean initialized=FALSE;
if (!initialized) {
- data_handle = find_dissector("data");
tetra_handle = create_dissector_handle(dissect_tetra, proto_tetra);
dissector_add_uint("udp.port", global_tetra_port, tetra_handle);
}
"T_simplex_duplex_selection_05", HFILL }},
/*--- End of included file: packet-tetra-hfarr.c ---*/
-#line 626 "./asn1/tetra/packet-tetra-template.c"
+#line 622 "./asn1/tetra/packet-tetra-template.c"
};
/* List of subtrees */
&ett_tetra_Modify_type,
/*--- End of included file: packet-tetra-ettarr.c ---*/
-#line 636 "./asn1/tetra/packet-tetra-template.c"
+#line 632 "./asn1/tetra/packet-tetra-template.c"
};
static ei_register_info ei[] = {
static expert_field ei_tftp_blocksize_range = EI_INIT;
static dissector_handle_t tftp_handle;
-static dissector_handle_t data_handle;
#define UDP_PORT_TFTP_RANGE "69"
/* Show data in tree */
if (bytes > 0) {
data_tvb = tvb_new_subset(tvb, offset, -1, bytes);
- call_dissector(data_handle, data_tvb, pinfo, tree);
+ call_data_dissector(data_tvb, pinfo, tree);
}
/* If Export Object tap is listening, need to accumulate blocks info list
if (!tftp_initialized) {
tftp_handle = find_dissector("tftp");
- data_handle = find_dissector("data");
heur_dissector_add("stun", dissect_embeddedtftp_heur, "TFTP over TURN", "tftp_stun", proto_tftp, HEURISTIC_ENABLE);
tftp_initialized = TRUE;
} else {
static int proto_tipc = -1;
/* dissector handles */
-static dissector_handle_t data_handle;
static dissector_handle_t ip_handle;
static int hf_tipc_msg_fragments = -1;
dissect_tipc(new_tvb, pinfo, top_tree, NULL);
} else { /* make a new subset */
data_tvb = tvb_new_subset(tipc_tvb, offset, len, reported_len);
- call_dissector(data_handle, data_tvb, pinfo, top_tree);
+ call_data_dissector(data_tvb, pinfo, top_tree);
}
pinfo->fragmented = save_fragmented;
} else {
/* don't reassemble is set in the "preferences" */
data_tvb = tvb_new_subset(tipc_tvb, offset, len, reported_len);
- call_dissector(data_handle, data_tvb, pinfo, top_tree);
+ call_data_dissector(data_tvb, pinfo, top_tree);
}
break;
/* dissection of TIPC data is not set in preferences or no subdissector found */
- call_dissector(data_handle, data_tvb, pinfo, top_tree);
+ call_data_dissector(data_tvb, pinfo, top_tree);
}
if (!inited) {
tipc_tcp_handle = create_dissector_handle(dissect_tipc_tcp, proto_tipc);
ip_handle = find_dissector("ip");
- data_handle = find_dissector("data");
dissector_add_uint("ethertype", ETHERTYPE_TIPC, tipc_handle);
static gint ett_tns_conn_flag = -1;
static gint ett_sql = -1;
-static dissector_handle_t data_handle;
-
#define TCP_PORT_TNS 1521
static const value_string tns_type_vals[] = {
col_append_str(pinfo->cinfo, COL_INFO, ", Data");
}
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset), pinfo, data_tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, data_tree);
return;
}
dissect_tns_data(tvb,offset,pinfo,tree,tns_tree);
break;
default:
- call_dissector(data_handle,
- tvb_new_subset_remaining(tvb, offset), pinfo,
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo,
tns_tree);
break;
}
tns_handle = create_dissector_handle(dissect_tns, proto_tns);
dissector_add_uint("tcp.port", TCP_PORT_TNS, tns_handle);
- data_handle = find_dissector("data");
}
/*
static dissector_handle_t trmac_handle;
static dissector_handle_t llc_handle;
-static dissector_handle_t data_handle;
static const char* tr_conv_get_filter_type(conv_item_t* conv, conv_filter_type_e filter)
{
break;
default:
/* non-MAC, non-LLC, i.e., "Reserved" */
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
}
*/
trmac_handle = find_dissector_add_dependency("trmac", proto_tr);
llc_handle = find_dissector_add_dependency("llc", proto_tr);
- data_handle = find_dissector("data");
tr_handle = find_dissector("tr");
dissector_add_uint("wtap_encap", WTAP_ENCAP_TOKEN_RING, tr_handle);
/* The ethernet dissector we hand off to */
static dissector_handle_t eth_handle;
-static dissector_handle_t data_handle;
-
static const value_string turbocell_type_values[] = {
{ TURBOCELL_TYPE_BEACON_NON_POLLING, "Beacon (Non-Polling Base Station)" },
{ TURBOCELL_TYPE_BEACON_NORMAL, "Beacon (Normal Base Station)" },
/*Couldn't make sense of the apparently random data in the end*/
next_tvb = tvb_new_subset_remaining(tvb, 0x34 + 8*i);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
} else {
if (remaining_length > 2) {
next_tvb = tvb_new_subset_remaining(next_tvb, msdu_offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
}
void proto_reg_handoff_turbocell(void)
{
eth_handle = find_dissector_add_dependency("eth_withoutfcs", proto_turbocell);
- data_handle = find_dissector("data");
}
/*
/* heuristic subdissectors */
static heur_dissector_list_t heur_subdissector_list;
-/* data dissector handle */
-static dissector_handle_t data_handle;
-
/* Initialize the protocol and registered fields */
static int proto_turnchannel = -1;
if (!dissector_try_heuristic(heur_subdissector_list,
next_tvb, pinfo, tree, &hdtbl_entry, NULL)) {
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
/* TURN negotiation is handled through STUN2 dissector (packet-stun.c),
so only it should be able to determine if a packet is a TURN packet */
heur_dissector_add("stun", dissect_turnchannel_heur, "TURN Channel over STUN", "turnchannel_stun", proto_turnchannel, HEURISTIC_ENABLE);
-
- data_handle = find_dissector("data");
}
/*
static dissector_handle_t ieee_802_11_handle;
static dissector_handle_t ieee_802_11_prism_handle;
static dissector_handle_t ieee_802_11_avs_handle;
-static dissector_handle_t data_handle;
/* ************************************************************************* */
/* WLAN radio header fields */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "UNKNOWN");
col_add_fstr(pinfo->cinfo, COL_INFO, "TZSP_ENCAP = %u",
encapsulation);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
}
ieee_802_11_handle = find_dissector_add_dependency("wlan", proto_tzsp);
ieee_802_11_prism_handle = find_dissector_add_dependency("prism", proto_tzsp);
ieee_802_11_avs_handle = find_dissector_add_dependency("wlancap", proto_tzsp);
- data_handle = find_dissector("data");
/* Register this protocol as an encapsulation type. */
dissector_add_uint("wtap_encap", WTAP_ENCAP_TZSP, tzsp_handle);
static dissector_handle_t noe_handle;
static dissector_handle_t ua3g_handle;
-static dissector_handle_t data_handle;
static void uadecode(e_ua_direction direction,
proto_tree *tree,
/* add text to the frame "INFO" column */
col_append_fstr(pinfo->cinfo, COL_INFO, " - UA3G Message ERR: Opcode (0x%02x) Unknown", tvb_get_guint8(tvb, (offset + 2)));
- call_dissector(data_handle,
- tvb_new_subset_length(tvb, offset, length),
+ call_data_dissector(tvb_new_subset_length(tvb, offset, length),
pinfo,
tree);
break;
#endif
noe_handle = find_dissector_add_dependency("noe", proto_ua_msg);
ua3g_handle = find_dissector_add_dependency("ua3g", proto_ua_msg);
- data_handle = find_dissector("data");
}
static gint ett_udld_flags = -1;
static gint ett_udld_tlv = -1;
-static dissector_handle_t data_handle;
-
#define TYPE_DEVICE_ID 0x0001
#define TYPE_PORT_ID 0x0002
#define TYPE_ECHO 0x0003
}
}
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo, udld_tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, udld_tree);
return tvb_captured_length(tvb);
}
{
dissector_handle_t udld_handle;
- data_handle = find_dissector("data");
udld_handle = create_dissector_handle(dissect_udld, proto_udld);
dissector_add_uint("llc.cisco_pid", 0x0111, udld_handle);
dissector_add_uint("chdlc.protocol", 0x0111, udld_handle);
static dissector_table_t udp_dissector_table;
static heur_dissector_list_t heur_subdissector_list;
-static dissector_handle_t data_handle;
static guint32 udp_stream_count;
/* Determine if there is a sub-dissector and call it. This has been */
}
}
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
int
register_capture_dissector("ipv6.nxt", IP_PROTO_UDP, capture_udp, hfi_udp->id);
register_capture_dissector("ipv6.nxt", IP_PROTO_UDPLITE, capture_udp, hfi_udplite->id);
- data_handle = find_dissector("data");
udp_tap = register_tap("udp");
udp_follow_tap = register_tap("udp_follow");
}
static expert_field ei_udt_nak_seqno = EI_INIT;
static dissector_handle_t udt_handle;
-static dissector_handle_t data_handle;
static int
dissect_udt(tvbuff_t *tvb, packet_info* pinfo, proto_tree *parent_tree,
}
next_tvb = tvb_new_subset_remaining(tvb, 16);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_reported_length(tvb);
void proto_reg_handoff_udt(void)
{
- data_handle = find_dissector("data");
udt_handle = create_dissector_handle(dissect_udt, proto_udt);
heur_dissector_add("udp", dissect_udt_heur, "UDT over UDP", "udt_udp", proto_udt, HEURISTIC_ENABLE);
static dissector_handle_t uma_tcp_handle;
static dissector_handle_t uma_udp_handle;
-static dissector_handle_t data_handle;
static dissector_table_t bssap_pdu_type_table;
static dissector_handle_t rtcp_handle;
static dissector_handle_t llc_handle;
proto_tree_add_item(urr_ie_tree, hf_uma_urr_L3_protocol_discriminator, tvb, ie_offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(urr_ie_tree, hf_uma_urr_L3_Message, tvb, ie_offset, ie_len, ENC_NA);
l3_tvb = tvb_new_subset_length(tvb, ie_offset, ie_len );
- if (!dissector_try_uint(bssap_pdu_type_table,BSSAP_PDU_TYPE_DTAP, l3_tvb, pinfo, urr_ie_tree))
- call_dissector(data_handle, l3_tvb, pinfo, urr_ie_tree);
+ if (!dissector_try_uint(bssap_pdu_type_table,BSSAP_PDU_TYPE_DTAP, l3_tvb, pinfo, urr_ie_tree))
+ call_data_dissector(l3_tvb, pinfo, urr_ie_tree);
break;
case 27:
/* 11.2.27 Channel Mode
proto_tree_add_item(urr_ie_tree, hf_uma_urr_L3_Message, tvb, ie_offset, ie_len, ENC_NA);
/* XXX the dissector to call should depend on the RAT type ??? */
l3_tvb = tvb_new_subset_length(tvb, ie_offset, ie_len );
- if (!dissector_try_uint(bssap_pdu_type_table,BSSAP_PDU_TYPE_DTAP, l3_tvb, pinfo, urr_ie_tree))
- call_dissector(data_handle, l3_tvb, pinfo, urr_ie_tree);
+ if (!dissector_try_uint(bssap_pdu_type_table,BSSAP_PDU_TYPE_DTAP, l3_tvb, pinfo, urr_ie_tree))
+ call_data_dissector(l3_tvb, pinfo, urr_ie_tree);
break;
case 33:
/* 11.2.33 UL Quality Indication */
*/
proto_tree_add_item(urr_ie_tree, hf_uma_urr_LLC_PDU, tvb, ie_offset, ie_len, ENC_NA);
llc_tvb = tvb_new_subset_length(tvb, ie_offset, ie_len );
- if (llc_handle) {
+ if (llc_handle) {
col_append_str(pinfo->cinfo, COL_PROTOCOL, "/");
col_set_fence(pinfo->cinfo, COL_PROTOCOL);
call_dissector(llc_handle, llc_tvb, pinfo, urr_ie_tree);
- }else{
- if (data_handle)
- call_dissector(data_handle, llc_tvb, pinfo, urr_ie_tree);
- }
+ }else{
+ call_data_dissector(llc_tvb, pinfo, urr_ie_tree);
+ }
break;
case 58: /* 11.2.58 Location Black List indicator */
proto_tree_add_item(urr_ie_tree, hf_uma_urr_LBLI, tvb, ie_offset, 1, ENC_BIG_ENDIAN);
uma_tcp_handle = find_dissector("umatcp");
uma_udp_handle = find_dissector("umaudp");
dissector_add_for_decode_as("udp.port", uma_udp_handle);
- data_handle = find_dissector("data");
rtcp_handle = find_dissector_add_dependency("rtcp", proto_uma);
llc_handle = find_dissector_add_dependency("llcgprs", proto_uma);
bssap_pdu_type_table = find_dissector_table("bssap.pdu_type");
static int usb_tap = -1;
static gboolean try_heuristics = TRUE;
-static dissector_handle_t data_handle;
-
static dissector_table_t usb_bulk_dissector_table;
static dissector_table_t usb_control_dissector_table;
static dissector_table_t usb_interrupt_dissector_table;
* XXX - is there something we can still do here?
*/
if (tvb_reported_length(next_tvb) > 0)
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return tvb_captured_length(next_tvb);
}
dissector_handle_t win32_usb_handle;
dissector_handle_t freebsd_usb_handle;
- data_handle = find_dissector("data");
-
linux_usb_handle = create_dissector_handle(dissect_linux_usb, proto_usb);
linux_usb_mmapped_handle = create_dissector_handle(dissect_linux_usb_mmapped,
proto_usb);
static gint ett_usbip_dev = -1;
static gint ett_usbip_intf = -1;
-/* dissectors for the data portion of this protocol
- */
-static dissector_handle_t data_handle;
-
enum usb_device_speed {
USB_SPEED_UNKNOWN = 0, /* enumerating */
USB_SPEED_LOW, /* usb 1.0 */
usbip_handle = create_dissector_handle(dissect_usbip, proto_usbip);
dissector_add_for_decode_as("tcp.port", usbip_handle);
- data_handle = find_dissector("data");
}
/*
static user_encap_t* encaps = NULL;
static guint num_encaps = 0;
static uat_t* encaps_uat;
-static dissector_handle_t data_handle;
static gint exported_pdu_tap = -1;
proto_item_set_text(item,"%s",msg);
expert_add_info_format(pinfo, item, &ei_user_encap_not_handled, "%s", msg);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
if (encap->payload_proto == NULL) {
proto_item_set_text(item,"%s",msg);
expert_add_info_format(pinfo, item, &ei_user_encap_not_handled, "%s", msg);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
guint i;
user_encap_handle = find_dissector("user_dlt");
- data_handle = find_dissector("data");
user2_encap.encap = WTAP_ENCAP_USER2;
user2_encap.payload_proto_name = g_strdup("pktap");
#include <epan/xdlc.h>
void proto_register_v120(void);
-void proto_reg_handoff_v120(void);
static int proto_v120 = -1;
static int hf_v120_address = -1;
static gint ett_v120_control = -1;
static gint ett_v120_header = -1;
-static dissector_handle_t data_handle;
-
static const true_false_string tfs_response_command = { "Response", "Command" };
static const true_false_string tfs_segmentation_no_segmentation = { "Segmentation", "No segmentation" };
v120len += dissect_v120_header(tvb, v120len, v120_tree);
proto_item_set_len(ti, v120len);
next_tvb = tvb_new_subset_remaining(tvb, v120len);
- call_dissector(data_handle,next_tvb, pinfo, v120_tree);
+ call_data_dissector(next_tvb, pinfo, v120_tree);
return tvb_captured_length(tvb);
}
register_dissector("v120", dissect_v120, proto_v120);
}
-void
-proto_reg_handoff_v120(void)
-{
- data_handle = find_dissector("data");
-}
-
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
}
static dissector_handle_t vines_ip_handle;
-static dissector_handle_t data_handle;
/* Control flags */
#define VINES_FRP_FIRST_FRAGMENT 0x01
next_tvb = tvb_new_subset_remaining(tvb, 1);
if (!dissector_try_uint(vines_llc_dissector_table, ptype,
next_tvb, pinfo, tree))
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
next_tvb = tvb_new_subset_remaining(tvb, offset);
if (!dissector_try_uint(vines_ip_dissector_table, vip_proto,
next_tvb, pinfo, tree))
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
dissector_add_uint("arcnet.protocol_id", ARCNET_PROTO_BANYAN,
vines_ip_handle);
dissector_add_uint("vines_llc.ptype", VINES_LLC_IP, vines_ip_handle);
- data_handle = find_dissector("data");
}
static int
if (viph.vipc_pkttype != PKTTYPE_DATA ||
!dissector_try_heuristic(vines_ipc_heur_subdissector_list,
next_tvb, pinfo, tree, &hdtbl_entry, NULL))
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
if (viph.vspp_pkttype != PKTTYPE_DATA ||
!dissector_try_heuristic(vines_spp_heur_subdissector_list,
next_tvb, pinfo, tree, &hdtbl_entry, NULL))
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
static gint ett_wai_fragment = -1;
static gint ett_wai_fragments = -1;
-static dissector_handle_t data_handle;
-
static const value_string wai_type_names [] = {
{ 1, "WAI protocol package"},
{ 0, NULL }
next_tvb = tvb_new_subset_remaining(tvb, WAI_DATA_OFFSET);
- /* Replace INFO column if message is fragmented and call data_handle */
+ /* Replace INFO column if message is fragmented and call data dissector */
if (flags) {
col_add_fstr(pinfo->cinfo, COL_INFO,
"Fragment (%d) of message, data not dissected", fragment_num);
"Reassembled WAI", frag_msg, &wai_frag_items,
NULL, wai_tree);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
} else {
/* If this is the last fragment of fragmented message, then reassamble and dissect
otherwise only dissect */
void
proto_reg_handoff_wai(void)
{
- data_handle = find_dissector("data");
dissector_add_uint("ethertype", ETHERTYPE_WAI, wai_handle);
}
void proto_register_websocket(void);
void proto_reg_handoff_websocket(void);
-static dissector_handle_t data_handle;
static dissector_handle_t text_lines_handle;
static dissector_handle_t json_handle;
static dissector_handle_t sip_handle;
break;
case WS_BINARY: /* Binary */
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
break;
default: /* Unknown */
void
proto_reg_handoff_websocket(void)
{
- data_handle = find_dissector("data");
text_lines_handle = find_dissector_add_dependency("data-text-lines", proto_websocket);
json_handle = find_dissector_add_dependency("json", proto_websocket);
sip_handle = find_dissector_add_dependency("sip", proto_websocket);
};
-static dissector_handle_t data_handle;
-
/* Initialize the protocol and registered fields */
static int proto_wsmp = -1;
static int hf_wsmp_version = -1;
*/
if (psid == 0xbff0)
{
- call_dissector(data_handle, wsmdata_tvb, pinfo, wsmdata_tree);
+ call_data_dissector(wsmdata_tvb, pinfo, wsmdata_tree);
}
return tvb_captured_length(tvb);
}
wsmp_handle = create_dissector_handle(dissect_wsmp, proto_wsmp);
dissector_add_uint("ethertype", ETHERTYPE_WSMP, wsmp_handle);
- data_handle = find_dissector("data");
- return;
}
/*
static dissector_handle_t clnp_handle;
static dissector_handle_t ositp_handle;
static dissector_handle_t qllc_handle;
-static dissector_handle_t data_handle;
/* Preferences */
static gboolean payload_is_qllc_sna = FALSE;
}
/* All else failed; dissect it as raw data */
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
/*
clnp_handle = find_dissector_add_dependency("clnp", proto_x25);
ositp_handle = find_dissector_add_dependency("ositp", proto_x25);
qllc_handle = find_dissector_add_dependency("qllc", proto_x25);
- data_handle = find_dissector("data");
x25_handle = find_dissector("x.25");
dissector_add_uint("llc.dsap", SAP_X25, x25_handle);
void proto_register_xip_serval(void);
void proto_reg_handoff_xip_serval(void);
-static dissector_handle_t data_handle;
static dissector_handle_t tcp_handle;
static dissector_handle_t udp_handle;
switch (protocol) {
case XIP_SERVAL_PROTO_DATA:
next_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
break;
case IP_PROTO_TCP: {
/* Get the Data Offset field of the TCP header, which is
void
proto_reg_handoff_xip_serval(void)
{
- data_handle = find_dissector("data");
tcp_handle = find_dissector_add_dependency("tcp", proto_xip_serval);
udp_handle = find_dissector_add_dependency("udp", proto_xip_serval);
}
void proto_reg_handoff_xip(void);
/* Next dissector handles. */
-static dissector_handle_t data_handle;
static dissector_handle_t xip_serval_handle;
static gint proto_xip = -1;
switch (next_header) {
case XIA_NEXT_HEADER_DATA:
next_tvb = tvb_new_subset_remaining(tvb, offset);
- return call_dissector(data_handle, next_tvb, pinfo, tree);
+ return call_data_dissector(next_tvb, pinfo, tree);
default:
expert_add_info_format(pinfo, next_ti, &ei_xip_next_header,
"Unrecognized next header type: 0x%02x", next_header);
dissector_add_uint("ethertype", ETHERTYPE_XIP, xip_handle);
xip_serval_handle = find_dissector_add_dependency("xipserval", proto_xip);
- data_handle = find_dissector("data");
}
/*
static void proto_init_zbee_aps(void);
static void proto_cleanup_zbee_aps(void);
-void proto_reg_handoff_zbee_aps(void);
void proto_register_zbee_aps(void);
/********************
static dissector_handle_t zbee_aps_handle;
static dissector_handle_t zbee_apf_handle;
-/* Subdissector Handles. */
-static dissector_handle_t data_handle;
-
/* Dissector List. */
static dissector_table_t zbee_aps_dissector_table;
else {
/* The reassembly handler could not defragment the message. */
col_append_fstr(pinfo->cinfo, COL_INFO, " (fragment %d)", block_num);
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
}
}
if (payload_tvb) {
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
proto_item_set_len(cmd_root, offset);
/* Dump the leftover to the data dissector. */
- call_dissector(data_handle, leftover_tvb, pinfo, root);
+ call_data_dissector(leftover_tvb, pinfo, root);
}
} /* dissect_zbee_aps_cmd */
if (offset < tvb_captured_length(tvb)) {
/* There are bytes remaining! */
app_tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, app_tvb, pinfo, tree);
+ call_data_dissector(app_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
zbee_apf_handle = register_dissector("zbee_apf", dissect_zbee_apf, proto_zbee_apf);
} /* proto_register_zbee_aps */
-/**
- *Registers the zigbee APS dissector with Wireshark.
- *
-*/
-void proto_reg_handoff_zbee_aps(void)
-{
- /* Find the other dissectors we need. */
- data_handle = find_dissector("data");
-} /* proto_reg_handoff_zbee_aps */
-
/**
*Initializes the APS dissectors prior to beginning protocol
*
static gint ett_zbee_nwk_fcf_ext = -1;
/* Common. */
-static dissector_handle_t data_handle;
static GSList *zbee_gp_keyring = NULL;
static guint num_uat_key_records = 0;
proto_item_set_len(cmd_root, offset);
/* Dump the tail. */
- call_dissector(data_handle, leftover_tvb, pinfo, root);
+ call_data_dissector(leftover_tvb, pinfo, root);
}
return offset;
} /* dissect_zbee_nwk_gp_cmd */
} else {
g_free(dec_buffer);
payload_tvb = tvb_new_subset(tvb, offset - packet.payload_len - packet.mic_size, packet.payload_len, -1);
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
}
}
return tvb_captured_length(tvb);
void
proto_reg_handoff_zbee_nwk_gp(void)
{
- /* Find the other dissectors we need. */
- data_handle = find_dissector("data");
/* Register our dissector with IEEE 802.15.4. */
dissector_add_for_decode_as(IEEE802154_PROTOABBREV_WPAN_PANID, find_dissector(ZBEE_PROTOABBREV_NWK_GP));
heur_dissector_add(IEEE802154_PROTOABBREV_WPAN, dissect_zbee_nwk_heur_gp, "ZigBee Green Power over IEEE 802.15.4", "zbee_nwk_gp_wlan", proto_zbee_nwk_gp, HEURISTIC_ENABLE);
static expert_field ei_zbee_nwk_missing_payload = EI_INIT;
-static dissector_handle_t data_handle;
static dissector_handle_t aps_handle;
static dissector_handle_t zbee_gp_handle;
}
else {
/* Invalid type. */
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
proto_item_set_len(cmd_root, offset);
/* Dump the leftover to the data dissector. */
- call_dissector(data_handle, leftover_tvb, pinfo, root);
+ call_data_dissector(leftover_tvb, pinfo, root);
}
} /* dissect_zbee_nwk_cmd */
proto_item_set_len(beacon_root, offset);
/* Dump the leftover to the data dissector. */
- call_dissector(data_handle, leftover_tvb, pinfo, root);
+ call_data_dissector(leftover_tvb, pinfo, root);
}
return tvb_captured_length(tvb);
proto_item_set_len(beacon_root, offset);
/* Dump the leftover to the data dissector. */
- call_dissector(data_handle, leftover_tvb, pinfo, root);
+ call_data_dissector(leftover_tvb, pinfo, root);
}
return tvb_captured_length(tvb);
} /* dissect_zbip_beacon */
void proto_reg_handoff_zbee_nwk(void)
{
/* Find the other dissectors we need. */
- data_handle = find_dissector("data");
aps_handle = find_dissector_add_dependency(ZBEE_PROTOABBREV_APS, proto_zbee_nwk);
zbee_gp_handle = find_dissector_add_dependency(ZBEE_PROTOABBREV_NWK_GP, proto_zbee_nwk);
heur_dissector_add(IEEE802154_PROTOABBREV_WPAN_BEACON, dissect_zbee_beacon_heur, "ZigBee Beacon", "zbee_wlan_beacon", proto_zbee_beacon, HEURISTIC_ENABLE);
heur_dissector_add(IEEE802154_PROTOABBREV_WPAN_BEACON, dissect_zbip_beacon_heur, "ZigBee IP Beacon", "zbip_wlan_beacon", proto_zbip_beacon, HEURISTIC_ENABLE);
heur_dissector_add(IEEE802154_PROTOABBREV_WPAN, dissect_zbee_nwk_heur, "ZigBee Network Layer over IEEE 802.15.4", "zbee_nwk_wlan", proto_zbee_nwk, HEURISTIC_ENABLE);
-
- /* Handoff the ZigBee security dissector code. */
- zbee_security_handoff();
} /* proto_reg_handoff_zbee */
static void free_keyring_key(gpointer key)
static expert_field ei_zbee_sec_encrypted_payload_sliced = EI_INIT;
static expert_field ei_zbee_sec_extended_source_unknown = EI_INIT;
-static dissector_handle_t data_handle;
-
static const value_string zbee_sec_key_names[] = {
{ ZBEE_SEC_KEY_LINK, "Link Key" },
{ ZBEE_SEC_KEY_NWK, "Network Key" },
return TRUE;
} /* zbee_security_parse_key */
-/*FUNCTION:------------------------------------------------------
- * NAME
- * zbee_security_handoff
- * DESCRIPTION
- * Hands off the security dissector.
- * PARAMETERS
- * none
- * RETURNS
- * tvbuff_t *
- *---------------------------------------------------------------
- */
-void
-zbee_security_handoff(void)
-{
- /* Lookup the data dissector. */
- data_handle = find_dissector("data");
-} /* zbee_security_handoff */
-
/*FUNCTION:------------------------------------------------------
* NAME
* dissect_zbee_secure
/* Create a buffer for the undecrypted payload. */
payload_tvb = tvb_new_subset_length(tvb, offset, payload_len);
/* Dump the payload to the data dissector. */
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
/* Couldn't decrypt, so return NULL. */
return NULL;
}
/* Create a buffer for the undecrypted payload. */
payload_tvb = tvb_new_subset_length(tvb, offset, payload_len);
/* Dump the payload to the data dissector. */
- call_dissector(data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
/* Couldn't decrypt, so return NULL. */
return NULL;
} /* dissect_zbee_secure */
/* Init routine for the Security dissectors. */
extern void zbee_security_register (module_t *module, int proto);
-extern void zbee_security_handoff (void);
/* Security Dissector Routine. */
extern tvbuff_t *dissect_zbee_secure(tvbuff_t *, packet_info *, proto_tree *, guint);
static gint ett_zbee_zcl_fcf = -1;
static gint ett_zbee_zcl_attr[ZBEE_ZCL_NUM_ATTR_ETT];
static gint ett_zbee_zcl_array_elements[ZBEE_ZCL_NUM_ARRAY_ELEM_ETT];
-/* Dissector Handles. */
-static dissector_handle_t data_handle;
/* Dissector List. */
static dissector_table_t zbee_zcl_dissector_table;
if (length > 0) {
remainder = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, remainder, pinfo, root);
+ call_data_dissector(remainder, pinfo, root);
}
return;
{
dissector_handle_t zbee_zcl_handle;
- /* Find the dissectors we need. */
- data_handle = find_dissector("data");
-
/* Register our dissector for the appropriate profiles. */
zbee_zcl_handle = find_dissector(ZBEE_PROTOABBREV_ZCL);
dissector_add_uint("zbee.profile", ZBEE_PROFILE_IPM, zbee_zcl_handle);
gint ett_zbee_zdp_table_entry = -1;
gint ett_zbee_zdp_descriptor_capability_field = -1;
-/* Data dissector handle. */
-static dissector_handle_t data_handle;
-
/**************************************
* Value Strings
**************************************
if (length > 0) {
excess = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, excess, pinfo, root);
+ call_data_dissector(excess, pinfo, root);
}
} /* zdp_dump_excess */
break;
default:
/* Invalid Cluster Identifier. */
- call_dissector(data_handle, zdp_tvb, pinfo, tree);
+ call_data_dissector(zdp_tvb, pinfo, tree);
break;
} /* switch */
{
dissector_handle_t zdp_handle;
- /* Find the other dissectors we need. */
- data_handle = find_dissector("data");
-
/* Register our dissector with the ZigBee application dissectors. */
zdp_handle = find_dissector("zbee_zdp");
dissector_add_uint("zbee.profile", ZBEE_ZDP_PROFILE, zdp_handle);
static expert_field ei_ziop_version = EI_INIT;
-static dissector_handle_t data_handle;
static dissector_handle_t ziop_tcp_handle;
giop_version_major,
giop_version_minor);
- call_dissector(data_handle, tvb, pinfo, tree);
+ call_data_dissector(tvb, pinfo, tree);
return tvb_reported_length(tvb);
}
dissector_add_for_decode_as("udp.port", ziop_tcp_handle);
heur_dissector_add("tcp", dissect_ziop_heur, "ZIOP over TCP", "ziop_tcp", proto_ziop, HEURISTIC_ENABLE);
-
- data_handle = find_dissector("data");
}
/*
return call_dissector_with_data(handle, tvb, pinfo, tree, NULL);
}
+int
+call_data_dissector(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
+{
+ return call_dissector_work(data_handle, tvb, pinfo, tree, TRUE, NULL);
+}
/*
* Call a heuristic dissector through a heur_dtbl_entry
WS_DLL_PUBLIC int call_dissector(dissector_handle_t handle, tvbuff_t *tvb,
packet_info *pinfo, proto_tree *tree);
+WS_DLL_PUBLIC int call_data_dissector(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
+
/** Call a dissector through a handle but if no dissector was found
* just return 0 and do not call the "data" dissector instead.
*
static int hf_docsis_ehdr_bpup2_sid = -1;
static dissector_handle_t docsis_handle;
static dissector_handle_t eth_withoutfcs_handle;
-static dissector_handle_t data_handle;
static dissector_handle_t docsis_mgmt_handle;
#if 0
static dissector_table_t docsis_dissector_table;
if (pdulen > 0)
{
mgt_tvb = tvb_new_subset (tvb, hdrlen, captured_length, pdulen);
- call_dissector (data_handle, mgt_tvb, pinfo, tree);
+ call_data_dissector(mgt_tvb, pinfo, tree);
}
if (concatlen > 0)
{
{
docsis_handle = find_dissector ("docsis");
- data_handle = find_dissector ("data");
dissector_add_uint ("wtap_encap", WTAP_ENCAP_DOCSIS, docsis_handle);
docsis_mgmt_handle = find_dissector ("docsis_mgmt");
static int hf_docsis_mgt_rsvd = -1;
static dissector_table_t docsis_mgmt_dissector_table;
-static dissector_handle_t data_handle;
/* Initialize the subtree pointers */
static gint ett_docsis_mgmt = -1;
payload_tvb = tvb_new_subset_length (tvb, 20, msg_len - 6);
if (!dissector_try_uint(docsis_mgmt_dissector_table, type, payload_tvb, pinfo, tree))
- call_dissector (data_handle, payload_tvb, pinfo, tree);
+ call_data_dissector(payload_tvb, pinfo, tree);
return tvb_captured_length(tvb);
}
docsis_mgmt_handle = find_dissector ("docsis_mgmt");
dissector_add_uint ("docsis", 0x03, docsis_mgmt_handle);
#endif
-
- data_handle = find_dissector ("data");
}
/*
static int proto_ethercat_frame = -1;
static dissector_table_t ethercat_frame_dissector_table;
-static dissector_handle_t ethercat_frame_data_handle;
/* Define the tree for the EtherCAT frame */
static int ett_ethercat_frame = -1;
col_add_fstr (pinfo->cinfo, COL_PROTOCOL, "0x%04x", hdr.v.protocol);
/* No sub dissector wanted to handle this payload, decode it as general
data instead. */
- call_dissector (ethercat_frame_data_handle, next_tvb, pinfo, tree);
+ call_data_dissector(next_tvb, pinfo, tree);
}
return tvb_captured_length(tvb);
}
dissector_add_uint("ethertype", ETHERTYPE_ECATF, ethercat_frame_handle);
dissector_add_uint("udp.port", ETHERTYPE_ECATF, ethercat_frame_handle);
dissector_add_uint("tcp.port", ETHERTYPE_ECATF, ethercat_frame_handle);
- ethercat_frame_data_handle = find_dissector("data");
}
/*
#define MAX_PARAMETERS 32
static gint ett_param[MAX_IAP_ENTRIES * MAX_PARAMETERS];
-static dissector_handle_t data_handle;
static dissector_handle_t ircomm_raw_handle;
static dissector_handle_t ircomm_cooked_handle;
proto_tree_add_item(ctrl_tree, hf_control_len, tvb, offset, 1, ENC_BIG_ENDIAN);
offset++;
- call_dissector(data_handle, tvb_new_subset_length(tvb, offset, clen), pinfo, ctrl_tree);
+ call_data_dissector(tvb_new_subset_length(tvb, offset, clen), pinfo, ctrl_tree);
offset += clen;
- call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo, ircomm_tree);
+ call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, ircomm_tree);
return len;
}
static int dissect_raw_ircomm(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, void* data _U_)
{
guint len = tvb_reported_length(tvb);
+ proto_item* ti;
+ proto_tree* ircomm_tree;
if (len == 0)
return 0;
col_add_fstr(pinfo->cinfo, COL_INFO, "User Data: %d byte%s", len, (len > 1)? "s": "");
- if (tree)
- {
- /* create display subtree for the protocol */
- proto_item* ti = proto_tree_add_item(tree, proto_ircomm, tvb, 0, -1, ENC_NA);
- proto_tree* ircomm_tree = proto_item_add_subtree(ti, ett_ircomm);
+ /* create display subtree for the protocol */
+ ti = proto_tree_add_item(tree, proto_ircomm, tvb, 0, -1, ENC_NA);
+ ircomm_tree = proto_item_add_subtree(ti, ett_ircomm);
- call_dissector(data_handle, tvb, pinfo, ircomm_tree);
- }
+ call_data_dissector(tvb, pinfo, ircomm_tree);
return len;
}
void
proto_reg_handoff_ircomm(void) {
- data_handle = find_dissector("data");
ircomm_raw_handle = find_dissector("ircomm_raw");
ircomm_cooked_handle = find_dissector("ircomm_cooked");
}
void proto_reg_handoff_irda(void);
void proto_register_irda(void);
-static dissector_handle_t data_handle;
-
/* Initialize the protocol and registered fields */
static int proto_irlap = -1;
static int hf_lap_a = -1;
/* If any bytes remain, send it to the generic data dissector */
tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, tvb, pinfo, root);
+ call_data_dissector(tvb, pinfo, root);
}
/* If any bytes remain, send it to the generic data dissector */
tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, tvb, pinfo, root);
+ call_data_dissector(tvb, pinfo, root);
}
call_dissector_with_data(lmp_conv->dissector, tvb, pinfo, root, GUINT_TO_POINTER(pdu_type));
}
else
- call_dissector(data_handle, tvb, pinfo, root);
+ call_data_dissector(tvb, pinfo, root);
}
else
{
if ((dlsap == LSAP_IAS) || (slsap == LSAP_IAS))
- call_dissector(data_handle, tvb, pinfo, root);
+ call_data_dissector(tvb, pinfo, root);
else
switch (opcode)
{
break;
default:
- call_dissector(data_handle, tvb, pinfo, root);
+ call_data_dissector(tvb, pinfo, root);
}
}
}
if (tvb_reported_length_remaining(tvb, offset) > 0)
{
tvb = tvb_new_subset_remaining(tvb, offset);
- call_dissector(data_handle, tvb, pinfo, root);
+ call_data_dissector(tvb, pinfo, root);
}
}
irda_handle = find_dissector("irda");
dissector_add_uint("wtap_encap", WTAP_ENCAP_IRDA, irda_handle);
dissector_add_uint("sll.ltype", LINUX_SLL_P_IRDA_LAP, irda_handle);
- data_handle = find_dissector("data");
}
/*
void proto_register_irsir(void);
/** Protocol handles. */
-static dissector_handle_t data_handle;
static dissector_handle_t irda_handle;
/** Protocol fields. */
{
dissector_add_uint("tcp.port", TCP_PORT_SIR, find_dissector("sir"));
- data_handle = find_dissector("data");
irda_handle = find_dissector("irda");
- if (irda_handle == NULL)
- irda_handle = data_handle;
}
static reassembly_table pdu_reassembly_table;
static GHashTable *reasembled_frag_table = NULL;
-static dissector_handle_t data_handle;
static dissector_table_t ethertype_subdissector_table;
static guint32 start_frag_OR_ID[16];
type = tvb_get_ntohs(pdu_tvb, 0);
pdu_tvb = tvb_new_subset_remaining(pdu_tvb, 2);
if (!dissector_try_uint(ethertype_subdissector_table, type, pdu_tvb, pinfo, tree))
- call_dissector(data_handle, pdu_tvb, pinfo, tree);
+ call_data_dissector(pdu_tvb, pinfo, tree);
}
}
return TRUE;
heur_dissector_add("pn_rt", dissect_CSF_SDU_heur, "PROFINET CSF_SDU IO", "pn_csf_sdu_pn_rt", proto_pn_rt, HEURISTIC_ENABLE);
heur_dissector_add("pn_rt", dissect_FRAG_PDU_heur, "PROFINET Frag PDU IO", "pn_frag_pn_rt", proto_pn_rt, HEURISTIC_ENABLE);
- data_handle = find_dissector("data");
ethertype_subdissector_table = find_dissector_table("ethertype");
}
git.samba.org / jlayton / wireshark.git / commitdiff