diff options
Diffstat (limited to 'epan/dissectors')
207 files changed, 457 insertions, 458 deletions
diff --git a/epan/dissectors/asn1/ansi_map/packet-ansi_map-template.c b/epan/dissectors/asn1/ansi_map/packet-ansi_map-template.c index 8694cce54c..54ef076af1 100644 --- a/epan/dissectors/asn1/ansi_map/packet-ansi_map-template.c +++ b/epan/dissectors/asn1/ansi_map/packet-ansi_map-template.c @@ -5472,15 +5472,15 @@ void proto_register_ansi_map(void) { is637_tele_id_dissector_table = register_dissector_table("ansi_map.tele_id", "IS-637 Teleservice ID", proto_ansi_map, - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT8, BASE_DEC); is683_dissector_table = register_dissector_table("ansi_map.ota", "IS-683-A (OTA)", proto_ansi_map, - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT8, BASE_DEC); is801_dissector_table = register_dissector_table("ansi_map.pld", "IS-801 (PLD)", proto_ansi_map, - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT8, BASE_DEC); ansi_map_tap = register_tap("ansi_map"); diff --git a/epan/dissectors/asn1/ansi_tcap/packet-ansi_tcap-template.c b/epan/dissectors/asn1/ansi_tcap/packet-ansi_tcap-template.c index 245013b3a4..b66295974e 100644 --- a/epan/dissectors/asn1/ansi_tcap/packet-ansi_tcap-template.c +++ b/epan/dissectors/asn1/ansi_tcap/packet-ansi_tcap-template.c @@ -516,7 +516,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", proto_ansi_tcap, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ansi_tcap_national_opcode_table = register_dissector_table("ansi_tcap.nat.opcode", "ANSI TCAP National Opcodes", proto_ansi_tcap, FT_UINT16, BASE_DEC); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_ansi_tcap, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); diff --git a/epan/dissectors/asn1/camel/packet-camel-template.c b/epan/dissectors/asn1/camel/packet-camel-template.c index 6f11179cfc..c7231bb249 100644 --- a/epan/dissectors/asn1/camel/packet-camel-template.c +++ b/epan/dissectors/asn1/camel/packet-camel-template.c @@ -1561,13 +1561,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)", proto_camel, - FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT32, BASE_HEX); camel_rose_ctx.res_local_dissector_table = register_dissector_table("camel.ros.local.res", "CAMEL Operation Result (local opcode)", proto_camel, - FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT32, BASE_HEX); camel_rose_ctx.err_local_dissector_table = register_dissector_table("camel.ros.local.err", "CAMEL Error (local opcode)", proto_camel, - FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT32, BASE_HEX); /* Register our configuration options, particularly our SSNs */ /* Set default SSNs */ diff --git a/epan/dissectors/asn1/cmip/packet-cmip-template.c b/epan/dissectors/asn1/cmip/packet-cmip-template.c index f93cc7ba34..2ccaa4b17b 100644 --- a/epan/dissectors/asn1/cmip/packet-cmip-template.c +++ b/epan/dissectors/asn1/cmip/packet-cmip-template.c @@ -200,7 +200,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", proto_cmip, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + attribute_id_dissector_table = register_dissector_table("cmip.attribute_id", "CMIP Attribute Id", proto_cmip, FT_UINT32, BASE_DEC); } diff --git a/epan/dissectors/asn1/dop/packet-dop-template.c b/epan/dissectors/asn1/dop/packet-dop-template.c index 2a94cdf4ca..505c93a0a5 100644 --- a/epan/dissectors/asn1/dop/packet-dop-template.c +++ b/epan/dissectors/asn1/dop/packet-dop-template.c @@ -263,7 +263,7 @@ void proto_register_dop(void) { register_dissector("dop", dissect_dop, proto_dop); - dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", proto_dop, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", proto_dop, FT_STRING, BASE_NONE); /* Register fields and subtrees */ proto_register_field_array(proto_dop, hf, array_length(hf)); diff --git a/epan/dissectors/asn1/gsm_map/packet-gsm_map-template.c b/epan/dissectors/asn1/gsm_map/packet-gsm_map-template.c index ff2a9a708e..7a39e69b94 100644 --- a/epan/dissectors/asn1/gsm_map/packet-gsm_map-template.c +++ b/epan/dissectors/asn1/gsm_map/packet-gsm_map-template.c @@ -3135,12 +3135,12 @@ 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)); - register_dissector_table("gsm_map.v3.arg.opcode", "GSM_MAP V3 Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - register_dissector_table("gsm_map.v3.res.opcode", "GSM_MAP V3 Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + register_dissector_table("gsm_map.v3.arg.opcode", "GSM_MAP V3 Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC); + register_dissector_table("gsm_map.v3.res.opcode", "GSM_MAP V3 Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC); - map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC); + map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC); + map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC); gsm_map_tap = register_tap("gsm_map"); diff --git a/epan/dissectors/asn1/h225/packet-h225-template.c b/epan/dissectors/asn1/h225/packet-h225-template.c index dd12c6f2b7..93a88a2d40 100644 --- a/epan/dissectors/asn1/h225/packet-h225-template.c +++ b/epan/dissectors/asn1/h225/packet-h225-template.c @@ -904,11 +904,11 @@ void proto_register_h225(void) { register_dissector("h323ui",dissect_h225_H323UserInformation, proto_h225); h225ras_handle = register_dissector("h225.ras", dissect_h225_h225_RasMessage, proto_h225); - nsp_object_dissector_table = register_dissector_table("h225.nsp.object", "H.225 NonStandardParameter (object)", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nsp_h221_dissector_table = register_dissector_table("h225.nsp.h221", "H.225 NonStandardParameter (h221)", proto_h225, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - tp_dissector_table = register_dissector_table("h225.tp", "H.225 TunnelledProtocol", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_name_dissector_table = register_dissector_table("h225.gef.name", "H.225 Generic Extensible Framework (names)", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_content_dissector_table = register_dissector_table("h225.gef.content", "H.225 Generic Extensible Framework", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_object_dissector_table = register_dissector_table("h225.nsp.object", "H.225 NonStandardParameter (object)", proto_h225, FT_STRING, BASE_NONE); + nsp_h221_dissector_table = register_dissector_table("h225.nsp.h221", "H.225 NonStandardParameter (h221)", proto_h225, FT_UINT32, BASE_HEX); + tp_dissector_table = register_dissector_table("h225.tp", "H.225 TunnelledProtocol", proto_h225, FT_STRING, BASE_NONE); + gef_name_dissector_table = register_dissector_table("h225.gef.name", "H.225 Generic Extensible Framework (names)", proto_h225, FT_STRING, BASE_NONE); + gef_content_dissector_table = register_dissector_table("h225.gef.content", "H.225 Generic Extensible Framework", proto_h225, FT_STRING, BASE_NONE); register_init_routine(&h225_init_routine); register_cleanup_routine(&h225_cleanup_routine); diff --git a/epan/dissectors/asn1/h245/packet-h245-template.c b/epan/dissectors/asn1/h245/packet-h245-template.c index ab42a0c988..d4da1cc117 100644 --- a/epan/dissectors/asn1/h245/packet-h245-template.c +++ b/epan/dissectors/asn1/h245/packet-h245-template.c @@ -542,10 +542,10 @@ void proto_register_h245(void) { MultimediaSystemControlMessage_handle = register_dissector("h245dg", dissect_h245_h245, proto_h245); h245_handle = register_dissector("h245", dissect_h245, proto_h245); - nsp_object_dissector_table = register_dissector_table("h245.nsp.object", "H.245 NonStandardParameter (object)", proto_h245, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nsp_h221_dissector_table = register_dissector_table("h245.nsp.h221", "H.245 NonStandardParameter (h221)", proto_h245, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_name_dissector_table = register_dissector_table("h245.gef.name", "H.245 Generic Extensible Framework (names)", proto_h245, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_content_dissector_table = register_dissector_table("h245.gef.content", "H.245 Generic Extensible Framework", proto_h245, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_object_dissector_table = register_dissector_table("h245.nsp.object", "H.245 NonStandardParameter (object)", proto_h245, FT_STRING, BASE_NONE); + nsp_h221_dissector_table = register_dissector_table("h245.nsp.h221", "H.245 NonStandardParameter (h221)", proto_h245, FT_UINT32, BASE_HEX); + gef_name_dissector_table = register_dissector_table("h245.gef.name", "H.245 Generic Extensible Framework (names)", proto_h245, FT_STRING, BASE_NONE); + gef_content_dissector_table = register_dissector_table("h245.gef.content", "H.245 Generic Extensible Framework", proto_h245, FT_STRING, BASE_NONE); h245_tap = register_tap("h245"); h245dg_tap = register_tap("h245dg"); diff --git a/epan/dissectors/asn1/h248/packet-h248-template.c b/epan/dissectors/asn1/h248/packet-h248-template.c index 7bae88586b..d4c18e4dcc 100644 --- a/epan/dissectors/asn1/h248/packet-h248-template.c +++ b/epan/dissectors/asn1/h248/packet-h248-template.c @@ -2371,7 +2371,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", proto_h248, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + subdissector_table = register_dissector_table("h248.magic_num", "H248 Magic Num", proto_h248, FT_UINT32, BASE_HEX); h248_module = prefs_register_protocol(proto_h248, proto_reg_handoff_h248); prefs_register_bool_preference(h248_module, "ctx_info", diff --git a/epan/dissectors/asn1/h450/packet-h450-template.c b/epan/dissectors/asn1/h450/packet-h450-template.c index 7c0ee14b74..23e4aa195a 100644 --- a/epan/dissectors/asn1/h450/packet-h450-template.c +++ b/epan/dissectors/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)", proto_h450, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.res_global_dissector_table = register_dissector_table("h450.ros.global.res", "H.450 Operation Result (global opcode)", proto_h450, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.arg_local_dissector_table = register_dissector_table("h450.ros.local.arg", "H.450 Operation Argument (local opcode)", proto_h450, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.res_local_dissector_table = register_dissector_table("h450.ros.local.res", "H.450 Operation Result (local opcode)", proto_h450, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.err_global_dissector_table = register_dissector_table("h450.ros.global.err", "H.450 Error (global opcode)", proto_h450, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.err_local_dissector_table = register_dissector_table("h450.ros.local.err", "H.450 Error (local opcode)", proto_h450, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.arg_global_dissector_table = register_dissector_table("h450.ros.global.arg", "H.450 Operation Argument (global opcode)", proto_h450, FT_STRING, BASE_NONE); + h450_rose_ctx.res_global_dissector_table = register_dissector_table("h450.ros.global.res", "H.450 Operation Result (global opcode)", proto_h450, FT_STRING, BASE_NONE); + h450_rose_ctx.arg_local_dissector_table = register_dissector_table("h450.ros.local.arg", "H.450 Operation Argument (local opcode)", proto_h450, FT_UINT32, BASE_HEX); + h450_rose_ctx.res_local_dissector_table = register_dissector_table("h450.ros.local.res", "H.450 Operation Result (local opcode)", proto_h450, FT_UINT32, BASE_HEX); + h450_rose_ctx.err_global_dissector_table = register_dissector_table("h450.ros.global.err", "H.450 Error (global opcode)", proto_h450, FT_STRING, BASE_NONE); + h450_rose_ctx.err_local_dissector_table = register_dissector_table("h450.ros.local.err", "H.450 Error (local opcode)", proto_h450, FT_UINT32, BASE_HEX); } diff --git a/epan/dissectors/asn1/hnbap/packet-hnbap-template.c b/epan/dissectors/asn1/hnbap/packet-hnbap-template.c index acac87f20a..c7e4523ad8 100644 --- a/epan/dissectors/asn1/hnbap/packet-hnbap-template.c +++ b/epan/dissectors/asn1/hnbap/packet-hnbap-template.c @@ -168,11 +168,11 @@ module_t *hnbap_module; hnbap_handle = register_dissector("hnbap", dissect_hnbap, proto_hnbap); /* Register dissector tables */ - hnbap_ies_dissector_table = register_dissector_table("hnbap.ies", "HNBAP-PROTOCOL-IES", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_extension_dissector_table = register_dissector_table("hnbap.extension", "HNBAP-PROTOCOL-EXTENSION", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_proc_imsg_dissector_table = register_dissector_table("hnbap.proc.imsg", "HNBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_proc_sout_dissector_table = register_dissector_table("hnbap.proc.sout", "HNBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_proc_uout_dissector_table = register_dissector_table("hnbap.proc.uout", "HNBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_ies_dissector_table = register_dissector_table("hnbap.ies", "HNBAP-PROTOCOL-IES", proto_hnbap, FT_UINT32, BASE_DEC); + hnbap_extension_dissector_table = register_dissector_table("hnbap.extension", "HNBAP-PROTOCOL-EXTENSION", proto_hnbap, FT_UINT32, BASE_DEC); + hnbap_proc_imsg_dissector_table = register_dissector_table("hnbap.proc.imsg", "HNBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_hnbap, FT_UINT32, BASE_DEC); + hnbap_proc_sout_dissector_table = register_dissector_table("hnbap.proc.sout", "HNBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC); + hnbap_proc_uout_dissector_table = register_dissector_table("hnbap.proc.uout", "HNBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC); hnbap_module = prefs_register_protocol(proto_hnbap, proto_reg_handoff_hnbap); 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/asn1/lcsap/packet-lcsap-template.c b/epan/dissectors/asn1/lcsap/packet-lcsap-template.c index 02ecf70ee5..0e165064c8 100644 --- a/epan/dissectors/asn1/lcsap/packet-lcsap-template.c +++ b/epan/dissectors/asn1/lcsap/packet-lcsap-template.c @@ -328,15 +328,15 @@ void proto_register_lcsap(void) { lcsap_handle = register_dissector("lcsap", dissect_lcsap, proto_lcsap); /* Register dissector tables */ - lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", proto_lcsap, FT_UINT32, BASE_DEC); expert_lcsap = expert_register_protocol(proto_lcsap); expert_register_field_array(expert_lcsap, ei, array_length(ei)); - lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", proto_lcsap, FT_UINT32, BASE_DEC); + lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lcsap, FT_UINT32, BASE_DEC); + lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC); + lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC); /* Register configuration options for ports */ lcsap_module = prefs_register_protocol(proto_lcsap, proto_reg_handoff_lcsap); diff --git a/epan/dissectors/asn1/ldap/packet-ldap-template.c b/epan/dissectors/asn1/ldap/packet-ldap-template.c index debb9a0441..785d2321a4 100644 --- a/epan/dissectors/asn1/ldap/packet-ldap-template.c +++ b/epan/dissectors/asn1/ldap/packet-ldap-template.c @@ -2240,7 +2240,7 @@ void proto_register_ldap(void) { ldap_tap=register_tap("ldap"); - ldap_name_dissector_table = register_dissector_table("ldap.name", "LDAP Attribute Type Dissectors", proto_cldap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ldap_name_dissector_table = register_dissector_table("ldap.name", "LDAP Attribute Type Dissectors", proto_cldap, FT_STRING, BASE_NONE); register_srt_table(proto_ldap, NULL, 1, ldapstat_packet, ldapstat_init, NULL); } diff --git a/epan/dissectors/asn1/lppa/packet-lppa-template.c b/epan/dissectors/asn1/lppa/packet-lppa-template.c index 479d0d8c21..55fb396e0b 100644 --- a/epan/dissectors/asn1/lppa/packet-lppa-template.c +++ b/epan/dissectors/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", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lppa_proc_imsg_dissector_table = register_dissector_table("lppa.proc.imsg", "LPPA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lppa_proc_sout_dissector_table = register_dissector_table("lppa.proc.sout", "LPPA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lppa_proc_uout_dissector_table = register_dissector_table("lppa.proc.uout", "LPPA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_ies_dissector_table = register_dissector_table("lppa.ies", "LPPA-PROTOCOL-IES", proto_lppa, FT_UINT32, BASE_DEC); + lppa_proc_imsg_dissector_table = register_dissector_table("lppa.proc.imsg", "LPPA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lppa, FT_UINT32, BASE_DEC); + lppa_proc_sout_dissector_table = register_dissector_table("lppa.proc.sout", "LPPA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC); + lppa_proc_uout_dissector_table = register_dissector_table("lppa.proc.uout", "LPPA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC); } /*--- proto_reg_handoff_lppa ---------------------------------------*/ diff --git a/epan/dissectors/asn1/m3ap/packet-m3ap-template.c b/epan/dissectors/asn1/m3ap/packet-m3ap-template.c index 91ad65c201..2d483587e6 100644 --- a/epan/dissectors/asn1/m3ap/packet-m3ap-template.c +++ b/epan/dissectors/asn1/m3ap/packet-m3ap-template.c @@ -183,11 +183,11 @@ void proto_register_m3ap(void) { expert_register_field_array(expert_m3ap, ei, array_length(ei)); /* Register dissector tables */ - m3ap_ies_dissector_table = register_dissector_table("m3ap.ies", "M3AP-PROTOCOL-IES", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_extension_dissector_table = register_dissector_table("m3ap.extension", "M3AP-PROTOCOL-EXTENSION", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_proc_imsg_dissector_table = register_dissector_table("m3ap.proc.imsg", "M3AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_proc_sout_dissector_table = register_dissector_table("m3ap.proc.sout", "M3AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_proc_uout_dissector_table = register_dissector_table("m3ap.proc.uout", "M3AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_ies_dissector_table = register_dissector_table("m3ap.ies", "M3AP-PROTOCOL-IES", proto_m3ap, FT_UINT32, BASE_DEC); + m3ap_extension_dissector_table = register_dissector_table("m3ap.extension", "M3AP-PROTOCOL-EXTENSION", proto_m3ap, FT_UINT32, BASE_DEC); + m3ap_proc_imsg_dissector_table = register_dissector_table("m3ap.proc.imsg", "M3AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_m3ap, FT_UINT32, BASE_DEC); + m3ap_proc_sout_dissector_table = register_dissector_table("m3ap.proc.sout", "M3AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC); + m3ap_proc_uout_dissector_table = register_dissector_table("m3ap.proc.uout", "M3AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC); } diff --git a/epan/dissectors/asn1/nbap/packet-nbap-template.c b/epan/dissectors/asn1/nbap/packet-nbap-template.c index acf2310209..5ba0528c34 100644 --- a/epan/dissectors/asn1/nbap/packet-nbap-template.c +++ b/epan/dissectors/asn1/nbap/packet-nbap-template.c @@ -516,11 +516,11 @@ void proto_register_nbap(void) } /* Register dissector tables */ - nbap_ies_dissector_table = register_dissector_table("nbap.ies", "NBAP-PROTOCOL-IES", proto_nbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_extension_dissector_table = register_dissector_table("nbap.extension", "NBAP-PROTOCOL-EXTENSION", proto_nbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_proc_imsg_dissector_table = register_dissector_table("nbap.proc.imsg", "NBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_nbap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_proc_sout_dissector_table = register_dissector_table("nbap.proc.sout", "NBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_proc_uout_dissector_table = register_dissector_table("nbap.proc.uout", "NBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_ies_dissector_table = register_dissector_table("nbap.ies", "NBAP-PROTOCOL-IES", proto_nbap, FT_UINT32, BASE_DEC); + nbap_extension_dissector_table = register_dissector_table("nbap.extension", "NBAP-PROTOCOL-EXTENSION", proto_nbap, FT_UINT32, BASE_DEC); + nbap_proc_imsg_dissector_table = register_dissector_table("nbap.proc.imsg", "NBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_nbap, FT_STRING, BASE_NONE); + nbap_proc_sout_dissector_table = register_dissector_table("nbap.proc.sout", "NBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE); + nbap_proc_uout_dissector_table = register_dissector_table("nbap.proc.uout", "NBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE); register_init_routine(nbap_init); } diff --git a/epan/dissectors/asn1/p1/packet-p1-template.c b/epan/dissectors/asn1/p1/packet-p1-template.c index f53b0d6024..0158854de2 100644 --- a/epan/dissectors/asn1/p1/packet-p1-template.c +++ b/epan/dissectors/asn1/p1/packet-p1-template.c @@ -375,9 +375,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", proto_p1, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", proto_p1, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", proto_p1, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + p1_extension_dissector_table = register_dissector_table("p1.extension", "P1-EXTENSION", proto_p1, FT_UINT32, BASE_DEC); + p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", proto_p1, FT_UINT32, BASE_DEC); + p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", proto_p1, FT_UINT32, BASE_DEC); /* Register our configuration options for P1, particularly our port */ diff --git a/epan/dissectors/asn1/pcap/packet-pcap-template.c b/epan/dissectors/asn1/pcap/packet-pcap-template.c index 68b7792402..7748a984dd 100644 --- a/epan/dissectors/asn1/pcap/packet-pcap-template.c +++ b/epan/dissectors/asn1/pcap/packet-pcap-template.c @@ -190,14 +190,14 @@ void proto_register_pcap(void) { pcap_handle = register_dissector("pcap", dissect_pcap, proto_pcap); /* Register dissector tables */ - pcap_ies_dissector_table = register_dissector_table("pcap.ies", "PCAP-PROTOCOL-IES", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_ies_p1_dissector_table = register_dissector_table("pcap.ies.pair.first", "PCAP-PROTOCOL-IES-PAIR FirstValue", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_ies_p2_dissector_table = register_dissector_table("pcap.ies.pair.second", "PCAP-PROTOCOL-IES-PAIR SecondValue", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_extension_dissector_table = register_dissector_table("pcap.extension", "PCAP-PROTOCOL-EXTENSION", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_imsg_dissector_table = register_dissector_table("pcap.proc.imsg", "PCAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_sout_dissector_table = register_dissector_table("pcap.proc.sout", "PCAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_uout_dissector_table = register_dissector_table("pcap.proc.uout", "PCAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_out_dissector_table = register_dissector_table("pcap.proc.out", "PCAP-ELEMENTARY-PROCEDURE Outcome", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_ies_dissector_table = register_dissector_table("pcap.ies", "PCAP-PROTOCOL-IES", proto_pcap, FT_UINT32, BASE_DEC); + pcap_ies_p1_dissector_table = register_dissector_table("pcap.ies.pair.first", "PCAP-PROTOCOL-IES-PAIR FirstValue", proto_pcap, FT_UINT32, BASE_DEC); + pcap_ies_p2_dissector_table = register_dissector_table("pcap.ies.pair.second", "PCAP-PROTOCOL-IES-PAIR SecondValue", proto_pcap, FT_UINT32, BASE_DEC); + pcap_extension_dissector_table = register_dissector_table("pcap.extension", "PCAP-PROTOCOL-EXTENSION", proto_pcap, FT_UINT32, BASE_DEC); + pcap_proc_imsg_dissector_table = register_dissector_table("pcap.proc.imsg", "PCAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_pcap, FT_UINT32, BASE_DEC); + pcap_proc_sout_dissector_table = register_dissector_table("pcap.proc.sout", "PCAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC); + pcap_proc_uout_dissector_table = register_dissector_table("pcap.proc.uout", "PCAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC); + pcap_proc_out_dissector_table = register_dissector_table("pcap.proc.out", "PCAP-ELEMENTARY-PROCEDURE Outcome", proto_pcap, FT_UINT32, BASE_DEC); /* Preferences */ diff --git a/epan/dissectors/asn1/q932/packet-q932-template.c b/epan/dissectors/asn1/q932/packet-q932-template.c index a5b517296f..ad62bb1c27 100644 --- a/epan/dissectors/asn1/q932/packet-q932-template.c +++ b/epan/dissectors/asn1/q932/packet-q932-template.c @@ -348,17 +348,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)", proto_q932, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - q932_rose_ctx.res_global_dissector_table = register_dissector_table("q932.ros.global.res", "Q.932 Operation Result (global opcode)", proto_q932, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - q932_rose_ctx.err_global_dissector_table = register_dissector_table("q932.ros.global.err", "Q.932 Error (global opcode)", proto_q932, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + q932_rose_ctx.arg_global_dissector_table = register_dissector_table("q932.ros.global.arg", "Q.932 Operation Argument (global opcode)", proto_q932, FT_STRING, BASE_NONE); + q932_rose_ctx.res_global_dissector_table = register_dissector_table("q932.ros.global.res", "Q.932 Operation Result (global opcode)", proto_q932, FT_STRING, BASE_NONE); + q932_rose_ctx.err_global_dissector_table = register_dissector_table("q932.ros.global.err", "Q.932 Error (global opcode)", proto_q932, FT_STRING, BASE_NONE); - qsig_arg_local_dissector_table = register_dissector_table("q932.ros.local.arg", "Q.932 Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - qsig_res_local_dissector_table = register_dissector_table("q932.ros.local.res", "Q.932 Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - qsig_err_local_dissector_table = register_dissector_table("q932.ros.local.err", "Q.932 Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + qsig_arg_local_dissector_table = register_dissector_table("q932.ros.local.arg", "Q.932 Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX); + qsig_res_local_dissector_table = register_dissector_table("q932.ros.local.res", "Q.932 Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX); + qsig_err_local_dissector_table = register_dissector_table("q932.ros.local.err", "Q.932 Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX); - etsi_arg_local_dissector_table = register_dissector_table("q932.ros.etsi.local.arg", "Q.932 ETSI Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - etsi_res_local_dissector_table = register_dissector_table("q932.ros.etsi.local.res", "Q.932 ETSI Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - etsi_err_local_dissector_table = register_dissector_table("q932.ros.etsi.local.err", "Q.932 ETSI Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + etsi_arg_local_dissector_table = register_dissector_table("q932.ros.etsi.local.arg", "Q.932 ETSI Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX); + etsi_res_local_dissector_table = register_dissector_table("q932.ros.etsi.local.res", "Q.932 ETSI Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX); + etsi_err_local_dissector_table = register_dissector_table("q932.ros.etsi.local.err", "Q.932 ETSI Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX); q932_module = prefs_register_protocol(proto_q932, proto_reg_handoff_q932); diff --git a/epan/dissectors/asn1/qsig/packet-qsig-template.c b/epan/dissectors/asn1/qsig/packet-qsig-template.c index 3fb961c6d6..3065ab144f 100644 --- a/epan/dissectors/asn1/qsig/packet-qsig-template.c +++ b/epan/dissectors/asn1/qsig/packet-qsig-template.c @@ -695,7 +695,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", proto_qsig, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + extension_dissector_table = register_dissector_table("qsig.ext", "QSIG Extension", proto_qsig, FT_STRING, BASE_NONE); qsig_init_tables(); } diff --git a/epan/dissectors/asn1/ranap/packet-ranap-template.c b/epan/dissectors/asn1/ranap/packet-ranap-template.c index 4db5c14bd6..df987a9e82 100644 --- a/epan/dissectors/asn1/ranap/packet-ranap-template.c +++ b/epan/dissectors/asn1/ranap/packet-ranap-template.c @@ -349,16 +349,16 @@ void proto_register_ranap(void) { ranap_handle = register_dissector("ranap", dissect_ranap, proto_ranap); /* Register dissector tables */ - ranap_ies_dissector_table = register_dissector_table("ranap.ies", "RANAP-PROTOCOL-IES", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_ies_p1_dissector_table = register_dissector_table("ranap.ies.pair.first", "RANAP-PROTOCOL-IES-PAIR FirstValue", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_ies_p2_dissector_table = register_dissector_table("ranap.ies.pair.second", "RANAP-PROTOCOL-IES-PAIR SecondValue", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_extension_dissector_table = register_dissector_table("ranap.extension", "RANAP-PROTOCOL-EXTENSION", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_imsg_dissector_table = register_dissector_table("ranap.proc.imsg", "RANAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_sout_dissector_table = register_dissector_table("ranap.proc.sout", "RANAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_uout_dissector_table = register_dissector_table("ranap.proc.uout", "RANAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_out_dissector_table = register_dissector_table("ranap.proc.out", "RANAP-ELEMENTARY-PROCEDURE Outcome", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - - nas_pdu_dissector_table = register_dissector_table("ranap.nas_pdu", "RANAP NAS PDU", proto_ranap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_ies_dissector_table = register_dissector_table("ranap.ies", "RANAP-PROTOCOL-IES", proto_ranap, FT_UINT32, BASE_DEC); + ranap_ies_p1_dissector_table = register_dissector_table("ranap.ies.pair.first", "RANAP-PROTOCOL-IES-PAIR FirstValue", proto_ranap, FT_UINT32, BASE_DEC); + ranap_ies_p2_dissector_table = register_dissector_table("ranap.ies.pair.second", "RANAP-PROTOCOL-IES-PAIR SecondValue", proto_ranap, FT_UINT32, BASE_DEC); + ranap_extension_dissector_table = register_dissector_table("ranap.extension", "RANAP-PROTOCOL-EXTENSION", proto_ranap, FT_UINT32, BASE_DEC); + ranap_proc_imsg_dissector_table = register_dissector_table("ranap.proc.imsg", "RANAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_ranap, FT_UINT32, BASE_DEC); + ranap_proc_sout_dissector_table = register_dissector_table("ranap.proc.sout", "RANAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC); + ranap_proc_uout_dissector_table = register_dissector_table("ranap.proc.uout", "RANAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC); + ranap_proc_out_dissector_table = register_dissector_table("ranap.proc.out", "RANAP-ELEMENTARY-PROCEDURE Outcome", proto_ranap, FT_UINT32, BASE_DEC); + + nas_pdu_dissector_table = register_dissector_table("ranap.nas_pdu", "RANAP NAS PDU", proto_ranap, FT_UINT8, BASE_DEC); ranap_module = prefs_register_protocol(proto_ranap, proto_reg_handoff_ranap); prefs_register_uint_preference(ranap_module, "sccp_ssn", "SCCP SSN for RANAP", diff --git a/epan/dissectors/asn1/rnsap/packet-rnsap-template.c b/epan/dissectors/asn1/rnsap/packet-rnsap-template.c index be451530a5..a337a26086 100644 --- a/epan/dissectors/asn1/rnsap/packet-rnsap-template.c +++ b/epan/dissectors/asn1/rnsap/packet-rnsap-template.c @@ -163,11 +163,11 @@ void proto_register_rnsap(void) { rnsap_handle = register_dissector("rnsap", dissect_rnsap, proto_rnsap); /* Register dissector tables */ - rnsap_ies_dissector_table = register_dissector_table("rnsap.ies", "RNSAP-PROTOCOL-IES", proto_rnsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_extension_dissector_table = register_dissector_table("rnsap.extension", "RNSAP-PROTOCOL-EXTENSION", proto_rnsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_proc_imsg_dissector_table = register_dissector_table("rnsap.proc.imsg", "RNSAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rnsap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_proc_sout_dissector_table = register_dissector_table("rnsap.proc.sout", "RNSAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_proc_uout_dissector_table = register_dissector_table("rnsap.proc.uout", "RNSAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_ies_dissector_table = register_dissector_table("rnsap.ies", "RNSAP-PROTOCOL-IES", proto_rnsap, FT_UINT32, BASE_DEC); + rnsap_extension_dissector_table = register_dissector_table("rnsap.extension", "RNSAP-PROTOCOL-EXTENSION", proto_rnsap, FT_UINT32, BASE_DEC); + rnsap_proc_imsg_dissector_table = register_dissector_table("rnsap.proc.imsg", "RNSAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rnsap, FT_STRING, BASE_NONE); + rnsap_proc_sout_dissector_table = register_dissector_table("rnsap.proc.sout", "RNSAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE); + rnsap_proc_uout_dissector_table = register_dissector_table("rnsap.proc.uout", "RNSAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE); } diff --git a/epan/dissectors/asn1/ros/packet-ros-template.c b/epan/dissectors/asn1/ros/packet-ros-template.c index 3051a0f7c5..4364de44af 100644 --- a/epan/dissectors/asn1/ros/packet-ros-template.c +++ b/epan/dissectors/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", proto_ros, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + ros_oid_dissector_table = register_dissector_table("ros.oid", "ROS OID Dissectors", proto_ros, FT_STRING, BASE_NONE); oid_table=g_hash_table_new(g_str_hash, g_str_equal); protocol_table=g_hash_table_new(g_str_hash, g_str_equal); diff --git a/epan/dissectors/asn1/rtse/packet-rtse-template.c b/epan/dissectors/asn1/rtse/packet-rtse-template.c index 4e4dfc6548..b929c9b5fa 100644 --- a/epan/dissectors/asn1/rtse/packet-rtse-template.c +++ b/epan/dissectors/asn1/rtse/packet-rtse-template.c @@ -402,7 +402,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", proto_rtse, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + rtse_oid_dissector_table = register_dissector_table("rtse.oid", "RTSE OID Dissectors", proto_rtse, FT_STRING, BASE_NONE); oid_table=g_hash_table_new(g_str_hash, g_str_equal); diff --git a/epan/dissectors/asn1/rua/packet-rua-template.c b/epan/dissectors/asn1/rua/packet-rua-template.c index a5a6c16f1b..a5445a25bb 100644 --- a/epan/dissectors/asn1/rua/packet-rua-template.c +++ b/epan/dissectors/asn1/rua/packet-rua-template.c @@ -153,11 +153,11 @@ module_t *rua_module; rua_handle = register_dissector("rua", dissect_rua, proto_rua); /* Register dissector tables */ - rua_ies_dissector_table = register_dissector_table("rua.ies", "RUA-PROTOCOL-IES", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_ies_dissector_table = register_dissector_table("rua.ies", "RUA-PROTOCOL-IES", proto_rua, FT_UINT32, BASE_DEC); + rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", proto_rua, FT_UINT32, BASE_DEC); + rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rua, FT_UINT32, BASE_DEC); + rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC); + rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC); rua_module = prefs_register_protocol(proto_rua, proto_reg_handoff_rua); 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/asn1/s1ap/packet-s1ap-template.c b/epan/dissectors/asn1/s1ap/packet-s1ap-template.c index 11ef67afbe..0cbb471863 100644 --- a/epan/dissectors/asn1/s1ap/packet-s1ap-template.c +++ b/epan/dissectors/asn1/s1ap/packet-s1ap-template.c @@ -279,13 +279,13 @@ void proto_register_s1ap(void) { s1ap_handle = register_dissector("s1ap", dissect_s1ap, proto_s1ap); /* Register dissector tables */ - s1ap_ies_dissector_table = register_dissector_table("s1ap.ies", "S1AP-PROTOCOL-IES", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_ies_p1_dissector_table = register_dissector_table("s1ap.ies.pair.first", "S1AP-PROTOCOL-IES-PAIR FirstValue", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_ies_p2_dissector_table = register_dissector_table("s1ap.ies.pair.second", "S1AP-PROTOCOL-IES-PAIR SecondValue", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_ies_dissector_table = register_dissector_table("s1ap.ies", "S1AP-PROTOCOL-IES", proto_s1ap, FT_UINT32, BASE_DEC); + s1ap_ies_p1_dissector_table = register_dissector_table("s1ap.ies.pair.first", "S1AP-PROTOCOL-IES-PAIR FirstValue", proto_s1ap, FT_UINT32, BASE_DEC); + s1ap_ies_p2_dissector_table = register_dissector_table("s1ap.ies.pair.second", "S1AP-PROTOCOL-IES-PAIR SecondValue", proto_s1ap, FT_UINT32, BASE_DEC); + s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", proto_s1ap, FT_UINT32, BASE_DEC); + s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_s1ap, FT_UINT32, BASE_DEC); + s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC); + s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC); /* Register configuration options for ports */ s1ap_module = prefs_register_protocol(proto_s1ap, proto_reg_handoff_s1ap); diff --git a/epan/dissectors/asn1/sabp/packet-sabp-template.c b/epan/dissectors/asn1/sabp/packet-sabp-template.c index 1c0e759cd8..a05cc45865 100644 --- a/epan/dissectors/asn1/sabp/packet-sabp-template.c +++ b/epan/dissectors/asn1/sabp/packet-sabp-template.c @@ -274,11 +274,11 @@ void proto_register_sabp(void) { sabp_tcp_handle = register_dissector("sabp.tcp", dissect_sabp_tcp, proto_sabp); /* Register dissector tables */ - sabp_ies_dissector_table = register_dissector_table("sabp.ies", "SABP-PROTOCOL-IES", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_extension_dissector_table = register_dissector_table("sabp.extension", "SABP-PROTOCOL-EXTENSION", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_proc_imsg_dissector_table = register_dissector_table("sabp.proc.imsg", "SABP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_proc_sout_dissector_table = register_dissector_table("sabp.proc.sout", "SABP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_proc_uout_dissector_table = register_dissector_table("sabp.proc.uout", "SABP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_ies_dissector_table = register_dissector_table("sabp.ies", "SABP-PROTOCOL-IES", proto_sabp, FT_UINT32, BASE_DEC); + sabp_extension_dissector_table = register_dissector_table("sabp.extension", "SABP-PROTOCOL-EXTENSION", proto_sabp, FT_UINT32, BASE_DEC); + sabp_proc_imsg_dissector_table = register_dissector_table("sabp.proc.imsg", "SABP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sabp, FT_UINT32, BASE_DEC); + sabp_proc_sout_dissector_table = register_dissector_table("sabp.proc.sout", "SABP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC); + sabp_proc_uout_dissector_table = register_dissector_table("sabp.proc.uout", "SABP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC); } diff --git a/epan/dissectors/asn1/sbc-ap/packet-sbc-ap-template.c b/epan/dissectors/asn1/sbc-ap/packet-sbc-ap-template.c index 31f7a515ec..3a012d404b 100644 --- a/epan/dissectors/asn1/sbc-ap/packet-sbc-ap-template.c +++ b/epan/dissectors/asn1/sbc-ap/packet-sbc-ap-template.c @@ -165,11 +165,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", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_extension_dissector_table = register_dissector_table("sbc_ap.extension", "SBC-AP-PROTOCOL-EXTENSION", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_proc_imsg_dissector_table = register_dissector_table("sbc_ap.proc.imsg", "SBC-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_proc_sout_dissector_table = register_dissector_table("sbc_ap.proc.sout", "SBC-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_proc_uout_dissector_table = register_dissector_table("sbc_ap.proc.uout", "SBC-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sbc_ap_ies_dissector_table = register_dissector_table("sbc_ap.ies", "SBC-AP-PROTOCOL-IES", proto_sbc_ap, FT_UINT32, BASE_DEC); + sbc_ap_extension_dissector_table = register_dissector_table("sbc_ap.extension", "SBC-AP-PROTOCOL-EXTENSION", proto_sbc_ap, FT_UINT32, BASE_DEC); + sbc_ap_proc_imsg_dissector_table = register_dissector_table("sbc_ap.proc.imsg", "SBC-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sbc_ap, FT_UINT32, BASE_DEC); + sbc_ap_proc_sout_dissector_table = register_dissector_table("sbc_ap.proc.sout", "SBC-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC); + sbc_ap_proc_uout_dissector_table = register_dissector_table("sbc_ap.proc.uout", "SBC-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC); } diff --git a/epan/dissectors/asn1/snmp/packet-snmp-template.c b/epan/dissectors/asn1/snmp/packet-snmp-template.c index 5262f8bd13..44cc3819c0 100644 --- a/epan/dissectors/asn1/snmp/packet-snmp-template.c +++ b/epan/dissectors/asn1/snmp/packet-snmp-template.c @@ -2566,7 +2566,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", proto_snmp, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + value_sub_dissectors_table = register_dissector_table("snmp.variable_oid","SNMP Variable OID", proto_snmp, FT_STRING, BASE_NONE); register_init_routine(init_ue_cache); register_cleanup_routine(cleanup_ue_cache); diff --git a/epan/dissectors/asn1/t124/packet-t124-template.c b/epan/dissectors/asn1/t124/packet-t124-template.c index 79c449a5c3..d0fa79b394 100644 --- a/epan/dissectors/asn1/t124/packet-t124-template.c +++ b/epan/dissectors/asn1/t124/packet-t124-template.c @@ -203,8 +203,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", proto_t124, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - t124_sd_dissector_table = register_dissector_table("t124.sd", "T.124 H.221 Send Data Dissectors", proto_t124, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + t124_ns_dissector_table = register_dissector_table("t124.ns", "T.124 H.221 Non Standard Dissectors", proto_t124, FT_STRING, BASE_NONE); + t124_sd_dissector_table = register_dissector_table("t124.sd", "T.124 H.221 Send Data Dissectors", proto_t124, FT_UINT32, BASE_HEX); register_dissector("t124", dissect_t124, proto_t124); diff --git a/epan/dissectors/asn1/x2ap/packet-x2ap-template.c b/epan/dissectors/asn1/x2ap/packet-x2ap-template.c index 8748863c64..d49367dff2 100644 --- a/epan/dissectors/asn1/x2ap/packet-x2ap-template.c +++ b/epan/dissectors/asn1/x2ap/packet-x2ap-template.c @@ -166,11 +166,11 @@ void proto_register_x2ap(void) { x2ap_handle = register_dissector("x2ap", dissect_x2ap, proto_x2ap); /* Register dissector tables */ - x2ap_ies_dissector_table = register_dissector_table("x2ap.ies", "X2AP-PROTOCOL-IES", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_ies_dissector_table = register_dissector_table("x2ap.ies", "X2AP-PROTOCOL-IES", proto_x2ap, FT_UINT32, BASE_DEC); + x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", proto_x2ap, FT_UINT32, BASE_DEC); + x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_x2ap, FT_UINT32, BASE_DEC); + x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC); + x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC); /* Register configuration options for ports */ x2ap_module = prefs_register_protocol(proto_x2ap, proto_reg_handoff_x2ap); diff --git a/epan/dissectors/file-file.c b/epan/dissectors/file-file.c index b75ffc31ae..b633fc2275 100644 --- a/epan/dissectors/file-file.c +++ b/epan/dissectors/file-file.c @@ -386,7 +386,7 @@ proto_register_file(void) register_dissector("file",dissect_file_record,proto_file); file_encap_dissector_table = register_dissector_table("ftap_encap", - "Filetap encapsulation type", proto_file, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Filetap encapsulation type", proto_file, FT_UINT32, BASE_DEC); /* You can't disable dissection of "Frame", as that would be tantamount to not doing any dissection whatsoever. */ diff --git a/epan/dissectors/packet-ansi_637.c b/epan/dissectors/packet-ansi_637.c index 7cc23be74d..d237e03f67 100644 --- a/epan/dissectors/packet-ansi_637.c +++ b/epan/dissectors/packet-ansi_637.c @@ -3406,7 +3406,7 @@ proto_register_ansi_637(void) tele_dissector_table = register_dissector_table("ansi_637.tele_id", - "ANSI IS-637-A Teleservice ID", proto_ansi_637_tele, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "ANSI IS-637-A Teleservice ID", proto_ansi_637_tele, FT_UINT8, BASE_DEC); } diff --git a/epan/dissectors/packet-ansi_a.c b/epan/dissectors/packet-ansi_a.c index 403aa8e636..f46cbb0e5f 100644 --- a/epan/dissectors/packet-ansi_a.c +++ b/epan/dissectors/packet-ansi_a.c @@ -12855,15 +12855,15 @@ proto_register_ansi_a(void) is637_dissector_table = register_dissector_table("ansi_a.sms", "IS-637-A (SMS)", - proto_a_bsmap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_a_bsmap, FT_UINT8, BASE_DEC); is683_dissector_table = register_dissector_table("ansi_a.ota", "IS-683-A (OTA)", - proto_a_bsmap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_a_bsmap, FT_UINT8, BASE_DEC); is801_dissector_table = register_dissector_table("ansi_a.pld", "IS-801 (PLD)", - proto_a_bsmap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_a_bsmap, FT_UINT8, BASE_DEC); proto_register_subtree_array(ett, array_length(ett)); diff --git a/epan/dissectors/packet-ansi_map.c b/epan/dissectors/packet-ansi_map.c index 65d62edcb7..78002f3501 100644 --- a/epan/dissectors/packet-ansi_map.c +++ b/epan/dissectors/packet-ansi_map.c @@ -19542,15 +19542,15 @@ void proto_register_ansi_map(void) { is637_tele_id_dissector_table = register_dissector_table("ansi_map.tele_id", "IS-637 Teleservice ID", proto_ansi_map, - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT8, BASE_DEC); is683_dissector_table = register_dissector_table("ansi_map.ota", "IS-683-A (OTA)", proto_ansi_map, - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT8, BASE_DEC); is801_dissector_table = register_dissector_table("ansi_map.pld", "IS-801 (PLD)", proto_ansi_map, - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT8, BASE_DEC); ansi_map_tap = register_tap("ansi_map"); diff --git a/epan/dissectors/packet-ansi_tcap.c b/epan/dissectors/packet-ansi_tcap.c index f702ba8d5e..54f04fcaad 100644 --- a/epan/dissectors/packet-ansi_tcap.c +++ b/epan/dissectors/packet-ansi_tcap.c @@ -1813,7 +1813,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", proto_ansi_tcap, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ansi_tcap_national_opcode_table = register_dissector_table("ansi_tcap.nat.opcode", "ANSI TCAP National Opcodes", proto_ansi_tcap, FT_UINT16, BASE_DEC); /* Required function calls to register the header fields and subtrees used */ 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 3ade0285f0..eaf7d43077 100644 --- a/epan/dissectors/packet-arcnet.c +++ b/epan/dissectors/packet-arcnet.c @@ -392,7 +392,7 @@ proto_register_arcnet (void) proto_register_subtree_array (ett, array_length (ett)); arcnet_dissector_table = register_dissector_table ("arcnet.protocol_id", "ARCNET Protocol ID", - proto_arcnet, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_arcnet, FT_UINT8, BASE_HEX); arcnet_address_type = address_type_dissector_register("AT_ARCNET", "ARCNET Address", arcnet_to_str, arcnet_str_len, NULL, arcnet_col_filter_str, arcnet_len, NULL, NULL); } diff --git a/epan/dissectors/packet-aruba-erm.c b/epan/dissectors/packet-aruba-erm.c index 2a6c1f02b1..6c65b14cfd 100644 --- a/epan/dissectors/packet-aruba-erm.c +++ b/epan/dissectors/packet-aruba-erm.c @@ -460,7 +460,7 @@ proto_register_aruba_erm(void) aruba_erm_subdissector_table = register_dissector_table( "aruba_erm.type", "Aruba ERM Type", proto_aruba_erm, - FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT32, BASE_DEC); register_decode_as(&aruba_erm_payload_da); diff --git a/epan/dissectors/packet-atalk.c b/epan/dissectors/packet-atalk.c index 4b0d8e616d..5d4d64e133 100644 --- a/epan/dissectors/packet-atalk.c +++ b/epan/dissectors/packet-atalk.c @@ -2035,7 +2035,7 @@ proto_register_atalk(void) /* subdissector code */ ddp_dissector_table = register_dissector_table("ddp.type", "DDP packet type", proto_ddp, - FT_UINT8, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + FT_UINT8, BASE_HEX); atalk_address_type = address_type_dissector_register("AT_ATALK", "Appletalk DDP", atalk_to_str, atalk_str_len, NULL, atalk_col_filter_str, atalk_len, NULL, NULL); } diff --git a/epan/dissectors/packet-atm.c b/epan/dissectors/packet-atm.c index 01700bc429..ff4bc60f32 100644 --- a/epan/dissectors/packet-atm.c +++ b/epan/dissectors/packet-atm.c @@ -1979,8 +1979,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", proto_atm, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - atm_type_aal5_table = register_dissector_table("atm.aal5.type", "ATM AAL_5 type subdissector", proto_atm, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + atm_type_aal2_table = register_dissector_table("atm.aal2.type", "ATM AAL_2 type subdissector", proto_atm, FT_UINT32, BASE_DEC); + atm_type_aal5_table = register_dissector_table("atm.aal5.type", "ATM AAL_5 type subdissector", proto_atm, FT_UINT32, BASE_DEC); register_capture_dissector_table("atm.aal5.type", "ATM AAL_5"); register_capture_dissector_table("atm_lane", "ATM LAN Emulation"); diff --git a/epan/dissectors/packet-ax25.c b/epan/dissectors/packet-ax25.c index fceb928dad..c9535bbe65 100644 --- a/epan/dissectors/packet-ax25.c +++ b/epan/dissectors/packet-ax25.c @@ -409,7 +409,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", proto_ax25, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + ax25_dissector_table = register_dissector_table("ax25.pid", "AX.25 protocol ID", proto_ax25, FT_UINT8, BASE_HEX); register_capture_dissector_table("ax25.pid", "AX.25"); } diff --git a/epan/dissectors/packet-bacapp.c b/epan/dissectors/packet-bacapp.c index e483496dd9..99ee969bae 100644 --- a/epan/dissectors/packet-bacapp.c +++ b/epan/dissectors/packet-bacapp.c @@ -11353,7 +11353,7 @@ proto_register_bacapp(void) bacapp_dissector_table = register_dissector_table("bacapp.vendor_identifier", "BACapp Vendor Identifier", proto_bacapp, - FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT8, BASE_HEX); /* Register BACnet Statistic trees */ register_bacapp_stat_trees(); diff --git a/epan/dissectors/packet-bacnet.c b/epan/dissectors/packet-bacnet.c index 372f80383b..d496d15bb7 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", proto_bacnet, - FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT8, BASE_HEX); } void diff --git a/epan/dissectors/packet-bctp.c b/epan/dissectors/packet-bctp.c index fbaad00954..6709feb545 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", proto_bctp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + bctp_dissector_table = register_dissector_table("bctp.tpi", "BCTP Tunneled Protocol Indicator", proto_bctp, FT_UINT32, BASE_DEC); } void diff --git a/epan/dissectors/packet-ber.c b/epan/dissectors/packet-ber.c index dd1300e575..10f39b7b04 100644 --- a/epan/dissectors/packet-ber.c +++ b/epan/dissectors/packet-ber.c @@ -4576,8 +4576,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", proto_ber, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ber_syntax_dissector_table = register_dissector_table("ber.syntax", "BER syntax", proto_ber, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ber_oid_dissector_table = register_dissector_table("ber.oid", "BER OID Dissectors", proto_ber, FT_STRING, BASE_NONE); + ber_syntax_dissector_table = register_dissector_table("ber.syntax", "BER syntax", proto_ber, FT_STRING, BASE_NONE); 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 cc3cbbd02c..a7a779e5f8 100644 --- a/epan/dissectors/packet-bitcoin.c +++ b/epan/dissectors/packet-bitcoin.c @@ -1860,7 +1860,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", proto_bitcoin, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + bitcoin_command_table = register_dissector_table("bitcoin.command", "Bitcoin Command", proto_bitcoin, FT_STRING, BASE_NONE); bitcoin_handle = register_dissector("bitcoin", dissect_bitcoin, proto_bitcoin); diff --git a/epan/dissectors/packet-bluecom.c b/epan/dissectors/packet-bluecom.c index 8207e27087..518c9405a5 100644 --- a/epan/dissectors/packet-bluecom.c +++ b/epan/dissectors/packet-bluecom.c @@ -871,7 +871,7 @@ proto_register_bluecom(void) /* add dissector table */ bcp_subdissector_table = register_dissector_table("bluecomseg", "bluecom SegCode", proto_bcp, - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT8, BASE_DEC); } /* diff --git a/epan/dissectors/packet-bluetooth.c b/epan/dissectors/packet-bluetooth.c index ccc6e50514..23e1514180 100644 --- a/epan/dissectors/packet-bluetooth.c +++ b/epan/dissectors/packet-bluetooth.c @@ -2226,7 +2226,7 @@ proto_register_bluetooth(void) proto_register_subtree_array(ett, array_length(ett)); bluetooth_table = register_dissector_table("bluetooth.encap", - "Bluetooth Encapsulation", proto_bluetooth, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Bluetooth Encapsulation", proto_bluetooth, FT_UINT32, BASE_HEX); chandle_sessions = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); chandle_to_bdaddr = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); @@ -2237,14 +2237,14 @@ proto_register_bluetooth(void) localhost_name = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); hci_vendors = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); - hci_vendor_table = register_dissector_table("bluetooth.vendor", "HCI Vendor", proto_bluetooth, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + hci_vendor_table = register_dissector_table("bluetooth.vendor", "HCI Vendor", proto_bluetooth, FT_UINT16, BASE_HEX); bluetooth_uuids = wmem_tree_new(wmem_epan_scope()); bluetooth_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", proto_bluetooth, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + bluetooth_uuid_table = register_dissector_table("bluetooth.uuid", "BT Service UUID", proto_bluetooth, FT_STRING, BASE_NONE); llc_add_oui(OUI_BLUETOOTH, "llc.bluetooth_pid", "LLC Bluetooth OUI PID", oui_hf, proto_bluetooth); 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 2f8b640858..6780eb39f2 100644 --- a/epan/dissectors/packet-bssap.c +++ b/epan/dissectors/packet-bssap.c @@ -2545,8 +2545,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", proto_bssap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - bsap_dissector_table = register_dissector_table("bsap.pdu_type", "BSAP Message Type", proto_bssap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + bssap_dissector_table = register_dissector_table("bssap.pdu_type", "BSSAP Message Type", proto_bssap, FT_UINT8, BASE_DEC); + bsap_dissector_table = register_dissector_table("bsap.pdu_type", "BSAP Message Type", proto_bssap, FT_UINT8, BASE_DEC); } void diff --git a/epan/dissectors/packet-btatt.c b/epan/dissectors/packet-btatt.c index 643dc6e237..d3873b5cc2 100644 --- a/epan/dissectors/packet-btatt.c +++ b/epan/dissectors/packet-btatt.c @@ -15109,7 +15109,7 @@ proto_register_btatt(void) btatt_handle = register_dissector("btatt", dissect_btatt, proto_btatt); - att_handle_dissector_table = register_dissector_table("btatt.handle", "BT ATT Handle", proto_btatt, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + att_handle_dissector_table = register_dissector_table("btatt.handle", "BT ATT Handle", proto_btatt, FT_UINT16, BASE_HEX); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_btatt, hf, array_length(hf)); diff --git a/epan/dissectors/packet-btbredr_rf.c b/epan/dissectors/packet-btbredr_rf.c index 4609baf220..48ed39dc6c 100644 --- a/epan/dissectors/packet-btbredr_rf.c +++ b/epan/dissectors/packet-btbredr_rf.c @@ -897,13 +897,13 @@ proto_register_btbredr_rf(void) proto_register_subtree_array(ett, array_length(ett)); btbredr_rf_handle = register_dissector("btbredr_rf", dissect_btbredr_rf, proto_btbredr_rf); - packet_type_sco_br_table = register_dissector_table("btbredr_rf.packet_type.sco.br", "BT Packet Type for SCO BR", proto_btbredr_rf, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - packet_type_esco_br_table = register_dissector_table("btbredr_rf.packet_type.esco.br", "BT Packet Type for eSCO BR", proto_btbredr_rf, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - packet_type_esco_edr_table = register_dissector_table("btbredr_rf.packet_type.esco.edr", "BT Packet Type for eSCO EDR", proto_btbredr_rf, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - packet_type_acl_br_table = register_dissector_table("btbredr_rf.packet_type.acl.br", "BT Packet Type for ACL BR", proto_btbredr_rf, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - packet_type_acl_edr_table = register_dissector_table("btbredr_rf.packet_type.acl.edr", "BT Packet Type for ACL EDR", proto_btbredr_rf, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - packet_type_csb_br_table = register_dissector_table("btbredr_rf.packet_type.csb.br", "BT Packet Type for CSB BR", proto_btbredr_rf, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - packet_type_csb_edr_table = register_dissector_table("btbredr_rf.packet_type.csb.edr", "BT Packet Type for CSB EDR", proto_btbredr_rf, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + packet_type_sco_br_table = register_dissector_table("btbredr_rf.packet_type.sco.br", "BT Packet Type for SCO BR", proto_btbredr_rf, FT_UINT8, BASE_HEX); + packet_type_esco_br_table = register_dissector_table("btbredr_rf.packet_type.esco.br", "BT Packet Type for eSCO BR", proto_btbredr_rf, FT_UINT8, BASE_HEX); + packet_type_esco_edr_table = register_dissector_table("btbredr_rf.packet_type.esco.edr", "BT Packet Type for eSCO EDR", proto_btbredr_rf, FT_UINT8, BASE_HEX); + packet_type_acl_br_table = register_dissector_table("btbredr_rf.packet_type.acl.br", "BT Packet Type for ACL BR", proto_btbredr_rf, FT_UINT8, BASE_HEX); + packet_type_acl_edr_table = register_dissector_table("btbredr_rf.packet_type.acl.edr", "BT Packet Type for ACL EDR", proto_btbredr_rf, FT_UINT8, BASE_HEX); + packet_type_csb_br_table = register_dissector_table("btbredr_rf.packet_type.csb.br", "BT Packet Type for CSB BR", proto_btbredr_rf, FT_UINT8, BASE_HEX); + packet_type_csb_edr_table = register_dissector_table("btbredr_rf.packet_type.csb.edr", "BT Packet Type for CSB EDR", proto_btbredr_rf, FT_UINT8, BASE_HEX); expert_module = expert_register_protocol(proto_btbredr_rf); expert_register_field_array(expert_module, ei, array_length(ei)); diff --git a/epan/dissectors/packet-bthci_cmd.c b/epan/dissectors/packet-bthci_cmd.c index 9f6765af6b..d6d8448543 100644 --- a/epan/dissectors/packet-bthci_cmd.c +++ b/epan/dissectors/packet-bthci_cmd.c @@ -5177,7 +5177,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", proto_bthci_cmd, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + vendor_dissector_table = register_dissector_table("bthci_cmd.vendor", "BT HCI Vendor", proto_bthci_cmd, FT_UINT16, BASE_HEX); module = prefs_register_protocol(proto_bthci_cmd, NULL); prefs_register_static_text_preference(module, "hci_cmd.version", @@ -6770,8 +6770,8 @@ proto_register_btcommon(void) btcommon_cod_handle = register_dissector("btcommon.cod", dissect_btcommon_cod, proto_btcommon); btcommon_le_channel_map_handle = register_dissector("btcommon.le_channel_map", dissect_btcommon_le_channel_map, proto_btcommon); - bluetooth_eir_ad_manufacturer_company_id = register_dissector_table("btcommon.eir_ad.manufacturer_company_id", "BT EIR/AD Manufacturer Company ID", proto_btcommon, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - bluetooth_eir_ad_tds_organization_id = register_dissector_table("btcommon.eir_ad.tds_organization_id", "BT EIR/AD TDS Organization ID", proto_btcommon, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + bluetooth_eir_ad_manufacturer_company_id = register_dissector_table("btcommon.eir_ad.manufacturer_company_id", "BT EIR/AD Manufacturer Company ID", proto_btcommon, FT_UINT16, BASE_HEX); + bluetooth_eir_ad_tds_organization_id = register_dissector_table("btcommon.eir_ad.tds_organization_id", "BT EIR/AD TDS Organization ID", proto_btcommon, FT_UINT8, BASE_HEX); register_decode_as(&bluetooth_eir_ad_manufacturer_company_id_da); register_decode_as(&bluetooth_eir_ad_tds_organization_id_da); diff --git a/epan/dissectors/packet-btl2cap.c b/epan/dissectors/packet-btl2cap.c index 77096ab727..db4c309f73 100644 --- a/epan/dissectors/packet-btl2cap.c +++ b/epan/dissectors/packet-btl2cap.c @@ -3360,8 +3360,8 @@ proto_register_btl2cap(void) register_dissector("btl2cap", dissect_btl2cap, proto_btl2cap); /* subdissector code */ - l2cap_psm_dissector_table = register_dissector_table("btl2cap.psm", "BT L2CAP PSM", proto_btl2cap, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - l2cap_cid_dissector_table = register_dissector_table("btl2cap.cid", "BT L2CAP CID", proto_btl2cap, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + l2cap_psm_dissector_table = register_dissector_table("btl2cap.psm", "BT L2CAP PSM", proto_btl2cap, FT_UINT16, BASE_HEX); + l2cap_cid_dissector_table = register_dissector_table("btl2cap.cid", "BT L2CAP CID", proto_btl2cap, FT_UINT16, BASE_HEX); /* 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-btrfcomm.c b/epan/dissectors/packet-btrfcomm.c index 9dbc83d736..71e1a1557d 100644 --- a/epan/dissectors/packet-btrfcomm.c +++ b/epan/dissectors/packet-btrfcomm.c @@ -1140,7 +1140,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", proto_btrfcomm, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + rfcomm_dlci_dissector_table = register_dissector_table("btrfcomm.dlci", "BT RFCOMM Directed Channel", proto_btrfcomm, FT_UINT16, BASE_DEC); module = prefs_register_protocol(proto_btrfcomm, NULL); prefs_register_static_text_preference(module, "rfcomm.version", diff --git a/epan/dissectors/packet-bvlc.c b/epan/dissectors/packet-bvlc.c index 626f6f855c..a3bf4e409d 100644 --- a/epan/dissectors/packet-bvlc.c +++ b/epan/dissectors/packet-bvlc.c @@ -406,7 +406,7 @@ proto_register_bvlc(void) register_dissector("bvlc", dissect_bvlc, proto_bvlc); bvlc_dissector_table = register_dissector_table("bvlc.function", - "BVLC Function", proto_bvlc, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "BVLC Function", proto_bvlc, FT_UINT8, BASE_HEX); } void diff --git a/epan/dissectors/packet-c15ch.c b/epan/dissectors/packet-c15ch.c index d185cb71d4..2353c6f40a 100644 --- a/epan/dissectors/packet-c15ch.c +++ b/epan/dissectors/packet-c15ch.c @@ -11972,7 +11972,7 @@ void proto_register_c15ch(void) ); proto_register_field_array(proto_c15ch_second_level, hf_second_level, array_length(hf_second_level)); proto_register_subtree_array(ett_second_level, array_length(ett_second_level)); - c15ch_dissector_table = register_dissector_table("c15", "C15", proto_c15ch, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + c15ch_dissector_table = register_dissector_table("c15", "C15", proto_c15ch, FT_UINT32, BASE_DEC); /* third level */ /* tone */ @@ -11983,7 +11983,7 @@ void proto_register_c15ch(void) ); proto_register_field_array(proto_c15ch_third_level_tone, hf_third_level_tone, array_length(hf_third_level_tone)); proto_register_subtree_array(ett_third_level_tone, array_length(ett_third_level_tone)); - c15ch_tone_dissector_table = register_dissector_table("c15.tone", "C15.TONE", proto_c15ch_third_level_tone, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + c15ch_tone_dissector_table = register_dissector_table("c15.tone", "C15.TONE", proto_c15ch_third_level_tone, FT_UINT32, BASE_DEC); /* inc gwe */ proto_c15ch_third_level_inc_gwe = proto_register_protocol( @@ -11993,7 +11993,7 @@ void proto_register_c15ch(void) ); proto_register_field_array(proto_c15ch_third_level_inc_gwe, hf_third_level_inc_gwe, array_length(hf_third_level_inc_gwe)); proto_register_subtree_array(ett_third_level_inc_gwe, array_length(ett_third_level_inc_gwe)); - c15ch_inc_gwe_dissector_table = register_dissector_table("c15.inc_gwe", "C15.INC_GWE", proto_c15ch_third_level_inc_gwe, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + c15ch_inc_gwe_dissector_table = register_dissector_table("c15.inc_gwe", "C15.INC_GWE", proto_c15ch_third_level_inc_gwe, FT_UINT32, BASE_DEC); /* out gwe */ proto_c15ch_third_level_out_gwe = proto_register_protocol( @@ -12003,7 +12003,7 @@ void proto_register_c15ch(void) ); proto_register_field_array(proto_c15ch_third_level_out_gwe, hf_third_level_out_gwe, array_length(hf_third_level_out_gwe)); proto_register_subtree_array(ett_third_level_out_gwe, array_length(ett_third_level_out_gwe)); - c15ch_out_gwe_dissector_table = register_dissector_table("c15.out_gwe", "C15.out_gwe", proto_c15ch_third_level_out_gwe, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + c15ch_out_gwe_dissector_table = register_dissector_table("c15.out_gwe", "C15.out_gwe", proto_c15ch_third_level_out_gwe, FT_UINT32, BASE_DEC); } diff --git a/epan/dissectors/packet-camel.c b/epan/dissectors/packet-camel.c index 93dfa4c6da..6214b542de 100644 --- a/epan/dissectors/packet-camel.c +++ b/epan/dissectors/packet-camel.c @@ -10680,13 +10680,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)", proto_camel, - FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT32, BASE_HEX); camel_rose_ctx.res_local_dissector_table = register_dissector_table("camel.ros.local.res", "CAMEL Operation Result (local opcode)", proto_camel, - FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT32, BASE_HEX); camel_rose_ctx.err_local_dissector_table = register_dissector_table("camel.ros.local.err", "CAMEL Error (local opcode)", proto_camel, - FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT32, BASE_HEX); /* Register our configuration options, particularly our SSNs */ /* Set default SSNs */ diff --git a/epan/dissectors/packet-ccsds.c b/epan/dissectors/packet-ccsds.c index 311457e83c..fd6b27f98d 100644 --- a/epan/dissectors/packet-ccsds.c +++ b/epan/dissectors/packet-ccsds.c @@ -715,7 +715,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", proto_ccsds, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + ccsds_dissector_table = register_dissector_table("ccsds.apid", "CCSDS apid", proto_ccsds, FT_UINT16, BASE_DEC); } diff --git a/epan/dissectors/packet-chdlc.c b/epan/dissectors/packet-chdlc.c index 2576349bff..c0aca21cbf 100644 --- a/epan/dissectors/packet-chdlc.c +++ b/epan/dissectors/packet-chdlc.c @@ -231,7 +231,7 @@ proto_register_chdlc(void) /* subdissector code */ subdissector_table = register_dissector_table("chdlc.protocol", "Cisco HDLC protocol", proto_chdlc, - FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT16, BASE_HEX); register_dissector("chdlc", dissect_chdlc, proto_chdlc); diff --git a/epan/dissectors/packet-cip.c b/epan/dissectors/packet-cip.c index 31be7fd1e1..31e0ed60ae 100644 --- a/epan/dissectors/packet-cip.c +++ b/epan/dissectors/packet-cip.c @@ -7989,9 +7989,9 @@ proto_register_cip(void) &cip_enhanced_info_column); subdissector_class_table = register_dissector_table("cip.class.iface", - "CIP Class Interface Handle", proto_cip, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "CIP Class Interface Handle", proto_cip, FT_UINT32, BASE_HEX); subdissector_symbol_table = register_dissector_table("cip.data_segment.iface", - "CIP Data Segment Interface Handle", proto_cip, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "CIP Data Segment Interface Handle", proto_cip, FT_UINT32, BASE_HEX); /* Register the protocol name and description */ 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 1d22152e9a..7dbcb334c9 100644 --- a/epan/dissectors/packet-cmip.c +++ b/epan/dissectors/packet-cmip.c @@ -5897,7 +5897,7 @@ void proto_register_cmip(void) { #line 201 "./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", proto_cmip, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + attribute_id_dissector_table = register_dissector_table("cmip.attribute_id", "CMIP Attribute Id", proto_cmip, FT_UINT32, BASE_DEC); } diff --git a/epan/dissectors/packet-cnip.c b/epan/dissectors/packet-cnip.c index 3b7c83964f..0b94e29474 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", proto_cnip, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "CN/IP Protocol", proto_cnip, FT_UINT8, BASE_DEC); } void proto_reg_handoff_cnip(void) diff --git a/epan/dissectors/packet-dccp.c b/epan/dissectors/packet-dccp.c index 571e354227..2850cba002 100644 --- a/epan/dissectors/packet-dccp.c +++ b/epan/dissectors/packet-dccp.c @@ -1278,7 +1278,7 @@ proto_register_dccp(void) /* subdissectors */ dccp_subdissector_table = register_dissector_table("dccp.port", "DCCP port", proto_dccp, FT_UINT16, - BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + BASE_DEC); heur_subdissector_list = register_heur_dissector_list("dccp", proto_dccp); /* reg preferences */ diff --git a/epan/dissectors/packet-dcerpc.c b/epan/dissectors/packet-dcerpc.c index 750f7ed6d1..d4c0d11b39 100644 --- a/epan/dissectors/packet-dcerpc.c +++ b/epan/dissectors/packet-dcerpc.c @@ -6944,7 +6944,7 @@ proto_register_dcerpc(void) expert_dcerpc = expert_register_protocol(proto_dcerpc); expert_register_field_array(expert_dcerpc, ei, array_length(ei)); - uuid_dissector_table = register_dissector_table("dcerpc.uuid", "DCE/RPC UUIDs", proto_dcerpc, FT_GUID, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + uuid_dissector_table = register_dissector_table("dcerpc.uuid", "DCE/RPC UUIDs", proto_dcerpc, FT_GUID, BASE_HEX); register_init_routine(dcerpc_init_protocol); register_cleanup_routine(dcerpc_cleanup_protocol); diff --git a/epan/dissectors/packet-dcp-etsi.c b/epan/dissectors/packet-dcp-etsi.c index 32cd8588e7..a23d668a1e 100644 --- a/epan/dissectors/packet-dcp-etsi.c +++ b/epan/dissectors/packet-dcp-etsi.c @@ -888,12 +888,12 @@ proto_register_dcp_etsi (void) /* subdissector code */ dcp_dissector_table = register_dissector_table("dcp-etsi.sync", - "DCP Sync", proto_dcp_etsi, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "DCP Sync", proto_dcp_etsi, FT_STRING, BASE_NONE); af_dissector_table = register_dissector_table("dcp-af.pt", - "DCP-AF Payload Type", proto_dcp_etsi, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "DCP-AF Payload Type", proto_dcp_etsi, FT_UINT8, BASE_DEC); tpl_dissector_table = register_dissector_table("dcp-tpl.ptr", - "DCP-TPL Protocol Type & Revision", proto_dcp_etsi, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "DCP-TPL Protocol Type & Revision", proto_dcp_etsi, FT_STRING, BASE_NONE); register_init_routine(dcp_init_protocol); register_cleanup_routine(dcp_cleanup_protocol); diff --git a/epan/dissectors/packet-diameter.c b/epan/dissectors/packet-diameter.c index ca79ca2346..58adcfb8c3 100644 --- a/epan/dissectors/packet-diameter.c +++ b/epan/dissectors/packet-diameter.c @@ -2326,11 +2326,11 @@ proto_register_diameter(void) proto_register_prefix("diameter", register_diameter_fields); /* Register dissector table(s) to do sub dissection of AVPs (OctetStrings) */ - diameter_dissector_table = register_dissector_table("diameter.base", "DIAMETER_BASE_AVPS", proto_diameter, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - diameter_3gpp_avp_dissector_table = register_dissector_table("diameter.3gpp", "DIAMETER_3GPP_AVPS", proto_diameter, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - diameter_ericsson_avp_dissector_table = register_dissector_table("diameter.ericsson", "DIAMETER_ERICSSON_AVPS", proto_diameter, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + diameter_dissector_table = register_dissector_table("diameter.base", "DIAMETER_BASE_AVPS", proto_diameter, FT_UINT32, BASE_DEC); + diameter_3gpp_avp_dissector_table = register_dissector_table("diameter.3gpp", "DIAMETER_3GPP_AVPS", proto_diameter, FT_UINT32, BASE_DEC); + diameter_ericsson_avp_dissector_table = register_dissector_table("diameter.ericsson", "DIAMETER_ERICSSON_AVPS", proto_diameter, FT_UINT32, BASE_DEC); - diameter_expr_result_vnd_table = register_dissector_table("diameter.vnd_exp_res", "DIAMETER Experimental-Result-Code", proto_diameter, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + diameter_expr_result_vnd_table = register_dissector_table("diameter.vnd_exp_res", "DIAMETER Experimental-Result-Code", proto_diameter, FT_UINT32, BASE_DEC); /* Set default TCP ports */ range_convert_str(&global_diameter_tcp_port_range, DEFAULT_DIAMETER_PORT_RANGE, MAX_UDP_PORT); diff --git a/epan/dissectors/packet-dmx.c b/epan/dissectors/packet-dmx.c index 0980a2d888..32b99dc946 100644 --- a/epan/dissectors/packet-dmx.c +++ b/epan/dissectors/packet-dmx.c @@ -413,7 +413,7 @@ proto_register_dmx(void) register_dissector("dmx", dissect_dmx, proto_dmx); dmx_dissector_table = register_dissector_table("dmx", "DMX Start Code", proto_dmx, - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT8, BASE_DEC); } diff --git a/epan/dissectors/packet-dns.c b/epan/dissectors/packet-dns.c index ed1c359eec..a41460da5d 100644 --- a/epan/dissectors/packet-dns.c +++ b/epan/dissectors/packet-dns.c @@ -5605,7 +5605,7 @@ proto_register_dns(void) "DNS address resolution settings can be changed in the Name Resolution preferences", "DNS address resolution settings can be changed in the Name Resolution preferences"); - dns_tsig_dissector_table = register_dissector_table("dns.tsig.mac", "DNS TSIG MAC Dissectors", proto_dns, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + dns_tsig_dissector_table = register_dissector_table("dns.tsig.mac", "DNS TSIG MAC Dissectors", proto_dns, FT_STRING, BASE_NONE); dns_handle = register_dissector("dns", dissect_dns, proto_dns); diff --git a/epan/dissectors/packet-dof.c b/epan/dissectors/packet-dof.c index e3d1fcef8b..1a5e410c02 100644 --- a/epan/dissectors/packet-dof.c +++ b/epan/dissectors/packet-dof.c @@ -10574,7 +10574,7 @@ static void dof_tun_register(void) proto_register_subtree_array(ett, array_length(ett)); register_dissector(TUNNEL_PROTOCOL_STACK, dissect_tunnel_common, proto_2012_1_tunnel); - dof_tun_app_dissectors = register_dissector_table("dof.tunnel.app", "DOF Tunnel Version", proto_2012_1_tunnel, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + dof_tun_app_dissectors = register_dissector_table("dof.tunnel.app", "DOF Tunnel Version", proto_2012_1_tunnel, FT_UINT8, BASE_DEC); } static void dof_tun_reset(void) @@ -10944,9 +10944,9 @@ static void dof_register(void) char *uat_load_err; expert_module_t *expert_security; - dsp_option_dissectors = register_dissector_table("dof.dsp.options", "DSP Protocol Options", proto_2008_1_dsp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - dof_sec_dissectors = register_dissector_table("dof.secmode", "DOF Security Mode of Operation", proto_2008_1_dof, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - register_dissector_table("dof.2008.1", "DOF Common PDU", proto_2008_1_dof, FT_STRING, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + dsp_option_dissectors = register_dissector_table("dof.dsp.options", "DSP Protocol Options", proto_2008_1_dsp, FT_UINT32, BASE_DEC); + dof_sec_dissectors = register_dissector_table("dof.secmode", "DOF Security Mode of Operation", proto_2008_1_dof, FT_UINT16, BASE_DEC); + register_dissector_table("dof.2008.1", "DOF Common PDU", proto_2008_1_dof, FT_STRING, BASE_DEC); proto_2008_1_dof = proto_register_protocol(DOF_PROTOCOL_STACK, "DOF", "dof"); @@ -11308,8 +11308,8 @@ static void dof_dnp_register(void) proto_register_field_array(proto_2008_1_dnp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - dnp_dissectors = register_dissector_table("dof.dnp", "DOF DNP Version", proto_2008_1_dnp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - dnp_framing_dissectors = register_dissector_table("dof.dnp.frame", "DOF DNP Framing", proto_2008_1_dnp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + dnp_dissectors = register_dissector_table("dof.dnp", "DOF DNP Version", proto_2008_1_dnp, FT_UINT8, BASE_DEC); + dnp_framing_dissectors = register_dissector_table("dof.dnp.frame", "DOF DNP Framing", proto_2008_1_dnp, FT_UINT8, BASE_DEC); dof_register_dnp_0(); dof_register_dnp_1(); @@ -11531,7 +11531,7 @@ static void dof_dpp_register(void) proto_register_field_array(proto_2008_1_dpp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - dof_dpp_dissectors = register_dissector_table("dof.dpp", "DOF DPP Version", proto_2008_1_dpp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + dof_dpp_dissectors = register_dissector_table("dof.dpp", "DOF DPP Version", proto_2008_1_dpp, FT_UINT8, BASE_DEC); expert_dpp = expert_register_protocol(proto_2008_1_dpp); expert_register_field_array(expert_dpp, ei, array_length(ei)); @@ -11565,7 +11565,7 @@ static void app_register(void) if (proto_2008_1_app == -1) { proto_2008_1_app = proto_register_protocol(DOF_APPLICATION_PROTOCOL, "DPS.APP", "dof.app"); - app_dissectors = register_dissector_table("dof.app", "DOF APP Version", proto_2008_1_app, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + app_dissectors = register_dissector_table("dof.app", "DOF APP Version", proto_2008_1_app, FT_UINT16, BASE_DEC); } } diff --git a/epan/dissectors/packet-dop.c b/epan/dissectors/packet-dop.c index b7dc6072d5..282ba5bb53 100644 --- a/epan/dissectors/packet-dop.c +++ b/epan/dissectors/packet-dop.c @@ -3056,7 +3056,7 @@ void proto_register_dop(void) { register_dissector("dop", dissect_dop, proto_dop); - dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", proto_dop, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", proto_dop, FT_STRING, BASE_NONE); /* Register fields and subtrees */ proto_register_field_array(proto_dop, hf, array_length(hf)); diff --git a/epan/dissectors/packet-dtls.c b/epan/dissectors/packet-dtls.c index 9e6e4d1763..8770276042 100644 --- a/epan/dissectors/packet-dtls.c +++ b/epan/dissectors/packet-dtls.c @@ -1771,7 +1771,7 @@ proto_register_dtls(void) proto_dtls = proto_register_protocol("Datagram Transport Layer Security", "DTLS", "dtls"); - dtls_associations = register_dissector_table("dtls.port", "DTLS UDP Dissector", proto_dtls, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + dtls_associations = register_dissector_table("dtls.port", "DTLS UDP Dissector", proto_dtls, FT_UINT16, BASE_DEC); /* Required function calls to register the header fields and * subtrees used */ diff --git a/epan/dissectors/packet-dvbci.c b/epan/dissectors/packet-dvbci.c index a692b5cf40..3626f1f359 100644 --- a/epan/dissectors/packet-dvbci.c +++ b/epan/dissectors/packet-dvbci.c @@ -6343,7 +6343,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", proto_dvbci, FT_STRING, STR_ASCII, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "SAS application id", proto_dvbci, FT_STRING, STR_ASCII); register_init_routine(dvbci_init); register_cleanup_routine(dvbci_cleanup); diff --git a/epan/dissectors/packet-eapol.c b/epan/dissectors/packet-eapol.c index 984c2fad75..09e0a2a4a9 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", proto_eapol, FT_UINT8, - BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + BASE_DEC); } void diff --git a/epan/dissectors/packet-ecp.c b/epan/dissectors/packet-ecp.c index 7ddcbd46d6..73a36c3548 100644 --- a/epan/dissectors/packet-ecp.c +++ b/epan/dissectors/packet-ecp.c @@ -444,7 +444,7 @@ proto_register_ecp(void) proto_register_field_array(proto_ecp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - ecp_subdissector_table = register_dissector_table("ecp.subtype", "ECP Subtypes", proto_ecp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + ecp_subdissector_table = register_dissector_table("ecp.subtype", "ECP Subtypes", proto_ecp, FT_UINT32, BASE_DEC); } void diff --git a/epan/dissectors/packet-enc.c b/epan/dissectors/packet-enc.c index 58496e0aea..c100f15ec3 100644 --- a/epan/dissectors/packet-enc.c +++ b/epan/dissectors/packet-enc.c @@ -159,7 +159,7 @@ proto_register_enc(void) proto_register_field_array(proto_enc, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - enc_dissector_table = register_dissector_table("enc", "OpenBSD Encapsulating device", proto_enc, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + enc_dissector_table = register_dissector_table("enc", "OpenBSD Encapsulating device", proto_enc, FT_UINT32, BASE_DEC); register_capture_dissector_table("enc", "ENC"); } diff --git a/epan/dissectors/packet-enip.c b/epan/dissectors/packet-enip.c index 7278233580..c4c9a266ee 100644 --- a/epan/dissectors/packet-enip.c +++ b/epan/dissectors/packet-enip.c @@ -4374,12 +4374,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", proto_enip, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "ENIP SendUnitData.Interface Handle", proto_enip, FT_UINT32, BASE_HEX); subdissector_srrd_table = register_dissector_table("enip.srrd.iface", - "ENIP SendRequestReplyData.Interface Handle", proto_enip, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "ENIP SendRequestReplyData.Interface Handle", proto_enip, FT_UINT32, BASE_HEX); - subdissector_io_table = register_dissector_table("enip.io", "ENIP IO dissector", proto_enip, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + subdissector_io_table = register_dissector_table("enip.io", "ENIP IO dissector", proto_enip, FT_UINT32, BASE_DEC); register_init_routine(&enip_init_protocol); register_cleanup_routine(&enip_cleanup_protocol); diff --git a/epan/dissectors/packet-epl.c b/epan/dissectors/packet-epl.c index 8b4fbc5ccc..633f3f82b4 100644 --- a/epan/dissectors/packet-epl.c +++ b/epan/dissectors/packet-epl.c @@ -4530,7 +4530,7 @@ proto_register_epl(void) heur_epl_subdissector_list = register_heur_dissector_list("epl", proto_epl); heur_epl_data_subdissector_list = register_heur_dissector_list("epl_data", proto_epl); epl_asnd_dissector_table = register_dissector_table("epl.asnd", - "Manufacturer specific ASND service", proto_epl, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Manufacturer specific ASND service", proto_epl, FT_UINT8, BASE_DEC); /* Registering protocol to be called by another dissector */ epl_handle = register_dissector("epl", dissect_epl, proto_epl); diff --git a/epan/dissectors/packet-erf.c b/epan/dissectors/packet-erf.c index 94266476c6..9fcbf4584c 100644 --- a/epan/dissectors/packet-erf.c +++ b/epan/dissectors/packet-erf.c @@ -3238,7 +3238,7 @@ proto_register_erf(void) */ prefs_register_obsolete_preference(erf_module, "ethfcs"); - erf_dissector_table = register_dissector_table("erf.types.type", "Type", proto_erf, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + erf_dissector_table = register_dissector_table("erf.types.type", "Type", proto_erf, FT_UINT8, BASE_DEC); register_init_routine(erf_init_dissection); /* No extra cleanup needed */ diff --git a/epan/dissectors/packet-ethertype.c b/epan/dissectors/packet-ethertype.c index 164b7e07ad..6a6e7eb7a8 100644 --- a/epan/dissectors/packet-ethertype.c +++ b/epan/dissectors/packet-ethertype.c @@ -355,7 +355,7 @@ proto_register_ethertype(void) /* subdissector code */ ethertype_dissector_table = register_dissector_table("ethertype", - "Ethertype", proto_ethertype, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Ethertype", proto_ethertype, FT_UINT16, BASE_HEX); register_capture_dissector_table("ethertype", "Ethertype"); register_decode_as(ðertype_da); diff --git a/epan/dissectors/packet-fc.c b/epan/dissectors/packet-fc.c index 127219c3ff..2658cad358 100644 --- a/epan/dissectors/packet-fc.c +++ b/epan/dissectors/packet-fc.c @@ -1559,7 +1559,7 @@ proto_register_fc(void) */ fcftype_dissector_table = register_dissector_table ("fc.ftype", "FC Frame Type", - proto_fc, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_fc, FT_UINT8, BASE_HEX); /* 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 5a5cc8526a..7e43c590fe 100644 --- a/epan/dissectors/packet-fcct.c +++ b/epan/dissectors/packet-fcct.c @@ -275,7 +275,7 @@ proto_register_fcct(void) fcct_gserver_table = register_dissector_table ("fcct.server", "FCCT Server", - proto_fcct, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_fcct, FT_UINT8, BASE_HEX); } void diff --git a/epan/dissectors/packet-flexray.c b/epan/dissectors/packet-flexray.c index 937fbfa4fe..2be2ce2d18 100644 --- a/epan/dissectors/packet-flexray.c +++ b/epan/dissectors/packet-flexray.c @@ -460,7 +460,7 @@ proto_register_flexray(void) register_decode_as(&flexray_da); subdissector_table = register_dissector_table("flexray.subdissector", - "FLEXRAY next level dissector", proto_flexray, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "FLEXRAY next level dissector", proto_flexray, FT_UINT32, BASE_HEX); } void diff --git a/epan/dissectors/packet-flip.c b/epan/dissectors/packet-flip.c index 869e8632d7..46669c3ab6 100644 --- a/epan/dissectors/packet-flip.c +++ b/epan/dissectors/packet-flip.c @@ -466,7 +466,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", proto_flip, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + subdissector_table = register_dissector_table("flip.payload", "FLIP subdissector", proto_flip, FT_UINT32, BASE_HEX); flip_module = prefs_register_protocol(proto_flip, NULL); diff --git a/epan/dissectors/packet-fr.c b/epan/dissectors/packet-fr.c index 4761d7f4ae..dc1eb11b48 100644 --- a/epan/dissectors/packet-fr.c +++ b/epan/dissectors/packet-fr.c @@ -969,9 +969,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", proto_fr, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Frame Relay NLPID", proto_fr, FT_UINT8, BASE_HEX); fr_osinl_subdissector_table = register_dissector_table("fr.osinl", - "Frame Relay OSI NLPID", proto_fr, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Frame Relay OSI NLPID", proto_fr, FT_UINT8, BASE_HEX); register_dissector("fr_uncompressed", dissect_fr_uncompressed, proto_fr); register_dissector("fr", dissect_fr, proto_fr); diff --git a/epan/dissectors/packet-frame.c b/epan/dissectors/packet-frame.c index f24e7ab387..292173c2e5 100644 --- a/epan/dissectors/packet-frame.c +++ b/epan/dissectors/packet-frame.c @@ -917,9 +917,9 @@ proto_register_frame(void) register_dissector("frame",dissect_frame,proto_frame); wtap_encap_dissector_table = register_dissector_table("wtap_encap", - "Wiretap encapsulation type", proto_frame, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "Wiretap encapsulation type", proto_frame, FT_UINT32, BASE_DEC); wtap_fts_rec_dissector_table = register_dissector_table("wtap_fts_rec", - "Wiretap file type for file-type-specific records", proto_frame, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "Wiretap file type for file-type-specific records", proto_frame, FT_UINT32, BASE_DEC); register_capture_dissector_table("wtap_encap", "Wiretap encapsulation type"); /* You can't disable dissection of "Frame", as that would be diff --git a/epan/dissectors/packet-gfp.c b/epan/dissectors/packet-gfp.c index df96244d71..fcd91480c9 100644 --- a/epan/dissectors/packet-gfp.c +++ b/epan/dissectors/packet-gfp.c @@ -578,7 +578,7 @@ proto_register_gfp(void) /* Subdissectors for payload */ gfp_dissector_table = register_dissector_table("gfp.upi", "GFP UPI (for Client Data frames)", - proto_gfp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_gfp, FT_UINT8, BASE_DEC); /* Don't register a preferences module yet since there are no prefs in * order to avoid a warning. (See section 2.6 of README.dissector diff --git a/epan/dissectors/packet-gprs-llc.c b/epan/dissectors/packet-gprs-llc.c index d47f869f0a..660ca9241e 100644 --- a/epan/dissectors/packet-gprs-llc.c +++ b/epan/dissectors/packet-gprs-llc.c @@ -1325,7 +1325,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", proto_llcgprs, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + llcgprs_subdissector_table = register_dissector_table("llcgprs.sapi", "GPRS LLC SAPI", proto_llcgprs, FT_UINT8, BASE_HEX); /* Required function calls to register the header fields and subtrees used */ 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 78eace6a3e..52ef0dedc3 100644 --- a/epan/dissectors/packet-gre.c +++ b/epan/dissectors/packet-gre.c @@ -746,7 +746,7 @@ proto_register_gre(void) /* subdissector code */ gre_dissector_table = register_dissector_table("gre.proto", - "GRE protocol type", proto_gre, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "GRE protocol type", proto_gre, FT_UINT16, BASE_HEX); } void diff --git a/epan/dissectors/packet-gsm_a_dtap.c b/epan/dissectors/packet-gsm_a_dtap.c index 343c313aeb..3d5397a139 100644 --- a/epan/dissectors/packet-gsm_a_dtap.c +++ b/epan/dissectors/packet-gsm_a_dtap.c @@ -8309,7 +8309,7 @@ proto_register_gsm_a_dtap(void) /* subdissector code */ 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", - proto_a_dtap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_a_dtap, FT_UINT8, BASE_DEC); } void diff --git a/epan/dissectors/packet-gsm_a_gm.c b/epan/dissectors/packet-gsm_a_gm.c index 95f65ae5b9..537e317cda 100644 --- a/epan/dissectors/packet-gsm_a_gm.c +++ b/epan/dissectors/packet-gsm_a_gm.c @@ -8867,7 +8867,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", proto_a_gm, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "GPRS SM PCO PPP protocol", proto_a_gm, FT_UINT16, BASE_HEX); } void diff --git a/epan/dissectors/packet-gsm_ipa.c b/epan/dissectors/packet-gsm_ipa.c index ce2d9d2a29..e9fa232a1f 100644 --- a/epan/dissectors/packet-gsm_ipa.c +++ b/epan/dissectors/packet-gsm_ipa.c @@ -455,7 +455,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", proto_ipa, - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT8, BASE_DEC); range_convert_str(&global_ipa_tcp_ports, IPA_TCP_PORTS, MAX_TCP_PORT); diff --git a/epan/dissectors/packet-gsm_map.c b/epan/dissectors/packet-gsm_map.c index e75e0af3ba..4fbdecaf9e 100644 --- a/epan/dissectors/packet-gsm_map.c +++ b/epan/dissectors/packet-gsm_map.c @@ -31128,12 +31128,12 @@ 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)); - register_dissector_table("gsm_map.v3.arg.opcode", "GSM_MAP V3 Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - register_dissector_table("gsm_map.v3.res.opcode", "GSM_MAP V3 Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + register_dissector_table("gsm_map.v3.arg.opcode", "GSM_MAP V3 Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC); + register_dissector_table("gsm_map.v3.res.opcode", "GSM_MAP V3 Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC); - map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC); + map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC); + map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC); gsm_map_tap = register_tap("gsm_map"); diff --git a/epan/dissectors/packet-gsm_sms.c b/epan/dissectors/packet-gsm_sms.c index 09ff280ce5..70fd85e5e4 100644 --- a/epan/dissectors/packet-gsm_sms.c +++ b/epan/dissectors/packet-gsm_sms.c @@ -3347,7 +3347,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", proto_gsm_sms, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "GSM SMS port IE in UDH", proto_gsm_sms, FT_UINT16, BASE_DEC); gsm_sms_module = prefs_register_protocol (proto_gsm_sms, NULL); diff --git a/epan/dissectors/packet-gsm_sms_ud.c b/epan/dissectors/packet-gsm_sms_ud.c index d98b3c364e..c3c1d44261 100644 --- a/epan/dissectors/packet-gsm_sms_ud.c +++ b/epan/dissectors/packet-gsm_sms_ud.c @@ -707,7 +707,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", proto_gsm_sms_ud, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "GSM SMS port IE in UDH", proto_gsm_sms_ud, FT_UINT16, BASE_DEC); /* Preferences for GSM SMS UD */ 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 4e46cd5525..d4ed1764a5 100644 --- a/epan/dissectors/packet-gsmtap.c +++ b/epan/dissectors/packet-gsmtap.c @@ -775,7 +775,7 @@ proto_register_gsmtap(void) proto_register_subtree_array(ett, array_length(ett)); gsmtap_dissector_table = register_dissector_table("gsmtap.type", - "GSMTAP type", proto_gsmtap, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "GSMTAP type", proto_gsmtap, FT_UINT8, BASE_HEX); } void diff --git a/epan/dissectors/packet-gtp.c b/epan/dissectors/packet-gtp.c index 029ba157f6..54535fdac1 100644 --- a/epan/dissectors/packet-gtp.c +++ b/epan/dissectors/packet-gtp.c @@ -10159,8 +10159,8 @@ proto_register_gtp(void) register_dissector("gtp", dissect_gtp, proto_gtp); register_dissector("gtpprime", dissect_gtpprime, proto_gtpprime); - gtp_priv_ext_dissector_table = register_dissector_table("gtp.priv_ext", "GTP PRIVATE EXT", proto_gtp, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - gtp_cdr_fmt_dissector_table = register_dissector_table("gtp.cdr_fmt", "GTP DATA RECORD TYPE", proto_gtp, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + gtp_priv_ext_dissector_table = register_dissector_table("gtp.priv_ext", "GTP PRIVATE EXT", proto_gtp, FT_UINT16, BASE_DEC); + gtp_cdr_fmt_dissector_table = register_dissector_table("gtp.cdr_fmt", "GTP DATA RECORD TYPE", proto_gtp, FT_UINT16, BASE_DEC); register_init_routine(gtp_init); register_cleanup_routine(gtp_cleanup); diff --git a/epan/dissectors/packet-gtpv2.c b/epan/dissectors/packet-gtpv2.c index b24b9e57e5..5ea6a5fec5 100644 --- a/epan/dissectors/packet-gtpv2.c +++ b/epan/dissectors/packet-gtpv2.c @@ -8896,7 +8896,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", proto_gtpv2, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + gtpv2_priv_ext_dissector_table = register_dissector_table("gtpv2.priv_ext", "GTPv2 PRIVATE EXT", proto_gtpv2, FT_UINT16, BASE_DEC); } void diff --git a/epan/dissectors/packet-h225.c b/epan/dissectors/packet-h225.c index c91d5491e7..d78331ba18 100644 --- a/epan/dissectors/packet-h225.c +++ b/epan/dissectors/packet-h225.c @@ -11816,11 +11816,11 @@ void proto_register_h225(void) { register_dissector("h323ui",dissect_h225_H323UserInformation, proto_h225); h225ras_handle = register_dissector("h225.ras", dissect_h225_h225_RasMessage, proto_h225); - nsp_object_dissector_table = register_dissector_table("h225.nsp.object", "H.225 NonStandardParameter (object)", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nsp_h221_dissector_table = register_dissector_table("h225.nsp.h221", "H.225 NonStandardParameter (h221)", proto_h225, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - tp_dissector_table = register_dissector_table("h225.tp", "H.225 TunnelledProtocol", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_name_dissector_table = register_dissector_table("h225.gef.name", "H.225 Generic Extensible Framework (names)", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_content_dissector_table = register_dissector_table("h225.gef.content", "H.225 Generic Extensible Framework", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_object_dissector_table = register_dissector_table("h225.nsp.object", "H.225 NonStandardParameter (object)", proto_h225, FT_STRING, BASE_NONE); + nsp_h221_dissector_table = register_dissector_table("h225.nsp.h221", "H.225 NonStandardParameter (h221)", proto_h225, FT_UINT32, BASE_HEX); + tp_dissector_table = register_dissector_table("h225.tp", "H.225 TunnelledProtocol", proto_h225, FT_STRING, BASE_NONE); + gef_name_dissector_table = register_dissector_table("h225.gef.name", "H.225 Generic Extensible Framework (names)", proto_h225, FT_STRING, BASE_NONE); + gef_content_dissector_table = register_dissector_table("h225.gef.content", "H.225 Generic Extensible Framework", proto_h225, FT_STRING, BASE_NONE); register_init_routine(&h225_init_routine); register_cleanup_routine(&h225_cleanup_routine); diff --git a/epan/dissectors/packet-h245.c b/epan/dissectors/packet-h245.c index 208ab5c5ef..401309d368 100644 --- a/epan/dissectors/packet-h245.c +++ b/epan/dissectors/packet-h245.c @@ -20763,10 +20763,10 @@ void proto_register_h245(void) { MultimediaSystemControlMessage_handle = register_dissector("h245dg", dissect_h245_h245, proto_h245); h245_handle = register_dissector("h245", dissect_h245, proto_h245); - nsp_object_dissector_table = register_dissector_table("h245.nsp.object", "H.245 NonStandardParameter (object)", proto_h245, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nsp_h221_dissector_table = register_dissector_table("h245.nsp.h221", "H.245 NonStandardParameter (h221)", proto_h245, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_name_dissector_table = register_dissector_table("h245.gef.name", "H.245 Generic Extensible Framework (names)", proto_h245, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_content_dissector_table = register_dissector_table("h245.gef.content", "H.245 Generic Extensible Framework", proto_h245, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_object_dissector_table = register_dissector_table("h245.nsp.object", "H.245 NonStandardParameter (object)", proto_h245, FT_STRING, BASE_NONE); + nsp_h221_dissector_table = register_dissector_table("h245.nsp.h221", "H.245 NonStandardParameter (h221)", proto_h245, FT_UINT32, BASE_HEX); + gef_name_dissector_table = register_dissector_table("h245.gef.name", "H.245 Generic Extensible Framework (names)", proto_h245, FT_STRING, BASE_NONE); + gef_content_dissector_table = register_dissector_table("h245.gef.content", "H.245 Generic Extensible Framework", proto_h245, FT_STRING, BASE_NONE); 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 3310cee54a..3214cf21e7 100644 --- a/epan/dissectors/packet-h248.c +++ b/epan/dissectors/packet-h248.c @@ -7702,7 +7702,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", proto_h248, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + subdissector_table = register_dissector_table("h248.magic_num", "H248 Magic Num", proto_h248, FT_UINT32, BASE_HEX); h248_module = prefs_register_protocol(proto_h248, proto_reg_handoff_h248); prefs_register_bool_preference(h248_module, "ctx_info", diff --git a/epan/dissectors/packet-h450.c b/epan/dissectors/packet-h450.c index 18a8b3c049..bd74418428 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)", proto_h450, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.res_global_dissector_table = register_dissector_table("h450.ros.global.res", "H.450 Operation Result (global opcode)", proto_h450, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.arg_local_dissector_table = register_dissector_table("h450.ros.local.arg", "H.450 Operation Argument (local opcode)", proto_h450, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.res_local_dissector_table = register_dissector_table("h450.ros.local.res", "H.450 Operation Result (local opcode)", proto_h450, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.err_global_dissector_table = register_dissector_table("h450.ros.global.err", "H.450 Error (global opcode)", proto_h450, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.err_local_dissector_table = register_dissector_table("h450.ros.local.err", "H.450 Error (local opcode)", proto_h450, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.arg_global_dissector_table = register_dissector_table("h450.ros.global.arg", "H.450 Operation Argument (global opcode)", proto_h450, FT_STRING, BASE_NONE); + h450_rose_ctx.res_global_dissector_table = register_dissector_table("h450.ros.global.res", "H.450 Operation Result (global opcode)", proto_h450, FT_STRING, BASE_NONE); + h450_rose_ctx.arg_local_dissector_table = register_dissector_table("h450.ros.local.arg", "H.450 Operation Argument (local opcode)", proto_h450, FT_UINT32, BASE_HEX); + h450_rose_ctx.res_local_dissector_table = register_dissector_table("h450.ros.local.res", "H.450 Operation Result (local opcode)", proto_h450, FT_UINT32, BASE_HEX); + h450_rose_ctx.err_global_dissector_table = register_dissector_table("h450.ros.global.err", "H.450 Error (global opcode)", proto_h450, FT_STRING, BASE_NONE); + h450_rose_ctx.err_local_dissector_table = register_dissector_table("h450.ros.local.err", "H.450 Error (local opcode)", proto_h450, FT_UINT32, BASE_HEX); } diff --git a/epan/dissectors/packet-hci_h1.c b/epan/dissectors/packet-hci_h1.c index 36520be98e..47149e0450 100644 --- a/epan/dissectors/packet-hci_h1.c +++ b/epan/dissectors/packet-hci_h1.c @@ -139,7 +139,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", proto_hci_h1, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "HCI h1 pdu type", proto_hci_h1, FT_UINT8, BASE_HEX); } void diff --git a/epan/dissectors/packet-hci_h4.c b/epan/dissectors/packet-hci_h4.c index 3336b04c29..6def54ea44 100644 --- a/epan/dissectors/packet-hci_h4.c +++ b/epan/dissectors/packet-hci_h4.c @@ -142,7 +142,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", proto_hci_h4, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "HCI H4 pdu type", proto_hci_h4, FT_UINT8, BASE_HEX); } void diff --git a/epan/dissectors/packet-hnbap.c b/epan/dissectors/packet-hnbap.c index eb6d9c99d2..8a38b94d37 100644 --- a/epan/dissectors/packet-hnbap.c +++ b/epan/dissectors/packet-hnbap.c @@ -3298,11 +3298,11 @@ module_t *hnbap_module; hnbap_handle = register_dissector("hnbap", dissect_hnbap, proto_hnbap); /* Register dissector tables */ - hnbap_ies_dissector_table = register_dissector_table("hnbap.ies", "HNBAP-PROTOCOL-IES", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_extension_dissector_table = register_dissector_table("hnbap.extension", "HNBAP-PROTOCOL-EXTENSION", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_proc_imsg_dissector_table = register_dissector_table("hnbap.proc.imsg", "HNBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_proc_sout_dissector_table = register_dissector_table("hnbap.proc.sout", "HNBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_proc_uout_dissector_table = register_dissector_table("hnbap.proc.uout", "HNBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_ies_dissector_table = register_dissector_table("hnbap.ies", "HNBAP-PROTOCOL-IES", proto_hnbap, FT_UINT32, BASE_DEC); + hnbap_extension_dissector_table = register_dissector_table("hnbap.extension", "HNBAP-PROTOCOL-EXTENSION", proto_hnbap, FT_UINT32, BASE_DEC); + hnbap_proc_imsg_dissector_table = register_dissector_table("hnbap.proc.imsg", "HNBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_hnbap, FT_UINT32, BASE_DEC); + hnbap_proc_sout_dissector_table = register_dissector_table("hnbap.proc.sout", "HNBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC); + hnbap_proc_uout_dissector_table = register_dissector_table("hnbap.proc.uout", "HNBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC); hnbap_module = prefs_register_protocol(proto_hnbap, proto_reg_handoff_hnbap); 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 f8f7f10497..a6420aa9e9 100644 --- a/epan/dissectors/packet-hpext.c +++ b/epan/dissectors/packet-hpext.c @@ -128,7 +128,7 @@ proto_register_hpext(void) /* subdissector code */ subdissector_table = register_dissector_table("hpext.dxsap", - "HPEXT XSAP", proto_hpext, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "HPEXT XSAP", proto_hpext, FT_UINT16, BASE_HEX); hpext_handle = register_dissector("hpext", dissect_hpext, proto_hpext); } diff --git a/epan/dissectors/packet-http.c b/epan/dissectors/packet-http.c index e38224f9fc..4c6ea09b2e 100644 --- a/epan/dissectors/packet-http.c +++ b/epan/dissectors/packet-http.c @@ -3667,7 +3667,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", proto_http, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "TCP port for protocols using HTTP", proto_http, FT_UINT16, BASE_DEC); /* * Dissectors can register themselves in this table. @@ -3676,7 +3676,7 @@ proto_register_http(void) */ media_type_subdissector_table = register_dissector_table("media_type", - "Internet media type", proto_http, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "Internet media type", proto_http, FT_STRING, BASE_NONE); /* * Heuristic dissectors SHOULD register themselves in diff --git a/epan/dissectors/packet-i2c.c b/epan/dissectors/packet-i2c.c index a8599e4f08..2adfd01c97 100644 --- a/epan/dissectors/packet-i2c.c +++ b/epan/dissectors/packet-i2c.c @@ -255,7 +255,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", proto_i2c, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + subdissector_table = register_dissector_table("i2c.message", "I2C messages dissector", proto_i2c, FT_UINT32, BASE_DEC); 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 47d77c545d..f01a98df36 100644 --- a/epan/dissectors/packet-iax2.c +++ b/epan/dissectors/packet-iax2.c @@ -3200,9 +3200,9 @@ proto_register_iax2(void) register_dissector("iax2", dissect_iax2, proto_iax2); iax2_codec_dissector_table = register_dissector_table( - "iax2.codec", "IAX codec number", proto_iax2, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "iax2.codec", "IAX codec number", proto_iax2, FT_UINT32, BASE_HEX); iax2_dataformat_dissector_table = register_dissector_table( - "iax2.dataformat", "IAX dataformat number", proto_iax2, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "iax2.dataformat", "IAX dataformat number", proto_iax2, FT_UINT32, BASE_HEX); /* 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 a83e813f23..3e4a44d227 100644 --- a/epan/dissectors/packet-idp.c +++ b/epan/dissectors/packet-idp.c @@ -196,7 +196,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", proto_idp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "IDP packet type", proto_idp, FT_UINT8, BASE_DEC); } void diff --git a/epan/dissectors/packet-ieee1722.c b/epan/dissectors/packet-ieee1722.c index b37c51b348..a2cdb2c414 100644 --- a/epan/dissectors/packet-ieee1722.c +++ b/epan/dissectors/packet-ieee1722.c @@ -507,7 +507,7 @@ void proto_register_1722(void) /* Sub-dissector for 1772.1, 1722 AAF, 1722 CRF, 1722 61883 */ avb_dissector_table = register_dissector_table("ieee1722.subtype", - "IEEE1722 AVBTP Subtype", proto_1722, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "IEEE1722 AVBTP Subtype", proto_1722, FT_UINT8, BASE_HEX); } void proto_reg_handoff_1722(void) diff --git a/epan/dissectors/packet-ieee802154.c b/epan/dissectors/packet-ieee802154.c index 762033ed22..6c40587b93 100644 --- a/epan/dissectors/packet-ieee802154.c +++ b/epan/dissectors/packet-ieee802154.c @@ -3860,7 +3860,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", proto_ieee802154, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + panid_dissector_table = register_dissector_table(IEEE802154_PROTOABBREV_WPAN_PANID, "IEEE 802.15.4 PANID", proto_ieee802154, FT_UINT16, BASE_HEX); ieee802154_heur_subdissector_list = register_heur_dissector_list(IEEE802154_PROTOABBREV_WPAN, proto_ieee802154); ieee802154_beacon_subdissector_list = register_heur_dissector_list(IEEE802154_PROTOABBREV_WPAN_BEACON, proto_ieee802154); diff --git a/epan/dissectors/packet-ieee802a.c b/epan/dissectors/packet-ieee802a.c index bd72ea365a..0d9f9c5561 100644 --- a/epan/dissectors/packet-ieee802a.c +++ b/epan/dissectors/packet-ieee802a.c @@ -60,7 +60,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, proto, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + table_ui_name, proto, FT_UINT16, BASE_HEX); new_info->field_info = hf_item; /* diff --git a/epan/dissectors/packet-igmp.c b/epan/dissectors/packet-igmp.c index c6483434c2..51ca96bdeb 100644 --- a/epan/dissectors/packet-igmp.c +++ b/epan/dissectors/packet-igmp.c @@ -1104,7 +1104,7 @@ proto_register_igmp(void) expert_igmp = expert_register_protocol(proto_igmp); expert_register_field_array(expert_igmp, ei, array_length(ei)); - subdissector_table = register_dissector_table("igmp.type", "IGMP commands", proto_igmp, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + subdissector_table = register_dissector_table("igmp.type", "IGMP commands", proto_igmp, FT_UINT32, BASE_HEX); } diff --git a/epan/dissectors/packet-interlink.c b/epan/dissectors/packet-interlink.c index 983b3e21d6..6b7a36800f 100644 --- a/epan/dissectors/packet-interlink.c +++ b/epan/dissectors/packet-interlink.c @@ -219,7 +219,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", proto_interlink, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Interlink type_version", proto_interlink, FT_UINT16, BASE_HEX); } diff --git a/epan/dissectors/packet-ip.c b/epan/dissectors/packet-ip.c index 59141f6137..054ffcc6e2 100644 --- a/epan/dissectors/packet-ip.c +++ b/epan/dissectors/packet-ip.c @@ -3080,7 +3080,7 @@ proto_register_ip(void) /* subdissector code */ ip_dissector_table = register_dissector_table("ip.proto", "IP protocol", - proto_ip, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_ip, FT_UINT8, BASE_DEC); heur_subdissector_list = register_heur_dissector_list("ip", proto_ip); register_capture_dissector_table("ip.proto", "IP protocol"); diff --git a/epan/dissectors/packet-ipmi-trace.c b/epan/dissectors/packet-ipmi-trace.c index 3ca562ae25..807e94530e 100644 --- a/epan/dissectors/packet-ipmi-trace.c +++ b/epan/dissectors/packet-ipmi-trace.c @@ -439,7 +439,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", proto_ipmi_trace, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "IPMI Channel Protocol Type", proto_ipmi_trace, FT_UINT8, BASE_HEX); } void diff --git a/epan/dissectors/packet-ipx.c b/epan/dissectors/packet-ipx.c index 309617fcba..a0b85871d5 100644 --- a/epan/dissectors/packet-ipx.c +++ b/epan/dissectors/packet-ipx.c @@ -1573,11 +1573,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", proto_ipx, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "IPX packet type", proto_ipx, FT_UINT8, BASE_HEX); ipx_socket_dissector_table = register_dissector_table("ipx.socket", - "IPX socket", proto_ipx, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "IPX socket", proto_ipx, FT_UINT16, BASE_HEX); spx_socket_dissector_table = register_dissector_table("spx.socket", - "SPX socket", proto_spx, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "SPX socket", proto_spx, FT_UINT16, BASE_HEX); register_init_routine(&spx_init_protocol); register_postseq_cleanup_routine(&spx_postseq_cleanup); diff --git a/epan/dissectors/packet-isi.c b/epan/dissectors/packet-isi.c index 93ae528f62..2393af806d 100644 --- a/epan/dissectors/packet-isi.c +++ b/epan/dissectors/packet-isi.c @@ -2126,7 +2126,7 @@ proto_register_isi(void) expert_register_field_array(expert_isi, ei, array_length(ei)); /* create new dissector table for isi resource */ - isi_resource_dissector_table = register_dissector_table("isi.resource", "ISI resource", proto_isi, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + isi_resource_dissector_table = register_dissector_table("isi.resource", "ISI resource", proto_isi, FT_UINT8, BASE_HEX); } /* Handler registration */ diff --git a/epan/dissectors/packet-isis.c b/epan/dissectors/packet-isis.c index ec21ce96fb..1096a81a7e 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", proto_isis, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "ISIS Type", proto_isis, FT_UINT8, BASE_DEC); } void diff --git a/epan/dissectors/packet-iso14443.c b/epan/dissectors/packet-iso14443.c index 5f4cb1a398..5fd063c140 100644 --- a/epan/dissectors/packet-iso14443.c +++ b/epan/dissectors/packet-iso14443.c @@ -1619,7 +1619,7 @@ proto_register_iso14443(void) iso14443_cmd_type_table = register_dissector_table( "iso14443.cmd_type", "ISO14443 Command Type", - proto_iso14443, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + proto_iso14443, FT_UINT8, BASE_DEC); iso14443_handle = register_dissector("iso14443", dissect_iso14443, proto_iso14443); diff --git a/epan/dissectors/packet-iso15765.c b/epan/dissectors/packet-iso15765.c index 38b21a5643..d33d014c27 100644 --- a/epan/dissectors/packet-iso15765.c +++ b/epan/dissectors/packet-iso15765.c @@ -602,7 +602,7 @@ proto_register_iso15765(void) subdissector_table = register_dissector_table("iso15765.subdissector", "ISO15765 next level dissector", proto_iso15765, - FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + FT_UINT32, BASE_HEX); iso15765_module = prefs_register_protocol(proto_iso15765, NULL); diff --git a/epan/dissectors/packet-j1939.c b/epan/dissectors/packet-j1939.c index 87dde191c6..192e3a6a2e 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", proto_j1939, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + subdissector_pgn_table = register_dissector_table("j1939.pgn", "PGN Handle", proto_j1939, FT_UINT32, BASE_DEC); j1939_address_type = address_type_dissector_register("AT_J1939", "J1939 Address", J1939_addr_to_str, J1939_addr_str_len, NULL, J1939_col_filter_str, J1939_addr_len, NULL, NULL); } diff --git a/epan/dissectors/packet-juniper.c b/epan/dissectors/packet-juniper.c index 037ff6ed5e..d03379dfdc 100644 --- a/epan/dissectors/packet-juniper.c +++ b/epan/dissectors/packet-juniper.c @@ -1550,7 +1550,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", proto_juniper, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + payload_table = register_dissector_table("juniper.proto", "Juniper payload dissectors", proto_juniper, FT_UINT32, BASE_HEX); } diff --git a/epan/dissectors/packet-kdsp.c b/epan/dissectors/packet-kdsp.c index 9e2ad1b2e0..8f429098c4 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", proto_kdsp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + subdissector_dlt_table = register_dissector_table("kdsp.cpt.dlt", "KDSP DLT Type", proto_kdsp, FT_UINT32, BASE_DEC); 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 9036e73904..97efd2e92e 100644 --- a/epan/dissectors/packet-l2tp.c +++ b/epan/dissectors/packet-l2tp.c @@ -3734,8 +3734,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", proto_l2tp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - pw_type_table = register_dissector_table("l2tp.pw_type", "L2TPv3 payload type", proto_l2tp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + l2tp_vendor_avp_dissector_table = register_dissector_table("l2tp.vendor_avp", "L2TP vendor AVP dissector table", proto_l2tp, FT_UINT32, BASE_DEC); + pw_type_table = register_dissector_table("l2tp.pw_type", "L2TPv3 payload type", proto_l2tp, FT_UINT32, BASE_DEC); l2tp_module = prefs_register_protocol(proto_l2tp, NULL); diff --git a/epan/dissectors/packet-lapd.c b/epan/dissectors/packet-lapd.c index 2f887fd8fc..5f91173504 100644 --- a/epan/dissectors/packet-lapd.c +++ b/epan/dissectors/packet-lapd.c @@ -714,10 +714,10 @@ proto_register_lapd(void) lapd_bitstream_handle = register_dissector("lapd-bitstream", dissect_lapd_bitstream, proto_lapd); lapd_sapi_dissector_table = register_dissector_table("lapd.sapi", - "LAPD SAPI", proto_lapd, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "LAPD SAPI", proto_lapd, FT_UINT16, BASE_DEC); lapd_gsm_sapi_dissector_table = register_dissector_table("lapd.gsm.sapi", - "LAPD GSM SAPI", proto_lapd, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "LAPD GSM SAPI", proto_lapd, FT_UINT16, BASE_DEC); 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 a9a6550c3d..c5abe86982 100644 --- a/epan/dissectors/packet-lapdm.c +++ b/epan/dissectors/packet-lapdm.c @@ -514,7 +514,7 @@ proto_register_lapdm(void) register_dissector("lapdm", dissect_lapdm, proto_lapdm); - lapdm_sapi_dissector_table = register_dissector_table("lapdm.sapi", "LAPDm SAPI", proto_lapdm, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + lapdm_sapi_dissector_table = register_dissector_table("lapdm.sapi", "LAPDm SAPI", proto_lapdm, FT_UINT8, BASE_DEC); 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 b69d45fd77..97cd2ee130 100644 --- a/epan/dissectors/packet-lapsat.c +++ b/epan/dissectors/packet-lapsat.c @@ -762,7 +762,7 @@ proto_register_lapsat(void) register_dissector("lapsat", dissect_lapsat, proto_lapsat); - lapsat_sapi_dissector_table = register_dissector_table("lapsat.sapi", "LAPSat SAPI", proto_lapsat, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + lapsat_sapi_dissector_table = register_dissector_table("lapsat.sapi", "LAPSat SAPI", proto_lapsat, FT_UINT8, BASE_DEC); 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 d710ea4902..37efe6025c 100644 --- a/epan/dissectors/packet-lcsap.c +++ b/epan/dissectors/packet-lcsap.c @@ -3043,15 +3043,15 @@ void proto_register_lcsap(void) { lcsap_handle = register_dissector("lcsap", dissect_lcsap, proto_lcsap); /* Register dissector tables */ - lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", proto_lcsap, FT_UINT32, BASE_DEC); expert_lcsap = expert_register_protocol(proto_lcsap); expert_register_field_array(expert_lcsap, ei, array_length(ei)); - lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", proto_lcsap, FT_UINT32, BASE_DEC); + lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lcsap, FT_UINT32, BASE_DEC); + lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC); + lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC); /* 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 1cc9021dd6..2606dc1c9b 100644 --- a/epan/dissectors/packet-ldap.c +++ b/epan/dissectors/packet-ldap.c @@ -5789,7 +5789,7 @@ void proto_register_ldap(void) { ldap_tap=register_tap("ldap"); - ldap_name_dissector_table = register_dissector_table("ldap.name", "LDAP Attribute Type Dissectors", proto_cldap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ldap_name_dissector_table = register_dissector_table("ldap.name", "LDAP Attribute Type Dissectors", proto_cldap, FT_STRING, BASE_NONE); register_srt_table(proto_ldap, NULL, 1, ldapstat_packet, ldapstat_init, NULL); } diff --git a/epan/dissectors/packet-llc.c b/epan/dissectors/packet-llc.c index 79c6c593d7..8b7db4b1cb 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, proto, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + table_ui_name, proto, FT_UINT16, BASE_HEX); new_info->field_info = hf_item; /* @@ -813,9 +813,9 @@ proto_register_llc(void) /* subdissector code */ dsap_subdissector_table = register_dissector_table("llc.dsap", - "LLC SAP", proto_llc, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "LLC SAP", proto_llc, FT_UINT8, BASE_HEX); xid_subdissector_table = register_dissector_table("llc.xid_dsap", - "LLC XID SAP", proto_llc, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "LLC XID SAP", proto_llc, FT_UINT8, BASE_HEX); register_capture_dissector_table("llc.dsap", "LLC"); register_dissector("llc", dissect_llc, proto_llc); diff --git a/epan/dissectors/packet-lldp.c b/epan/dissectors/packet-lldp.c index da416b3c0d..adc52ad935 100644 --- a/epan/dissectors/packet-lldp.c +++ b/epan/dissectors/packet-lldp.c @@ -5226,7 +5226,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", proto_lldp, FT_UINT24, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE ); + oui_unique_code_table = register_dissector_table("lldp.orgtlv.oui", "LLDP OUI", proto_lldp, FT_UINT24, BASE_HEX ); 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 b43a22d413..31413003b8 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", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lppa_proc_imsg_dissector_table = register_dissector_table("lppa.proc.imsg", "LPPA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lppa_proc_sout_dissector_table = register_dissector_table("lppa.proc.sout", "LPPA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lppa_proc_uout_dissector_table = register_dissector_table("lppa.proc.uout", "LPPA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_ies_dissector_table = register_dissector_table("lppa.ies", "LPPA-PROTOCOL-IES", proto_lppa, FT_UINT32, BASE_DEC); + lppa_proc_imsg_dissector_table = register_dissector_table("lppa.proc.imsg", "LPPA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lppa, FT_UINT32, BASE_DEC); + lppa_proc_sout_dissector_table = register_dissector_table("lppa.proc.sout", "LPPA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC); + lppa_proc_uout_dissector_table = register_dissector_table("lppa.proc.uout", "LPPA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC); } /*--- proto_reg_handoff_lppa ---------------------------------------*/ diff --git a/epan/dissectors/packet-m3ap.c b/epan/dissectors/packet-m3ap.c index ce20fffe37..705296ce0c 100644 --- a/epan/dissectors/packet-m3ap.c +++ b/epan/dissectors/packet-m3ap.c @@ -2542,11 +2542,11 @@ void proto_register_m3ap(void) { expert_register_field_array(expert_m3ap, ei, array_length(ei)); /* Register dissector tables */ - m3ap_ies_dissector_table = register_dissector_table("m3ap.ies", "M3AP-PROTOCOL-IES", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_extension_dissector_table = register_dissector_table("m3ap.extension", "M3AP-PROTOCOL-EXTENSION", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_proc_imsg_dissector_table = register_dissector_table("m3ap.proc.imsg", "M3AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_proc_sout_dissector_table = register_dissector_table("m3ap.proc.sout", "M3AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_proc_uout_dissector_table = register_dissector_table("m3ap.proc.uout", "M3AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_ies_dissector_table = register_dissector_table("m3ap.ies", "M3AP-PROTOCOL-IES", proto_m3ap, FT_UINT32, BASE_DEC); + m3ap_extension_dissector_table = register_dissector_table("m3ap.extension", "M3AP-PROTOCOL-EXTENSION", proto_m3ap, FT_UINT32, BASE_DEC); + m3ap_proc_imsg_dissector_table = register_dissector_table("m3ap.proc.imsg", "M3AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_m3ap, FT_UINT32, BASE_DEC); + m3ap_proc_sout_dissector_table = register_dissector_table("m3ap.proc.sout", "M3AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC); + m3ap_proc_uout_dissector_table = register_dissector_table("m3ap.proc.uout", "M3AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC); } diff --git a/epan/dissectors/packet-mbim.c b/epan/dissectors/packet-mbim.c index 23fdf087f7..b50712d7b0 100644 --- a/epan/dissectors/packet-mbim.c +++ b/epan/dissectors/packet-mbim.c @@ -9606,7 +9606,7 @@ proto_register_mbim(void) register_dissector("mbim.descriptor", dissect_mbim_descriptor, proto_mbim); register_dissector("mbim.bulk", dissect_mbim_bulk, proto_mbim); dss_dissector_table = register_dissector_table("mbim.dss_session_id", - "MBIM DSS Session Id", proto_mbim, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "MBIM DSS Session Id", proto_mbim, FT_UINT8, BASE_DEC); 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 56296521e0..da11c9f8f4 100644 --- a/epan/dissectors/packet-mbtcp.c +++ b/epan/dissectors/packet-mbtcp.c @@ -1972,8 +1972,8 @@ proto_register_modbus(void) mbudp_handle = register_dissector("mbudp", dissect_mbudp, proto_mbudp); /* Registering subdissectors table */ - modbus_data_dissector_table = register_dissector_table("modbus.data", "Modbus Data", proto_modbus, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - modbus_dissector_table = register_dissector_table("mbtcp.prot_id", "Modbus/TCP protocol identifier", proto_mbtcp, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + modbus_data_dissector_table = register_dissector_table("modbus.data", "Modbus Data", proto_modbus, FT_STRING, BASE_NONE); + modbus_dissector_table = register_dissector_table("mbtcp.prot_id", "Modbus/TCP protocol identifier", proto_mbtcp, FT_UINT16, BASE_DEC); /* 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 76e3850666..197af34077 100644 --- a/epan/dissectors/packet-meta.c +++ b/epan/dissectors/packet-meta.c @@ -797,7 +797,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", proto_meta, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "META protocol", proto_meta, FT_UINT16, BASE_DEC); } void diff --git a/epan/dissectors/packet-mip.c b/epan/dissectors/packet-mip.c index 5f61009bb0..ee8b2c3668 100644 --- a/epan/dissectors/packet-mip.c +++ b/epan/dissectors/packet-mip.c @@ -1471,7 +1471,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", proto_mip, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "MIP Normal Vendor/Organization Specific Extension", proto_mip, FT_UINT32, BASE_DEC); } void diff --git a/epan/dissectors/packet-mip6.c b/epan/dissectors/packet-mip6.c index cd0dae319a..b5d42fd08a 100644 --- a/epan/dissectors/packet-mip6.c +++ b/epan/dissectors/packet-mip6.c @@ -5426,7 +5426,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", proto_mip6, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + mip6_vsm_dissector_table = register_dissector_table("mip6.vsm", "Mobile IPv6 vendor specific option", proto_mip6, FT_UINT32, BASE_DEC); } void diff --git a/epan/dissectors/packet-moldudp64.c b/epan/dissectors/packet-moldudp64.c index c8ea55412a..37b8e65cdb 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", proto_moldudp64, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + moldudp64_payload_table = register_dissector_table("moldudp64.payload", "MoldUDP64 Payload", proto_moldudp64, FT_UINT32, BASE_DEC); /* 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 12af8aaf5b..d799ed2167 100644 --- a/epan/dissectors/packet-mpeg-sect.c +++ b/epan/dissectors/packet-mpeg-sect.c @@ -369,7 +369,7 @@ proto_register_mpeg_sect(void) mpeg_sect_tid_dissector_table = register_dissector_table("mpeg_sect.tid", "MPEG SECT Table ID", - proto_mpeg_sect, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_mpeg_sect, FT_UINT8, BASE_HEX); } diff --git a/epan/dissectors/packet-mpls.c b/epan/dissectors/packet-mpls.c index 8ae02e25e9..519d617d04 100644 --- a/epan/dissectors/packet-mpls.c +++ b/epan/dissectors/packet-mpls.c @@ -604,9 +604,9 @@ proto_register_mpls(void) /* FF: mpls subdissector table is indexed by label */ mpls_subdissector_table = register_dissector_table("mpls.label", "MPLS protocol", - proto_mpls, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_mpls, FT_UINT32, BASE_DEC); - pw_ach_subdissector_table = register_dissector_table("pwach.channel_type", "PW Associated Channel Type", proto_pw_ach, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + pw_ach_subdissector_table = register_dissector_table("pwach.channel_type", "PW Associated Channel Type", proto_pw_ach, FT_UINT16, BASE_HEX); module_mpls = prefs_register_protocol( proto_mpls, NULL ); diff --git a/epan/dissectors/packet-mstp.c b/epan/dissectors/packet-mstp.c index 5b3c3a842f..b64831da22 100644 --- a/epan/dissectors/packet-mstp.c +++ b/epan/dissectors/packet-mstp.c @@ -397,7 +397,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", proto_mstp, FT_UINT24, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "MSTP Vendor specific Frametypes", proto_mstp, FT_UINT24, BASE_DEC); /* 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, NULL, mstp_col_filter_str, mstp_len, NULL, NULL); diff --git a/epan/dissectors/packet-mtp3.c b/epan/dissectors/packet-mtp3.c index 5897edd01d..dc12d27376 100644 --- a/epan/dissectors/packet-mtp3.c +++ b/epan/dissectors/packet-mtp3.c @@ -1075,7 +1075,7 @@ proto_register_mtp3(void) mtp3_sio_dissector_table = register_dissector_table("mtp3.service_indicator", "MTP3 Service indicator", - proto_mtp3, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_mtp3, FT_UINT8, BASE_HEX); mtp3_address_type = address_type_dissector_register("AT_SS7PC", "SS7 Point Code", mtp3_addr_to_str, mtp3_str_addr_len, NULL, NULL, mtp3_addr_len, NULL, NULL); diff --git a/epan/dissectors/packet-multipart.c b/epan/dissectors/packet-multipart.c index 05b96f5fd0..1c0e30ef6d 100644 --- a/epan/dissectors/packet-multipart.c +++ b/epan/dissectors/packet-multipart.c @@ -1079,7 +1079,7 @@ proto_register_multipart(void) multipart_media_subdissector_table = register_dissector_table( "multipart_media_type", "Internet media type (for multipart processing)", - proto_multipart, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_multipart, FT_STRING, BASE_NONE); } diff --git a/epan/dissectors/packet-nbap.c b/epan/dissectors/packet-nbap.c index 8284bceae5..132e57e335 100644 --- a/epan/dissectors/packet-nbap.c +++ b/epan/dissectors/packet-nbap.c @@ -70172,11 +70172,11 @@ void proto_register_nbap(void) } /* Register dissector tables */ - nbap_ies_dissector_table = register_dissector_table("nbap.ies", "NBAP-PROTOCOL-IES", proto_nbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_extension_dissector_table = register_dissector_table("nbap.extension", "NBAP-PROTOCOL-EXTENSION", proto_nbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_proc_imsg_dissector_table = register_dissector_table("nbap.proc.imsg", "NBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_nbap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_proc_sout_dissector_table = register_dissector_table("nbap.proc.sout", "NBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_proc_uout_dissector_table = register_dissector_table("nbap.proc.uout", "NBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_ies_dissector_table = register_dissector_table("nbap.ies", "NBAP-PROTOCOL-IES", proto_nbap, FT_UINT32, BASE_DEC); + nbap_extension_dissector_table = register_dissector_table("nbap.extension", "NBAP-PROTOCOL-EXTENSION", proto_nbap, FT_UINT32, BASE_DEC); + nbap_proc_imsg_dissector_table = register_dissector_table("nbap.proc.imsg", "NBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_nbap, FT_STRING, BASE_NONE); + nbap_proc_sout_dissector_table = register_dissector_table("nbap.proc.sout", "NBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE); + nbap_proc_uout_dissector_table = register_dissector_table("nbap.proc.uout", "NBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE); register_init_routine(nbap_init); } diff --git a/epan/dissectors/packet-netlink.c b/epan/dissectors/packet-netlink.c index 09a41a2cbb..db002f0a75 100644 --- a/epan/dissectors/packet-netlink.c +++ b/epan/dissectors/packet-netlink.c @@ -531,7 +531,7 @@ proto_register_netlink(void) "netlink.protocol", "Linux netlink protocol type", proto_netlink, FT_UINT16, - BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE + BASE_HEX ); register_dissector("netlink", dissect_netlink, proto_netlink); } diff --git a/epan/dissectors/packet-nfs.c b/epan/dissectors/packet-nfs.c index 9b0eb6cb5a..0cf59d3b1a 100644 --- a/epan/dissectors/packet-nfs.c +++ b/epan/dissectors/packet-nfs.c @@ -13981,7 +13981,7 @@ proto_register_nfs(void) &display_major_nfs4_ops); nfs_fhandle_table = register_dissector_table("nfs_fhandle.type", - "NFS Filehandle types", proto_nfs, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "NFS Filehandle types", proto_nfs, FT_UINT8, BASE_HEX); prefs_register_obsolete_preference(nfs_module, "default_fhandle_type"); diff --git a/epan/dissectors/packet-null.c b/epan/dissectors/packet-null.c index e2d3b31579..448a2a653a 100644 --- a/epan/dissectors/packet-null.c +++ b/epan/dissectors/packet-null.c @@ -525,7 +525,7 @@ proto_register_null(void) /* subdissector code */ null_dissector_table = register_dissector_table("null.type", - "Null type", proto_null, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Null type", proto_null, FT_UINT32, BASE_DEC); } void diff --git a/epan/dissectors/packet-obex.c b/epan/dissectors/packet-obex.c index 9ef9202378..35e9190879 100644 --- a/epan/dissectors/packet-obex.c +++ b/epan/dissectors/packet-obex.c @@ -3825,7 +3825,7 @@ proto_register_obex(void) obex_handle = register_dissector("obex", dissect_obex, proto_obex); - obex_profile_table = register_dissector_table("obex.profile", "OBEX Profile", proto_obex, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + obex_profile_table = register_dissector_table("obex.profile", "OBEX Profile", proto_obex, FT_UINT8, BASE_DEC); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_obex, hf, array_length(hf)); diff --git a/epan/dissectors/packet-osi.c b/epan/dissectors/packet-osi.c index abfeb42567..7d7868c37d 100644 --- a/epan/dissectors/packet-osi.c +++ b/epan/dissectors/packet-osi.c @@ -560,13 +560,13 @@ proto_register_osi(void) should register here */ osinl_incl_subdissector_table = register_dissector_table("osinl.incl", - "OSI incl NLPID", proto_osi, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "OSI incl NLPID", proto_osi, FT_UINT8, BASE_HEX); /* 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", proto_osi, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "OSI excl NLPID", proto_osi, FT_UINT8, BASE_HEX); /* Preferences how OSI protocols should be dissected */ osi_module = prefs_register_protocol(proto_osi, proto_reg_handoff_osi); diff --git a/epan/dissectors/packet-p1.c b/epan/dissectors/packet-p1.c index 855237aebd..4666b4e884 100644 --- a/epan/dissectors/packet-p1.c +++ b/epan/dissectors/packet-p1.c @@ -11113,9 +11113,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", proto_p1, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", proto_p1, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", proto_p1, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + p1_extension_dissector_table = register_dissector_table("p1.extension", "P1-EXTENSION", proto_p1, FT_UINT32, BASE_DEC); + p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", proto_p1, FT_UINT32, BASE_DEC); + p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", proto_p1, FT_UINT32, BASE_DEC); /* Register our configuration options for P1, particularly our port */ diff --git a/epan/dissectors/packet-pcap.c b/epan/dissectors/packet-pcap.c index 7bd19a35e7..906d6d5d17 100644 --- a/epan/dissectors/packet-pcap.c +++ b/epan/dissectors/packet-pcap.c @@ -18720,14 +18720,14 @@ void proto_register_pcap(void) { pcap_handle = register_dissector("pcap", dissect_pcap, proto_pcap); /* Register dissector tables */ - pcap_ies_dissector_table = register_dissector_table("pcap.ies", "PCAP-PROTOCOL-IES", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_ies_p1_dissector_table = register_dissector_table("pcap.ies.pair.first", "PCAP-PROTOCOL-IES-PAIR FirstValue", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_ies_p2_dissector_table = register_dissector_table("pcap.ies.pair.second", "PCAP-PROTOCOL-IES-PAIR SecondValue", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_extension_dissector_table = register_dissector_table("pcap.extension", "PCAP-PROTOCOL-EXTENSION", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_imsg_dissector_table = register_dissector_table("pcap.proc.imsg", "PCAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_sout_dissector_table = register_dissector_table("pcap.proc.sout", "PCAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_uout_dissector_table = register_dissector_table("pcap.proc.uout", "PCAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_out_dissector_table = register_dissector_table("pcap.proc.out", "PCAP-ELEMENTARY-PROCEDURE Outcome", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_ies_dissector_table = register_dissector_table("pcap.ies", "PCAP-PROTOCOL-IES", proto_pcap, FT_UINT32, BASE_DEC); + pcap_ies_p1_dissector_table = register_dissector_table("pcap.ies.pair.first", "PCAP-PROTOCOL-IES-PAIR FirstValue", proto_pcap, FT_UINT32, BASE_DEC); + pcap_ies_p2_dissector_table = register_dissector_table("pcap.ies.pair.second", "PCAP-PROTOCOL-IES-PAIR SecondValue", proto_pcap, FT_UINT32, BASE_DEC); + pcap_extension_dissector_table = register_dissector_table("pcap.extension", "PCAP-PROTOCOL-EXTENSION", proto_pcap, FT_UINT32, BASE_DEC); + pcap_proc_imsg_dissector_table = register_dissector_table("pcap.proc.imsg", "PCAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_pcap, FT_UINT32, BASE_DEC); + pcap_proc_sout_dissector_table = register_dissector_table("pcap.proc.sout", "PCAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC); + pcap_proc_uout_dissector_table = register_dissector_table("pcap.proc.uout", "PCAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC); + pcap_proc_out_dissector_table = register_dissector_table("pcap.proc.out", "PCAP-ELEMENTARY-PROCEDURE Outcome", proto_pcap, FT_UINT32, BASE_DEC); /* Preferences */ diff --git a/epan/dissectors/packet-pcapng_block.c b/epan/dissectors/packet-pcapng_block.c index 31b83309f8..f139f8303c 100644 --- a/epan/dissectors/packet-pcapng_block.c +++ b/epan/dissectors/packet-pcapng_block.c @@ -59,7 +59,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", proto_pcapng_block, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "pcap-ng block type", proto_pcapng_block, FT_UINT32, BASE_DEC); } void diff --git a/epan/dissectors/packet-pcli.c b/epan/dissectors/packet-pcli.c index c015aaf9a5..3f2611bbad 100644 --- a/epan/dissectors/packet-pcli.c +++ b/epan/dissectors/packet-pcli.c @@ -269,7 +269,7 @@ proto_register_pcli(void) pcli_subdissector_table = register_dissector_table( "pcli.payload", "PCLI payload dissector", - proto_pcli, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_pcli, FT_UINT32, BASE_DEC); register_decode_as(&pcli_payload_da); } diff --git a/epan/dissectors/packet-per.c b/epan/dissectors/packet-per.c index 979033accd..d498aa29bf 100644 --- a/epan/dissectors/packet-per.c +++ b/epan/dissectors/packet-per.c @@ -2728,7 +2728,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", proto_per, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + per_oid_dissector_table = register_dissector_table("per.oid", "PER OID Dissectors", proto_per, FT_STRING, BASE_NONE); } diff --git a/epan/dissectors/packet-pgm.c b/epan/dissectors/packet-pgm.c index 254ee615ed..d261ee09a8 100644 --- a/epan/dissectors/packet-pgm.c +++ b/epan/dissectors/packet-pgm.c @@ -1393,7 +1393,7 @@ proto_register_pgm(void) /* subdissector code */ subdissector_table = register_dissector_table("pgm.port", - "PGM port", proto_pgm, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "PGM port", proto_pgm, FT_UINT16, BASE_DEC); heur_subdissector_list = register_heur_dissector_list("pgm", proto_pgm); /* diff --git a/epan/dissectors/packet-ppp.c b/epan/dissectors/packet-ppp.c index 5e6e2b1863..f7384984be 100644 --- a/epan/dissectors/packet-ppp.c +++ b/epan/dissectors/packet-ppp.c @@ -5920,7 +5920,7 @@ proto_register_ppp(void) /* subdissector code */ ppp_subdissector_table = register_dissector_table("ppp.protocol", - "PPP protocol", proto_ppp, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "PPP protocol", proto_ppp, FT_UINT16, BASE_HEX); 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 69901a50c7..bbcf0841e2 100644 --- a/epan/dissectors/packet-q931.c +++ b/epan/dissectors/packet-q931.c @@ -3974,8 +3974,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", proto_q931, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ie_dissector_table = register_dissector_table("q931.ie", "Q.931 IE", proto_q931, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + codeset_dissector_table = register_dissector_table("q931.codeset", "Q.931 Codeset", proto_q931, FT_UINT8, BASE_HEX); + ie_dissector_table = register_dissector_table("q931.ie", "Q.931 IE", proto_q931, FT_UINT16, BASE_HEX); q931_user_heur_subdissector_list = register_heur_dissector_list("q931_user", proto_q931); q931_module = prefs_register_protocol(proto_q931, NULL); diff --git a/epan/dissectors/packet-q932.c b/epan/dissectors/packet-q932.c index 054864a439..16fbcda682 100644 --- a/epan/dissectors/packet-q932.c +++ b/epan/dissectors/packet-q932.c @@ -1096,17 +1096,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)", proto_q932, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - q932_rose_ctx.res_global_dissector_table = register_dissector_table("q932.ros.global.res", "Q.932 Operation Result (global opcode)", proto_q932, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - q932_rose_ctx.err_global_dissector_table = register_dissector_table("q932.ros.global.err", "Q.932 Error (global opcode)", proto_q932, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + q932_rose_ctx.arg_global_dissector_table = register_dissector_table("q932.ros.global.arg", "Q.932 Operation Argument (global opcode)", proto_q932, FT_STRING, BASE_NONE); + q932_rose_ctx.res_global_dissector_table = register_dissector_table("q932.ros.global.res", "Q.932 Operation Result (global opcode)", proto_q932, FT_STRING, BASE_NONE); + q932_rose_ctx.err_global_dissector_table = register_dissector_table("q932.ros.global.err", "Q.932 Error (global opcode)", proto_q932, FT_STRING, BASE_NONE); - qsig_arg_local_dissector_table = register_dissector_table("q932.ros.local.arg", "Q.932 Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - qsig_res_local_dissector_table = register_dissector_table("q932.ros.local.res", "Q.932 Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - qsig_err_local_dissector_table = register_dissector_table("q932.ros.local.err", "Q.932 Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + qsig_arg_local_dissector_table = register_dissector_table("q932.ros.local.arg", "Q.932 Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX); + qsig_res_local_dissector_table = register_dissector_table("q932.ros.local.res", "Q.932 Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX); + qsig_err_local_dissector_table = register_dissector_table("q932.ros.local.err", "Q.932 Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX); - etsi_arg_local_dissector_table = register_dissector_table("q932.ros.etsi.local.arg", "Q.932 ETSI Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - etsi_res_local_dissector_table = register_dissector_table("q932.ros.etsi.local.res", "Q.932 ETSI Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - etsi_err_local_dissector_table = register_dissector_table("q932.ros.etsi.local.err", "Q.932 ETSI Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + etsi_arg_local_dissector_table = register_dissector_table("q932.ros.etsi.local.arg", "Q.932 ETSI Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX); + etsi_res_local_dissector_table = register_dissector_table("q932.ros.etsi.local.res", "Q.932 ETSI Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX); + etsi_err_local_dissector_table = register_dissector_table("q932.ros.etsi.local.err", "Q.932 ETSI Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX); q932_module = prefs_register_protocol(proto_q932, proto_reg_handoff_q932); diff --git a/epan/dissectors/packet-qsig.c b/epan/dissectors/packet-qsig.c index 14165b1092..9613b66f71 100644 --- a/epan/dissectors/packet-qsig.c +++ b/epan/dissectors/packet-qsig.c @@ -16382,7 +16382,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", proto_qsig, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + extension_dissector_table = register_dissector_table("qsig.ext", "QSIG Extension", proto_qsig, FT_STRING, BASE_NONE); qsig_init_tables(); } diff --git a/epan/dissectors/packet-raknet.c b/epan/dissectors/packet-raknet.c index 8657612cc5..f4a01af433 100644 --- a/epan/dissectors/packet-raknet.c +++ b/epan/dissectors/packet-raknet.c @@ -645,7 +645,7 @@ proto_register_raknet(void) raknet_dissector_table = register_dissector_table("raknet.packet_id", "RakNet libs packet ids", - proto_raknet, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + proto_raknet, FT_UINT8, BASE_HEX); /* * Raknet subdissector for use by external protocols. */ diff --git a/epan/dissectors/packet-ranap.c b/epan/dissectors/packet-ranap.c index b6d33ac898..9987ca94aa 100644 --- a/epan/dissectors/packet-ranap.c +++ b/epan/dissectors/packet-ranap.c @@ -16516,16 +16516,16 @@ void proto_register_ranap(void) { ranap_handle = register_dissector("ranap", dissect_ranap, proto_ranap); /* Register dissector tables */ - ranap_ies_dissector_table = register_dissector_table("ranap.ies", "RANAP-PROTOCOL-IES", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_ies_p1_dissector_table = register_dissector_table("ranap.ies.pair.first", "RANAP-PROTOCOL-IES-PAIR FirstValue", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_ies_p2_dissector_table = register_dissector_table("ranap.ies.pair.second", "RANAP-PROTOCOL-IES-PAIR SecondValue", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_extension_dissector_table = register_dissector_table("ranap.extension", "RANAP-PROTOCOL-EXTENSION", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_imsg_dissector_table = register_dissector_table("ranap.proc.imsg", "RANAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_sout_dissector_table = register_dissector_table("ranap.proc.sout", "RANAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_uout_dissector_table = register_dissector_table("ranap.proc.uout", "RANAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_out_dissector_table = register_dissector_table("ranap.proc.out", "RANAP-ELEMENTARY-PROCEDURE Outcome", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - - nas_pdu_dissector_table = register_dissector_table("ranap.nas_pdu", "RANAP NAS PDU", proto_ranap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_ies_dissector_table = register_dissector_table("ranap.ies", "RANAP-PROTOCOL-IES", proto_ranap, FT_UINT32, BASE_DEC); + ranap_ies_p1_dissector_table = register_dissector_table("ranap.ies.pair.first", "RANAP-PROTOCOL-IES-PAIR FirstValue", proto_ranap, FT_UINT32, BASE_DEC); + ranap_ies_p2_dissector_table = register_dissector_table("ranap.ies.pair.second", "RANAP-PROTOCOL-IES-PAIR SecondValue", proto_ranap, FT_UINT32, BASE_DEC); + ranap_extension_dissector_table = register_dissector_table("ranap.extension", "RANAP-PROTOCOL-EXTENSION", proto_ranap, FT_UINT32, BASE_DEC); + ranap_proc_imsg_dissector_table = register_dissector_table("ranap.proc.imsg", "RANAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_ranap, FT_UINT32, BASE_DEC); + ranap_proc_sout_dissector_table = register_dissector_table("ranap.proc.sout", "RANAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC); + ranap_proc_uout_dissector_table = register_dissector_table("ranap.proc.uout", "RANAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC); + ranap_proc_out_dissector_table = register_dissector_table("ranap.proc.out", "RANAP-ELEMENTARY-PROCEDURE Outcome", proto_ranap, FT_UINT32, BASE_DEC); + + nas_pdu_dissector_table = register_dissector_table("ranap.nas_pdu", "RANAP NAS PDU", proto_ranap, FT_UINT8, BASE_DEC); ranap_module = prefs_register_protocol(proto_ranap, proto_reg_handoff_ranap); 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 910c91765d..2df5acd1bb 100644 --- a/epan/dissectors/packet-rmcp.c +++ b/epan/dissectors/packet-rmcp.c @@ -223,7 +223,7 @@ proto_register_rmcp(void) proto_register_subtree_array(ett, array_length(ett)); rmcp_dissector_table = register_dissector_table( - "rmcp.class", "RMCP Class", proto_rmcp, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "rmcp.class", "RMCP Class", proto_rmcp, FT_UINT8, BASE_HEX); } void diff --git a/epan/dissectors/packet-rnsap.c b/epan/dissectors/packet-rnsap.c index 59a507b3ba..9dda4d7dce 100644 --- a/epan/dissectors/packet-rnsap.c +++ b/epan/dissectors/packet-rnsap.c @@ -62954,11 +62954,11 @@ void proto_register_rnsap(void) { rnsap_handle = register_dissector("rnsap", dissect_rnsap, proto_rnsap); /* Register dissector tables */ - rnsap_ies_dissector_table = register_dissector_table("rnsap.ies", "RNSAP-PROTOCOL-IES", proto_rnsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_extension_dissector_table = register_dissector_table("rnsap.extension", "RNSAP-PROTOCOL-EXTENSION", proto_rnsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_proc_imsg_dissector_table = register_dissector_table("rnsap.proc.imsg", "RNSAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rnsap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_proc_sout_dissector_table = register_dissector_table("rnsap.proc.sout", "RNSAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_proc_uout_dissector_table = register_dissector_table("rnsap.proc.uout", "RNSAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_ies_dissector_table = register_dissector_table("rnsap.ies", "RNSAP-PROTOCOL-IES", proto_rnsap, FT_UINT32, BASE_DEC); + rnsap_extension_dissector_table = register_dissector_table("rnsap.extension", "RNSAP-PROTOCOL-EXTENSION", proto_rnsap, FT_UINT32, BASE_DEC); + rnsap_proc_imsg_dissector_table = register_dissector_table("rnsap.proc.imsg", "RNSAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rnsap, FT_STRING, BASE_NONE); + rnsap_proc_sout_dissector_table = register_dissector_table("rnsap.proc.sout", "RNSAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE); + rnsap_proc_uout_dissector_table = register_dissector_table("rnsap.proc.uout", "RNSAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE); } diff --git a/epan/dissectors/packet-ros.c b/epan/dissectors/packet-ros.c index 128d40bdd7..1d68c5b188 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", proto_ros, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + ros_oid_dissector_table = register_dissector_table("ros.oid", "ROS OID Dissectors", proto_ros, FT_STRING, BASE_NONE); oid_table=g_hash_table_new(g_str_hash, g_str_equal); 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 caeaae61b2..77d10c2718 100644 --- a/epan/dissectors/packet-rpc.c +++ b/epan/dissectors/packet-rpc.c @@ -4360,8 +4360,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", proto_rpc, rpc_proc_hash, rpc_proc_equal, DISSECTOR_TABLE_ALLOW_DUPLICATE); - subdissector_reply_table = register_custom_dissector_table("rpc.reply", "RPC Reply Functions", proto_rpc, rpc_proc_hash, rpc_proc_equal, DISSECTOR_TABLE_ALLOW_DUPLICATE); + subdissector_call_table = register_custom_dissector_table("rpc.call", "RPC Call Functions", proto_rpc, rpc_proc_hash, rpc_proc_equal); + subdissector_reply_table = register_custom_dissector_table("rpc.reply", "RPC Reply Functions", proto_rpc, rpc_proc_hash, rpc_proc_equal); /* 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 7b99337e6a..7030f0fff9 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 */ rtacser_handle = register_dissector("rtacser", dissect_rtacser, proto_rtacser); - subdissector_table = register_dissector_table("rtacser.data", "RTAC Serial Data Subdissector", proto_rtacser, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + subdissector_table = register_dissector_table("rtacser.data", "RTAC Serial Data Subdissector", proto_rtacser, FT_UINT32, BASE_HEX); /* 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 2f3650f2b9..d991e22aa4 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", proto_rtcp, 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", proto_rtcp, 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", proto_rtcp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + rtcp_dissector_table = register_dissector_table("rtcp.app.name", "RTCP Application Name", proto_rtcp, FT_STRING, BASE_NONE); + rtcp_psfb_dissector_table = register_dissector_table("rtcp.psfb.fmt", "RTCP Payload Specific Feedback Message Format", proto_rtcp, FT_UINT8, BASE_DEC); + rtcp_rtpfb_dissector_table = register_dissector_table("rtcp.rtpfb.fmt", "RTCP Generic RTP Feedback Message Format", proto_rtcp, FT_UINT8, BASE_DEC); } void diff --git a/epan/dissectors/packet-rtp.c b/epan/dissectors/packet-rtp.c index 53a2107460..9868e08df8 100644 --- a/epan/dissectors/packet-rtp.c +++ b/epan/dissectors/packet-rtp.c @@ -3670,15 +3670,15 @@ proto_register_rtp(void) rtp_tap = register_tap("rtp"); rtp_pt_dissector_table = register_dissector_table("rtp.pt", - "RTP payload type", proto_rtp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "RTP payload type", proto_rtp, FT_UINT8, BASE_DEC); rtp_dyn_pt_dissector_table = register_dissector_table("rtp_dyn_payload_type", - "Dynamic RTP payload type", proto_rtp, FT_STRING, TRUE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "Dynamic RTP payload type", proto_rtp, FT_STRING, TRUE); rtp_hdr_ext_dissector_table = register_dissector_table("rtp.hdr_ext", - "RTP header extension", proto_rtp, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "RTP header extension", proto_rtp, FT_UINT32, BASE_HEX); rtp_hdr_ext_rfc5285_dissector_table = register_dissector_table("rtp.ext.rfc5285.id", - "RTP Generic header extension (RFC 5285)", proto_rtp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "RTP Generic header extension (RFC 5285)", proto_rtp, FT_UINT8, BASE_DEC); 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-rtps.c b/epan/dissectors/packet-rtps.c index 6272a52cfc..4f925c5bb9 100644 --- a/epan/dissectors/packet-rtps.c +++ b/epan/dissectors/packet-rtps.c @@ -11627,7 +11627,7 @@ void proto_register_rtps(void) { register_init_routine(rtps_init); rtps_type_name_table = register_dissector_table("rtps.type_name", "RTPS Type Name", - proto_rtps, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + proto_rtps, FT_STRING, BASE_NONE); } diff --git a/epan/dissectors/packet-rtse.c b/epan/dissectors/packet-rtse.c index 8e783be177..915b3ba05b 100644 --- a/epan/dissectors/packet-rtse.c +++ b/epan/dissectors/packet-rtse.c @@ -1063,7 +1063,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", proto_rtse, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + rtse_oid_dissector_table = register_dissector_table("rtse.oid", "RTSE OID Dissectors", proto_rtse, FT_STRING, BASE_NONE); oid_table=g_hash_table_new(g_str_hash, g_str_equal); diff --git a/epan/dissectors/packet-rua.c b/epan/dissectors/packet-rua.c index 8ab8fd173e..458ad8d708 100644 --- a/epan/dissectors/packet-rua.c +++ b/epan/dissectors/packet-rua.c @@ -1744,11 +1744,11 @@ module_t *rua_module; rua_handle = register_dissector("rua", dissect_rua, proto_rua); /* Register dissector tables */ - rua_ies_dissector_table = register_dissector_table("rua.ies", "RUA-PROTOCOL-IES", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_ies_dissector_table = register_dissector_table("rua.ies", "RUA-PROTOCOL-IES", proto_rua, FT_UINT32, BASE_DEC); + rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", proto_rua, FT_UINT32, BASE_DEC); + rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rua, FT_UINT32, BASE_DEC); + rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC); + rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC); rua_module = prefs_register_protocol(proto_rua, proto_reg_handoff_rua); 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 b342de0de5..224173e4e4 100644 --- a/epan/dissectors/packet-s1ap.c +++ b/epan/dissectors/packet-s1ap.c @@ -16224,13 +16224,13 @@ void proto_register_s1ap(void) { s1ap_handle = register_dissector("s1ap", dissect_s1ap, proto_s1ap); /* Register dissector tables */ - s1ap_ies_dissector_table = register_dissector_table("s1ap.ies", "S1AP-PROTOCOL-IES", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_ies_p1_dissector_table = register_dissector_table("s1ap.ies.pair.first", "S1AP-PROTOCOL-IES-PAIR FirstValue", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_ies_p2_dissector_table = register_dissector_table("s1ap.ies.pair.second", "S1AP-PROTOCOL-IES-PAIR SecondValue", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_ies_dissector_table = register_dissector_table("s1ap.ies", "S1AP-PROTOCOL-IES", proto_s1ap, FT_UINT32, BASE_DEC); + s1ap_ies_p1_dissector_table = register_dissector_table("s1ap.ies.pair.first", "S1AP-PROTOCOL-IES-PAIR FirstValue", proto_s1ap, FT_UINT32, BASE_DEC); + s1ap_ies_p2_dissector_table = register_dissector_table("s1ap.ies.pair.second", "S1AP-PROTOCOL-IES-PAIR SecondValue", proto_s1ap, FT_UINT32, BASE_DEC); + s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", proto_s1ap, FT_UINT32, BASE_DEC); + s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_s1ap, FT_UINT32, BASE_DEC); + s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC); + s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC); /* Register configuration options for ports */ 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 65fe8e65bf..fc69b13d3d 100644 --- a/epan/dissectors/packet-s5066sis.c +++ b/epan/dissectors/packet-s5066sis.c @@ -1446,7 +1446,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", proto_s5066, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + s5066sis_dissector_table = register_dissector_table("s5066sis.ctl.appid", "STANAG 5066 Application Identifier", proto_s5066, FT_UINT16, BASE_DEC); } diff --git a/epan/dissectors/packet-sabp.c b/epan/dissectors/packet-sabp.c index f729fcc41f..6f81d37bb3 100644 --- a/epan/dissectors/packet-sabp.c +++ b/epan/dissectors/packet-sabp.c @@ -2276,11 +2276,11 @@ void proto_register_sabp(void) { sabp_tcp_handle = register_dissector("sabp.tcp", dissect_sabp_tcp, proto_sabp); /* Register dissector tables */ - sabp_ies_dissector_table = register_dissector_table("sabp.ies", "SABP-PROTOCOL-IES", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_extension_dissector_table = register_dissector_table("sabp.extension", "SABP-PROTOCOL-EXTENSION", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_proc_imsg_dissector_table = register_dissector_table("sabp.proc.imsg", "SABP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_proc_sout_dissector_table = register_dissector_table("sabp.proc.sout", "SABP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_proc_uout_dissector_table = register_dissector_table("sabp.proc.uout", "SABP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_ies_dissector_table = register_dissector_table("sabp.ies", "SABP-PROTOCOL-IES", proto_sabp, FT_UINT32, BASE_DEC); + sabp_extension_dissector_table = register_dissector_table("sabp.extension", "SABP-PROTOCOL-EXTENSION", proto_sabp, FT_UINT32, BASE_DEC); + sabp_proc_imsg_dissector_table = register_dissector_table("sabp.proc.imsg", "SABP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sabp, FT_UINT32, BASE_DEC); + sabp_proc_sout_dissector_table = register_dissector_table("sabp.proc.sout", "SABP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC); + sabp_proc_uout_dissector_table = register_dissector_table("sabp.proc.uout", "SABP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC); } diff --git a/epan/dissectors/packet-sbc-ap.c b/epan/dissectors/packet-sbc-ap.c index 0cc5368f5b..e7e6fcfd25 100644 --- a/epan/dissectors/packet-sbc-ap.c +++ b/epan/dissectors/packet-sbc-ap.c @@ -1459,11 +1459,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", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_extension_dissector_table = register_dissector_table("sbc_ap.extension", "SBC-AP-PROTOCOL-EXTENSION", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_proc_imsg_dissector_table = register_dissector_table("sbc_ap.proc.imsg", "SBC-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_proc_sout_dissector_table = register_dissector_table("sbc_ap.proc.sout", "SBC-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_proc_uout_dissector_table = register_dissector_table("sbc_ap.proc.uout", "SBC-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sbc_ap_ies_dissector_table = register_dissector_table("sbc_ap.ies", "SBC-AP-PROTOCOL-IES", proto_sbc_ap, FT_UINT32, BASE_DEC); + sbc_ap_extension_dissector_table = register_dissector_table("sbc_ap.extension", "SBC-AP-PROTOCOL-EXTENSION", proto_sbc_ap, FT_UINT32, BASE_DEC); + sbc_ap_proc_imsg_dissector_table = register_dissector_table("sbc_ap.proc.imsg", "SBC-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sbc_ap, FT_UINT32, BASE_DEC); + sbc_ap_proc_sout_dissector_table = register_dissector_table("sbc_ap.proc.sout", "SBC-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC); + sbc_ap_proc_uout_dissector_table = register_dissector_table("sbc_ap.proc.uout", "SBC-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC); } diff --git a/epan/dissectors/packet-sccp.c b/epan/dissectors/packet-sccp.c index 803bf58f43..80ca6c29f9 100644 --- a/epan/dissectors/packet-sccp.c +++ b/epan/dissectors/packet-sccp.c @@ -4090,7 +4090,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", proto_sccp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + sccp_ssn_dissector_table = register_dissector_table("sccp.ssn", "SCCP SSN", proto_sccp, FT_UINT8, BASE_DEC); heur_subdissector_list = register_heur_dissector_list("sccp", proto_sccp); diff --git a/epan/dissectors/packet-scte35.c b/epan/dissectors/packet-scte35.c index 30977f403d..0fe9974511 100644 --- a/epan/dissectors/packet-scte35.c +++ b/epan/dissectors/packet-scte35.c @@ -439,8 +439,7 @@ proto_register_scte35_private_command(void) /* Allow other modules to hook private commands and decode them. */ private_identifier_table = register_dissector_table( "scte35_private_command.identifier", "SCTE-35 Private Command Identifier", - proto_private_command, FT_UINT32, BASE_HEX, - DISSECTOR_TABLE_ALLOW_DUPLICATE); + proto_private_command, FT_UINT32, BASE_HEX); } void @@ -1508,7 +1507,7 @@ proto_register_scte35(void) */ scte35_cmd_dissector_table = register_dissector_table( "scte35.splice_command_type", "SCTE-35 Command", proto_scte35, FT_UINT8, - BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + BASE_HEX); } void diff --git a/epan/dissectors/packet-sctp.c b/epan/dissectors/packet-sctp.c index b145a1250e..2f5ebd1a50 100644 --- a/epan/dissectors/packet-sctp.c +++ b/epan/dissectors/packet-sctp.c @@ -5072,8 +5072,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", proto_sctp, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - sctp_ppi_dissector_table = register_dissector_table("sctp.ppi", "SCTP payload protocol identifier", proto_sctp, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + sctp_port_dissector_table = register_dissector_table("sctp.port", "SCTP port", proto_sctp, FT_UINT16, BASE_DEC); + sctp_ppi_dissector_table = register_dissector_table("sctp.ppi", "SCTP payload protocol identifier", proto_sctp, FT_UINT32, BASE_HEX); register_dissector("sctp", dissect_sctp, proto_sctp); sctp_heur_subdissector_list = register_heur_dissector_list("sctp", proto_sctp); diff --git a/epan/dissectors/packet-sdp.c b/epan/dissectors/packet-sdp.c index a950de2140..b51592406c 100644 --- a/epan/dissectors/packet-sdp.c +++ b/epan/dissectors/packet-sdp.c @@ -3058,7 +3058,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", proto_sdp, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Key Management", proto_sdp, FT_STRING, BASE_NONE); /* * Preferences registration */ diff --git a/epan/dissectors/packet-sflow.c b/epan/dissectors/packet-sflow.c index 6c9206db6f..5ea293c10c 100644 --- a/epan/dissectors/packet-sflow.c +++ b/epan/dissectors/packet-sflow.c @@ -3633,7 +3633,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", proto_sflow, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + header_subdissector_table = register_dissector_table("sflow_245.header_protocol", "SFLOW header protocol", proto_sflow, FT_UINT32, BASE_DEC); /* 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 1670b4cb13..2492b7773a 100644 --- a/epan/dissectors/packet-sip.c +++ b/epan/dissectors/packet-sip.c @@ -6692,7 +6692,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", proto_sip, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + ext_hdr_subdissector_table = register_dissector_table("sip.hdr", "SIP Extension header", proto_sip, FT_STRING, BASE_NONE); register_stat_tap_table_ui(&sip_stat_table); diff --git a/epan/dissectors/packet-sita.c b/epan/dissectors/packet-sita.c index 3fcc04b9dc..67466ea6d8 100644 --- a/epan/dissectors/packet-sita.c +++ b/epan/dissectors/packet-sita.c @@ -390,7 +390,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", proto_sita, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + sita_dissector_table = register_dissector_table("sita.proto", "SITA protocol number", proto_sita, FT_UINT8, BASE_HEX); 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 a3e75a4c3e..5098bbfcc9 100644 --- a/epan/dissectors/packet-sll.c +++ b/epan/dissectors/packet-sll.c @@ -338,7 +338,7 @@ proto_register_sll(void) "sll.ltype", "Linux SLL protocol type", proto_sll, FT_UINT16, - BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE + BASE_HEX ); register_capture_dissector_table("sll.ltype", "Linux SLL protocol"); register_decode_as(&sll_da); diff --git a/epan/dissectors/packet-slowprotocols.c b/epan/dissectors/packet-slowprotocols.c index c2f4b94951..f23602aea6 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", - proto_slow, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_slow, FT_UINT8, BASE_DEC); } void diff --git a/epan/dissectors/packet-snmp.c b/epan/dissectors/packet-snmp.c index 238c619afe..faf3f1128e 100644 --- a/epan/dissectors/packet-snmp.c +++ b/epan/dissectors/packet-snmp.c @@ -4064,7 +4064,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", proto_snmp, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + value_sub_dissectors_table = register_dissector_table("snmp.variable_oid","SNMP Variable OID", proto_snmp, FT_STRING, BASE_NONE); register_init_routine(init_ue_cache); register_cleanup_routine(cleanup_ue_cache); diff --git a/epan/dissectors/packet-socketcan.c b/epan/dissectors/packet-socketcan.c index d5aa554a61..1a917a5b28 100644 --- a/epan/dissectors/packet-socketcan.c +++ b/epan/dissectors/packet-socketcan.c @@ -264,7 +264,7 @@ proto_register_socketcan(void) proto_register_subtree_array(ett, array_length(ett)); subdissector_table = register_dissector_table("can.subdissector", - "CAN next level dissector", proto_can, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "CAN next level dissector", proto_can, FT_UINT32, BASE_HEX); can_module = prefs_register_protocol(proto_can, NULL); diff --git a/epan/dissectors/packet-spp.c b/epan/dissectors/packet-spp.c index cd6b6a40e9..c0c2ec595a 100644 --- a/epan/dissectors/packet-spp.c +++ b/epan/dissectors/packet-spp.c @@ -261,7 +261,7 @@ proto_register_spp(void) proto_register_subtree_array(ett, array_length(ett)); spp_socket_dissector_table = register_dissector_table("spp.socket", - "SPP socket", proto_spp, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "SPP socket", proto_spp, FT_UINT16, BASE_HEX); } void diff --git a/epan/dissectors/packet-ssl.c b/epan/dissectors/packet-ssl.c index 6d9c0fe4b7..573346b132 100644 --- a/epan/dissectors/packet-ssl.c +++ b/epan/dissectors/packet-ssl.c @@ -4145,7 +4145,7 @@ proto_register_ssl(void) proto_ssl = proto_register_protocol("Secure Sockets Layer", "SSL", "ssl"); - ssl_associations = register_dissector_table("ssl.port", "SSL TCP Dissector", proto_ssl, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + ssl_associations = register_dissector_table("ssl.port", "SSL TCP Dissector", proto_ssl, FT_UINT16, BASE_DEC); /* Required function calls to register the header fields and * subtrees used */ diff --git a/epan/dissectors/packet-sua.c b/epan/dissectors/packet-sua.c index 13bdab10ea..b547038336 100644 --- a/epan/dissectors/packet-sua.c +++ b/epan/dissectors/packet-sua.c @@ -2470,7 +2470,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", proto_sua); - sua_parameter_table = register_dissector_table("sua.prop.tags", "SUA Proprietary Tags", proto_sua, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sua_parameter_table = register_dissector_table("sua.prop.tags", "SUA Proprietary Tags", proto_sua, FT_UINT16, BASE_DEC); 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 f1467f972a..e35e7565e7 100644 --- a/epan/dissectors/packet-t124.c +++ b/epan/dissectors/packet-t124.c @@ -4012,8 +4012,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", proto_t124, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - t124_sd_dissector_table = register_dissector_table("t124.sd", "T.124 H.221 Send Data Dissectors", proto_t124, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + t124_ns_dissector_table = register_dissector_table("t124.ns", "T.124 H.221 Non Standard Dissectors", proto_t124, FT_STRING, BASE_NONE); + t124_sd_dissector_table = register_dissector_table("t124.sd", "T.124 H.221 Send Data Dissectors", proto_t124, FT_UINT32, BASE_HEX); register_dissector("t124", dissect_t124, proto_t124); diff --git a/epan/dissectors/packet-tali.c b/epan/dissectors/packet-tali.c index 97cbec2444..5ab6e8b1e1 100644 --- a/epan/dissectors/packet-tali.c +++ b/epan/dissectors/packet-tali.c @@ -208,7 +208,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", proto_tali, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + tali_dissector_table = register_dissector_table("tali.opcode", "Tali OPCODE", proto_tali, FT_STRING, BASE_NONE); 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 c493712149..befef7aa7b 100644 --- a/epan/dissectors/packet-tcp.c +++ b/epan/dissectors/packet-tcp.c @@ -7174,7 +7174,7 @@ proto_register_tcp(void) /* subdissector code */ subdissector_table = register_dissector_table("tcp.port", - "TCP port", proto_tcp, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "TCP port", proto_tcp, FT_UINT16, BASE_DEC); heur_subdissector_list = register_heur_dissector_list("tcp", proto_tcp); register_capture_dissector_table("tcp.port", "TCP"); diff --git a/epan/dissectors/packet-teredo.c b/epan/dissectors/packet-teredo.c index 13edd1b526..e4e86b5e00 100644 --- a/epan/dissectors/packet-teredo.c +++ b/epan/dissectors/packet-teredo.c @@ -384,7 +384,7 @@ proto_register_teredo(void) proto_register_subtree_array(ett, array_length(ett)); /* subdissector code */ - teredo_dissector_table = register_dissector_table("teredo", "Teredo", proto_teredo, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + teredo_dissector_table = register_dissector_table("teredo", "Teredo", proto_teredo, FT_UINT16, BASE_DEC); teredo_module = prefs_register_protocol(proto_teredo, NULL); diff --git a/epan/dissectors/packet-tipc.c b/epan/dissectors/packet-tipc.c index a627f3b708..71ad52f8ce 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", proto_tipc, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "TIPC user", proto_tipc, FT_UINT8, BASE_DEC); /* 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", proto_tipc, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "TIPC port name type", proto_tipc, FT_UINT32, BASE_DEC); /* make heuristic dissectors possible */ tipc_heur_subdissector_list = register_heur_dissector_list("tipc", proto_tipc); diff --git a/epan/dissectors/packet-ua.c b/epan/dissectors/packet-ua.c index 1ba74b264d..9a89e0c42c 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, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + BASE_HEX); #endif diff --git a/epan/dissectors/packet-uaudp.c b/epan/dissectors/packet-uaudp.c index 9f2321bb2c..a5bc3e7b80 100644 --- a/epan/dissectors/packet-uaudp.c +++ b/epan/dissectors/packet-uaudp.c @@ -619,7 +619,7 @@ void proto_reg_handoff_uaudp(void) register_dissector_table("uaudp.opcode", "UAUDP opcode", FT_UINT8, - BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + BASE_DEC); #endif prefs_initialized = TRUE; } diff --git a/epan/dissectors/packet-udp.c b/epan/dissectors/packet-udp.c index 937fd215aa..e3dee309ab 100644 --- a/epan/dissectors/packet-udp.c +++ b/epan/dissectors/packet-udp.c @@ -1219,7 +1219,7 @@ proto_register_udp(void) /* subdissector code */ udp_dissector_table = register_dissector_table("udp.port", - "UDP port", proto_udp, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "UDP port", proto_udp, FT_UINT16, BASE_DEC); heur_subdissector_list = register_heur_dissector_list("udp", proto_udp); register_capture_dissector_table("udp.port", "UDP"); diff --git a/epan/dissectors/packet-usb.c b/epan/dissectors/packet-usb.c index 9cac525630..7146da0b18 100644 --- a/epan/dissectors/packet-usb.c +++ b/epan/dissectors/packet-usb.c @@ -5286,21 +5286,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", proto_usb, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - protocol_to_dissector = register_dissector_table("usb.protocol", "USB protocol", proto_usb, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - product_to_dissector = register_dissector_table("usb.product", "USB product", proto_usb, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + device_to_dissector = register_dissector_table("usb.device", "USB device", proto_usb, FT_UINT32, BASE_HEX); + protocol_to_dissector = register_dissector_table("usb.protocol", "USB protocol", proto_usb, FT_UINT32, BASE_HEX); + product_to_dissector = register_dissector_table("usb.product", "USB product", proto_usb, FT_UINT32, BASE_HEX); usb_bulk_dissector_table = register_dissector_table("usb.bulk", - "USB bulk endpoint", proto_usb, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "USB bulk endpoint", proto_usb, FT_UINT8, BASE_DEC); heur_bulk_subdissector_list = register_heur_dissector_list("usb.bulk", proto_usb); usb_control_dissector_table = register_dissector_table("usb.control", - "USB control endpoint", proto_usb, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "USB control endpoint", proto_usb, FT_UINT8, BASE_DEC); heur_control_subdissector_list = register_heur_dissector_list("usb.control", proto_usb); usb_interrupt_dissector_table = register_dissector_table("usb.interrupt", - "USB interrupt endpoint", proto_usb, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "USB interrupt endpoint", proto_usb, FT_UINT8, BASE_DEC); heur_interrupt_subdissector_list = register_heur_dissector_list("usb.interrupt", proto_usb); usb_descriptor_dissector_table = register_dissector_table("usb.descriptor", - "USB descriptor", proto_usb, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "USB descriptor", proto_usb, FT_UINT8, BASE_DEC); 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 3a8161d86b..5ab4cdb2e3 100644 --- a/epan/dissectors/packet-vines.c +++ b/epan/dissectors/packet-vines.c @@ -494,7 +494,7 @@ proto_register_vines_llc(void) /* subdissector code */ vines_llc_dissector_table = register_dissector_table("vines_llc.ptype", - "Vines LLC protocol", proto_vines_llc, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Vines LLC protocol", proto_vines_llc, FT_UINT8, BASE_HEX); } void @@ -721,7 +721,7 @@ proto_register_vines_ip(void) /* subdissector code */ vines_ip_dissector_table = register_dissector_table("vines_ip.protocol", - "Vines protocol", proto_vines_ip, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Vines protocol", proto_vines_ip, FT_UINT8, BASE_HEX); vines_ip_handle = create_dissector_handle(dissect_vines_ip, proto_vines_ip); diff --git a/epan/dissectors/packet-vxlan.c b/epan/dissectors/packet-vxlan.c index 5150e679c1..dcb20bb8a4 100644 --- a/epan/dissectors/packet-vxlan.c +++ b/epan/dissectors/packet-vxlan.c @@ -283,7 +283,7 @@ proto_register_vxlan(void) /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_vxlan, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - vxlan_dissector_table = register_dissector_table("vxlan.next_proto", "VXLAN Next Protocol", proto_vxlan, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + vxlan_dissector_table = register_dissector_table("vxlan.next_proto", "VXLAN Next Protocol", proto_vxlan, FT_UINT8, BASE_DEC); } diff --git a/epan/dissectors/packet-websocket.c b/epan/dissectors/packet-websocket.c index 19579203d7..289775b952 100644 --- a/epan/dissectors/packet-websocket.c +++ b/epan/dissectors/packet-websocket.c @@ -539,10 +539,10 @@ proto_register_websocket(void) heur_subdissector_list = register_heur_dissector_list("ws", proto_websocket); port_subdissector_table = register_dissector_table("ws.port", - "TCP port for protocols using WebSocket", proto_websocket, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "TCP port for protocols using WebSocket", proto_websocket, FT_UINT16, BASE_DEC); protocol_subdissector_table = register_dissector_table("ws.protocol", - "Negotiated WebSocket protocol", proto_websocket, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Negotiated WebSocket protocol", proto_websocket, FT_STRING, BASE_NONE); 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 fc8924f737..64522064ed 100644 --- a/epan/dissectors/packet-x25.c +++ b/epan/dissectors/packet-x25.c @@ -2369,7 +2369,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", proto_x25, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "X.25 secondary protocol identifier", proto_x25, FT_UINT8, BASE_HEX); x25_heur_subdissector_list = register_heur_dissector_list("x.25", proto_x25); 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 3e24ac9168..f75842c7ed 100644 --- a/epan/dissectors/packet-x2ap.c +++ b/epan/dissectors/packet-x2ap.c @@ -7910,11 +7910,11 @@ void proto_register_x2ap(void) { x2ap_handle = register_dissector("x2ap", dissect_x2ap, proto_x2ap); /* Register dissector tables */ - x2ap_ies_dissector_table = register_dissector_table("x2ap.ies", "X2AP-PROTOCOL-IES", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_ies_dissector_table = register_dissector_table("x2ap.ies", "X2AP-PROTOCOL-IES", proto_x2ap, FT_UINT32, BASE_DEC); + x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", proto_x2ap, FT_UINT32, BASE_DEC); + x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_x2ap, FT_UINT32, BASE_DEC); + x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC); + x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC); /* Register configuration options for ports */ 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 0bb149aed3..5851ab105f 100644 --- a/epan/dissectors/packet-zbee-aps.c +++ b/epan/dissectors/packet-zbee-aps.c @@ -2149,7 +2149,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", proto_zbee_aps, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + zbee_aps_dissector_table = register_dissector_table("zbee.profile", "ZigBee Profile ID", proto_zbee_aps, FT_UINT16, BASE_HEX); zbee_aps_handle = 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 3f06c961ea..5e570eec52 100644 --- a/epan/dissectors/packet-zbee-zcl.c +++ b/epan/dissectors/packet-zbee-zcl.c @@ -2266,7 +2266,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", proto_zbee_zcl, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + zbee_zcl_dissector_table = register_dissector_table("zbee.zcl.cluster", "ZigBee ZCL Cluster ID", proto_zbee_zcl, FT_UINT16, BASE_HEX); register_dissector(ZBEE_PROTOABBREV_ZCL, dissect_zbee_zcl, proto_zbee_zcl); } /* proto_register_zbee_zcl */ |