osmocom
/
wireshark
14
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity

(Trivial) 

- Fix indentation to match editor modelines (tabs-->spaces);
 - Rework/add some whitespace;

svn path=/trunk/; revision=53978
This commit is contained in:
Bill Meier 2013-12-12 20:16:30 +00:00
parent e14b04c20f
commit ebaeed5a1f
14 changed files with 4172 additions and 4172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6430
epan/dissectors/packet-assa_r3.c
View File

File diff suppressed because it is too large Load Diff

2
epan/dissectors/packet-atmtcp.c
View File

@ -92,7 +92,7 @@ dissect_atmtcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _
length = tvb_get_ntohl(tvb, offset);
if(length == ATMTCP_HDR_MAGIC)
{
col_append_str(pinfo->cinfo, COL_INFO, " Command");
col_append_str(pinfo->cinfo, COL_INFO, " Command");
}
else
{

44
epan/dissectors/packet-cip.h
View File

@ -263,13 +263,13 @@ typedef int attribute_dissector_func(packet_info *pinfo, proto_tree *tree, proto
int offset, int total_len);
typedef struct attribute_info {
guint class_id;
gboolean class_instance;
guint attribute;
const char *text;
enum cip_datatype datatype;
int* phf;
attribute_dissector_func* pdissect;
guint class_id;
gboolean class_instance;
guint attribute;
const char *text;
enum cip_datatype datatype;
int* phf;
attribute_dissector_func *pdissect;
} attribute_info_t;
typedef struct cip_connID_info {
@ -287,25 +287,25 @@ typedef struct cip_safety_epath_info {
} cip_safety_epath_info_t;
typedef struct cip_conn_info {
guint16 ConnSerialNumber;
guint16 VendorID;
guint32 DeviceSerialNumber;
cip_connID_info_t O2T;
cip_connID_info_t T2O;
guint8 TransportClass_trigger;
guint16 ConnSerialNumber;
guint16 VendorID;
guint32 DeviceSerialNumber;
cip_connID_info_t O2T;
cip_connID_info_t T2O;
guint8 TransportClass_trigger;
cip_safety_epath_info_t safety;
gboolean motion;
gboolean motion;
} cip_conn_info_t;
typedef struct cip_req_info {
dissector_handle_t dissector;
guint8 bService;
guint IOILen;
void *pIOI;
void *pData;
cip_simple_request_info_t* ciaData;
cip_conn_info_t* connInfo;
gboolean isUnconnectedSend;
dissector_handle_t dissector;
guint8 bService;
guint IOILen;
void *pIOI;
void *pData;
cip_simple_request_info_t *ciaData;
cip_conn_info_t* connInfo;
gboolean isUnconnectedSend;
} cip_req_info_t;
/*

138
epan/dissectors/packet-dcerpc.c
View File

@ -735,7 +735,7 @@ decode_dcerpc_binding_free(void *binding_in)
g_free((void *) binding->addr_a.data);
g_free((void *) binding->addr_b.data);
if(binding->ifname)
if (binding->ifname)
g_string_free(binding->ifname, TRUE);
g_free(binding);
}
@ -754,7 +754,7 @@ decode_dcerpc_reset_all(void)
{
decode_dcerpc_bind_values_t *binding;
while(decode_dcerpc_bindings) {
while (decode_dcerpc_bindings) {
binding = (decode_dcerpc_bind_values_t *)decode_dcerpc_bindings->data;
decode_dcerpc_binding_free(binding);
@ -778,7 +778,7 @@ dcerpc_prompt(packet_info *pinfo, gchar* result)
*address_str = g_string_new("");
dcerpc_decode_as_data* decode_data = dcerpc_get_decode_data(pinfo);
switch(pinfo->ptype) {
switch (pinfo->ptype) {
case(PT_TCP):
g_string_append(address_str, "Address: ToBeDone TCP port");
break;
@ -837,7 +837,7 @@ decode_dcerpc_add_to_list(gpointer key, gpointer value, gpointer user_data)
/*dcerpc_uuid_key *k = key;*/
dcerpc_uuid_value *v = (dcerpc_uuid_value *)value;
if(strcmp(v->name, "(none)"))
if (strcmp(v->name, "(none)"))
populate->add_to_list("DCE-RPC", v->name, key, populate->ui_element);
}
@ -861,7 +861,7 @@ decode_dcerpc_binding_cmp(gconstpointer a, gconstpointer b)
/* don't compare uuid and ver! */
if(
if (
ADDRESSES_EQUAL(&binding_a->addr_a, &binding_b->addr_a) &&
ADDRESSES_EQUAL(&binding_a->addr_b, &binding_b->addr_b) &&
binding_a->ptype == binding_b->ptype &&
@ -890,7 +890,7 @@ decode_dcerpc_binding_reset(const char *name _U_, const gpointer pattern)
le = g_slist_find_custom(decode_dcerpc_bindings,
binding,
decode_dcerpc_binding_cmp);
if(le == NULL)
if (le == NULL)
return FALSE;
old_binding = (decode_dcerpc_bind_values_t *)le->data;
@ -912,9 +912,9 @@ dcerpc_decode_as_change(const char *name, const gpointer pattern, gpointer handl
dcerpc_uuid_key *key = *((dcerpc_uuid_key**)handle);
binding->ifname = g_string_new(list_name);
binding->uuid = key->uuid;
binding->ver = key->ver;
binding->ifname = g_string_new(list_name);
binding->uuid = key->uuid;
binding->ver = key->ver;
/* remove a probably existing old binding */
decode_dcerpc_binding_reset(name, binding);
@ -987,43 +987,43 @@ static reassembly_table dcerpc_co_reassembly_table;
static reassembly_table dcerpc_cl_reassembly_table;
typedef struct _dcerpc_fragment_key {
address src;
address dst;
guint32 id;
e_uuid_t act_id;
address src;
address dst;
guint32 id;
e_uuid_t act_id;
} dcerpc_fragment_key;
static guint
dcerpc_fragment_hash(gconstpointer k)
{
const dcerpc_fragment_key* key = (const dcerpc_fragment_key*) k;
guint hash_val;
const dcerpc_fragment_key* key = (const dcerpc_fragment_key*) k;
guint hash_val;
hash_val = 0;
hash_val = 0;
hash_val += key->id;
hash_val += key->act_id.Data1;
hash_val += key->act_id.Data2 << 16;
hash_val += key->act_id.Data3;
hash_val += key->id;
hash_val += key->act_id.Data1;
hash_val += key->act_id.Data2 << 16;
hash_val += key->act_id.Data3;
return hash_val;
return hash_val;
}
static gint
dcerpc_fragment_equal(gconstpointer k1, gconstpointer k2)
{
const dcerpc_fragment_key* key1 = (const dcerpc_fragment_key*) k1;
const dcerpc_fragment_key* key2 = (const dcerpc_fragment_key*) k2;
const dcerpc_fragment_key* key1 = (const dcerpc_fragment_key*) k1;
const dcerpc_fragment_key* key2 = (const dcerpc_fragment_key*) k2;
/*key.id is the first item to compare since item is most
likely to differ between sessions, thus shortcircuiting
the comparison of addresses.
*/
return (((key1->id == key2->id)
&& (ADDRESSES_EQUAL(&key1->src, &key2->src))
&& (ADDRESSES_EQUAL(&key1->dst, &key2->dst))
&& (memcmp (&key1->act_id, &key2->act_id, sizeof (e_uuid_t)) == 0))
? TRUE : FALSE);
/*key.id is the first item to compare since item is most
likely to differ between sessions, thus shortcircuiting
the comparison of addresses.
*/
return (((key1->id == key2->id)
&& (ADDRESSES_EQUAL(&key1->src, &key2->src))
&& (ADDRESSES_EQUAL(&key1->dst, &key2->dst))
&& (memcmp (&key1->act_id, &key2->act_id, sizeof (e_uuid_t)) == 0))
? TRUE : FALSE);
}
/* allocate a persistent dcerpc fragment key to insert in the hash */
@ -1031,15 +1031,15 @@ static void *
dcerpc_fragment_temporary_key(const packet_info *pinfo, const guint32 id,
const void *data)
{
dcerpc_fragment_key *key = g_slice_new(dcerpc_fragment_key);
e_dce_dg_common_hdr_t *hdr = (e_dce_dg_common_hdr_t *)data;
dcerpc_fragment_key *key = g_slice_new(dcerpc_fragment_key);
e_dce_dg_common_hdr_t *hdr = (e_dce_dg_common_hdr_t *)data;
key->src = pinfo->src;
key->dst = pinfo->dst;
key->id = id;
key->act_id = hdr->act_id;
key->src = pinfo->src;
key->dst = pinfo->dst;
key->id = id;
key->act_id = hdr->act_id;
return key;
return key;
}
/* allocate a persistent dcerpc fragment key to insert in the hash */
@ -1047,49 +1047,49 @@ static void *
dcerpc_fragment_persistent_key(const packet_info *pinfo, const guint32 id,
const void *data)
{
dcerpc_fragment_key *key = g_slice_new(dcerpc_fragment_key);
e_dce_dg_common_hdr_t *hdr = (e_dce_dg_common_hdr_t *)data;
dcerpc_fragment_key *key = g_slice_new(dcerpc_fragment_key);
e_dce_dg_common_hdr_t *hdr = (e_dce_dg_common_hdr_t *)data;
COPY_ADDRESS(&key->src, &pinfo->src);
COPY_ADDRESS(&key->dst, &pinfo->dst);
key->id = id;
key->act_id = hdr->act_id;
COPY_ADDRESS(&key->src, &pinfo->src);
COPY_ADDRESS(&key->dst, &pinfo->dst);
key->id = id;
key->act_id = hdr->act_id;
return key;
return key;
}
static void
dcerpc_fragment_free_temporary_key(gpointer ptr)
{
dcerpc_fragment_key *key = (dcerpc_fragment_key *)ptr;
dcerpc_fragment_key *key = (dcerpc_fragment_key *)ptr;
if(key)
g_slice_free(dcerpc_fragment_key, key);
if (key)
g_slice_free(dcerpc_fragment_key, key);
}
static void
dcerpc_fragment_free_persistent_key(gpointer ptr)
{
dcerpc_fragment_key *key = (dcerpc_fragment_key *)ptr;
dcerpc_fragment_key *key = (dcerpc_fragment_key *)ptr;
if(key){
/*
* Free up the copies of the addresses from the old key.
*/
g_free((gpointer)key->src.data);
g_free((gpointer)key->dst.data);
if (key) {
/*
* Free up the copies of the addresses from the old key.
*/
g_free((gpointer)key->src.data);
g_free((gpointer)key->dst.data);
g_slice_free(dcerpc_fragment_key, key);
}
g_slice_free(dcerpc_fragment_key, key);
}
}
static const reassembly_table_functions dcerpc_cl_reassembly_table_functions = {
dcerpc_fragment_hash,
dcerpc_fragment_equal,
dcerpc_fragment_temporary_key,
dcerpc_fragment_persistent_key,
dcerpc_fragment_free_temporary_key,
dcerpc_fragment_free_persistent_key
dcerpc_fragment_hash,
dcerpc_fragment_equal,
dcerpc_fragment_temporary_key,
dcerpc_fragment_persistent_key,
dcerpc_fragment_free_temporary_key,
dcerpc_fragment_free_persistent_key
};
static void
@ -1767,7 +1767,7 @@ dissect_ndr_ucarray(tvbuff_t *tvb, gint offset, packet_info *pinfo,
proto_tree_add_uint(tree, hf_dcerpc_array_max_count, tvb, di->array_max_count_offset, conformance_size, di->array_max_count);
/* real run, dissect the elements */
for(i=0; i<di->array_max_count; i++) {
for (i=0; i<di->array_max_count; i++) {
offset = (*fnct)(tvb, offset, pinfo, tree, di, drep);
}
}
@ -1826,7 +1826,7 @@ dissect_ndr_ucvarray_core(tvbuff_t *tvb, gint offset, packet_info *pinfo,
if (fnct_block) {
offset = (*fnct_block)(tvb, offset, di->array_actual_count, pinfo, tree, drep);
} else {
for(i=0 ;i<di->array_actual_count; i++) {
for (i=0 ;i<di->array_actual_count; i++) {
old_offset = offset;
offset = (*fnct_bytes)(tvb, offset, pinfo, tree, di, drep);
if (offset <= old_offset)
@ -1891,7 +1891,7 @@ dissect_ndr_uvarray(tvbuff_t *tvb, gint offset, packet_info *pinfo,
proto_tree_add_uint(tree, hf_dcerpc_array_actual_count, tvb, di->array_actual_count_offset, conformance_size, di->array_actual_count);
/* real run, dissect the elements */
for(i=0; i<di->array_actual_count; i++) {
for (i=0; i<di->array_actual_count; i++) {
offset = (*fnct)(tvb, offset, pinfo, tree, di, drep);
}
}
@ -2327,7 +2327,7 @@ dissect_deferred_pointers(packet_info *pinfo, tvbuff_t *tvb, int offset, dcerpc_
found_new_pointer = 0;
len = g_slist_length(ndr_pointer_list);
for(i=next_pointer; i<len; i++) {
for (i=next_pointer; i<len; i++) {
ndr_pointer_data_t *tnpd = (ndr_pointer_data_t *)g_slist_nth_data(ndr_pointer_list, i);
if (tnpd->fnct) {
dcerpc_dissect_fnct_t *fnct;
@ -2463,7 +2463,7 @@ find_pointer_index(guint32 id)
int i,len;
len = g_slist_length(ndr_pointer_list);
for(i=0; i<len; i++) {
for (i=0; i<len; i++) {
npd = (ndr_pointer_data_t *)g_slist_nth_data(ndr_pointer_list, i);
if (npd) {
if (npd->id == id) {

10
epan/dissectors/packet-dvb-data-mpe.c
View File

@ -96,18 +96,18 @@ dissect_dvb_data_mpe(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
mac_bytes_tvb[4] = tvb_new_subset(tvb, offset, 1, 1);
offset += 1;
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_reserved, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_reserved, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_payload_scrambling_control, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_address_scrambling_control, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_llc_snap_flag, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_current_next_indicator, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_llc_snap_flag, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_current_next_indicator, tvb, offset, 1, ENC_BIG_ENDIAN);
llc_snap_flag = tvb_get_guint8(tvb, offset) & DVB_DATA_MPE_LLC_SNAP_FLAG_MASK;
offset += 1;
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_section_number, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_section_number, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_last_section_number, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_last_section_number, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
for (i = 3; i >= 0; i--) {

2
epan/dissectors/packet-dvb-s2-bb.c
View File

@ -640,7 +640,7 @@ static int dissect_dvb_s2_gse(tvbuff_t *tvb, int cur_off, proto_tree *tree, pack
col_append_str(pinfo->cinfo, COL_INFO, "0 ");
}
if (gse_proto < 0x0600 && gse_proto >= 0x100) {
/* Only display optional extension headers */
/* Only display optional extension headers */
/* TODO: needs to be tested */
/* TODO: implementation needs to be checked (len of ext-header??) */

214
epan/dissectors/packet-gtpv2.c
View File

@ -4684,9 +4684,9 @@ dissect_gtpv2_rfsp_index(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree
int offset = 0;
if(instance == 0){
proto_tree_add_item(tree, hf_gtpv2_subscriber_rfsp, tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_gtpv2_subscriber_rfsp, tvb, offset, 2, ENC_BIG_ENDIAN);
}else if(instance == 1){
proto_tree_add_item(tree, hf_gtpv2_rfsp_inuse, tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_gtpv2_rfsp_inuse, tvb, offset, 2, ENC_BIG_ENDIAN);
}
}
@ -5653,38 +5653,38 @@ void proto_register_gtpv2(void)
{"MSV (MS Validated)", "gtpv2.msv",
FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}
},
{&hf_gtpv2_spare1,
{"Spare", "gtpv2.spare",
FT_BOOLEAN, 8, NULL, 0x80, NULL, HFILL}
},
{&hf_gtpv2_spare2,
{"Spare", "gtpv2.spare",
FT_BOOLEAN, 8, NULL, 0x40, NULL, HFILL}
},
{&hf_gtpv2_spare3,
{"Spare", "gtpv2.spare",
FT_BOOLEAN, 8, NULL, 0x20, NULL, HFILL}
},
{&hf_gtpv2_s6af,
{"S6AF (Static IPv6 Address Flag)", "gtpv2.s6af",
FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL}
},
{&hf_gtpv2_s4af,
{"S4AF (Static IPv4 Address Flag))", "gtpv2.s4af",
FT_BOOLEAN, 8, NULL, 0x08, NULL, HFILL}
},
{&hf_gtpv2_mbmdt,
{"MBMDT (Management Based MDT allowed flag)", "gtpv2.mbmdt",
FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}
},
{&hf_gtpv2_israu,
{"ISRAU (ISR is activated for the UE)", "gtpv2.israu",
FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}
},
{&hf_gtpv2_ccrsi,
{"CCRSI (CSG Change Reporting support indication)", "gtpv2.ccrsi",
FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}
},
{&hf_gtpv2_spare1,
{"Spare", "gtpv2.spare",
FT_BOOLEAN, 8, NULL, 0x80, NULL, HFILL}
},
{&hf_gtpv2_spare2,
{"Spare", "gtpv2.spare",
FT_BOOLEAN, 8, NULL, 0x40, NULL, HFILL}
},
{&hf_gtpv2_spare3,
{"Spare", "gtpv2.spare",
FT_BOOLEAN, 8, NULL, 0x20, NULL, HFILL}
},
{&hf_gtpv2_s6af,
{"S6AF (Static IPv6 Address Flag)", "gtpv2.s6af",
FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL}
},
{&hf_gtpv2_s4af,
{"S4AF (Static IPv4 Address Flag))", "gtpv2.s4af",
FT_BOOLEAN, 8, NULL, 0x08, NULL, HFILL}
},
{&hf_gtpv2_mbmdt,
{"MBMDT (Management Based MDT allowed flag)", "gtpv2.mbmdt",
FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}
},
{&hf_gtpv2_israu,
{"ISRAU (ISR is activated for the UE)", "gtpv2.israu",
FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}
},
{&hf_gtpv2_ccrsi,
{"CCRSI (CSG Change Reporting support indication)", "gtpv2.ccrsi",
FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}
},
{ &hf_gtpv2_pdn_type,
{"PDN Type", "gtpv2.pdn_type",
FT_UINT8, BASE_DEC, VALS(gtpv2_pdn_type_vals), 0x07,
@ -6556,9 +6556,9 @@ void proto_register_gtpv2(void)
NULL, HFILL}
},
{ &hf_gtpv2_ue_time_zone_dst,
{"Daylight Saving Time", "gtpv2.ue_time_zone_dst",
FT_UINT8, BASE_DEC, VALS(gtpv2_ue_time_zone_dst_vals), 0x03,
NULL, HFILL}
{"Daylight Saving Time", "gtpv2.ue_time_zone_dst",
FT_UINT8, BASE_DEC, VALS(gtpv2_ue_time_zone_dst_vals), 0x03,
NULL, HFILL}
},
{ &hf_gtpv2_fq_csid_type,
{"Node-ID Type", "gtpv2.fq_csid_type",
@ -6757,38 +6757,38 @@ void proto_register_gtpv2(void)
},
{ &hf_gtpv2_mbms_service_area_nr,
{"Number of MBMS Service Area codes", "gtpv2.mbms_service_area_nr",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL}
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL}
},
{ &hf_gtpv2_mbms_service_area_id,
{"MBMS Service Area code (Service Area Identity)", "gtpv2.mbms_service_area_id",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL}
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL}
},
{ &hf_gtpv2_mbms_session_id,
{"MBMS Session Identifier", "gtpv2.mbms_session_id",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL}
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL}
},
{ &hf_gtpv2_mbms_flow_id,
{"MBMS Flow Identifier", "gtpv2.mbms_flow_id",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL}
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL}
},
{ &hf_gtpv2_cteid,
{"Common Tunnel Endpoint Identifier", "gtpv2.cetid",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL}
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL}
},
{ &hf_gtpv2_ip_addr_type,
{"IP Address Type", "gtpv2.ip_addr_type",
FT_UINT8, BASE_DEC, NULL, 0xc0,
NULL, HFILL}
FT_UINT8, BASE_DEC, NULL, 0xc0,
NULL, HFILL}
},
{ &hf_gtpv2_ip_addr_len,
{"IP Address Length", "gtpv2.ip_addr_len",
FT_UINT8, BASE_DEC, NULL, 0x3f,
NULL, HFILL}
FT_UINT8, BASE_DEC, NULL, 0x3f,
NULL, HFILL}
},
{ &hf_gtpv2_mbms_ip_mc_dist_addrv4,
{"MBMS IP Multicast Distribution Address (IPv4)", "gtpv2.mbms_ip_mc_dist_addrv4",
@ -6812,43 +6812,43 @@ void proto_register_gtpv2(void)
},
{ &hf_gtpv2_mbms_hc_indicator,
{"MBMS HC Indicator", "gtpv2.mbms_hc_indicator",
FT_UINT8, BASE_DEC, VALS(gtpv2_mbms_hc_indicator_vals), 0x0,
NULL, HFILL}
FT_UINT8, BASE_DEC, VALS(gtpv2_mbms_hc_indicator_vals), 0x0,
NULL, HFILL}
},
{ &hf_gtpv2_mbms_dist_indication,
{"MBMS Distribution Indication", "gtpv2.mbms_dist_indication",
FT_UINT8, BASE_DEC, VALS(gtpv2_mbms_dist_indication_vals), 0x03,
NULL, HFILL}
FT_UINT8, BASE_DEC, VALS(gtpv2_mbms_dist_indication_vals), 0x03,
NULL, HFILL}
},
{ &hf_gtpv2_subscriber_rfsp,
{"Subscribed RFSP Index", "gtpv2.subscriber_rfsp",
FT_INT16, BASE_DEC, NULL, 0x0,
NULL, HFILL}
FT_INT16, BASE_DEC, NULL, 0x0,
NULL, HFILL}
},
{ &hf_gtpv2_rfsp_inuse,
{"RFSP Index in Use", "gtpv2.rfsp_inuse",
FT_INT16, BASE_DEC, NULL, 0x0,
NULL, HFILL}
FT_INT16, BASE_DEC, NULL, 0x0,
NULL, HFILL}
},
{ &hf_gtpv2_mbms_service_id,
{"MBMS Service ID", "gtpv2.mbms_service_id",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL}
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL}
},
{ &hf_gtpv2_add_flags_for_srvcc_ics,
{"ICS (IMS Centralized Service)", "gtpv2.add_flags_for_srvcc_ics",
FT_BOOLEAN, 8, NULL, 0x01,
NULL, HFILL}
FT_BOOLEAN, 8, NULL, 0x01,
NULL, HFILL}
},
{ &hf_gtpv2_vsrvcc_flag,
{"VF (vSRVCC Flag)", "gtpv2.vsrvcc_flag",
FT_BOOLEAN, 8, NULL, 0x02,
NULL, HFILL}
FT_BOOLEAN, 8, NULL, 0x02,
NULL, HFILL}
},
{ &hf_gtpv2_henb_info_report_fti,
{"FTI", "gtpv2.henb_info_report_fti",
FT_BOOLEAN, 8, TFS(&gtpv2_henb_info_report_fti_vals), 0x01,
NULL, HFILL}
FT_BOOLEAN, 8, TFS(&gtpv2_henb_info_report_fti_vals), 0x01,
NULL, HFILL}
},
{ &hf_gtpv2_ip4cp_subnet_prefix_len,
{"Subnet Prefix Length", "gtpv2.ip4cp_subnet_prefix_len",
@ -6862,13 +6862,13 @@ void proto_register_gtpv2(void)
},
{ &hf_gtpv2_change_report_flags_sncr,
{"SNCR (Service Network Change to Report)", "gtpv2.change_report_flags_sncr",
FT_BOOLEAN, 8, NULL, 0x01,
NULL, HFILL}
FT_BOOLEAN, 8, NULL, 0x01,
NULL, HFILL}
},
{ &hf_gtpv2_change_report_flags_tzcr,
{"TZCR (Time Zone Change to Report)", "gtpv2.change_report_flags_tzcr",
FT_BOOLEAN, 8, NULL, 0x02,
NULL, HFILL}
FT_BOOLEAN, 8, NULL, 0x02,
NULL, HFILL}
},
{&hf_gtpv2_action_indication_val,
{"Action Indication", "gtpv2.action_indication_val",
@ -6877,88 +6877,88 @@ void proto_register_gtpv2(void)
},
{ &hf_gtpv2_abs_time_mbms_data,
{"Absolute Time of MBMS Data Transfer", "gtpv2.abs_time_mbms_data",
FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL}
FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL}
},
{ &hf_gtpv2_mbms_session_duration_days,
{"MBMS Session Duration (days)", "gtpv2.mbms_session_duration_days",
FT_UINT24, BASE_DEC, NULL, 0x00007F,
NULL, HFILL}
FT_UINT24, BASE_DEC, NULL, 0x00007F,
NULL, HFILL}
},
{ &hf_gtpv2_mbms_session_duration_secs,
{"MBMS Session Duration (seconds)", "gtpv2.mbms_session_duration_secs",
FT_UINT24, BASE_DEC, NULL, 0xFFFF80,
NULL, HFILL}
FT_UINT24, BASE_DEC, NULL, 0xFFFF80,
NULL, HFILL}
},
{ &hf_gtpv2_node_features_prn,
{"PGW Restart Notification (PRN)", "gtpv2.node_features_prn",
FT_BOOLEAN, 8, TFS(&tfs_enabled_disabled), 0x01,
NULL, HFILL}
FT_BOOLEAN, 8, TFS(&tfs_enabled_disabled), 0x01,
NULL, HFILL}
},
{ &hf_gtpv2_node_features_mabr,
{"Modify Access Bearers Request (MABR)", "gtpv2.node_features_mabr",
FT_BOOLEAN, 8, TFS(&tfs_enabled_disabled), 0x02,
NULL, HFILL}
FT_BOOLEAN, 8, TFS(&tfs_enabled_disabled), 0x02,
NULL, HFILL}
},
{ &hf_gtpv2_node_features_ntsr,
{"Network Triggered Service Restoration (NTSR)", "gtpv2.node_features_ntsr",
FT_BOOLEAN, 8, TFS(&tfs_enabled_disabled), 0x04,
NULL, HFILL}
FT_BOOLEAN, 8, TFS(&tfs_enabled_disabled), 0x04,
NULL, HFILL}
},
{ &hf_gtpv2_time_to_data_xfer,
{"MBMS Time to Data Transfer", "gtpv2.time_to_data_xfer",
FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL}
FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL}
},
{ &hf_gtpv2_arp_pvi,
{"Pre-emption Vulnerability (PVI)", "gtpv2.arp_pvi",
FT_BOOLEAN, 8, TFS(&tfs_disabled_enabled), 0x01,
NULL, HFILL}
FT_BOOLEAN, 8, TFS(&tfs_disabled_enabled), 0x01,
NULL, HFILL}
},
{ &hf_gtpv2_arp_pl,
{"Priority Level", "gtpv2.arp_pl",
FT_UINT8, BASE_DEC, NULL, 0x3c,
NULL, HFILL}
FT_UINT8, BASE_DEC, NULL, 0x3c,
NULL, HFILL}
},
{ &hf_gtpv2_arp_pci,
{"Pre-emption Capability (PCI)", "gtpv2.arp_pci",
FT_BOOLEAN, 8, TFS(&tfs_disabled_enabled), 0x40,
NULL, HFILL}
FT_BOOLEAN, 8, TFS(&tfs_disabled_enabled), 0x40,
NULL, HFILL}
},
{ &hf_gtpv2_timer_unit,
{"Timer unit", "gtpv2.timer_unit",
FT_UINT8, BASE_DEC, VALS(gtpv2_timer_unit_vals), 0xe0,
NULL, HFILL}
FT_UINT8, BASE_DEC, VALS(gtpv2_timer_unit_vals), 0xe0,
NULL, HFILL}
},
{ &hf_gtpv2_timer_value,
{"Timer value", "gtpv2.timer_value",
FT_UINT8, BASE_DEC, NULL, 0x1f,
NULL, HFILL}
FT_UINT8, BASE_DEC, NULL, 0x1f,
NULL, HFILL}
},
{ &hf_gtpv2_lapi,
{"LAPI (Low Access Priority Indication)", "gtpv2.lapi",
FT_BOOLEAN, 8, NULL, 0x01,
NULL, HFILL}
FT_BOOLEAN, 8, NULL, 0x01,
NULL, HFILL}
},
{ &hf_gtpv2_mm_context_higher_br_16mb_flg_len,
{"Length of Higher bitrates than 16 Mbps flag", "gtpv2.mm_context_higher_br_16mb_flg_len",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL}
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL}
},
{ &hf_gtpv2_mm_context_higher_br_16mb_flg,
{"Higher bitrates than 16 Mbps flag", "gtpv2.mm_context_higher_br_16mb_flg",
FT_UINT8, BASE_DEC, VALS(gtpv2_mm_context_higher_br_16mb_flg_vals), 0x0,
NULL, HFILL}
FT_UINT8, BASE_DEC, VALS(gtpv2_mm_context_higher_br_16mb_flg_vals), 0x0,
NULL, HFILL}
},
{ &hf_gtpv2_mmbr_ul,
{"Max MBR/APN-AMBR for uplink", "gtpv2.mmbr_ul",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL}
{"Max MBR/APN-AMBR for uplink", "gtpv2.mmbr_ul",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL}
},
{ &hf_gtpv2_mmbr_dl,
{"Max MBR/APN-AMBR for downlink", "gtpv2.mmbr_dl",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL}
{"Max MBR/APN-AMBR for downlink", "gtpv2.mmbr_dl",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL}
},
};

