osmith
/
wireshark
forked from osmocom/wireshark
1
0
Fork 0
Code Pull Requests Releases Wiki Activity

Don't do any Decode As stuff for dissector tables not used with Decode As. 

Have all dissector tables have a "supports Decode As" flag, which
defaults to FALSE, and which is set to TRUE if a register_decode_as()
refers to it.

When adding a dissector to a dissector table with a given key, only add
it for Decode As if the dissector table supports it.

For non-FT_STRING dissector tables, always check for multiple entries
for the same protocol with different dissectors, and report an error if
we found them.

This means there's no need for the creator of a dissector table to
specify whether duplicates of that sort should be allowed - we always do
the check when registering something for "Decode As" (in a non-FT_STRING
dissector table), and just don't bother registering anything for "Decode
As" if the dissector table doesn't support "Decode As", so there's no
check done for those dissector tables.

Change-Id: I4a1fdea3bddc2af27a65cfbca23edc99b26c0eed
Reviewed-on: https://code.wireshark.org/review/17402
Petri-Dish: Guy Harris <guy@alum.mit.edu>
Reviewed-by: Guy Harris <guy@alum.mit.edu>
This commit is contained in:
Guy Harris 2016-08-30 15:51:54 -07:00
parent 1dbd2216ed
commit a4c8ebc18b
217 changed files with 520 additions and 516 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
debian/libwireshark0.symbols vendored
View File

@ -437,10 +437,10 @@ libwireshark.so.0 libwireshark0 #MINVER#
dissector_hostlist_init@Base 1.99.0 dissector_hostlist_init@Base 1.99.0
dissector_reset_string@Base 1.9.1 dissector_reset_string@Base 1.9.1
dissector_reset_uint@Base 1.9.1 dissector_reset_uint@Base 1.9.1
dissector_table_allow_decode_as@Base 2.3.0
dissector_table_foreach@Base 1.9.1 dissector_table_foreach@Base 1.9.1
dissector_table_foreach_handle@Base 1.9.1 dissector_table_foreach_handle@Base 1.9.1
dissector_table_get_dissector_handles@Base 1.12.0~rc1 dissector_table_get_dissector_handles@Base 1.12.0~rc1
dissector_table_get_proto_allowed@Base 2.1.0
dissector_table_get_type@Base 1.12.0~rc1 dissector_table_get_type@Base 1.12.0~rc1
dissector_try_guid@Base 2.1.0 dissector_try_guid@Base 2.1.0
dissector_try_guid_new@Base 2.1.0 dissector_try_guid_new@Base 2.1.0

2
doc/README.dissector
View File

@ -3317,7 +3317,7 @@ Consider the following example using IP dissection, stolen from packet-ip.c:
static decode_as_t ip_da = {"ip", "Network", "ip.proto", 1, 0, &ip_da_values, NULL, NULL, static decode_as_t ip_da = {"ip", "Network", "ip.proto", 1, 0, &ip_da_values, NULL, NULL,
decode_as_default_populate_list, decode_as_default_reset, decode_as_default_change, NULL}; decode_as_default_populate_list, decode_as_default_reset, decode_as_default_change, NULL};
... ...
ip_dissector_table = register_dissector_table("ip.proto", "IP protocol", ip_proto, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); ip_dissector_table = register_dissector_table("ip.proto", "IP protocol", ip_proto, FT_UINT8, BASE_DEC);
... ...
register_decode_as(&ip_da); register_decode_as(&ip_da);

16
epan/decode_as.c
View File

@ -40,24 +40,10 @@ void register_decode_as(decode_as_t* reg)
DISSECTOR_ASSERT(reg->reset_value); DISSECTOR_ASSERT(reg->reset_value);
DISSECTOR_ASSERT(reg->change_value); DISSECTOR_ASSERT(reg->change_value);
/* Ensure the dissector table can't have duplicate protocols
that could confuse users */
decode_table = find_dissector_table(reg->table_name); decode_table = find_dissector_table(reg->table_name);
/* XXX - This should really be a DISSECTOR_ASSERT but a Bluetooth
* dissector is registering for "media_type" dissector table before it
* can be created
* There is also the "fake" DCE/RPC dissector table that needs to be fixed
*/
if (decode_table != NULL) if (decode_table != NULL)
{ {
/* FT_STRING can at least show the string value in the dialog, so don't penalize them */ dissector_table_allow_decode_as(decode_table);
if ((dissector_table_get_type(decode_table) != FT_STRING) &&
(dissector_table_get_proto_allowed(decode_table) != DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE))
{
fprintf(stderr, "%s allows duplicates, which can lead to confuse in the Decode As dialog\n", reg->table_name);
if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL)
abort();
}
} }
decode_as_list = g_list_append(decode_as_list, reg); decode_as_list = g_list_append(decode_as_list, reg);

6
epan/dissectors/asn1/ansi_map/packet-ansi_map-template.c
View File

