diff options
199 files changed, 489 insertions, 429 deletions
diff --git a/asn1/ansi_map/packet-ansi_map-template.c b/asn1/ansi_map/packet-ansi_map-template.c index c0ba2641f9..64448fbd48 100644 --- a/asn1/ansi_map/packet-ansi_map-template.c +++ b/asn1/ansi_map/packet-ansi_map-template.c @@ -5461,15 +5461,15 @@ void proto_register_ansi_map(void) { is637_tele_id_dissector_table = register_dissector_table("ansi_map.tele_id", "IS-637 Teleservice ID", - FT_UINT8, BASE_DEC); + FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); is683_dissector_table = register_dissector_table("ansi_map.ota", "IS-683-A (OTA)", - FT_UINT8, BASE_DEC); + FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); is801_dissector_table = register_dissector_table("ansi_map.pld", "IS-801 (PLD)", - FT_UINT8, BASE_DEC); + FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); ansi_map_tap = register_tap("ansi_map"); diff --git a/asn1/ansi_tcap/packet-ansi_tcap-template.c b/asn1/ansi_tcap/packet-ansi_tcap-template.c index fd170fc82f..2376afdd23 100644 --- a/asn1/ansi_tcap/packet-ansi_tcap-template.c +++ b/asn1/ansi_tcap/packet-ansi_tcap-template.c @@ -513,7 +513,7 @@ proto_register_ansi_tcap(void) register_dissector("ansi_tcap", dissect_ansi_tcap, proto_ansi_tcap); /* 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", FT_UINT16, BASE_DEC); + ansi_tcap_national_opcode_table = register_dissector_table("ansi_tcap.nat.opcode", "ANSI TCAP National Opcodes", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_ansi_tcap, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); diff --git a/asn1/camel/packet-camel-template.c b/asn1/camel/packet-camel-template.c index 9986abbea1..60093f8f58 100644 --- a/asn1/camel/packet-camel-template.c +++ b/asn1/camel/packet-camel-template.c @@ -1564,13 +1564,13 @@ void proto_register_camel(void) { /* Register dissector tables */ camel_rose_ctx.arg_local_dissector_table = register_dissector_table("camel.ros.local.arg", "CAMEL Operation Argument (local opcode)", - FT_UINT32, BASE_HEX); + FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); camel_rose_ctx.res_local_dissector_table = register_dissector_table("camel.ros.local.res", "CAMEL Operation Result (local opcode)", - FT_UINT32, BASE_HEX); + FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); camel_rose_ctx.err_local_dissector_table = register_dissector_table("camel.ros.local.err", "CAMEL Error (local opcode)", - FT_UINT32, BASE_HEX); + FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Register our configuration options, particularly our SSNs */ /* Set default SSNs */ diff --git a/asn1/cmip/packet-cmip-template.c b/asn1/cmip/packet-cmip-template.c index 7dd27fc98c..f710307a2b 100644 --- a/asn1/cmip/packet-cmip-template.c +++ b/asn1/cmip/packet-cmip-template.c @@ -198,7 +198,7 @@ void proto_register_cmip(void) { #include "packet-cmip-dis-tab.c" 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", FT_UINT32, BASE_DEC); + attribute_id_dissector_table = register_dissector_table("cmip.attribute_id", "CMIP Attribute Id", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/asn1/dop/packet-dop-template.c b/asn1/dop/packet-dop-template.c index ceb022c98f..0e905c16f7 100644 --- a/asn1/dop/packet-dop-template.c +++ b/asn1/dop/packet-dop-template.c @@ -263,7 +263,7 @@ void proto_register_dop(void) { new_register_dissector("dop", dissect_dop, proto_dop); - dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", FT_STRING, BASE_NONE); + dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register fields and subtrees */ proto_register_field_array(proto_dop, hf, array_length(hf)); diff --git a/asn1/gsm_map/packet-gsm_map-template.c b/asn1/gsm_map/packet-gsm_map-template.c index f0a9e8b022..45094b4acb 100644 --- a/asn1/gsm_map/packet-gsm_map-template.c +++ b/asn1/gsm_map/packet-gsm_map-template.c @@ -3131,9 +3131,9 @@ void proto_register_gsm_map(void) { expert_gsm_map = expert_register_protocol(proto_gsm_map); expert_register_field_array(expert_gsm_map, ei, array_length(ei)); - map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", FT_UINT8, BASE_DEC); - map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", FT_UINT8, BASE_DEC); - map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", FT_UINT8, BASE_DEC); + map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); gsm_map_tap = register_tap("gsm_map"); diff --git a/asn1/h225/packet-h225-template.c b/asn1/h225/packet-h225-template.c index 9e78f785ee..b2b6ec0a0c 100644 --- a/asn1/h225/packet-h225-template.c +++ b/asn1/h225/packet-h225-template.c @@ -912,11 +912,11 @@ void proto_register_h225(void) { new_register_dissector("h323ui",dissect_h225_H323UserInformation, proto_h225); new_register_dissector("h225.ras", dissect_h225_h225_RasMessage, proto_h225); - nsp_object_dissector_table = register_dissector_table("h225.nsp.object", "H.225 NonStandardParameter (object)", FT_STRING, BASE_NONE); - nsp_h221_dissector_table = register_dissector_table("h225.nsp.h221", "H.225 NonStandardParameter (h221)", FT_UINT32, BASE_HEX); - tp_dissector_table = register_dissector_table("h225.tp", "H.225 TunnelledProtocol", FT_STRING, BASE_NONE); - gef_name_dissector_table = register_dissector_table("h225.gef.name", "H.225 Generic Extensible Framework (names)", FT_STRING, BASE_NONE); - gef_content_dissector_table = register_dissector_table("h225.gef.content", "H.225 Generic Extensible Framework", FT_STRING, BASE_NONE); + nsp_object_dissector_table = register_dissector_table("h225.nsp.object", "H.225 NonStandardParameter (object)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_h221_dissector_table = register_dissector_table("h225.nsp.h221", "H.225 NonStandardParameter (h221)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + tp_dissector_table = register_dissector_table("h225.tp", "H.225 TunnelledProtocol", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_name_dissector_table = register_dissector_table("h225.gef.name", "H.225 Generic Extensible Framework (names)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_content_dissector_table = register_dissector_table("h225.gef.content", "H.225 Generic Extensible Framework", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_init_routine(&h225_init_routine); register_cleanup_routine(&h225_cleanup_routine); diff --git a/asn1/h245/packet-h245-template.c b/asn1/h245/packet-h245-template.c index 3407a52714..02b23bac95 100644 --- a/asn1/h245/packet-h245-template.c +++ b/asn1/h245/packet-h245-template.c @@ -539,10 +539,10 @@ void proto_register_h245(void) { register_dissector("h245dg", dissect_h245_h245, proto_h245); register_dissector("h245", dissect_h245, proto_h245); - nsp_object_dissector_table = register_dissector_table("h245.nsp.object", "H.245 NonStandardParameter (object)", FT_STRING, BASE_NONE); - nsp_h221_dissector_table = register_dissector_table("h245.nsp.h221", "H.245 NonStandardParameter (h221)", FT_UINT32, BASE_HEX); - gef_name_dissector_table = register_dissector_table("h245.gef.name", "H.245 Generic Extensible Framework (names)", FT_STRING, BASE_NONE); - gef_content_dissector_table = register_dissector_table("h245.gef.content", "H.245 Generic Extensible Framework", FT_STRING, BASE_NONE); + nsp_object_dissector_table = register_dissector_table("h245.nsp.object", "H.245 NonStandardParameter (object)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_h221_dissector_table = register_dissector_table("h245.nsp.h221", "H.245 NonStandardParameter (h221)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_name_dissector_table = register_dissector_table("h245.gef.name", "H.245 Generic Extensible Framework (names)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_content_dissector_table = register_dissector_table("h245.gef.content", "H.245 Generic Extensible Framework", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); h245_tap = register_tap("h245"); h245dg_tap = register_tap("h245dg"); diff --git a/asn1/h248/packet-h248-template.c b/asn1/h248/packet-h248-template.c index 59084ca0b8..0168c8d242 100644 --- a/asn1/h248/packet-h248-template.c +++ b/asn1/h248/packet-h248-template.c @@ -1621,7 +1621,7 @@ void proto_register_h248(void) { expert_h248 = expert_register_protocol(proto_h248); expert_register_field_array(expert_h248, ei, array_length(ei)); - subdissector_table = register_dissector_table("h248.magic_num", "H248 Magic Num", FT_UINT32, BASE_HEX); + subdissector_table = register_dissector_table("h248.magic_num", "H248 Magic Num", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); h248_module = prefs_register_protocol(proto_h248, proto_reg_handoff_h248); prefs_register_bool_preference(h248_module, "ctx_info", diff --git a/asn1/h450/packet-h450-template.c b/asn1/h450/packet-h450-template.c index f179e6b746..fb6776431c 100644 --- a/asn1/h450/packet-h450-template.c +++ b/asn1/h450/packet-h450-template.c @@ -289,12 +289,12 @@ void proto_register_h450(void) { rose_ctx_init(&h450_rose_ctx); /* Register dissector tables */ - h450_rose_ctx.arg_global_dissector_table = register_dissector_table("h450.ros.global.arg", "H.450 Operation Argument (global opcode)", FT_STRING, BASE_NONE); - h450_rose_ctx.res_global_dissector_table = register_dissector_table("h450.ros.global.res", "H.450 Operation Result (global opcode)", FT_STRING, BASE_NONE); - h450_rose_ctx.arg_local_dissector_table = register_dissector_table("h450.ros.local.arg", "H.450 Operation Argument (local opcode)", FT_UINT32, BASE_HEX); - h450_rose_ctx.res_local_dissector_table = register_dissector_table("h450.ros.local.res", "H.450 Operation Result (local opcode)", FT_UINT32, BASE_HEX); - h450_rose_ctx.err_global_dissector_table = register_dissector_table("h450.ros.global.err", "H.450 Error (global opcode)", FT_STRING, BASE_NONE); - h450_rose_ctx.err_local_dissector_table = register_dissector_table("h450.ros.local.err", "H.450 Error (local opcode)", FT_UINT32, BASE_HEX); + h450_rose_ctx.arg_global_dissector_table = register_dissector_table("h450.ros.global.arg", "H.450 Operation Argument (global opcode)", 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)", FT_STRING, BASE_NONE, 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)", 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)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.err_global_dissector_table = register_dissector_table("h450.ros.global.err", "H.450 Error (global opcode)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.err_local_dissector_table = register_dissector_table("h450.ros.local.err", "H.450 Error (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/asn1/hnbap/packet-hnbap-template.c b/asn1/hnbap/packet-hnbap-template.c index b375783aa6..26a3b6e5fc 100644 --- a/asn1/hnbap/packet-hnbap-template.c +++ b/asn1/hnbap/packet-hnbap-template.c @@ -166,11 +166,11 @@ module_t *hnbap_module; new_register_dissector("hnbap", dissect_hnbap, proto_hnbap); /* Register dissector tables */ - hnbap_ies_dissector_table = register_dissector_table("hnbap.ies", "HNBAP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - hnbap_extension_dissector_table = register_dissector_table("hnbap.extension", "HNBAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - hnbap_proc_imsg_dissector_table = register_dissector_table("hnbap.proc.imsg", "HNBAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - hnbap_proc_sout_dissector_table = register_dissector_table("hnbap.proc.sout", "HNBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - hnbap_proc_uout_dissector_table = register_dissector_table("hnbap.proc.uout", "HNBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + hnbap_ies_dissector_table = register_dissector_table("hnbap.ies", "HNBAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_extension_dissector_table = register_dissector_table("hnbap.extension", "HNBAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_proc_imsg_dissector_table = register_dissector_table("hnbap.proc.imsg", "HNBAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_proc_sout_dissector_table = register_dissector_table("hnbap.proc.sout", "HNBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_proc_uout_dissector_table = register_dissector_table("hnbap.proc.uout", "HNBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); 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); diff --git a/asn1/lcsap/packet-lcsap-template.c b/asn1/lcsap/packet-lcsap-template.c index dda8c07ac3..378306f9a2 100644 --- a/asn1/lcsap/packet-lcsap-template.c +++ b/asn1/lcsap/packet-lcsap-template.c @@ -309,13 +309,13 @@ void proto_register_lcsap(void) { register_dissector("lcsap", dissect_lcsap, proto_lcsap); /* Register dissector tables */ - lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", FT_UINT32, BASE_DEC); + lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register configuration options for ports */ lcsap_module = prefs_register_protocol(proto_lcsap, proto_reg_handoff_lcsap); diff --git a/asn1/ldap/packet-ldap-template.c b/asn1/ldap/packet-ldap-template.c index 0d5e2cdd06..0dbe926b4c 100644 --- a/asn1/ldap/packet-ldap-template.c +++ b/asn1/ldap/packet-ldap-template.c @@ -2299,7 +2299,7 @@ void proto_register_ldap(void) { register_cleanup_routine(ldap_cleanup); ldap_tap=register_tap("ldap"); - ldap_name_dissector_table = register_dissector_table("ldap.name", "LDAP Attribute Type Dissectors", FT_STRING, BASE_NONE); + ldap_name_dissector_table = register_dissector_table("ldap.name", "LDAP Attribute Type Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_srt_table(proto_ldap, NULL, 1, ldapstat_packet, ldapstat_init, NULL); } diff --git a/asn1/lppa/packet-lppa-template.c b/asn1/lppa/packet-lppa-template.c index 32b8ce71b8..fd914ac8c6 100644 --- a/asn1/lppa/packet-lppa-template.c +++ b/asn1/lppa/packet-lppa-template.c @@ -111,10 +111,10 @@ void proto_register_lppa(void) { proto_register_subtree_array(ett, array_length(ett)); /* Register dissector tables */ - lppa_ies_dissector_table = register_dissector_table("lppa.ies", "LPPA-PROTOCOL-IES", FT_UINT32, BASE_DEC); - lppa_proc_imsg_dissector_table = register_dissector_table("lppa.proc.imsg", "LPPA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - lppa_proc_sout_dissector_table = register_dissector_table("lppa.proc.sout", "LPPA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - lppa_proc_uout_dissector_table = register_dissector_table("lppa.proc.uout", "LPPA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + lppa_ies_dissector_table = register_dissector_table("lppa.ies", "LPPA-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_proc_imsg_dissector_table = register_dissector_table("lppa.proc.imsg", "LPPA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_proc_sout_dissector_table = register_dissector_table("lppa.proc.sout", "LPPA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_proc_uout_dissector_table = register_dissector_table("lppa.proc.uout", "LPPA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } /*--- proto_reg_handoff_lppa ---------------------------------------*/ diff --git a/asn1/m3ap/packet-m3ap-template.c b/asn1/m3ap/packet-m3ap-template.c index a992df9c5b..d17d4b1db4 100644 --- a/asn1/m3ap/packet-m3ap-template.c +++ b/asn1/m3ap/packet-m3ap-template.c @@ -166,11 +166,11 @@ void proto_register_m3ap(void) { proto_register_subtree_array(ett, array_length(ett)); /* Register dissector tables */ - m3ap_ies_dissector_table = register_dissector_table("m3ap.ies", "M3AP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - m3ap_extension_dissector_table = register_dissector_table("m3ap.extension", "M3AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - m3ap_proc_imsg_dissector_table = register_dissector_table("m3ap.proc.imsg", "M3AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - m3ap_proc_sout_dissector_table = register_dissector_table("m3ap.proc.sout", "M3AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - m3ap_proc_uout_dissector_table = register_dissector_table("m3ap.proc.uout", "M3AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + m3ap_ies_dissector_table = register_dissector_table("m3ap.ies", "M3AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_extension_dissector_table = register_dissector_table("m3ap.extension", "M3AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_proc_imsg_dissector_table = register_dissector_table("m3ap.proc.imsg", "M3AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_proc_sout_dissector_table = register_dissector_table("m3ap.proc.sout", "M3AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_proc_uout_dissector_table = register_dissector_table("m3ap.proc.uout", "M3AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/asn1/nbap/packet-nbap-template.c b/asn1/nbap/packet-nbap-template.c index b8646f3d5d..ec723822ba 100644 --- a/asn1/nbap/packet-nbap-template.c +++ b/asn1/nbap/packet-nbap-template.c @@ -517,11 +517,11 @@ void proto_register_nbap(void) } /* Register dissector tables */ - nbap_ies_dissector_table = register_dissector_table("nbap.ies", "NBAP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - nbap_extension_dissector_table = register_dissector_table("nbap.extension", "NBAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - nbap_proc_imsg_dissector_table = register_dissector_table("nbap.proc.imsg", "NBAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_STRING, BASE_NONE); - nbap_proc_sout_dissector_table = register_dissector_table("nbap.proc.sout", "NBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_STRING, BASE_NONE); - nbap_proc_uout_dissector_table = register_dissector_table("nbap.proc.uout", "NBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_STRING, BASE_NONE); + nbap_ies_dissector_table = register_dissector_table("nbap.ies", "NBAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_extension_dissector_table = register_dissector_table("nbap.extension", "NBAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_proc_imsg_dissector_table = register_dissector_table("nbap.proc.imsg", "NBAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_proc_sout_dissector_table = register_dissector_table("nbap.proc.sout", "NBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_proc_uout_dissector_table = register_dissector_table("nbap.proc.uout", "NBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_init_routine(nbap_init); register_cleanup_routine(nbap_cleanup); diff --git a/asn1/p1/packet-p1-template.c b/asn1/p1/packet-p1-template.c index c129eeb87b..c4da37c0d5 100644 --- a/asn1/p1/packet-p1-template.c +++ b/asn1/p1/packet-p1-template.c @@ -372,9 +372,9 @@ void proto_register_p1(void) { expert_p1 = expert_register_protocol(proto_p1); expert_register_field_array(expert_p1, ei, array_length(ei)); - p1_extension_dissector_table = register_dissector_table("p1.extension", "P1-EXTENSION", FT_UINT32, BASE_DEC); - p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", FT_UINT32, BASE_DEC); - p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", FT_UINT32, BASE_DEC); + p1_extension_dissector_table = register_dissector_table("p1.extension", "P1-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register our configuration options for P1, particularly our port */ diff --git a/asn1/pcap/packet-pcap-template.c b/asn1/pcap/packet-pcap-template.c index 9786168b93..8807b99d37 100644 --- a/asn1/pcap/packet-pcap-template.c +++ b/asn1/pcap/packet-pcap-template.c @@ -190,14 +190,14 @@ void proto_register_pcap(void) { register_dissector("pcap", dissect_pcap, proto_pcap); /* Register dissector tables */ - pcap_ies_dissector_table = register_dissector_table("pcap.ies", "PCAP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - pcap_ies_p1_dissector_table = register_dissector_table("pcap.ies.pair.first", "PCAP-PROTOCOL-IES-PAIR FirstValue", FT_UINT32, BASE_DEC); - pcap_ies_p2_dissector_table = register_dissector_table("pcap.ies.pair.second", "PCAP-PROTOCOL-IES-PAIR SecondValue", FT_UINT32, BASE_DEC); - pcap_extension_dissector_table = register_dissector_table("pcap.extension", "PCAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - pcap_proc_imsg_dissector_table = register_dissector_table("pcap.proc.imsg", "PCAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - pcap_proc_sout_dissector_table = register_dissector_table("pcap.proc.sout", "PCAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - pcap_proc_uout_dissector_table = register_dissector_table("pcap.proc.uout", "PCAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); - pcap_proc_out_dissector_table = register_dissector_table("pcap.proc.out", "PCAP-ELEMENTARY-PROCEDURE Outcome", FT_UINT32, BASE_DEC); + pcap_ies_dissector_table = register_dissector_table("pcap.ies", "PCAP-PROTOCOL-IES", 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", 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", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_extension_dissector_table = register_dissector_table("pcap.extension", "PCAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_imsg_dissector_table = register_dissector_table("pcap.proc.imsg", "PCAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_sout_dissector_table = register_dissector_table("pcap.proc.sout", "PCAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_uout_dissector_table = register_dissector_table("pcap.proc.uout", "PCAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_out_dissector_table = register_dissector_table("pcap.proc.out", "PCAP-ELEMENTARY-PROCEDURE Outcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Preferences */ diff --git a/asn1/q932/packet-q932-template.c b/asn1/q932/packet-q932-template.c index 6c58a592cc..694908766b 100644 --- a/asn1/q932/packet-q932-template.c +++ b/asn1/q932/packet-q932-template.c @@ -345,17 +345,17 @@ void proto_register_q932(void) { rose_ctx_init(&q932_rose_ctx); /* Register dissector tables */ - q932_rose_ctx.arg_global_dissector_table = register_dissector_table("q932.ros.global.arg", "Q.932 Operation Argument (global opcode)", FT_STRING, BASE_NONE); - q932_rose_ctx.res_global_dissector_table = register_dissector_table("q932.ros.global.res", "Q.932 Operation Result (global opcode)", FT_STRING, BASE_NONE); - q932_rose_ctx.err_global_dissector_table = register_dissector_table("q932.ros.global.err", "Q.932 Error (global opcode)", FT_STRING, BASE_NONE); + q932_rose_ctx.arg_global_dissector_table = register_dissector_table("q932.ros.global.arg", "Q.932 Operation Argument (global opcode)", 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)", 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)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - qsig_arg_local_dissector_table = register_dissector_table("q932.ros.local.arg", "Q.932 Operation Argument (local opcode)", FT_UINT32, BASE_HEX); - qsig_res_local_dissector_table = register_dissector_table("q932.ros.local.res", "Q.932 Operation Result (local opcode)", FT_UINT32, BASE_HEX); - qsig_err_local_dissector_table = register_dissector_table("q932.ros.local.err", "Q.932 Error (local opcode)", FT_UINT32, BASE_HEX); + qsig_arg_local_dissector_table = register_dissector_table("q932.ros.local.arg", "Q.932 Operation Argument (local opcode)", 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)", 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)", 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)", FT_UINT32, BASE_HEX); - etsi_res_local_dissector_table = register_dissector_table("q932.ros.etsi.local.res", "Q.932 ETSI Operation Result (local opcode)", FT_UINT32, BASE_HEX); - etsi_err_local_dissector_table = register_dissector_table("q932.ros.etsi.local.err", "Q.932 ETSI Error (local opcode)", FT_UINT32, BASE_HEX); + etsi_arg_local_dissector_table = register_dissector_table("q932.ros.etsi.local.arg", "Q.932 ETSI Operation Argument (local opcode)", 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)", 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)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); q932_module = prefs_register_protocol(proto_q932, proto_reg_handoff_q932); diff --git a/asn1/qsig/packet-qsig-template.c b/asn1/qsig/packet-qsig-template.c index 304ab88d02..9835d417f1 100644 --- a/asn1/qsig/packet-qsig-template.c +++ b/asn1/qsig/packet-qsig-template.c @@ -691,7 +691,7 @@ void proto_register_qsig(void) { expert_register_field_array(expert_qsig, ei, array_length(ei)); /* Register dissector tables */ - extension_dissector_table = register_dissector_table("qsig.ext", "QSIG Extension", FT_STRING, BASE_NONE); + extension_dissector_table = register_dissector_table("qsig.ext", "QSIG Extension", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); qsig_init_tables(); } diff --git a/asn1/ranap/packet-ranap-template.c b/asn1/ranap/packet-ranap-template.c index ee61f74728..43f47ba90f 100644 --- a/asn1/ranap/packet-ranap-template.c +++ b/asn1/ranap/packet-ranap-template.c @@ -345,16 +345,16 @@ void proto_register_ranap(void) { new_register_dissector("ranap", dissect_ranap, proto_ranap); /* Register dissector tables */ - ranap_ies_dissector_table = register_dissector_table("ranap.ies", "RANAP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - ranap_ies_p1_dissector_table = register_dissector_table("ranap.ies.pair.first", "RANAP-PROTOCOL-IES-PAIR FirstValue", FT_UINT32, BASE_DEC); - ranap_ies_p2_dissector_table = register_dissector_table("ranap.ies.pair.second", "RANAP-PROTOCOL-IES-PAIR SecondValue", FT_UINT32, BASE_DEC); - ranap_extension_dissector_table = register_dissector_table("ranap.extension", "RANAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - ranap_proc_imsg_dissector_table = register_dissector_table("ranap.proc.imsg", "RANAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - ranap_proc_sout_dissector_table = register_dissector_table("ranap.proc.sout", "RANAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - ranap_proc_uout_dissector_table = register_dissector_table("ranap.proc.uout", "RANAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); - ranap_proc_out_dissector_table = register_dissector_table("ranap.proc.out", "RANAP-ELEMENTARY-PROCEDURE Outcome", FT_UINT32, BASE_DEC); - - nas_pdu_dissector_table = register_dissector_table("ranap.nas_pdu", "RANAP NAS PDU", FT_UINT8, BASE_DEC); + ranap_ies_dissector_table = register_dissector_table("ranap.ies", "RANAP-PROTOCOL-IES", 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", 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", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_extension_dissector_table = register_dissector_table("ranap.extension", "RANAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_imsg_dissector_table = register_dissector_table("ranap.proc.imsg", "RANAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_sout_dissector_table = register_dissector_table("ranap.proc.sout", "RANAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_uout_dissector_table = register_dissector_table("ranap.proc.uout", "RANAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_out_dissector_table = register_dissector_table("ranap.proc.out", "RANAP-ELEMENTARY-PROCEDURE Outcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + + nas_pdu_dissector_table = register_dissector_table("ranap.nas_pdu", "RANAP NAS PDU", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); ranap_module = prefs_register_protocol(proto_ranap, proto_reg_handoff_ranap); prefs_register_uint_preference(ranap_module, "sccp_ssn", "SCCP SSN for RANAP", diff --git a/asn1/rnsap/packet-rnsap-template.c b/asn1/rnsap/packet-rnsap-template.c index 80fe3536a9..0d71cc22cf 100644 --- a/asn1/rnsap/packet-rnsap-template.c +++ b/asn1/rnsap/packet-rnsap-template.c @@ -161,11 +161,11 @@ void proto_register_rnsap(void) { new_register_dissector("rnsap", dissect_rnsap, proto_rnsap); /* Register dissector tables */ - rnsap_ies_dissector_table = register_dissector_table("rnsap.ies", "RNSAP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - rnsap_extension_dissector_table = register_dissector_table("rnsap.extension", "RNSAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - rnsap_proc_imsg_dissector_table = register_dissector_table("rnsap.proc.imsg", "RNSAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_STRING, BASE_NONE); - rnsap_proc_sout_dissector_table = register_dissector_table("rnsap.proc.sout", "RNSAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_STRING, BASE_NONE); - rnsap_proc_uout_dissector_table = register_dissector_table("rnsap.proc.uout", "RNSAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_STRING, BASE_NONE); + rnsap_ies_dissector_table = register_dissector_table("rnsap.ies", "RNSAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_extension_dissector_table = register_dissector_table("rnsap.extension", "RNSAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_proc_imsg_dissector_table = register_dissector_table("rnsap.proc.imsg", "RNSAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_proc_sout_dissector_table = register_dissector_table("rnsap.proc.sout", "RNSAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_proc_uout_dissector_table = register_dissector_table("rnsap.proc.uout", "RNSAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/asn1/ros/packet-ros-template.c b/asn1/ros/packet-ros-template.c index 49cbd9e499..4a7424077c 100644 --- a/asn1/ros/packet-ros-template.c +++ b/asn1/ros/packet-ros-template.c @@ -513,7 +513,7 @@ void proto_register_ros(void) { expert_ros = expert_register_protocol(proto_ros); expert_register_field_array(expert_ros, ei, array_length(ei)); - ros_oid_dissector_table = register_dissector_table("ros.oid", "ROS OID Dissectors", FT_STRING, BASE_NONE); + ros_oid_dissector_table = register_dissector_table("ros.oid", "ROS OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); oid_table=g_hash_table_new(g_str_hash, g_str_equal); protocol_table=g_hash_table_new(g_str_hash, g_str_equal); diff --git a/asn1/rtse/packet-rtse-template.c b/asn1/rtse/packet-rtse-template.c index 35130d7d9f..16bc142948 100644 --- a/asn1/rtse/packet-rtse-template.c +++ b/asn1/rtse/packet-rtse-template.c @@ -401,7 +401,7 @@ void proto_register_rtse(void) { " \"Allow subdissectors to reassemble TCP streams\"" " in the TCP protocol settings.", &rtse_reassemble); - rtse_oid_dissector_table = register_dissector_table("rtse.oid", "RTSE OID Dissectors", FT_STRING, BASE_NONE); + rtse_oid_dissector_table = register_dissector_table("rtse.oid", "RTSE OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); oid_table=g_hash_table_new(g_str_hash, g_str_equal); diff --git a/asn1/rua/packet-rua-template.c b/asn1/rua/packet-rua-template.c index e33555e456..fce68dd639 100644 --- a/asn1/rua/packet-rua-template.c +++ b/asn1/rua/packet-rua-template.c @@ -151,11 +151,11 @@ module_t *rua_module; new_register_dissector("rua", dissect_rua, proto_rua); /* Register dissector tables */ - rua_ies_dissector_table = register_dissector_table("rua.ies", "RUA-PROTOCOL-IES", FT_UINT32, BASE_DEC); - rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + rua_ies_dissector_table = register_dissector_table("rua.ies", "RUA-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); 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); diff --git a/asn1/s1ap/packet-s1ap-template.c b/asn1/s1ap/packet-s1ap-template.c index 9b73e8e764..f0da694a95 100644 --- a/asn1/s1ap/packet-s1ap-template.c +++ b/asn1/s1ap/packet-s1ap-template.c @@ -276,13 +276,13 @@ void proto_register_s1ap(void) { register_dissector("s1ap", dissect_s1ap, proto_s1ap); /* Register dissector tables */ - s1ap_ies_dissector_table = register_dissector_table("s1ap.ies", "S1AP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - s1ap_ies_p1_dissector_table = register_dissector_table("s1ap.ies.pair.first", "S1AP-PROTOCOL-IES-PAIR FirstValue", FT_UINT32, BASE_DEC); - s1ap_ies_p2_dissector_table = register_dissector_table("s1ap.ies.pair.second", "S1AP-PROTOCOL-IES-PAIR SecondValue", FT_UINT32, BASE_DEC); - s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + s1ap_ies_dissector_table = register_dissector_table("s1ap.ies", "S1AP-PROTOCOL-IES", 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", 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", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register configuration options for ports */ s1ap_module = prefs_register_protocol(proto_s1ap, proto_reg_handoff_s1ap); diff --git a/asn1/sabp/packet-sabp-template.c b/asn1/sabp/packet-sabp-template.c index 6261b27a9c..f2437c6362 100644 --- a/asn1/sabp/packet-sabp-template.c +++ b/asn1/sabp/packet-sabp-template.c @@ -271,11 +271,11 @@ void proto_register_sabp(void) { new_register_dissector("sabp.tcp", dissect_sabp_tcp, proto_sabp); /* Register dissector tables */ - sabp_ies_dissector_table = register_dissector_table("sabp.ies", "SABP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - sabp_extension_dissector_table = register_dissector_table("sabp.extension", "SABP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - sabp_proc_imsg_dissector_table = register_dissector_table("sabp.proc.imsg", "SABP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - sabp_proc_sout_dissector_table = register_dissector_table("sabp.proc.sout", "SABP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - sabp_proc_uout_dissector_table = register_dissector_table("sabp.proc.uout", "SABP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + sabp_ies_dissector_table = register_dissector_table("sabp.ies", "SABP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_extension_dissector_table = register_dissector_table("sabp.extension", "SABP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_proc_imsg_dissector_table = register_dissector_table("sabp.proc.imsg", "SABP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_proc_sout_dissector_table = register_dissector_table("sabp.proc.sout", "SABP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_proc_uout_dissector_table = register_dissector_table("sabp.proc.uout", "SABP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/asn1/sbc-ap/packet-sbc-ap-template.c b/asn1/sbc-ap/packet-sbc-ap-template.c index a96864a260..78fd676bfd 100644 --- a/asn1/sbc-ap/packet-sbc-ap-template.c +++ b/asn1/sbc-ap/packet-sbc-ap-template.c @@ -164,11 +164,11 @@ void proto_register_sbc_ap(void) { /* Register dissector tables */ - sbc_ap_ies_dissector_table = register_dissector_table("sbc_ap.ies", "SBC-AP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - sbc_ap_extension_dissector_table = register_dissector_table("sbc_ap.extension", "SBC-AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - sbc_ap_proc_imsg_dissector_table = register_dissector_table("sbc_ap.proc.imsg", "SBC-AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - sbc_ap_proc_sout_dissector_table = register_dissector_table("sbc_ap.proc.sout", "SBC-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - sbc_ap_proc_uout_dissector_table = register_dissector_table("sbc_ap.proc.uout", "SBC-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + sbc_ap_ies_dissector_table = register_dissector_table("sbc_ap.ies", "SBC-AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sbc_ap_extension_dissector_table = register_dissector_table("sbc_ap.extension", "SBC-AP-PROTOCOL-EXTENSION", 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", 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", 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", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/asn1/snmp/packet-snmp-template.c b/asn1/snmp/packet-snmp-template.c index a94dffdf35..16b4e0a71c 100644 --- a/asn1/snmp/packet-snmp-template.c +++ b/asn1/snmp/packet-snmp-template.c @@ -2575,7 +2575,7 @@ void proto_register_snmp(void) { "MIB settings can be changed in the Name Resolution preferences"); #endif - value_sub_dissectors_table = register_dissector_table("snmp.variable_oid","SNMP Variable OID", FT_STRING, BASE_NONE); + value_sub_dissectors_table = register_dissector_table("snmp.variable_oid","SNMP Variable OID", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_init_routine(init_ue_cache); register_cleanup_routine(cleanup_ue_cache); diff --git a/asn1/t124/packet-t124-template.c b/asn1/t124/packet-t124-template.c index 63134698b0..c8a7f27ac9 100644 --- a/asn1/t124/packet-t124-template.c +++ b/asn1/t124/packet-t124-template.c @@ -209,8 +209,8 @@ void proto_register_t124(void) { proto_register_field_array(proto_t124, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - t124_ns_dissector_table = register_dissector_table("t124.ns", "T.124 H.221 Non Standard Dissectors", FT_STRING, BASE_NONE); - t124_sd_dissector_table = register_dissector_table("t124.sd", "T.124 H.221 Send Data Dissectors", FT_UINT32, BASE_HEX); + t124_ns_dissector_table = register_dissector_table("t124.ns", "T.124 H.221 Non Standard Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + t124_sd_dissector_table = register_dissector_table("t124.sd", "T.124 H.221 Send Data Dissectors", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); new_register_dissector("t124", dissect_t124_new, proto_t124); diff --git a/asn1/x2ap/packet-x2ap-template.c b/asn1/x2ap/packet-x2ap-template.c index 9e0fe8165e..a2ce14a2ab 100644 --- a/asn1/x2ap/packet-x2ap-template.c +++ b/asn1/x2ap/packet-x2ap-template.c @@ -164,11 +164,11 @@ void proto_register_x2ap(void) { new_register_dissector("x2ap", dissect_x2ap, proto_x2ap); /* Register dissector tables */ - x2ap_ies_dissector_table = register_dissector_table("x2ap.ies", "X2AP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + x2ap_ies_dissector_table = register_dissector_table("x2ap.ies", "X2AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register configuration options for ports */ x2ap_module = prefs_register_protocol(proto_x2ap, proto_reg_handoff_x2ap); diff --git a/epan/decode_as.c b/epan/decode_as.c index f66f17ca19..3f9c63d129 100644 --- a/epan/decode_as.c +++ b/epan/decode_as.c @@ -26,16 +26,40 @@ #include "decode_as.h" #include "packet.h" +#include <stdio.h> +#include <stdlib.h> GList *decode_as_list = NULL; void register_decode_as(decode_as_t* reg) { + dissector_table_t decode_table; + /* Ensure valid functions */ DISSECTOR_ASSERT(reg->populate_list); DISSECTOR_ASSERT(reg->reset_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); + /* 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) + { + /* FT_STRING can at least show the string value in the dialog, so don't penalize them */ + 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); } diff --git a/epan/dissectors/file-file.c b/epan/dissectors/file-file.c index b668000a06..04fe6fad66 100644 --- a/epan/dissectors/file-file.c +++ b/epan/dissectors/file-file.c @@ -388,7 +388,7 @@ proto_register_file(void) #endif file_encap_dissector_table = register_dissector_table("ftap_encap", - "Filetap encapsulation type", FT_UINT32, BASE_DEC); + "Filetap encapsulation type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_file = proto_register_protocol("File", "File", "file"); proto_register_field_array(proto_file, hf, array_length(hf)); diff --git a/epan/dissectors/packet-ansi_637.c b/epan/dissectors/packet-ansi_637.c index 7963b20bd1..67cae51704 100644 --- a/epan/dissectors/packet-ansi_637.c +++ b/epan/dissectors/packet-ansi_637.c @@ -3344,7 +3344,7 @@ proto_register_ansi_637(void) tele_dissector_table = register_dissector_table("ansi_637.tele_id", - "ANSI IS-637-A Teleservice ID", FT_UINT8, BASE_DEC); + "ANSI IS-637-A Teleservice ID", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-ansi_a.c b/epan/dissectors/packet-ansi_a.c index ea1870a6a4..06260abed1 100644 --- a/epan/dissectors/packet-ansi_a.c +++ b/epan/dissectors/packet-ansi_a.c @@ -12930,15 +12930,15 @@ proto_register_ansi_a(void) is637_dissector_table = register_dissector_table("ansi_a.sms", "IS-637-A (SMS)", - FT_UINT8, BASE_DEC); + FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); is683_dissector_table = register_dissector_table("ansi_a.ota", "IS-683-A (OTA)", - FT_UINT8, BASE_DEC); + FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); is801_dissector_table = register_dissector_table("ansi_a.pld", "IS-801 (PLD)", - FT_UINT8, BASE_DEC); + FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_register_subtree_array(ett, ett_len / (int) sizeof(gint *)); diff --git a/epan/dissectors/packet-ansi_map.c b/epan/dissectors/packet-ansi_map.c index 1feecdf9dd..23dbaeab54 100644 --- a/epan/dissectors/packet-ansi_map.c +++ b/epan/dissectors/packet-ansi_map.c @@ -19531,15 +19531,15 @@ void proto_register_ansi_map(void) { is637_tele_id_dissector_table = register_dissector_table("ansi_map.tele_id", "IS-637 Teleservice ID", - FT_UINT8, BASE_DEC); + FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); is683_dissector_table = register_dissector_table("ansi_map.ota", "IS-683-A (OTA)", - FT_UINT8, BASE_DEC); + FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); is801_dissector_table = register_dissector_table("ansi_map.pld", "IS-801 (PLD)", - FT_UINT8, BASE_DEC); + FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); ansi_map_tap = register_tap("ansi_map"); diff --git a/epan/dissectors/packet-ansi_tcap.c b/epan/dissectors/packet-ansi_tcap.c index 289288789f..1613af2dc0 100644 --- a/epan/dissectors/packet-ansi_tcap.c +++ b/epan/dissectors/packet-ansi_tcap.c @@ -1810,7 +1810,7 @@ proto_register_ansi_tcap(void) register_dissector("ansi_tcap", dissect_ansi_tcap, proto_ansi_tcap); /* 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", FT_UINT16, BASE_DEC); + ansi_tcap_national_opcode_table = register_dissector_table("ansi_tcap.nat.opcode", "ANSI TCAP National Opcodes", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_ansi_tcap, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); diff --git a/epan/dissectors/packet-arcnet.c b/epan/dissectors/packet-arcnet.c index 6e9d3fd356..1785704966 100644 --- a/epan/dissectors/packet-arcnet.c +++ b/epan/dissectors/packet-arcnet.c @@ -376,7 +376,7 @@ proto_register_arcnet (void) arcnet_dissector_table = register_dissector_table ("arcnet.protocol_id", "ARCNET Protocol ID", - FT_UINT8, BASE_HEX); + FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Register the protocol name and description */ proto_arcnet = proto_register_protocol ("ARCNET", "ARCNET", "arcnet"); diff --git a/epan/dissectors/packet-aruba-erm.c b/epan/dissectors/packet-aruba-erm.c index c46efa272a..245f3b8317 100644 --- a/epan/dissectors/packet-aruba-erm.c +++ b/epan/dissectors/packet-aruba-erm.c @@ -455,7 +455,7 @@ proto_register_aruba_erm(void) aruba_erm_subdissector_table = register_dissector_table( "aruba_erm.type", "Aruba ERM Type", - FT_UINT32, BASE_DEC); + FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_decode_as(&aruba_erm_payload_da); diff --git a/epan/dissectors/packet-atalk.c b/epan/dissectors/packet-atalk.c index a02dfc27f4..f53488486b 100644 --- a/epan/dissectors/packet-atalk.c +++ b/epan/dissectors/packet-atalk.c @@ -2066,7 +2066,7 @@ proto_register_atalk(void) /* subdissector code */ ddp_dissector_table = register_dissector_table("ddp.type", "DDP packet type", - FT_UINT8, BASE_HEX); + FT_UINT8, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); atalk_address_type = address_type_dissector_register("AT_ATALK", "Appletalk DDP", atalk_to_str, atalk_str_len, atalk_col_filter_str, atalk_len, NULL, NULL); } diff --git a/epan/dissectors/packet-atm.c b/epan/dissectors/packet-atm.c index d3e1bce357..a4c99f2825 100644 --- a/epan/dissectors/packet-atm.c +++ b/epan/dissectors/packet-atm.c @@ -1996,8 +1996,8 @@ proto_register_atm(void) 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", FT_UINT32, BASE_DEC); - atm_type_aal5_table = register_dissector_table("atm.aal5.type", "ATM AAL_5 type subdissector", FT_UINT32, BASE_DEC); + atm_type_aal2_table = register_dissector_table("atm.aal2.type", "ATM AAL_2 type subdissector", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + atm_type_aal5_table = register_dissector_table("atm.aal5.type", "ATM AAL_5 type subdissector", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); atm_handle = new_register_dissector("atm_truncated", dissect_atm_truncated, proto_atm); new_register_dissector("atm_pw_truncated", dissect_atm_pw_truncated, proto_atm); diff --git a/epan/dissectors/packet-ax25.c b/epan/dissectors/packet-ax25.c index b760b5b472..5463b021b7 100644 --- a/epan/dissectors/packet-ax25.c +++ b/epan/dissectors/packet-ax25.c @@ -425,7 +425,7 @@ proto_register_ax25(void) proto_register_subtree_array(ett, array_length(ett ) ); /* Register dissector table for protocol IDs */ - ax25_dissector_table = register_dissector_table("ax25.pid", "AX.25 protocol ID", FT_UINT8, BASE_HEX); + ax25_dissector_table = register_dissector_table("ax25.pid", "AX.25 protocol ID", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-bacapp.c b/epan/dissectors/packet-bacapp.c index e7a2125559..d4df51be31 100644 --- a/epan/dissectors/packet-bacapp.c +++ b/epan/dissectors/packet-bacapp.c @@ -11318,7 +11318,7 @@ proto_register_bacapp(void) bacapp_dissector_table = register_dissector_table("bacapp.vendor_identifier", "BACapp Vendor Identifier", - FT_UINT8, BASE_HEX); + FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Register BACnet Statistic trees */ register_bacapp_stat_trees(); diff --git a/epan/dissectors/packet-bacnet.c b/epan/dissectors/packet-bacnet.c index 6286332cf3..23dccbc07b 100644 --- a/epan/dissectors/packet-bacnet.c +++ b/epan/dissectors/packet-bacnet.c @@ -621,7 +621,7 @@ proto_register_bacnet(void) bacnet_dissector_table = register_dissector_table("bacnet.vendor", "BACnet Vendor Identifier", - FT_UINT8, BASE_HEX); + FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-bctp.c b/epan/dissectors/packet-bctp.c index 99e82154aa..58372a2f04 100644 --- a/epan/dissectors/packet-bctp.c +++ b/epan/dissectors/packet-bctp.c @@ -107,7 +107,7 @@ proto_register_bctp (void) register_dissector("bctp", dissect_bctp, proto_bctp); - bctp_dissector_table = register_dissector_table("bctp.tpi", "BCTP Tunneled Protocol Indicator", FT_UINT32, BASE_DEC); + bctp_dissector_table = register_dissector_table("bctp.tpi", "BCTP Tunneled Protocol Indicator", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-ber.c b/epan/dissectors/packet-ber.c index feebbf2586..e6101bdf20 100644 --- a/epan/dissectors/packet-ber.c +++ b/epan/dissectors/packet-ber.c @@ -4514,8 +4514,8 @@ proto_register_ber(void) " and the syntax of any associated values", users_uat); - ber_oid_dissector_table = register_dissector_table("ber.oid", "BER OID Dissectors", FT_STRING, BASE_NONE); - ber_syntax_dissector_table = register_dissector_table("ber.syntax", "BER syntax", FT_STRING, BASE_NONE); + ber_oid_dissector_table = register_dissector_table("ber.oid", "BER OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ber_syntax_dissector_table = register_dissector_table("ber.syntax", "BER syntax", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); 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); diff --git a/epan/dissectors/packet-bitcoin.c b/epan/dissectors/packet-bitcoin.c index fa2fcc88a8..1f1c62d6d1 100644 --- a/epan/dissectors/packet-bitcoin.c +++ b/epan/dissectors/packet-bitcoin.c @@ -1861,7 +1861,7 @@ proto_register_bitcoin(void) expert_bitcoin = expert_register_protocol(proto_bitcoin); expert_register_field_array(expert_bitcoin, ei, array_length(ei)); - bitcoin_command_table = register_dissector_table("bitcoin.command", "Bitcoin Command", FT_STRING, BASE_NONE); + bitcoin_command_table = register_dissector_table("bitcoin.command", "Bitcoin Command", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); bitcoin_handle = new_register_dissector("bitcoin", dissect_bitcoin, proto_bitcoin); diff --git a/epan/dissectors/packet-bluetooth.c b/epan/dissectors/packet-bluetooth.c index e450a45b5b..01c362922f 100644 --- a/epan/dissectors/packet-bluetooth.c +++ b/epan/dissectors/packet-bluetooth.c @@ -1609,7 +1609,7 @@ proto_register_bluetooth(void) proto_register_subtree_array(ett, array_length(ett)); bluetooth_table = register_dissector_table("bluetooth.encap", - "Bluetooth Encapsulation", FT_UINT32, BASE_HEX); + "Bluetooth Encapsulation", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); 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()); @@ -1620,13 +1620,13 @@ proto_register_bluetooth(void) 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_vendor_table = register_dissector_table("bluetooth.vendor", "HCI Vendor", FT_UINT16, BASE_HEX); + hci_vendor_table = register_dissector_table("bluetooth.vendor", "HCI Vendor", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); bluetooth_tap = register_tap("bluetooth"); bluetooth_device_tap = register_tap("bluetooth.device"); bluetooth_hci_summary_tap = register_tap("bluetooth.hci_summary"); - bluetooth_uuid_table = register_dissector_table("bluetooth.uuid", "BT Service UUID", FT_STRING, BASE_NONE); + bluetooth_uuid_table = register_dissector_table("bluetooth.uuid", "BT Service UUID", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_conversation_table(proto_bluetooth, TRUE, bluetooth_conversation_packet, bluetooth_hostlist_packet); diff --git a/epan/dissectors/packet-bssap.c b/epan/dissectors/packet-bssap.c index c2c2234761..0618f69d6c 100644 --- a/epan/dissectors/packet-bssap.c +++ b/epan/dissectors/packet-bssap.c @@ -2546,8 +2546,8 @@ proto_register_bssap(void) "Subsystem number used for BSSAP", "Set Subsystem number used for BSSAP/BSSAP+", 10, &global_bssap_ssn); - bssap_dissector_table = register_dissector_table("bssap.pdu_type", "BSSAP Message Type", FT_UINT8, BASE_DEC); - bsap_dissector_table = register_dissector_table("bsap.pdu_type", "BSAP Message Type", FT_UINT8, BASE_DEC); + bssap_dissector_table = register_dissector_table("bssap.pdu_type", "BSSAP Message Type", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + bsap_dissector_table = register_dissector_table("bsap.pdu_type", "BSAP Message Type", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-btatt.c b/epan/dissectors/packet-btatt.c index 2b8bd0cdb6..be012c8720 100644 --- a/epan/dissectors/packet-btatt.c +++ b/epan/dissectors/packet-btatt.c @@ -10652,7 +10652,7 @@ proto_register_btatt(void) btatt_handle = new_register_dissector("btatt", dissect_btatt, proto_btatt); - att_handle_dissector_table = register_dissector_table("btatt.handle", "BT ATT Handle", FT_UINT16, BASE_HEX); + att_handle_dissector_table = register_dissector_table("btatt.handle", "BT ATT Handle", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_btatt, hf, array_length(hf)); diff --git a/epan/dissectors/packet-bthci_cmd.c b/epan/dissectors/packet-bthci_cmd.c index f9aeed3ef4..8f009f481a 100644 --- a/epan/dissectors/packet-bthci_cmd.c +++ b/epan/dissectors/packet-bthci_cmd.c @@ -4853,7 +4853,7 @@ proto_register_bthci_cmd(void) bthci_cmds = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); - vendor_dissector_table = register_dissector_table("bthci_cmd.vendor", "BT HCI Vendor", FT_UINT16, BASE_HEX); + vendor_dissector_table = register_dissector_table("bthci_cmd.vendor", "BT HCI Vendor", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); module = prefs_register_protocol(proto_bthci_cmd, NULL); prefs_register_static_text_preference(module, "hci_cmd.version", diff --git a/epan/dissectors/packet-btl2cap.c b/epan/dissectors/packet-btl2cap.c index 5787b3180e..e7ad285029 100644 --- a/epan/dissectors/packet-btl2cap.c +++ b/epan/dissectors/packet-btl2cap.c @@ -2649,8 +2649,8 @@ proto_register_btl2cap(void) new_register_dissector("btl2cap", dissect_btl2cap, proto_btl2cap); /* subdissector code */ - l2cap_psm_dissector_table = register_dissector_table("btl2cap.psm", "BT L2CAP PSM", FT_UINT16, BASE_HEX); - l2cap_cid_dissector_table = register_dissector_table("btl2cap.cid", "BT L2CAP CID", FT_UINT16, BASE_HEX); + l2cap_psm_dissector_table = register_dissector_table("btl2cap.psm", "BT L2CAP PSM", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + l2cap_cid_dissector_table = register_dissector_table("btl2cap.cid", "BT L2CAP CID", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_btl2cap, hf, array_length(hf)); diff --git a/epan/dissectors/packet-btobex.c b/epan/dissectors/packet-btobex.c index 0971e6e3c6..0b68b1b717 100644 --- a/epan/dissectors/packet-btobex.c +++ b/epan/dissectors/packet-btobex.c @@ -3820,7 +3820,7 @@ proto_register_btobex(void) btobex_handle = new_register_dissector("btobex", dissect_btobex, proto_btobex); - btobex_profile = register_dissector_table("btobex.profile", "BTOBEX Profile", FT_UINT8, BASE_DEC); + btobex_profile = register_dissector_table("btobex.profile", "BTOBEX Profile", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_btobex, hf, array_length(hf)); diff --git a/epan/dissectors/packet-btrfcomm.c b/epan/dissectors/packet-btrfcomm.c index 22609687f8..1cd237e4b3 100644 --- a/epan/dissectors/packet-btrfcomm.c +++ b/epan/dissectors/packet-btrfcomm.c @@ -1139,7 +1139,7 @@ proto_register_btrfcomm(void) 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", FT_UINT16, BASE_DEC); + rfcomm_dlci_dissector_table = register_dissector_table("btrfcomm.dlci", "BT RFCOMM Directed Channel", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); module = prefs_register_protocol(proto_btrfcomm, NULL); prefs_register_static_text_preference(module, "rfcomm.version", diff --git a/epan/dissectors/packet-bvlc.c b/epan/dissectors/packet-bvlc.c index d98d75b3cb..b7a55f7f6e 100644 --- a/epan/dissectors/packet-bvlc.c +++ b/epan/dissectors/packet-bvlc.c @@ -408,7 +408,7 @@ proto_register_bvlc(void) new_register_dissector("bvlc", dissect_bvlc, proto_bvlc); bvlc_dissector_table = register_dissector_table("bvlc.function", - "BVLC Function", FT_UINT8, BASE_HEX); + "BVLC Function", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-c15ch.c b/epan/dissectors/packet-c15ch.c index f7f0b36201..9a746ecb8c 100644 --- a/epan/dissectors/packet-c15ch.c +++ b/epan/dissectors/packet-c15ch.c @@ -11982,7 +11982,7 @@ void proto_register_c15ch(void) ); 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)); - c15ch_dissector_table = register_dissector_table("c15", "C15", FT_UINT32, BASE_DEC); + c15ch_dissector_table = register_dissector_table("c15", "C15", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* third level */ /* tone */ @@ -11993,7 +11993,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_subtree_array(ett_third_level_tone, array_length(ett_third_level_tone)); - c15ch_tone_dissector_table = register_dissector_table("c15.tone", "C15.TONE", FT_UINT32, BASE_DEC); + c15ch_tone_dissector_table = register_dissector_table("c15.tone", "C15.TONE", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* inc gwe */ proto_c15ch_third_level_inc_gwe = proto_register_protocol( @@ -12003,7 +12003,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_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", FT_UINT32, BASE_DEC); + c15ch_inc_gwe_dissector_table = register_dissector_table("c15.inc_gwe", "C15.INC_GWE", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* out gwe */ proto_c15ch_third_level_out_gwe = proto_register_protocol( @@ -12013,7 +12013,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_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", FT_UINT32, BASE_DEC); + c15ch_out_gwe_dissector_table = register_dissector_table("c15.out_gwe", "C15.out_gwe", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-camel.c b/epan/dissectors/packet-camel.c index 7ca875a5fa..18ee509ed5 100644 --- a/epan/dissectors/packet-camel.c +++ b/epan/dissectors/packet-camel.c @@ -10683,13 +10683,13 @@ void proto_register_camel(void) { /* Register dissector tables */ camel_rose_ctx.arg_local_dissector_table = register_dissector_table("camel.ros.local.arg", "CAMEL Operation Argument (local opcode)", - FT_UINT32, BASE_HEX); + FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); camel_rose_ctx.res_local_dissector_table = register_dissector_table("camel.ros.local.res", "CAMEL Operation Result (local opcode)", - FT_UINT32, BASE_HEX); + FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); camel_rose_ctx.err_local_dissector_table = register_dissector_table("camel.ros.local.err", "CAMEL Error (local opcode)", - FT_UINT32, BASE_HEX); + FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Register our configuration options, particularly our SSNs */ /* Set default SSNs */ diff --git a/epan/dissectors/packet-ccsds.c b/epan/dissectors/packet-ccsds.c index 3405bdb2b6..9c79849be3 100644 --- a/epan/dissectors/packet-ccsds.c +++ b/epan/dissectors/packet-ccsds.c @@ -717,7 +717,7 @@ proto_register_ccsds(void) &global_dissect_checkword, dissect_checkword, FALSE); /* Dissector table for sub-dissetors */ - ccsds_dissector_table = register_dissector_table("ccsds.apid", "CCSDS apid", FT_UINT16, BASE_DEC); + ccsds_dissector_table = register_dissector_table("ccsds.apid", "CCSDS apid", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-chdlc.c b/epan/dissectors/packet-chdlc.c index 5299626887..1a6740b242 100644 --- a/epan/dissectors/packet-chdlc.c +++ b/epan/dissectors/packet-chdlc.c @@ -234,7 +234,7 @@ proto_register_chdlc(void) /* subdissector code */ subdissector_table = register_dissector_table("chdlc.protocol", "Cisco HDLC protocol", - FT_UINT16, BASE_HEX); + FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_dissector("chdlc", dissect_chdlc, proto_chdlc); diff --git a/epan/dissectors/packet-cip.c b/epan/dissectors/packet-cip.c index 8cac8f0299..038a2d532e 100644 --- a/epan/dissectors/packet-cip.c +++ b/epan/dissectors/packet-cip.c @@ -6891,9 +6891,9 @@ proto_register_cip(void) expert_register_field_array(expert_cip, ei, array_length(ei)); subdissector_class_table = register_dissector_table("cip.class.iface", - "CIP Class Interface Handle", FT_UINT32, BASE_HEX); + "CIP Class Interface Handle", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); subdissector_symbol_table = register_dissector_table("cip.data_segment.iface", - "CIP Data Segment Interface Handle", FT_UINT32, BASE_HEX); + "CIP Data Segment Interface Handle", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Register the protocol name and description */ proto_cip_class_generic = proto_register_protocol("CIP Class Generic", diff --git a/epan/dissectors/packet-cmip.c b/epan/dissectors/packet-cmip.c index 1eddc8f8f7..6f462ac7e1 100644 --- a/epan/dissectors/packet-cmip.c +++ b/epan/dissectors/packet-cmip.c @@ -5895,7 +5895,7 @@ void proto_register_cmip(void) { #line 199 "../../asn1/cmip/packet-cmip-template.c" 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", FT_UINT32, BASE_DEC); + attribute_id_dissector_table = register_dissector_table("cmip.attribute_id", "CMIP Attribute Id", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-cnip.c b/epan/dissectors/packet-cnip.c index 27c2c10990..4240916d76 100644 --- a/epan/dissectors/packet-cnip.c +++ b/epan/dissectors/packet-cnip.c @@ -234,7 +234,7 @@ void proto_register_cnip(void) /* Register table for subdissectors */ cnip_dissector_table = register_dissector_table("cnip.protocol", - "CN/IP Protocol", FT_UINT8, BASE_DEC); + "CN/IP Protocol", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void proto_reg_handoff_cnip(void) diff --git a/epan/dissectors/packet-dccp.c b/epan/dissectors/packet-dccp.c index 339e8d822d..427e29e9cf 100644 --- a/epan/dissectors/packet-dccp.c +++ b/epan/dissectors/packet-dccp.c @@ -1299,7 +1299,7 @@ proto_register_dccp(void) /* subdissectors */ dccp_subdissector_table = register_dissector_table("dccp.port", "DCCP port", FT_UINT16, - BASE_DEC); + BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); heur_subdissector_list = register_heur_dissector_list("dccp"); /* reg preferences */ diff --git a/epan/dissectors/packet-dcp-etsi.c b/epan/dissectors/packet-dcp-etsi.c index 7df06f51e7..d609ba26e4 100644 --- a/epan/dissectors/packet-dcp-etsi.c +++ b/epan/dissectors/packet-dcp-etsi.c @@ -895,12 +895,12 @@ proto_register_dcp_etsi (void) /* subdissector code */ dcp_dissector_table = register_dissector_table("dcp-etsi.sync", - "DCP Sync", FT_STRING, BASE_NONE); + "DCP Sync", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); af_dissector_table = register_dissector_table("dcp-af.pt", - "DCP-AF Payload Type", FT_UINT8, BASE_DEC); + "DCP-AF Payload Type", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); tpl_dissector_table = register_dissector_table("dcp-tpl.ptr", - "DCP-TPL Protocol Type & Revision", FT_STRING, BASE_NONE); + "DCP-TPL Protocol Type & Revision", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_init_routine(dcp_init_protocol); register_cleanup_routine(dcp_cleanup_protocol); diff --git a/epan/dissectors/packet-diameter.c b/epan/dissectors/packet-diameter.c index 66edf48607..5118c31ed6 100644 --- a/epan/dissectors/packet-diameter.c +++ b/epan/dissectors/packet-diameter.c @@ -2267,11 +2267,11 @@ real_proto_register_diameter(void) new_register_dissector("diameter", dissect_diameter, proto_diameter); /* Register dissector table(s) to do sub dissection of AVPs (OctetStrings) */ - diameter_dissector_table = register_dissector_table("diameter.base", "DIAMETER_BASE_AVPS", FT_UINT32, BASE_DEC); - diameter_3gpp_avp_dissector_table = register_dissector_table("diameter.3gpp", "DIAMETER_3GPP_AVPS", FT_UINT32, BASE_DEC); - diameter_ericsson_avp_dissector_table = register_dissector_table("diameter.ericsson", "DIAMETER_ERICSSON_AVPS", FT_UINT32, BASE_DEC); + diameter_dissector_table = register_dissector_table("diameter.base", "DIAMETER_BASE_AVPS", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + diameter_3gpp_avp_dissector_table = register_dissector_table("diameter.3gpp", "DIAMETER_3GPP_AVPS", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + diameter_ericsson_avp_dissector_table = register_dissector_table("diameter.ericsson", "DIAMETER_ERICSSON_AVPS", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - diameter_expr_result_vnd_table = register_dissector_table("diameter.vnd_exp_res", "DIAMETER Experimental-Result-Code", FT_UINT32, BASE_DEC); + diameter_expr_result_vnd_table = register_dissector_table("diameter.vnd_exp_res", "DIAMETER Experimental-Result-Code", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Set default TCP ports */ range_convert_str(&global_diameter_tcp_port_range, DEFAULT_DIAMETER_PORT_RANGE, MAX_UDP_PORT); diff --git a/epan/dissectors/packet-dns.c b/epan/dissectors/packet-dns.c index 4f418ce5d4..e6d72e21e4 100644 --- a/epan/dissectors/packet-dns.c +++ b/epan/dissectors/packet-dns.c @@ -5564,7 +5564,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_tsig_dissector_table = register_dissector_table("dns.tsig.mac", "DNS TSIG MAC Dissectors", FT_STRING, BASE_NONE); + dns_tsig_dissector_table = register_dissector_table("dns.tsig.mac", "DNS TSIG MAC Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); dns_tap = register_tap("dns"); } diff --git a/epan/dissectors/packet-dop.c b/epan/dissectors/packet-dop.c index 84111ca9ba..b9472c068d 100644 --- a/epan/dissectors/packet-dop.c +++ b/epan/dissectors/packet-dop.c @@ -3056,7 +3056,7 @@ void proto_register_dop(void) { new_register_dissector("dop", dissect_dop, proto_dop); - dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", FT_STRING, BASE_NONE); + dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register fields and subtrees */ proto_register_field_array(proto_dop, hf, array_length(hf)); diff --git a/epan/dissectors/packet-dvbci.c b/epan/dissectors/packet-dvbci.c index c64ecb44f6..85dd237264 100644 --- a/epan/dissectors/packet-dvbci.c +++ b/epan/dissectors/packet-dvbci.c @@ -6328,7 +6328,7 @@ proto_register_dvbci(void) &dvbci_dissect_lsc_msg); sas_msg_dissector_table = register_dissector_table("dvb-ci.sas.app_id_str", - "SAS application id", FT_STRING, STR_ASCII); + "SAS application id", FT_STRING, STR_ASCII, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_init_routine(dvbci_init); register_cleanup_routine(dvbci_cleanup); diff --git a/epan/dissectors/packet-eapol.c b/epan/dissectors/packet-eapol.c index a62e15b845..d845ba80bd 100644 --- a/epan/dissectors/packet-eapol.c +++ b/epan/dissectors/packet-eapol.c @@ -308,7 +308,7 @@ proto_register_eapol(void) eapol_keydes_type_dissector_table = register_dissector_table("eapol.keydes.type", "EAPOL Key Descriptor Type", FT_UINT8, - BASE_DEC); + BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-enip.c b/epan/dissectors/packet-enip.c index c758b309b0..3ed4c9d627 100644 --- a/epan/dissectors/packet-enip.c +++ b/epan/dissectors/packet-enip.c @@ -3719,12 +3719,12 @@ proto_register_enip(void) prefs_register_obsolete_preference(enip_module, "default_io_dissector"); subdissector_sud_table = register_dissector_table("enip.sud.iface", - "ENIP SendUnitData.Interface Handle", FT_UINT32, BASE_HEX); + "ENIP SendUnitData.Interface Handle", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); subdissector_srrd_table = register_dissector_table("enip.srrd.iface", - "ENIP SendRequestReplyData.Interface Handle", FT_UINT32, BASE_HEX); + "ENIP SendRequestReplyData.Interface Handle", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - subdissector_io_table = register_dissector_table("enip.io", "ENIP IO dissector", FT_UINT32, BASE_DEC); + subdissector_io_table = register_dissector_table("enip.io", "ENIP IO dissector", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_init_routine(&enip_init_protocol); register_cleanup_routine(&enip_cleanup_protocol); diff --git a/epan/dissectors/packet-epl.c b/epan/dissectors/packet-epl.c index 2c3ba6eb22..9cc7c93c03 100644 --- a/epan/dissectors/packet-epl.c +++ b/epan/dissectors/packet-epl.c @@ -4352,7 +4352,7 @@ proto_register_epl(void) heur_epl_subdissector_list = register_heur_dissector_list("epl"); heur_epl_data_subdissector_list = register_heur_dissector_list("epl_data"); epl_asnd_dissector_table = register_dissector_table("epl.asnd", - "Manufacturer specific ASND service", FT_UINT8, BASE_DEC); + "Manufacturer specific ASND service", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Registering protocol to be called by another dissector */ epl_handle = new_register_dissector("epl", dissect_epl, proto_epl); diff --git a/epan/dissectors/packet-erf.c b/epan/dissectors/packet-erf.c index faefd904a3..8fd25b1d30 100644 --- a/epan/dissectors/packet-erf.c +++ b/epan/dissectors/packet-erf.c @@ -1925,7 +1925,7 @@ proto_register_erf(void) "Whether the FCS is present in Ethernet packets", &erf_ethfcs); - erf_dissector_table = register_dissector_table("erf.types.type", "Type", FT_UINT8, BASE_DEC); + erf_dissector_table = register_dissector_table("erf.types.type", "Type", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-ethertype.c b/epan/dissectors/packet-ethertype.c index 2d899884c5..b2ab5ab1b7 100644 --- a/epan/dissectors/packet-ethertype.c +++ b/epan/dissectors/packet-ethertype.c @@ -397,7 +397,7 @@ proto_register_ethertype(void) /* subdissector code */ ethertype_dissector_table = register_dissector_table("ethertype", - "Ethertype", FT_UINT16, BASE_HEX); + "Ethertype", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_decode_as(ðertype_da); } diff --git a/epan/dissectors/packet-fc.c b/epan/dissectors/packet-fc.c index 671e5b1627..7897ae5cd7 100644 --- a/epan/dissectors/packet-fc.c +++ b/epan/dissectors/packet-fc.c @@ -1579,7 +1579,7 @@ proto_register_fc(void) */ fcftype_dissector_table = register_dissector_table ("fc.ftype", "FC Frame Type", - FT_UINT8, BASE_HEX); + FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Register preferences */ fc_module = prefs_register_protocol (proto_fc, NULL); diff --git a/epan/dissectors/packet-fcct.c b/epan/dissectors/packet-fcct.c index 519c5379cc..747db42b81 100644 --- a/epan/dissectors/packet-fcct.c +++ b/epan/dissectors/packet-fcct.c @@ -276,7 +276,7 @@ proto_register_fcct(void) fcct_gserver_table = register_dissector_table ("fcct.server", "FCCT Server", - FT_UINT8, BASE_HEX); + FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-flip.c b/epan/dissectors/packet-flip.c index 41d32c7578..516233e724 100644 --- a/epan/dissectors/packet-flip.c +++ b/epan/dissectors/packet-flip.c @@ -468,7 +468,7 @@ proto_register_flip(void) proto_register_field_array(proto_flip, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - subdissector_table = register_dissector_table("flip.payload", "FLIP subdissector", FT_UINT32, BASE_HEX); + subdissector_table = register_dissector_table("flip.payload", "FLIP subdissector", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); flip_module = prefs_register_protocol(proto_flip, NULL); diff --git a/epan/dissectors/packet-fr.c b/epan/dissectors/packet-fr.c index 234d59dd7f..f9029093d2 100644 --- a/epan/dissectors/packet-fr.c +++ b/epan/dissectors/packet-fr.c @@ -978,9 +978,9 @@ proto_register_fr(void) expert_register_field_array(expert_fr, ei, array_length(ei)); fr_subdissector_table = register_dissector_table("fr.nlpid", - "Frame Relay NLPID", FT_UINT8, BASE_HEX); + "Frame Relay NLPID", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); fr_osinl_subdissector_table = register_dissector_table("fr.osinl", - "Frame Relay OSI NLPID", FT_UINT8, BASE_HEX); + "Frame Relay OSI NLPID", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_dissector("fr_uncompressed", dissect_fr_uncompressed, proto_fr); register_dissector("fr", dissect_fr, proto_fr); diff --git a/epan/dissectors/packet-frame.c b/epan/dissectors/packet-frame.c index fde672106e..950803696e 100644 --- a/epan/dissectors/packet-frame.c +++ b/epan/dissectors/packet-frame.c @@ -876,9 +876,9 @@ proto_register_frame(void) } wtap_encap_dissector_table = register_dissector_table("wtap_encap", - "Wiretap encapsulation type", FT_UINT32, BASE_DEC); + "Wiretap encapsulation type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); wtap_fts_rec_dissector_table = register_dissector_table("wtap_fts_rec", - "Wiretap file type for file-type-specific records", FT_UINT32, BASE_DEC); + "Wiretap file type for file-type-specific records", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); proto_frame = proto_register_protocol("Frame", "Frame", "frame"); proto_pkt_comment = proto_register_protocol("Packet comments", "Pkt_Comment", "pkt_comment"); diff --git a/epan/dissectors/packet-gprs-llc.c b/epan/dissectors/packet-gprs-llc.c index 98d901bf40..2d4e6ce160 100644 --- a/epan/dissectors/packet-gprs-llc.c +++ b/epan/dissectors/packet-gprs-llc.c @@ -1331,7 +1331,7 @@ proto_register_llcgprs(void) /* Register the protocol name and description */ proto_llcgprs = proto_register_protocol("Logical Link Control GPRS", "GPRS-LLC", "llcgprs"); - llcgprs_subdissector_table = register_dissector_table("llcgprs.sapi", "GPRS LLC SAPI", FT_UINT8, BASE_HEX); + llcgprs_subdissector_table = register_dissector_table("llcgprs.sapi", "GPRS LLC SAPI", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_llcgprs, hf, array_length(hf)); diff --git a/epan/dissectors/packet-gre.c b/epan/dissectors/packet-gre.c index 6cbab33f84..10433514fd 100644 --- a/epan/dissectors/packet-gre.c +++ b/epan/dissectors/packet-gre.c @@ -736,7 +736,7 @@ proto_register_gre(void) /* subdissector code */ gre_dissector_table = register_dissector_table("gre.proto", - "GRE protocol type", FT_UINT16, BASE_HEX); + "GRE protocol type", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-gsm_a_dtap.c b/epan/dissectors/packet-gsm_a_dtap.c index 16591cbe09..43e6cb9120 100644 --- a/epan/dissectors/packet-gsm_a_dtap.c +++ b/epan/dissectors/packet-gsm_a_dtap.c @@ -8332,7 +8332,7 @@ proto_register_gsm_a_dtap(void) /* subdissector code */ new_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", - FT_UINT8, BASE_DEC); + FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-gsm_a_gm.c b/epan/dissectors/packet-gsm_a_gm.c index 6299a3f8ad..b81d8b769c 100644 --- a/epan/dissectors/packet-gsm_a_gm.c +++ b/epan/dissectors/packet-gsm_a_gm.c @@ -8523,7 +8523,7 @@ proto_register_gsm_a_gm(void) /* subdissector code */ gprs_sm_pco_subdissector_table = register_dissector_table("sm_pco.protocol", - "GPRS SM PCO PPP protocol", FT_UINT16, BASE_HEX); + "GPRS SM PCO PPP protocol", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-gsm_ipa.c b/epan/dissectors/packet-gsm_ipa.c index 6d155969dc..d203638759 100644 --- a/epan/dissectors/packet-gsm_ipa.c +++ b/epan/dissectors/packet-gsm_ipa.c @@ -453,7 +453,7 @@ void proto_register_ipa(void) /* Register table for subdissectors */ osmo_dissector_table = register_dissector_table("ipa.osmo.protocol", "GSM over IP ip.access Protocol", - FT_UINT8, BASE_DEC); + FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); range_convert_str(&global_ipa_tcp_ports, IPA_TCP_PORTS, MAX_TCP_PORT); diff --git a/epan/dissectors/packet-gsm_map.c b/epan/dissectors/packet-gsm_map.c index b6b5bb0c9c..e2d1bc19cd 100644 --- a/epan/dissectors/packet-gsm_map.c +++ b/epan/dissectors/packet-gsm_map.c @@ -30617,9 +30617,9 @@ void proto_register_gsm_map(void) { expert_gsm_map = expert_register_protocol(proto_gsm_map); expert_register_field_array(expert_gsm_map, ei, array_length(ei)); - map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", FT_UINT8, BASE_DEC); - map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", FT_UINT8, BASE_DEC); - map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", FT_UINT8, BASE_DEC); + map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); gsm_map_tap = register_tap("gsm_map"); diff --git a/epan/dissectors/packet-gsm_sms.c b/epan/dissectors/packet-gsm_sms.c index 68179d3f18..1b13927ed8 100644 --- a/epan/dissectors/packet-gsm_sms.c +++ b/epan/dissectors/packet-gsm_sms.c @@ -3277,7 +3277,7 @@ proto_register_gsm_sms(void) expert_register_field_array(expert_gsm_sms, ei, array_length(ei)); gsm_sms_dissector_tbl = register_dissector_table("gsm_sms.udh.port", - "GSM SMS port IE in UDH", FT_UINT16, BASE_DEC); + "GSM SMS port IE in UDH", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); gsm_sms_module = prefs_register_protocol (proto_gsm_sms, NULL); diff --git a/epan/dissectors/packet-gsm_sms_ud.c b/epan/dissectors/packet-gsm_sms_ud.c index a621d91517..d313b7180b 100644 --- a/epan/dissectors/packet-gsm_sms_ud.c +++ b/epan/dissectors/packet-gsm_sms_ud.c @@ -630,7 +630,7 @@ proto_register_gsm_sms_ud(void) /* Subdissector code */ gsm_sms_dissector_table = register_dissector_table("gsm_sms_ud.udh.port", - "GSM SMS port IE in UDH", FT_UINT16, BASE_DEC); + "GSM SMS port IE in UDH", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Preferences for GSM SMS UD */ gsm_sms_ud_module = prefs_register_protocol(proto_gsm_sms_ud, NULL); diff --git a/epan/dissectors/packet-gsmtap.c b/epan/dissectors/packet-gsmtap.c index 527461a8c4..739a0b53d2 100644 --- a/epan/dissectors/packet-gsmtap.c +++ b/epan/dissectors/packet-gsmtap.c @@ -774,7 +774,7 @@ proto_register_gsmtap(void) proto_register_subtree_array(ett, array_length(ett)); gsmtap_dissector_table = register_dissector_table("gsmtap.type", - "GSMTAP type", FT_UINT8, BASE_HEX); + "GSMTAP type", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-gtp.c b/epan/dissectors/packet-gtp.c index 844c1de7df..4556c0706b 100644 --- a/epan/dissectors/packet-gtp.c +++ b/epan/dissectors/packet-gtp.c @@ -9794,8 +9794,8 @@ proto_register_gtp(void) new_register_dissector("gtp", dissect_gtp, proto_gtp); new_register_dissector("gtpprime", dissect_gtpprime, proto_gtpprime); - gtp_priv_ext_dissector_table = register_dissector_table("gtp.priv_ext", "GTP PRIVATE EXT", FT_UINT16, BASE_DEC); - gtp_cdr_fmt_dissector_table = register_dissector_table("gtp.cdr_fmt", "GTP DATA RECORD TYPE", FT_UINT16, BASE_DEC); + gtp_priv_ext_dissector_table = register_dissector_table("gtp.priv_ext", "GTP PRIVATE EXT", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + gtp_cdr_fmt_dissector_table = register_dissector_table("gtp.cdr_fmt", "GTP DATA RECORD TYPE", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_cleanup_routine(gtp_cleanup); gtp_tap = register_tap("gtp"); diff --git a/epan/dissectors/packet-gtpv2.c b/epan/dissectors/packet-gtpv2.c index 410f024b5c..88b5dd296b 100644 --- a/epan/dissectors/packet-gtpv2.c +++ b/epan/dissectors/packet-gtpv2.c @@ -8134,7 +8134,7 @@ void proto_register_gtpv2(void) register_dissector("gtpv2", dissect_gtpv2, proto_gtpv2); /* Dissector table for private extensions */ - gtpv2_priv_ext_dissector_table = register_dissector_table("gtpv2.priv_ext", "GTPv2 PRIVATE EXT", FT_UINT16, BASE_DEC); + gtpv2_priv_ext_dissector_table = register_dissector_table("gtpv2.priv_ext", "GTPv2 PRIVATE EXT", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-h225.c b/epan/dissectors/packet-h225.c index 96c7ef587d..867bf8da33 100644 --- a/epan/dissectors/packet-h225.c +++ b/epan/dissectors/packet-h225.c @@ -11663,11 +11663,11 @@ void proto_register_h225(void) { new_register_dissector("h323ui",dissect_h225_H323UserInformation, proto_h225); new_register_dissector("h225.ras", dissect_h225_h225_RasMessage, proto_h225); - nsp_object_dissector_table = register_dissector_table("h225.nsp.object", "H.225 NonStandardParameter (object)", FT_STRING, BASE_NONE); - nsp_h221_dissector_table = register_dissector_table("h225.nsp.h221", "H.225 NonStandardParameter (h221)", FT_UINT32, BASE_HEX); - tp_dissector_table = register_dissector_table("h225.tp", "H.225 TunnelledProtocol", FT_STRING, BASE_NONE); - gef_name_dissector_table = register_dissector_table("h225.gef.name", "H.225 Generic Extensible Framework (names)", FT_STRING, BASE_NONE); - gef_content_dissector_table = register_dissector_table("h225.gef.content", "H.225 Generic Extensible Framework", FT_STRING, BASE_NONE); + nsp_object_dissector_table = register_dissector_table("h225.nsp.object", "H.225 NonStandardParameter (object)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_h221_dissector_table = register_dissector_table("h225.nsp.h221", "H.225 NonStandardParameter (h221)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + tp_dissector_table = register_dissector_table("h225.tp", "H.225 TunnelledProtocol", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_name_dissector_table = register_dissector_table("h225.gef.name", "H.225 Generic Extensible Framework (names)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_content_dissector_table = register_dissector_table("h225.gef.content", "H.225 Generic Extensible Framework", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_init_routine(&h225_init_routine); register_cleanup_routine(&h225_cleanup_routine); diff --git a/epan/dissectors/packet-h245.c b/epan/dissectors/packet-h245.c index f3f26ecaba..9ac7913db1 100644 --- a/epan/dissectors/packet-h245.c +++ b/epan/dissectors/packet-h245.c @@ -20760,10 +20760,10 @@ void proto_register_h245(void) { register_dissector("h245dg", dissect_h245_h245, proto_h245); register_dissector("h245", dissect_h245, proto_h245); - nsp_object_dissector_table = register_dissector_table("h245.nsp.object", "H.245 NonStandardParameter (object)", FT_STRING, BASE_NONE); - nsp_h221_dissector_table = register_dissector_table("h245.nsp.h221", "H.245 NonStandardParameter (h221)", FT_UINT32, BASE_HEX); - gef_name_dissector_table = register_dissector_table("h245.gef.name", "H.245 Generic Extensible Framework (names)", FT_STRING, BASE_NONE); - gef_content_dissector_table = register_dissector_table("h245.gef.content", "H.245 Generic Extensible Framework", FT_STRING, BASE_NONE); + nsp_object_dissector_table = register_dissector_table("h245.nsp.object", "H.245 NonStandardParameter (object)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_h221_dissector_table = register_dissector_table("h245.nsp.h221", "H.245 NonStandardParameter (h221)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_name_dissector_table = register_dissector_table("h245.gef.name", "H.245 Generic Extensible Framework (names)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_content_dissector_table = register_dissector_table("h245.gef.content", "H.245 Generic Extensible Framework", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); h245_tap = register_tap("h245"); h245dg_tap = register_tap("h245dg"); diff --git a/epan/dissectors/packet-h248.c b/epan/dissectors/packet-h248.c index 4bda7dbc7f..6f709b9158 100644 --- a/epan/dissectors/packet-h248.c +++ b/epan/dissectors/packet-h248.c @@ -6952,7 +6952,7 @@ void proto_register_h248(void) { expert_h248 = expert_register_protocol(proto_h248); expert_register_field_array(expert_h248, ei, array_length(ei)); - subdissector_table = register_dissector_table("h248.magic_num", "H248 Magic Num", FT_UINT32, BASE_HEX); + subdissector_table = register_dissector_table("h248.magic_num", "H248 Magic Num", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); h248_module = prefs_register_protocol(proto_h248, proto_reg_handoff_h248); prefs_register_bool_preference(h248_module, "ctx_info", diff --git a/epan/dissectors/packet-h450.c b/epan/dissectors/packet-h450.c index 5926dbb2e6..de8d7498ab 100644 --- a/epan/dissectors/packet-h450.c +++ b/epan/dissectors/packet-h450.c @@ -6491,12 +6491,12 @@ void proto_register_h450(void) { rose_ctx_init(&h450_rose_ctx); /* Register dissector tables */ - h450_rose_ctx.arg_global_dissector_table = register_dissector_table("h450.ros.global.arg", "H.450 Operation Argument (global opcode)", FT_STRING, BASE_NONE); - h450_rose_ctx.res_global_dissector_table = register_dissector_table("h450.ros.global.res", "H.450 Operation Result (global opcode)", FT_STRING, BASE_NONE); - h450_rose_ctx.arg_local_dissector_table = register_dissector_table("h450.ros.local.arg", "H.450 Operation Argument (local opcode)", FT_UINT32, BASE_HEX); - h450_rose_ctx.res_local_dissector_table = register_dissector_table("h450.ros.local.res", "H.450 Operation Result (local opcode)", FT_UINT32, BASE_HEX); - h450_rose_ctx.err_global_dissector_table = register_dissector_table("h450.ros.global.err", "H.450 Error (global opcode)", FT_STRING, BASE_NONE); - h450_rose_ctx.err_local_dissector_table = register_dissector_table("h450.ros.local.err", "H.450 Error (local opcode)", FT_UINT32, BASE_HEX); + h450_rose_ctx.arg_global_dissector_table = register_dissector_table("h450.ros.global.arg", "H.450 Operation Argument (global opcode)", 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)", FT_STRING, BASE_NONE, 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)", 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)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.err_global_dissector_table = register_dissector_table("h450.ros.global.err", "H.450 Error (global opcode)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.err_local_dissector_table = register_dissector_table("h450.ros.local.err", "H.450 Error (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-hci_h1.c b/epan/dissectors/packet-hci_h1.c index f439f9748f..7ed6d665db 100644 --- a/epan/dissectors/packet-hci_h1.c +++ b/epan/dissectors/packet-hci_h1.c @@ -140,7 +140,7 @@ proto_register_hci_h1(void) proto_register_subtree_array(ett, array_length(ett)); hci_h1_table = register_dissector_table("hci_h1.type", - "HCI h1 pdu type", FT_UINT8, BASE_HEX); + "HCI h1 pdu type", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-hci_h4.c b/epan/dissectors/packet-hci_h4.c index 2c22589523..bd8534063b 100644 --- a/epan/dissectors/packet-hci_h4.c +++ b/epan/dissectors/packet-hci_h4.c @@ -143,7 +143,7 @@ proto_register_hci_h4(void) proto_register_subtree_array(ett, array_length(ett)); hci_h4_table = register_dissector_table("hci_h4.type", - "HCI H4 pdu type", FT_UINT8, BASE_HEX); + "HCI H4 pdu type", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-hnbap.c b/epan/dissectors/packet-hnbap.c index 4162644c96..3f7d418e46 100644 --- a/epan/dissectors/packet-hnbap.c +++ b/epan/dissectors/packet-hnbap.c @@ -3296,11 +3296,11 @@ module_t *hnbap_module; new_register_dissector("hnbap", dissect_hnbap, proto_hnbap); /* Register dissector tables */ - hnbap_ies_dissector_table = register_dissector_table("hnbap.ies", "HNBAP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - hnbap_extension_dissector_table = register_dissector_table("hnbap.extension", "HNBAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - hnbap_proc_imsg_dissector_table = register_dissector_table("hnbap.proc.imsg", "HNBAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - hnbap_proc_sout_dissector_table = register_dissector_table("hnbap.proc.sout", "HNBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - hnbap_proc_uout_dissector_table = register_dissector_table("hnbap.proc.uout", "HNBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + hnbap_ies_dissector_table = register_dissector_table("hnbap.ies", "HNBAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_extension_dissector_table = register_dissector_table("hnbap.extension", "HNBAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_proc_imsg_dissector_table = register_dissector_table("hnbap.proc.imsg", "HNBAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_proc_sout_dissector_table = register_dissector_table("hnbap.proc.sout", "HNBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_proc_uout_dissector_table = register_dissector_table("hnbap.proc.uout", "HNBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); 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); diff --git a/epan/dissectors/packet-hpext.c b/epan/dissectors/packet-hpext.c index 2a0358218d..f2ae620531 100644 --- a/epan/dissectors/packet-hpext.c +++ b/epan/dissectors/packet-hpext.c @@ -129,7 +129,7 @@ proto_register_hpext(void) /* subdissector code */ subdissector_table = register_dissector_table("hpext.dxsap", - "HPEXT XSAP", FT_UINT16, BASE_HEX); + "HPEXT XSAP", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); hpext_handle = register_dissector("hpext", dissect_hpext, proto_hpext); } diff --git a/epan/dissectors/packet-http.c b/epan/dissectors/packet-http.c index 6d74bfc7b2..e99c249227 100644 --- a/epan/dissectors/packet-http.c +++ b/epan/dissectors/packet-http.c @@ -3389,7 +3389,7 @@ proto_register_http(void) * HTTP on a specific non-HTTP port. */ port_subdissector_table = register_dissector_table("http.port", - "TCP port for protocols using HTTP", FT_UINT16, BASE_DEC); + "TCP port for protocols using HTTP", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* * Dissectors can register themselves in this table. @@ -3398,7 +3398,7 @@ proto_register_http(void) */ media_type_subdissector_table = register_dissector_table("media_type", - "Internet media type", FT_STRING, BASE_NONE); + "Internet media type", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* * Heuristic dissectors SHOULD register themselves in diff --git a/epan/dissectors/packet-i2c.c b/epan/dissectors/packet-i2c.c index d88bdfebfa..1754040ddd 100644 --- a/epan/dissectors/packet-i2c.c +++ b/epan/dissectors/packet-i2c.c @@ -247,7 +247,7 @@ proto_register_i2c(void) proto_register_field_array(proto_i2c, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - subdissector_table = register_dissector_table("i2c.message", "I2C messages dissector", FT_UINT32, BASE_DEC); + subdissector_table = register_dissector_table("i2c.message", "I2C messages dissector", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); m = prefs_register_protocol(proto_i2c, NULL); prefs_register_obsolete_preference(m, "type"); diff --git a/epan/dissectors/packet-iax2.c b/epan/dissectors/packet-iax2.c index ac2f8e75fd..b3de3e3a5b 100644 --- a/epan/dissectors/packet-iax2.c +++ b/epan/dissectors/packet-iax2.c @@ -3201,9 +3201,9 @@ proto_register_iax2(void) register_dissector("iax2", dissect_iax2, proto_iax2); iax2_codec_dissector_table = register_dissector_table( - "iax2.codec", "IAX codec number", FT_UINT32, BASE_HEX); + "iax2.codec", "IAX codec number", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); iax2_dataformat_dissector_table = register_dissector_table( - "iax2.dataformat", "IAX dataformat number", FT_UINT32, BASE_HEX); + "iax2.dataformat", "IAX dataformat number", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* register our init routine to be called at the start of a capture, to clear out our hash tables etc */ diff --git a/epan/dissectors/packet-idp.c b/epan/dissectors/packet-idp.c index fe53f7654f..598a8c73a9 100644 --- a/epan/dissectors/packet-idp.c +++ b/epan/dissectors/packet-idp.c @@ -197,7 +197,7 @@ proto_register_idp(void) proto_register_subtree_array(ett, array_length(ett)); idp_type_dissector_table = register_dissector_table("idp.packet_type", - "IDP packet type", FT_UINT8, BASE_DEC); + "IDP packet type", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-ieee1722.c b/epan/dissectors/packet-ieee1722.c index aeaab32ebf..fe5996e17a 100644 --- a/epan/dissectors/packet-ieee1722.c +++ b/epan/dissectors/packet-ieee1722.c @@ -402,7 +402,7 @@ void proto_register_1722(void) /* Sub-dissector for 1772.1 */ avb_dissector_table = register_dissector_table("ieee1722.subtype", - "IEEE1722 AVBTP Subtype", FT_UINT8, BASE_HEX); + "IEEE1722 AVBTP Subtype", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void proto_reg_handoff_1722(void) diff --git a/epan/dissectors/packet-ieee802154.c b/epan/dissectors/packet-ieee802154.c index c2214c9ca0..88a6a2e0b5 100644 --- a/epan/dissectors/packet-ieee802154.c +++ b/epan/dissectors/packet-ieee802154.c @@ -2837,7 +2837,7 @@ void proto_register_ieee802154(void) &ieee802154_extend_auth); /* Register the subdissector list */ - panid_dissector_table = register_dissector_table(IEEE802154_PROTOABBREV_WPAN_PANID, "IEEE 802.15.4 PANID", FT_UINT16, BASE_HEX); + panid_dissector_table = register_dissector_table(IEEE802154_PROTOABBREV_WPAN_PANID, "IEEE 802.15.4 PANID", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); ieee802154_heur_subdissector_list = register_heur_dissector_list(IEEE802154_PROTOABBREV_WPAN); ieee802154_beacon_subdissector_list = register_heur_dissector_list(IEEE802154_PROTOABBREV_WPAN_BEACON); diff --git a/epan/dissectors/packet-ieee802a.c b/epan/dissectors/packet-ieee802a.c index 4f6e1b38bf..465a5c55ab 100644 --- a/epan/dissectors/packet-ieee802a.c +++ b/epan/dissectors/packet-ieee802a.c @@ -62,7 +62,7 @@ ieee802a_add_oui(guint32 oui, const char *table_name, const char *table_ui_name, new_info = (oui_info_t *)g_malloc(sizeof (oui_info_t)); new_info->table = register_dissector_table(table_name, - table_ui_name, FT_UINT16, BASE_HEX); + table_ui_name, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); new_info->field_info = hf_item; /* diff --git a/epan/dissectors/packet-igmp.c b/epan/dissectors/packet-igmp.c index 113cf0e9cb..aba1e51b3e 100644 --- a/epan/dissectors/packet-igmp.c +++ b/epan/dissectors/packet-igmp.c @@ -1108,7 +1108,7 @@ proto_register_igmp(void) proto_register_field_array(proto_igmp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - subdissector_table = register_dissector_table("igmp.type", "IGMP commands", FT_UINT32, BASE_HEX); + subdissector_table = register_dissector_table("igmp.type", "IGMP commands", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-interlink.c b/epan/dissectors/packet-interlink.c index 0ec989f42c..e459424630 100644 --- a/epan/dissectors/packet-interlink.c +++ b/epan/dissectors/packet-interlink.c @@ -217,7 +217,7 @@ proto_register_interlink(void) /* Probably someone will write sub-dissectors. You can never know. */ subdissector_table = register_dissector_table("interlink.type_version", - "Interlink type_version", FT_UINT16, BASE_HEX); + "Interlink type_version", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-ip.c b/epan/dissectors/packet-ip.c index 5702623891..3cbec4fbe6 100644 --- a/epan/dissectors/packet-ip.c +++ b/epan/dissectors/packet-ip.c @@ -3129,7 +3129,7 @@ proto_register_ip(void) /* subdissector code */ ip_dissector_table = register_dissector_table("ip.proto", "IP protocol", - FT_UINT8, BASE_DEC); + FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); heur_subdissector_list = register_heur_dissector_list("ip"); /* Register configuration options */ diff --git a/epan/dissectors/packet-ipmi-trace.c b/epan/dissectors/packet-ipmi-trace.c index a4853932e3..7ae312e27d 100644 --- a/epan/dissectors/packet-ipmi-trace.c +++ b/epan/dissectors/packet-ipmi-trace.c @@ -440,7 +440,7 @@ proto_register_ipmi_trace(void) /* register dissector table for IPMI messaging protocols */ proto_dissector_table = register_dissector_table("ipmi.protocol", - "IPMI Channel Protocol Type", FT_UINT8, BASE_HEX); + "IPMI Channel Protocol Type", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-ipv6.c b/epan/dissectors/packet-ipv6.c index 2973caf4e1..f71bca1a1b 100644 --- a/epan/dissectors/packet-ipv6.c +++ b/epan/dissectors/packet-ipv6.c @@ -3467,7 +3467,7 @@ proto_register_ipv6(void) proto_ipv6_fraghdr = proto_register_protocol("IPv6 Fragment", "IPv6 Fragment", "ipv6.fraghdr"); proto_ipv6_shim6 = proto_register_protocol("IPv6 SHIM6", "SHIM6", "ipv6.shim6"); proto_ipv6_dstopts = proto_register_protocol("IPv6 Destination Options", "IPv6 Destination", "ipv6.dstopts"); - ipv6_next_header_dissector_table = register_dissector_table("ipv6.nxt", "IPv6 Next Header", FT_UINT32, BASE_DEC); + ipv6_next_header_dissector_table = register_dissector_table("ipv6.nxt", "IPv6 Next Header", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Register configuration options */ ipv6_module = prefs_register_protocol(proto_ipv6, NULL); diff --git a/epan/dissectors/packet-ipx.c b/epan/dissectors/packet-ipx.c index 6188c81ddd..d7a2cde5a6 100644 --- a/epan/dissectors/packet-ipx.c +++ b/epan/dissectors/packet-ipx.c @@ -1580,11 +1580,11 @@ proto_register_ipx(void) proto_register_subtree_array(ett, array_length(ett)); ipx_type_dissector_table = register_dissector_table("ipx.packet_type", - "IPX packet type", FT_UINT8, BASE_HEX); + "IPX packet type", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); ipx_socket_dissector_table = register_dissector_table("ipx.socket", - "IPX socket", FT_UINT16, BASE_HEX); + "IPX socket", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); spx_socket_dissector_table = register_dissector_table("spx.socket", - "SPX socket", FT_UINT16, BASE_HEX); + "SPX socket", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_init_routine(&spx_init_protocol); register_postseq_cleanup_routine(&spx_postseq_cleanup); diff --git a/epan/dissectors/packet-isis.c b/epan/dissectors/packet-isis.c index 43e92ead7d..f65d734344 100644 --- a/epan/dissectors/packet-isis.c +++ b/epan/dissectors/packet-isis.c @@ -212,7 +212,7 @@ proto_register_isis(void) isis_handle = register_dissector("isis", dissect_isis, proto_isis); isis_dissector_table = register_dissector_table("isis.type", - "ISIS Type", FT_UINT8, BASE_DEC); + "ISIS Type", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-j1939.c b/epan/dissectors/packet-j1939.c index 4e47ee03b2..0fb7f9bfa4 100644 --- a/epan/dissectors/packet-j1939.c +++ b/epan/dissectors/packet-j1939.c @@ -348,7 +348,7 @@ void proto_register_j1939(void) proto_register_field_array(proto_j1939, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - subdissector_pgn_table = register_dissector_table("j1939.pgn", "PGN Handle", FT_UINT32, BASE_DEC); + subdissector_pgn_table = register_dissector_table("j1939.pgn", "PGN Handle", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); j1939_address_type = address_type_dissector_register("AT_J1939", "J1939 Address", J1939_addr_to_str, J1939_addr_str_len, J1939_col_filter_str, J1939_addr_len, NULL, NULL); } diff --git a/epan/dissectors/packet-juniper.c b/epan/dissectors/packet-juniper.c index dfc0565499..297838146c 100644 --- a/epan/dissectors/packet-juniper.c +++ b/epan/dissectors/packet-juniper.c @@ -1404,7 +1404,7 @@ proto_register_juniper(void) expert_juniper = expert_register_protocol(proto_juniper); expert_register_field_array(expert_juniper, ei, array_length(ei)); - payload_table = register_dissector_table("juniper.proto", "Juniper payload dissectors", FT_UINT32, BASE_HEX); + payload_table = register_dissector_table("juniper.proto", "Juniper payload dissectors", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-kdsp.c b/epan/dissectors/packet-kdsp.c index 115a0f7034..69588227a6 100644 --- a/epan/dissectors/packet-kdsp.c +++ b/epan/dissectors/packet-kdsp.c @@ -1145,7 +1145,7 @@ proto_register_kdsp(void) expert_kdsp = expert_register_protocol(proto_kdsp); expert_register_field_array(expert_kdsp, ei, array_length(ei)); - subdissector_dlt_table = register_dissector_table("kdsp.cpt.dlt", "KDSP DLT Type", FT_UINT32, BASE_DEC); + subdissector_dlt_table = register_dissector_table("kdsp.cpt.dlt", "KDSP DLT Type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); prefs_register_uint_preference(kdsp_module, "tcp.port", "Kismet Drone TCP Port", diff --git a/epan/dissectors/packet-l2tp.c b/epan/dissectors/packet-l2tp.c index dbb7f681c2..1661ef2006 100644 --- a/epan/dissectors/packet-l2tp.c +++ b/epan/dissectors/packet-l2tp.c @@ -3002,8 +3002,8 @@ proto_register_l2tp(void) expert_l2tp = expert_register_protocol(proto_l2tp); expert_register_field_array(expert_l2tp, ei, array_length(ei)); - l2tp_vendor_avp_dissector_table = register_dissector_table("l2tp.vendor_avp", "L2TP vendor AVP dissector table", FT_UINT32, BASE_DEC); - pw_type_table = register_dissector_table("l2tp.pw_type", "L2TPv3 payload type", FT_UINT32, BASE_DEC); + l2tp_vendor_avp_dissector_table = register_dissector_table("l2tp.vendor_avp", "L2TP vendor AVP dissector table", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + pw_type_table = register_dissector_table("l2tp.pw_type", "L2TPv3 payload type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); l2tp_module = prefs_register_protocol(proto_l2tp, NULL); diff --git a/epan/dissectors/packet-lapd.c b/epan/dissectors/packet-lapd.c index 23ec1f7e70..e5d4e0a676 100644 --- a/epan/dissectors/packet-lapd.c +++ b/epan/dissectors/packet-lapd.c @@ -731,10 +731,10 @@ proto_register_lapd(void) register_dissector("lapd", dissect_lapd, proto_lapd); lapd_sapi_dissector_table = register_dissector_table("lapd.sapi", - "LAPD SAPI", FT_UINT16, BASE_DEC); + "LAPD SAPI", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); lapd_gsm_sapi_dissector_table = register_dissector_table("lapd.gsm.sapi", - "LAPD GSM SAPI", FT_UINT16, BASE_DEC); + "LAPD GSM SAPI", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); lapd_module = prefs_register_protocol(proto_lapd, proto_reg_handoff_lapd); diff --git a/epan/dissectors/packet-lapdm.c b/epan/dissectors/packet-lapdm.c index 9edb2d4c51..8f81127fe7 100644 --- a/epan/dissectors/packet-lapdm.c +++ b/epan/dissectors/packet-lapdm.c @@ -491,7 +491,7 @@ proto_register_lapdm(void) register_dissector("lapdm", dissect_lapdm, proto_lapdm); - lapdm_sapi_dissector_table = register_dissector_table("lapdm.sapi", "LAPDm SAPI", FT_UINT8, BASE_DEC); + lapdm_sapi_dissector_table = register_dissector_table("lapdm.sapi", "LAPDm SAPI", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); lapdm_module = prefs_register_protocol(proto_lapdm, NULL); prefs_register_bool_preference(lapdm_module, "reassemble", diff --git a/epan/dissectors/packet-lapsat.c b/epan/dissectors/packet-lapsat.c index 784816fc2c..91fc71b409 100644 --- a/epan/dissectors/packet-lapsat.c +++ b/epan/dissectors/packet-lapsat.c @@ -764,7 +764,7 @@ proto_register_lapsat(void) register_dissector("lapsat", dissect_lapsat, proto_lapsat); - lapsat_sapi_dissector_table = register_dissector_table("lapsat.sapi", "LAPSat SAPI", FT_UINT8, BASE_DEC); + lapsat_sapi_dissector_table = register_dissector_table("lapsat.sapi", "LAPSat SAPI", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_init_routine (lapsat_defragment_init); register_cleanup_routine (lapsat_defragment_cleanup); diff --git a/epan/dissectors/packet-lcsap.c b/epan/dissectors/packet-lcsap.c index ff56694e8e..570c078316 100644 --- a/epan/dissectors/packet-lcsap.c +++ b/epan/dissectors/packet-lcsap.c @@ -2853,13 +2853,13 @@ void proto_register_lcsap(void) { register_dissector("lcsap", dissect_lcsap, proto_lcsap); /* Register dissector tables */ - lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", FT_UINT32, BASE_DEC); + lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register configuration options for ports */ lcsap_module = prefs_register_protocol(proto_lcsap, proto_reg_handoff_lcsap); diff --git a/epan/dissectors/packet-ldap.c b/epan/dissectors/packet-ldap.c index 3a414cc33a..fe26c37390 100644 --- a/epan/dissectors/packet-ldap.c +++ b/epan/dissectors/packet-ldap.c @@ -5847,7 +5847,7 @@ void proto_register_ldap(void) { register_cleanup_routine(ldap_cleanup); ldap_tap=register_tap("ldap"); - ldap_name_dissector_table = register_dissector_table("ldap.name", "LDAP Attribute Type Dissectors", FT_STRING, BASE_NONE); + ldap_name_dissector_table = register_dissector_table("ldap.name", "LDAP Attribute Type Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_srt_table(proto_ldap, NULL, 1, ldapstat_packet, ldapstat_init, NULL); } diff --git a/epan/dissectors/packet-llc.c b/epan/dissectors/packet-llc.c index e641866e4c..4e0402657c 100644 --- a/epan/dissectors/packet-llc.c +++ b/epan/dissectors/packet-llc.c @@ -236,7 +236,7 @@ llc_add_oui(guint32 oui, const char *table_name, const char *table_ui_name, new_info = (oui_info_t *)g_malloc(sizeof (oui_info_t)); new_info->table = register_dissector_table(table_name, - table_ui_name, FT_UINT16, BASE_HEX); + table_ui_name, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); new_info->field_info = hf_item; /* @@ -856,9 +856,9 @@ proto_register_llc(void) /* subdissector code */ dsap_subdissector_table = register_dissector_table("llc.dsap", - "LLC SAP", FT_UINT8, BASE_HEX); + "LLC SAP", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); xid_subdissector_table = register_dissector_table("llc.xid_dsap", - "LLC XID SAP", FT_UINT8, BASE_HEX); + "LLC XID SAP", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_dissector("llc", dissect_llc, proto_llc); } diff --git a/epan/dissectors/packet-lldp.c b/epan/dissectors/packet-lldp.c index e7a7663cbc..9c7d2a02fa 100644 --- a/epan/dissectors/packet-lldp.c +++ b/epan/dissectors/packet-lldp.c @@ -5030,7 +5030,7 @@ proto_register_lldp(void) /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_lldp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - oui_unique_code_table = register_dissector_table("lldp.orgtlv.oui", "LLDP OUI", FT_UINT24, BASE_HEX ); + oui_unique_code_table = register_dissector_table("lldp.orgtlv.oui", "LLDP OUI", FT_UINT24, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE ); expert_lldp = expert_register_protocol(proto_lldp); expert_register_field_array(expert_lldp, ei, array_length(ei)); diff --git a/epan/dissectors/packet-lppa.c b/epan/dissectors/packet-lppa.c index 333d7b8910..554fa37511 100644 --- a/epan/dissectors/packet-lppa.c +++ b/epan/dissectors/packet-lppa.c @@ -2939,10 +2939,10 @@ void proto_register_lppa(void) { proto_register_subtree_array(ett, array_length(ett)); /* Register dissector tables */ - lppa_ies_dissector_table = register_dissector_table("lppa.ies", "LPPA-PROTOCOL-IES", FT_UINT32, BASE_DEC); - lppa_proc_imsg_dissector_table = register_dissector_table("lppa.proc.imsg", "LPPA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - lppa_proc_sout_dissector_table = register_dissector_table("lppa.proc.sout", "LPPA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - lppa_proc_uout_dissector_table = register_dissector_table("lppa.proc.uout", "LPPA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + lppa_ies_dissector_table = register_dissector_table("lppa.ies", "LPPA-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_proc_imsg_dissector_table = register_dissector_table("lppa.proc.imsg", "LPPA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_proc_sout_dissector_table = register_dissector_table("lppa.proc.sout", "LPPA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_proc_uout_dissector_table = register_dissector_table("lppa.proc.uout", "LPPA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } /*--- proto_reg_handoff_lppa ---------------------------------------*/ diff --git a/epan/dissectors/packet-m3ap.c b/epan/dissectors/packet-m3ap.c index a2f80f926c..f0900873fe 100644 --- a/epan/dissectors/packet-m3ap.c +++ b/epan/dissectors/packet-m3ap.c @@ -2515,11 +2515,11 @@ void proto_register_m3ap(void) { proto_register_subtree_array(ett, array_length(ett)); /* Register dissector tables */ - m3ap_ies_dissector_table = register_dissector_table("m3ap.ies", "M3AP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - m3ap_extension_dissector_table = register_dissector_table("m3ap.extension", "M3AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - m3ap_proc_imsg_dissector_table = register_dissector_table("m3ap.proc.imsg", "M3AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - m3ap_proc_sout_dissector_table = register_dissector_table("m3ap.proc.sout", "M3AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - m3ap_proc_uout_dissector_table = register_dissector_table("m3ap.proc.uout", "M3AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + m3ap_ies_dissector_table = register_dissector_table("m3ap.ies", "M3AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_extension_dissector_table = register_dissector_table("m3ap.extension", "M3AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_proc_imsg_dissector_table = register_dissector_table("m3ap.proc.imsg", "M3AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_proc_sout_dissector_table = register_dissector_table("m3ap.proc.sout", "M3AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_proc_uout_dissector_table = register_dissector_table("m3ap.proc.uout", "M3AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-mbim.c b/epan/dissectors/packet-mbim.c index 3a217ddada..67f3c1610f 100644 --- a/epan/dissectors/packet-mbim.c +++ b/epan/dissectors/packet-mbim.c @@ -8000,7 +8000,7 @@ proto_register_mbim(void) new_register_dissector("mbim.descriptor", dissect_mbim_descriptor, proto_mbim); new_register_dissector("mbim.bulk", dissect_mbim_bulk, proto_mbim); dss_dissector_table = register_dissector_table("mbim.dss_session_id", - "MBIM DSS Session Id", FT_UINT8, BASE_DEC); + "MBIM DSS Session Id", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); mbim_module = prefs_register_protocol(proto_mbim, proto_reg_handoff_mbim); prefs_register_obsolete_preference(mbim_module, "bulk_heuristic"); diff --git a/epan/dissectors/packet-mbtcp.c b/epan/dissectors/packet-mbtcp.c index 690b0c5700..155e0960b9 100644 --- a/epan/dissectors/packet-mbtcp.c +++ b/epan/dissectors/packet-mbtcp.c @@ -1817,8 +1817,8 @@ proto_register_modbus(void) mbrtu_handle = new_register_dissector("mbrtu", dissect_mbrtu, proto_mbrtu); /* Registering subdissectors table */ - modbus_data_dissector_table = register_dissector_table("modbus.data", "Modbus Data", FT_STRING, BASE_NONE); - modbus_dissector_table = register_dissector_table("mbtcp.prot_id", "Modbus/TCP protocol identifier", FT_UINT16, BASE_DEC); + modbus_data_dissector_table = register_dissector_table("modbus.data", "Modbus Data", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + modbus_dissector_table = register_dissector_table("mbtcp.prot_id", "Modbus/TCP protocol identifier", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_mbtcp, mbtcp_hf, array_length(mbtcp_hf)); diff --git a/epan/dissectors/packet-meta.c b/epan/dissectors/packet-meta.c index cacb699061..21bb434a1f 100644 --- a/epan/dissectors/packet-meta.c +++ b/epan/dissectors/packet-meta.c @@ -788,7 +788,7 @@ proto_register_meta(void) expert_register_field_array(expert_meta, ei, array_length(ei)); meta_dissector_table = register_dissector_table("meta.proto", - "META protocol", FT_UINT16, BASE_DEC); + "META protocol", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-mip.c b/epan/dissectors/packet-mip.c index f801d6bfbe..314ea18fc2 100644 --- a/epan/dissectors/packet-mip.c +++ b/epan/dissectors/packet-mip.c @@ -1474,7 +1474,7 @@ void proto_register_mip(void) expert_register_field_array(expert_mip, ei, array_length(ei)); mip_nvse_ext_dissector_table = register_dissector_table("mip.nvse_ext", - "MIP Normal Vendor/Organization Specific Extension", FT_UINT32, BASE_DEC); + "MIP Normal Vendor/Organization Specific Extension", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-mip6.c b/epan/dissectors/packet-mip6.c index f209483019..0d5f1a4e15 100644 --- a/epan/dissectors/packet-mip6.c +++ b/epan/dissectors/packet-mip6.c @@ -5355,7 +5355,7 @@ proto_register_mip6(void) expert_mip6 = expert_register_protocol(proto_mip6); expert_register_field_array(expert_mip6, ei, array_length(ei)); - mip6_vsm_dissector_table = register_dissector_table("mip6.vsm", "Mobile IPv6 vendor specific option", FT_UINT32, BASE_DEC); + mip6_vsm_dissector_table = register_dissector_table("mip6.vsm", "Mobile IPv6 vendor specific option", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-moldudp64.c b/epan/dissectors/packet-moldudp64.c index 250a2b8f93..b8c46cee11 100644 --- a/epan/dissectors/packet-moldudp64.c +++ b/epan/dissectors/packet-moldudp64.c @@ -279,7 +279,7 @@ proto_register_moldudp64(void) proto_moldudp64 = proto_register_protocol("MoldUDP64", "MoldUDP64", "moldudp64"); - moldudp64_payload_table = register_dissector_table("moldudp64.payload", "MoldUDP64 Payload", FT_UINT32, BASE_DEC); + moldudp64_payload_table = register_dissector_table("moldudp64.payload", "MoldUDP64 Payload", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_moldudp64, hf, array_length(hf)); diff --git a/epan/dissectors/packet-mpeg-sect.c b/epan/dissectors/packet-mpeg-sect.c index 9fbd336e52..d49c3224f8 100644 --- a/epan/dissectors/packet-mpeg-sect.c +++ b/epan/dissectors/packet-mpeg-sect.c @@ -380,7 +380,7 @@ proto_register_mpeg_sect(void) mpeg_sect_tid_dissector_table = register_dissector_table("mpeg_sect.tid", "MPEG SECT Table ID", - FT_UINT8, BASE_HEX); + FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-mpls.c b/epan/dissectors/packet-mpls.c index 87aa63245c..ec1b1ff26f 100644 --- a/epan/dissectors/packet-mpls.c +++ b/epan/dissectors/packet-mpls.c @@ -590,7 +590,7 @@ proto_register_mpls(void) /* FF: mpls subdissector table is indexed by label */ mpls_subdissector_table = register_dissector_table("mpls.label", "MPLS protocol", - FT_UINT32, BASE_DEC); + FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_mpls = proto_register_protocol("MultiProtocol Label Switching Header", "MPLS", "mpls"); proto_pw_ach = proto_register_protocol(PW_ACH, @@ -605,7 +605,7 @@ proto_register_mpls(void) register_dissector("mpls", dissect_mpls, proto_mpls); - pw_ach_subdissector_table = register_dissector_table("pwach.channel_type", "PW Associated Channel Type", FT_UINT16, BASE_HEX); + pw_ach_subdissector_table = register_dissector_table("pwach.channel_type", "PW Associated Channel Type", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); module_mpls = prefs_register_protocol( proto_mpls, NULL ); diff --git a/epan/dissectors/packet-mstp.c b/epan/dissectors/packet-mstp.c index c611b06ecb..897358d6fe 100644 --- a/epan/dissectors/packet-mstp.c +++ b/epan/dissectors/packet-mstp.c @@ -462,7 +462,7 @@ proto_register_mstp(void) register_dissector("mstp", dissect_mstp_wtap, proto_mstp); subdissector_table = register_dissector_table("mstp.vendor_frame_type", - "MSTP Vendor specific Frametypes", FT_UINT24, BASE_DEC); + "MSTP Vendor specific Frametypes", FT_UINT24, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Table_type: (Vendor ID << 16) + Frametype */ mstp_address_type = address_type_dissector_register("AT_MSTP", "BACnet MS/TP Address", mstp_to_str, mstp_str_len, mstp_col_filter_str, mstp_len, NULL, NULL); diff --git a/epan/dissectors/packet-mtp3.c b/epan/dissectors/packet-mtp3.c index c1014e92f8..0219eee957 100644 --- a/epan/dissectors/packet-mtp3.c +++ b/epan/dissectors/packet-mtp3.c @@ -1056,7 +1056,7 @@ proto_register_mtp3(void) mtp3_sio_dissector_table = register_dissector_table("mtp3.service_indicator", "MTP3 Service indicator", - FT_UINT8, BASE_HEX); + FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); mtp3_tap = register_tap("mtp3"); diff --git a/epan/dissectors/packet-multipart.c b/epan/dissectors/packet-multipart.c index 2fe889098a..e70b5fc312 100644 --- a/epan/dissectors/packet-multipart.c +++ b/epan/dissectors/packet-multipart.c @@ -1014,7 +1014,7 @@ proto_register_multipart(void) multipart_media_subdissector_table = register_dissector_table( "multipart_media_type", "Internet media type (for multipart processing)", - FT_STRING, BASE_NONE); + FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-nbap.c b/epan/dissectors/packet-nbap.c index 91880f6e11..f9a2feb5b9 100644 --- a/epan/dissectors/packet-nbap.c +++ b/epan/dissectors/packet-nbap.c @@ -70167,11 +70167,11 @@ void proto_register_nbap(void) } /* Register dissector tables */ - nbap_ies_dissector_table = register_dissector_table("nbap.ies", "NBAP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - nbap_extension_dissector_table = register_dissector_table("nbap.extension", "NBAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - nbap_proc_imsg_dissector_table = register_dissector_table("nbap.proc.imsg", "NBAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_STRING, BASE_NONE); - nbap_proc_sout_dissector_table = register_dissector_table("nbap.proc.sout", "NBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_STRING, BASE_NONE); - nbap_proc_uout_dissector_table = register_dissector_table("nbap.proc.uout", "NBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_STRING, BASE_NONE); + nbap_ies_dissector_table = register_dissector_table("nbap.ies", "NBAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_extension_dissector_table = register_dissector_table("nbap.extension", "NBAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_proc_imsg_dissector_table = register_dissector_table("nbap.proc.imsg", "NBAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_proc_sout_dissector_table = register_dissector_table("nbap.proc.sout", "NBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_proc_uout_dissector_table = register_dissector_table("nbap.proc.uout", "NBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_init_routine(nbap_init); register_cleanup_routine(nbap_cleanup); diff --git a/epan/dissectors/packet-netlink.c b/epan/dissectors/packet-netlink.c index 18dba0ad9f..ca09c2c4d5 100644 --- a/epan/dissectors/packet-netlink.c +++ b/epan/dissectors/packet-netlink.c @@ -416,7 +416,7 @@ proto_register_netlink(void) "netlink.protocol", "Linux netlink protocol type", FT_UINT16, - BASE_HEX + BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE ); } diff --git a/epan/dissectors/packet-nfs.c b/epan/dissectors/packet-nfs.c index 75ed9c623a..140ba97bb3 100644 --- a/epan/dissectors/packet-nfs.c +++ b/epan/dissectors/packet-nfs.c @@ -13721,7 +13721,7 @@ proto_register_nfs(void) &display_major_nfs4_ops); nfs_fhandle_table = register_dissector_table("nfs_fhandle.type", - "NFS Filehandle types", FT_UINT8, BASE_HEX); + "NFS Filehandle types", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); prefs_register_obsolete_preference(nfs_module, "default_fhandle_type"); diff --git a/epan/dissectors/packet-null.c b/epan/dissectors/packet-null.c index bad3d046b5..361b74fb24 100644 --- a/epan/dissectors/packet-null.c +++ b/epan/dissectors/packet-null.c @@ -535,7 +535,7 @@ proto_register_null(void) /* subdissector code */ null_dissector_table = register_dissector_table("null.type", - "Null type", FT_UINT32, BASE_DEC); + "Null type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-osi.c b/epan/dissectors/packet-osi.c index 20cce76e6d..4105a106b0 100644 --- a/epan/dissectors/packet-osi.c +++ b/epan/dissectors/packet-osi.c @@ -582,13 +582,13 @@ proto_register_osi(void) should register here */ osinl_incl_subdissector_table = register_dissector_table("osinl.incl", - "OSI incl NLPID", FT_UINT8, BASE_HEX); + "OSI incl NLPID", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* This dissector table is for those protocols whose PDUs * aren't* defined to begin with an NLPID. * (typically non OSI protocols like IP,IPv6,PPP */ osinl_excl_subdissector_table = register_dissector_table("osinl.excl", - "OSI excl NLPID", FT_UINT8, BASE_HEX); + "OSI excl NLPID", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_osi = proto_register_protocol("OSI", "OSI", "osi"); proto_register_field_array(proto_osi, hf, array_length(hf)); diff --git a/epan/dissectors/packet-p1.c b/epan/dissectors/packet-p1.c index 8f85b71f8f..35e2bbfe14 100644 --- a/epan/dissectors/packet-p1.c +++ b/epan/dissectors/packet-p1.c @@ -11104,9 +11104,9 @@ void proto_register_p1(void) { expert_p1 = expert_register_protocol(proto_p1); expert_register_field_array(expert_p1, ei, array_length(ei)); - p1_extension_dissector_table = register_dissector_table("p1.extension", "P1-EXTENSION", FT_UINT32, BASE_DEC); - p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", FT_UINT32, BASE_DEC); - p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", FT_UINT32, BASE_DEC); + p1_extension_dissector_table = register_dissector_table("p1.extension", "P1-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register our configuration options for P1, particularly our port */ diff --git a/epan/dissectors/packet-pcap.c b/epan/dissectors/packet-pcap.c index 4a7cc559ba..d0a1b7d198 100644 --- a/epan/dissectors/packet-pcap.c +++ b/epan/dissectors/packet-pcap.c @@ -18720,14 +18720,14 @@ void proto_register_pcap(void) { register_dissector("pcap", dissect_pcap, proto_pcap); /* Register dissector tables */ - pcap_ies_dissector_table = register_dissector_table("pcap.ies", "PCAP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - pcap_ies_p1_dissector_table = register_dissector_table("pcap.ies.pair.first", "PCAP-PROTOCOL-IES-PAIR FirstValue", FT_UINT32, BASE_DEC); - pcap_ies_p2_dissector_table = register_dissector_table("pcap.ies.pair.second", "PCAP-PROTOCOL-IES-PAIR SecondValue", FT_UINT32, BASE_DEC); - pcap_extension_dissector_table = register_dissector_table("pcap.extension", "PCAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - pcap_proc_imsg_dissector_table = register_dissector_table("pcap.proc.imsg", "PCAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - pcap_proc_sout_dissector_table = register_dissector_table("pcap.proc.sout", "PCAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - pcap_proc_uout_dissector_table = register_dissector_table("pcap.proc.uout", "PCAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); - pcap_proc_out_dissector_table = register_dissector_table("pcap.proc.out", "PCAP-ELEMENTARY-PROCEDURE Outcome", FT_UINT32, BASE_DEC); + pcap_ies_dissector_table = register_dissector_table("pcap.ies", "PCAP-PROTOCOL-IES", 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", 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", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_extension_dissector_table = register_dissector_table("pcap.extension", "PCAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_imsg_dissector_table = register_dissector_table("pcap.proc.imsg", "PCAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_sout_dissector_table = register_dissector_table("pcap.proc.sout", "PCAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_uout_dissector_table = register_dissector_table("pcap.proc.uout", "PCAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_out_dissector_table = register_dissector_table("pcap.proc.out", "PCAP-ELEMENTARY-PROCEDURE Outcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Preferences */ diff --git a/epan/dissectors/packet-pcapng_block.c b/epan/dissectors/packet-pcapng_block.c index 00aca618c5..831c55bd0b 100644 --- a/epan/dissectors/packet-pcapng_block.c +++ b/epan/dissectors/packet-pcapng_block.c @@ -58,7 +58,7 @@ void proto_register_pcapng_block(void) proto_pcapng_block = proto_register_protocol("PCAP-NG block", "PCAP-NG", "pcapng"); pcapng_block_type_dissector_table = register_dissector_table("pcapng.block_type", - "pcap-ng block type", FT_UINT32, BASE_DEC); + "pcap-ng block type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-pcli.c b/epan/dissectors/packet-pcli.c index 697c7f4d01..f0704bbdbe 100644 --- a/epan/dissectors/packet-pcli.c +++ b/epan/dissectors/packet-pcli.c @@ -267,7 +267,7 @@ proto_register_pcli(void) pcli_subdissector_table = register_dissector_table( "pcli.payload", "PCLI payload dissector", - FT_UINT32, BASE_DEC); + FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_decode_as(&pcli_payload_da); } diff --git a/epan/dissectors/packet-per.c b/epan/dissectors/packet-per.c index c6a3cfa687..ffc27b5724 100644 --- a/epan/dissectors/packet-per.c +++ b/epan/dissectors/packet-per.c @@ -2765,7 +2765,7 @@ proto_register_per(void) "Whether the dissector should put the internal PER data in the tree or if it should hide it", &display_internal_per_fields); - per_oid_dissector_table = register_dissector_table("per.oid", "PER OID Dissectors", FT_STRING, BASE_NONE); + per_oid_dissector_table = register_dissector_table("per.oid", "PER OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-pgm.c b/epan/dissectors/packet-pgm.c index 1a44dadc45..0f3f9b769c 100644 --- a/epan/dissectors/packet-pgm.c +++ b/epan/dissectors/packet-pgm.c @@ -1404,7 +1404,7 @@ proto_register_pgm(void) /* subdissector code */ subdissector_table = register_dissector_table("pgm.port", - "PGM port", FT_UINT16, BASE_DEC); + "PGM port", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); heur_subdissector_list = register_heur_dissector_list("pgm"); /* diff --git a/epan/dissectors/packet-ppp.c b/epan/dissectors/packet-ppp.c index e586b73fa8..01612b2d68 100644 --- a/epan/dissectors/packet-ppp.c +++ b/epan/dissectors/packet-ppp.c @@ -5417,7 +5417,7 @@ proto_register_ppp(void) /* subdissector code */ ppp_subdissector_table = register_dissector_table("ppp.protocol", - "PPP protocol", FT_UINT16, BASE_HEX); + "PPP protocol", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_dissector("ppp_hdlc", dissect_ppp_hdlc, proto_ppp); register_dissector("ppp_lcp_options", dissect_lcp_options, proto_ppp); diff --git a/epan/dissectors/packet-q931.c b/epan/dissectors/packet-q931.c index 14d45f271e..50463c5f0b 100644 --- a/epan/dissectors/packet-q931.c +++ b/epan/dissectors/packet-q931.c @@ -3969,8 +3969,8 @@ proto_register_q931(void) register_dissector("q931.ie.cs7", dissect_q931_ie_cs7, proto_q931); /* subdissector code */ - codeset_dissector_table = register_dissector_table("q931.codeset", "Q.931 Codeset", FT_UINT8, BASE_HEX); - ie_dissector_table = register_dissector_table("q931.ie", "Q.931 IE", FT_UINT16, BASE_HEX); + codeset_dissector_table = register_dissector_table("q931.codeset", "Q.931 Codeset", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ie_dissector_table = register_dissector_table("q931.ie", "Q.931 IE", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); q931_user_heur_subdissector_list = register_heur_dissector_list("q931_user"); q931_module = prefs_register_protocol(proto_q931, NULL); diff --git a/epan/dissectors/packet-q932.c b/epan/dissectors/packet-q932.c index f058f73b24..1667ad7d13 100644 --- a/epan/dissectors/packet-q932.c +++ b/epan/dissectors/packet-q932.c @@ -1036,17 +1036,17 @@ void proto_register_q932(void) { rose_ctx_init(&q932_rose_ctx); /* Register dissector tables */ - q932_rose_ctx.arg_global_dissector_table = register_dissector_table("q932.ros.global.arg", "Q.932 Operation Argument (global opcode)", FT_STRING, BASE_NONE); - q932_rose_ctx.res_global_dissector_table = register_dissector_table("q932.ros.global.res", "Q.932 Operation Result (global opcode)", FT_STRING, BASE_NONE); - q932_rose_ctx.err_global_dissector_table = register_dissector_table("q932.ros.global.err", "Q.932 Error (global opcode)", FT_STRING, BASE_NONE); + q932_rose_ctx.arg_global_dissector_table = register_dissector_table("q932.ros.global.arg", "Q.932 Operation Argument (global opcode)", 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)", 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)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - qsig_arg_local_dissector_table = register_dissector_table("q932.ros.local.arg", "Q.932 Operation Argument (local opcode)", FT_UINT32, BASE_HEX); - qsig_res_local_dissector_table = register_dissector_table("q932.ros.local.res", "Q.932 Operation Result (local opcode)", FT_UINT32, BASE_HEX); - qsig_err_local_dissector_table = register_dissector_table("q932.ros.local.err", "Q.932 Error (local opcode)", FT_UINT32, BASE_HEX); + qsig_arg_local_dissector_table = register_dissector_table("q932.ros.local.arg", "Q.932 Operation Argument (local opcode)", 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)", 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)", 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)", FT_UINT32, BASE_HEX); - etsi_res_local_dissector_table = register_dissector_table("q932.ros.etsi.local.res", "Q.932 ETSI Operation Result (local opcode)", FT_UINT32, BASE_HEX); - etsi_err_local_dissector_table = register_dissector_table("q932.ros.etsi.local.err", "Q.932 ETSI Error (local opcode)", FT_UINT32, BASE_HEX); + etsi_arg_local_dissector_table = register_dissector_table("q932.ros.etsi.local.arg", "Q.932 ETSI Operation Argument (local opcode)", 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)", 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)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); q932_module = prefs_register_protocol(proto_q932, proto_reg_handoff_q932); diff --git a/epan/dissectors/packet-qsig.c b/epan/dissectors/packet-qsig.c index 02bc45af8b..93bf8e7825 100644 --- a/epan/dissectors/packet-qsig.c +++ b/epan/dissectors/packet-qsig.c @@ -16378,7 +16378,7 @@ void proto_register_qsig(void) { expert_register_field_array(expert_qsig, ei, array_length(ei)); /* Register dissector tables */ - extension_dissector_table = register_dissector_table("qsig.ext", "QSIG Extension", FT_STRING, BASE_NONE); + extension_dissector_table = register_dissector_table("qsig.ext", "QSIG Extension", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); qsig_init_tables(); } diff --git a/epan/dissectors/packet-raknet.c b/epan/dissectors/packet-raknet.c index b7a01d2d6f..c025c16be4 100644 --- a/epan/dissectors/packet-raknet.c +++ b/epan/dissectors/packet-raknet.c @@ -644,7 +644,7 @@ proto_register_raknet(void) raknet_dissector_table = register_dissector_table("raknet.packet_id", "RakNet libs packet ids", - FT_UINT8, BASE_HEX); + FT_UINT8, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* * Raknet subdissector for use by external protocols. */ diff --git a/epan/dissectors/packet-ranap.c b/epan/dissectors/packet-ranap.c index 1245e20c6c..c7de5c9f41 100644 --- a/epan/dissectors/packet-ranap.c +++ b/epan/dissectors/packet-ranap.c @@ -16495,16 +16495,16 @@ void proto_register_ranap(void) { new_register_dissector("ranap", dissect_ranap, proto_ranap); /* Register dissector tables */ - ranap_ies_dissector_table = register_dissector_table("ranap.ies", "RANAP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - ranap_ies_p1_dissector_table = register_dissector_table("ranap.ies.pair.first", "RANAP-PROTOCOL-IES-PAIR FirstValue", FT_UINT32, BASE_DEC); - ranap_ies_p2_dissector_table = register_dissector_table("ranap.ies.pair.second", "RANAP-PROTOCOL-IES-PAIR SecondValue", FT_UINT32, BASE_DEC); - ranap_extension_dissector_table = register_dissector_table("ranap.extension", "RANAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - ranap_proc_imsg_dissector_table = register_dissector_table("ranap.proc.imsg", "RANAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - ranap_proc_sout_dissector_table = register_dissector_table("ranap.proc.sout", "RANAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - ranap_proc_uout_dissector_table = register_dissector_table("ranap.proc.uout", "RANAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); - ranap_proc_out_dissector_table = register_dissector_table("ranap.proc.out", "RANAP-ELEMENTARY-PROCEDURE Outcome", FT_UINT32, BASE_DEC); - - nas_pdu_dissector_table = register_dissector_table("ranap.nas_pdu", "RANAP NAS PDU", FT_UINT8, BASE_DEC); + ranap_ies_dissector_table = register_dissector_table("ranap.ies", "RANAP-PROTOCOL-IES", 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", 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", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_extension_dissector_table = register_dissector_table("ranap.extension", "RANAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_imsg_dissector_table = register_dissector_table("ranap.proc.imsg", "RANAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_sout_dissector_table = register_dissector_table("ranap.proc.sout", "RANAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_uout_dissector_table = register_dissector_table("ranap.proc.uout", "RANAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_out_dissector_table = register_dissector_table("ranap.proc.out", "RANAP-ELEMENTARY-PROCEDURE Outcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + + nas_pdu_dissector_table = register_dissector_table("ranap.nas_pdu", "RANAP NAS PDU", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); ranap_module = prefs_register_protocol(proto_ranap, proto_reg_handoff_ranap); prefs_register_uint_preference(ranap_module, "sccp_ssn", "SCCP SSN for RANAP", diff --git a/epan/dissectors/packet-rmcp.c b/epan/dissectors/packet-rmcp.c index dd3ddce298..ceb7d974a0 100644 --- a/epan/dissectors/packet-rmcp.c +++ b/epan/dissectors/packet-rmcp.c @@ -224,7 +224,7 @@ proto_register_rmcp(void) proto_register_subtree_array(ett, array_length(ett)); rmcp_dissector_table = register_dissector_table( - "rmcp.class", "RMCP Class", FT_UINT8, BASE_HEX); + "rmcp.class", "RMCP Class", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-rnsap.c b/epan/dissectors/packet-rnsap.c index b9fc200dde..51041cd73d 100644 --- a/epan/dissectors/packet-rnsap.c +++ b/epan/dissectors/packet-rnsap.c @@ -55352,11 +55352,11 @@ void proto_register_rnsap(void) { new_register_dissector("rnsap", dissect_rnsap, proto_rnsap); /* Register dissector tables */ - rnsap_ies_dissector_table = register_dissector_table("rnsap.ies", "RNSAP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - rnsap_extension_dissector_table = register_dissector_table("rnsap.extension", "RNSAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - rnsap_proc_imsg_dissector_table = register_dissector_table("rnsap.proc.imsg", "RNSAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_STRING, BASE_NONE); - rnsap_proc_sout_dissector_table = register_dissector_table("rnsap.proc.sout", "RNSAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_STRING, BASE_NONE); - rnsap_proc_uout_dissector_table = register_dissector_table("rnsap.proc.uout", "RNSAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_STRING, BASE_NONE); + rnsap_ies_dissector_table = register_dissector_table("rnsap.ies", "RNSAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_extension_dissector_table = register_dissector_table("rnsap.extension", "RNSAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_proc_imsg_dissector_table = register_dissector_table("rnsap.proc.imsg", "RNSAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_proc_sout_dissector_table = register_dissector_table("rnsap.proc.sout", "RNSAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_proc_uout_dissector_table = register_dissector_table("rnsap.proc.uout", "RNSAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-ros.c b/epan/dissectors/packet-ros.c index 7f0a03595a..6db3a874a0 100644 --- a/epan/dissectors/packet-ros.c +++ b/epan/dissectors/packet-ros.c @@ -1279,7 +1279,7 @@ void proto_register_ros(void) { expert_ros = expert_register_protocol(proto_ros); expert_register_field_array(expert_ros, ei, array_length(ei)); - ros_oid_dissector_table = register_dissector_table("ros.oid", "ROS OID Dissectors", FT_STRING, BASE_NONE); + ros_oid_dissector_table = register_dissector_table("ros.oid", "ROS OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); oid_table=g_hash_table_new(g_str_hash, g_str_equal); protocol_table=g_hash_table_new(g_str_hash, g_str_equal); diff --git a/epan/dissectors/packet-rpc.c b/epan/dissectors/packet-rpc.c index 5079419d8e..6137c261db 100644 --- a/epan/dissectors/packet-rpc.c +++ b/epan/dissectors/packet-rpc.c @@ -4252,8 +4252,8 @@ proto_register_rpc(void) proto_rpc = proto_register_protocol("Remote Procedure Call", "RPC", "rpc"); - subdissector_call_table = register_custom_dissector_table("rpc.call", "RPC Call Functions", rpc_proc_hash, rpc_proc_equal); - subdissector_reply_table = register_custom_dissector_table("rpc.reply", "RPC Reply Functions", rpc_proc_hash, rpc_proc_equal); + subdissector_call_table = register_custom_dissector_table("rpc.call", "RPC Call Functions", rpc_proc_hash, rpc_proc_equal, DISSECTOR_TABLE_ALLOW_DUPLICATE); + subdissector_reply_table = register_custom_dissector_table("rpc.reply", "RPC Reply Functions", rpc_proc_hash, rpc_proc_equal, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* this is a dummy dissector for all those unknown rpc programs */ proto_register_field_array(proto_rpc, hf, array_length(hf)); diff --git a/epan/dissectors/packet-rtacser.c b/epan/dissectors/packet-rtacser.c index c150a1dcd0..d89865bc9a 100644 --- a/epan/dissectors/packet-rtacser.c +++ b/epan/dissectors/packet-rtacser.c @@ -293,7 +293,7 @@ proto_register_rtacser(void) /* Registering protocol to be called by another dissector */ new_register_dissector("rtacser", dissect_rtacser, proto_rtacser); - subdissector_table = register_dissector_table("rtacser.data", "RTAC Serial Data Subdissector", FT_UINT32, BASE_HEX); + subdissector_table = register_dissector_table("rtacser.data", "RTAC Serial Data Subdissector", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_rtacser, rtacser_hf, array_length(rtacser_hf)); diff --git a/epan/dissectors/packet-rtcp.c b/epan/dissectors/packet-rtcp.c index 369e46264b..5d11477f8c 100644 --- a/epan/dissectors/packet-rtcp.c +++ b/epan/dissectors/packet-rtcp.c @@ -6531,9 +6531,9 @@ proto_register_rtcp(void) 10, &global_rtcp_show_roundtrip_calculation_minimum); /* Register table for sub-dissetors */ - rtcp_dissector_table = register_dissector_table("rtcp.app.name", "RTCP Application Name", FT_STRING, BASE_NONE); - rtcp_psfb_dissector_table = register_dissector_table("rtcp.psfb.fmt", "RTCP Payload Specific Feedback Message Format", FT_UINT8, BASE_DEC); - rtcp_rtpfb_dissector_table = register_dissector_table("rtcp.rtpfb.fmt", "RTCP Generic RTP Feedback Message Format", FT_UINT8, BASE_DEC); + rtcp_dissector_table = register_dissector_table("rtcp.app.name", "RTCP Application Name", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + rtcp_psfb_dissector_table = register_dissector_table("rtcp.psfb.fmt", "RTCP Payload Specific Feedback Message Format", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + rtcp_rtpfb_dissector_table = register_dissector_table("rtcp.rtpfb.fmt", "RTCP Generic RTP Feedback Message Format", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-rtp.c b/epan/dissectors/packet-rtp.c index 2998ec13ff..4e157b07fe 100644 --- a/epan/dissectors/packet-rtp.c +++ b/epan/dissectors/packet-rtp.c @@ -3669,15 +3669,15 @@ proto_register_rtp(void) rtp_tap = register_tap("rtp"); rtp_pt_dissector_table = register_dissector_table("rtp.pt", - "RTP payload type", FT_UINT8, BASE_DEC); + "RTP payload type", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); rtp_dyn_pt_dissector_table = register_dissector_table("rtp_dyn_payload_type", - "Dynamic RTP payload type", FT_STRING, TRUE); + "Dynamic RTP payload type", FT_STRING, TRUE, DISSECTOR_TABLE_ALLOW_DUPLICATE); rtp_hdr_ext_dissector_table = register_dissector_table("rtp.hdr_ext", - "RTP header extension", FT_UINT32, BASE_HEX); + "RTP header extension", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); rtp_hdr_ext_rfc5285_dissector_table = register_dissector_table("rtp.ext.rfc5285.id", - "RTP Generic header extension (RFC 5285)", FT_UINT8, BASE_DEC); + "RTP Generic header extension (RFC 5285)", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_dissector("rtp.ext.ed137", dissect_rtp_hdr_ext_ed137, proto_rtp); register_dissector("rtp.ext.ed137a", dissect_rtp_hdr_ext_ed137a, proto_rtp); diff --git a/epan/dissectors/packet-rtse.c b/epan/dissectors/packet-rtse.c index 5ba17e72d9..4f11458369 100644 --- a/epan/dissectors/packet-rtse.c +++ b/epan/dissectors/packet-rtse.c @@ -1062,7 +1062,7 @@ void proto_register_rtse(void) { " \"Allow subdissectors to reassemble TCP streams\"" " in the TCP protocol settings.", &rtse_reassemble); - rtse_oid_dissector_table = register_dissector_table("rtse.oid", "RTSE OID Dissectors", FT_STRING, BASE_NONE); + rtse_oid_dissector_table = register_dissector_table("rtse.oid", "RTSE OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); oid_table=g_hash_table_new(g_str_hash, g_str_equal); diff --git a/epan/dissectors/packet-rua.c b/epan/dissectors/packet-rua.c index 65e57b8176..d96af352d4 100644 --- a/epan/dissectors/packet-rua.c +++ b/epan/dissectors/packet-rua.c @@ -1742,11 +1742,11 @@ module_t *rua_module; new_register_dissector("rua", dissect_rua, proto_rua); /* Register dissector tables */ - rua_ies_dissector_table = register_dissector_table("rua.ies", "RUA-PROTOCOL-IES", FT_UINT32, BASE_DEC); - rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + rua_ies_dissector_table = register_dissector_table("rua.ies", "RUA-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); 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); diff --git a/epan/dissectors/packet-s1ap.c b/epan/dissectors/packet-s1ap.c index 88a0ce03b4..8f62e95195 100644 --- a/epan/dissectors/packet-s1ap.c +++ b/epan/dissectors/packet-s1ap.c @@ -13392,13 +13392,13 @@ void proto_register_s1ap(void) { register_dissector("s1ap", dissect_s1ap, proto_s1ap); /* Register dissector tables */ - s1ap_ies_dissector_table = register_dissector_table("s1ap.ies", "S1AP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - s1ap_ies_p1_dissector_table = register_dissector_table("s1ap.ies.pair.first", "S1AP-PROTOCOL-IES-PAIR FirstValue", FT_UINT32, BASE_DEC); - s1ap_ies_p2_dissector_table = register_dissector_table("s1ap.ies.pair.second", "S1AP-PROTOCOL-IES-PAIR SecondValue", FT_UINT32, BASE_DEC); - s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + s1ap_ies_dissector_table = register_dissector_table("s1ap.ies", "S1AP-PROTOCOL-IES", 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", 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", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register configuration options for ports */ s1ap_module = prefs_register_protocol(proto_s1ap, proto_reg_handoff_s1ap); diff --git a/epan/dissectors/packet-s5066sis.c b/epan/dissectors/packet-s5066sis.c index 29829d3e1e..54fea05e87 100644 --- a/epan/dissectors/packet-s5066sis.c +++ b/epan/dissectors/packet-s5066sis.c @@ -1447,7 +1447,7 @@ proto_register_s5066(void) " This number is registered with IANA.)", 10, &global_s5066_port); - s5066sis_dissector_table = register_dissector_table("s5066sis.ctl.appid", "STANAG 5066 Application Identifier", FT_UINT16, BASE_DEC); + s5066sis_dissector_table = register_dissector_table("s5066sis.ctl.appid", "STANAG 5066 Application Identifier", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-sabp.c b/epan/dissectors/packet-sabp.c index fbbea58995..da08756dab 100644 --- a/epan/dissectors/packet-sabp.c +++ b/epan/dissectors/packet-sabp.c @@ -2273,11 +2273,11 @@ void proto_register_sabp(void) { new_register_dissector("sabp.tcp", dissect_sabp_tcp, proto_sabp); /* Register dissector tables */ - sabp_ies_dissector_table = register_dissector_table("sabp.ies", "SABP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - sabp_extension_dissector_table = register_dissector_table("sabp.extension", "SABP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - sabp_proc_imsg_dissector_table = register_dissector_table("sabp.proc.imsg", "SABP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - sabp_proc_sout_dissector_table = register_dissector_table("sabp.proc.sout", "SABP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - sabp_proc_uout_dissector_table = register_dissector_table("sabp.proc.uout", "SABP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + sabp_ies_dissector_table = register_dissector_table("sabp.ies", "SABP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_extension_dissector_table = register_dissector_table("sabp.extension", "SABP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_proc_imsg_dissector_table = register_dissector_table("sabp.proc.imsg", "SABP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_proc_sout_dissector_table = register_dissector_table("sabp.proc.sout", "SABP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_proc_uout_dissector_table = register_dissector_table("sabp.proc.uout", "SABP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-sbc-ap.c b/epan/dissectors/packet-sbc-ap.c index 4f59cfaebb..bed8385fbd 100644 --- a/epan/dissectors/packet-sbc-ap.c +++ b/epan/dissectors/packet-sbc-ap.c @@ -1458,11 +1458,11 @@ void proto_register_sbc_ap(void) { /* Register dissector tables */ - sbc_ap_ies_dissector_table = register_dissector_table("sbc_ap.ies", "SBC-AP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - sbc_ap_extension_dissector_table = register_dissector_table("sbc_ap.extension", "SBC-AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - sbc_ap_proc_imsg_dissector_table = register_dissector_table("sbc_ap.proc.imsg", "SBC-AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - sbc_ap_proc_sout_dissector_table = register_dissector_table("sbc_ap.proc.sout", "SBC-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - sbc_ap_proc_uout_dissector_table = register_dissector_table("sbc_ap.proc.uout", "SBC-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + sbc_ap_ies_dissector_table = register_dissector_table("sbc_ap.ies", "SBC-AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sbc_ap_extension_dissector_table = register_dissector_table("sbc_ap.extension", "SBC-AP-PROTOCOL-EXTENSION", 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", 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", 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", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-sccp.c b/epan/dissectors/packet-sccp.c index 7f2a1025cf..229e674068 100644 --- a/epan/dissectors/packet-sccp.c +++ b/epan/dissectors/packet-sccp.c @@ -4084,7 +4084,7 @@ proto_register_sccp(void) expert_sccp = expert_register_protocol(proto_sccp); expert_register_field_array(expert_sccp, ei, array_length(ei)); - sccp_ssn_dissector_table = register_dissector_table("sccp.ssn", "SCCP SSN", FT_UINT8, BASE_DEC); + sccp_ssn_dissector_table = register_dissector_table("sccp.ssn", "SCCP SSN", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); heur_subdissector_list = register_heur_dissector_list("sccp"); diff --git a/epan/dissectors/packet-sctp.c b/epan/dissectors/packet-sctp.c index 0fc30fafc2..479ce656c0 100644 --- a/epan/dissectors/packet-sctp.c +++ b/epan/dissectors/packet-sctp.c @@ -5038,8 +5038,8 @@ proto_register_sctp(void) sctp_tap = register_tap("sctp"); exported_pdu_tap = find_tap_id(EXPORT_PDU_TAP_NAME_LAYER_3); /* subdissector code */ - sctp_port_dissector_table = register_dissector_table("sctp.port", "SCTP port", FT_UINT16, BASE_DEC); - sctp_ppi_dissector_table = register_dissector_table("sctp.ppi", "SCTP payload protocol identifier", FT_UINT32, BASE_HEX); + sctp_port_dissector_table = register_dissector_table("sctp.port", "SCTP port", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + sctp_ppi_dissector_table = register_dissector_table("sctp.ppi", "SCTP payload protocol identifier", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_dissector("sctp", dissect_sctp, proto_sctp); sctp_heur_subdissector_list = register_heur_dissector_list("sctp"); diff --git a/epan/dissectors/packet-sdp.c b/epan/dissectors/packet-sdp.c index 42a820ccdf..ec01b8b6b1 100644 --- a/epan/dissectors/packet-sdp.c +++ b/epan/dissectors/packet-sdp.c @@ -3076,7 +3076,7 @@ proto_register_sdp(void) expert_register_field_array(expert_sdp, ei, array_length(ei)); key_mgmt_dissector_table = register_dissector_table("key_mgmt", - "Key Management", FT_STRING, BASE_NONE); + "Key Management", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* * Preferences registration */ diff --git a/epan/dissectors/packet-sflow.c b/epan/dissectors/packet-sflow.c index 492799c6f6..bcbfc93571 100644 --- a/epan/dissectors/packet-sflow.c +++ b/epan/dissectors/packet-sflow.c @@ -3468,7 +3468,7 @@ proto_register_sflow(void) { expert_sflow = expert_register_protocol(proto_sflow); expert_register_field_array(expert_sflow, ei, array_length(ei)); - header_subdissector_table = register_dissector_table("sflow_245.header_protocol", "SFLOW header protocol", FT_UINT32, BASE_DEC); + header_subdissector_table = register_dissector_table("sflow_245.header_protocol", "SFLOW header protocol", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Register our configuration options for sFlow */ sflow_245_module = prefs_register_protocol(proto_sflow, proto_reg_handoff_sflow_245); diff --git a/epan/dissectors/packet-sip.c b/epan/dissectors/packet-sip.c index 8160c87001..08a70181fc 100644 --- a/epan/dissectors/packet-sip.c +++ b/epan/dissectors/packet-sip.c @@ -6407,7 +6407,7 @@ void proto_register_sip(void) /* Register for tapping */ sip_tap = register_tap("sip"); - ext_hdr_subdissector_table = register_dissector_table("sip.hdr", "SIP Extension header", FT_STRING, BASE_NONE); + ext_hdr_subdissector_table = register_dissector_table("sip.hdr", "SIP Extension header", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_new_stat_tap_ui(&sip_stat_table); diff --git a/epan/dissectors/packet-sita.c b/epan/dissectors/packet-sita.c index abc5632430..428bb52eb2 100644 --- a/epan/dissectors/packet-sita.c +++ b/epan/dissectors/packet-sita.c @@ -375,7 +375,7 @@ proto_register_sita(void) }; proto_sita = proto_register_protocol("Societe Internationale de Telecommunications Aeronautiques", "SITA", "sita"); /* name, short name,abbreviation */ - sita_dissector_table = register_dissector_table("sita.proto", "SITA protocol number", FT_UINT8, BASE_HEX); + sita_dissector_table = register_dissector_table("sita.proto", "SITA protocol number", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_register_field_array(proto_sita, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("sita", dissect_sita, proto_sita); diff --git a/epan/dissectors/packet-sll.c b/epan/dissectors/packet-sll.c index b8dc3deb5d..2e41d723fc 100644 --- a/epan/dissectors/packet-sll.c +++ b/epan/dissectors/packet-sll.c @@ -339,7 +339,7 @@ proto_register_sll(void) "sll.ltype", "Linux SLL protocol type", FT_UINT16, - BASE_HEX + BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE ); } diff --git a/epan/dissectors/packet-slowprotocols.c b/epan/dissectors/packet-slowprotocols.c index 79944a6679..ee8be727db 100644 --- a/epan/dissectors/packet-slowprotocols.c +++ b/epan/dissectors/packet-slowprotocols.c @@ -135,7 +135,7 @@ proto_register_slow_protocols(void) /* subdissector code */ slow_protocols_dissector_table = register_dissector_table("slow.subtype", "Slow protocol subtype", - FT_UINT8, BASE_DEC); + FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-snmp.c b/epan/dissectors/packet-snmp.c index 6a258641bf..8afd3a98ec 100644 --- a/epan/dissectors/packet-snmp.c +++ b/epan/dissectors/packet-snmp.c @@ -4080,7 +4080,7 @@ void proto_register_snmp(void) { "MIB settings can be changed in the Name Resolution preferences"); #endif - value_sub_dissectors_table = register_dissector_table("snmp.variable_oid","SNMP Variable OID", FT_STRING, BASE_NONE); + value_sub_dissectors_table = register_dissector_table("snmp.variable_oid","SNMP Variable OID", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_init_routine(init_ue_cache); register_cleanup_routine(cleanup_ue_cache); diff --git a/epan/dissectors/packet-socketcan.c b/epan/dissectors/packet-socketcan.c index 52891c47b2..8385b10551 100644 --- a/epan/dissectors/packet-socketcan.c +++ b/epan/dissectors/packet-socketcan.c @@ -233,7 +233,7 @@ proto_register_socketcan(void) proto_register_subtree_array(ett, array_length(ett)); subdissector_table = register_dissector_table("can.subdissector", - "CAN next level dissector", FT_UINT32, BASE_HEX); + "CAN next level dissector", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); can_module = prefs_register_protocol(proto_can, NULL); diff --git a/epan/dissectors/packet-spp.c b/epan/dissectors/packet-spp.c index fb8d85f530..530a066d9f 100644 --- a/epan/dissectors/packet-spp.c +++ b/epan/dissectors/packet-spp.c @@ -260,7 +260,7 @@ proto_register_spp(void) proto_register_subtree_array(ett, array_length(ett)); spp_socket_dissector_table = register_dissector_table("spp.socket", - "SPP socket", FT_UINT16, BASE_HEX); + "SPP socket", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-sua.c b/epan/dissectors/packet-sua.c index 7b3dc0177f..a82d168056 100644 --- a/epan/dissectors/packet-sua.c +++ b/epan/dissectors/packet-sua.c @@ -2474,7 +2474,7 @@ proto_register_sua(void) " This may affect TCAP's ability to recognize which messages belong to which TCAP session.", &set_addresses); heur_subdissector_list = register_heur_dissector_list("sua"); - sua_parameter_table = register_dissector_table("sua.prop.tags", "SUA Proprietary Tags", FT_UINT16, BASE_DEC); + sua_parameter_table = register_dissector_table("sua.prop.tags", "SUA Proprietary Tags", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); sua_tap = register_tap("sua"); assocs = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); diff --git a/epan/dissectors/packet-t124.c b/epan/dissectors/packet-t124.c index a67133e967..19fd89da51 100644 --- a/epan/dissectors/packet-t124.c +++ b/epan/dissectors/packet-t124.c @@ -4018,8 +4018,8 @@ void proto_register_t124(void) { proto_register_field_array(proto_t124, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - t124_ns_dissector_table = register_dissector_table("t124.ns", "T.124 H.221 Non Standard Dissectors", FT_STRING, BASE_NONE); - t124_sd_dissector_table = register_dissector_table("t124.sd", "T.124 H.221 Send Data Dissectors", FT_UINT32, BASE_HEX); + t124_ns_dissector_table = register_dissector_table("t124.ns", "T.124 H.221 Non Standard Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + t124_sd_dissector_table = register_dissector_table("t124.sd", "T.124 H.221 Send Data Dissectors", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); new_register_dissector("t124", dissect_t124_new, proto_t124); diff --git a/epan/dissectors/packet-tali.c b/epan/dissectors/packet-tali.c index b8c9e2bd84..0550072efa 100644 --- a/epan/dissectors/packet-tali.c +++ b/epan/dissectors/packet-tali.c @@ -210,7 +210,7 @@ proto_register_tali(void) proto_register_fields(proto_tali, hfi, array_length(hfi)); proto_register_subtree_array(ett, array_length(ett)); - tali_dissector_table = register_dissector_table("tali.opcode", "Tali OPCODE", FT_STRING, BASE_NONE); + tali_dissector_table = register_dissector_table("tali.opcode", "Tali OPCODE", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); tali_module = prefs_register_protocol(proto_tali, NULL); prefs_register_bool_preference(tali_module, "reassemble", diff --git a/epan/dissectors/packet-tcp.c b/epan/dissectors/packet-tcp.c index 56bbdf34e6..5b1b2ff39d 100644 --- a/epan/dissectors/packet-tcp.c +++ b/epan/dissectors/packet-tcp.c @@ -6536,7 +6536,7 @@ proto_register_tcp(void) /* subdissector code */ subdissector_table = register_dissector_table("tcp.port", - "TCP port", FT_UINT16, BASE_DEC); + "TCP port", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); heur_subdissector_list = register_heur_dissector_list("tcp"); /* Register configuration preferences */ diff --git a/epan/dissectors/packet-teredo.c b/epan/dissectors/packet-teredo.c index 091a38bb76..a07117804b 100644 --- a/epan/dissectors/packet-teredo.c +++ b/epan/dissectors/packet-teredo.c @@ -387,7 +387,7 @@ proto_register_teredo(void) proto_register_subtree_array(ett, array_length(ett)); /* subdissector code */ - teredo_dissector_table = register_dissector_table("teredo","Teredo ", FT_UINT16, BASE_DEC); + teredo_dissector_table = register_dissector_table("teredo","Teredo ", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); teredo_module = prefs_register_protocol(proto_teredo, NULL); diff --git a/epan/dissectors/packet-tipc.c b/epan/dissectors/packet-tipc.c index 508c2e7a34..6abcc13afa 100644 --- a/epan/dissectors/packet-tipc.c +++ b/epan/dissectors/packet-tipc.c @@ -3026,12 +3026,12 @@ proto_register_tipc(void) /* this allows e.g. to dissect everything which is TIPC Data */ tipc_user_dissector = register_dissector_table("tipc.usr", - "TIPC user", FT_UINT8, BASE_DEC); + "TIPC user", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* this allows to dissect everything which is TIPC Data and uses a specific * port name type it actually does not really work because the type is not * necessarily set in every data message */ tipc_type_dissector = register_dissector_table("tipcv2.port_name_type", - "TIPC port name type", FT_UINT32, BASE_DEC); + "TIPC port name type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* make heuristic dissectors possible */ tipc_heur_subdissector_list = register_heur_dissector_list("tipc"); diff --git a/epan/dissectors/packet-ua.c b/epan/dissectors/packet-ua.c index 941ccc190f..986b890d30 100644 --- a/epan/dissectors/packet-ua.c +++ b/epan/dissectors/packet-ua.c @@ -300,7 +300,7 @@ void proto_reg_handoff_ua_msg(void) register_dissector_table("ua.opcode", "ua.opcode", FT_UINT8, - BASE_HEX); + BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); #endif diff --git a/epan/dissectors/packet-uaudp.c b/epan/dissectors/packet-uaudp.c index 93da22a073..d5df3d6eae 100644 --- a/epan/dissectors/packet-uaudp.c +++ b/epan/dissectors/packet-uaudp.c @@ -642,7 +642,7 @@ void proto_reg_handoff_uaudp(void) register_dissector_table("uaudp.opcode", "UAUDP opcode", FT_UINT8, - BASE_DEC); + BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); #endif prefs_initialized = TRUE; } diff --git a/epan/dissectors/packet-udp.c b/epan/dissectors/packet-udp.c index 197131c15c..a6c0409be9 100644 --- a/epan/dissectors/packet-udp.c +++ b/epan/dissectors/packet-udp.c @@ -1087,7 +1087,7 @@ proto_register_udp(void) /* subdissector code */ udp_dissector_table = register_dissector_table("udp.port", - "UDP port", FT_UINT16, BASE_DEC); + "UDP port", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); heur_subdissector_list = register_heur_dissector_list("udp"); /* Register configuration preferences */ diff --git a/epan/dissectors/packet-usb.c b/epan/dissectors/packet-usb.c index 55decc792b..b4757f48e1 100644 --- a/epan/dissectors/packet-usb.c +++ b/epan/dissectors/packet-usb.c @@ -4515,21 +4515,21 @@ proto_register_usb(void) device_to_product_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); device_to_protocol_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); - device_to_dissector = register_dissector_table("usb.device", "USB device", FT_UINT32, BASE_HEX); - protocol_to_dissector = register_dissector_table("usb.protocol", "USB protocol", FT_UINT32, BASE_HEX); - product_to_dissector = register_dissector_table("usb.product", "USB product", FT_UINT32, BASE_HEX); + device_to_dissector = register_dissector_table("usb.device", "USB device", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + protocol_to_dissector = register_dissector_table("usb.protocol", "USB protocol", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + product_to_dissector = register_dissector_table("usb.product", "USB product", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); usb_bulk_dissector_table = register_dissector_table("usb.bulk", - "USB bulk endpoint", FT_UINT8, BASE_DEC); + "USB bulk endpoint", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); heur_bulk_subdissector_list = register_heur_dissector_list("usb.bulk"); usb_control_dissector_table = register_dissector_table("usb.control", - "USB control endpoint", FT_UINT8, BASE_DEC); + "USB control endpoint", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); heur_control_subdissector_list = register_heur_dissector_list("usb.control"); usb_interrupt_dissector_table = register_dissector_table("usb.interrupt", - "USB interrupt endpoint", FT_UINT8, BASE_DEC); + "USB interrupt endpoint", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); heur_interrupt_subdissector_list = register_heur_dissector_list("usb.interrupt"); usb_descriptor_dissector_table = register_dissector_table("usb.descriptor", - "USB descriptor", FT_UINT8, BASE_DEC); + "USB descriptor", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); usb_module = prefs_register_protocol(proto_usb, NULL); prefs_register_bool_preference(usb_module, "try_heuristics", diff --git a/epan/dissectors/packet-vines.c b/epan/dissectors/packet-vines.c index 5a3b8b66c6..702fcf50ec 100644 --- a/epan/dissectors/packet-vines.c +++ b/epan/dissectors/packet-vines.c @@ -486,7 +486,7 @@ proto_register_vines_llc(void) /* subdissector code */ vines_llc_dissector_table = register_dissector_table("vines_llc.ptype", - "Vines LLC protocol", FT_UINT8, BASE_HEX); + "Vines LLC protocol", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void @@ -688,7 +688,7 @@ proto_register_vines_ip(void) /* subdissector code */ vines_ip_dissector_table = register_dissector_table("vines_ip.protocol", - "Vines protocol", FT_UINT8, BASE_HEX); + "Vines protocol", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); vines_ip_handle = create_dissector_handle(dissect_vines_ip, proto_vines_ip); diff --git a/epan/dissectors/packet-websocket.c b/epan/dissectors/packet-websocket.c index a96dd17ce7..0d86807311 100644 --- a/epan/dissectors/packet-websocket.c +++ b/epan/dissectors/packet-websocket.c @@ -534,7 +534,7 @@ proto_register_websocket(void) heur_subdissector_list = register_heur_dissector_list("ws"); port_subdissector_table = register_dissector_table("ws.port", - "TCP port for protocols using WebSocket", FT_UINT16, BASE_DEC); + "TCP port for protocols using WebSocket", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_register_field_array(proto_websocket, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); diff --git a/epan/dissectors/packet-x25.c b/epan/dissectors/packet-x25.c index a1bbc4dc3d..8b87902765 100644 --- a/epan/dissectors/packet-x25.c +++ b/epan/dissectors/packet-x25.c @@ -2368,7 +2368,7 @@ proto_register_x25(void) expert_register_field_array(expert_x25, ei, array_length(ei)); x25_subdissector_table = register_dissector_table("x.25.spi", - "X.25 secondary protocol identifier", FT_UINT8, BASE_HEX); + "X.25 secondary protocol identifier", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); x25_heur_subdissector_list = register_heur_dissector_list("x.25"); register_dissector("x.25_dir", dissect_x25_dir, proto_x25); diff --git a/epan/dissectors/packet-x2ap.c b/epan/dissectors/packet-x2ap.c index 08d020f01a..023aa7ff34 100644 --- a/epan/dissectors/packet-x2ap.c +++ b/epan/dissectors/packet-x2ap.c @@ -7908,11 +7908,11 @@ void proto_register_x2ap(void) { new_register_dissector("x2ap", dissect_x2ap, proto_x2ap); /* Register dissector tables */ - x2ap_ies_dissector_table = register_dissector_table("x2ap.ies", "X2AP-PROTOCOL-IES", FT_UINT32, BASE_DEC); - x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); - x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); - x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); - x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); + x2ap_ies_dissector_table = register_dissector_table("x2ap.ies", "X2AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register configuration options for ports */ x2ap_module = prefs_register_protocol(proto_x2ap, proto_reg_handoff_x2ap); diff --git a/epan/dissectors/packet-zbee-aps.c b/epan/dissectors/packet-zbee-aps.c index a1351d28a2..166bc56b40 100644 --- a/epan/dissectors/packet-zbee-aps.c +++ b/epan/dissectors/packet-zbee-aps.c @@ -2114,7 +2114,7 @@ void proto_register_zbee_aps(void) expert_register_field_array(expert_zbee_aps, ei, array_length(ei)); /* Register the APS dissector and subdissector list. */ - zbee_aps_dissector_table = register_dissector_table("zbee.profile", "ZigBee Profile ID", FT_UINT16, BASE_HEX); + zbee_aps_dissector_table = register_dissector_table("zbee.profile", "ZigBee Profile ID", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); zbee_aps_handle = new_register_dissector(ZBEE_PROTOABBREV_APS, dissect_zbee_aps, proto_zbee_aps); /* Register the init routine. */ diff --git a/epan/dissectors/packet-zbee-zcl.c b/epan/dissectors/packet-zbee-zcl.c index cfcf4d52dd..bbe8c90708 100644 --- a/epan/dissectors/packet-zbee-zcl.c +++ b/epan/dissectors/packet-zbee-zcl.c @@ -2399,7 +2399,7 @@ void proto_register_zbee_zcl(void) proto_register_subtree_array(ett, array_length(ett)); /* Register the ZCL dissector and subdissector list. */ - zbee_zcl_dissector_table = register_dissector_table("zbee.zcl.cluster", "ZigBee ZCL Cluster ID", FT_UINT16, BASE_HEX); + zbee_zcl_dissector_table = register_dissector_table("zbee.zcl.cluster", "ZigBee ZCL Cluster ID", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); new_register_dissector(ZBEE_PROTOABBREV_ZCL, dissect_zbee_zcl, proto_zbee_zcl); } /* proto_register_zbee_zcl */ diff --git a/epan/packet.c b/epan/packet.c index 465229016c..efd13b8135 100644 --- a/epan/packet.c +++ b/epan/packet.c @@ -95,6 +95,7 @@ struct dissector_table { ftenum_t type; int param; GHashFunc hash_func; + dissector_table_allow_e allow_dup_proto; /* XXX - Could be converted to a flag-like field */ }; static GHashTable *dissector_tables = NULL; @@ -1711,6 +1712,7 @@ dissector_add_for_decode_as(const char *name, dissector_handle_t handle) { dissector_table_t sub_dissectors = find_dissector_table( name); GSList *entry; + dissector_handle_t dup_handle; /* * Make sure the dissector table exists. @@ -1734,6 +1736,22 @@ dissector_add_for_decode_as(const char *name, dissector_handle_t handle) return; } + /* Ensure the protocol is unique. This prevents confusion when using Decode As + with duplicative entires */ + if (sub_dissectors->allow_dup_proto == DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE) + { + for (entry = sub_dissectors->dissector_handles; entry != NULL; entry = g_slist_next(entry)) + { + dup_handle = (dissector_handle_t)entry->data; + if (dup_handle->protocol == handle->protocol) + { + fprintf(stderr, "Duplicative protocol %s in %s\n", proto_get_protocol_short_name(handle->protocol), name); + if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL) + abort(); + } + } + } + /* Add it to the list. */ sub_dissectors->dissector_handles = g_slist_insert_sorted(sub_dissectors->dissector_handles, (gpointer)handle, (GCompareFunc)dissector_compare_filter_name); @@ -1757,6 +1775,13 @@ dissector_table_get_type(dissector_table_t dissector_table) { return dissector_table->type; } +dissector_table_allow_e +dissector_table_get_proto_allowed(dissector_table_t dissector_table) +{ + if (!dissector_table) return DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE; + return dissector_table->allow_dup_proto; +} + static gint uuid_equal(gconstpointer k1, gconstpointer k2) { @@ -2015,7 +2040,7 @@ dissector_all_tables_foreach_table (DATFunc_table func, dissector_table_t register_dissector_table(const char *name, const char *ui_name, const ftenum_t type, - const int param) + const int param, dissector_table_allow_e allow_dup) { dissector_table_t sub_dissectors; @@ -2066,12 +2091,13 @@ register_dissector_table(const char *name, const char *ui_name, const ftenum_t t sub_dissectors->ui_name = ui_name; sub_dissectors->type = type; sub_dissectors->param = param; + sub_dissectors->allow_dup_proto = allow_dup; g_hash_table_insert( dissector_tables, (gpointer)name, (gpointer) sub_dissectors ); return sub_dissectors; } dissector_table_t register_custom_dissector_table(const char *name, - const char *ui_name, GHashFunc hash_func, GEqualFunc key_equal_func) + const char *ui_name, GHashFunc hash_func, GEqualFunc key_equal_func, dissector_table_allow_e allow_dup) { dissector_table_t sub_dissectors; @@ -2093,6 +2119,7 @@ dissector_table_t register_custom_dissector_table(const char *name, sub_dissectors->ui_name = ui_name; sub_dissectors->type = FT_BYTES; /* Consider key a "blob" of data, no need to really create new type */ sub_dissectors->param = BASE_NONE; + sub_dissectors->allow_dup_proto = allow_dup; g_hash_table_insert( dissector_tables, (gpointer)name, (gpointer) sub_dissectors ); return sub_dissectors; } diff --git a/epan/packet.h b/epan/packet.h index 5333d99348..9e54ebe892 100644 --- a/epan/packet.h +++ b/epan/packet.h @@ -124,6 +124,11 @@ typedef enum { HEURISTIC_ENABLE } heuristic_enable_e; +typedef enum { + DISSECTOR_TABLE_ALLOW_DUPLICATE, + DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE +} dissector_table_allow_e; + typedef void (*DATFunc) (const gchar *table_name, ftenum_t selector_type, gpointer key, gpointer value, gpointer user_data); typedef void (*DATFunc_handle) (const gchar *table_name, gpointer value, @@ -202,14 +207,14 @@ WS_DLL_PUBLIC void dissector_all_tables_foreach_table (DATFunc_table func, * case-sensitive) */ WS_DLL_PUBLIC dissector_table_t register_dissector_table(const char *name, - const char *ui_name, const ftenum_t type, const int param); + const char *ui_name, const ftenum_t type, const int param, dissector_table_allow_e allow_dup); /* * Similar to register_dissector_table, but with a "custom" hash function * to store subdissectors. */ WS_DLL_PUBLIC dissector_table_t register_custom_dissector_table(const char *name, - const char *ui_name, GHashFunc hash_func, GEqualFunc key_equal_func); + const char *ui_name, GHashFunc hash_func, GEqualFunc key_equal_func, dissector_table_allow_e allow_dup); /** Deregister the dissector table by table name. */ WS_DLL_PUBLIC void deregister_dissector_table(const char *name); @@ -398,6 +403,10 @@ WS_DLL_PUBLIC GSList *dissector_table_get_dissector_handles(dissector_table_t di */ WS_DLL_PUBLIC ftenum_t dissector_table_get_type(dissector_table_t dissector_table); +/** Get a dissector table's ability to allow duplicate protocols + */ +WS_DLL_PUBLIC dissector_table_allow_e dissector_table_get_proto_allowed(dissector_table_t dissector_table); + /* List of "heuristic" dissectors (which get handed a packet, look at it, and either recognize it as being for their protocol, dissect it, and return TRUE, or don't recognize it and return FALSE) to be called diff --git a/epan/wslua/wslua_dissector.c b/epan/wslua/wslua_dissector.c index 0a31266a36..9ed12a2122 100644 --- a/epan/wslua/wslua_dissector.c +++ b/epan/wslua/wslua_dissector.c @@ -201,7 +201,7 @@ WSLUA_CONSTRUCTOR DissectorTable_new (lua_State *L) { name = g_strdup(name); ui_name = g_strdup(ui_name); - dt->table = register_dissector_table(name, ui_name, type, base); + dt->table = register_dissector_table(name, ui_name, type, base, DISSECTOR_TABLE_ALLOW_DUPLICATE); dt->name = name; dt->ui_name = ui_name; dt->created = TRUE; diff --git a/plugins/docsis/packet-docsis.c b/plugins/docsis/packet-docsis.c index 1df07a8588..6b548c5b55 100644 --- a/plugins/docsis/packet-docsis.c +++ b/plugins/docsis/packet-docsis.c @@ -789,7 +789,7 @@ proto_register_docsis (void) #if 0 docsis_dissector_table = register_dissector_table ("docsis", "DOCSIS Encapsulation Type", - FT_UINT8, BASE_DEC); + FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); #endif proto_docsis = proto_register_protocol ("DOCSIS 1.1", "DOCSIS", "docsis"); diff --git a/plugins/docsis/packet-macmgmt.c b/plugins/docsis/packet-macmgmt.c index a068135451..6680dfce23 100644 --- a/plugins/docsis/packet-macmgmt.c +++ b/plugins/docsis/packet-macmgmt.c @@ -258,7 +258,7 @@ proto_register_docsis_mgmt (void) docsis_mgmt_dissector_table = register_dissector_table ("docsis_mgmt", "DOCSIS Mac Management", - FT_UINT8, BASE_DEC); + FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_docsis_mgmt = proto_register_protocol ("DOCSIS Mac Management", diff --git a/plugins/ethercat/packet-ethercat-frame.c b/plugins/ethercat/packet-ethercat-frame.c index 17b9d3de4a..7ecd0a27bf 100644 --- a/plugins/ethercat/packet-ethercat-frame.c +++ b/plugins/ethercat/packet-ethercat-frame.c @@ -139,7 +139,7 @@ void proto_register_ethercat_frame(void) /* Define a handle (ecatf.type) for sub dissectors that want to dissect the Ethercat frame ether type (E88A4) payload. */ ethercat_frame_dissector_table = register_dissector_table("ecatf.type", - "EtherCAT frame type", FT_UINT8, BASE_DEC); + "EtherCAT frame type", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void proto_reg_handoff_ethercat_frame(void) diff --git a/plugins/wimax/mac_mgmt_msg_decoder.c b/plugins/wimax/mac_mgmt_msg_decoder.c index 12ebf8b7fd..937614b5bc 100644 --- a/plugins/wimax/mac_mgmt_msg_decoder.c +++ b/plugins/wimax/mac_mgmt_msg_decoder.c @@ -213,7 +213,7 @@ void proto_register_mac_mgmt_msg(void) expert_register_field_array(expert_mac_mgmt, ei, array_length(ei)); subdissector_message_table = register_dissector_table("wmx.mgmtmsg", - "WiMax MAC Management Message", FT_UINT8, BASE_DEC); + "WiMax MAC Management Message", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register dissector by name */ register_dissector("wmx_mac_mgmt_msg_decoder", dissect_mac_mgmt_msg_decoder, |