824
epan/dissectors/packet-hazelcast.c
View File

@ -71,14 +71,14 @@ static int hf_hazelcast_values = -1;
/* flags */
static int hf_hazelcast_flags = -1;
#define HAZELCAST_LOCKCOUNT_FLAG (1 << 0)
#define HAZELCAST_TIMEOUT_FLAG (1 << 1)
#define HAZELCAST_TTL_FLAG (1 << 2)
#define HAZELCAST_TXN_FLAG (1 << 3)
#define HAZELCAST_LONGVALUE_FLAG (1 << 4)
#define HAZELCAST_VERSION_FLAG (1 << 5)
#define HAZELCAST_CLIENT_FLAG (1 << 6)
#define HAZELCAST_LOCKADDRNULL_FLAG (1 << 7)
#define HAZELCAST_LOCKCOUNT_FLAG (1 << 0)
#define HAZELCAST_TIMEOUT_FLAG (1 << 1)
#define HAZELCAST_TTL_FLAG (1 << 2)
#define HAZELCAST_TXN_FLAG (1 << 3)
#define HAZELCAST_LONGVALUE_FLAG (1 << 4)
#define HAZELCAST_VERSION_FLAG (1 << 5)
#define HAZELCAST_CLIENT_FLAG (1 << 6)
#define HAZELCAST_LOCKADDRNULL_FLAG (1 << 7)
static int hf_hazelcast_flags_lockCount = -1;
static int hf_hazelcast_flags_timeout = -1;
@ -98,137 +98,137 @@ static gboolean hazelcast_desegment = TRUE;
static guint gPORT_PREF = 5701;
static const value_string operationTypes[] = {
{0, "NONE"},
{1, "RESPONSE"},
{2, "LOG"},
{3, "HEARTBEAT"},
{4, "JOIN_CHECK"},
{5, "REMOTELY_PROCESS"},
{6, "REMOTELY_PROCESS_AND_RESPOND"},
{7, "REMOTELY_CALLABLE_BOOLEAN"},
{8, "REMOTELY_CALLABLE_OBJECT"},
{9, "EVENT"},
{10, "EXECUTE"},
{11, "CANCEL_EXECUTION"},
{12, "ADD_LISTENER"},
{13, "ADD_LISTENER_NO_RESPONSE"},
{14, "REMOVE_LISTENER"},
{15, "BLOCKING_ADD_KEY"},
{16, "BLOCKING_REMOVE_KEY"},
{17, "BLOCKING_OFFER_KEY"},
{18, "BLOCKING_GENERATE_KEY"},
{19, "BLOCKING_ITERATE"},
{20, "BLOCKING_SIZE"},
{21, "BLOCKING_TAKE_KEY"},
{22, "BLOCKING_CANCEL_TAKE_KEY"},
{23, "BLOCKING_SET"},
{24, "BLOCKING_PEEK_KEY"},
{25, "BLOCKING_GET_KEY_BY_INDEX"},
{26, "BLOCKING_GET_INDEX_BY_KEY"},
{27, "BLOCKING_QUEUE_POLL"},
{28, "BLOCKING_QUEUE_OFFER"},
{29, "BLOCKING_QUEUE_SIZE"},
{30, "BLOCKING_QUEUE_PEEK"},
{31, "BLOCKING_QUEUE_REMOVE"},
{32, "TOPIC_PUBLISH"},
{33, "ATOMIC_NUMBER_ADD_AND_GET"},
{34, "ATOMIC_NUMBER_GET_AND_ADD"},
{35, "ATOMIC_NUMBER_GET_AND_SET"},
{36, "ATOMIC_NUMBER_COMPARE_AND_SET"},
{37, "CONCURRENT_MAP_PUT"},
{38, "CONCURRENT_MAP_PUT_ALL"},
{39, "CONCURRENT_MAP_PUT_TRANSIENT"},
{40, "CONCURRENT_MAP_SET"},
{41, "CONCURRENT_MAP_MERGE"},
{42, "CONCURRENT_MAP_ASYNC_MERGE"},
{43, "CONCURRENT_MAP_WAN_MERGE"},
{44, "CONCURRENT_MAP_TRY_PUT"},
{45, "CONCURRENT_MAP_PUT_AND_UNLOCK"},
{46, "CONCURRENT_MAP_GET"},
{47, "CONCURRENT_MAP_GET_ALL"},
{48, "CONCURRENT_MAP_REMOVE"},
{49, "CONCURRENT_MAP_TRY_REMOVE"},
{50, "CONCURRENT_MAP_REMOVE_ITEM"},
{51, "CONCURRENT_MAP_GET_MAP_ENTRY"},
{52, "CONCURRENT_MAP_GET_DATA_RECORD_ENTRY"},
{53, "CONCURRENT_MAP_BLOCK_INFO"},
{54, "CONCURRENT_MAP_BLOCK_MIGRATION_CHECK"},
{55, "CONCURRENT_MAP_SIZE"},
{56, "CONCURRENT_MAP_CONTAINS_KEY"},
{57, "CONCURRENT_MAP_CONTAINS_ENTRY"},
{58, "CONCURRENT_MAP_ITERATE_ENTRIES"},
{59, "CONCURRENT_MAP_ITERATE_KEYS"},
{60, "CONCURRENT_MAP_ITERATE_KEYS_ALL"},
{61, "CONCURRENT_MAP_ITERATE_VALUES"},
{62, "CONCURRENT_MAP_LOCK"},
{63, "CONCURRENT_MAP_LOCK_MAP"},
{64, "CONCURRENT_MAP_UNLOCK"},
{65, "CONCURRENT_MAP_FORCE_UNLOCK"},
{66, "CONCURRENT_MAP_UNLOCK_MAP"},
{67, "CONCURRENT_MAP_BLOCKS"},
{68, "CONCURRENT_MAP_CONTAINS_VALUE"},
{69, "CONCURRENT_MAP_PUT_IF_ABSENT"},
{70, "CONCURRENT_MAP_REMOVE_IF_SAME"},
{71, "CONCURRENT_MAP_REPLACE_IF_NOT_NULL"},
{72, "CONCURRENT_MAP_REPLACE_IF_SAME"},
{73, "CONCURRENT_MAP_TRY_LOCK_AND_GET"},
{74, "CONCURRENT_MAP_ADD_TO_LIST"},
{75, "CONCURRENT_MAP_ADD_TO_SET"},
{76, "CONCURRENT_MAP_MIGRATE_RECORD"},
{77, "CONCURRENT_MAP_PUT_MULTI"},
{78, "CONCURRENT_MAP_REMOVE_MULTI"},
{79, "CONCURRENT_MAP_VALUE_COUNT"},
{80, "CONCURRENT_MAP_BACKUP_PUT"},
{81, "CONCURRENT_MAP_BACKUP_REMOVE"},
{82, "CONCURRENT_MAP_BACKUP_REMOVE_MULTI"},
{83, "CONCURRENT_MAP_BACKUP_LOCK"},
{84, "CONCURRENT_MAP_BACKUP_ADD"},
{85, "CONCURRENT_MAP_INVALIDATE"},
{86, "CONCURRENT_MAP_EVICT"},
{87, "CONCURRENT_MAP_FLUSH"},
{88, "TRANSACTION_BEGIN"},
{89, "TRANSACTION_COMMIT"},
{90, "TRANSACTION_ROLLBACK"},
{91, "DESTROY"},
{92, "GET_ID"},
{93, "NEW_ID"},
{94, "ADD_INDEX"},
{95, "GET_INSTANCES"},
{96, "GET_MEMBERS"},
{97, "GET_CLUSTER_TIME"},
{98, "CLIENT_AUTHENTICATE"},
{99, "CLIENT_ADD_INSTANCE_LISTENER"},
{100, "CLIENT_GET_PARTITIONS"},
{101, "BLOCKING_QUEUE_REMAINING_CAPACITY"},
{102, "BLOCKING_QUEUE_ENTRIES"},
{103, "COUNT_DOWN_LATCH_AWAIT"},
{104, "COUNT_DOWN_LATCH_COUNT_DOWN"},
{105, "COUNT_DOWN_LATCH_DESTROY"},
{106, "COUNT_DOWN_LATCH_GET_COUNT"},
{107, "COUNT_DOWN_LATCH_GET_OWNER"},
{108, "COUNT_DOWN_LATCH_SET_COUNT"},
{109, "SEMAPHORE_ATTACH_DETACH_PERMITS"},
{110, "SEMAPHORE_CANCEL_ACQUIRE"},
{111, "SEMAPHORE_DESTROY"},
{112, "SEMAPHORE_DRAIN_PERMITS"},
{113, "SEMAPHORE_GET_ATTACHED_PERMITS"},
{114, "SEMAPHORE_GET_AVAILABLE_PERMITS"},
{115, "SEMAPHORE_REDUCE_PERMITS"},
{116, "SEMAPHORE_RELEASE"},
{117, "SEMAPHORE_TRY_ACQUIRE"},
{118, "LOCK_LOCK"},
{119, "LOCK_UNLOCK"},
{120, "LOCK_FORCE_UNLOCK"},
{0 , NULL}
{0, "NONE"},
{1, "RESPONSE"},
{2, "LOG"},
{3, "HEARTBEAT"},
{4, "JOIN_CHECK"},
{5, "REMOTELY_PROCESS"},
{6, "REMOTELY_PROCESS_AND_RESPOND"},
{7, "REMOTELY_CALLABLE_BOOLEAN"},
{8, "REMOTELY_CALLABLE_OBJECT"},
{9, "EVENT"},
{10, "EXECUTE"},
{11, "CANCEL_EXECUTION"},
{12, "ADD_LISTENER"},
{13, "ADD_LISTENER_NO_RESPONSE"},
{14, "REMOVE_LISTENER"},
{15, "BLOCKING_ADD_KEY"},
{16, "BLOCKING_REMOVE_KEY"},
{17, "BLOCKING_OFFER_KEY"},
{18, "BLOCKING_GENERATE_KEY"},
{19, "BLOCKING_ITERATE"},
{20, "BLOCKING_SIZE"},
{21, "BLOCKING_TAKE_KEY"},
{22, "BLOCKING_CANCEL_TAKE_KEY"},
{23, "BLOCKING_SET"},
{24, "BLOCKING_PEEK_KEY"},
{25, "BLOCKING_GET_KEY_BY_INDEX"},
{26, "BLOCKING_GET_INDEX_BY_KEY"},
{27, "BLOCKING_QUEUE_POLL"},
{28, "BLOCKING_QUEUE_OFFER"},
{29, "BLOCKING_QUEUE_SIZE"},
{30, "BLOCKING_QUEUE_PEEK"},
{31, "BLOCKING_QUEUE_REMOVE"},
{32, "TOPIC_PUBLISH"},
{33, "ATOMIC_NUMBER_ADD_AND_GET"},
{34, "ATOMIC_NUMBER_GET_AND_ADD"},
{35, "ATOMIC_NUMBER_GET_AND_SET"},
{36, "ATOMIC_NUMBER_COMPARE_AND_SET"},
{37, "CONCURRENT_MAP_PUT"},
{38, "CONCURRENT_MAP_PUT_ALL"},
{39, "CONCURRENT_MAP_PUT_TRANSIENT"},
{40, "CONCURRENT_MAP_SET"},
{41, "CONCURRENT_MAP_MERGE"},
{42, "CONCURRENT_MAP_ASYNC_MERGE"},
{43, "CONCURRENT_MAP_WAN_MERGE"},
{44, "CONCURRENT_MAP_TRY_PUT"},
{45, "CONCURRENT_MAP_PUT_AND_UNLOCK"},
{46, "CONCURRENT_MAP_GET"},
{47, "CONCURRENT_MAP_GET_ALL"},
{48, "CONCURRENT_MAP_REMOVE"},
{49, "CONCURRENT_MAP_TRY_REMOVE"},
{50, "CONCURRENT_MAP_REMOVE_ITEM"},
{51, "CONCURRENT_MAP_GET_MAP_ENTRY"},
{52, "CONCURRENT_MAP_GET_DATA_RECORD_ENTRY"},
{53, "CONCURRENT_MAP_BLOCK_INFO"},
{54, "CONCURRENT_MAP_BLOCK_MIGRATION_CHECK"},
{55, "CONCURRENT_MAP_SIZE"},
{56, "CONCURRENT_MAP_CONTAINS_KEY"},
{57, "CONCURRENT_MAP_CONTAINS_ENTRY"},
{58, "CONCURRENT_MAP_ITERATE_ENTRIES"},
{59, "CONCURRENT_MAP_ITERATE_KEYS"},
{60, "CONCURRENT_MAP_ITERATE_KEYS_ALL"},
{61, "CONCURRENT_MAP_ITERATE_VALUES"},
{62, "CONCURRENT_MAP_LOCK"},
{63, "CONCURRENT_MAP_LOCK_MAP"},
{64, "CONCURRENT_MAP_UNLOCK"},
{65, "CONCURRENT_MAP_FORCE_UNLOCK"},
{66, "CONCURRENT_MAP_UNLOCK_MAP"},
{67, "CONCURRENT_MAP_BLOCKS"},
{68, "CONCURRENT_MAP_CONTAINS_VALUE"},
{69, "CONCURRENT_MAP_PUT_IF_ABSENT"},
{70, "CONCURRENT_MAP_REMOVE_IF_SAME"},
{71, "CONCURRENT_MAP_REPLACE_IF_NOT_NULL"},
{72, "CONCURRENT_MAP_REPLACE_IF_SAME"},
{73, "CONCURRENT_MAP_TRY_LOCK_AND_GET"},
{74, "CONCURRENT_MAP_ADD_TO_LIST"},
{75, "CONCURRENT_MAP_ADD_TO_SET"},
{76, "CONCURRENT_MAP_MIGRATE_RECORD"},
{77, "CONCURRENT_MAP_PUT_MULTI"},
{78, "CONCURRENT_MAP_REMOVE_MULTI"},
{79, "CONCURRENT_MAP_VALUE_COUNT"},
{80, "CONCURRENT_MAP_BACKUP_PUT"},
{81, "CONCURRENT_MAP_BACKUP_REMOVE"},
{82, "CONCURRENT_MAP_BACKUP_REMOVE_MULTI"},
{83, "CONCURRENT_MAP_BACKUP_LOCK"},
{84, "CONCURRENT_MAP_BACKUP_ADD"},
{85, "CONCURRENT_MAP_INVALIDATE"},
{86, "CONCURRENT_MAP_EVICT"},
{87, "CONCURRENT_MAP_FLUSH"},
{88, "TRANSACTION_BEGIN"},
{89, "TRANSACTION_COMMIT"},
{90, "TRANSACTION_ROLLBACK"},
{91, "DESTROY"},
{92, "GET_ID"},
{93, "NEW_ID"},
{94, "ADD_INDEX"},
{95, "GET_INSTANCES"},
{96, "GET_MEMBERS"},
{97, "GET_CLUSTER_TIME"},
{98, "CLIENT_AUTHENTICATE"},
{99, "CLIENT_ADD_INSTANCE_LISTENER"},
{100, "CLIENT_GET_PARTITIONS"},
{101, "BLOCKING_QUEUE_REMAINING_CAPACITY"},
{102, "BLOCKING_QUEUE_ENTRIES"},
{103, "COUNT_DOWN_LATCH_AWAIT"},
{104, "COUNT_DOWN_LATCH_COUNT_DOWN"},
{105, "COUNT_DOWN_LATCH_DESTROY"},
{106, "COUNT_DOWN_LATCH_GET_COUNT"},
{107, "COUNT_DOWN_LATCH_GET_OWNER"},
{108, "COUNT_DOWN_LATCH_SET_COUNT"},
{109, "SEMAPHORE_ATTACH_DETACH_PERMITS"},
{110, "SEMAPHORE_CANCEL_ACQUIRE"},
{111, "SEMAPHORE_DESTROY"},
{112, "SEMAPHORE_DRAIN_PERMITS"},
{113, "SEMAPHORE_GET_ATTACHED_PERMITS"},
{114, "SEMAPHORE_GET_AVAILABLE_PERMITS"},
{115, "SEMAPHORE_REDUCE_PERMITS"},
{116, "SEMAPHORE_RELEASE"},
{117, "SEMAPHORE_TRY_ACQUIRE"},
{118, "LOCK_LOCK"},
{119, "LOCK_UNLOCK"},
{120, "LOCK_FORCE_UNLOCK"},
{0 , NULL}
};
static value_string_ext operationTypes_ext = VALUE_STRING_EXT_INIT(operationTypes);
static const value_string responseTypes[] = {
{2, "RESPONSE_NONE"},
{3, "RESPONSE_SUCCESS"},
{4, "RESPONSE_FAILURE"},
{5, "RESPONSE_REDO"},
{0, NULL}
{2, "RESPONSE_NONE"},
{3, "RESPONSE_SUCCESS"},
{4, "RESPONSE_FAILURE"},
{5, "RESPONSE_REDO"},
{0, NULL}
};
static value_string_ext responseTypes_ext = VALUE_STRING_EXT_INIT(responseTypes);
@ -238,191 +238,191 @@ static value_string_ext responseTypes_ext = VALUE_STRING_EXT_INIT(responseTypes)
/* Get the length of a single HAZELCAST message */
static guint get_hazelcast_message_len(packet_info *pinfo _U_, tvbuff_t *tvb, int offset) {
guint messageLength;
guint headerKeyLength;
guint headerValueLength;
guint messageLength;
guint headerKeyLength;
guint headerValueLength;
messageLength = tvb_get_ntohl(tvb, offset);
messageLength = tvb_get_ntohl(tvb, offset);
headerKeyLength = tvb_get_ntohl(tvb, offset+4);
headerKeyLength = tvb_get_ntohl(tvb, offset+4);
headerValueLength = tvb_get_ntohl(tvb, offset+8);
headerValueLength = tvb_get_ntohl(tvb, offset+8);
/*
* * That length doesn't include the length of the header itself add that in.
*/
return messageLength + headerKeyLength + headerValueLength + 13;
/*
* * That length doesn't include the length of the header itself add that in.
*/
return messageLength + headerKeyLength + headerValueLength + 13;
}
static int dissect_hazelcast_message(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void* data _U_) {
guint8 version;
guint8 version;
guint8 flags;
guint8 operation;
guint8 flags;
guint8 operation;
guint8 lockCountFlag;
guint8 timeoutFlag;
guint8 ttlFlag;
guint8 txnFlag;
guint8 longValueFlag;
guint8 versionFlag;
guint8 lockAddrNullFlag;
guint8 lockCountFlag;
guint8 timeoutFlag;
guint8 ttlFlag;
guint8 txnFlag;
guint8 longValueFlag;
guint8 versionFlag;
guint8 lockAddrNullFlag;
guint32 nameLength;
guint32 keyLength;
guint32 valueLength;
gint offset = 0;
guint32 nameLength;
guint32 keyLength;
guint32 valueLength;
gint offset = 0;
proto_tree *hcast_tree = NULL;
proto_tree *flag_tree = NULL;
proto_tree *hcast_tree = NULL;
proto_tree *flag_tree = NULL;
proto_item *tf = NULL;
proto_item *tf = NULL;
/* Make entries in Protocol column and Info column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "HAZELCAST");
col_set_str(pinfo->cinfo, COL_INFO, "Hazelcast distributed object goodness");
/* Make entries in Protocol column and Info column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "HAZELCAST");
col_set_str(pinfo->cinfo, COL_INFO, "Hazelcast distributed object goodness");
if (tree) {
if (tree) {
proto_item *ti = NULL;
ti = proto_tree_add_item(tree, proto_hazelcast, tvb, 0, -1, ENC_NA);
proto_item *ti = NULL;
ti = proto_tree_add_item(tree, proto_hazelcast, tvb, 0, -1, ENC_NA);
hcast_tree = proto_item_add_subtree(ti, ett_hazelcast);
}
if (tvb_length_remaining(tvb, 0) < 13) {
col_set_str(pinfo->cinfo, COL_INFO, "Hazelcast too short");
return 0;
}
hcast_tree = proto_item_add_subtree(ti, ett_hazelcast);
}
if (tvb_length_remaining(tvb, 0) < 13) {
col_set_str(pinfo->cinfo, COL_INFO, "Hazelcast too short");
return 0;
}
version = tvb_get_guint8(tvb, 12);
if ( version != 6 ) {
col_set_str(pinfo->cinfo, COL_INFO, "Hazelcast unsupported version");
return 12;
}
version = tvb_get_guint8(tvb, 12);
if ( version != 6 ) {
col_set_str(pinfo->cinfo, COL_INFO, "Hazelcast unsupported version");
return 12;
}
proto_tree_add_item(hcast_tree, hf_hazelcast_headerLength, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
proto_tree_add_item(hcast_tree, hf_hazelcast_headerKeyLength, tvb, offset, 4, ENC_BIG_ENDIAN);
keyLength = tvb_get_ntohl(tvb, offset);
offset += 4;
proto_tree_add_item(hcast_tree, hf_hazelcast_headerValueLength, tvb, offset, 4, ENC_BIG_ENDIAN);
valueLength = tvb_get_ntohl(tvb, offset);
offset += 4;
proto_tree_add_item(hcast_tree, hf_hazelcast_headerVersion, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
proto_tree_add_item(hcast_tree, hf_hazelcast_headerLength, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
proto_tree_add_item(hcast_tree, hf_hazelcast_headerKeyLength, tvb, offset, 4, ENC_BIG_ENDIAN);
keyLength = tvb_get_ntohl(tvb, offset);
offset += 4;
proto_tree_add_item(hcast_tree, hf_hazelcast_headerValueLength, tvb, offset, 4, ENC_BIG_ENDIAN);
valueLength = tvb_get_ntohl(tvb, offset);
offset += 4;
proto_tree_add_item(hcast_tree, hf_hazelcast_headerVersion, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
proto_tree_add_item(hcast_tree, hf_hazelcast_operation, tvb, offset, 1, ENC_BIG_ENDIAN);
operation = tvb_get_guint8(tvb, offset);
col_add_fstr(pinfo->cinfo, COL_INFO, "%s", val_to_str(operation, operationTypes, "Unknown (0x%02x)"));
offset += 1;
proto_tree_add_item(hcast_tree, hf_hazelcast_operation, tvb, offset, 1, ENC_BIG_ENDIAN);
operation = tvb_get_guint8(tvb, offset);
col_add_fstr(pinfo->cinfo, COL_INFO, "%s", val_to_str(operation, operationTypes, "Unknown (0x%02x)"));
offset += 1;
proto_tree_add_item(hcast_tree, hf_hazelcast_blockID, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
proto_tree_add_item(hcast_tree, hf_hazelcast_threadID, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
proto_tree_add_item(hcast_tree, hf_hazelcast_blockID, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
proto_tree_add_item(hcast_tree, hf_hazelcast_threadID, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
flags = tvb_get_guint8(tvb, offset);
flags = tvb_get_guint8(tvb, offset);
tf = proto_tree_add_item(hcast_tree, hf_hazelcast_flags, tvb, offset, 1, ENC_BIG_ENDIAN);
tf = proto_tree_add_item(hcast_tree, hf_hazelcast_flags, tvb, offset, 1, ENC_BIG_ENDIAN);
flag_tree = proto_item_add_subtree(tf, ett_hazelcast_flags);
flag_tree = proto_item_add_subtree(tf, ett_hazelcast_flags);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_lockCount, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_timeout, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_ttl, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_txn, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_longValue, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_version, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_client, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_lockAddrNull, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_lockCount, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_timeout, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_ttl, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_txn, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_longValue, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_version, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_client, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flag_tree, hf_hazelcast_flags_lockAddrNull, tvb, offset, 1, ENC_BIG_ENDIAN);
lockCountFlag = flags & HAZELCAST_LOCKCOUNT_FLAG;
timeoutFlag = flags & HAZELCAST_TIMEOUT_FLAG;
ttlFlag = flags & HAZELCAST_TTL_FLAG;
txnFlag = flags & HAZELCAST_TXN_FLAG;
longValueFlag = flags & HAZELCAST_LONGVALUE_FLAG;
versionFlag = flags & HAZELCAST_VERSION_FLAG;
lockAddrNullFlag = flags & HAZELCAST_LOCKADDRNULL_FLAG;
lockCountFlag = flags & HAZELCAST_LOCKCOUNT_FLAG;
timeoutFlag = flags & HAZELCAST_TIMEOUT_FLAG;
ttlFlag = flags & HAZELCAST_TTL_FLAG;
txnFlag = flags & HAZELCAST_TXN_FLAG;
longValueFlag = flags & HAZELCAST_LONGVALUE_FLAG;
versionFlag = flags & HAZELCAST_VERSION_FLAG;
lockAddrNullFlag = flags & HAZELCAST_LOCKADDRNULL_FLAG;
offset += 1;
offset += 1;
if ( lockCountFlag ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_lockCount, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
}
if ( lockCountFlag ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_lockCount, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
}
if ( timeoutFlag ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_timeout, tvb, offset, 8, ENC_BIG_ENDIAN);
offset += 8;
}
if ( timeoutFlag ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_timeout, tvb, offset, 8, ENC_BIG_ENDIAN);
offset += 8;
}
if ( ttlFlag ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_ttl, tvb, offset, 8, ENC_BIG_ENDIAN);
offset += 8;
}
if ( ttlFlag ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_ttl, tvb, offset, 8, ENC_BIG_ENDIAN);
offset += 8;
}
if ( txnFlag ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_txnID, tvb, offset, 8, ENC_BIG_ENDIAN);
offset += 8;
}
if ( txnFlag ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_txnID, tvb, offset, 8, ENC_BIG_ENDIAN);
offset += 8;
}
if ( longValueFlag ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_longValue, tvb, offset, 8, ENC_BIG_ENDIAN);
offset += 8;
}
if ( longValueFlag ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_longValue, tvb, offset, 8, ENC_BIG_ENDIAN);
offset += 8;
}
if ( versionFlag ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_version, tvb, offset, 8, ENC_BIG_ENDIAN);
offset += 8;
}
if ( versionFlag ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_version, tvb, offset, 8, ENC_BIG_ENDIAN);
offset += 8;
}
if ( lockAddrNullFlag == 0 ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_lockAddrIP, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
proto_tree_add_item(hcast_tree, hf_hazelcast_lockAddrPort, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
}
if ( lockAddrNullFlag == 0 ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_lockAddrIP, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
proto_tree_add_item(hcast_tree, hf_hazelcast_lockAddrPort, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
}
proto_tree_add_item(hcast_tree, hf_hazelcast_callID, tvb, offset, 8, ENC_BIG_ENDIAN);
offset += 8;
proto_tree_add_item(hcast_tree, hf_hazelcast_callID, tvb, offset, 8, ENC_BIG_ENDIAN);
offset += 8;
proto_tree_add_item(hcast_tree, hf_hazelcast_responseType, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
proto_tree_add_item(hcast_tree, hf_hazelcast_responseType, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
proto_tree_add_item(hcast_tree, hf_hazelcast_nameLength, tvb, offset, 4, ENC_BIG_ENDIAN);
nameLength = tvb_get_ntohl(tvb, offset);
offset += 4;
proto_tree_add_item(hcast_tree, hf_hazelcast_nameLength, tvb, offset, 4, ENC_BIG_ENDIAN);
nameLength = tvb_get_ntohl(tvb, offset);
offset += 4;
if ( nameLength > 0 ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_name, tvb, offset, nameLength, ENC_ASCII);
offset += nameLength;
}
if ( nameLength > 0 ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_name, tvb, offset, nameLength, ENC_ASCII);
offset += nameLength;
}
proto_tree_add_item(hcast_tree, hf_hazelcast_indexCount, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
proto_tree_add_item(hcast_tree, hf_hazelcast_indexCount, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
proto_tree_add_item(hcast_tree, hf_hazelcast_keyPartitionHash, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
proto_tree_add_item(hcast_tree, hf_hazelcast_keyPartitionHash, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
proto_tree_add_item(hcast_tree, hf_hazelcast_valuePartitionHash, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
proto_tree_add_item(hcast_tree, hf_hazelcast_valuePartitionHash, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
if ( keyLength > 0 ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_keys, tvb, offset, keyLength, ENC_NA);
offset += keyLength;
}
if ( keyLength > 0 ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_keys, tvb, offset, keyLength, ENC_NA);
offset += keyLength;
}
if ( valueLength > 0 ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_values, tvb, offset, valueLength, ENC_NA);
/*offset += valueLength;*/
}
if ( valueLength > 0 ) {
proto_tree_add_item(hcast_tree, hf_hazelcast_values, tvb, offset, valueLength, ENC_NA);
/*offset += valueLength;*/
}
return tvb_length(tvb);
return tvb_length(tvb);
}
/*
@ -430,171 +430,171 @@ static int dissect_hazelcast_message(tvbuff_t *tvb, packet_info *pinfo _U_, prot
*
* this really just works in TCP reassembly and calls the real dissector
*
*/
*/
static int dissect_hazelcast(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data) {
tcp_dissect_pdus(tvb, pinfo, tree, hazelcast_desegment, 13, get_hazelcast_message_len, dissect_hazelcast_message, data);
return tvb_length(tvb);
tcp_dissect_pdus(tvb, pinfo, tree, hazelcast_desegment, 13, get_hazelcast_message_len, dissect_hazelcast_message, data);
return tvb_length(tvb);
}
void proto_register_hazelcast(void) {
static hf_register_info hf[] = {
static hf_register_info hf[] = {
{ &hf_hazelcast_headerLength,
{ "Hazelcast hdr length", "hazelcast.hdr.length", FT_UINT32, BASE_DEC, NULL, 0x0, "header length", HFILL }
},
{ &hf_hazelcast_headerKeyLength,
{ "Hazelcast hdr key length", "hazelcast.hdr.keylength", FT_UINT32, BASE_DEC, NULL, 0x0, "header key length", HFILL }
},
{ &hf_hazelcast_headerValueLength,
{ "Hazelcast hdr value length", "hazelcast.hdr.valuelength", FT_UINT32, BASE_DEC, NULL, 0x0, "header value length", HFILL }
},
{ &hf_hazelcast_headerVersion,
{ "Hazelcast hdr version", "hazelcast.hdr.version", FT_UINT8, BASE_DEC, NULL, 0x0, "header version", HFILL }
},
{ &hf_hazelcast_operation,
{ "Hazelcast operation", "hazelcast.operation", FT_UINT8, BASE_DEC|BASE_EXT_STRING, &operationTypes_ext, 0x0, "operation", HFILL }
},
{ &hf_hazelcast_blockID,
{ "Hazelcast blockID", "hazelcast.blockID", FT_UINT32, BASE_HEX, NULL, 0x0, "blockID", HFILL }
},
{ &hf_hazelcast_threadID,
{ "Hazelcast threadID", "hazelcast.threadID", FT_UINT32, BASE_DEC, NULL, 0x0, "threadID", HFILL }
},
{ &hf_hazelcast_flags,
{ "hazelcast flags", "hazelcast.flags", FT_UINT32, BASE_HEX, NULL, 0x0, "flags", HFILL }
},
{ &hf_hazelcast_flags_lockCount,
{ "hazelcast lockCount flag", "hazelcast.flags.lockCount", FT_BOOLEAN, 8, NULL, HAZELCAST_LOCKCOUNT_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_flags_timeout,
{ "hazelcast timeout flag", "hazelcast.flags.timeout", FT_BOOLEAN, 8, NULL, HAZELCAST_TIMEOUT_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_flags_ttl,
{ "hazelcast ttl flag", "hazelcast.flags.ttl", FT_BOOLEAN, 8, NULL, HAZELCAST_TTL_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_flags_txn,
{ "hazelcast txn flag", "hazelcast.flags.txn", FT_BOOLEAN, 8, NULL, HAZELCAST_TXN_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_flags_longValue,
{ "hazelcast longValue flag", "hazelcast.flags.longValue", FT_BOOLEAN, 8, NULL, HAZELCAST_LONGVALUE_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_flags_version,
{ "hazelcast version flag", "hazelcast.flags.version", FT_BOOLEAN, 8, NULL, HAZELCAST_VERSION_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_flags_client,
{ "hazelcast client flag", "hazelcast.flags.client", FT_BOOLEAN, 8, NULL, HAZELCAST_CLIENT_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_flags_lockAddrNull,
{ "hazelcast lockAddrNull flag", "hazelcast.flags.lockAddrNull", FT_BOOLEAN, 8, NULL, HAZELCAST_LOCKADDRNULL_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_timeout,
{ "hazelcast timeout", "hazelcast.timeout", FT_UINT64, BASE_DEC, NULL, 0x0, "timeout", HFILL }
},
{ &hf_hazelcast_ttl,
{ "hazelcast ttl", "hazelcast.ttl", FT_UINT64, BASE_DEC, NULL, 0x0, "ttl", HFILL }
},
{ &hf_hazelcast_longValue,
{ "hazelcast longValue", "hazelcast.longValue", FT_UINT64, BASE_DEC, NULL, 0x0, "longValue", HFILL }
},
{ &hf_hazelcast_txnID,
{ "hazelcast txnID", "hazelcast.txnID", FT_UINT64, BASE_DEC, NULL, 0x0, "txnID", HFILL }
},
{ &hf_hazelcast_version,
{ "hazelcast version", "hazelcast.version", FT_UINT64, BASE_DEC, NULL, 0x0, "version", HFILL }
},
{ &hf_hazelcast_lockCount,
{ "hazelcast lockCount", "hazelcast.lockCount", FT_UINT32, BASE_DEC, NULL, 0x0, "lockCount", HFILL }
},
{ &hf_hazelcast_lockAddrIP,
{ "hazelcast lock address IP", "hazelcast.lockaddr.ip", FT_IPv4, BASE_NONE, NULL, 0x0, "lockAddrIP", HFILL }
},
{ &hf_hazelcast_lockAddrPort,
{ "hazelcast lock address Port", "hazelcast.lockaddr.port", FT_UINT32, BASE_DEC, NULL, 0x0, "lockAddrPort", HFILL }
},
{ &hf_hazelcast_callID,
{ "hazelcast callID", "hazelcast.callID", FT_INT64, BASE_DEC, NULL, 0x0, "callID", HFILL }
},
{ &hf_hazelcast_responseType,
{ "hazelcast response type", "hazelcast.responseType", FT_UINT8, BASE_DEC|BASE_EXT_STRING, &responseTypes_ext, 0x0, "responseType", HFILL }
},
{ &hf_hazelcast_nameLength,
{ "hazelcast name length", "hazelcast.nameLength", FT_UINT32, BASE_DEC, NULL, 0x0, "nameLength", HFILL }
},
{ &hf_hazelcast_name,
{ "hazelcast name", "hazelcast.name", FT_STRING, BASE_NONE, NULL, 0x0, "name", HFILL }
},
{ &hf_hazelcast_indexCount,
{ "hazelcast indexCount", "hazelcast.indexCount", FT_UINT8, BASE_DEC, NULL, 0x0, "indexCount", HFILL }
},
{ &hf_hazelcast_keyPartitionHash,
{ "hazelcast keyPartitionHash", "hazelcast.keyPartitionHash", FT_UINT32, BASE_HEX, NULL, 0x0, "keyPartitionHash", HFILL }
},
{ &hf_hazelcast_valuePartitionHash,
{ "hazelcast valuePartitionHash", "hazelcast.valuePartitionHash", FT_UINT32, BASE_HEX, NULL, 0x0, "valuePartitionHash", HFILL }
},
{ &hf_hazelcast_keys,
{ "hazelcast keys", "hazelcast.keys", FT_BYTES, BASE_NONE, NULL, 0x0, "keys", HFILL }
},
{ &hf_hazelcast_values,
{ "hazelcast values", "hazelcast.values", FT_BYTES, BASE_NONE, NULL, 0x0, "values", HFILL }
}
{ &hf_hazelcast_headerLength,
{ "Hazelcast hdr length", "hazelcast.hdr.length", FT_UINT32, BASE_DEC, NULL, 0x0, "header length", HFILL }
},
{ &hf_hazelcast_headerKeyLength,
{ "Hazelcast hdr key length", "hazelcast.hdr.keylength", FT_UINT32, BASE_DEC, NULL, 0x0, "header key length", HFILL }
},
{ &hf_hazelcast_headerValueLength,
{ "Hazelcast hdr value length", "hazelcast.hdr.valuelength", FT_UINT32, BASE_DEC, NULL, 0x0, "header value length", HFILL }
},
{ &hf_hazelcast_headerVersion,
{ "Hazelcast hdr version", "hazelcast.hdr.version", FT_UINT8, BASE_DEC, NULL, 0x0, "header version", HFILL }
},
{ &hf_hazelcast_operation,
{ "Hazelcast operation", "hazelcast.operation", FT_UINT8, BASE_DEC|BASE_EXT_STRING, &operationTypes_ext, 0x0, "operation", HFILL }
},
{ &hf_hazelcast_blockID,
{ "Hazelcast blockID", "hazelcast.blockID", FT_UINT32, BASE_HEX, NULL, 0x0, "blockID", HFILL }
},
{ &hf_hazelcast_threadID,
{ "Hazelcast threadID", "hazelcast.threadID", FT_UINT32, BASE_DEC, NULL, 0x0, "threadID", HFILL }
},
{ &hf_hazelcast_flags,
{ "hazelcast flags", "hazelcast.flags", FT_UINT32, BASE_HEX, NULL, 0x0, "flags", HFILL }
},
{ &hf_hazelcast_flags_lockCount,
{ "hazelcast lockCount flag", "hazelcast.flags.lockCount", FT_BOOLEAN, 8, NULL, HAZELCAST_LOCKCOUNT_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_flags_timeout,
{ "hazelcast timeout flag", "hazelcast.flags.timeout", FT_BOOLEAN, 8, NULL, HAZELCAST_TIMEOUT_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_flags_ttl,
{ "hazelcast ttl flag", "hazelcast.flags.ttl", FT_BOOLEAN, 8, NULL, HAZELCAST_TTL_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_flags_txn,
{ "hazelcast txn flag", "hazelcast.flags.txn", FT_BOOLEAN, 8, NULL, HAZELCAST_TXN_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_flags_longValue,
{ "hazelcast longValue flag", "hazelcast.flags.longValue", FT_BOOLEAN, 8, NULL, HAZELCAST_LONGVALUE_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_flags_version,
{ "hazelcast version flag", "hazelcast.flags.version", FT_BOOLEAN, 8, NULL, HAZELCAST_VERSION_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_flags_client,
{ "hazelcast client flag", "hazelcast.flags.client", FT_BOOLEAN, 8, NULL, HAZELCAST_CLIENT_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_flags_lockAddrNull,
{ "hazelcast lockAddrNull flag", "hazelcast.flags.lockAddrNull", FT_BOOLEAN, 8, NULL, HAZELCAST_LOCKADDRNULL_FLAG, NULL, HFILL }
},
{ &hf_hazelcast_timeout,
{ "hazelcast timeout", "hazelcast.timeout", FT_UINT64, BASE_DEC, NULL, 0x0, "timeout", HFILL }
},
{ &hf_hazelcast_ttl,
{ "hazelcast ttl", "hazelcast.ttl", FT_UINT64, BASE_DEC, NULL, 0x0, "ttl", HFILL }
},
{ &hf_hazelcast_longValue,
{ "hazelcast longValue", "hazelcast.longValue", FT_UINT64, BASE_DEC, NULL, 0x0, "longValue", HFILL }
},
{ &hf_hazelcast_txnID,
{ "hazelcast txnID", "hazelcast.txnID", FT_UINT64, BASE_DEC, NULL, 0x0, "txnID", HFILL }
},
{ &hf_hazelcast_version,
{ "hazelcast version", "hazelcast.version", FT_UINT64, BASE_DEC, NULL, 0x0, "version", HFILL }
},
{ &hf_hazelcast_lockCount,
{ "hazelcast lockCount", "hazelcast.lockCount", FT_UINT32, BASE_DEC, NULL, 0x0, "lockCount", HFILL }
},
{ &hf_hazelcast_lockAddrIP,
{ "hazelcast lock address IP", "hazelcast.lockaddr.ip", FT_IPv4, BASE_NONE, NULL, 0x0, "lockAddrIP", HFILL }
},
{ &hf_hazelcast_lockAddrPort,
{ "hazelcast lock address Port", "hazelcast.lockaddr.port", FT_UINT32, BASE_DEC, NULL, 0x0, "lockAddrPort", HFILL }
},
{ &hf_hazelcast_callID,
{ "hazelcast callID", "hazelcast.callID", FT_INT64, BASE_DEC, NULL, 0x0, "callID", HFILL }
},
{ &hf_hazelcast_responseType,
{ "hazelcast response type", "hazelcast.responseType", FT_UINT8, BASE_DEC|BASE_EXT_STRING, &responseTypes_ext, 0x0, "responseType", HFILL }
},
{ &hf_hazelcast_nameLength,
{ "hazelcast name length", "hazelcast.nameLength", FT_UINT32, BASE_DEC, NULL, 0x0, "nameLength", HFILL }
},
{ &hf_hazelcast_name,
{ "hazelcast name", "hazelcast.name", FT_STRING, BASE_NONE, NULL, 0x0, "name", HFILL }
},
{ &hf_hazelcast_indexCount,
{ "hazelcast indexCount", "hazelcast.indexCount", FT_UINT8, BASE_DEC, NULL, 0x0, "indexCount", HFILL }
},
{ &hf_hazelcast_keyPartitionHash,
{ "hazelcast keyPartitionHash", "hazelcast.keyPartitionHash", FT_UINT32, BASE_HEX, NULL, 0x0, "keyPartitionHash", HFILL }
},
{ &hf_hazelcast_valuePartitionHash,
{ "hazelcast valuePartitionHash", "hazelcast.valuePartitionHash", FT_UINT32, BASE_HEX, NULL, 0x0, "valuePartitionHash", HFILL }
},
{ &hf_hazelcast_keys,
{ "hazelcast keys", "hazelcast.keys", FT_BYTES, BASE_NONE, NULL, 0x0, "keys", HFILL }
},
{ &hf_hazelcast_values,
{ "hazelcast values", "hazelcast.values", FT_BYTES, BASE_NONE, NULL, 0x0, "values", HFILL }
}
};
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_hazelcast,
&ett_hazelcast_flags
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_hazelcast,
&ett_hazelcast_flags
};
module_t *hazelcast_module;
module_t *hazelcast_module;
proto_hazelcast = proto_register_protocol (
"Hazelcast Wire Protocol", /* name */
"HAZELCAST", /* short name */
"hzlcst" /* abbrev */
);
proto_hazelcast = proto_register_protocol (
"Hazelcast Wire Protocol", /* name */
"HAZELCAST", /* short name */
"hzlcst" /* abbrev */
);
proto_register_field_array(proto_hazelcast, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
proto_register_field_array(proto_hazelcast, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
hazelcast_module = prefs_register_protocol(proto_hazelcast, NULL);
hazelcast_module = prefs_register_protocol(proto_hazelcast, NULL);
prefs_register_bool_preference(hazelcast_module, "desegment",
"Reassemble hazelcast messages spanning multiple TCP segments",
"Whether the hazel dissector should reassemble messages spanning multiple TCP segments."
" To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.",
&hazelcast_desegment);
prefs_register_bool_preference(hazelcast_module, "desegment",
"Reassemble hazelcast messages spanning multiple TCP segments",
"Whether the hazel dissector should reassemble messages spanning multiple TCP segments."
" To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.",
&hazelcast_desegment);
prefs_register_uint_preference(hazelcast_module, "tcp.port",
"Hazelcast TCP Port",
" Hazelcast TCP port if other than the default",
10,
&gPORT_PREF);
prefs_register_uint_preference(hazelcast_module, "tcp.port",
"Hazelcast TCP Port",
" Hazelcast TCP port if other than the default",
10,
&gPORT_PREF);
hazelcast_tap = register_tap("hzlcst");
hazelcast_tap = register_tap("hzlcst");
}
void
proto_reg_handoff_hazelcast(void) {
static gboolean initialized = FALSE;
static dissector_handle_t hazelcast_handle;
static int currentPort;
static gboolean initialized = FALSE;
static dissector_handle_t hazelcast_handle;
static int currentPort;
if (!initialized) {
hazelcast_handle = new_create_dissector_handle(dissect_hazelcast, proto_hazelcast);
initialized = TRUE;
} else {
dissector_delete_uint("tcp.port", currentPort, hazelcast_handle);
}
if (!initialized) {
hazelcast_handle = new_create_dissector_handle(dissect_hazelcast, proto_hazelcast);
initialized = TRUE;
} else {
dissector_delete_uint("tcp.port", currentPort, hazelcast_handle);
}
currentPort = gPORT_PREF;
dissector_add_uint("tcp.port", currentPort, hazelcast_handle);
currentPort = gPORT_PREF;
dissector_add_uint("tcp.port", currentPort, hazelcast_handle);
}
/*

46
epan/dissectors/packet-ieee80211.c
View File

@ -8681,17 +8681,17 @@ enum vs_nintendo_type {
};
static const value_string ieee80211_vs_nintendo_type_vals[] = {
{ NINTENDO_SERVICES, "Services"},
{ NINTENDO_CONSOLEID, "ConsoleID"},
{ 0, NULL }
{ NINTENDO_SERVICES, "Services"},
{ NINTENDO_CONSOLEID, "ConsoleID"},
{ 0, NULL }
};
static proto_tree*
dissect_vendor_ie_nintendo_tlv(const int hfindex, proto_tree *ietree,
tvbuff_t *tvb, int offset, guint32 sublen)
{
proto_item *nintendo_item;
proto_tree *nintendo_tree;
proto_item *nintendo_item;
proto_tree *nintendo_tree;
nintendo_item = proto_tree_add_item(ietree, hfindex, tvb, offset, sublen, ENC_NA);
nintendo_tree = proto_item_add_subtree(nintendo_item, ett_nintendo);
@ -8706,11 +8706,11 @@ static void
dissect_vendor_ie_nintendo(proto_item *item _U_, proto_tree *ietree,
tvbuff_t *tvb, int offset, guint32 tag_len)
{
proto_tree *nintendo_tree;
proto_tree *nintendo_tree;
guint8 subtype;
guint8 sublength;
guint32 length = tag_len;
guint8 subtype;
guint8 sublength;
guint32 length = tag_len;
/* Skip OUI type for now - the code is for type 1 (StreetPass) only */
/* http://3dbrew.org/wiki/StreetPass */
@ -12951,26 +12951,26 @@ add_tagged_field(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, int offset
case TAG_MESH_CONFIGURATION:
{
proto_item *item;
proto_tree *subtree;
proto_item *item;
proto_tree *subtree;
offset += 2;
proto_tree_add_item (tree, hf_ieee80211_mesh_config_path_sel_protocol, tvb, offset, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (tree, hf_ieee80211_mesh_config_path_sel_metric, tvb, offset + 1, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (tree, hf_ieee80211_mesh_config_congestion_control, tvb, offset + 2, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (tree, hf_ieee80211_mesh_config_sync_method, tvb, offset + 3, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (tree, hf_ieee80211_mesh_config_auth_protocol, tvb, offset + 4, 1, ENC_LITTLE_ENDIAN);
item = proto_tree_add_item (tree, hf_ieee80211_mesh_config_formation_info, tvb, offset + 5, 1, ENC_LITTLE_ENDIAN);
subtree = proto_item_add_subtree(item, ett_mesh_formation_info_tree);
proto_tree_add_item (subtree, hf_ieee80211_mesh_form_info_num_of_peerings, tvb, offset + 5, 1, ENC_LITTLE_ENDIAN);
item = proto_tree_add_item (tree, hf_ieee80211_mesh_config_capability, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
subtree = proto_item_add_subtree(item, ett_mesh_config_cap_tree);
proto_tree_add_item (subtree, hf_ieee80211_mesh_config_cap_accepting, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (subtree, hf_ieee80211_mesh_config_cap_mcca_support, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (subtree, hf_ieee80211_mesh_config_cap_mcca_enabled, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (subtree, hf_ieee80211_mesh_config_cap_forwarding, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (subtree, hf_ieee80211_mesh_config_cap_mbca_enabled, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (subtree, hf_ieee80211_mesh_config_cap_tbtt_adjusting, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (subtree, hf_ieee80211_mesh_config_cap_power_save_level, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
item = proto_tree_add_item (tree, hf_ieee80211_mesh_config_formation_info, tvb, offset + 5, 1, ENC_LITTLE_ENDIAN);
subtree = proto_item_add_subtree(item, ett_mesh_formation_info_tree);
proto_tree_add_item (subtree, hf_ieee80211_mesh_form_info_num_of_peerings, tvb, offset + 5, 1, ENC_LITTLE_ENDIAN);
item = proto_tree_add_item (tree, hf_ieee80211_mesh_config_capability, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
subtree = proto_item_add_subtree(item, ett_mesh_config_cap_tree);
proto_tree_add_item (subtree, hf_ieee80211_mesh_config_cap_accepting, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (subtree, hf_ieee80211_mesh_config_cap_mcca_support, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (subtree, hf_ieee80211_mesh_config_cap_mcca_enabled, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (subtree, hf_ieee80211_mesh_config_cap_forwarding, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (subtree, hf_ieee80211_mesh_config_cap_mbca_enabled, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (subtree, hf_ieee80211_mesh_config_cap_tbtt_adjusting, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item (subtree, hf_ieee80211_mesh_config_cap_power_save_level, tvb, offset + 6, 1, ENC_LITTLE_ENDIAN);
break;
}

576
epan/dissectors/packet-isup.c
View File

@ -3859,12 +3859,12 @@ dissect_isup_range_and_status_parameter(tvbuff_t *parameter_tvb, proto_tree *par
actual_status_length = tvb_reported_length_remaining(parameter_tvb, offset);
if (actual_status_length > 0) {
item = proto_tree_add_text(parameter_tree, parameter_tvb , offset, -1, "Status subfield");
range_tree = proto_item_add_subtree(item, ett_isup_range);
if (range<9) {
proto_tree_add_text(range_tree, parameter_tvb , offset, 1, "Bit %u %s bit 1",
range,
decode_bits_in_field(8-range, range, tvb_get_guint8(parameter_tvb, offset)));
}
range_tree = proto_item_add_subtree(item, ett_isup_range);
if (range<9) {
proto_tree_add_text(range_tree, parameter_tvb , offset, 1, "Bit %u %s bit 1",
range,
decode_bits_in_field(8-range, range, tvb_get_guint8(parameter_tvb, offset)));
}
} else {
proto_tree_add_text(parameter_tree, parameter_tvb , 0, 0, "Status subfield is not present with this message type");
}
@ -5808,7 +5808,7 @@ dissect_isup_generic_notification_indicator_parameter(tvbuff_t *parameter_tvb, p
proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(parameter_tree, hf_isup_notification_indicator, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
proto_item_set_text(parameter_item, "Generic notification indicator: %s",
val_to_str_ext((indicators&0x7f), &q763_generic_notification_indicator_vals_ext, "Reserved (0x%X)"));
val_to_str_ext((indicators&0x7f), &q763_generic_notification_indicator_vals_ext, "Reserved (0x%X)"));
}
/* ------------------------------------------------------------------
Dissector Parameter Call history information
@ -7046,22 +7046,22 @@ dissect_isup_unknown_parameter(tvbuff_t *parameter_tvb, proto_item *parameter_it
static void
dissect_japan_isup_called_dir_num(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
int offset = 0;
int parameter_length;
int offset = 0;
int parameter_length;
parameter_length = tvb_length_remaining(parameter_tvb, offset);
parameter_length = tvb_length_remaining(parameter_tvb, offset);
proto_tree_add_item(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(parameter_tree, hf_isup_called_party_nature_of_address_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
proto_tree_add_item(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(parameter_tree, hf_isup_called_party_nature_of_address_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
proto_tree_add_item(parameter_tree, hf_isup_inn_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
proto_tree_add_item(parameter_tree, hf_isup_inn_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
proto_tree_add_text(parameter_tree, parameter_tvb, offset, parameter_length-offset, "Number not dissected yet");
proto_tree_add_text(parameter_tree, parameter_tvb, offset, parameter_length-offset, "Number not dissected yet");
proto_item_set_text(parameter_item, "Called Directory Number");
proto_item_set_text(parameter_item, "Called Directory Number");
}
@ -7423,15 +7423,15 @@ dissect_japan_isup_network_poi_cad(tvbuff_t *parameter_tvb, proto_tree *paramete
}
static const range_string jpn_isup_add_user_cat_type_vals[] = {
{ 0, 0, "Spare" },
{ 1, 0x80, "Reserved for network specific use" },
{ 0x81, 0xfa, "Spare" },
{ 0xfb, 0xfb, "Type 3 of additional mobile service information" },
{ 0xfc, 0xfc, "Type 2 of additional mobile service information" },
{ 0xfd, 0xfd, "Type 1 of additional mobile service information" },
{ 0xfe, 0xfe, "Type 1 of additional fixed service information" },
{ 0xff, 0xff, "Spare" },
{ 0, 0, NULL } };
{ 0, 0, "Spare" },
{ 1, 0x80, "Reserved for network specific use" },
{ 0x81, 0xfa, "Spare" },
{ 0xfb, 0xfb, "Type 3 of additional mobile service information" },
{ 0xfc, 0xfc, "Type 2 of additional mobile service information" },
{ 0xfd, 0xfd, "Type 1 of additional mobile service information" },
{ 0xfe, 0xfe, "Type 1 of additional fixed service information" },
{ 0xff, 0xff, "Spare" },
{ 0, 0, NULL } };
static const value_string jpn_isup_type_1_add_fixed_serv_inf_vals[] = {
{ 0, "Spare" },
@ -7798,13 +7798,13 @@ dissect_japan_isup_carrier_information(tvbuff_t *parameter_tvb, proto_tree *para
static const range_string japan_isup_charge_delay_type_value[] = {
{ 0, 0, "Spare" },
{ 1, 0xfc, "Reserved for network specific use" },
{ 0x81, 0xfa, "Spare" },
{ 0xfd, 0xfd, "Charge rate transfer" },
{ 0xfe, 0xfe, "Terminating charge area information" },
{ 0xff, 0xff, "Spare" },
{ 0, 0, NULL } };
{ 0, 0, "Spare" },
{ 1, 0xfc, "Reserved for network specific use" },
{ 0x81, 0xfa, "Spare" },
{ 0xfd, 0xfd, "Charge rate transfer" },
{ 0xfe, 0xfe, "Terminating charge area information" },
{ 0xff, 0xff, "Spare" },
{ 0, 0, NULL } };
static void
dissect_japan_isup_charge_inf_delay(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
@ -9919,9 +9919,9 @@ dissect_japan_chg_inf(tvbuff_t *message_tvb, proto_tree *isup_tree)
parameter_type,
val_to_str_ext_const(parameter_type, &japan_isup_parameter_type_value_ext, "unknown"));
proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
PARAMETER_POINTER_LENGTH, parameter_pointer);
PARAMETER_POINTER_LENGTH, parameter_pointer);
proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
PARAMETER_LENGTH_IND_LENGTH, parameter_length);
PARAMETER_LENGTH_IND_LENGTH, parameter_length);
actual_length = tvb_ensure_length_remaining(message_tvb, offset);
parameter_tvb = tvb_new_subset(message_tvb,
offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
@ -9930,17 +9930,17 @@ dissect_japan_chg_inf(tvbuff_t *message_tvb, proto_tree *isup_tree)
/* TODO: Dissect the parameter here, switch on type */
switch (chg_inf_type) {
case 3:
/* Advanced Charge Rate Transfer (TDS service) */
dissect_japan_chg_inf_type_acr(parameter_tvb, parameter_tree, parameter_item);
break;
case 254:
/* Charge rate transfer (flexible charging) */
dissect_japan_chg_inf_type_crt(parameter_tvb, parameter_tree, parameter_item);
break;
default:
case 3:
/* Advanced Charge Rate Transfer (TDS service) */
dissect_japan_chg_inf_type_acr(parameter_tvb, parameter_tree, parameter_item);
break;
case 254:
/* Charge rate transfer (flexible charging) */
dissect_japan_chg_inf_type_crt(parameter_tvb, parameter_tree, parameter_item);
break;
default:
proto_tree_add_text(parameter_tree, parameter_tvb, 0, -1, "Charge information data, not dissected yet");
break;
break;
}
@ -9963,7 +9963,7 @@ dissect_ansi_isup_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree
gint offset, bufferlength;
guint8 message_type, opt_parameter_pointer;
gint opt_part_possible = FALSE; /* default setting - for message types allowing optional
params explicitely set to TRUE in case statement */
params explicitely set to TRUE in case statement */
tap_calling_number = NULL;
offset = 0;
@ -9971,254 +9971,254 @@ dissect_ansi_isup_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree
message_type = tvb_get_guint8(message_tvb, 0);
proto_tree_add_uint_format(isup_tree, hf_isup_message_type, message_tvb, 0, MESSAGE_TYPE_LENGTH, message_type, "Message type: %s (%u)",
val_to_str_ext_const(message_type, &ansi_isup_message_type_value_ext, "reserved"), message_type);
val_to_str_ext_const(message_type, &ansi_isup_message_type_value_ext, "reserved"), message_type);
offset += MESSAGE_TYPE_LENGTH;
tap_rec = (isup_tap_rec_t *)wmem_alloc(wmem_packet_scope(), sizeof(isup_tap_rec_t));
tap_rec->message_type = message_type;
tap_rec->calling_number = NULL;
tap_rec->called_number = NULL;
tap_rec = (isup_tap_rec_t *)wmem_alloc(wmem_packet_scope(), sizeof(isup_tap_rec_t));
tap_rec->message_type = message_type;
tap_rec->calling_number = NULL;
tap_rec->called_number = NULL;
parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);
parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);
/* distinguish between message types:*/
switch (message_type) {
case MESSAGE_TYPE_INITIAL_ADDR:
offset += dissect_isup_initial_address_message(parameter_tvb, isup_tree, itu_isup_variant);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_SUBSEQ_ADDR:
offset += dissect_isup_subsequent_address_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_INFO_REQ:
offset += dissect_isup_information_request_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_INFO:
offset += dissect_isup_information_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_CONTINUITY:
offset += dissect_isup_continuity_message(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_ADDR_CMPL:
offset += dissect_isup_address_complete_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_CONNECT:
offset += dissect_isup_connect_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_FORW_TRANS:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_ANSWER:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_RELEASE:
offset += dissect_isup_release_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_SUSPEND:
offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_RESUME:
offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_REL_CMPL:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_CONT_CHECK_REQ:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_RESET_CIRCUIT:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_BLOCKING:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_UNBLOCKING:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_BLOCK_ACK:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_UNBLOCK_ACK:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_CIRC_GRP_RST:
offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_CIRC_GRP_BLCK:
offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_CIRC_GRP_UNBL:
offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_CIRC_GRP_BL_ACK:
offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_CIRC_GRP_UNBL_ACK:
offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_FACILITY_REQ:
offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_FACILITY_ACC:
offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_FACILITY_REJ:
offset += dissect_isup_facility_reject_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_LOOP_BACK_ACK:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_PASS_ALONG:
/* call dissect_isup_message recursively */
{
guint8 pa_message_type;
pa_message_type = tvb_get_guint8(parameter_tvb, 0);
pass_along_item = proto_tree_add_text(isup_tree, parameter_tvb, offset, -1,
"Pass-along: %s Message (%u)",
val_to_str_ext_const(pa_message_type, &isup_message_type_value_acro_ext, "reserved"),
pa_message_type);
pass_along_tree = proto_item_add_subtree(pass_along_item, ett_isup_pass_along_message);
dissect_ansi_isup_message(parameter_tvb, pinfo, pass_along_tree, itu_isup_variant);
break;
}
case MESSAGE_TYPE_CIRC_GRP_RST_ACK:
offset += dissect_isup_circuit_group_reset_acknowledgement_message(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_CIRC_GRP_QRY:
offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_CIRC_GRP_QRY_RSP:
offset += dissect_isup_circuit_group_query_response_message(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_CALL_PROGRSS:
offset += dissect_isup_call_progress_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_USER2USER_INFO:
offset += dissect_isup_user_to_user_information_message(parameter_tvb, pinfo, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_UNEQUIPPED_CIC:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_CONFUSION:
offset += dissect_isup_confusion_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_OVERLOAD:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_CHARGE_INFO:
/* do nothing since format is a national matter */
bufferlength = tvb_length_remaining(message_tvb, offset);
if (bufferlength != 0)
proto_tree_add_text(isup_tree, parameter_tvb, 0, bufferlength, "Format is a national matter");
break;
case MESSAGE_TYPE_NETW_RESRC_MGMT:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_FACILITY:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_USER_PART_TEST:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_USER_PART_AVAIL:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_IDENT_REQ:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_IDENT_RSP:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_SEGMENTATION:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_LOOP_PREVENTION:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_APPLICATION_TRANS:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_PRE_RELEASE_INFO:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_SUBSEQUENT_DIR_NUM:
/* do nothing since format is a national matter */
bufferlength = tvb_length_remaining(message_tvb, offset);
if (bufferlength != 0)
proto_tree_add_text(isup_tree, parameter_tvb, 0, bufferlength, "Format is a national matter");
break;
case ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES_ACK:
/* no dissector necessary since no mandatory parameters included */
break;
case ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES:
offset += dissect_ansi_isup_circuit_reservation_message(parameter_tvb, isup_tree);
break;
case ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST_RSP:
opt_part_possible = TRUE;
offset += dissect_ansi_isup_circuit_validation_test_resp_message(parameter_tvb, isup_tree);
break;
case ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST:
/* no dissector necessary since no mandatory parameters included */
break;
default:
bufferlength = tvb_length_remaining(message_tvb, offset);
if (bufferlength != 0)
proto_tree_add_text(isup_tree, parameter_tvb, 0, bufferlength,
"Unknown Message type (possibly reserved/used in former ISUP version)");
break;
/* distinguish between message types:*/
switch (message_type) {
case MESSAGE_TYPE_INITIAL_ADDR:
offset += dissect_isup_initial_address_message(parameter_tvb, isup_tree, itu_isup_variant);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_SUBSEQ_ADDR:
offset += dissect_isup_subsequent_address_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_INFO_REQ:
offset += dissect_isup_information_request_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_INFO:
offset += dissect_isup_information_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_CONTINUITY:
offset += dissect_isup_continuity_message(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_ADDR_CMPL:
offset += dissect_isup_address_complete_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_CONNECT:
offset += dissect_isup_connect_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_FORW_TRANS:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_ANSWER:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_RELEASE:
offset += dissect_isup_release_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_SUSPEND:
offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_RESUME:
offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_REL_CMPL:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_CONT_CHECK_REQ:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_RESET_CIRCUIT:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_BLOCKING:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_UNBLOCKING:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_BLOCK_ACK:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_UNBLOCK_ACK:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_CIRC_GRP_RST:
offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_CIRC_GRP_BLCK:
offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_CIRC_GRP_UNBL:
offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_CIRC_GRP_BL_ACK:
offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_CIRC_GRP_UNBL_ACK:
offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_FACILITY_REQ:
offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_FACILITY_ACC:
offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_FACILITY_REJ:
offset += dissect_isup_facility_reject_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_LOOP_BACK_ACK:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_PASS_ALONG:
/* call dissect_isup_message recursively */
{
guint8 pa_message_type;
pa_message_type = tvb_get_guint8(parameter_tvb, 0);
pass_along_item = proto_tree_add_text(isup_tree, parameter_tvb, offset, -1,
"Pass-along: %s Message (%u)",
val_to_str_ext_const(pa_message_type, &isup_message_type_value_acro_ext, "reserved"),
pa_message_type);
pass_along_tree = proto_item_add_subtree(pass_along_item, ett_isup_pass_along_message);
dissect_ansi_isup_message(parameter_tvb, pinfo, pass_along_tree, itu_isup_variant);
break;
}
case MESSAGE_TYPE_CIRC_GRP_RST_ACK:
offset += dissect_isup_circuit_group_reset_acknowledgement_message(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_CIRC_GRP_QRY:
offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_CIRC_GRP_QRY_RSP:
offset += dissect_isup_circuit_group_query_response_message(parameter_tvb, isup_tree);
break;
case MESSAGE_TYPE_CALL_PROGRSS:
offset += dissect_isup_call_progress_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_USER2USER_INFO:
offset += dissect_isup_user_to_user_information_message(parameter_tvb, pinfo, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_UNEQUIPPED_CIC:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_CONFUSION:
offset += dissect_isup_confusion_message(parameter_tvb, isup_tree);
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_OVERLOAD:
/* no dissector necessary since no mandatory parameters included */
break;
case MESSAGE_TYPE_CHARGE_INFO:
/* do nothing since format is a national matter */
bufferlength = tvb_length_remaining(message_tvb, offset);
if (bufferlength != 0)
proto_tree_add_text(isup_tree, parameter_tvb, 0, bufferlength, "Format is a national matter");
break;
case MESSAGE_TYPE_NETW_RESRC_MGMT:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_FACILITY:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_USER_PART_TEST:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_USER_PART_AVAIL:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_IDENT_REQ:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_IDENT_RSP:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_SEGMENTATION:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_LOOP_PREVENTION:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_APPLICATION_TRANS:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_PRE_RELEASE_INFO:
/* no dissector necessary since no mandatory parameters included */
opt_part_possible = TRUE;
break;
case MESSAGE_TYPE_SUBSEQUENT_DIR_NUM:
/* do nothing since format is a national matter */
bufferlength = tvb_length_remaining(message_tvb, offset);
if (bufferlength != 0)
proto_tree_add_text(isup_tree, parameter_tvb, 0, bufferlength, "Format is a national matter");
break;
case ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES_ACK:
/* no dissector necessary since no mandatory parameters included */
break;
case ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES:
offset += dissect_ansi_isup_circuit_reservation_message(parameter_tvb, isup_tree);
break;
case ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST_RSP:
opt_part_possible = TRUE;
offset += dissect_ansi_isup_circuit_validation_test_resp_message(parameter_tvb, isup_tree);
break;
case ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST:
/* no dissector necessary since no mandatory parameters included */
break;
default:
bufferlength = tvb_length_remaining(message_tvb, offset);
if (bufferlength != 0)
proto_tree_add_text(isup_tree, parameter_tvb, 0, bufferlength,
"Unknown Message type (possibly reserved/used in former ISUP version)");
break;
}
/* extract pointer to start of optional part (if any) */
if (opt_part_possible == TRUE) {
opt_parameter_pointer = tvb_get_guint8(message_tvb, offset);
if (opt_parameter_pointer > 0) {
proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
"Pointer to start of optional part: %u", opt_parameter_pointer);
offset += opt_parameter_pointer;
optional_parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);
dissect_ansi_isup_optional_parameter(optional_parameter_tvb, pinfo, isup_tree, itu_isup_variant);
}
else
proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
"No optional parameter present (Pointer: %u)", opt_parameter_pointer);
}
else if (message_type != MESSAGE_TYPE_CHARGE_INFO)
proto_tree_add_text(isup_tree, message_tvb, 0, 0, "No optional parameters are possible with this message type");
/* extract pointer to start of optional part (if any) */
if (opt_part_possible == TRUE) {
opt_parameter_pointer = tvb_get_guint8(message_tvb, offset);
if (opt_parameter_pointer > 0) {
proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
"Pointer to start of optional part: %u", opt_parameter_pointer);
offset += opt_parameter_pointer;
optional_parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);
dissect_ansi_isup_optional_parameter(optional_parameter_tvb, pinfo, isup_tree, itu_isup_variant);
}
else
proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
"No optional parameter present (Pointer: %u)", opt_parameter_pointer);
}
else if (message_type != MESSAGE_TYPE_CHARGE_INFO)
proto_tree_add_text(isup_tree, message_tvb, 0, 0, "No optional parameters are possible with this message type");
/* if there are calling/called number, we'll get them for the tap */
tap_rec->calling_number = tap_calling_number ? tap_calling_number : wmem_strdup(wmem_packet_scope(), "");
tap_rec->called_number = tap_called_number;
tap_rec->cause_value = tap_cause_value;
tap_queue_packet(isup_tap, pinfo, tap_rec);
/* if there are calling/called number, we'll get them for the tap */
tap_rec->calling_number = tap_calling_number ? tap_calling_number : wmem_strdup(wmem_packet_scope(), "");
tap_rec->called_number = tap_called_number;
tap_rec->cause_value = tap_cause_value;
tap_queue_packet(isup_tap, pinfo, tap_rec);
}
static void
@ -12184,7 +12184,7 @@ proto_register_isup(void)
&ett_acs,
&ett_isup_apm_msg_fragment,
&ett_isup_apm_msg_fragments,
&ett_isup_range,
&ett_isup_range,
};
static const enum_val_t isup_variants[] = {

16
epan/dissectors/packet-kafka.c
View File

@ -267,14 +267,14 @@ dissect_kafka_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int s
if (raw) {
payload = tvb_child_uncompress(tvb, raw, 0, tvb_length(raw));
if (payload) {
add_new_data_source(pinfo, payload, "Uncompressed Message");
proto_tree_add_item(subtree, hf_kafka_message_value, payload, 0, -1, ENC_NA);
} else {
/* TODO make this an expert item */
proto_tree_add_text(subtree, tvb, 0, tvb_length(raw), "[Failed to decompress message!]");
proto_tree_add_item(subtree, hf_kafka_message_value, raw, 0, -1, ENC_NA);
}
if (payload) {
add_new_data_source(pinfo, payload, "Uncompressed Message");
proto_tree_add_item(subtree, hf_kafka_message_value, payload, 0, -1, ENC_NA);
} else {
/* TODO make this an expert item */
proto_tree_add_text(subtree, tvb, 0, tvb_length(raw), "[Failed to decompress message!]");
proto_tree_add_item(subtree, hf_kafka_message_value, raw, 0, -1, ENC_NA);
}
offset += tvb_length(raw);
}
else {

2
epan/dissectors/packet-knet.c
View File

@ -564,7 +564,7 @@ static int
dissect_knet_tcp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
dissect_knet(tvb, pinfo, tree, KNET_TCP_PACKET);
return tvb_length(tvb);
return tvb_length(tvb);
}
static int

12
epan/dissectors/packet-p_mul.c
View File

@ -278,9 +278,9 @@ static const gchar *get_type (guint8 value)
/*Function checksum, found in ACP142 annex B-3 */
static guint16 checksum (guint8 *buffer, gint len, gint offset)
{
guint16 c0 = 0, c1 = 0, ret, ctmp;
gint16 cs;
guint8 *hpp, *pls;
guint16 c0 = 0, c1 = 0, ret, ctmp;
gint16 cs;
guint8 *hpp, *pls;
if (len < offset+2) {
/* Buffer to small */
@ -1615,14 +1615,14 @@ void proto_register_p_mul (void)
void proto_reg_handoff_p_mul (void)
{
static gboolean p_mul_prefs_initialized = FALSE;
static range_t *p_mul_port_range;
static gboolean p_mul_prefs_initialized = FALSE;
static range_t *p_mul_port_range;
if (!p_mul_prefs_initialized) {
p_mul_prefs_initialized = TRUE;
data_handle = find_dissector ("data");
} else {
dissector_delete_uint_range ("udp.port", p_mul_port_range, p_mul_handle);
dissector_delete_uint_range ("udp.port", p_mul_port_range, p_mul_handle);
g_free (p_mul_port_range);
}

28
epan/dissectors/packet-ppp.c
View File

@ -3757,35 +3757,35 @@ dissect_vsncp_addressalloc_opt(const ip_tcp_opt *optp, tvbuff_t *tvb,
static void
dissect_vsncp_apn_ambr_opt(const ip_tcp_opt *optp, tvbuff_t *tvb,
int offset, guint length, packet_info *pinfo _U_, proto_tree *tree, void *data _U_)
int offset, guint length, packet_info *pinfo _U_, proto_tree *tree, void *data _U_)
{
proto_item *tf;
proto_tree *field_tree;
if (tree) {
if (tree) {
tf = proto_tree_add_text(tree, tvb, offset, length, "%s: (%d byte%s)",
optp->name, length, plurality(length, "", "s"));
field_tree = proto_item_add_subtree(tf, ett_lcp_options);
tf = proto_tree_add_text(tree, tvb, offset, length, "%s: (%d byte%s)",
optp->name, length, plurality(length, "", "s"));
field_tree = proto_item_add_subtree(tf, ett_lcp_options);
/*de_esm_apn_aggr_max_br(tvb, field_tree, pinfo, offset, length, NULL, 0);*/
proto_tree_add_text(field_tree, tvb, offset, length, "AMBR Data");
/*de_esm_apn_aggr_max_br(tvb, field_tree, pinfo, offset, length, NULL, 0);*/
proto_tree_add_text(field_tree, tvb, offset, length, "AMBR Data");
}
}
static void
dissect_vsncp_ipv6_hsgw_lla_iid_opt(const ip_tcp_opt *optp _U_, tvbuff_t *tvb,
int offset, guint length, packet_info *pinfo _U_, proto_tree *tree, void *data _U_)
int offset, guint length, packet_info *pinfo _U_, proto_tree *tree, void *data _U_)
{
proto_item *tf;
proto_tree *field_tree;
if (tree) {
tf = proto_tree_add_text(tree, tvb, offset, length, "%s: (%d byte%s)",
optp->name, length, plurality(length, "", "s"));
field_tree = proto_item_add_subtree(tf, ett_lcp_options);
if (tree) {
tf = proto_tree_add_text(tree, tvb, offset, length, "%s: (%d byte%s)",
optp->name, length, plurality(length, "", "s"));
field_tree = proto_item_add_subtree(tf, ett_lcp_options);
proto_tree_add_text(field_tree, tvb, offset, length, "IPv6 interface identifier");
proto_tree_add_text(field_tree, tvb, offset, length, "IPv6 interface identifier");
}
}
@ -4110,7 +4110,7 @@ dissect_vsncp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
val_to_str_const(code, cp_vals, "Unknown"), code);
proto_tree_add_text(fh_tree, tvb, 1, 1, "Identifier: 0x%02x", id);
proto_tree_add_text(fh_tree, tvb, 2, 2, "Length: %u", length);
proto_tree_add_item(fh_tree, hf_ppp_oui, tvb, 4, 3, ENC_BIG_ENDIAN);
proto_tree_add_item(fh_tree, hf_ppp_oui, tvb, 4, 3, ENC_BIG_ENDIAN);
}
offset = 7;