@ -5472,15 +5472,15 @@ void proto_register_ansi_map(void) {
is637_tele_id_dissector_table = is637_tele_id_dissector_table =
register_dissector_table("ansi_map.tele_id", "IS-637 Teleservice ID", proto_ansi_map, register_dissector_table("ansi_map.tele_id", "IS-637 Teleservice ID", proto_ansi_map,
FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT8, BASE_DEC);
is683_dissector_table = is683_dissector_table =
register_dissector_table("ansi_map.ota", "IS-683-A (OTA)", proto_ansi_map, register_dissector_table("ansi_map.ota", "IS-683-A (OTA)", proto_ansi_map,
FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT8, BASE_DEC);
is801_dissector_table = is801_dissector_table =
register_dissector_table("ansi_map.pld", "IS-801 (PLD)", proto_ansi_map, register_dissector_table("ansi_map.pld", "IS-801 (PLD)", proto_ansi_map,
FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT8, BASE_DEC);
ansi_map_tap = register_tap("ansi_map"); ansi_map_tap = register_tap("ansi_map");

2
epan/dissectors/asn1/ansi_tcap/packet-ansi_tcap-template.c
View File

@ -516,7 +516,7 @@ proto_register_ansi_tcap(void)
register_dissector("ansi_tcap", dissect_ansi_tcap, proto_ansi_tcap); register_dissector("ansi_tcap", dissect_ansi_tcap, proto_ansi_tcap);
/* Note the high bit should be masked off when registering in this table (0x7fff)*/ /* Note the high bit should be masked off when registering in this table (0x7fff)*/
ansi_tcap_national_opcode_table = register_dissector_table("ansi_tcap.nat.opcode", "ANSI TCAP National Opcodes", proto_ansi_tcap, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); ansi_tcap_national_opcode_table = register_dissector_table("ansi_tcap.nat.opcode", "ANSI TCAP National Opcodes", proto_ansi_tcap, FT_UINT16, BASE_DEC);
/* Required function calls to register the header fields and subtrees used */ /* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_ansi_tcap, hf, array_length(hf)); proto_register_field_array(proto_ansi_tcap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett)); proto_register_subtree_array(ett, array_length(ett));

6
epan/dissectors/asn1/camel/packet-camel-template.c
View File

@ -1561,13 +1561,13 @@ void proto_register_camel(void) {
/* Register dissector tables */ /* Register dissector tables */
camel_rose_ctx.arg_local_dissector_table = register_dissector_table("camel.ros.local.arg", camel_rose_ctx.arg_local_dissector_table = register_dissector_table("camel.ros.local.arg",
"CAMEL Operation Argument (local opcode)", proto_camel, "CAMEL Operation Argument (local opcode)", proto_camel,
FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT32, BASE_HEX);
camel_rose_ctx.res_local_dissector_table = register_dissector_table("camel.ros.local.res", camel_rose_ctx.res_local_dissector_table = register_dissector_table("camel.ros.local.res",
"CAMEL Operation Result (local opcode)", proto_camel, "CAMEL Operation Result (local opcode)", proto_camel,
FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT32, BASE_HEX);
camel_rose_ctx.err_local_dissector_table = register_dissector_table("camel.ros.local.err", camel_rose_ctx.err_local_dissector_table = register_dissector_table("camel.ros.local.err",
"CAMEL Error (local opcode)", proto_camel, "CAMEL Error (local opcode)", proto_camel,
FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT32, BASE_HEX);
/* Register our configuration options, particularly our SSNs */ /* Register our configuration options, particularly our SSNs */
/* Set default SSNs */ /* Set default SSNs */

2
epan/dissectors/asn1/cmip/packet-cmip-template.c
View File

@ -200,7 +200,7 @@ void proto_register_cmip(void) {
#include "packet-cmip-dis-tab.c" #include "packet-cmip-dis-tab.c"
oid_add_from_string("discriminatorId(1)","2.9.3.2.7.1"); oid_add_from_string("discriminatorId(1)","2.9.3.2.7.1");
attribute_id_dissector_table = register_dissector_table("cmip.attribute_id", "CMIP Attribute Id", proto_cmip, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); attribute_id_dissector_table = register_dissector_table("cmip.attribute_id", "CMIP Attribute Id", proto_cmip, FT_UINT32, BASE_DEC);
} }

2
epan/dissectors/asn1/dop/packet-dop-template.c
View File

@ -263,7 +263,7 @@ void proto_register_dop(void) {
register_dissector("dop", dissect_dop, proto_dop); register_dissector("dop", dissect_dop, proto_dop);
dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", proto_dop, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", proto_dop, FT_STRING, BASE_NONE);
/* Register fields and subtrees */ /* Register fields and subtrees */
proto_register_field_array(proto_dop, hf, array_length(hf)); proto_register_field_array(proto_dop, hf, array_length(hf));

10
epan/dissectors/asn1/gsm_map/packet-gsm_map-template.c
View File

@ -3135,12 +3135,12 @@ void proto_register_gsm_map(void) {
expert_gsm_map = expert_register_protocol(proto_gsm_map); expert_gsm_map = expert_register_protocol(proto_gsm_map);
expert_register_field_array(expert_gsm_map, ei, array_length(ei)); expert_register_field_array(expert_gsm_map, ei, array_length(ei));
register_dissector_table("gsm_map.v3.arg.opcode", "GSM_MAP V3 Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_dissector_table("gsm_map.v3.arg.opcode", "GSM_MAP V3 Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC);
register_dissector_table("gsm_map.v3.res.opcode", "GSM_MAP V3 Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_dissector_table("gsm_map.v3.res.opcode", "GSM_MAP V3 Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC);
map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC);
map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC);
map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC);
gsm_map_tap = register_tap("gsm_map"); gsm_map_tap = register_tap("gsm_map");

10
epan/dissectors/asn1/h225/packet-h225-template.c
View File

@ -904,11 +904,11 @@ void proto_register_h225(void) {
register_dissector("h323ui",dissect_h225_H323UserInformation, proto_h225); register_dissector("h323ui",dissect_h225_H323UserInformation, proto_h225);
h225ras_handle = register_dissector("h225.ras", dissect_h225_h225_RasMessage, proto_h225); h225ras_handle = register_dissector("h225.ras", dissect_h225_h225_RasMessage, proto_h225);
nsp_object_dissector_table = register_dissector_table("h225.nsp.object", "H.225 NonStandardParameter (object)", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); nsp_object_dissector_table = register_dissector_table("h225.nsp.object", "H.225 NonStandardParameter (object)", proto_h225, FT_STRING, BASE_NONE);
nsp_h221_dissector_table = register_dissector_table("h225.nsp.h221", "H.225 NonStandardParameter (h221)", proto_h225, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); nsp_h221_dissector_table = register_dissector_table("h225.nsp.h221", "H.225 NonStandardParameter (h221)", proto_h225, FT_UINT32, BASE_HEX);
tp_dissector_table = register_dissector_table("h225.tp", "H.225 TunnelledProtocol", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); tp_dissector_table = register_dissector_table("h225.tp", "H.225 TunnelledProtocol", proto_h225, FT_STRING, BASE_NONE);
gef_name_dissector_table = register_dissector_table("h225.gef.name", "H.225 Generic Extensible Framework (names)", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); gef_name_dissector_table = register_dissector_table("h225.gef.name", "H.225 Generic Extensible Framework (names)", proto_h225, FT_STRING, BASE_NONE);
gef_content_dissector_table = register_dissector_table("h225.gef.content", "H.225 Generic Extensible Framework", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); gef_content_dissector_table = register_dissector_table("h225.gef.content", "H.225 Generic Extensible Framework", proto_h225, FT_STRING, BASE_NONE);
register_init_routine(&h225_init_routine); register_init_routine(&h225_init_routine);
register_cleanup_routine(&h225_cleanup_routine); register_cleanup_routine(&h225_cleanup_routine);

8
epan/dissectors/asn1/h245/packet-h245-template.c
View File

@ -542,10 +542,10 @@ void proto_register_h245(void) {
MultimediaSystemControlMessage_handle = register_dissector("h245dg", dissect_h245_h245, proto_h245); MultimediaSystemControlMessage_handle = register_dissector("h245dg", dissect_h245_h245, proto_h245);
h245_handle = register_dissector("h245", dissect_h245, proto_h245); h245_handle = register_dissector("h245", dissect_h245, proto_h245);
nsp_object_dissector_table = register_dissector_table("h245.nsp.object", "H.245 NonStandardParameter (object)", proto_h245, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); nsp_object_dissector_table = register_dissector_table("h245.nsp.object", "H.245 NonStandardParameter (object)", proto_h245, FT_STRING, BASE_NONE);
nsp_h221_dissector_table = register_dissector_table("h245.nsp.h221", "H.245 NonStandardParameter (h221)", proto_h245, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); nsp_h221_dissector_table = register_dissector_table("h245.nsp.h221", "H.245 NonStandardParameter (h221)", proto_h245, FT_UINT32, BASE_HEX);
gef_name_dissector_table = register_dissector_table("h245.gef.name", "H.245 Generic Extensible Framework (names)", proto_h245, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); gef_name_dissector_table = register_dissector_table("h245.gef.name", "H.245 Generic Extensible Framework (names)", proto_h245, FT_STRING, BASE_NONE);
gef_content_dissector_table = register_dissector_table("h245.gef.content", "H.245 Generic Extensible Framework", proto_h245, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); gef_content_dissector_table = register_dissector_table("h245.gef.content", "H.245 Generic Extensible Framework", proto_h245, FT_STRING, BASE_NONE);
h245_tap = register_tap("h245"); h245_tap = register_tap("h245");
h245dg_tap = register_tap("h245dg"); h245dg_tap = register_tap("h245dg");

2
epan/dissectors/asn1/h248/packet-h248-template.c
View File

@ -2371,7 +2371,7 @@ void proto_register_h248(void) {
expert_h248 = expert_register_protocol(proto_h248); expert_h248 = expert_register_protocol(proto_h248);
expert_register_field_array(expert_h248, ei, array_length(ei)); expert_register_field_array(expert_h248, ei, array_length(ei));
subdissector_table = register_dissector_table("h248.magic_num", "H248 Magic Num", proto_h248, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); subdissector_table = register_dissector_table("h248.magic_num", "H248 Magic Num", proto_h248, FT_UINT32, BASE_HEX);
h248_module = prefs_register_protocol(proto_h248, proto_reg_handoff_h248); h248_module = prefs_register_protocol(proto_h248, proto_reg_handoff_h248);
prefs_register_bool_preference(h248_module, "ctx_info", prefs_register_bool_preference(h248_module, "ctx_info",

12
epan/dissectors/asn1/h450/packet-h450-template.c
View File

@ -289,12 +289,12 @@ void proto_register_h450(void) {
rose_ctx_init(&h450_rose_ctx); rose_ctx_init(&h450_rose_ctx);
/* Register dissector tables */ /* Register dissector tables */
h450_rose_ctx.arg_global_dissector_table = register_dissector_table("h450.ros.global.arg", "H.450 Operation Argument (global opcode)", proto_h450, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); h450_rose_ctx.arg_global_dissector_table = register_dissector_table("h450.ros.global.arg", "H.450 Operation Argument (global opcode)", proto_h450, FT_STRING, BASE_NONE);
h450_rose_ctx.res_global_dissector_table = register_dissector_table("h450.ros.global.res", "H.450 Operation Result (global opcode)", proto_h450, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); h450_rose_ctx.res_global_dissector_table = register_dissector_table("h450.ros.global.res", "H.450 Operation Result (global opcode)", proto_h450, FT_STRING, BASE_NONE);
h450_rose_ctx.arg_local_dissector_table = register_dissector_table("h450.ros.local.arg", "H.450 Operation Argument (local opcode)", proto_h450, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); h450_rose_ctx.arg_local_dissector_table = register_dissector_table("h450.ros.local.arg", "H.450 Operation Argument (local opcode)", proto_h450, FT_UINT32, BASE_HEX);
h450_rose_ctx.res_local_dissector_table = register_dissector_table("h450.ros.local.res", "H.450 Operation Result (local opcode)", proto_h450, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); h450_rose_ctx.res_local_dissector_table = register_dissector_table("h450.ros.local.res", "H.450 Operation Result (local opcode)", proto_h450, FT_UINT32, BASE_HEX);
h450_rose_ctx.err_global_dissector_table = register_dissector_table("h450.ros.global.err", "H.450 Error (global opcode)", proto_h450, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); h450_rose_ctx.err_global_dissector_table = register_dissector_table("h450.ros.global.err", "H.450 Error (global opcode)", proto_h450, FT_STRING, BASE_NONE);
h450_rose_ctx.err_local_dissector_table = register_dissector_table("h450.ros.local.err", "H.450 Error (local opcode)", proto_h450, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); h450_rose_ctx.err_local_dissector_table = register_dissector_table("h450.ros.local.err", "H.450 Error (local opcode)", proto_h450, FT_UINT32, BASE_HEX);
} }

10
epan/dissectors/asn1/hnbap/packet-hnbap-template.c
View File

@ -168,11 +168,11 @@ module_t *hnbap_module;
hnbap_handle = register_dissector("hnbap", dissect_hnbap, proto_hnbap); hnbap_handle = register_dissector("hnbap", dissect_hnbap, proto_hnbap);
/* Register dissector tables */ /* Register dissector tables */
hnbap_ies_dissector_table = register_dissector_table("hnbap.ies", "HNBAP-PROTOCOL-IES", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); hnbap_ies_dissector_table = register_dissector_table("hnbap.ies", "HNBAP-PROTOCOL-IES", proto_hnbap, FT_UINT32, BASE_DEC);
hnbap_extension_dissector_table = register_dissector_table("hnbap.extension", "HNBAP-PROTOCOL-EXTENSION", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); hnbap_extension_dissector_table = register_dissector_table("hnbap.extension", "HNBAP-PROTOCOL-EXTENSION", proto_hnbap, FT_UINT32, BASE_DEC);
hnbap_proc_imsg_dissector_table = register_dissector_table("hnbap.proc.imsg", "HNBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); hnbap_proc_imsg_dissector_table = register_dissector_table("hnbap.proc.imsg", "HNBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_hnbap, FT_UINT32, BASE_DEC);
hnbap_proc_sout_dissector_table = register_dissector_table("hnbap.proc.sout", "HNBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); hnbap_proc_sout_dissector_table = register_dissector_table("hnbap.proc.sout", "HNBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC);
hnbap_proc_uout_dissector_table = register_dissector_table("hnbap.proc.uout", "HNBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); hnbap_proc_uout_dissector_table = register_dissector_table("hnbap.proc.uout", "HNBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC);
hnbap_module = prefs_register_protocol(proto_hnbap, proto_reg_handoff_hnbap); hnbap_module = prefs_register_protocol(proto_hnbap, proto_reg_handoff_hnbap);
prefs_register_uint_preference(hnbap_module, "port", "HNBAP SCTP Port", "Set the port for HNBAP messages (Default of 29169)", 10, &global_sctp_port); prefs_register_uint_preference(hnbap_module, "port", "HNBAP SCTP Port", "Set the port for HNBAP messages (Default of 29169)", 10, &global_sctp_port);

10
epan/dissectors/asn1/lcsap/packet-lcsap-template.c
View File

@ -328,15 +328,15 @@ void proto_register_lcsap(void) {
lcsap_handle = register_dissector("lcsap", dissect_lcsap, proto_lcsap); lcsap_handle = register_dissector("lcsap", dissect_lcsap, proto_lcsap);
/* Register dissector tables */ /* Register dissector tables */
lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", proto_lcsap, FT_UINT32, BASE_DEC);
expert_lcsap = expert_register_protocol(proto_lcsap); expert_lcsap = expert_register_protocol(proto_lcsap);
expert_register_field_array(expert_lcsap, ei, array_length(ei)); expert_register_field_array(expert_lcsap, ei, array_length(ei));
lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", proto_lcsap, FT_UINT32, BASE_DEC);
lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lcsap, FT_UINT32, BASE_DEC);
lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC);
lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC);
/* Register configuration options for ports */ /* Register configuration options for ports */
lcsap_module = prefs_register_protocol(proto_lcsap, proto_reg_handoff_lcsap); lcsap_module = prefs_register_protocol(proto_lcsap, proto_reg_handoff_lcsap);

2
epan/dissectors/asn1/ldap/packet-ldap-template.c
View File

@ -2240,7 +2240,7 @@ void proto_register_ldap(void) {
ldap_tap=register_tap("ldap"); ldap_tap=register_tap("ldap");
ldap_name_dissector_table = register_dissector_table("ldap.name", "LDAP Attribute Type Dissectors", proto_cldap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); ldap_name_dissector_table = register_dissector_table("ldap.name", "LDAP Attribute Type Dissectors", proto_cldap, FT_STRING, BASE_NONE);
register_srt_table(proto_ldap, NULL, 1, ldapstat_packet, ldapstat_init, NULL); register_srt_table(proto_ldap, NULL, 1, ldapstat_packet, ldapstat_init, NULL);
} }

8
epan/dissectors/asn1/lppa/packet-lppa-template.c
View File

@ -111,10 +111,10 @@ void proto_register_lppa(void) {
proto_register_subtree_array(ett, array_length(ett)); proto_register_subtree_array(ett, array_length(ett));
/* Register dissector tables */ /* Register dissector tables */
lppa_ies_dissector_table = register_dissector_table("lppa.ies", "LPPA-PROTOCOL-IES", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); lppa_ies_dissector_table = register_dissector_table("lppa.ies", "LPPA-PROTOCOL-IES", proto_lppa, FT_UINT32, BASE_DEC);
lppa_proc_imsg_dissector_table = register_dissector_table("lppa.proc.imsg", "LPPA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); lppa_proc_imsg_dissector_table = register_dissector_table("lppa.proc.imsg", "LPPA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lppa, FT_UINT32, BASE_DEC);
lppa_proc_sout_dissector_table = register_dissector_table("lppa.proc.sout", "LPPA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); lppa_proc_sout_dissector_table = register_dissector_table("lppa.proc.sout", "LPPA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC);
lppa_proc_uout_dissector_table = register_dissector_table("lppa.proc.uout", "LPPA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); lppa_proc_uout_dissector_table = register_dissector_table("lppa.proc.uout", "LPPA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC);
} }
/*--- proto_reg_handoff_lppa ---------------------------------------*/ /*--- proto_reg_handoff_lppa ---------------------------------------*/

10
epan/dissectors/asn1/m3ap/packet-m3ap-template.c
View File

@ -183,11 +183,11 @@ void proto_register_m3ap(void) {
expert_register_field_array(expert_m3ap, ei, array_length(ei)); expert_register_field_array(expert_m3ap, ei, array_length(ei));
/* Register dissector tables */ /* Register dissector tables */
m3ap_ies_dissector_table = register_dissector_table("m3ap.ies", "M3AP-PROTOCOL-IES", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); m3ap_ies_dissector_table = register_dissector_table("m3ap.ies", "M3AP-PROTOCOL-IES", proto_m3ap, FT_UINT32, BASE_DEC);
m3ap_extension_dissector_table = register_dissector_table("m3ap.extension", "M3AP-PROTOCOL-EXTENSION", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); m3ap_extension_dissector_table = register_dissector_table("m3ap.extension", "M3AP-PROTOCOL-EXTENSION", proto_m3ap, FT_UINT32, BASE_DEC);
m3ap_proc_imsg_dissector_table = register_dissector_table("m3ap.proc.imsg", "M3AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); m3ap_proc_imsg_dissector_table = register_dissector_table("m3ap.proc.imsg", "M3AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_m3ap, FT_UINT32, BASE_DEC);
m3ap_proc_sout_dissector_table = register_dissector_table("m3ap.proc.sout", "M3AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); m3ap_proc_sout_dissector_table = register_dissector_table("m3ap.proc.sout", "M3AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC);
m3ap_proc_uout_dissector_table = register_dissector_table("m3ap.proc.uout", "M3AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); m3ap_proc_uout_dissector_table = register_dissector_table("m3ap.proc.uout", "M3AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC);
} }

10
epan/dissectors/asn1/nbap/packet-nbap-template.c
View File

@ -516,11 +516,11 @@ void proto_register_nbap(void)
} }
/* Register dissector tables */ /* Register dissector tables */
nbap_ies_dissector_table = register_dissector_table("nbap.ies", "NBAP-PROTOCOL-IES", proto_nbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); nbap_ies_dissector_table = register_dissector_table("nbap.ies", "NBAP-PROTOCOL-IES", proto_nbap, FT_UINT32, BASE_DEC);
nbap_extension_dissector_table = register_dissector_table("nbap.extension", "NBAP-PROTOCOL-EXTENSION", proto_nbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); nbap_extension_dissector_table = register_dissector_table("nbap.extension", "NBAP-PROTOCOL-EXTENSION", proto_nbap, FT_UINT32, BASE_DEC);
nbap_proc_imsg_dissector_table = register_dissector_table("nbap.proc.imsg", "NBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_nbap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); nbap_proc_imsg_dissector_table = register_dissector_table("nbap.proc.imsg", "NBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_nbap, FT_STRING, BASE_NONE);
nbap_proc_sout_dissector_table = register_dissector_table("nbap.proc.sout", "NBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); nbap_proc_sout_dissector_table = register_dissector_table("nbap.proc.sout", "NBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE);
nbap_proc_uout_dissector_table = register_dissector_table("nbap.proc.uout", "NBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); nbap_proc_uout_dissector_table = register_dissector_table("nbap.proc.uout", "NBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE);
register_init_routine(nbap_init); register_init_routine(nbap_init);
} }

6
epan/dissectors/asn1/p1/packet-p1-template.c
View File

@ -375,9 +375,9 @@ void proto_register_p1(void) {
expert_p1 = expert_register_protocol(proto_p1); expert_p1 = expert_register_protocol(proto_p1);
expert_register_field_array(expert_p1, ei, array_length(ei)); expert_register_field_array(expert_p1, ei, array_length(ei));
p1_extension_dissector_table = register_dissector_table("p1.extension", "P1-EXTENSION", proto_p1, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); p1_extension_dissector_table = register_dissector_table("p1.extension", "P1-EXTENSION", proto_p1, FT_UINT32, BASE_DEC);
p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", proto_p1, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", proto_p1, FT_UINT32, BASE_DEC);
p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", proto_p1, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", proto_p1, FT_UINT32, BASE_DEC);
/* Register our configuration options for P1, particularly our port */ /* Register our configuration options for P1, particularly our port */

16
epan/dissectors/asn1/pcap/packet-pcap-template.c
View File

@ -190,14 +190,14 @@ void proto_register_pcap(void) {
pcap_handle = register_dissector("pcap", dissect_pcap, proto_pcap); pcap_handle = register_dissector("pcap", dissect_pcap, proto_pcap);
/* Register dissector tables */ /* Register dissector tables */
pcap_ies_dissector_table = register_dissector_table("pcap.ies", "PCAP-PROTOCOL-IES", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); pcap_ies_dissector_table = register_dissector_table("pcap.ies", "PCAP-PROTOCOL-IES", proto_pcap, FT_UINT32, BASE_DEC);
pcap_ies_p1_dissector_table = register_dissector_table("pcap.ies.pair.first", "PCAP-PROTOCOL-IES-PAIR FirstValue", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); pcap_ies_p1_dissector_table = register_dissector_table("pcap.ies.pair.first", "PCAP-PROTOCOL-IES-PAIR FirstValue", proto_pcap, FT_UINT32, BASE_DEC);
pcap_ies_p2_dissector_table = register_dissector_table("pcap.ies.pair.second", "PCAP-PROTOCOL-IES-PAIR SecondValue", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); pcap_ies_p2_dissector_table = register_dissector_table("pcap.ies.pair.second", "PCAP-PROTOCOL-IES-PAIR SecondValue", proto_pcap, FT_UINT32, BASE_DEC);
pcap_extension_dissector_table = register_dissector_table("pcap.extension", "PCAP-PROTOCOL-EXTENSION", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); pcap_extension_dissector_table = register_dissector_table("pcap.extension", "PCAP-PROTOCOL-EXTENSION", proto_pcap, FT_UINT32, BASE_DEC);
pcap_proc_imsg_dissector_table = register_dissector_table("pcap.proc.imsg", "PCAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); pcap_proc_imsg_dissector_table = register_dissector_table("pcap.proc.imsg", "PCAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_pcap, FT_UINT32, BASE_DEC);
pcap_proc_sout_dissector_table = register_dissector_table("pcap.proc.sout", "PCAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); pcap_proc_sout_dissector_table = register_dissector_table("pcap.proc.sout", "PCAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC);
pcap_proc_uout_dissector_table = register_dissector_table("pcap.proc.uout", "PCAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); pcap_proc_uout_dissector_table = register_dissector_table("pcap.proc.uout", "PCAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC);
pcap_proc_out_dissector_table = register_dissector_table("pcap.proc.out", "PCAP-ELEMENTARY-PROCEDURE Outcome", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); pcap_proc_out_dissector_table = register_dissector_table("pcap.proc.out", "PCAP-ELEMENTARY-PROCEDURE Outcome", proto_pcap, FT_UINT32, BASE_DEC);
/* Preferences */ /* Preferences */

18
epan/dissectors/asn1/q932/packet-q932-template.c
View File

@ -348,17 +348,17 @@ void proto_register_q932(void) {
rose_ctx_init(&q932_rose_ctx); rose_ctx_init(&q932_rose_ctx);
/* Register dissector tables */ /* Register dissector tables */
q932_rose_ctx.arg_global_dissector_table = register_dissector_table("q932.ros.global.arg", "Q.932 Operation Argument (global opcode)", proto_q932, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); q932_rose_ctx.arg_global_dissector_table = register_dissector_table("q932.ros.global.arg", "Q.932 Operation Argument (global opcode)", proto_q932, FT_STRING, BASE_NONE);
q932_rose_ctx.res_global_dissector_table = register_dissector_table("q932.ros.global.res", "Q.932 Operation Result (global opcode)", proto_q932, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); q932_rose_ctx.res_global_dissector_table = register_dissector_table("q932.ros.global.res", "Q.932 Operation Result (global opcode)", proto_q932, FT_STRING, BASE_NONE);
q932_rose_ctx.err_global_dissector_table = register_dissector_table("q932.ros.global.err", "Q.932 Error (global opcode)", proto_q932, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); q932_rose_ctx.err_global_dissector_table = register_dissector_table("q932.ros.global.err", "Q.932 Error (global opcode)", proto_q932, FT_STRING, BASE_NONE);
qsig_arg_local_dissector_table = register_dissector_table("q932.ros.local.arg", "Q.932 Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); qsig_arg_local_dissector_table = register_dissector_table("q932.ros.local.arg", "Q.932 Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX);
qsig_res_local_dissector_table = register_dissector_table("q932.ros.local.res", "Q.932 Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); qsig_res_local_dissector_table = register_dissector_table("q932.ros.local.res", "Q.932 Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX);
qsig_err_local_dissector_table = register_dissector_table("q932.ros.local.err", "Q.932 Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); qsig_err_local_dissector_table = register_dissector_table("q932.ros.local.err", "Q.932 Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX);
etsi_arg_local_dissector_table = register_dissector_table("q932.ros.etsi.local.arg", "Q.932 ETSI Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); etsi_arg_local_dissector_table = register_dissector_table("q932.ros.etsi.local.arg", "Q.932 ETSI Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX);
etsi_res_local_dissector_table = register_dissector_table("q932.ros.etsi.local.res", "Q.932 ETSI Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); etsi_res_local_dissector_table = register_dissector_table("q932.ros.etsi.local.res", "Q.932 ETSI Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX);
etsi_err_local_dissector_table = register_dissector_table("q932.ros.etsi.local.err", "Q.932 ETSI Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); etsi_err_local_dissector_table = register_dissector_table("q932.ros.etsi.local.err", "Q.932 ETSI Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX);
q932_module = prefs_register_protocol(proto_q932, proto_reg_handoff_q932); q932_module = prefs_register_protocol(proto_q932, proto_reg_handoff_q932);

2
epan/dissectors/asn1/qsig/packet-qsig-template.c
View File

@ -695,7 +695,7 @@ void proto_register_qsig(void) {
expert_register_field_array(expert_qsig, ei, array_length(ei)); expert_register_field_array(expert_qsig, ei, array_length(ei));
/* Register dissector tables */ /* Register dissector tables */
extension_dissector_table = register_dissector_table("qsig.ext", "QSIG Extension", proto_qsig, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); extension_dissector_table = register_dissector_table("qsig.ext", "QSIG Extension", proto_qsig, FT_STRING, BASE_NONE);
qsig_init_tables(); qsig_init_tables();
} }

18
epan/dissectors/asn1/ranap/packet-ranap-template.c
View File

@ -349,16 +349,16 @@ void proto_register_ranap(void) {
ranap_handle = register_dissector("ranap", dissect_ranap, proto_ranap); ranap_handle = register_dissector("ranap", dissect_ranap, proto_ranap);
/* Register dissector tables */ /* Register dissector tables */
ranap_ies_dissector_table = register_dissector_table("ranap.ies", "RANAP-PROTOCOL-IES", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); ranap_ies_dissector_table = register_dissector_table("ranap.ies", "RANAP-PROTOCOL-IES", proto_ranap, FT_UINT32, BASE_DEC);
ranap_ies_p1_dissector_table = register_dissector_table("ranap.ies.pair.first", "RANAP-PROTOCOL-IES-PAIR FirstValue", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); ranap_ies_p1_dissector_table = register_dissector_table("ranap.ies.pair.first", "RANAP-PROTOCOL-IES-PAIR FirstValue", proto_ranap, FT_UINT32, BASE_DEC);
ranap_ies_p2_dissector_table = register_dissector_table("ranap.ies.pair.second", "RANAP-PROTOCOL-IES-PAIR SecondValue", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); ranap_ies_p2_dissector_table = register_dissector_table("ranap.ies.pair.second", "RANAP-PROTOCOL-IES-PAIR SecondValue", proto_ranap, FT_UINT32, BASE_DEC);
ranap_extension_dissector_table = register_dissector_table("ranap.extension", "RANAP-PROTOCOL-EXTENSION", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); ranap_extension_dissector_table = register_dissector_table("ranap.extension", "RANAP-PROTOCOL-EXTENSION", proto_ranap, FT_UINT32, BASE_DEC);
ranap_proc_imsg_dissector_table = register_dissector_table("ranap.proc.imsg", "RANAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); ranap_proc_imsg_dissector_table = register_dissector_table("ranap.proc.imsg", "RANAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_ranap, FT_UINT32, BASE_DEC);
ranap_proc_sout_dissector_table = register_dissector_table("ranap.proc.sout", "RANAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); ranap_proc_sout_dissector_table = register_dissector_table("ranap.proc.sout", "RANAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC);
ranap_proc_uout_dissector_table = register_dissector_table("ranap.proc.uout", "RANAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); ranap_proc_uout_dissector_table = register_dissector_table("ranap.proc.uout", "RANAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC);
ranap_proc_out_dissector_table = register_dissector_table("ranap.proc.out", "RANAP-ELEMENTARY-PROCEDURE Outcome", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); ranap_proc_out_dissector_table = register_dissector_table("ranap.proc.out", "RANAP-ELEMENTARY-PROCEDURE Outcome", proto_ranap, FT_UINT32, BASE_DEC);
nas_pdu_dissector_table = register_dissector_table("ranap.nas_pdu", "RANAP NAS PDU", proto_ranap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); nas_pdu_dissector_table = register_dissector_table("ranap.nas_pdu", "RANAP NAS PDU", proto_ranap, FT_UINT8, BASE_DEC);
ranap_module = prefs_register_protocol(proto_ranap, proto_reg_handoff_ranap); ranap_module = prefs_register_protocol(proto_ranap, proto_reg_handoff_ranap);
prefs_register_uint_preference(ranap_module, "sccp_ssn", "SCCP SSN for RANAP", prefs_register_uint_preference(ranap_module, "sccp_ssn", "SCCP SSN for RANAP",

10
epan/dissectors/asn1/rnsap/packet-rnsap-template.c
View File

@ -163,11 +163,11 @@ void proto_register_rnsap(void) {
rnsap_handle = register_dissector("rnsap", dissect_rnsap, proto_rnsap); rnsap_handle = register_dissector("rnsap", dissect_rnsap, proto_rnsap);
/* Register dissector tables */ /* Register dissector tables */
rnsap_ies_dissector_table = register_dissector_table("rnsap.ies", "RNSAP-PROTOCOL-IES", proto_rnsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); rnsap_ies_dissector_table = register_dissector_table("rnsap.ies", "RNSAP-PROTOCOL-IES", proto_rnsap, FT_UINT32, BASE_DEC);
rnsap_extension_dissector_table = register_dissector_table("rnsap.extension", "RNSAP-PROTOCOL-EXTENSION", proto_rnsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); rnsap_extension_dissector_table = register_dissector_table("rnsap.extension", "RNSAP-PROTOCOL-EXTENSION", proto_rnsap, FT_UINT32, BASE_DEC);
rnsap_proc_imsg_dissector_table = register_dissector_table("rnsap.proc.imsg", "RNSAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rnsap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); rnsap_proc_imsg_dissector_table = register_dissector_table("rnsap.proc.imsg", "RNSAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rnsap, FT_STRING, BASE_NONE);
rnsap_proc_sout_dissector_table = register_dissector_table("rnsap.proc.sout", "RNSAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); rnsap_proc_sout_dissector_table = register_dissector_table("rnsap.proc.sout", "RNSAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE);
rnsap_proc_uout_dissector_table = register_dissector_table("rnsap.proc.uout", "RNSAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); rnsap_proc_uout_dissector_table = register_dissector_table("rnsap.proc.uout", "RNSAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE);
} }

2
epan/dissectors/asn1/ros/packet-ros-template.c
View File

@ -513,7 +513,7 @@ void proto_register_ros(void) {
expert_ros = expert_register_protocol(proto_ros); expert_ros = expert_register_protocol(proto_ros);
expert_register_field_array(expert_ros, ei, array_length(ei)); expert_register_field_array(expert_ros, ei, array_length(ei));
ros_oid_dissector_table = register_dissector_table("ros.oid", "ROS OID Dissectors", proto_ros, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); ros_oid_dissector_table = register_dissector_table("ros.oid", "ROS OID Dissectors", proto_ros, FT_STRING, BASE_NONE);
oid_table=g_hash_table_new(g_str_hash, g_str_equal); oid_table=g_hash_table_new(g_str_hash, g_str_equal);
protocol_table=g_hash_table_new(g_str_hash, g_str_equal); protocol_table=g_hash_table_new(g_str_hash, g_str_equal);

2
epan/dissectors/asn1/rtse/packet-rtse-template.c
View File

@ -402,7 +402,7 @@ void proto_register_rtse(void) {
" \"Allow subdissectors to reassemble TCP streams\"" " \"Allow subdissectors to reassemble TCP streams\""
" in the TCP protocol settings.", &rtse_reassemble); " in the TCP protocol settings.", &rtse_reassemble);
rtse_oid_dissector_table = register_dissector_table("rtse.oid", "RTSE OID Dissectors", proto_rtse, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); rtse_oid_dissector_table = register_dissector_table("rtse.oid", "RTSE OID Dissectors", proto_rtse, FT_STRING, BASE_NONE);
oid_table=g_hash_table_new(g_str_hash, g_str_equal); oid_table=g_hash_table_new(g_str_hash, g_str_equal);

10
epan/dissectors/asn1/rua/packet-rua-template.c
View File

@ -153,11 +153,11 @@ module_t *rua_module;
rua_handle = register_dissector("rua", dissect_rua, proto_rua); rua_handle = register_dissector("rua", dissect_rua, proto_rua);
/* Register dissector tables */ /* Register dissector tables */
rua_ies_dissector_table = register_dissector_table("rua.ies", "RUA-PROTOCOL-IES", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); rua_ies_dissector_table = register_dissector_table("rua.ies", "RUA-PROTOCOL-IES", proto_rua, FT_UINT32, BASE_DEC);
rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", proto_rua, FT_UINT32, BASE_DEC);
rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rua, FT_UINT32, BASE_DEC);
rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC);
rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC);
rua_module = prefs_register_protocol(proto_rua, proto_reg_handoff_rua); rua_module = prefs_register_protocol(proto_rua, proto_reg_handoff_rua);
prefs_register_uint_preference(rua_module, "port", "RUA SCTP Port", "Set the port for RUA messages (Default of 29169)", 10, &global_sctp_port); prefs_register_uint_preference(rua_module, "port", "RUA SCTP Port", "Set the port for RUA messages (Default of 29169)", 10, &global_sctp_port);

14
epan/dissectors/asn1/s1ap/packet-s1ap-template.c
View File

@ -279,13 +279,13 @@ void proto_register_s1ap(void) {
s1ap_handle = register_dissector("s1ap", dissect_s1ap, proto_s1ap); s1ap_handle = register_dissector("s1ap", dissect_s1ap, proto_s1ap);
/* Register dissector tables */ /* Register dissector tables */
s1ap_ies_dissector_table = register_dissector_table("s1ap.ies", "S1AP-PROTOCOL-IES", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); s1ap_ies_dissector_table = register_dissector_table("s1ap.ies", "S1AP-PROTOCOL-IES", proto_s1ap, FT_UINT32, BASE_DEC);
s1ap_ies_p1_dissector_table = register_dissector_table("s1ap.ies.pair.first", "S1AP-PROTOCOL-IES-PAIR FirstValue", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); s1ap_ies_p1_dissector_table = register_dissector_table("s1ap.ies.pair.first", "S1AP-PROTOCOL-IES-PAIR FirstValue", proto_s1ap, FT_UINT32, BASE_DEC);
s1ap_ies_p2_dissector_table = register_dissector_table("s1ap.ies.pair.second", "S1AP-PROTOCOL-IES-PAIR SecondValue", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); s1ap_ies_p2_dissector_table = register_dissector_table("s1ap.ies.pair.second", "S1AP-PROTOCOL-IES-PAIR SecondValue", proto_s1ap, FT_UINT32, BASE_DEC);
s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", proto_s1ap, FT_UINT32, BASE_DEC);
s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_s1ap, FT_UINT32, BASE_DEC);
s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC);
s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC);
/* Register configuration options for ports */ /* Register configuration options for ports */
s1ap_module = prefs_register_protocol(proto_s1ap, proto_reg_handoff_s1ap); s1ap_module = prefs_register_protocol(proto_s1ap, proto_reg_handoff_s1ap);

10
epan/dissectors/asn1/sabp/packet-sabp-template.c
View File

@ -274,11 +274,11 @@ void proto_register_sabp(void) {
sabp_tcp_handle = register_dissector("sabp.tcp", dissect_sabp_tcp, proto_sabp); sabp_tcp_handle = register_dissector("sabp.tcp", dissect_sabp_tcp, proto_sabp);
/* Register dissector tables */ /* Register dissector tables */
sabp_ies_dissector_table = register_dissector_table("sabp.ies", "SABP-PROTOCOL-IES", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); sabp_ies_dissector_table = register_dissector_table("sabp.ies", "SABP-PROTOCOL-IES", proto_sabp, FT_UINT32, BASE_DEC);
sabp_extension_dissector_table = register_dissector_table("sabp.extension", "SABP-PROTOCOL-EXTENSION", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); sabp_extension_dissector_table = register_dissector_table("sabp.extension", "SABP-PROTOCOL-EXTENSION", proto_sabp, FT_UINT32, BASE_DEC);
sabp_proc_imsg_dissector_table = register_dissector_table("sabp.proc.imsg", "SABP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); sabp_proc_imsg_dissector_table = register_dissector_table("sabp.proc.imsg", "SABP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sabp, FT_UINT32, BASE_DEC);
sabp_proc_sout_dissector_table = register_dissector_table("sabp.proc.sout", "SABP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); sabp_proc_sout_dissector_table = register_dissector_table("sabp.proc.sout", "SABP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC);
sabp_proc_uout_dissector_table = register_dissector_table("sabp.proc.uout", "SABP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); sabp_proc_uout_dissector_table = register_dissector_table("sabp.proc.uout", "SABP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC);
} }

10
epan/dissectors/asn1/sbc-ap/packet-sbc-ap-template.c
View File

@ -165,11 +165,11 @@ void proto_register_sbc_ap(void) {
/* Register dissector tables */ /* Register dissector tables */
sbc_ap_ies_dissector_table = register_dissector_table("sbc_ap.ies", "SBC-AP-PROTOCOL-IES", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); sbc_ap_ies_dissector_table = register_dissector_table("sbc_ap.ies", "SBC-AP-PROTOCOL-IES", proto_sbc_ap, FT_UINT32, BASE_DEC);
sbc_ap_extension_dissector_table = register_dissector_table("sbc_ap.extension", "SBC-AP-PROTOCOL-EXTENSION", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); sbc_ap_extension_dissector_table = register_dissector_table("sbc_ap.extension", "SBC-AP-PROTOCOL-EXTENSION", proto_sbc_ap, FT_UINT32, BASE_DEC);
sbc_ap_proc_imsg_dissector_table = register_dissector_table("sbc_ap.proc.imsg", "SBC-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); sbc_ap_proc_imsg_dissector_table = register_dissector_table("sbc_ap.proc.imsg", "SBC-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sbc_ap, FT_UINT32, BASE_DEC);
sbc_ap_proc_sout_dissector_table = register_dissector_table("sbc_ap.proc.sout", "SBC-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); sbc_ap_proc_sout_dissector_table = register_dissector_table("sbc_ap.proc.sout", "SBC-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC);
sbc_ap_proc_uout_dissector_table = register_dissector_table("sbc_ap.proc.uout", "SBC-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); sbc_ap_proc_uout_dissector_table = register_dissector_table("sbc_ap.proc.uout", "SBC-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC);
} }

2
epan/dissectors/asn1/snmp/packet-snmp-template.c
View File

@ -2566,7 +2566,7 @@ void proto_register_snmp(void) {
"MIB settings can be changed in the Name Resolution preferences"); "MIB settings can be changed in the Name Resolution preferences");
#endif #endif
value_sub_dissectors_table = register_dissector_table("snmp.variable_oid","SNMP Variable OID", proto_snmp, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); value_sub_dissectors_table = register_dissector_table("snmp.variable_oid","SNMP Variable OID", proto_snmp, FT_STRING, BASE_NONE);
register_init_routine(init_ue_cache); register_init_routine(init_ue_cache);
register_cleanup_routine(cleanup_ue_cache); register_cleanup_routine(cleanup_ue_cache);

4
epan/dissectors/asn1/t124/packet-t124-template.c
View File

@ -203,8 +203,8 @@ void proto_register_t124(void) {
proto_register_field_array(proto_t124, hf, array_length(hf)); proto_register_field_array(proto_t124, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett)); proto_register_subtree_array(ett, array_length(ett));
t124_ns_dissector_table = register_dissector_table("t124.ns", "T.124 H.221 Non Standard Dissectors", proto_t124, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); t124_ns_dissector_table = register_dissector_table("t124.ns", "T.124 H.221 Non Standard Dissectors", proto_t124, FT_STRING, BASE_NONE);
t124_sd_dissector_table = register_dissector_table("t124.sd", "T.124 H.221 Send Data Dissectors", proto_t124, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); t124_sd_dissector_table = register_dissector_table("t124.sd", "T.124 H.221 Send Data Dissectors", proto_t124, FT_UINT32, BASE_HEX);
register_dissector("t124", dissect_t124, proto_t124); register_dissector("t124", dissect_t124, proto_t124);

10
epan/dissectors/asn1/x2ap/packet-x2ap-template.c
View File

@ -166,11 +166,11 @@ void proto_register_x2ap(void) {
x2ap_handle = register_dissector("x2ap", dissect_x2ap, proto_x2ap); x2ap_handle = register_dissector("x2ap", dissect_x2ap, proto_x2ap);
/* Register dissector tables */ /* Register dissector tables */
x2ap_ies_dissector_table = register_dissector_table("x2ap.ies", "X2AP-PROTOCOL-IES", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); x2ap_ies_dissector_table = register_dissector_table("x2ap.ies", "X2AP-PROTOCOL-IES", proto_x2ap, FT_UINT32, BASE_DEC);
x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", proto_x2ap, FT_UINT32, BASE_DEC);
x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_x2ap, FT_UINT32, BASE_DEC);
x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC);
x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC);
/* Register configuration options for ports */ /* Register configuration options for ports */
x2ap_module = prefs_register_protocol(proto_x2ap, proto_reg_handoff_x2ap); x2ap_module = prefs_register_protocol(proto_x2ap, proto_reg_handoff_x2ap);

2
epan/dissectors/file-file.c
View File

@ -386,7 +386,7 @@ proto_register_file(void)
register_dissector("file",dissect_file_record,proto_file); register_dissector("file",dissect_file_record,proto_file);
file_encap_dissector_table = register_dissector_table("ftap_encap", file_encap_dissector_table = register_dissector_table("ftap_encap",
"Filetap encapsulation type", proto_file, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "Filetap encapsulation type", proto_file, FT_UINT32, BASE_DEC);
/* You can't disable dissection of "Frame", as that would be /* You can't disable dissection of "Frame", as that would be
tantamount to not doing any dissection whatsoever. */ tantamount to not doing any dissection whatsoever. */

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

@ -3406,7 +3406,7 @@ proto_register_ansi_637(void)
tele_dissector_table = tele_dissector_table =
register_dissector_table("ansi_637.tele_id", register_dissector_table("ansi_637.tele_id",
"ANSI IS-637-A Teleservice ID", proto_ansi_637_tele, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "ANSI IS-637-A Teleservice ID", proto_ansi_637_tele, FT_UINT8, BASE_DEC);
} }

6
epan/dissectors/packet-ansi_a.c
View File

@ -12855,15 +12855,15 @@ proto_register_ansi_a(void)
is637_dissector_table = is637_dissector_table =
register_dissector_table("ansi_a.sms", "IS-637-A (SMS)", register_dissector_table("ansi_a.sms", "IS-637-A (SMS)",
proto_a_bsmap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_a_bsmap, FT_UINT8, BASE_DEC);
is683_dissector_table = is683_dissector_table =
register_dissector_table("ansi_a.ota", "IS-683-A (OTA)", register_dissector_table("ansi_a.ota", "IS-683-A (OTA)",
proto_a_bsmap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_a_bsmap, FT_UINT8, BASE_DEC);
is801_dissector_table = is801_dissector_table =
register_dissector_table("ansi_a.pld", "IS-801 (PLD)", register_dissector_table("ansi_a.pld", "IS-801 (PLD)",
proto_a_bsmap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_a_bsmap, FT_UINT8, BASE_DEC);
proto_register_subtree_array(ett, array_length(ett)); proto_register_subtree_array(ett, array_length(ett));

6
epan/dissectors/packet-ansi_map.c
View File

@ -19542,15 +19542,15 @@ void proto_register_ansi_map(void) {
is637_tele_id_dissector_table = is637_tele_id_dissector_table =
register_dissector_table("ansi_map.tele_id", "IS-637 Teleservice ID", proto_ansi_map, register_dissector_table("ansi_map.tele_id", "IS-637 Teleservice ID", proto_ansi_map,
FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT8, BASE_DEC);
is683_dissector_table = is683_dissector_table =
register_dissector_table("ansi_map.ota", "IS-683-A (OTA)", proto_ansi_map, register_dissector_table("ansi_map.ota", "IS-683-A (OTA)", proto_ansi_map,
FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT8, BASE_DEC);
is801_dissector_table = is801_dissector_table =
register_dissector_table("ansi_map.pld", "IS-801 (PLD)", proto_ansi_map, register_dissector_table("ansi_map.pld", "IS-801 (PLD)", proto_ansi_map,
FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT8, BASE_DEC);
ansi_map_tap = register_tap("ansi_map"); ansi_map_tap = register_tap("ansi_map");

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

@ -1813,7 +1813,7 @@ proto_register_ansi_tcap(void)
register_dissector("ansi_tcap", dissect_ansi_tcap, proto_ansi_tcap); register_dissector("ansi_tcap", dissect_ansi_tcap, proto_ansi_tcap);
/* Note the high bit should be masked off when registering in this table (0x7fff)*/ /* Note the high bit should be masked off when registering in this table (0x7fff)*/
ansi_tcap_national_opcode_table = register_dissector_table("ansi_tcap.nat.opcode", "ANSI TCAP National Opcodes", proto_ansi_tcap, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); ansi_tcap_national_opcode_table = register_dissector_table("ansi_tcap.nat.opcode", "ANSI TCAP National Opcodes", proto_ansi_tcap, FT_UINT16, BASE_DEC);
/* Required function calls to register the header fields and subtrees used */ /* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_ansi_tcap, hf, array_length(hf)); proto_register_field_array(proto_ansi_tcap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett)); proto_register_subtree_array(ett, array_length(ett));

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

@ -392,7 +392,7 @@ proto_register_arcnet (void)
proto_register_subtree_array (ett, array_length (ett)); proto_register_subtree_array (ett, array_length (ett));
arcnet_dissector_table = register_dissector_table ("arcnet.protocol_id", "ARCNET Protocol ID", arcnet_dissector_table = register_dissector_table ("arcnet.protocol_id", "ARCNET Protocol ID",
proto_arcnet, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_arcnet, FT_UINT8, BASE_HEX);
arcnet_address_type = address_type_dissector_register("AT_ARCNET", "ARCNET Address", arcnet_to_str, arcnet_str_len, NULL, arcnet_col_filter_str, arcnet_len, NULL, NULL); arcnet_address_type = address_type_dissector_register("AT_ARCNET", "ARCNET Address", arcnet_to_str, arcnet_str_len, NULL, arcnet_col_filter_str, arcnet_len, NULL, NULL);
} }

2
epan/dissectors/packet-aruba-erm.c
View File

@ -460,7 +460,7 @@ proto_register_aruba_erm(void)
aruba_erm_subdissector_table = register_dissector_table( aruba_erm_subdissector_table = register_dissector_table(
"aruba_erm.type", "Aruba ERM Type", proto_aruba_erm, "aruba_erm.type", "Aruba ERM Type", proto_aruba_erm,
FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT32, BASE_DEC);
register_decode_as(&aruba_erm_payload_da); register_decode_as(&aruba_erm_payload_da);

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

@ -2035,7 +2035,7 @@ proto_register_atalk(void)
/* subdissector code */ /* subdissector code */
ddp_dissector_table = register_dissector_table("ddp.type", "DDP packet type", proto_ddp, ddp_dissector_table = register_dissector_table("ddp.type", "DDP packet type", proto_ddp,
FT_UINT8, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); FT_UINT8, BASE_HEX);
atalk_address_type = address_type_dissector_register("AT_ATALK", "Appletalk DDP", atalk_to_str, atalk_str_len, NULL, atalk_col_filter_str, atalk_len, NULL, NULL); atalk_address_type = address_type_dissector_register("AT_ATALK", "Appletalk DDP", atalk_to_str, atalk_str_len, NULL, atalk_col_filter_str, atalk_len, NULL, NULL);
} }

4
epan/dissectors/packet-atm.c
View File

@ -1979,8 +1979,8 @@ proto_register_atm(void)
proto_atm_lane = proto_register_protocol("ATM LAN Emulation", "ATM LANE", "lane"); proto_atm_lane = proto_register_protocol("ATM LAN Emulation", "ATM LANE", "lane");
atm_type_aal2_table = register_dissector_table("atm.aal2.type", "ATM AAL_2 type subdissector", proto_atm, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); atm_type_aal2_table = register_dissector_table("atm.aal2.type", "ATM AAL_2 type subdissector", proto_atm, FT_UINT32, BASE_DEC);
atm_type_aal5_table = register_dissector_table("atm.aal5.type", "ATM AAL_5 type subdissector", proto_atm, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); atm_type_aal5_table = register_dissector_table("atm.aal5.type", "ATM AAL_5 type subdissector", proto_atm, FT_UINT32, BASE_DEC);
register_capture_dissector_table("atm.aal5.type", "ATM AAL_5"); register_capture_dissector_table("atm.aal5.type", "ATM AAL_5");
register_capture_dissector_table("atm_lane", "ATM LAN Emulation"); register_capture_dissector_table("atm_lane", "ATM LAN Emulation");

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

@ -409,7 +409,7 @@ proto_register_ax25(void)
proto_register_subtree_array(ett, array_length(ett ) ); proto_register_subtree_array(ett, array_length(ett ) );
/* Register dissector table for protocol IDs */ /* Register dissector table for protocol IDs */
ax25_dissector_table = register_dissector_table("ax25.pid", "AX.25 protocol ID", proto_ax25, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); ax25_dissector_table = register_dissector_table("ax25.pid", "AX.25 protocol ID", proto_ax25, FT_UINT8, BASE_HEX);
register_capture_dissector_table("ax25.pid", "AX.25"); register_capture_dissector_table("ax25.pid", "AX.25");
} }

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

@ -11353,7 +11353,7 @@ proto_register_bacapp(void)
bacapp_dissector_table = register_dissector_table("bacapp.vendor_identifier", bacapp_dissector_table = register_dissector_table("bacapp.vendor_identifier",
"BACapp Vendor Identifier", proto_bacapp, "BACapp Vendor Identifier", proto_bacapp,
FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT8, BASE_HEX);
/* Register BACnet Statistic trees */ /* Register BACnet Statistic trees */
register_bacapp_stat_trees(); register_bacapp_stat_trees();

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

@ -621,7 +621,7 @@ proto_register_bacnet(void)
bacnet_dissector_table = register_dissector_table("bacnet.vendor", bacnet_dissector_table = register_dissector_table("bacnet.vendor",
"BACnet Vendor Identifier", proto_bacnet, "BACnet Vendor Identifier", proto_bacnet,
FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT8, BASE_HEX);
} }
void void

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

@ -107,7 +107,7 @@ proto_register_bctp (void)
register_dissector("bctp", dissect_bctp, proto_bctp); register_dissector("bctp", dissect_bctp, proto_bctp);
bctp_dissector_table = register_dissector_table("bctp.tpi", "BCTP Tunneled Protocol Indicator", proto_bctp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); bctp_dissector_table = register_dissector_table("bctp.tpi", "BCTP Tunneled Protocol Indicator", proto_bctp, FT_UINT32, BASE_DEC);
} }
void void

4
epan/dissectors/packet-ber.c
View File

@ -4576,8 +4576,8 @@ proto_register_ber(void)
" and the syntax of any associated values", " and the syntax of any associated values",
users_uat); users_uat);
ber_oid_dissector_table = register_dissector_table("ber.oid", "BER OID Dissectors", proto_ber, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); ber_oid_dissector_table = register_dissector_table("ber.oid", "BER OID Dissectors", proto_ber, FT_STRING, BASE_NONE);
ber_syntax_dissector_table = register_dissector_table("ber.syntax", "BER syntax", proto_ber, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); ber_syntax_dissector_table = register_dissector_table("ber.syntax", "BER syntax", proto_ber, FT_STRING, BASE_NONE);
syntax_table = g_hash_table_new(g_str_hash, g_str_equal); /* oid to syntax */ syntax_table = g_hash_table_new(g_str_hash, g_str_equal); /* oid to syntax */
register_ber_syntax_dissector("ASN.1", proto_ber, dissect_ber_syntax); register_ber_syntax_dissector("ASN.1", proto_ber, dissect_ber_syntax);

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

@ -1860,7 +1860,7 @@ proto_register_bitcoin(void)
expert_bitcoin = expert_register_protocol(proto_bitcoin); expert_bitcoin = expert_register_protocol(proto_bitcoin);
expert_register_field_array(expert_bitcoin, ei, array_length(ei)); expert_register_field_array(expert_bitcoin, ei, array_length(ei));
bitcoin_command_table = register_dissector_table("bitcoin.command", "Bitcoin Command", proto_bitcoin, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); bitcoin_command_table = register_dissector_table("bitcoin.command", "Bitcoin Command", proto_bitcoin, FT_STRING, BASE_NONE);
bitcoin_handle = register_dissector("bitcoin", dissect_bitcoin, proto_bitcoin); bitcoin_handle = register_dissector("bitcoin", dissect_bitcoin, proto_bitcoin);

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

@ -871,7 +871,7 @@ proto_register_bluecom(void)
/* add dissector table */ /* add dissector table */
bcp_subdissector_table = register_dissector_table("bluecomseg", "bluecom SegCode", proto_bcp, bcp_subdissector_table = register_dissector_table("bluecomseg", "bluecom SegCode", proto_bcp,
FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT8, BASE_DEC);
} }
/* /*

6
epan/dissectors/packet-bluetooth.c
View File

@ -2226,7 +2226,7 @@ proto_register_bluetooth(void)
proto_register_subtree_array(ett, array_length(ett)); proto_register_subtree_array(ett, array_length(ett));
bluetooth_table = register_dissector_table("bluetooth.encap", bluetooth_table = register_dissector_table("bluetooth.encap",
"Bluetooth Encapsulation", proto_bluetooth, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "Bluetooth Encapsulation", proto_bluetooth, FT_UINT32, BASE_HEX);
chandle_sessions = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); chandle_sessions = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
chandle_to_bdaddr = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); chandle_to_bdaddr = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
@ -2237,14 +2237,14 @@ proto_register_bluetooth(void)
localhost_name = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); localhost_name = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
hci_vendors = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); hci_vendors = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
hci_vendor_table = register_dissector_table("bluetooth.vendor", "HCI Vendor", proto_bluetooth, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); hci_vendor_table = register_dissector_table("bluetooth.vendor", "HCI Vendor", proto_bluetooth, FT_UINT16, BASE_HEX);
bluetooth_uuids = wmem_tree_new(wmem_epan_scope()); bluetooth_uuids = wmem_tree_new(wmem_epan_scope());
bluetooth_tap = register_tap("bluetooth"); bluetooth_tap = register_tap("bluetooth");
bluetooth_device_tap = register_tap("bluetooth.device"); bluetooth_device_tap = register_tap("bluetooth.device");
bluetooth_hci_summary_tap = register_tap("bluetooth.hci_summary"); bluetooth_hci_summary_tap = register_tap("bluetooth.hci_summary");
bluetooth_uuid_table = register_dissector_table("bluetooth.uuid", "BT Service UUID", proto_bluetooth, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); bluetooth_uuid_table = register_dissector_table("bluetooth.uuid", "BT Service UUID", proto_bluetooth, FT_STRING, BASE_NONE);
llc_add_oui(OUI_BLUETOOTH, "llc.bluetooth_pid", "LLC Bluetooth OUI PID", oui_hf, proto_bluetooth); llc_add_oui(OUI_BLUETOOTH, "llc.bluetooth_pid", "LLC Bluetooth OUI PID", oui_hf, proto_bluetooth);
register_conversation_table(proto_bluetooth, TRUE, bluetooth_conversation_packet, bluetooth_hostlist_packet); register_conversation_table(proto_bluetooth, TRUE, bluetooth_conversation_packet, bluetooth_hostlist_packet);

4
epan/dissectors/packet-bssap.c
View File

@ -2545,8 +2545,8 @@ proto_register_bssap(void)
"Subsystem number used for BSSAP", "Subsystem number used for BSSAP",
"Set Subsystem number used for BSSAP/BSSAP+", "Set Subsystem number used for BSSAP/BSSAP+",
10, &global_bssap_ssn); 10, &global_bssap_ssn);
bssap_dissector_table = register_dissector_table("bssap.pdu_type", "BSSAP Message Type", proto_bssap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); bssap_dissector_table = register_dissector_table("bssap.pdu_type", "BSSAP Message Type", proto_bssap, FT_UINT8, BASE_DEC);
bsap_dissector_table = register_dissector_table("bsap.pdu_type", "BSAP Message Type", proto_bssap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); bsap_dissector_table = register_dissector_table("bsap.pdu_type", "BSAP Message Type", proto_bssap, FT_UINT8, BASE_DEC);
} }
void void

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

@ -15109,7 +15109,7 @@ proto_register_btatt(void)
btatt_handle = register_dissector("btatt", dissect_btatt, proto_btatt); btatt_handle = register_dissector("btatt", dissect_btatt, proto_btatt);
att_handle_dissector_table = register_dissector_table("btatt.handle", "BT ATT Handle", proto_btatt, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); att_handle_dissector_table = register_dissector_table("btatt.handle", "BT ATT Handle", proto_btatt, FT_UINT16, BASE_HEX);
/* Required function calls to register the header fields and subtrees used */ /* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_btatt, hf, array_length(hf)); proto_register_field_array(proto_btatt, hf, array_length(hf));

14
epan/dissectors/packet-btbredr_rf.c
View File

@ -897,13 +897,13 @@ proto_register_btbredr_rf(void)
proto_register_subtree_array(ett, array_length(ett)); proto_register_subtree_array(ett, array_length(ett));
btbredr_rf_handle = register_dissector("btbredr_rf", dissect_btbredr_rf, proto_btbredr_rf); btbredr_rf_handle = register_dissector("btbredr_rf", dissect_btbredr_rf, proto_btbredr_rf);
packet_type_sco_br_table = register_dissector_table("btbredr_rf.packet_type.sco.br", "BT Packet Type for SCO BR", proto_btbredr_rf, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); packet_type_sco_br_table = register_dissector_table("btbredr_rf.packet_type.sco.br", "BT Packet Type for SCO BR", proto_btbredr_rf, FT_UINT8, BASE_HEX);
packet_type_esco_br_table = register_dissector_table("btbredr_rf.packet_type.esco.br", "BT Packet Type for eSCO BR", proto_btbredr_rf, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); packet_type_esco_br_table = register_dissector_table("btbredr_rf.packet_type.esco.br", "BT Packet Type for eSCO BR", proto_btbredr_rf, FT_UINT8, BASE_HEX);
packet_type_esco_edr_table = register_dissector_table("btbredr_rf.packet_type.esco.edr", "BT Packet Type for eSCO EDR", proto_btbredr_rf, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); packet_type_esco_edr_table = register_dissector_table("btbredr_rf.packet_type.esco.edr", "BT Packet Type for eSCO EDR", proto_btbredr_rf, FT_UINT8, BASE_HEX);
packet_type_acl_br_table = register_dissector_table("btbredr_rf.packet_type.acl.br", "BT Packet Type for ACL BR", proto_btbredr_rf, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); packet_type_acl_br_table = register_dissector_table("btbredr_rf.packet_type.acl.br", "BT Packet Type for ACL BR", proto_btbredr_rf, FT_UINT8, BASE_HEX);
packet_type_acl_edr_table = register_dissector_table("btbredr_rf.packet_type.acl.edr", "BT Packet Type for ACL EDR", proto_btbredr_rf, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); packet_type_acl_edr_table = register_dissector_table("btbredr_rf.packet_type.acl.edr", "BT Packet Type for ACL EDR", proto_btbredr_rf, FT_UINT8, BASE_HEX);
packet_type_csb_br_table = register_dissector_table("btbredr_rf.packet_type.csb.br", "BT Packet Type for CSB BR", proto_btbredr_rf, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); packet_type_csb_br_table = register_dissector_table("btbredr_rf.packet_type.csb.br", "BT Packet Type for CSB BR", proto_btbredr_rf, FT_UINT8, BASE_HEX);
packet_type_csb_edr_table = register_dissector_table("btbredr_rf.packet_type.csb.edr", "BT Packet Type for CSB EDR", proto_btbredr_rf, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); packet_type_csb_edr_table = register_dissector_table("btbredr_rf.packet_type.csb.edr", "BT Packet Type for CSB EDR", proto_btbredr_rf, FT_UINT8, BASE_HEX);
expert_module = expert_register_protocol(proto_btbredr_rf); expert_module = expert_register_protocol(proto_btbredr_rf);
expert_register_field_array(expert_module, ei, array_length(ei)); expert_register_field_array(expert_module, ei, array_length(ei));

6
epan/dissectors/packet-bthci_cmd.c
View File

@ -5177,7 +5177,7 @@ proto_register_bthci_cmd(void)
bthci_cmds = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); bthci_cmds = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
vendor_dissector_table = register_dissector_table("bthci_cmd.vendor", "BT HCI Vendor", proto_bthci_cmd, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); vendor_dissector_table = register_dissector_table("bthci_cmd.vendor", "BT HCI Vendor", proto_bthci_cmd, FT_UINT16, BASE_HEX);
module = prefs_register_protocol(proto_bthci_cmd, NULL); module = prefs_register_protocol(proto_bthci_cmd, NULL);
prefs_register_static_text_preference(module, "hci_cmd.version", prefs_register_static_text_preference(module, "hci_cmd.version",
@ -6770,8 +6770,8 @@ proto_register_btcommon(void)
btcommon_cod_handle = register_dissector("btcommon.cod", dissect_btcommon_cod, proto_btcommon); btcommon_cod_handle = register_dissector("btcommon.cod", dissect_btcommon_cod, proto_btcommon);
btcommon_le_channel_map_handle = register_dissector("btcommon.le_channel_map", dissect_btcommon_le_channel_map, proto_btcommon); btcommon_le_channel_map_handle = register_dissector("btcommon.le_channel_map", dissect_btcommon_le_channel_map, proto_btcommon);
bluetooth_eir_ad_manufacturer_company_id = register_dissector_table("btcommon.eir_ad.manufacturer_company_id", "BT EIR/AD Manufacturer Company ID", proto_btcommon, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); bluetooth_eir_ad_manufacturer_company_id = register_dissector_table("btcommon.eir_ad.manufacturer_company_id", "BT EIR/AD Manufacturer Company ID", proto_btcommon, FT_UINT16, BASE_HEX);
bluetooth_eir_ad_tds_organization_id = register_dissector_table("btcommon.eir_ad.tds_organization_id", "BT EIR/AD TDS Organization ID", proto_btcommon, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); bluetooth_eir_ad_tds_organization_id = register_dissector_table("btcommon.eir_ad.tds_organization_id", "BT EIR/AD TDS Organization ID", proto_btcommon, FT_UINT8, BASE_HEX);
register_decode_as(&bluetooth_eir_ad_manufacturer_company_id_da); register_decode_as(&bluetooth_eir_ad_manufacturer_company_id_da);
register_decode_as(&bluetooth_eir_ad_tds_organization_id_da); register_decode_as(&bluetooth_eir_ad_tds_organization_id_da);

4
epan/dissectors/packet-btl2cap.c
View File

@ -3360,8 +3360,8 @@ proto_register_btl2cap(void)
register_dissector("btl2cap", dissect_btl2cap, proto_btl2cap); register_dissector("btl2cap", dissect_btl2cap, proto_btl2cap);
/* subdissector code */ /* subdissector code */
l2cap_psm_dissector_table = register_dissector_table("btl2cap.psm", "BT L2CAP PSM", proto_btl2cap, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); l2cap_psm_dissector_table = register_dissector_table("btl2cap.psm", "BT L2CAP PSM", proto_btl2cap, FT_UINT16, BASE_HEX);
l2cap_cid_dissector_table = register_dissector_table("btl2cap.cid", "BT L2CAP CID", proto_btl2cap, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); l2cap_cid_dissector_table = register_dissector_table("btl2cap.cid", "BT L2CAP CID", proto_btl2cap, FT_UINT16, BASE_HEX);
/* Required function calls to register the header fields and subtrees used */ /* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_btl2cap, hf, array_length(hf)); proto_register_field_array(proto_btl2cap, hf, array_length(hf));

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

@ -1140,7 +1140,7 @@ proto_register_btrfcomm(void)
service_directions = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); service_directions = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
rfcomm_dlci_dissector_table = register_dissector_table("btrfcomm.dlci", "BT RFCOMM Directed Channel", proto_btrfcomm, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); rfcomm_dlci_dissector_table = register_dissector_table("btrfcomm.dlci", "BT RFCOMM Directed Channel", proto_btrfcomm, FT_UINT16, BASE_DEC);
module = prefs_register_protocol(proto_btrfcomm, NULL); module = prefs_register_protocol(proto_btrfcomm, NULL);
prefs_register_static_text_preference(module, "rfcomm.version", prefs_register_static_text_preference(module, "rfcomm.version",

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

@ -406,7 +406,7 @@ proto_register_bvlc(void)
register_dissector("bvlc", dissect_bvlc, proto_bvlc); register_dissector("bvlc", dissect_bvlc, proto_bvlc);
bvlc_dissector_table = register_dissector_table("bvlc.function", bvlc_dissector_table = register_dissector_table("bvlc.function",
"BVLC Function", proto_bvlc, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "BVLC Function", proto_bvlc, FT_UINT8, BASE_HEX);
} }
void void

8
epan/dissectors/packet-c15ch.c
View File

@ -11972,7 +11972,7 @@ void proto_register_c15ch(void)
); );
proto_register_field_array(proto_c15ch_second_level, hf_second_level, array_length(hf_second_level)); proto_register_field_array(proto_c15ch_second_level, hf_second_level, array_length(hf_second_level));
proto_register_subtree_array(ett_second_level, array_length(ett_second_level)); proto_register_subtree_array(ett_second_level, array_length(ett_second_level));
c15ch_dissector_table = register_dissector_table("c15", "C15", proto_c15ch, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); c15ch_dissector_table = register_dissector_table("c15", "C15", proto_c15ch, FT_UINT32, BASE_DEC);
/* third level */ /* third level */
/* tone */ /* tone */
@ -11983,7 +11983,7 @@ void proto_register_c15ch(void)
); );
proto_register_field_array(proto_c15ch_third_level_tone, hf_third_level_tone, array_length(hf_third_level_tone)); proto_register_field_array(proto_c15ch_third_level_tone, hf_third_level_tone, array_length(hf_third_level_tone));
proto_register_subtree_array(ett_third_level_tone, array_length(ett_third_level_tone)); proto_register_subtree_array(ett_third_level_tone, array_length(ett_third_level_tone));
c15ch_tone_dissector_table = register_dissector_table("c15.tone", "C15.TONE", proto_c15ch_third_level_tone, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); c15ch_tone_dissector_table = register_dissector_table("c15.tone", "C15.TONE", proto_c15ch_third_level_tone, FT_UINT32, BASE_DEC);
/* inc gwe */ /* inc gwe */
proto_c15ch_third_level_inc_gwe = proto_register_protocol( proto_c15ch_third_level_inc_gwe = proto_register_protocol(
@ -11993,7 +11993,7 @@ void proto_register_c15ch(void)
); );
proto_register_field_array(proto_c15ch_third_level_inc_gwe, hf_third_level_inc_gwe, array_length(hf_third_level_inc_gwe)); proto_register_field_array(proto_c15ch_third_level_inc_gwe, hf_third_level_inc_gwe, array_length(hf_third_level_inc_gwe));
proto_register_subtree_array(ett_third_level_inc_gwe, array_length(ett_third_level_inc_gwe)); proto_register_subtree_array(ett_third_level_inc_gwe, array_length(ett_third_level_inc_gwe));
c15ch_inc_gwe_dissector_table = register_dissector_table("c15.inc_gwe", "C15.INC_GWE", proto_c15ch_third_level_inc_gwe, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); c15ch_inc_gwe_dissector_table = register_dissector_table("c15.inc_gwe", "C15.INC_GWE", proto_c15ch_third_level_inc_gwe, FT_UINT32, BASE_DEC);
/* out gwe */ /* out gwe */
proto_c15ch_third_level_out_gwe = proto_register_protocol( proto_c15ch_third_level_out_gwe = proto_register_protocol(
@ -12003,7 +12003,7 @@ void proto_register_c15ch(void)
); );
proto_register_field_array(proto_c15ch_third_level_out_gwe, hf_third_level_out_gwe, array_length(hf_third_level_out_gwe)); proto_register_field_array(proto_c15ch_third_level_out_gwe, hf_third_level_out_gwe, array_length(hf_third_level_out_gwe));
proto_register_subtree_array(ett_third_level_out_gwe, array_length(ett_third_level_out_gwe)); proto_register_subtree_array(ett_third_level_out_gwe, array_length(ett_third_level_out_gwe));
c15ch_out_gwe_dissector_table = register_dissector_table("c15.out_gwe", "C15.out_gwe", proto_c15ch_third_level_out_gwe, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); c15ch_out_gwe_dissector_table = register_dissector_table("c15.out_gwe", "C15.out_gwe", proto_c15ch_third_level_out_gwe, FT_UINT32, BASE_DEC);
} }

6
epan/dissectors/packet-camel.c
View File

@ -10680,13 +10680,13 @@ void proto_register_camel(void) {
/* Register dissector tables */ /* Register dissector tables */
camel_rose_ctx.arg_local_dissector_table = register_dissector_table("camel.ros.local.arg", camel_rose_ctx.arg_local_dissector_table = register_dissector_table("camel.ros.local.arg",
"CAMEL Operation Argument (local opcode)", proto_camel, "CAMEL Operation Argument (local opcode)", proto_camel,
FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT32, BASE_HEX);
camel_rose_ctx.res_local_dissector_table = register_dissector_table("camel.ros.local.res", camel_rose_ctx.res_local_dissector_table = register_dissector_table("camel.ros.local.res",
"CAMEL Operation Result (local opcode)", proto_camel, "CAMEL Operation Result (local opcode)", proto_camel,
FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT32, BASE_HEX);
camel_rose_ctx.err_local_dissector_table = register_dissector_table("camel.ros.local.err", camel_rose_ctx.err_local_dissector_table = register_dissector_table("camel.ros.local.err",
"CAMEL Error (local opcode)", proto_camel, "CAMEL Error (local opcode)", proto_camel,
FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT32, BASE_HEX);
/* Register our configuration options, particularly our SSNs */ /* Register our configuration options, particularly our SSNs */
/* Set default SSNs */ /* Set default SSNs */

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

@ -715,7 +715,7 @@ proto_register_ccsds(void)
&global_dissect_checkword, dissect_checkword, FALSE); &global_dissect_checkword, dissect_checkword, FALSE);
/* Dissector table for sub-dissetors */ /* Dissector table for sub-dissetors */
ccsds_dissector_table = register_dissector_table("ccsds.apid", "CCSDS apid", proto_ccsds, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); ccsds_dissector_table = register_dissector_table("ccsds.apid", "CCSDS apid", proto_ccsds, FT_UINT16, BASE_DEC);
} }

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

@ -231,7 +231,7 @@ proto_register_chdlc(void)
/* subdissector code */ /* subdissector code */
subdissector_table = register_dissector_table("chdlc.protocol", subdissector_table = register_dissector_table("chdlc.protocol",
"Cisco HDLC protocol", proto_chdlc, "Cisco HDLC protocol", proto_chdlc,
FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT16, BASE_HEX);
register_dissector("chdlc", dissect_chdlc, proto_chdlc); register_dissector("chdlc", dissect_chdlc, proto_chdlc);

4
epan/dissectors/packet-cip.c
View File

@ -7989,9 +7989,9 @@ proto_register_cip(void)
&cip_enhanced_info_column); &cip_enhanced_info_column);
subdissector_class_table = register_dissector_table("cip.class.iface", subdissector_class_table = register_dissector_table("cip.class.iface",
"CIP Class Interface Handle", proto_cip, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "CIP Class Interface Handle", proto_cip, FT_UINT32, BASE_HEX);
subdissector_symbol_table = register_dissector_table("cip.data_segment.iface", subdissector_symbol_table = register_dissector_table("cip.data_segment.iface",
"CIP Data Segment Interface Handle", proto_cip, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "CIP Data Segment Interface Handle", proto_cip, FT_UINT32, BASE_HEX);
/* Register the protocol name and description */ /* Register the protocol name and description */
proto_cip_class_generic = proto_register_protocol("CIP Class Generic", proto_cip_class_generic = proto_register_protocol("CIP Class Generic",

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

@ -5897,7 +5897,7 @@ void proto_register_cmip(void) {
#line 201 "./asn1/cmip/packet-cmip-template.c" #line 201 "./asn1/cmip/packet-cmip-template.c"
oid_add_from_string("discriminatorId(1)","2.9.3.2.7.1"); oid_add_from_string("discriminatorId(1)","2.9.3.2.7.1");
attribute_id_dissector_table = register_dissector_table("cmip.attribute_id", "CMIP Attribute Id", proto_cmip, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); attribute_id_dissector_table = register_dissector_table("cmip.attribute_id", "CMIP Attribute Id", proto_cmip, FT_UINT32, BASE_DEC);
} }

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

@ -234,7 +234,7 @@ void proto_register_cnip(void)
/* Register table for subdissectors */ /* Register table for subdissectors */
cnip_dissector_table = register_dissector_table("cnip.protocol", cnip_dissector_table = register_dissector_table("cnip.protocol",
"CN/IP Protocol", proto_cnip, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "CN/IP Protocol", proto_cnip, FT_UINT8, BASE_DEC);
} }
void proto_reg_handoff_cnip(void) void proto_reg_handoff_cnip(void)

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

@ -1278,7 +1278,7 @@ proto_register_dccp(void)
/* subdissectors */ /* subdissectors */
dccp_subdissector_table = dccp_subdissector_table =
register_dissector_table("dccp.port", "DCCP port", proto_dccp, FT_UINT16, register_dissector_table("dccp.port", "DCCP port", proto_dccp, FT_UINT16,
BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); BASE_DEC);
heur_subdissector_list = register_heur_dissector_list("dccp", proto_dccp); heur_subdissector_list = register_heur_dissector_list("dccp", proto_dccp);
/* reg preferences */ /* reg preferences */

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

@ -6944,7 +6944,7 @@ proto_register_dcerpc(void)
expert_dcerpc = expert_register_protocol(proto_dcerpc); expert_dcerpc = expert_register_protocol(proto_dcerpc);
expert_register_field_array(expert_dcerpc, ei, array_length(ei)); expert_register_field_array(expert_dcerpc, ei, array_length(ei));
uuid_dissector_table = register_dissector_table("dcerpc.uuid", "DCE/RPC UUIDs", proto_dcerpc, FT_GUID, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); uuid_dissector_table = register_dissector_table("dcerpc.uuid", "DCE/RPC UUIDs", proto_dcerpc, FT_GUID, BASE_HEX);
register_init_routine(dcerpc_init_protocol); register_init_routine(dcerpc_init_protocol);
register_cleanup_routine(dcerpc_cleanup_protocol); register_cleanup_routine(dcerpc_cleanup_protocol);

6
epan/dissectors/packet-dcp-etsi.c
View File

@ -888,12 +888,12 @@ proto_register_dcp_etsi (void)
/* subdissector code */ /* subdissector code */
dcp_dissector_table = register_dissector_table("dcp-etsi.sync", dcp_dissector_table = register_dissector_table("dcp-etsi.sync",
"DCP Sync", proto_dcp_etsi, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "DCP Sync", proto_dcp_etsi, FT_STRING, BASE_NONE);
af_dissector_table = register_dissector_table("dcp-af.pt", af_dissector_table = register_dissector_table("dcp-af.pt",
"DCP-AF Payload Type", proto_dcp_etsi, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "DCP-AF Payload Type", proto_dcp_etsi, FT_UINT8, BASE_DEC);
tpl_dissector_table = register_dissector_table("dcp-tpl.ptr", tpl_dissector_table = register_dissector_table("dcp-tpl.ptr",
"DCP-TPL Protocol Type & Revision", proto_dcp_etsi, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "DCP-TPL Protocol Type & Revision", proto_dcp_etsi, FT_STRING, BASE_NONE);
register_init_routine(dcp_init_protocol); register_init_routine(dcp_init_protocol);
register_cleanup_routine(dcp_cleanup_protocol); register_cleanup_routine(dcp_cleanup_protocol);

8
epan/dissectors/packet-diameter.c
View File

@ -2326,11 +2326,11 @@ proto_register_diameter(void)
proto_register_prefix("diameter", register_diameter_fields); proto_register_prefix("diameter", register_diameter_fields);
/* Register dissector table(s) to do sub dissection of AVPs (OctetStrings) */ /* Register dissector table(s) to do sub dissection of AVPs (OctetStrings) */
diameter_dissector_table = register_dissector_table("diameter.base", "DIAMETER_BASE_AVPS", proto_diameter, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); diameter_dissector_table = register_dissector_table("diameter.base", "DIAMETER_BASE_AVPS", proto_diameter, FT_UINT32, BASE_DEC);
diameter_3gpp_avp_dissector_table = register_dissector_table("diameter.3gpp", "DIAMETER_3GPP_AVPS", proto_diameter, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); diameter_3gpp_avp_dissector_table = register_dissector_table("diameter.3gpp", "DIAMETER_3GPP_AVPS", proto_diameter, FT_UINT32, BASE_DEC);
diameter_ericsson_avp_dissector_table = register_dissector_table("diameter.ericsson", "DIAMETER_ERICSSON_AVPS", proto_diameter, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); diameter_ericsson_avp_dissector_table = register_dissector_table("diameter.ericsson", "DIAMETER_ERICSSON_AVPS", proto_diameter, FT_UINT32, BASE_DEC);
diameter_expr_result_vnd_table = register_dissector_table("diameter.vnd_exp_res", "DIAMETER Experimental-Result-Code", proto_diameter, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); diameter_expr_result_vnd_table = register_dissector_table("diameter.vnd_exp_res", "DIAMETER Experimental-Result-Code", proto_diameter, FT_UINT32, BASE_DEC);
/* Set default TCP ports */ /* Set default TCP ports */
range_convert_str(&global_diameter_tcp_port_range, DEFAULT_DIAMETER_PORT_RANGE, MAX_UDP_PORT); range_convert_str(&global_diameter_tcp_port_range, DEFAULT_DIAMETER_PORT_RANGE, MAX_UDP_PORT);

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

@ -413,7 +413,7 @@ proto_register_dmx(void)
register_dissector("dmx", dissect_dmx, proto_dmx); register_dissector("dmx", dissect_dmx, proto_dmx);
dmx_dissector_table = register_dissector_table("dmx", "DMX Start Code", proto_dmx, dmx_dissector_table = register_dissector_table("dmx", "DMX Start Code", proto_dmx,
FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT8, BASE_DEC);
} }

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

@ -5605,7 +5605,7 @@ proto_register_dns(void)
"DNS address resolution settings can be changed in the Name Resolution preferences", "DNS address resolution settings can be changed in the Name Resolution preferences",
"DNS address resolution settings can be changed in the Name Resolution preferences"); "DNS address resolution settings can be changed in the Name Resolution preferences");
dns_tsig_dissector_table = register_dissector_table("dns.tsig.mac", "DNS TSIG MAC Dissectors", proto_dns, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); dns_tsig_dissector_table = register_dissector_table("dns.tsig.mac", "DNS TSIG MAC Dissectors", proto_dns, FT_STRING, BASE_NONE);
dns_handle = register_dissector("dns", dissect_dns, proto_dns); dns_handle = register_dissector("dns", dissect_dns, proto_dns);

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

@ -10574,7 +10574,7 @@ static void dof_tun_register(void)
proto_register_subtree_array(ett, array_length(ett)); proto_register_subtree_array(ett, array_length(ett));
register_dissector(TUNNEL_PROTOCOL_STACK, dissect_tunnel_common, proto_2012_1_tunnel); register_dissector(TUNNEL_PROTOCOL_STACK, dissect_tunnel_common, proto_2012_1_tunnel);
dof_tun_app_dissectors = register_dissector_table("dof.tunnel.app", "DOF Tunnel Version", proto_2012_1_tunnel, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); dof_tun_app_dissectors = register_dissector_table("dof.tunnel.app", "DOF Tunnel Version", proto_2012_1_tunnel, FT_UINT8, BASE_DEC);
} }
static void dof_tun_reset(void) static void dof_tun_reset(void)
@ -10944,9 +10944,9 @@ static void dof_register(void)
char *uat_load_err; char *uat_load_err;
expert_module_t *expert_security; expert_module_t *expert_security;
dsp_option_dissectors = register_dissector_table("dof.dsp.options", "DSP Protocol Options", proto_2008_1_dsp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); dsp_option_dissectors = register_dissector_table("dof.dsp.options", "DSP Protocol Options", proto_2008_1_dsp, FT_UINT32, BASE_DEC);
dof_sec_dissectors = register_dissector_table("dof.secmode", "DOF Security Mode of Operation", proto_2008_1_dof, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); dof_sec_dissectors = register_dissector_table("dof.secmode", "DOF Security Mode of Operation", proto_2008_1_dof, FT_UINT16, BASE_DEC);
register_dissector_table("dof.2008.1", "DOF Common PDU", proto_2008_1_dof, FT_STRING, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_dissector_table("dof.2008.1", "DOF Common PDU", proto_2008_1_dof, FT_STRING, BASE_DEC);
proto_2008_1_dof = proto_register_protocol(DOF_PROTOCOL_STACK, "DOF", "dof"); proto_2008_1_dof = proto_register_protocol(DOF_PROTOCOL_STACK, "DOF", "dof");
@ -11308,8 +11308,8 @@ static void dof_dnp_register(void)
proto_register_field_array(proto_2008_1_dnp, hf, array_length(hf)); proto_register_field_array(proto_2008_1_dnp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett)); proto_register_subtree_array(ett, array_length(ett));
dnp_dissectors = register_dissector_table("dof.dnp", "DOF DNP Version", proto_2008_1_dnp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); dnp_dissectors = register_dissector_table("dof.dnp", "DOF DNP Version", proto_2008_1_dnp, FT_UINT8, BASE_DEC);
dnp_framing_dissectors = register_dissector_table("dof.dnp.frame", "DOF DNP Framing", proto_2008_1_dnp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); dnp_framing_dissectors = register_dissector_table("dof.dnp.frame", "DOF DNP Framing", proto_2008_1_dnp, FT_UINT8, BASE_DEC);
dof_register_dnp_0(); dof_register_dnp_0();
dof_register_dnp_1(); dof_register_dnp_1();
@ -11531,7 +11531,7 @@ static void dof_dpp_register(void)
proto_register_field_array(proto_2008_1_dpp, hf, array_length(hf)); proto_register_field_array(proto_2008_1_dpp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett)); proto_register_subtree_array(ett, array_length(ett));
dof_dpp_dissectors = register_dissector_table("dof.dpp", "DOF DPP Version", proto_2008_1_dpp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); dof_dpp_dissectors = register_dissector_table("dof.dpp", "DOF DPP Version", proto_2008_1_dpp, FT_UINT8, BASE_DEC);
expert_dpp = expert_register_protocol(proto_2008_1_dpp); expert_dpp = expert_register_protocol(proto_2008_1_dpp);
expert_register_field_array(expert_dpp, ei, array_length(ei)); expert_register_field_array(expert_dpp, ei, array_length(ei));
@ -11565,7 +11565,7 @@ static void app_register(void)
if (proto_2008_1_app == -1) if (proto_2008_1_app == -1)
{ {
proto_2008_1_app = proto_register_protocol(DOF_APPLICATION_PROTOCOL, "DPS.APP", "dof.app"); proto_2008_1_app = proto_register_protocol(DOF_APPLICATION_PROTOCOL, "DPS.APP", "dof.app");
app_dissectors = register_dissector_table("dof.app", "DOF APP Version", proto_2008_1_app, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); app_dissectors = register_dissector_table("dof.app", "DOF APP Version", proto_2008_1_app, FT_UINT16, BASE_DEC);
} }
} }

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

@ -3056,7 +3056,7 @@ void proto_register_dop(void) {
register_dissector("dop", dissect_dop, proto_dop); register_dissector("dop", dissect_dop, proto_dop);
dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", proto_dop, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", proto_dop, FT_STRING, BASE_NONE);
/* Register fields and subtrees */ /* Register fields and subtrees */
proto_register_field_array(proto_dop, hf, array_length(hf)); proto_register_field_array(proto_dop, hf, array_length(hf));

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

@ -1771,7 +1771,7 @@ proto_register_dtls(void)
proto_dtls = proto_register_protocol("Datagram Transport Layer Security", proto_dtls = proto_register_protocol("Datagram Transport Layer Security",
"DTLS", "dtls"); "DTLS", "dtls");
dtls_associations = register_dissector_table("dtls.port", "DTLS UDP Dissector", proto_dtls, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); dtls_associations = register_dissector_table("dtls.port", "DTLS UDP Dissector", proto_dtls, FT_UINT16, BASE_DEC);
/* Required function calls to register the header fields and /* Required function calls to register the header fields and
* subtrees used */ * subtrees used */

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

@ -6343,7 +6343,7 @@ proto_register_dvbci(void)
&dvbci_dissect_lsc_msg); &dvbci_dissect_lsc_msg);
sas_msg_dissector_table = register_dissector_table("dvb-ci.sas.app_id_str", sas_msg_dissector_table = register_dissector_table("dvb-ci.sas.app_id_str",
"SAS application id", proto_dvbci, FT_STRING, STR_ASCII, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "SAS application id", proto_dvbci, FT_STRING, STR_ASCII);
register_init_routine(dvbci_init); register_init_routine(dvbci_init);
register_cleanup_routine(dvbci_cleanup); register_cleanup_routine(dvbci_cleanup);

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

@ -308,7 +308,7 @@ proto_register_eapol(void)
eapol_keydes_type_dissector_table = register_dissector_table("eapol.keydes.type", eapol_keydes_type_dissector_table = register_dissector_table("eapol.keydes.type",
"EAPOL Key Descriptor Type", "EAPOL Key Descriptor Type",
proto_eapol, FT_UINT8, proto_eapol, FT_UINT8,
BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); BASE_DEC);
} }
void void

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

@ -444,7 +444,7 @@ proto_register_ecp(void)
proto_register_field_array(proto_ecp, hf, array_length(hf)); proto_register_field_array(proto_ecp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett)); proto_register_subtree_array(ett, array_length(ett));
ecp_subdissector_table = register_dissector_table("ecp.subtype", "ECP Subtypes", proto_ecp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); ecp_subdissector_table = register_dissector_table("ecp.subtype", "ECP Subtypes", proto_ecp, FT_UINT32, BASE_DEC);
} }
void void

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

@ -159,7 +159,7 @@ proto_register_enc(void)
proto_register_field_array(proto_enc, hf, array_length(hf)); proto_register_field_array(proto_enc, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett)); proto_register_subtree_array(ett, array_length(ett));
enc_dissector_table = register_dissector_table("enc", "OpenBSD Encapsulating device", proto_enc, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); enc_dissector_table = register_dissector_table("enc", "OpenBSD Encapsulating device", proto_enc, FT_UINT32, BASE_DEC);
register_capture_dissector_table("enc", "ENC"); register_capture_dissector_table("enc", "ENC");
} }

6
epan/dissectors/packet-enip.c
View File

@ -4374,12 +4374,12 @@ proto_register_enip(void)
prefs_register_obsolete_preference(enip_module, "default_io_dissector"); prefs_register_obsolete_preference(enip_module, "default_io_dissector");
subdissector_sud_table = register_dissector_table("enip.sud.iface", subdissector_sud_table = register_dissector_table("enip.sud.iface",
"ENIP SendUnitData.Interface Handle", proto_enip, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "ENIP SendUnitData.Interface Handle", proto_enip, FT_UINT32, BASE_HEX);
subdissector_srrd_table = register_dissector_table("enip.srrd.iface", subdissector_srrd_table = register_dissector_table("enip.srrd.iface",
"ENIP SendRequestReplyData.Interface Handle", proto_enip, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "ENIP SendRequestReplyData.Interface Handle", proto_enip, FT_UINT32, BASE_HEX);
subdissector_io_table = register_dissector_table("enip.io", "ENIP IO dissector", proto_enip, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); subdissector_io_table = register_dissector_table("enip.io", "ENIP IO dissector", proto_enip, FT_UINT32, BASE_DEC);
register_init_routine(&enip_init_protocol); register_init_routine(&enip_init_protocol);
register_cleanup_routine(&enip_cleanup_protocol); register_cleanup_routine(&enip_cleanup_protocol);

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

@ -4530,7 +4530,7 @@ proto_register_epl(void)
heur_epl_subdissector_list = register_heur_dissector_list("epl", proto_epl); heur_epl_subdissector_list = register_heur_dissector_list("epl", proto_epl);
heur_epl_data_subdissector_list = register_heur_dissector_list("epl_data", proto_epl); heur_epl_data_subdissector_list = register_heur_dissector_list("epl_data", proto_epl);
epl_asnd_dissector_table = register_dissector_table("epl.asnd", epl_asnd_dissector_table = register_dissector_table("epl.asnd",
"Manufacturer specific ASND service", proto_epl, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "Manufacturer specific ASND service", proto_epl, FT_UINT8, BASE_DEC);
/* Registering protocol to be called by another dissector */ /* Registering protocol to be called by another dissector */
epl_handle = register_dissector("epl", dissect_epl, proto_epl); epl_handle = register_dissector("epl", dissect_epl, proto_epl);

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

@ -3238,7 +3238,7 @@ proto_register_erf(void)
*/ */
prefs_register_obsolete_preference(erf_module, "ethfcs"); prefs_register_obsolete_preference(erf_module, "ethfcs");
erf_dissector_table = register_dissector_table("erf.types.type", "Type", proto_erf, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); erf_dissector_table = register_dissector_table("erf.types.type", "Type", proto_erf, FT_UINT8, BASE_DEC);
register_init_routine(erf_init_dissection); register_init_routine(erf_init_dissection);
/* No extra cleanup needed */ /* No extra cleanup needed */

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

@ -355,7 +355,7 @@ proto_register_ethertype(void)
/* subdissector code */ /* subdissector code */
ethertype_dissector_table = register_dissector_table("ethertype", ethertype_dissector_table = register_dissector_table("ethertype",
"Ethertype", proto_ethertype, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "Ethertype", proto_ethertype, FT_UINT16, BASE_HEX);
register_capture_dissector_table("ethertype", "Ethertype"); register_capture_dissector_table("ethertype", "Ethertype");
register_decode_as(&ethertype_da); register_decode_as(&ethertype_da);

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

@ -1559,7 +1559,7 @@ proto_register_fc(void)
*/ */
fcftype_dissector_table = register_dissector_table ("fc.ftype", fcftype_dissector_table = register_dissector_table ("fc.ftype",
"FC Frame Type", "FC Frame Type",
proto_fc, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_fc, FT_UINT8, BASE_HEX);
/* Register preferences */ /* Register preferences */
fc_module = prefs_register_protocol (proto_fc, NULL); fc_module = prefs_register_protocol (proto_fc, NULL);

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

@ -275,7 +275,7 @@ proto_register_fcct(void)
fcct_gserver_table = register_dissector_table ("fcct.server", fcct_gserver_table = register_dissector_table ("fcct.server",
"FCCT Server", "FCCT Server",
proto_fcct, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_fcct, FT_UINT8, BASE_HEX);
} }
void void

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

@ -460,7 +460,7 @@ proto_register_flexray(void)
register_decode_as(&flexray_da); register_decode_as(&flexray_da);
subdissector_table = register_dissector_table("flexray.subdissector", subdissector_table = register_dissector_table("flexray.subdissector",
"FLEXRAY next level dissector", proto_flexray, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "FLEXRAY next level dissector", proto_flexray, FT_UINT32, BASE_HEX);
} }
void void

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

@ -466,7 +466,7 @@ proto_register_flip(void)
proto_register_field_array(proto_flip, hf, array_length(hf)); proto_register_field_array(proto_flip, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett)); proto_register_subtree_array(ett, array_length(ett));
subdissector_table = register_dissector_table("flip.payload", "FLIP subdissector", proto_flip, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); subdissector_table = register_dissector_table("flip.payload", "FLIP subdissector", proto_flip, FT_UINT32, BASE_HEX);
flip_module = prefs_register_protocol(proto_flip, NULL); flip_module = prefs_register_protocol(proto_flip, NULL);

4
epan/dissectors/packet-fr.c
View File

@ -969,9 +969,9 @@ proto_register_fr(void)
expert_register_field_array(expert_fr, ei, array_length(ei)); expert_register_field_array(expert_fr, ei, array_length(ei));
fr_subdissector_table = register_dissector_table("fr.nlpid", fr_subdissector_table = register_dissector_table("fr.nlpid",
"Frame Relay NLPID", proto_fr, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "Frame Relay NLPID", proto_fr, FT_UINT8, BASE_HEX);
fr_osinl_subdissector_table = register_dissector_table("fr.osinl", fr_osinl_subdissector_table = register_dissector_table("fr.osinl",
"Frame Relay OSI NLPID", proto_fr, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "Frame Relay OSI NLPID", proto_fr, FT_UINT8, BASE_HEX);
register_dissector("fr_uncompressed", dissect_fr_uncompressed, proto_fr); register_dissector("fr_uncompressed", dissect_fr_uncompressed, proto_fr);
register_dissector("fr", dissect_fr, proto_fr); register_dissector("fr", dissect_fr, proto_fr);

4
epan/dissectors/packet-frame.c
View File

@ -917,9 +917,9 @@ proto_register_frame(void)
register_dissector("frame",dissect_frame,proto_frame); register_dissector("frame",dissect_frame,proto_frame);
wtap_encap_dissector_table = register_dissector_table("wtap_encap", wtap_encap_dissector_table = register_dissector_table("wtap_encap",
"Wiretap encapsulation type", proto_frame, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); "Wiretap encapsulation type", proto_frame, FT_UINT32, BASE_DEC);
wtap_fts_rec_dissector_table = register_dissector_table("wtap_fts_rec", wtap_fts_rec_dissector_table = register_dissector_table("wtap_fts_rec",
"Wiretap file type for file-type-specific records", proto_frame, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); "Wiretap file type for file-type-specific records", proto_frame, FT_UINT32, BASE_DEC);
register_capture_dissector_table("wtap_encap", "Wiretap encapsulation type"); register_capture_dissector_table("wtap_encap", "Wiretap encapsulation type");
/* You can't disable dissection of "Frame", as that would be /* You can't disable dissection of "Frame", as that would be

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

@ -578,7 +578,7 @@ proto_register_gfp(void)
/* Subdissectors for payload */ /* Subdissectors for payload */
gfp_dissector_table = register_dissector_table("gfp.upi", "GFP UPI (for Client Data frames)", gfp_dissector_table = register_dissector_table("gfp.upi", "GFP UPI (for Client Data frames)",
proto_gfp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_gfp, FT_UINT8, BASE_DEC);
/* Don't register a preferences module yet since there are no prefs in /* Don't register a preferences module yet since there are no prefs in
* order to avoid a warning. (See section 2.6 of README.dissector * order to avoid a warning. (See section 2.6 of README.dissector

2
epan/dissectors/packet-gprs-llc.c
View File

@ -1325,7 +1325,7 @@ proto_register_llcgprs(void)
/* Register the protocol name and description */ /* Register the protocol name and description */
proto_llcgprs = proto_register_protocol("Logical Link Control GPRS", proto_llcgprs = proto_register_protocol("Logical Link Control GPRS",
"GPRS-LLC", "llcgprs"); "GPRS-LLC", "llcgprs");
llcgprs_subdissector_table = register_dissector_table("llcgprs.sapi", "GPRS LLC SAPI", proto_llcgprs, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); llcgprs_subdissector_table = register_dissector_table("llcgprs.sapi", "GPRS LLC SAPI", proto_llcgprs, FT_UINT8, BASE_HEX);
/* Required function calls to register the header fields and subtrees used */ /* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_llcgprs, hf, array_length(hf)); proto_register_field_array(proto_llcgprs, hf, array_length(hf));

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

@ -746,7 +746,7 @@ proto_register_gre(void)
/* subdissector code */ /* subdissector code */
gre_dissector_table = register_dissector_table("gre.proto", gre_dissector_table = register_dissector_table("gre.proto",
"GRE protocol type", proto_gre, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); "GRE protocol type", proto_gre, FT_UINT16, BASE_HEX);
} }
void void

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

@ -8309,7 +8309,7 @@ proto_register_gsm_a_dtap(void)
/* subdissector code */ /* subdissector code */
register_dissector("gsm_a_dtap", dissect_dtap, proto_a_dtap); register_dissector("gsm_a_dtap", dissect_dtap, proto_a_dtap);
u2u_dissector_table = register_dissector_table("gsm_a.dtap.u2u_prot_discr", "GSM User to User Signalling", u2u_dissector_table = register_dissector_table("gsm_a.dtap.u2u_prot_discr", "GSM User to User Signalling",
proto_a_dtap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_a_dtap, FT_UINT8, BASE_DEC);
} }
void void

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

@ -8867,7 +8867,7 @@ proto_register_gsm_a_gm(void)
/* subdissector code */ /* subdissector code */
gprs_sm_pco_subdissector_table = register_dissector_table("sm_pco.protocol", gprs_sm_pco_subdissector_table = register_dissector_table("sm_pco.protocol",
"GPRS SM PCO PPP protocol", proto_a_gm, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "GPRS SM PCO PPP protocol", proto_a_gm, FT_UINT16, BASE_HEX);
} }
void void

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

@ -455,7 +455,7 @@ void proto_register_ipa(void)
/* Register table for subdissectors */ /* Register table for subdissectors */
osmo_dissector_table = register_dissector_table("ipa.osmo.protocol", osmo_dissector_table = register_dissector_table("ipa.osmo.protocol",
"GSM over IP ip.access Protocol", proto_ipa, "GSM over IP ip.access Protocol", proto_ipa,
FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); FT_UINT8, BASE_DEC);
range_convert_str(&global_ipa_tcp_ports, IPA_TCP_PORTS, MAX_TCP_PORT); range_convert_str(&global_ipa_tcp_ports, IPA_TCP_PORTS, MAX_TCP_PORT);

10
epan/dissectors/packet-gsm_map.c
View File

@ -31128,12 +31128,12 @@ void proto_register_gsm_map(void) {
expert_gsm_map = expert_register_protocol(proto_gsm_map); expert_gsm_map = expert_register_protocol(proto_gsm_map);
expert_register_field_array(expert_gsm_map, ei, array_length(ei)); expert_register_field_array(expert_gsm_map, ei, array_length(ei));
register_dissector_table("gsm_map.v3.arg.opcode", "GSM_MAP V3 Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_dissector_table("gsm_map.v3.arg.opcode", "GSM_MAP V3 Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC);
register_dissector_table("gsm_map.v3.res.opcode", "GSM_MAP V3 Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_dissector_table("gsm_map.v3.res.opcode", "GSM_MAP V3 Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC);
map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC);
map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC);
map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC);
gsm_map_tap = register_tap("gsm_map"); gsm_map_tap = register_tap("gsm_map");

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

@ -3347,7 +3347,7 @@ proto_register_gsm_sms(void)
expert_register_field_array(expert_gsm_sms, ei, array_length(ei)); expert_register_field_array(expert_gsm_sms, ei, array_length(ei));
gsm_sms_dissector_tbl = register_dissector_table("gsm_sms.udh.port", gsm_sms_dissector_tbl = register_dissector_table("gsm_sms.udh.port",
"GSM SMS port IE in UDH", proto_gsm_sms, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "GSM SMS port IE in UDH", proto_gsm_sms, FT_UINT16, BASE_DEC);
gsm_sms_module = prefs_register_protocol (proto_gsm_sms, NULL); gsm_sms_module = prefs_register_protocol (proto_gsm_sms, NULL);

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

@ -707,7 +707,7 @@ proto_register_gsm_sms_ud(void)
/* Subdissector code */ /* Subdissector code */
gsm_sms_dissector_table = register_dissector_table("gsm_sms_ud.udh.port", gsm_sms_dissector_table = register_dissector_table("gsm_sms_ud.udh.port",
"GSM SMS port IE in UDH", proto_gsm_sms_ud, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "GSM SMS port IE in UDH", proto_gsm_sms_ud, FT_UINT16, BASE_DEC);
/* Preferences for GSM SMS UD */ /* Preferences for GSM SMS UD */
gsm_sms_ud_module = prefs_register_protocol(proto_gsm_sms_ud, NULL); gsm_sms_ud_module = prefs_register_protocol(proto_gsm_sms_ud, NULL);

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

@ -775,7 +775,7 @@ proto_register_gsmtap(void)
proto_register_subtree_array(ett, array_length(ett)); proto_register_subtree_array(ett, array_length(ett));
gsmtap_dissector_table = register_dissector_table("gsmtap.type", gsmtap_dissector_table = register_dissector_table("gsmtap.type",
"GSMTAP type", proto_gsmtap, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); "GSMTAP type", proto_gsmtap, FT_UINT8, BASE_HEX);
} }
void void

4
epan/dissectors/packet-gtp.c
View File

@ -10159,8 +10159,8 @@ proto_register_gtp(void)
register_dissector("gtp", dissect_gtp, proto_gtp); register_dissector("gtp", dissect_gtp, proto_gtp);
register_dissector("gtpprime", dissect_gtpprime, proto_gtpprime); register_dissector("gtpprime", dissect_gtpprime, proto_gtpprime);
gtp_priv_ext_dissector_table = register_dissector_table("gtp.priv_ext", "GTP PRIVATE EXT", proto_gtp, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); gtp_priv_ext_dissector_table = register_dissector_table("gtp.priv_ext", "GTP PRIVATE EXT", proto_gtp, FT_UINT16, BASE_DEC);
gtp_cdr_fmt_dissector_table = register_dissector_table("gtp.cdr_fmt", "GTP DATA RECORD TYPE", proto_gtp, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); gtp_cdr_fmt_dissector_table = register_dissector_table("gtp.cdr_fmt", "GTP DATA RECORD TYPE", proto_gtp, FT_UINT16, BASE_DEC);
register_init_routine(gtp_init); register_init_routine(gtp_init);
register_cleanup_routine(gtp_cleanup); register_cleanup_routine(gtp_cleanup);

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

@ -8896,7 +8896,7 @@ void proto_register_gtpv2(void)
register_dissector("gtpv2", dissect_gtpv2, proto_gtpv2); register_dissector("gtpv2", dissect_gtpv2, proto_gtpv2);
/* Dissector table for private extensions */ /* Dissector table for private extensions */
gtpv2_priv_ext_dissector_table = register_dissector_table("gtpv2.priv_ext", "GTPv2 PRIVATE EXT", proto_gtpv2, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); gtpv2_priv_ext_dissector_table = register_dissector_table("gtpv2.priv_ext", "GTPv2 PRIVATE EXT", proto_gtpv2, FT_UINT16, BASE_DEC);
} }
void void

Some files were not shown because too many files have changed in this diff Show More