diff options
author | David Perry <boolean263@protonmail.com> | 2023-09-19 14:12:28 -0400 |
---|---|---|
committer | AndersBroman <a.broman58@gmail.com> | 2023-09-19 19:06:51 +0000 |
commit | fb9d01556dbc28a507778f66cbaca234a55e6305 (patch) | |
tree | 6bd4e8351e33d1519492b96ae9baf69eef6ee678 | |
parent | d4f47c60b7eb12a84348d5c0228f6b5afd013660 (diff) |
Use `register_dissector()` for more protocols
Changes several calls of `create_dissector_handle()` to instead call
`register_dissector()` with a name for the dissector.
This should handle all dissectors in `epan/` from `packet-p*` to
`packet-v*`.
This change allows affected dissectors to be findable by calls to
`find_dissector()`. In turn, this opens up more command-line use for
these protocols, including fuzzshark and rawshark, as well as lua use
via `Dissector.get()`.
Where needed, move the call from the protocol handoff function to the
protocol register function, save the result in a static variable,
and use that variable in the handoff function.
There were some calls to `create_dissector_handle()` or
`register_dissector()` which passed `-1` as the protocol argument. When
I saw those I corrected them to pass the actual `proto_foo` identifier
instead.
Partially addresses #5612
148 files changed, 647 insertions, 592 deletions
diff --git a/epan/dissectors/packet-pa-hbbackup.c b/epan/dissectors/packet-pa-hbbackup.c index c930e8f293..b51bca5fcf 100644 --- a/epan/dissectors/packet-pa-hbbackup.c +++ b/epan/dissectors/packet-pa-hbbackup.c @@ -35,6 +35,7 @@ static int hf_hbbak_trailer = -1; static gint ett_hbbak = -1; +static dissector_handle_t hbbak_handle; static dissector_handle_t ethertype_handle; static int @@ -95,16 +96,15 @@ proto_register_hbbak(void) proto_hbbak = proto_register_protocol(PROTO_LONG_NAME, PROTO_LONG_NAME, "hbbak"); proto_register_field_array(proto_hbbak, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + hbbak_handle = register_dissector("hbbak", dissect_hbbak, proto_hbbak); } void proto_reg_handoff_hbbak(void) { - dissector_handle_t hbbak_handle; ethertype_handle = find_dissector_add_dependency("ethertype", proto_hbbak); - hbbak_handle = create_dissector_handle(dissect_hbbak, proto_hbbak); dissector_add_uint("ethertype", ETHERTYPE_PA_HBBACKUP, hbbak_handle); } diff --git a/epan/dissectors/packet-pagp.c b/epan/dissectors/packet-pagp.c index c46b8c7535..ca4474f026 100644 --- a/epan/dissectors/packet-pagp.c +++ b/epan/dissectors/packet-pagp.c @@ -22,6 +22,8 @@ void proto_register_pagp(void); void proto_reg_handoff_pagp(void); +static dissector_handle_t pagp_handle; + /* Offsets of fields within a PagP PDU */ #define PAGP_VERSION_NUMBER 0 @@ -471,15 +473,13 @@ proto_register_pagp(void) proto_register_subtree_array(ett, array_length(ett)); expert_pagp = expert_register_protocol(proto_pagp); expert_register_field_array(expert_pagp, ei, array_length(ei)); + pagp_handle = register_dissector("pagp", dissect_pagp, proto_pagp); } void proto_reg_handoff_pagp(void) { - dissector_handle_t pagp_handle; - - pagp_handle = create_dissector_handle(dissect_pagp, proto_pagp); dissector_add_uint("llc.cisco_pid", CISCO_PID_PAGP, pagp_handle); } diff --git a/epan/dissectors/packet-pana.c b/epan/dissectors/packet-pana.c index d8f52a464c..dc64b6822a 100644 --- a/epan/dissectors/packet-pana.c +++ b/epan/dissectors/packet-pana.c @@ -21,6 +21,8 @@ void proto_register_pana(void); void proto_reg_handoff_pana(void); +static dissector_handle_t pana_handle; + #if 0 #define PANA_UDP_PORT 3001 #endif @@ -864,18 +866,16 @@ proto_register_pana(void) proto_register_field_array(proto_pana, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + /* Register the dissector handle */ + pana_handle = register_dissector("pana", dissect_pana, proto_pana); } void proto_reg_handoff_pana(void) { - - dissector_handle_t pana_handle; - heur_dissector_add("udp", dissect_pana, "PANA over UDP", "pana_udp", proto_pana, HEURISTIC_ENABLE); - pana_handle = create_dissector_handle(dissect_pana, proto_pana); dissector_add_for_decode_as_with_preference("udp.port", pana_handle); eap_handle = find_dissector_add_dependency("eap", proto_pana); diff --git a/epan/dissectors/packet-pathport.c b/epan/dissectors/packet-pathport.c index 90f0b56b9b..1f0bc613bf 100644 --- a/epan/dissectors/packet-pathport.c +++ b/epan/dissectors/packet-pathport.c @@ -31,6 +31,8 @@ void proto_reg_handoff_pathport(void); void proto_register_pathport(void); +static dissector_handle_t pathport_handle; + /* Initialize the protocol and registered fields */ static int proto_pathport = -1; @@ -675,14 +677,14 @@ proto_register_pathport(void) /* Required function calls to register the header fields and subtrees */ proto_register_field_array(proto_pathport, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + /* Register the dissector handle */ + pathport_handle = register_dissector("pathport", dissect_pathport, proto_pathport); } void proto_reg_handoff_pathport(void) { - static dissector_handle_t pathport_handle; - - pathport_handle = create_dissector_handle(dissect_pathport, proto_pathport); heur_dissector_add("udp", dissect_pathport_heur, "Pathport over UDP", "pathport_udp", proto_pathport, HEURISTIC_ENABLE); dissector_add_uint_with_preference("udp.port", PATHPORT_UDP_PORT, pathport_handle); } diff --git a/epan/dissectors/packet-pcapng_block.c b/epan/dissectors/packet-pcapng_block.c index 3634bafbf4..424d54314c 100644 --- a/epan/dissectors/packet-pcapng_block.c +++ b/epan/dissectors/packet-pcapng_block.c @@ -17,6 +17,8 @@ void proto_register_pcapng_block(void); void proto_reg_handoff_pcapng_block(void); +static dissector_handle_t pcapng_block_handle; + static int proto_pcapng_block = -1; static dissector_table_t pcapng_block_type_dissector_table; @@ -48,15 +50,14 @@ void proto_register_pcapng_block(void) "PCAPNG", "pcapng"); pcapng_block_type_dissector_table = register_dissector_table("pcapng.block_type", "pcapng block type", proto_pcapng_block, FT_UINT32, BASE_DEC); + + pcapng_block_handle = register_dissector("pcapng", dissect_pcapng_block, + proto_pcapng_block); } void proto_reg_handoff_pcapng_block(void) { - dissector_handle_t pcapng_block_handle; - - pcapng_block_handle = create_dissector_handle(dissect_pcapng_block, - proto_pcapng_block); dissector_add_uint("wtap_fts_rec", wtap_pcapng_file_type_subtype(), pcapng_block_handle); } diff --git a/epan/dissectors/packet-pcep.c b/epan/dissectors/packet-pcep.c index 7bc2875d2b..ec037a32f2 100644 --- a/epan/dissectors/packet-pcep.c +++ b/epan/dissectors/packet-pcep.c @@ -67,6 +67,8 @@ void proto_register_pcep(void); void proto_reg_handoff_pcep(void); +static dissector_handle_t pcep_handle; + /* Object-Class */ #define PCEP_OPEN_OBJ 1 /* RFC 5440 */ #define PCEP_RP_OBJ 2 /* RFC 5440 */ @@ -6599,15 +6601,15 @@ proto_register_pcep(void) proto_register_subtree_array(ett, array_length(ett)); expert_pcep = expert_register_protocol(proto_pcep); expert_register_field_array(expert_pcep, ei, array_length(ei)); + + /* Register the dissector handle */ + pcep_handle = register_dissector("pcep", dissect_pcep, proto_pcep); } /*Dissector Handoff*/ void proto_reg_handoff_pcep(void) { - dissector_handle_t pcep_handle; - - pcep_handle = create_dissector_handle(dissect_pcep, proto_pcep); dissector_add_uint_with_preference("tcp.port", TCP_PORT_PCEP, pcep_handle); } diff --git a/epan/dissectors/packet-pcli.c b/epan/dissectors/packet-pcli.c index c629706bba..78da68a57d 100644 --- a/epan/dissectors/packet-pcli.c +++ b/epan/dissectors/packet-pcli.c @@ -60,6 +60,8 @@ void proto_register_pcli(void); void proto_reg_handoff_pcli(void); +static dissector_handle_t pcli_handle, pcli_handle8, pcli_handle12, pcli_handle20; + /* Define the pcli proto */ static int proto_pcli = -1; @@ -235,6 +237,12 @@ proto_register_pcli(void) pcli_subdissector_table = register_decode_as_next_proto(proto_pcli, "pcli.payload", "PCLI payload dissector", pcli_prompt); + + /* Register the dissector handles */ + pcli_handle = register_dissector("pcli", dissect_pcli, proto_pcli); + pcli_handle8 = register_dissector("pcli8", dissect_pcli8, proto_pcli8); + pcli_handle12 = register_dissector("pcli12", dissect_pcli12, proto_pcli12); + pcli_handle20 = register_dissector("pcli20", dissect_pcli20, proto_pcli20); } /* The registration hand-off routing */ @@ -242,13 +250,6 @@ proto_register_pcli(void) void proto_reg_handoff_pcli(void) { - dissector_handle_t pcli_handle, pcli_handle8, pcli_handle12, pcli_handle20; - - pcli_handle = create_dissector_handle(dissect_pcli, proto_pcli); - pcli_handle8 = create_dissector_handle(dissect_pcli8, proto_pcli8); - pcli_handle12 = create_dissector_handle(dissect_pcli12, proto_pcli12); - pcli_handle20 = create_dissector_handle(dissect_pcli20, proto_pcli20); - dissector_add_for_decode_as_with_preference("udp.port", pcli_handle); dissector_add_for_decode_as_with_preference("udp.port", pcli_handle8); dissector_add_for_decode_as_with_preference("udp.port", pcli_handle12); diff --git a/epan/dissectors/packet-pdc.c b/epan/dissectors/packet-pdc.c index 9dc0c28dc0..1bc4a5f272 100644 --- a/epan/dissectors/packet-pdc.c +++ b/epan/dissectors/packet-pdc.c @@ -40,6 +40,9 @@ void proto_reg_handoff_pdc(void); #define PDC_MSG_SIZE_FIELD_LENGTH 2 /* minimum amount of data to find out how big the split packet should be when recombined */ #define FRAME_HEADER_LEN 8 +/* global handle for our dissector */ +static dissector_handle_t pdc_tcp_handle; + /* global handle for calling asterix decoder if required */ static dissector_handle_t asterix_handle; @@ -563,16 +566,15 @@ void proto_register_pdc(void) /*Required Function Calls to register the header fields and subtrees used*/ proto_register_field_array(proto_pdc, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + /* Register our dissector handle */ + pdc_tcp_handle = register_dissector("pdc", tcp_dissect_pdc, proto_pdc); } /* Function to add pdc dissector to tcp.port dissector table and to get handle for asterix dissector */ void proto_reg_handoff_pdc(void) { - dissector_handle_t pdc_tcp_handle; - asterix_handle = find_dissector_add_dependency("asterix", proto_pdc); - pdc_tcp_handle = create_dissector_handle(tcp_dissect_pdc, proto_pdc); - dissector_add_for_decode_as_with_preference("tcp.port", pdc_tcp_handle); } diff --git a/epan/dissectors/packet-per.c b/epan/dissectors/packet-per.c index 49d13194ea..4a4ac7c859 100644 --- a/epan/dissectors/packet-per.c +++ b/epan/dissectors/packet-per.c @@ -2803,6 +2803,12 @@ register_per_oid_dissector(const char *oid, dissector_t dissector, int proto, co { dissector_handle_t dissector_handle; + /* FIXME: This would be better as register_dissector() + * so the dissector could be referenced by name + * from the command line, Lua, etc. + * But can we blindly trust name to be a unique dissector name, + * or should we prefix "per." or something? + */ dissector_handle = create_dissector_handle(dissector, proto); dissector_add_string("per.oid", oid, dissector_handle); oid_add_from_string(name, oid); diff --git a/epan/dissectors/packet-pflog.c b/epan/dissectors/packet-pflog.c index f592044fa5..fafb7f090e 100644 --- a/epan/dissectors/packet-pflog.c +++ b/epan/dissectors/packet-pflog.c @@ -56,6 +56,8 @@ void proto_reg_handoff_pflog(void); void proto_register_old_pflog(void); void proto_reg_handoff_old_pflog(void); +static dissector_handle_t old_pflog_handle; +static dissector_handle_t pflog_handle; static dissector_handle_t ip_handle, ipv6_handle; /* header fields */ @@ -528,6 +530,8 @@ proto_register_pflog(void) expert_pflog = expert_register_protocol(proto_pflog); expert_register_field_array(expert_pflog, ei, array_length(ei)); + pflog_handle = register_dissector("pflog", dissect_pflog, proto_pflog); + pflog_module = prefs_register_protocol(proto_pflog, NULL); prefs_register_enum_preference(pflog_module, "id_endian", @@ -540,12 +544,9 @@ proto_register_pflog(void) void proto_reg_handoff_pflog(void) { - dissector_handle_t pflog_handle; - ip_handle = find_dissector_add_dependency("ip", proto_pflog); ipv6_handle = find_dissector_add_dependency("ipv6", proto_pflog); - pflog_handle = create_dissector_handle(dissect_pflog, proto_pflog); dissector_add_uint("wtap_encap", WTAP_ENCAP_PFLOG, pflog_handle); } @@ -650,15 +651,14 @@ proto_register_old_pflog(void) "PFLOG-OLD", "pflog-old"); proto_register_field_array(proto_old_pflog, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + old_pflog_handle = register_dissector("pflog-old", dissect_old_pflog, proto_old_pflog); } void proto_reg_handoff_old_pflog(void) { - dissector_handle_t pflog_handle; - - pflog_handle = create_dissector_handle(dissect_old_pflog, proto_old_pflog); - dissector_add_uint("wtap_encap", WTAP_ENCAP_OLD_PFLOG, pflog_handle); + dissector_add_uint("wtap_encap", WTAP_ENCAP_OLD_PFLOG, old_pflog_handle); } /* * Editor modelines diff --git a/epan/dissectors/packet-pgm.c b/epan/dissectors/packet-pgm.c index af79ff5cd0..b8f14cc015 100644 --- a/epan/dissectors/packet-pgm.c +++ b/epan/dissectors/packet-pgm.c @@ -56,6 +56,8 @@ void proto_register_pgm(void); void proto_reg_handoff_pgm(void); +static dissector_handle_t pgm_handle; + /* * Flag to control whether to check the PGM checksum. */ @@ -1377,6 +1379,7 @@ proto_register_pgm(void) expert_register_field_array(expert_pgm, ei, array_length(ei)); /* subdissector code */ + pgm_handle = register_dissector("pgm", dissect_pgm, proto_pgm); subdissector_table = register_dissector_table("pgm.port", "PGM port", proto_pgm, FT_UINT16, BASE_DEC); heur_subdissector_list = register_heur_dissector_list("pgm", proto_pgm); @@ -1405,9 +1408,6 @@ proto_register_pgm(void) void proto_reg_handoff_pgm(void) { - dissector_handle_t pgm_handle; - - pgm_handle = create_dissector_handle(dissect_pgm, proto_pgm); dissector_add_uint_range_with_preference("udp.port", "", pgm_handle); dissector_add_uint("ip.proto", IP_PROTO_PGM, pgm_handle); } diff --git a/epan/dissectors/packet-pim.c b/epan/dissectors/packet-pim.c index a1d0a7e9c5..1277cbbd4c 100644 --- a/epan/dissectors/packet-pim.c +++ b/epan/dissectors/packet-pim.c @@ -322,6 +322,8 @@ static gint ett_pim_addr_flags = -1; static expert_field ei_pim_cksum = EI_INIT; +static dissector_handle_t pim_handle; +static dissector_handle_t pimv1_handle; static dissector_handle_t ip_handle; static dissector_handle_t ipv6_handle; @@ -2297,6 +2299,9 @@ proto_register_pim(void) expert_pim = expert_register_protocol(proto_pim); expert_register_field_array(expert_pim, ei, array_length(ei)); + pim_handle = register_dissector("pim", dissect_pim, proto_pim); + pimv1_handle = register_dissector("pimv1", dissect_pimv1, proto_pim); + pim_module = prefs_register_protocol(proto_pim, NULL); prefs_register_bool_preference(pim_module, "payload_tree", "PIM payload shown on main tree", @@ -2308,12 +2313,7 @@ proto_register_pim(void) void proto_reg_handoff_pim(void) { - dissector_handle_t pim_handle, pimv1_handle; - - pim_handle = create_dissector_handle(dissect_pim, proto_pim); dissector_add_uint("ip.proto", IP_PROTO_PIM, pim_handle); - - pimv1_handle = create_dissector_handle(dissect_pimv1, proto_pim); dissector_add_uint("igmp.type", IGMP_V1_PIM_ROUTING_MESSAGE, pimv1_handle); /* diff --git a/epan/dissectors/packet-pingpongprotocol.c b/epan/dissectors/packet-pingpongprotocol.c index 5362393c53..5a6d5c78c4 100644 --- a/epan/dissectors/packet-pingpongprotocol.c +++ b/epan/dissectors/packet-pingpongprotocol.c @@ -26,6 +26,8 @@ void proto_register_pingpongprotocol(void); void proto_reg_handoff_pingpongprotocol(void); +static dissector_handle_t pingpongprotocol_handle; + /* Initialize the protocol and registered fields */ static int proto_pingpongprotocol = -1; static int tap_pingpongprotocol = -1; @@ -433,15 +435,15 @@ proto_register_pingpongprotocol(void) proto_register_subtree_array(ett, array_length(ett)); tap_pingpongprotocol = register_tap("pingpongprotocol"); + /* Register the dissector handle */ + pingpongprotocol_handle = register_dissector("pingpongprotocol", dissect_pingpongprotocol, proto_pingpongprotocol); + register_stat_tap_table_ui(&pingpongprotocol_stat_table); } void proto_reg_handoff_pingpongprotocol(void) { - dissector_handle_t pingpongprotocol_handle; - - pingpongprotocol_handle = create_dissector_handle(dissect_pingpongprotocol, proto_pingpongprotocol); dissector_add_uint("sctp.ppi", PINGPONGPROTOCOL_PAYLOAD_PROTOCOL_ID_LEGACY, pingpongprotocol_handle); dissector_add_uint("sctp.ppi", PPP_PAYLOAD_PROTOCOL_ID, pingpongprotocol_handle); } diff --git a/epan/dissectors/packet-pktc.c b/epan/dissectors/packet-pktc.c index 44c8b4f83a..420ddcd1d1 100644 --- a/epan/dissectors/packet-pktc.c +++ b/epan/dissectors/packet-pktc.c @@ -36,6 +36,9 @@ void proto_reg_handoff_pktc(void); void proto_register_pktc_mtafqdn(void); void proto_reg_handoff_pktc_mtafqdn(void); +static dissector_handle_t pktc_handle; +static dissector_handle_t pktc_mtafqdn_handle; + static int proto_pktc = -1; static int proto_pktc_mtafqdn = -1; static gint hf_pktc_app_spec_data = -1; @@ -735,14 +738,13 @@ proto_register_pktc(void) proto_pktc = proto_register_protocol("PacketCable", "PKTC", "pktc"); proto_register_field_array(proto_pktc, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + pktc_handle = register_dissector("pktc", dissect_pktc, proto_pktc); } void proto_reg_handoff_pktc(void) { - dissector_handle_t pktc_handle; - - pktc_handle = create_dissector_handle(dissect_pktc, proto_pktc); dissector_add_uint_with_preference("udp.port", PKTC_PORT, pktc_handle); } @@ -796,14 +798,13 @@ proto_register_pktc_mtafqdn(void) proto_register_subtree_array(ett, array_length(ett)); expert_pktc = expert_register_protocol(proto_pktc_mtafqdn); expert_register_field_array(expert_pktc, ei, array_length(ei)); + + pktc_mtafqdn_handle = register_dissector("pktc.mtafqdn", dissect_pktc_mtafqdn, proto_pktc_mtafqdn); } void proto_reg_handoff_pktc_mtafqdn(void) { - dissector_handle_t pktc_mtafqdn_handle; - - pktc_mtafqdn_handle = create_dissector_handle(dissect_pktc_mtafqdn, proto_pktc_mtafqdn); dissector_add_uint_with_preference("udp.port", PKTC_MTAFQDN_PORT, pktc_mtafqdn_handle); } diff --git a/epan/dissectors/packet-pmproxy.c b/epan/dissectors/packet-pmproxy.c index d645d7eb87..5843f8092a 100644 --- a/epan/dissectors/packet-pmproxy.c +++ b/epan/dissectors/packet-pmproxy.c @@ -239,12 +239,13 @@ void proto_register_pmproxy(void) { proto_register_field_array(proto_pmproxy, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + pmproxy_handle = register_dissector("pmproxy", dissect_pmproxy, proto_pmproxy); } void proto_reg_handoff_pmproxy(void) { - pmproxy_handle = create_dissector_handle(dissect_pmproxy, proto_pmproxy); pcp_handle = find_dissector_add_dependency("pcp", proto_pmproxy); dissector_add_uint_with_preference("tcp.port", PMPROXY_PORT, pmproxy_handle); diff --git a/epan/dissectors/packet-pnrp.c b/epan/dissectors/packet-pnrp.c index 9e8d7d73a4..f97cf9b9fa 100644 --- a/epan/dissectors/packet-pnrp.c +++ b/epan/dissectors/packet-pnrp.c @@ -96,6 +96,8 @@ void proto_register_pnrp(void); void proto_reg_handoff_pnrp(void); +static dissector_handle_t pnrp_handle; + /* Define all helper methods */ static void dissect_pnrp_ids(tvbuff_t *tvb, gint offset, gint length, proto_tree *tree); static void dissect_ipv6_address(tvbuff_t *tvb, gint offset, gint length, proto_tree *tree); @@ -1459,6 +1461,8 @@ void proto_register_pnrp(void) proto_register_field_array(proto_pnrp,hf,array_length(hf)); proto_register_subtree_array (ett, array_length(ett)); + pnrp_handle = register_dissector(PROTOABBREV, dissect_pnrp, proto_pnrp); + reassembly_table_register(&pnrp_reassembly_table, &addresses_reassembly_table_functions); } @@ -1466,8 +1470,6 @@ void proto_register_pnrp(void) /* Initialise the dissector */ void proto_reg_handoff_pnrp(void) { - dissector_handle_t pnrp_handle; - pnrp_handle = create_dissector_handle(dissect_pnrp, proto_pnrp); dissector_add_uint_with_preference("udp.port",PNRP_PORT,pnrp_handle); } diff --git a/epan/dissectors/packet-pppoe.c b/epan/dissectors/packet-pppoe.c index b773cfa6bb..e0b54a95c7 100644 --- a/epan/dissectors/packet-pppoe.c +++ b/epan/dissectors/packet-pppoe.c @@ -24,6 +24,9 @@ void proto_register_pppoes(void); void proto_register_pppoe(void); void proto_reg_handoff_pppoes(void); +static dissector_handle_t pppoed_handle; +static dissector_handle_t pppoes_handle; + static int proto_pppoed = -1; /* Common to session and discovery protocols */ @@ -1010,6 +1013,9 @@ void proto_register_pppoed(void) proto_register_subtree_array(ett, array_length(ett)); proto_register_field_array(proto_pppoed, hf, array_length(hf)); + /* Register dissector handle */ + pppoed_handle = register_dissector("pppoed", dissect_pppoed, proto_pppoed); + /* Preference setting */ pppoed_module = prefs_register_protocol(proto_pppoed, NULL); prefs_register_bool_preference(pppoed_module, "show_tags_and_lengths", @@ -1020,9 +1026,6 @@ void proto_register_pppoed(void) void proto_reg_handoff_pppoed(void) { - dissector_handle_t pppoed_handle; - - pppoed_handle = create_dissector_handle(dissect_pppoed, proto_pppoed); dissector_add_uint("ethertype", ETHERTYPE_PPPOED, pppoed_handle); } @@ -1225,6 +1228,8 @@ void proto_register_pppoes(void) proto_register_subtree_array(ett, array_length(ett)); proto_register_field_array(proto_pppoes, hf, array_length(hf)); + + pppoes_handle = register_dissector("pppoes", dissect_pppoes, proto_pppoes); } void proto_register_pppoe(void) @@ -1282,8 +1287,6 @@ void proto_register_pppoe(void) void proto_reg_handoff_pppoes(void) { - dissector_handle_t pppoes_handle = - create_dissector_handle(dissect_pppoes, proto_pppoes); dissector_add_uint("ethertype", ETHERTYPE_PPPOES, pppoes_handle); dissector_add_uint("wtap_encap", WTAP_ENCAP_PPP_ETHER, pppoes_handle); diff --git a/epan/dissectors/packet-ptpip.c b/epan/dissectors/packet-ptpip.c index 2e273881e1..6e5f7e523b 100644 --- a/epan/dissectors/packet-ptpip.c +++ b/epan/dissectors/packet-ptpip.c @@ -75,6 +75,8 @@ static void dissect_ptpIP_guid (tvbuff_t *tvb, packet_info *pinf void proto_register_ptpip( void ); void proto_reg_handoff_ptpIP( void ); +static dissector_handle_t ptpIP_handle; + typedef enum { PTP_VENDOR_UNKNOWN = 0, PTP_VENDOR_EASTMAN_KODAK = 1, @@ -1090,6 +1092,12 @@ void proto_register_ptpip( void ) proto_register_field_array(proto_ptpIP, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + /* Use register_dissector() to indicate that dissect_ptpIP() + * returns the number of bytes it dissected (or 0 if it thinks the packet + * does not belong to PROTONAME). + */ + ptpIP_handle = register_dissector("ptpip", dissect_ptpIP, proto_ptpIP); + ptpIP_module = prefs_register_protocol(proto_ptpIP, NULL); prefs_register_enum_preference(ptpIP_module, "vendor", @@ -1100,15 +1108,6 @@ void proto_register_ptpip( void ) } void proto_reg_handoff_ptpIP( void ) { - - dissector_handle_t ptpIP_handle; - - /* Use create_dissector_handle() to indicate that dissect_ptpIP() - * returns the number of bytes it dissected (or 0 if it thinks the packet - * does not belong to PROTONAME). - */ - - ptpIP_handle = create_dissector_handle(dissect_ptpIP, proto_ptpIP); dissector_add_uint_with_preference("tcp.port", PTPIP_PORT, ptpIP_handle); } diff --git a/epan/dissectors/packet-pulse.c b/epan/dissectors/packet-pulse.c index 93a946d8ea..29388b1c29 100644 --- a/epan/dissectors/packet-pulse.c +++ b/epan/dissectors/packet-pulse.c @@ -23,6 +23,8 @@ void proto_register_pulse(void); void proto_reg_handoff_pulse(void); +static dissector_handle_t pulse_handle; + static int proto_pulse = -1; static int hf_pulse_magic = -1; static gint ett_pulse = -1; @@ -93,13 +95,13 @@ proto_register_pulse(void) proto_pulse = proto_register_protocol("PULSE protocol for Linux Virtual Server redundancy", "PULSE", "pulse"); proto_register_field_array(proto_pulse, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + pulse_handle = register_dissector("pulse", dissect_pulse, proto_pulse); } void proto_reg_handoff_pulse(void) { - dissector_handle_t pulse_handle; - pulse_handle = create_dissector_handle(dissect_pulse, proto_pulse); dissector_add_uint_with_preference("udp.port", PORT_PULSE, pulse_handle); } diff --git a/epan/dissectors/packet-pw-cesopsn.c b/epan/dissectors/packet-pw-cesopsn.c index c41626035c..b5f58ae86a 100644 --- a/epan/dissectors/packet-pw-cesopsn.c +++ b/epan/dissectors/packet-pw-cesopsn.c @@ -52,6 +52,7 @@ static expert_field ei_packet_size_too_small = EI_INIT; static dissector_handle_t pw_padding_handle; static dissector_handle_t pw_cesopsn_udp_handle; +static dissector_handle_t pw_cesopsn_mpls_handle; const char pwc_longname_pw_cesopsn[] = "CESoPSN basic NxDS0 mode (no RTP support)"; @@ -433,19 +434,16 @@ void proto_register_pw_cesopsn(void) proto_register_subtree_array(ett_array, array_length(ett_array)); expert_pwcesopsn = expert_register_protocol(proto); expert_register_field_array(expert_pwcesopsn, ei, array_length(ei)); - register_dissector("pw_cesopsn_mpls", dissect_pw_cesopsn_mpls, proto); + pw_cesopsn_mpls_handle = register_dissector("pw_cesopsn_mpls", dissect_pw_cesopsn_mpls, proto); pw_cesopsn_udp_handle = register_dissector("pw_cesopsn_udp", dissect_pw_cesopsn_udp, proto); } void proto_reg_handoff_pw_cesopsn(void) { - dissector_handle_t pw_cesopsn_mpls_handle; - pw_padding_handle = find_dissector_add_dependency("pw_padding", proto); /* For Decode As */ - pw_cesopsn_mpls_handle = create_dissector_handle( dissect_pw_cesopsn_mpls, proto ); dissector_add_for_decode_as("mpls.label", pw_cesopsn_mpls_handle); dissector_add_for_decode_as_with_preference("udp.port", pw_cesopsn_udp_handle); diff --git a/epan/dissectors/packet-pw-oam.c b/epan/dissectors/packet-pw-oam.c index 776eaca4d6..dfbfe614f6 100644 --- a/epan/dissectors/packet-pw-oam.c +++ b/epan/dissectors/packet-pw-oam.c @@ -19,6 +19,8 @@ void proto_register_pw_oam(void); void proto_reg_handoff_pw_oam(void); +static dissector_handle_t pw_oam_handle; + /* MPLS-TP FM protocol specific variables */ static gint proto_pw_oam = -1; static gint ett_pw_oam = -1; @@ -188,14 +190,13 @@ proto_register_pw_oam(void) proto_register_field_array (proto_pw_oam, hf, array_length(hf)); proto_register_subtree_array (ett, array_length(ett)); + + pw_oam_handle = register_dissector ("pw_oam", dissect_pw_oam, proto_pw_oam); } void proto_reg_handoff_pw_oam(void) { - dissector_handle_t pw_oam_handle; - - pw_oam_handle = create_dissector_handle( dissect_pw_oam, proto_pw_oam ); dissector_add_uint("pwach.channel_type", PW_ACH_TYPE_PW_OAM, pw_oam_handle); } diff --git a/epan/dissectors/packet-qnet6.c b/epan/dissectors/packet-qnet6.c index 06360b4f24..e081b9e04b 100644 --- a/epan/dissectors/packet-qnet6.c +++ b/epan/dissectors/packet-qnet6.c @@ -22,6 +22,8 @@ void proto_reg_handoff_qnet6(void); void proto_register_qnet6(void); +static dissector_handle_t qnet6_handle; + static int proto_qnet6_l4 = -1; static int proto_qnet6_qos = -1; static int proto_qnet6_lr = -1; @@ -5952,6 +5954,9 @@ proto_register_qnet6(void) proto_qnet6_nr = proto_register_protocol("QNX6 QNET Network Resolver protocol", "NR", "nr"); + /* Register the dissector handle */ + qnet6_handle = register_dissector("lwl4", dissect_qnet6, proto_qnet6_l4); + /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_qnet6_l4, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); @@ -5980,9 +5985,6 @@ proto_register_qnet6(void) void proto_reg_handoff_qnet6(void) { - dissector_handle_t qnet6_handle; - - qnet6_handle = create_dissector_handle(dissect_qnet6, proto_qnet6_l4); dissector_add_uint("ethertype", ETHERTYPE_QNX_QNET6, qnet6_handle); dissector_add_uint("ip.proto", IP_PROTO_QNX, qnet6_handle); } diff --git a/epan/dissectors/packet-quake.c b/epan/dissectors/packet-quake.c index b48c46e12d..ea9e559101 100644 --- a/epan/dissectors/packet-quake.c +++ b/epan/dissectors/packet-quake.c @@ -571,13 +571,14 @@ proto_register_quake(void) proto_quake = proto_register_protocol("Quake Network Protocol", "QUAKE", "quake"); proto_register_field_array(proto_quake, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + quake_handle = register_dissector("quake", dissect_quake, proto_quake); } void proto_reg_handoff_quake(void) { - quake_handle = create_dissector_handle(dissect_quake, proto_quake); dissector_add_uint_with_preference("udp.port", DEFAULTnet_hostport, quake_handle); } diff --git a/epan/dissectors/packet-quake2.c b/epan/dissectors/packet-quake2.c index e75a0c527f..432f024782 100644 --- a/epan/dissectors/packet-quake2.c +++ b/epan/dissectors/packet-quake2.c @@ -24,6 +24,8 @@ void proto_register_quake2(void); void proto_reg_handoff_quake2(void); +static dissector_handle_t quake2_handle; + static int proto_quake2 = -1; static int hf_quake2_s2c = -1; @@ -820,6 +822,9 @@ proto_register_quake2(void) proto_register_field_array(proto_quake2, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + /* Register the dissector handle */ + quake2_handle = register_dissector("quake2", dissect_quake2, proto_quake2); + /* Register a configuration option for port */ prefs_register_protocol(proto_quake2, apply_quake2_prefs); } @@ -827,9 +832,6 @@ proto_register_quake2(void) void proto_reg_handoff_quake2(void) { - dissector_handle_t quake2_handle; - quake2_handle = create_dissector_handle(dissect_quake2, proto_quake2); - dissector_add_uint_with_preference("udp.port", PORT_MASTER, quake2_handle); apply_quake2_prefs(); } diff --git a/epan/dissectors/packet-quake3.c b/epan/dissectors/packet-quake3.c index 1f46c10406..f9a7077f66 100644 --- a/epan/dissectors/packet-quake3.c +++ b/epan/dissectors/packet-quake3.c @@ -30,6 +30,7 @@ #include <epan/addr_resolv.h> void proto_register_quake3(void); +static dissector_handle_t quake3_handle; static int proto_quake3 = -1; static int hf_quake3_direction = -1; @@ -549,6 +550,9 @@ proto_register_quake3(void) proto_register_field_array(proto_quake3, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + /* Register the dissector handle */ + quake3_handle = register_dissector("quake3", dissect_quake3, proto_quake3); + /* Register a configuration option for port */ quake3_module = prefs_register_protocol(proto_quake3, proto_reg_handoff_quake3); prefs_register_uint_preference(quake3_module, "udp.arena_port", @@ -566,14 +570,11 @@ void proto_reg_handoff_quake3(void) { static gboolean initialized=FALSE; - static dissector_handle_t quake3_handle; static guint server_port; static guint master_port; int i; if (!initialized) { - quake3_handle = create_dissector_handle(dissect_quake3, - proto_quake3); initialized=TRUE; } else { for (i=0;i<4;i++) diff --git a/epan/dissectors/packet-quakeworld.c b/epan/dissectors/packet-quakeworld.c index 881cd68c08..bfdbdc5789 100644 --- a/epan/dissectors/packet-quakeworld.c +++ b/epan/dissectors/packet-quakeworld.c @@ -25,6 +25,8 @@ void proto_register_quakeworld(void); void proto_reg_handoff_quakeworld(void); +static dissector_handle_t quakeworld_handle; + static int proto_quakeworld = -1; static int hf_quakeworld_s2c = -1; @@ -813,6 +815,9 @@ proto_register_quakeworld(void) proto_register_field_array(proto_quakeworld, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + /* Register the dissector handle */ + quakeworld_handle = register_dissector("quakeworld", dissect_quakeworld, proto_quakeworld); + /* Register a configuration option for port */ prefs_register_protocol(proto_quakeworld, apply_quakeworld_prefs); @@ -824,9 +829,6 @@ proto_register_quakeworld(void) void proto_reg_handoff_quakeworld(void) { - dissector_handle_t quakeworld_handle; - - quakeworld_handle = create_dissector_handle(dissect_quakeworld, proto_quakeworld); dissector_add_uint_with_preference("udp.port", PORT_MASTER, quakeworld_handle); apply_quakeworld_prefs(); } diff --git a/epan/dissectors/packet-rdm.c b/epan/dissectors/packet-rdm.c index f3e615ddbf..8f8f660815 100644 --- a/epan/dissectors/packet-rdm.c +++ b/epan/dissectors/packet-rdm.c @@ -38,6 +38,8 @@ void proto_register_rdm(void); void proto_reg_handoff_rdm(void); +static dissector_handle_t rdm_handle; + #define RDM_SC_RDM 0xCC #define RDM_SC_SUB_MESSAGE 0x01 @@ -6916,14 +6918,14 @@ proto_register_rdm(void) proto_rdm = proto_register_protocol("Remote Device Management", "RDM", "rdm"); proto_register_field_array(proto_rdm, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - register_dissector("rdm", dissect_rdm, proto_rdm); + rdm_handle = register_dissector("rdm", dissect_rdm, proto_rdm); expert_rdm = expert_register_protocol(proto_rdm); expert_register_field_array(expert_rdm, ei, array_length(ei)); } void proto_reg_handoff_rdm(void) { - dissector_add_uint("dmx", 0xCC, create_dissector_handle(dissect_rdm, proto_rdm)); + dissector_add_uint("dmx", 0xCC, rdm_handle); } /* diff --git a/epan/dissectors/packet-reload-framing.c b/epan/dissectors/packet-reload-framing.c index 86edacabbb..eac1744c31 100644 --- a/epan/dissectors/packet-reload-framing.c +++ b/epan/dissectors/packet-reload-framing.c @@ -43,6 +43,8 @@ static int hf_reload_framing_response_to = -1; static int hf_reload_framing_time = -1; static dissector_handle_t reload_handle; +static dissector_handle_t reload_framing_tcp_handle; +static dissector_handle_t reload_framing_udp_handle; static gint exported_pdu_tap = -1; @@ -565,20 +567,14 @@ proto_register_reload_framing(void) expert_reload_framing = expert_register_protocol(proto_reload_framing); expert_register_field_array(expert_reload_framing, ei, array_length(ei)); - register_dissector("reload-framing", dissect_reload_framing, proto_reload_framing); + reload_framing_udp_handle = register_dissector("reload-framing", dissect_reload_framing, proto_reload_framing); + reload_framing_tcp_handle = register_dissector("reload-framing.tcp", dissect_reload_framing_tcp, proto_reload_framing); } void proto_reg_handoff_reload_framing(void) { - - dissector_handle_t reload_framing_tcp_handle; - dissector_handle_t reload_framing_udp_handle; - - reload_framing_tcp_handle = create_dissector_handle(dissect_reload_framing_tcp, proto_reload_framing); - reload_framing_udp_handle = create_dissector_handle(dissect_reload_framing, proto_reload_framing); - reload_handle = find_dissector_add_dependency("reload", proto_reload_framing); dissector_add_uint_with_preference("tcp.port", TCP_PORT_RELOAD, reload_framing_tcp_handle); diff --git a/epan/dissectors/packet-resp.c b/epan/dissectors/packet-resp.c index 0b80767525..19bf2e4ace 100644 --- a/epan/dissectors/packet-resp.c +++ b/epan/dissectors/packet-resp.c @@ -428,6 +428,7 @@ void proto_register_resp(void) { expert_module_t *expert_pcp = expert_register_protocol(proto_resp); expert_register_field_array(expert_pcp, ei, array_length(ei)); + resp_handle = register_dissector("resp", dissect_resp, proto_resp); proto_register_field_array(proto_resp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); @@ -435,7 +436,5 @@ void proto_register_resp(void) { void proto_reg_handoff_resp(void) { - resp_handle = create_dissector_handle(dissect_resp, proto_resp); - dissector_add_uint_with_preference("tcp.port", RESP_PORT, resp_handle); } diff --git a/epan/dissectors/packet-riemann.c b/epan/dissectors/packet-riemann.c index b9d28ec177..ed61cf0b53 100644 --- a/epan/dissectors/packet-riemann.c +++ b/epan/dissectors/packet-riemann.c @@ -70,6 +70,8 @@ void proto_reg_handoff_riemann(void); void proto_register_riemann(void); +static dissector_handle_t riemann_udp_handle, riemann_tcp_handle; + static int proto_riemann = -1; static int hf_riemann_msg_ok = -1; static int hf_riemann_msg_error = -1; @@ -807,15 +809,14 @@ proto_register_riemann(void) proto_register_field_array(proto_riemann, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + riemann_udp_handle = register_dissector("riemann.udp", dissect_riemann_udp, proto_riemann); + riemann_tcp_handle = register_dissector("riemann.tcp", dissect_riemann_tcp, proto_riemann); } void proto_reg_handoff_riemann(void) { - dissector_handle_t riemann_udp_handle, riemann_tcp_handle; - - riemann_udp_handle = create_dissector_handle(dissect_riemann_udp, proto_riemann); - riemann_tcp_handle = create_dissector_handle(dissect_riemann_tcp, proto_riemann); dissector_add_for_decode_as_with_preference("tcp.port", riemann_tcp_handle); dissector_add_for_decode_as_with_preference("udp.port", riemann_udp_handle); } diff --git a/epan/dissectors/packet-rip.c b/epan/dissectors/packet-rip.c index e0e6fe0296..fa37c8d36f 100644 --- a/epan/dissectors/packet-rip.c +++ b/epan/dissectors/packet-rip.c @@ -381,7 +381,7 @@ proto_register_rip(void) prefs_register_bool_preference(rip_module, "display_routing_domain", "Display Routing Domain field", "Display the third and forth bytes of the RIPv2 header as the Routing Domain field (introduced in RFC 1388 [January 1993] and obsolete as of RFC 1723 [November 1994])", &pref_display_routing_domain); - rip_handle = create_dissector_handle(dissect_rip, proto_rip); + rip_handle = register_dissector("rip", dissect_rip, proto_rip); } void diff --git a/epan/dissectors/packet-ripng.c b/epan/dissectors/packet-ripng.c index a23dc571c5..8df74457f4 100644 --- a/epan/dissectors/packet-ripng.c +++ b/epan/dissectors/packet-ripng.c @@ -23,6 +23,8 @@ void proto_register_ripng(void); void proto_reg_handoff_ripng(void); +static dissector_handle_t ripng_handle; + static int proto_ripng = -1; static int hf_ripng_cmd = -1; static int hf_ripng_version = -1; @@ -152,14 +154,13 @@ proto_register_ripng(void) proto_ripng = proto_register_protocol("RIPng", "RIPng", "ripng"); proto_register_field_array(proto_ripng, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + ripng_handle = register_dissector("ripng", dissect_ripng, proto_ripng); } void proto_reg_handoff_ripng(void) { - dissector_handle_t ripng_handle; - - ripng_handle = create_dissector_handle(dissect_ripng, proto_ripng); dissector_add_uint_with_preference("udp.port", UDP_PORT_RIPNG, ripng_handle); } diff --git a/epan/dissectors/packet-rlogin.c b/epan/dissectors/packet-rlogin.c index cfac4f149d..93b031c520 100644 --- a/epan/dissectors/packet-rlogin.c +++ b/epan/dissectors/packet-rlogin.c @@ -24,6 +24,8 @@ void proto_register_rlogin(void); void proto_reg_handoff_rlogin(void); +static dissector_handle_t rlogin_handle; + static int proto_rlogin = -1; static int ett_rlogin = -1; @@ -585,12 +587,13 @@ void proto_register_rlogin(void) expert_rlogin = expert_register_protocol(proto_rlogin); expert_register_field_array(expert_rlogin, ei, array_length(ei)); + + rlogin_handle = register_dissector("rlogin", dissect_rlogin,proto_rlogin); } void proto_reg_handoff_rlogin(void) { /* Dissector install routine */ - dissector_handle_t rlogin_handle = create_dissector_handle(dissect_rlogin,proto_rlogin); dissector_add_uint_with_preference("tcp.port", RLOGIN_PORT, rlogin_handle); } diff --git a/epan/dissectors/packet-rmcp.c b/epan/dissectors/packet-rmcp.c index 4b410140e3..dd10691b29 100644 --- a/epan/dissectors/packet-rmcp.c +++ b/epan/dissectors/packet-rmcp.c @@ -21,6 +21,9 @@ void proto_register_rsp(void); void proto_reg_handoff_rmcp(void); void proto_reg_handoff_rsp(void); +static dissector_handle_t rmcp_handle; +static dissector_handle_t rsp_handle; + /* * See * http://www.dmtf.org/standards/standard_alert.php @@ -210,6 +213,8 @@ proto_register_rmcp(void) proto_register_field_array(proto_rmcp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + rmcp_handle = register_dissector("rmcp", dissect_rmcp, proto_rmcp); + rmcp_dissector_table = register_dissector_table( "rmcp.class", "RMCP Class", proto_rmcp, FT_UINT8, BASE_HEX); } @@ -235,23 +240,19 @@ proto_register_rsp(void) "RMCP Security-extensions Protocol", "RSP", "rsp"); proto_register_field_array(proto_rsp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + rsp_handle = register_dissector("rsp", dissect_rsp, proto_rsp); } void proto_reg_handoff_rmcp(void) { - dissector_handle_t rmcp_handle; - - rmcp_handle = create_dissector_handle(dissect_rmcp, proto_rmcp); dissector_add_uint_with_preference("udp.port", UDP_PORT_RMCP, rmcp_handle); } void proto_reg_handoff_rsp(void) { - dissector_handle_t rsp_handle; - - rsp_handle = create_dissector_handle(dissect_rsp, proto_rsp); dissector_add_uint_with_preference("udp.port", UDP_PORT_RMCP_SECURE, rsp_handle); } diff --git a/epan/dissectors/packet-rmi.c b/epan/dissectors/packet-rmi.c index 62ba856e60..74ebe84011 100644 --- a/epan/dissectors/packet-rmi.c +++ b/epan/dissectors/packet-rmi.c @@ -19,6 +19,8 @@ void proto_register_rmi(void); void proto_reg_handoff_rmi(void); +static dissector_handle_t rmi_handle; + static void dissect_ser(tvbuff_t *tvb, proto_tree *tree); @@ -353,14 +355,12 @@ proto_register_rmi(void) proto_register_field_array(proto_rmi, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + rmi_handle = register_dissector("rmi", dissect_rmi, proto_rmi); } void proto_reg_handoff_rmi(void) { - dissector_handle_t rmi_handle; - - rmi_handle = create_dissector_handle(dissect_rmi, proto_rmi); dissector_add_uint_with_preference("tcp.port", TCP_PORT_RMI, rmi_handle); } diff --git a/epan/dissectors/packet-rmt-alc.c b/epan/dissectors/packet-rmt-alc.c index bf26207d8e..a0281738ac 100644 --- a/epan/dissectors/packet-rmt-alc.c +++ b/epan/dissectors/packet-rmt-alc.c @@ -296,7 +296,7 @@ void proto_register_alc(void) /* Register the protocol name and description */ proto_rmt_alc = proto_register_protocol("Asynchronous Layered Coding", "ALC", "alc"); - register_dissector("alc", dissect_alc, proto_rmt_alc); + alc_handle = register_dissector("alc", dissect_alc, proto_rmt_alc); /* Register the header fields and subtrees used */ proto_register_field_array(proto_rmt_alc, hf_ptr, array_length(hf_ptr)); @@ -342,7 +342,6 @@ void proto_register_alc(void) void proto_reg_handoff_alc(void) { - alc_handle = create_dissector_handle(dissect_alc, proto_rmt_alc); dissector_add_for_decode_as_with_preference("udp.port", alc_handle); xml_handle = find_dissector_add_dependency("xml", proto_rmt_alc); rmt_lct_handle = find_dissector_add_dependency("rmt-lct", proto_rmt_alc); diff --git a/epan/dissectors/packet-rmt-norm.c b/epan/dissectors/packet-rmt-norm.c index a965462ed4..98889896e6 100644 --- a/epan/dissectors/packet-rmt-norm.c +++ b/epan/dissectors/packet-rmt-norm.c @@ -38,6 +38,8 @@ void proto_register_norm(void); void proto_reg_handoff_norm(void); +static dissector_handle_t norm_handle; + /* String tables */ #define NORM_INFO 1 @@ -954,6 +956,8 @@ void proto_register_norm(void) expert_rmt_norm = expert_register_protocol(proto_rmt_norm); expert_register_field_array(expert_rmt_norm, ei, array_length(ei)); + /* Register the subdissector handle */ + norm_handle = register_dissector("norm", dissect_norm, proto_rmt_norm); /* Register preferences */ module = prefs_register_protocol(proto_rmt_norm, NULL); @@ -962,10 +966,7 @@ void proto_register_norm(void) void proto_reg_handoff_norm(void) { - static dissector_handle_t handle; - - handle = create_dissector_handle(dissect_norm, proto_rmt_norm); - dissector_add_for_decode_as_with_preference("udp.port", handle); + dissector_add_for_decode_as_with_preference("udp.port", norm_handle); heur_dissector_add("udp", dissect_norm_heur, "NORM over UDP", "rmt_norm_udp", proto_rmt_norm, HEURISTIC_DISABLE); rmt_fec_handle = find_dissector_add_dependency("rmt-fec", proto_rmt_norm); diff --git a/epan/dissectors/packet-roofnet.c b/epan/dissectors/packet-roofnet.c index 6ad02d57a5..9630969fd9 100644 --- a/epan/dissectors/packet-roofnet.c +++ b/epan/dissectors/packet-roofnet.c @@ -61,6 +61,7 @@ static const value_string roofnet_pt_vals[] = { void proto_register_roofnet(void); void proto_reg_handoff_roofnet(void); +static dissector_handle_t roofnet_handle; static dissector_handle_t ip_handle; static dissector_handle_t eth_withoutfcs_handle; static int proto_roofnet = -1; @@ -379,18 +380,17 @@ void proto_register_roofnet(void) proto_register_subtree_array(ett, array_length(ett)); expert_roofnet = expert_register_protocol(proto_roofnet); expert_register_field_array(expert_roofnet, ei, array_length(ei)); + + roofnet_handle = register_dissector("roofnet", dissect_roofnet, proto_roofnet); } void proto_reg_handoff_roofnet(void) { - dissector_handle_t roofnet_handle; - /* Until now there is no other option than having an IPv4 payload (maybe * extended one day to IPv6 or other?) */ ip_handle = find_dissector_add_dependency("ip", proto_roofnet); eth_withoutfcs_handle = find_dissector_add_dependency("eth_withoutfcs", proto_roofnet); - roofnet_handle = create_dissector_handle(dissect_roofnet, proto_roofnet); /* I did not put the type numbers in the ethertypes.h as they only are * experimental and not official */ dissector_add_uint("ethertype", 0x0641, roofnet_handle); diff --git a/epan/dissectors/packet-roon_discovery.c b/epan/dissectors/packet-roon_discovery.c index 5d83f1f73d..b0686ac084 100644 --- a/epan/dissectors/packet-roon_discovery.c +++ b/epan/dissectors/packet-roon_discovery.c @@ -26,6 +26,8 @@ void proto_reg_handoff_roon_discover(void); void proto_register_roon_discover(void); +static dissector_handle_t roon_discover_handle; + /* Initialize the protocol and registered fields */ static int proto_roon_discover = -1; static int hf_roon_disco_config_version = -1; @@ -329,14 +331,13 @@ proto_register_roon_discover(void) /* Required function calls to register the header fields and subtrees */ proto_register_field_array(proto_roon_discover, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + roon_discover_handle = register_dissector("roon_disco", dissect_roon_discover, proto_roon_discover); } void proto_reg_handoff_roon_discover(void) { - static dissector_handle_t roon_discover_handle; - - roon_discover_handle = create_dissector_handle(dissect_roon_discover, proto_roon_discover); dissector_add_uint_with_preference("udp.port", ROON_DISCOVERY_UDP_PORT, roon_discover_handle); } diff --git a/epan/dissectors/packet-rpcap.c b/epan/dissectors/packet-rpcap.c index e95f87210e..1c86babc46 100644 --- a/epan/dissectors/packet-rpcap.c +++ b/epan/dissectors/packet-rpcap.c @@ -1633,6 +1633,7 @@ proto_register_rpcap (void) proto_rpcap = proto_register_protocol (PNAME, PSNAME, PFNAME); register_dissector (PFNAME, dissect_rpcap, proto_rpcap); + rpcap_tcp_handle = register_dissector(PFNAME ".tcp", dissect_rpcap_tcp, proto_rpcap); expert_rpcap = expert_register_protocol(proto_rpcap); expert_register_field_array(expert_rpcap, ei, array_length(ei)); @@ -1672,8 +1673,6 @@ proto_reg_handoff_rpcap (void) heur_dissector_add ("tcp", dissect_rpcap_heur_tcp, "RPCAP over TCP", "rpcap_tcp", proto_rpcap, HEURISTIC_ENABLE); heur_dissector_add ("udp", dissect_rpcap_heur_udp, "RPCAP over UDP", "rpcap_udp", proto_rpcap, HEURISTIC_ENABLE); - - rpcap_tcp_handle = create_dissector_handle(dissect_rpcap_tcp, proto_rpcap); } info_added = FALSE; diff --git a/epan/dissectors/packet-rpcrdma.c b/epan/dissectors/packet-rpcrdma.c index 7b58951c69..e7f650c91b 100644 --- a/epan/dissectors/packet-rpcrdma.c +++ b/epan/dissectors/packet-rpcrdma.c @@ -46,6 +46,7 @@ void proto_reg_handoff_rpcordma(void); void proto_register_rpcordma(void); static int proto_rpcordma = -1; +static dissector_handle_t rpcordma_handle; static dissector_handle_t rpc_handler; /* RPCoRDMA Header */ @@ -2047,6 +2048,9 @@ proto_register_rpcordma(void) proto_register_subtree_array(ett, array_length(ett)); reassembly_table_register(&rpcordma_reassembly_table, &addresses_ports_reassembly_table_functions); + /* Register dissector handle */ + rpcordma_handle = register_dissector("rpcordma", dissect_rpcrdma, proto_rpcordma); + /* Register preferences */ rpcordma_module = prefs_register_protocol_obsolete(proto_rpcordma); @@ -2067,7 +2071,7 @@ proto_reg_handoff_rpcordma(void) { heur_dissector_add("infiniband.payload", dissect_rpcrdma_ib_heur, "RPC-over-RDMA on Infiniband", "rpcrdma_infiniband", proto_rpcordma, HEURISTIC_ENABLE); - dissector_add_for_decode_as("infiniband", create_dissector_handle( dissect_rpcrdma, proto_rpcordma ) ); + dissector_add_for_decode_as("infiniband", rpcordma_handle); heur_dissector_add("iwarp_ddp_rdmap", dissect_rpcrdma_iwarp_heur, "RPC-over-RDMA on iWARP", "rpcrdma_iwarp", proto_rpcordma, HEURISTIC_ENABLE); diff --git a/epan/dissectors/packet-rsh.c b/epan/dissectors/packet-rsh.c index 3fe31a111e..360e65b7a4 100644 --- a/epan/dissectors/packet-rsh.c +++ b/epan/dissectors/packet-rsh.c @@ -27,6 +27,8 @@ void proto_register_rsh(void); void proto_reg_handoff_rsh(void); +static dissector_handle_t rsh_handle; + /* Variables for our preferences */ static gboolean preference_info_show_client_username = FALSE; static gboolean preference_info_show_server_username = TRUE; @@ -387,6 +389,9 @@ proto_register_rsh(void) proto_register_field_array(proto_rsh, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + /* Register the dissector handle */ + rsh_handle = register_dissector("rsh", dissect_rsh, proto_rsh); + /* Register preferences module */ rsh_module = prefs_register_protocol(proto_rsh, NULL); @@ -412,9 +417,6 @@ proto_register_rsh(void) void proto_reg_handoff_rsh(void) { - dissector_handle_t rsh_handle; - - rsh_handle = create_dissector_handle(dissect_rsh, proto_rsh); dissector_add_uint_with_preference("tcp.port", RSH_PORT, rsh_handle); } diff --git a/epan/dissectors/packet-rsip.c b/epan/dissectors/packet-rsip.c index 66bbda8e04..4b90c789d8 100644 --- a/epan/dissectors/packet-rsip.c +++ b/epan/dissectors/packet-rsip.c @@ -21,6 +21,8 @@ void proto_register_rsip(void); /* Forward declaration we need below */ void proto_reg_handoff_rsip(void); +static dissector_handle_t rsip_handle; + /* Initialize the protocol and registered fields */ static int proto_rsip = -1; static int hf_rsip_version = -1; @@ -1225,14 +1227,12 @@ proto_register_rsip(void) proto_register_field_array(proto_rsip, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + rsip_handle = register_dissector("rsip", dissect_rsip, proto_rsip); } void proto_reg_handoff_rsip(void) { - dissector_handle_t rsip_handle; - - rsip_handle = create_dissector_handle(dissect_rsip, proto_rsip); dissector_add_uint_with_preference("udp.port", UDP_PORT_RSIP, rsip_handle); dissector_add_uint_with_preference("tcp.port", TCP_PORT_RSIP, rsip_handle); } diff --git a/epan/dissectors/packet-rsync.c b/epan/dissectors/packet-rsync.c index 74c85e6067..6e96875af6 100644 --- a/epan/dissectors/packet-rsync.c +++ b/epan/dissectors/packet-rsync.c @@ -339,7 +339,7 @@ proto_register_rsync(void) " \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.", &rsync_desegment); - rsync_handle = create_dissector_handle(dissect_rsync, proto_rsync); + rsync_handle = register_dissector("rsync", dissect_rsync, proto_rsync); } void proto_reg_handoff_rsync(void) diff --git a/epan/dissectors/packet-rtcdc.c b/epan/dissectors/packet-rtcdc.c index dbf2ea86a2..88681d1ece 100644 --- a/epan/dissectors/packet-rtcdc.c +++ b/epan/dissectors/packet-rtcdc.c @@ -27,6 +27,8 @@ void proto_register_rtcdc(void); void proto_reg_handoff_rtcdc(void); +static dissector_handle_t rtcdc_handle; + /* Initialize the protocol and registered fields */ static int proto_rtcdc = -1; static int hf_message_type = -1; @@ -365,14 +367,13 @@ proto_register_rtcdc(void) expert_rtcdc = expert_register_protocol(proto_rtcdc); expert_register_field_array(expert_rtcdc, ei, array_length(ei)); /* rtcdc_module = prefs_register_protocol(proto_rtcdc, NULL); */ + + rtcdc_handle = register_dissector("rtcdc", dissect_rtcdc, proto_rtcdc); } void proto_reg_handoff_rtcdc(void) { - static dissector_handle_t rtcdc_handle; - - rtcdc_handle = create_dissector_handle(dissect_rtcdc, proto_rtcdc); dissector_add_uint_with_preference("sctp.ppi", WEBRTC_DCEP_PROTOCOL_ID, rtcdc_handle); } diff --git a/epan/dissectors/packet-rtmpt.c b/epan/dissectors/packet-rtmpt.c index 415504d9e9..7760318b85 100644 --- a/epan/dissectors/packet-rtmpt.c +++ b/epan/dissectors/packet-rtmpt.c @@ -134,6 +134,7 @@ static gint ett_rtmpt_video_control = -1; static gint ett_rtmpt_tag = -1; static gint ett_rtmpt_tag_data = -1; +static dissector_handle_t amf_handle; static dissector_handle_t rtmpt_tcp_handle; static dissector_handle_t rtmpt_http_handle; @@ -2748,6 +2749,9 @@ proto_register_rtmpt(void) proto_register_field_array(proto_rtmpt, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + rtmpt_tcp_handle = register_dissector("rtmpt.tcp", dissect_rtmpt_tcp, proto_rtmpt); + rtmpt_http_handle = register_dissector("rtmpt.http", dissect_rtmpt_http, proto_rtmpt); + rtmpt_module = prefs_register_protocol(proto_rtmpt, NULL); prefs_register_bool_preference(rtmpt_module, "desegment", "Reassemble RTMPT messages spanning multiple TCP segments", @@ -2971,21 +2975,17 @@ proto_register_amf(void) proto_register_subtree_array(ett, array_length(ett)); expert_amf = expert_register_protocol(proto_amf); expert_register_field_array(expert_amf, ei, array_length(ei)); + + amf_handle = register_dissector("amf", dissect_amf, proto_amf); } void proto_reg_handoff_rtmpt(void) { - dissector_handle_t amf_handle; - heur_dissector_add("tcp", dissect_rtmpt_heur, "RTMPT over TCP", "rtmpt_tcp", proto_rtmpt, HEURISTIC_DISABLE); - rtmpt_tcp_handle = create_dissector_handle(dissect_rtmpt_tcp, proto_rtmpt); dissector_add_uint_with_preference("tcp.port", RTMP_PORT, rtmpt_tcp_handle); - rtmpt_http_handle = create_dissector_handle(dissect_rtmpt_http, proto_rtmpt); dissector_add_string("media_type", "application/x-fcs", rtmpt_http_handle); - - amf_handle = create_dissector_handle(dissect_amf, proto_amf); dissector_add_string("media_type", "application/x-amf", amf_handle); } diff --git a/epan/dissectors/packet-rtnet.c b/epan/dissectors/packet-rtnet.c index ff54cf9fd9..43a7d76912 100644 --- a/epan/dissectors/packet-rtnet.c +++ b/epan/dissectors/packet-rtnet.c @@ -31,6 +31,9 @@ void proto_register_rtmac(void); void proto_reg_handoff_rtmac(void); +static dissector_handle_t rtmac_handle; +static dissector_handle_t rtcfg_handle; + void proto_register_rtcfg(void); void proto_reg_handoff_rtcfg(void); @@ -1153,6 +1156,8 @@ proto_register_rtmac(void) { proto_register_field_array(proto_rtmac, hf_array_rtmac, array_length(hf_array_rtmac)); proto_register_subtree_array(ett_array_rtmac, array_length(ett_array_rtmac)); + rtmac_handle = register_dissector("rtmac", dissect_rtmac, proto_rtmac); + proto_tdma = proto_register_protocol("TDMA RTmac Discipline", "TDMA", "tdma"); proto_register_field_array(proto_rtmac, hf_array_tdma, array_length(hf_array_tdma)); proto_register_subtree_array(ett_array_tdma, array_length(ett_array_tdma)); @@ -1314,25 +1319,21 @@ proto_register_rtcfg(void) { proto_rtcfg = proto_register_protocol("RTcfg","RTcfg","rtcfg"); proto_register_field_array(proto_rtcfg,hf,array_length(hf)); proto_register_subtree_array(ett,array_length(ett)); + + rtcfg_handle = register_dissector("rtcfg", dissect_rtcfg, proto_rtcfg); } /* The registration hand-off routing */ void proto_reg_handoff_rtmac(void) { - dissector_handle_t rtmac_handle; - - rtmac_handle = create_dissector_handle(dissect_rtmac, proto_rtmac); dissector_add_uint("ethertype", ETHERTYPE_RTMAC, rtmac_handle); ethertype_table = find_dissector_table("ethertype"); } void proto_reg_handoff_rtcfg(void) { - dissector_handle_t rtcfg_handle; - data_handle = find_dissector("data"); - rtcfg_handle = create_dissector_handle(dissect_rtcfg, proto_rtcfg); dissector_add_uint("ethertype", ETHERTYPE_RTCFG, rtcfg_handle); } diff --git a/epan/dissectors/packet-rudp.c b/epan/dissectors/packet-rudp.c index 9f762834ea..73bc2eff43 100644 --- a/epan/dissectors/packet-rudp.c +++ b/epan/dissectors/packet-rudp.c @@ -37,6 +37,8 @@ void proto_register_rudp(void); void proto_reg_handoff_rudp(void); +static dissector_handle_t rudp_handle; + static int proto_rudp = -1; static int hf_rudp_flags = -1; @@ -194,13 +196,13 @@ proto_register_rudp(void) proto_register_field_array(proto_rudp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + rudp_handle = register_dissector("rudp", dissect_rudp, proto_rudp); } void proto_reg_handoff_rudp(void) { - dissector_handle_t rudp_handle; - /* Disable rudp by default. The previously hardcoded value of * 7000 (used by Cisco) collides with afs and as the draft states: * "RUDP doesn't place any restrictions on which UDP port numbers are used. @@ -210,7 +212,6 @@ proto_reg_handoff_rudp(void) { * heuristic dissector, but it isn't complete anyway. */ - rudp_handle = create_dissector_handle(dissect_rudp, proto_rudp); dissector_add_for_decode_as_with_preference("udp.port", rudp_handle); sm_handle = find_dissector_add_dependency("sm", proto_rudp); } diff --git a/epan/dissectors/packet-rx.c b/epan/dissectors/packet-rx.c index a922066471..30a7b5cf8c 100644 --- a/epan/dissectors/packet-rx.c +++ b/epan/dissectors/packet-rx.c @@ -30,6 +30,8 @@ void proto_register_rx(void); void proto_reg_handoff_rx(void); +static dissector_handle_t rx_handle; + #define UDP_PORT_RX_RANGE "7000-7009,7021" static const value_string rx_types[] = { @@ -753,19 +755,18 @@ proto_register_rx(void) proto_rx = proto_register_protocol("RX Protocol", "RX", "rx"); proto_register_field_array(proto_rx, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + rx_handle = register_dissector("rx", dissect_rx, proto_rx); } void proto_reg_handoff_rx(void) { - dissector_handle_t rx_handle; - /* * Get handle for the AFS dissector. */ afs_handle = find_dissector_add_dependency("afs", proto_rx); - rx_handle = create_dissector_handle(dissect_rx, proto_rx); dissector_add_uint_range_with_preference("udp.port", UDP_PORT_RX_RANGE, rx_handle); } diff --git a/epan/dissectors/packet-s101.c b/epan/dissectors/packet-s101.c index 5acbdec730..0c6aafeec6 100644 --- a/epan/dissectors/packet-s101.c +++ b/epan/dissectors/packet-s101.c @@ -63,6 +63,7 @@ static int hf_S101_crc_status = -1; static int hf_S101_eof = -1; static int hf_S101_error = -1; +static dissector_handle_t S101_handle; static dissector_handle_t glow_handle = NULL; static reassembly_table s101_data_reassembly_table; @@ -630,6 +631,8 @@ proto_register_S101(void) proto_register_field_array(proto_S101, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + S101_handle = register_dissector("s101", dissect_S101, proto_S101); + reassembly_table_register(&s101_data_reassembly_table, &addresses_ports_reassembly_table_functions); @@ -645,11 +648,6 @@ proto_register_S101(void) void proto_reg_handoff_S101(void) { - static dissector_handle_t S101_handle; - - S101_handle = create_dissector_handle(dissect_S101, - proto_S101); - glow_handle = find_dissector_add_dependency("glow", proto_S101); dissector_add_uint_with_preference("tcp.port", S101_TCP_PORT, S101_handle); } diff --git a/epan/dissectors/packet-s5066dts.c b/epan/dissectors/packet-s5066dts.c index 81c3170f3c..0d22ded2f9 100644 --- a/epan/dissectors/packet-s5066dts.c +++ b/epan/dissectors/packet-s5066dts.c @@ -60,6 +60,9 @@ void proto_register_s5066dts(void); static gint proto_s5066dts = -1; +static dissector_handle_t s5066dts_handle; +static dissector_handle_t s5066dts_over_tcp_handle; + /* Configuration parameters */ static gboolean config_proto_desegment = TRUE; @@ -1325,7 +1328,8 @@ void proto_register_s5066dts (void) proto_register_subtree_array(ett, array_length(ett)); expert_s5066dts = expert_register_protocol(proto_s5066dts); expert_register_field_array(expert_s5066dts, ei, array_length(ei)); - register_dissector(DISSECTOR_NAME, dissect_s5066dts_tcp, proto_s5066dts); + s5066dts_handle = register_dissector(DISSECTOR_NAME ".raw", dissect_s5066dts_raw, proto_s5066dts); + s5066dts_over_tcp_handle = register_dissector(DISSECTOR_NAME, dissect_s5066dts_tcp, proto_s5066dts); } s5066dts_module = prefs_register_protocol(proto_s5066dts, apply_s5066dts_prefs); @@ -1339,13 +1343,7 @@ void proto_register_s5066dts (void) /* Routine that will be called when s5066dts is handing off to the next dissector */ void proto_reg_handoff_s5066dts(void) { - dissector_handle_t s5066dts_handle; - dissector_handle_t s5066dts_over_tcp_handle; - - s5066dts_handle = create_dissector_handle(dissect_s5066dts_raw, proto_s5066dts); dissector_add_uint("wtap_encap", WTAP_ENCAP_STANAG_5066_D_PDU, s5066dts_handle); - s5066dts_over_tcp_handle = create_dissector_handle(dissect_s5066dts_tcp, proto_s5066dts); - dissector_add_for_decode_as_with_preference("tcp.port", s5066dts_over_tcp_handle); apply_s5066dts_prefs(); } diff --git a/epan/dissectors/packet-s5066sis.c b/epan/dissectors/packet-s5066sis.c index 8123384ca0..c7d5dac093 100644 --- a/epan/dissectors/packet-s5066sis.c +++ b/epan/dissectors/packet-s5066sis.c @@ -25,6 +25,7 @@ # define SAPID_UDOP 7 /* Forward reference */ +static dissector_handle_t s5066_tcp_handle; /* Register functions */ void proto_register_s5066(void); void proto_reg_handoff_s5066(void); @@ -1413,6 +1414,8 @@ proto_register_s5066(void) proto_register_field_array(proto_s5066, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + s5066_tcp_handle = register_dissector("s5066sis", dissect_s5066_tcp, proto_s5066); + s5066_module = prefs_register_protocol(proto_s5066, proto_reg_handoff_s5066); prefs_register_bool_preference(s5066_module, "desegment_pdus", "Reassemble S5066 SIS PDUs spanning multiple TCP segments", @@ -1433,10 +1436,8 @@ void proto_reg_handoff_s5066(void) { static gboolean Initialized = FALSE; - static dissector_handle_t s5066_tcp_handle; if (!Initialized) { - s5066_tcp_handle = create_dissector_handle(dissect_s5066_tcp, proto_s5066); dissector_add_uint_with_preference("tcp.port", S5066_PORT, s5066_tcp_handle); Initialized = TRUE; } diff --git a/epan/dissectors/packet-sametime.c b/epan/dissectors/packet-sametime.c index e3ad782092..bef0f797c6 100644 --- a/epan/dissectors/packet-sametime.c +++ b/epan/dissectors/packet-sametime.c @@ -877,6 +877,8 @@ proto_register_sametime(void) proto_register_field_array(proto_sametime, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + sametime_handle = register_dissector("sametime", dissect_sametime, proto_sametime); + sametime_tap = register_tap("sametime"); /* Preference setting */ @@ -897,7 +899,6 @@ proto_register_sametime(void) void proto_reg_handoff_sametime(void) { - sametime_handle = create_dissector_handle(dissect_sametime, proto_sametime); dissector_add_uint_with_preference("tcp.port", DEFAULT_SAMETIME_PORT, sametime_handle); stats_tree_register("sametime", "sametime", "Sametime/Messages", 0, diff --git a/epan/dissectors/packet-sap.c b/epan/dissectors/packet-sap.c index f6d4fe8dfb..df30168d55 100644 --- a/epan/dissectors/packet-sap.c +++ b/epan/dissectors/packet-sap.c @@ -28,6 +28,8 @@ void proto_register_sap(void); void proto_reg_handoff_sap(void); +static dissector_handle_t sap_handle; + static const value_string mcast_sap_ver[] = { { MCAST_SAP_VER0, "SAPv0"}, { MCAST_SAP_VER1PLUS, "SAPv1 or later"}, @@ -363,14 +365,13 @@ void proto_register_sap(void) proto_register_subtree_array(ett, array_length(ett)); expert_sap = expert_register_protocol(proto_sap); expert_register_field_array(expert_sap, ei, array_length(ei)); + + sap_handle = register_dissector("sap", dissect_sap, proto_sap); } void proto_reg_handoff_sap(void) { - dissector_handle_t sap_handle; - - sap_handle = create_dissector_handle(dissect_sap, proto_sap); dissector_add_uint_with_preference("udp.port", UDP_PORT_SAP, sap_handle); /* diff --git a/epan/dissectors/packet-sbus.c b/epan/dissectors/packet-sbus.c index 449a4af3c8..be800a526e 100644 --- a/epan/dissectors/packet-sbus.c +++ b/epan/dissectors/packet-sbus.c @@ -18,6 +18,8 @@ void proto_register_sbus(void); void proto_reg_handoff_sbus(void); +static dissector_handle_t sbus_handle; + #define SBUS_UDP_PORT 5050 /* Not IANA registered */ /* Attribute values*/ @@ -2586,14 +2588,14 @@ proto_register_sbus(void) expert_sbus = expert_register_protocol(proto_sbus); expert_register_field_array(expert_sbus, ei, array_length(ei)); sbus_request_hash = wmem_map_new_autoreset(wmem_epan_scope(), wmem_file_scope(), sbus_hash, sbus_equal); + +/* Register the dissector handle */ + sbus_handle = register_dissector("sbus", dissect_sbus, proto_sbus); } void proto_reg_handoff_sbus(void) { - dissector_handle_t sbus_handle; - - sbus_handle = create_dissector_handle(dissect_sbus, proto_sbus); dissector_add_uint_with_preference("udp.port", SBUS_UDP_PORT, sbus_handle); } diff --git a/epan/dissectors/packet-sccpmg.c b/epan/dissectors/packet-sccpmg.c index 944d6c43e9..a37115e912 100644 --- a/epan/dissectors/packet-sccpmg.c +++ b/epan/dissectors/packet-sccpmg.c @@ -42,6 +42,8 @@ void proto_register_sccpmg(void); void proto_reg_handoff_sccpmg(void); +static dissector_handle_t sccpmg_handle; + /* Same as below but with names typed out */ static const value_string sccpmg_message_type_values[] = { { SCCPMG_MESSAGE_TYPE_SSA, "SubSystem Allowed" }, @@ -337,15 +339,14 @@ proto_register_sccpmg(void) proto_register_subtree_array(ett, array_length(ett)); expert_sccpmg = expert_register_protocol(proto_sccpmg); expert_register_field_array(expert_sccpmg, ei, array_length(ei)); + + /* Register the dissector handle */ + sccpmg_handle = register_dissector("sccpmg", dissect_sccpmg, proto_sccpmg); } void proto_reg_handoff_sccpmg(void) { - dissector_handle_t sccpmg_handle; - - sccpmg_handle = create_dissector_handle(dissect_sccpmg, proto_sccpmg); - /* Register for SCCP SSN=1 messages */ dissector_add_uint("sccp.ssn", SCCPMG_SSN, sccpmg_handle); } diff --git a/epan/dissectors/packet-scriptingservice.c b/epan/dissectors/packet-scriptingservice.c index 56650d0798..a9ed01de0f 100644 --- a/epan/dissectors/packet-scriptingservice.c +++ b/epan/dissectors/packet-scriptingservice.c @@ -21,6 +21,8 @@ void proto_register_ssprotocol(void); void proto_reg_handoff_ssprotocol(void); +static dissector_handle_t ssprotocol_handle; + #define SSPROTOCOL_PAYLOAD_PROTOCOL_ID_LEGACY 0x29097604 @@ -466,15 +468,15 @@ proto_register_ssprotocol(void) proto_register_subtree_array(ett, array_length(ett)); tap_ssprotocol = register_tap("ssprotocol"); + /* Register the dissector handle */ + ssprotocol_handle = register_dissector("ssp", dissect_ssprotocol, proto_ssprotocol); + register_stat_tap_table_ui(&ssprotocol_stat_table); } void proto_reg_handoff_ssprotocol(void) { - dissector_handle_t ssprotocol_handle; - - ssprotocol_handle = create_dissector_handle(dissect_ssprotocol, proto_ssprotocol); dissector_add_uint("sctp.ppi", SSPROTOCOL_PAYLOAD_PROTOCOL_ID_LEGACY, ssprotocol_handle); dissector_add_uint("sctp.ppi", SSP_PAYLOAD_PROTOCOL_ID, ssprotocol_handle); } diff --git a/epan/dissectors/packet-scte35.c b/epan/dissectors/packet-scte35.c index 371c75a562..3083d1b4fe 100644 --- a/epan/dissectors/packet-scte35.c +++ b/epan/dissectors/packet-scte35.c @@ -136,6 +136,10 @@ static gint hf_private_byte = -1; static dissector_table_t private_identifier_table = NULL; static dissector_handle_t scte35_handle = NULL; +static dissector_handle_t scte35_time_handle; +static dissector_handle_t scte35_private_command_handle; +static dissector_handle_t scte35_si_handle; +static dissector_handle_t scte35_ss_handle; /* splice_insert protocol and fields */ static int proto_scte35_si = -1; @@ -359,17 +363,14 @@ proto_register_scte35_time_signal(void) proto_scte35_time = proto_register_protocol("SCTE-35 Time Signal", "SCTE35 TS", "scte35_time"); proto_register_subtree_array(ett, array_length(ett)); proto_register_field_array(proto_scte35_time, hf, array_length(hf)); + + /* Create a dissector for time_signal packets. */ + scte35_time_handle = register_dissector("scte35_time", dissect_scte35_time_signal, proto_scte35_time); } void proto_reg_handoff_scte35_time_signal(void) { - dissector_handle_t scte35_time_handle; - - /* Create a dissector for time_signal packets. */ - scte35_time_handle = create_dissector_handle(dissect_scte35_time_signal, proto_scte35_time); - - /* And hook it up to SCTE-35 messages. */ dissector_add_uint("scte35.splice_command_type", SCTE35_CMD_TIME_SIGNAL, scte35_time_handle); } @@ -428,17 +429,14 @@ proto_register_scte35_private_command(void) private_identifier_table = register_dissector_table( "scte35_private_command.identifier", "SCTE-35 Private Command Identifier", proto_private_command, FT_UINT32, BASE_HEX); + + /* Create a dissector for private commands. */ + scte35_private_command_handle = register_dissector("scte35_private_command", dissect_scte35_private_command, proto_private_command); } void proto_reg_handoff_scte35_private_command(void) { - dissector_handle_t scte35_private_command_handle; - - /* Create a dissector for private commands. */ - scte35_private_command_handle = create_dissector_handle(dissect_scte35_private_command, proto_private_command); - - /* Trigger our dissector on any private_command SCTE-35 messages. */ dissector_add_uint("scte35.splice_command_type", SCTE35_CMD_PRIVATE_COMMAND, scte35_private_command_handle); } @@ -712,15 +710,14 @@ proto_register_scte35_splice_insert(void) proto_register_subtree_array(ett, array_length(ett)); proto_register_field_array(proto_scte35_si, hf, array_length(hf)); + + /* Create a splice_insert dissector. */ + scte35_si_handle = register_dissector("scte35_si", dissect_scte35_splice_insert, proto_scte35_si); } void proto_reg_handoff_scte35_splice_insert(void) { - dissector_handle_t scte35_si_handle; - - /* Create a splice_insert dissector, and hook it into SCTE35 parsing. */ - scte35_si_handle = create_dissector_handle(dissect_scte35_splice_insert, proto_scte35_si); dissector_add_uint("scte35.splice_command_type", SCTE35_CMD_SPLICE_INSERT, scte35_si_handle); } @@ -935,15 +932,14 @@ proto_register_scte35_splice_schedule(void) proto_register_subtree_array(ett, array_length(ett)); proto_register_field_array(proto_scte35_splice_schedule, hf, array_length(hf)); + + scte35_ss_handle = register_dissector("scte35_splice_schedule", dissect_scte35_splice_schedule, proto_scte35_splice_schedule); } void proto_reg_handoff_scte35_splice_schedule(void) { - dissector_handle_t dissector; - - dissector = create_dissector_handle(dissect_scte35_splice_schedule, proto_scte35_splice_schedule); - dissector_add_uint("scte35.splice_command_type", SCTE35_CMD_SPLICE_SCHEDULE, dissector); + dissector_add_uint("scte35.splice_command_type", SCTE35_CMD_SPLICE_SCHEDULE, scte35_ss_handle); } diff --git a/epan/dissectors/packet-scylla.c b/epan/dissectors/packet-scylla.c index 173a4dc6df..c5254f7a7a 100644 --- a/epan/dissectors/packet-scylla.c +++ b/epan/dissectors/packet-scylla.c @@ -30,6 +30,8 @@ void proto_reg_handoff_scylla(void); void proto_register_scylla(void); +static dissector_handle_t scylla_handle; + #define SCYLLA_PORT 0 /* Not IANA registered, 7000 is the expected value */ #define SCYLLA_HEADER_SIZE 28 @@ -527,14 +529,13 @@ proto_register_scylla(void) proto_register_subtree_array(ett, array_length(ett)); expert_scylla = expert_register_protocol(proto_scylla); expert_register_field_array(expert_scylla, ei, array_length(ei)); + + scylla_handle = register_dissector("scylla", dissect_scylla, proto_scylla); } void proto_reg_handoff_scylla(void) { - static dissector_handle_t scylla_handle; - - scylla_handle = create_dissector_handle(dissect_scylla, proto_scylla); dissector_add_uint_with_preference("tcp.port", SCYLLA_PORT, scylla_handle); } diff --git a/epan/dissectors/packet-sdlc.c b/epan/dissectors/packet-sdlc.c index b60eebdd6c..0fca3fb9f0 100644 --- a/epan/dissectors/packet-sdlc.c +++ b/epan/dissectors/packet-sdlc.c @@ -27,6 +27,8 @@ void proto_register_sdlc(void); void proto_reg_handoff_sdlc(void); +static dissector_handle_t sdlc_handle; + static int proto_sdlc = -1; static int hf_sdlc_address = -1; static int hf_sdlc_control = -1; @@ -182,19 +184,18 @@ proto_register_sdlc(void) "Synchronous Data Link Control (SDLC)", "SDLC", "sdlc"); proto_register_field_array(proto_sdlc, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + sdlc_handle = register_dissector("sdlc", dissect_sdlc, proto_sdlc); } void proto_reg_handoff_sdlc(void) { - dissector_handle_t sdlc_handle; - /* * Get handle for the SNA dissector. */ sna_handle = find_dissector_add_dependency("sna", proto_sdlc); - sdlc_handle = create_dissector_handle(dissect_sdlc, proto_sdlc); dissector_add_uint("wtap_encap", WTAP_ENCAP_SDLC, sdlc_handle); } diff --git a/epan/dissectors/packet-sebek.c b/epan/dissectors/packet-sebek.c index d906341968..6fc1018fac 100644 --- a/epan/dissectors/packet-sebek.c +++ b/epan/dissectors/packet-sebek.c @@ -70,6 +70,8 @@ void proto_register_sebek(void); void proto_reg_handoff_sebek(void); +static dissector_handle_t sebek_handle; + static int proto_sebek = -1; static int hf_sebek_magic = -1; @@ -317,14 +319,13 @@ proto_register_sebek(void) proto_sebek = proto_register_protocol("SEBEK - Kernel Data Capture", "SEBEK", "sebek"); proto_register_field_array(proto_sebek, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + sebek_handle = register_dissector("sebek", dissect_sebek, proto_sebek); } void proto_reg_handoff_sebek(void) { - dissector_handle_t sebek_handle; - - sebek_handle = create_dissector_handle(dissect_sebek, proto_sebek); dissector_add_uint_with_preference("udp.port", UDP_PORT_SEBEK, sebek_handle); } diff --git a/epan/dissectors/packet-sercosiii.c b/epan/dissectors/packet-sercosiii.c index 0521f32c9d..268fef7b63 100644 --- a/epan/dissectors/packet-sercosiii.c +++ b/epan/dissectors/packet-sercosiii.c @@ -36,6 +36,8 @@ void proto_register_sercosiii(void); void proto_reg_handoff_sercosiii(void); +static dissector_handle_t siii_handle; + /* Initialize the protocol and registered fields */ static gint proto_siii = -1; @@ -1607,7 +1609,7 @@ proto_register_sercosiii(void) proto_siii = proto_register_protocol("SERCOS III V1.1", "SERCOS III V1.1", "siii"); - register_dissector("sercosiii", dissect_siii, proto_siii); + siii_handle = register_dissector("sercosiii", dissect_siii, proto_siii); /* subdissector code */ heur_subdissector_list = register_heur_dissector_list("sercosiii", proto_siii); @@ -1622,9 +1624,6 @@ proto_register_sercosiii(void) void proto_reg_handoff_sercosiii(void) { - dissector_handle_t siii_handle; - - siii_handle = create_dissector_handle(dissect_siii, proto_siii); dissector_add_uint("ethertype", ETHERTYPE_SERCOS, siii_handle); } diff --git a/epan/dissectors/packet-sflow.c b/epan/dissectors/packet-sflow.c index c86fecb9ec..44185efa92 100644 --- a/epan/dissectors/packet-sflow.c +++ b/epan/dissectors/packet-sflow.c @@ -3794,6 +3794,9 @@ proto_register_sflow(void) { header_subdissector_table = register_dissector_table("sflow_245.header_protocol", "SFLOW header protocol", proto_sflow, FT_UINT32, BASE_DEC); + /* Register our dissector handle */ + sflow_handle = register_dissector("sflow", dissect_sflow_245, proto_sflow); + /* Register our configuration options for sFlow */ sflow_245_module = prefs_register_protocol(proto_sflow, NULL); @@ -3828,7 +3831,6 @@ proto_register_sflow(void) { void proto_reg_handoff_sflow_245(void) { - sflow_handle = create_dissector_handle(dissect_sflow_245, proto_sflow); dissector_add_uint_range_with_preference("udp.port", SFLOW_UDP_PORTS, sflow_handle); } diff --git a/epan/dissectors/packet-shim6.c b/epan/dissectors/packet-shim6.c index cae37fe185..c696840c59 100644 --- a/epan/dissectors/packet-shim6.c +++ b/epan/dissectors/packet-shim6.c @@ -24,6 +24,8 @@ void proto_register_shim6(void); void proto_reg_handoff_shim6(void); +static dissector_handle_t shim6_handle; + /* SHIM6 header */ struct ip6_shim { guint8 ip6s_nxt; /* next header */ @@ -852,14 +854,12 @@ proto_register_shim6(void) proto_register_subtree_array(ett_shim6, array_length(ett_shim6)); expert_shim6 = expert_register_protocol(proto_shim6); expert_register_field_array(expert_shim6, ei_shim6, array_length(ei_shim6)); + shim6_handle = register_dissector("shim6", dissect_shim6, proto_shim6); } void proto_reg_handoff_shim6(void) { - dissector_handle_t shim6_handle; - - shim6_handle = create_dissector_handle(dissect_shim6, proto_shim6); dissector_add_uint("ip.proto", IP_PROTO_SHIM6, shim6_handle); } diff --git a/epan/dissectors/packet-simple.c b/epan/dissectors/packet-simple.c index 49648d85e5..822b94912e 100644 --- a/epan/dissectors/packet-simple.c +++ b/epan/dissectors/packet-simple.c @@ -176,6 +176,7 @@ static const value_string Link11_Role[] = { static int proto_simple = -1; +static dissector_handle_t simple_dissector_handle; static dissector_handle_t link16_handle; static gint hf_simple_sync_byte_1 = -1; @@ -660,13 +661,11 @@ void proto_register_simple(void) proto_register_subtree_array(ett, array_length(ett)); expert_simple = expert_register_protocol(proto_simple); expert_register_field_array(expert_simple, ei, array_length(ei)); - register_dissector("simple", dissect_simple, proto_simple); + simple_dissector_handle = register_dissector("simple", dissect_simple, proto_simple); } void proto_reg_handoff_simple(void) { - dissector_handle_t simple_dissector_handle; - simple_dissector_handle = create_dissector_handle(dissect_simple, proto_simple); dissector_add_for_decode_as_with_preference("udp.port", simple_dissector_handle); dissector_add_for_decode_as_with_preference("tcp.port", simple_dissector_handle); diff --git a/epan/dissectors/packet-simulcrypt.c b/epan/dissectors/packet-simulcrypt.c index 5e35504a65..5fac3a135c 100644 --- a/epan/dissectors/packet-simulcrypt.c +++ b/epan/dissectors/packet-simulcrypt.c @@ -60,6 +60,9 @@ static void dissect_simulcrypt_data(proto_tree *simulcrypt_tree, proto_item *sim /* Wireshark ID of the SIMULCRYPT protocol */ static guint proto_simulcrypt = -1; +/* Dissector handle for SIMULCRYPT protocol */ +static dissector_handle_t simulcrypt_handle; + /* Preferences (with default values) */ static int ca_system_id_mikey = CA_SYSTEM_ID_MIKEY; /* MIKEY ECM CA_system_ID */ @@ -1803,6 +1806,8 @@ proto_register_simulcrypt (void) register_init_routine(simulcrypt_init); + simulcrypt_handle = register_dissector("simulcrypt", dissect_simulcrypt, proto_simulcrypt); + /* Register our configuration options for Simulcrypt, particularly our port. */ /* This registers our preferences; function proto_reg_handoff_simulcrypt is */ /* called when preferences are applied. */ @@ -1817,11 +1822,9 @@ void proto_reg_handoff_simulcrypt(void) { static gboolean initialized=FALSE; - dissector_handle_t simulcrypt_handle; guint i; if (!initialized) { - simulcrypt_handle = create_dissector_handle(dissect_simulcrypt, proto_simulcrypt); for(i=0;i<ECM_INTERPRETATION_SIZE;i++) { tab_ecm_inter[i].protocol_handle = find_dissector(tab_ecm_inter[i].protocol_name); diff --git a/epan/dissectors/packet-skype.c b/epan/dissectors/packet-skype.c index 97cbdce7f4..7acd4f4aa8 100644 --- a/epan/dissectors/packet-skype.c +++ b/epan/dissectors/packet-skype.c @@ -36,6 +36,8 @@ void proto_register_skype(void); void proto_reg_handoff_skype(void); +static dissector_handle_t skype_handle; + /* Things we may want to remember for a whole conversation */ typedef struct _skype_udp_conv_info_t { guint32 global_src_ip; @@ -426,14 +428,13 @@ proto_register_skype(void) proto_skype = proto_register_protocol(PROTO_LONG_NAME, PROTO_SHORT_NAME, "skype"); proto_register_field_array(proto_skype, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + skype_handle = register_dissector("skype", dissect_skype_static, proto_skype); } void proto_reg_handoff_skype(void) { - dissector_handle_t skype_handle; - - skype_handle = create_dissector_handle(dissect_skype_static, proto_skype); dissector_add_for_decode_as_with_preference("tcp.port", skype_handle); dissector_add_for_decode_as_with_preference("udp.port", skype_handle); diff --git a/epan/dissectors/packet-slimp3.c b/epan/dissectors/packet-slimp3.c index 9242e26b01..3ef2882e9f 100644 --- a/epan/dissectors/packet-slimp3.c +++ b/epan/dissectors/packet-slimp3.c @@ -21,6 +21,8 @@ void proto_register_slimp3(void); void proto_reg_handoff_slimp3(void); +static dissector_handle_t slimp3_handle; + static int proto_slimp3 = -1; static int hf_slimp3_opcode = -1; static int hf_slimp3_control = -1; @@ -691,14 +693,13 @@ proto_register_slimp3(void) proto_slimp3 = proto_register_protocol("SliMP3 Communication Protocol", "SliMP3", "slimp3"); proto_register_field_array(proto_slimp3, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + slimp3_handle = register_dissector("slimp3", dissect_slimp3, proto_slimp3); } void proto_reg_handoff_slimp3(void) { - dissector_handle_t slimp3_handle; - - slimp3_handle = create_dissector_handle(dissect_slimp3, proto_slimp3); dissector_add_uint_range_with_preference("udp.port", UDP_PORT_SLIMP3_RANGE, slimp3_handle); } diff --git a/epan/dissectors/packet-slowprotocols.c b/epan/dissectors/packet-slowprotocols.c index 46c4b67803..c8f8ad7435 100644 --- a/epan/dissectors/packet-slowprotocols.c +++ b/epan/dissectors/packet-slowprotocols.c @@ -25,6 +25,8 @@ void proto_register_slow_protocols(void); void proto_reg_handoff_slow_protocols(void); +static dissector_handle_t slow_protocols_handle; + static dissector_table_t slow_protocols_dissector_table; static const value_string subtype_vals[] = { @@ -121,6 +123,9 @@ proto_register_slow_protocols(void) proto_register_field_array(proto_slow, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + /* Register the dissector handle */ + slow_protocols_handle = register_dissector("slow", dissect_slow_protocols, proto_slow); + /* subdissector code */ slow_protocols_dissector_table = register_dissector_table("slow.subtype", "Slow protocol subtype", @@ -130,9 +135,6 @@ proto_register_slow_protocols(void) void proto_reg_handoff_slow_protocols(void) { - dissector_handle_t slow_protocols_handle; - - slow_protocols_handle = create_dissector_handle(dissect_slow_protocols, proto_slow); dissector_add_uint("ethertype", ETHERTYPE_SLOW_PROTOCOLS, slow_protocols_handle); } diff --git a/epan/dissectors/packet-slsk.c b/epan/dissectors/packet-slsk.c index e5893b9f0c..2ee9a9254a 100644 --- a/epan/dissectors/packet-slsk.c +++ b/epan/dissectors/packet-slsk.c @@ -28,6 +28,8 @@ void proto_register_slsk(void); void proto_reg_handoff_slsk(void); +static dissector_handle_t slsk_handle; + /* Initialize the protocol and registered fields */ static int proto_slsk = -1; @@ -2335,9 +2337,11 @@ proto_register_slsk(void) expert_slsk = expert_register_protocol(proto_slsk); expert_register_field_array(expert_slsk, ei, array_length(ei)); - slsk_module = prefs_register_protocol(proto_slsk, NULL); + /* Register the dissector handle */ + slsk_handle = register_dissector("slsk", dissect_slsk, proto_slsk); /* Registers the options in the menu preferences */ + slsk_module = prefs_register_protocol(proto_slsk, NULL); prefs_register_bool_preference(slsk_module, "desegment", "Reassemble SoulSeek messages spanning multiple TCP segments", "Whether the SoulSeek dissector should reassemble messages spanning multiple TCP segments." @@ -2356,9 +2360,6 @@ proto_register_slsk(void) void proto_reg_handoff_slsk(void) { - dissector_handle_t slsk_handle; - - slsk_handle = create_dissector_handle(dissect_slsk, proto_slsk); dissector_add_uint_range_with_preference("tcp.port", SLSK_TCP_PORT_RANGE, slsk_handle); } diff --git a/epan/dissectors/packet-smb-direct.c b/epan/dissectors/packet-smb-direct.c index 60b8270044..a612df37aa 100644 --- a/epan/dissectors/packet-smb-direct.c +++ b/epan/dissectors/packet-smb-direct.c @@ -25,6 +25,8 @@ void proto_register_smb_direct(void); void proto_reg_handoff_smb_direct(void); +static dissector_handle_t smb_direct_handle; + static int proto_smb_direct = -1; static gint ett_smb_direct = -1; @@ -662,6 +664,8 @@ void proto_register_smb_direct(void) proto_register_subtree_array(ett, array_length(ett)); proto_register_field_array(proto_smb_direct, hf, array_length(hf)); + smb_direct_handle = register_dissector("smb_direct", dissect_smb_direct_infiniband, proto_smb_direct); + smb_direct_heur_subdissector_list = register_heur_dissector_list("smb_direct", proto_smb_direct); smb_direct_module = prefs_register_protocol(proto_smb_direct, NULL); @@ -685,7 +689,7 @@ proto_reg_handoff_smb_direct(void) dissect_smb_direct_infiniband_heur, "SMB Direct Infiniband", "smb_direct_infiniband", proto_smb_direct, HEURISTIC_ENABLE); - dissector_add_for_decode_as("infiniband", create_dissector_handle( dissect_smb_direct_infiniband, proto_smb_direct ) ); + dissector_add_for_decode_as("infiniband", smb_direct_handle); } diff --git a/epan/dissectors/packet-smc.c b/epan/dissectors/packet-smc.c index 25dd924394..06075b5039 100644 --- a/epan/dissectors/packet-smc.c +++ b/epan/dissectors/packet-smc.c @@ -439,6 +439,7 @@ static int hf_smcr_rmbe_ctrl_peer_abnormal_close = -1; void proto_register_smcr(void); void proto_reg_handoff_smcr(void); static dissector_handle_t smc_tcp_handle; +static dissector_handle_t smc_infiniband_handle; static void disect_smc_uncompress_size(proto_item* ti, guint size, guint max_valid) @@ -2559,6 +2560,7 @@ proto_register_smcr(void) proto_register_subtree_array(ett, array_length(ett)); smc_tcp_handle = register_dissector("smc", dissect_smc_tcp, proto_smc); + smc_infiniband_handle = register_dissector("smc.infiniband", dissect_smcr_infiniband, proto_smc); } void @@ -2566,7 +2568,7 @@ proto_reg_handoff_smcr(void) { heur_dissector_add("tcp", dissect_smc_tcp_heur, "Shared Memory Communications over TCP", "smc_tcp", proto_smc, HEURISTIC_ENABLE); heur_dissector_add("infiniband.payload", dissect_smcr_infiniband_heur, "Shared Memory Communications Infiniband", "smcr_infiniband", proto_smc, HEURISTIC_ENABLE); - dissector_add_for_decode_as("infiniband", create_dissector_handle( dissect_smcr_infiniband, proto_smc ) ); + dissector_add_for_decode_as("infiniband", smc_infiniband_handle); } /* diff --git a/epan/dissectors/packet-sml.c b/epan/dissectors/packet-sml.c index 52b4a8c34b..8051f34015 100644 --- a/epan/dissectors/packet-sml.c +++ b/epan/dissectors/packet-sml.c @@ -78,6 +78,8 @@ Short description of the SML protocol on the SML Wireshark Wiki page: void proto_register_sml(void); void proto_reg_handoff_sml(void); +static dissector_handle_t sml_handle; + /* Initialize the protocol and registered fields */ static int proto_sml = -1; @@ -3005,6 +3007,8 @@ void proto_register_sml (void) { }; proto_sml = proto_register_protocol("Smart Message Language","SML", "sml"); + sml_handle = register_dissector("sml", dissect_sml, proto_sml); + sml_module = prefs_register_protocol(proto_sml, NULL); prefs_register_bool_preference (sml_module, "reassemble", "Enable reassemble", "Enable reassembling (default is enabled)", &sml_reassemble); @@ -3017,13 +3021,8 @@ void proto_register_sml (void) { } void proto_reg_handoff_sml(void) { - dissector_handle_t sml_handle; - - sml_handle = create_dissector_handle(dissect_sml, proto_sml); dissector_add_for_decode_as_with_preference("tcp.port", sml_handle); dissector_add_for_decode_as_with_preference("udp.port", sml_handle); - - register_dissector("sml", dissect_sml, proto_sml); } /* diff --git a/epan/dissectors/packet-smp.c b/epan/dissectors/packet-smp.c index c50db501b2..989034f1a5 100644 --- a/epan/dissectors/packet-smp.c +++ b/epan/dissectors/packet-smp.c @@ -68,6 +68,7 @@ static gint ett_smp_flags = -1; #define SMP_MIN_LENGTH 16 static dissector_handle_t tds_handle; +static dissector_handle_t smp_handle; static dissector_table_t smp_payload_table; static gboolean reassemble_smp = TRUE; @@ -232,6 +233,7 @@ proto_register_smp(void) proto_register_field_array(proto_smp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("smp_tds", dissect_smp_tds, proto_smp); + smp_handle = register_dissector("smp", dissect_smp, proto_smp); smp_payload_table = register_decode_as_next_proto(proto_smp, "smp.payload", "SMP Payload", smp_prompt); @@ -246,8 +248,6 @@ proto_register_smp(void) void proto_reg_handoff_smp(void) { - dissector_handle_t smp_handle; - smp_handle = create_dissector_handle(dissect_smp, proto_smp); dissector_add_for_decode_as_with_preference("tcp.port", smp_handle); tds_handle = find_dissector_add_dependency("tds", proto_smp); diff --git a/epan/dissectors/packet-snaeth.c b/epan/dissectors/packet-snaeth.c index c9cede09ad..029030e93e 100644 --- a/epan/dissectors/packet-snaeth.c +++ b/epan/dissectors/packet-snaeth.c @@ -28,6 +28,7 @@ static int hf_snaeth_padding = -1; static gint ett_snaeth = -1; static dissector_handle_t llc_handle; +static dissector_handle_t snaeth_handle; static int dissect_snaeth(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) @@ -84,19 +85,18 @@ proto_register_snaeth(void) "SNAETH", "snaeth"); proto_register_field_array(proto_snaeth, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + snaeth_handle = register_dissector("snaeth", dissect_snaeth, proto_snaeth); } void proto_reg_handoff_snaeth(void) { - dissector_handle_t snaeth_handle; - /* * Get handle for the LLC dissector. */ llc_handle = find_dissector_add_dependency("llc", proto_snaeth); - snaeth_handle = create_dissector_handle(dissect_snaeth, proto_snaeth); dissector_add_uint("ethertype", ETHERTYPE_SNA, snaeth_handle); } diff --git a/epan/dissectors/packet-snort.c b/epan/dissectors/packet-snort.c index a497064c35..4fb9e23a57 100644 --- a/epan/dissectors/packet-snort.c +++ b/epan/dissectors/packet-snort.c @@ -1575,7 +1575,7 @@ proto_register_snort(void) &snort_ignore_checksum_errors); - snort_handle = create_dissector_handle(snort_dissector, proto_snort); + snort_handle = register_dissector("snort", snort_dissector, proto_snort); register_init_routine(snort_start); register_postdissector(snort_handle); diff --git a/epan/dissectors/packet-socketcan.c b/epan/dissectors/packet-socketcan.c index c71f3f46c3..c8fbf93630 100644 --- a/epan/dissectors/packet-socketcan.c +++ b/epan/dissectors/packet-socketcan.c @@ -108,6 +108,8 @@ static dissector_table_t can_extended_id_dissector_table = NULL; static dissector_table_t subdissector_table = NULL; static dissector_handle_t socketcan_classic_handle; static dissector_handle_t socketcan_fd_handle; +static dissector_handle_t socketcan_bigendian_handle; + static const value_string can_err_prot_error_location_vals[] = { { 0x00, "unspecified" }, @@ -841,6 +843,7 @@ proto_register_socketcan(void) { * "can-hostendian" as the dissector name. */ socketcan_classic_handle = register_dissector("can-hostendian", dissect_socketcan_classic, proto_can); + socketcan_bigendian_handle = register_dissector("can-bigendian", dissect_socketcan_bigendian, proto_can); proto_canfd = proto_register_protocol("Controller Area Network FD", "CANFD", "canfd"); socketcan_fd_handle = register_dissector("canfd", dissect_socketcan_fd, proto_canfd); @@ -926,9 +929,6 @@ proto_register_socketcan(void) { void proto_reg_handoff_socketcan(void) { - dissector_handle_t socketcan_bigendian_handle; - - socketcan_bigendian_handle = create_dissector_handle(dissect_socketcan_bigendian, proto_can); dissector_add_uint("wtap_encap", WTAP_ENCAP_SOCKETCAN, socketcan_bigendian_handle); dissector_add_uint("sll.ltype", LINUX_SLL_P_CAN, socketcan_classic_handle); diff --git a/epan/dissectors/packet-solaredge.c b/epan/dissectors/packet-solaredge.c index e9bedf98b5..34e81c78f4 100644 --- a/epan/dissectors/packet-solaredge.c +++ b/epan/dissectors/packet-solaredge.c @@ -477,6 +477,8 @@ typedef struct solaredge_conversion_data { void proto_reg_handoff_solaredge(void); void proto_register_solaredge(void); +static dissector_handle_t solaredge_handle; + static gboolean global_show_unknown_fields = TRUE; static expert_field ei_solaredge_invalid_length = EI_INIT; @@ -1357,8 +1359,6 @@ dissect_solaredge(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree _U_, void void proto_reg_handoff_solaredge(void) { - dissector_handle_t solaredge_handle; - solaredge_handle = create_dissector_handle(dissect_solaredge, proto_solaredge); dissector_add_for_decode_as("tcp.port", solaredge_handle); } @@ -1658,6 +1658,7 @@ proto_register_solaredge(void) "SolarEdge", "solaredge" ); + solaredge_handle = register_dissector("solaredge", dissect_solaredge, proto_solaredge); module_t * module_solaredge = prefs_register_protocol(proto_solaredge, NULL); prefs_register_bool_preference(module_solaredge, "unknown", "Show unknown fields", "Show unidentified fields (\"padding\") in packet dissections", &global_show_unknown_fields); diff --git a/epan/dissectors/packet-someip-sd.c b/epan/dissectors/packet-someip-sd.c index af89f3a9aa..85144d5925 100644 --- a/epan/dissectors/packet-someip-sd.c +++ b/epan/dissectors/packet-someip-sd.c @@ -247,6 +247,8 @@ static expert_field ef_someipsd_config_string_malformed = EI_INIT; void proto_register_someip_sd(void); void proto_reg_handoff_someip_sd(void); +static dissector_handle_t someip_sd_handle; + /************************************** ******** SOME/IP-SD Dissector ******** *************************************/ @@ -1195,16 +1197,17 @@ proto_register_someip_sd(void) { { &ef_someipsd_config_string_malformed,{ "someipsd.config_string_malformed", PI_MALFORMED, PI_ERROR, "SOME/IP-SD Configuration String malformed!", EXPFILL } }, }; - /* Register Protocol, Fields, ETTs, Expert Info, Taps */ + /* Register Protocol, Fields, ETTs, Expert Info, Taps, Dissector */ proto_someip_sd = proto_register_protocol(SOMEIP_SD_NAME_LONG, SOMEIP_SD_NAME, SOMEIP_SD_NAME_FILTER); proto_register_field_array(proto_someip_sd, hf_sd, array_length(hf_sd)); proto_register_subtree_array(ett_sd, array_length(ett_sd)); expert_module_someip_sd = expert_register_protocol(proto_someip_sd); expert_register_field_array(expert_module_someip_sd, ei_sd, array_length(ei_sd)); tap_someip_sd_entries = register_tap("someipsd_entries"); + someip_sd_handle = register_dissector(SOMEIP_SD_NAME_FILTER, dissect_someip_sd_pdu, proto_someip_sd); /* Register preferences */ - someipsd_module = prefs_register_protocol(proto_someip_sd, &proto_reg_handoff_someip_sd); + someipsd_module = prefs_register_protocol(proto_someip_sd, NULL); range_convert_str(wmem_epan_scope(), &someip_ignore_ports_udp, "", 65535); prefs_register_range_preference(someipsd_module, "ports.udp.ignore", "UDP Ports ignored", @@ -1219,19 +1222,8 @@ proto_register_someip_sd(void) { void proto_reg_handoff_someip_sd(void) { - static gboolean initialized = FALSE; - static dissector_handle_t someip_sd_handle = NULL; - - if (!initialized) { - someip_sd_handle = create_dissector_handle(dissect_someip_sd_pdu, proto_someip_sd); - dissector_add_uint("someip.messageid", SOMEIP_SD_MESSAGEID, someip_sd_handle); - - stats_tree_register("someipsd_entries", "someipsd_entries", "SOME/IP-SD Entries", 0, someipsd_entries_stats_tree_packet, someipsd_entries_stats_tree_init, NULL); - - initialized = TRUE; - } - - /* nothing to do here right now */ + dissector_add_uint("someip.messageid", SOMEIP_SD_MESSAGEID, someip_sd_handle); + stats_tree_register("someipsd_entries", "someipsd_entries", "SOME/IP-SD Entries", 0, someipsd_entries_stats_tree_packet, someipsd_entries_stats_tree_init, NULL); } /* diff --git a/epan/dissectors/packet-soupbintcp.c b/epan/dissectors/packet-soupbintcp.c index e14c42d3f9..6b8baa5cd5 100644 --- a/epan/dissectors/packet-soupbintcp.c +++ b/epan/dissectors/packet-soupbintcp.c @@ -523,6 +523,7 @@ proto_register_soupbintcp(void) module_t *soupbintcp_module; proto_soupbintcp = proto_register_protocol("SoupBinTCP", "SoupBinTCP", "soupbintcp"); + soupbintcp_handle = register_dissector("soupbintcp", dissect_soupbintcp_tcp, proto_soupbintcp); proto_register_field_array(proto_soupbintcp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); @@ -547,7 +548,6 @@ proto_register_soupbintcp(void) void proto_reg_handoff_soupbintcp(void) { - soupbintcp_handle = create_dissector_handle(dissect_soupbintcp_tcp, proto_soupbintcp); dissector_add_uint_range_with_preference("tcp.port", "", soupbintcp_handle); } diff --git a/epan/dissectors/packet-spice.c b/epan/dissectors/packet-spice.c index 3eb903ecac..22681c11a9 100644 --- a/epan/dissectors/packet-spice.c +++ b/epan/dissectors/packet-spice.c @@ -4689,6 +4689,9 @@ proto_register_spice(void) /* Register the protocol name and description */ proto_spice = proto_register_protocol("Spice protocol", "Spice", "spice"); + /* Register the dissector handle */ + spice_handle = register_dissector("spice", dissect_spice, proto_spice); + /* Required function calls to register the header fields and subtrees */ proto_register_field_array(proto_spice, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); @@ -4700,7 +4703,6 @@ proto_register_spice(void) void proto_reg_handoff_spice(void) { - spice_handle = create_dissector_handle(dissect_spice, proto_spice); dissector_add_for_decode_as_with_preference("tcp.port", spice_handle); heur_dissector_add("tcp", test_spice_protocol, "Spice over TCP", "spice_tcp", proto_spice, HEURISTIC_ENABLE); jpeg_handle = find_dissector_add_dependency("image-jfif", proto_spice); diff --git a/epan/dissectors/packet-srt.c b/epan/dissectors/packet-srt.c index d7a1c0bf07..b36a89bed0 100644 --- a/epan/dissectors/packet-srt.c +++ b/epan/dissectors/packet-srt.c @@ -1259,14 +1259,12 @@ void proto_register_srt(void) expert_srt = expert_register_protocol(proto_srt); expert_register_field_array(expert_srt, ei, array_length(ei)); - register_dissector("srt", dissect_srt_udp, proto_srt); + srt_udp_handle = register_dissector("srt", dissect_srt_udp, proto_srt); } void proto_reg_handoff_srt(void) { - srt_udp_handle = create_dissector_handle(dissect_srt_udp, proto_srt); - /* register as heuristic dissector for UDP */ heur_dissector_add("udp", dissect_srt_heur_udp, "SRT over UDP", "srt_udp", proto_srt, HEURISTIC_ENABLE); diff --git a/epan/dissectors/packet-srvloc.c b/epan/dissectors/packet-srvloc.c index 0f4823b39d..18d6525895 100644 --- a/epan/dissectors/packet-srvloc.c +++ b/epan/dissectors/packet-srvloc.c @@ -32,6 +32,9 @@ void proto_register_srvloc(void); void proto_reg_handoff_srvloc(void); +static dissector_handle_t srvloc_handle; +static dissector_handle_t srvloc_tcp_handle; + static gboolean srvloc_desegment = TRUE; static int proto_srvloc = -1; static int hf_srvloc_version = -1; @@ -1856,6 +1859,8 @@ proto_register_srvloc(void) "SRVLOC", "srvloc"); proto_register_field_array(proto_srvloc, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + srvloc_handle = register_dissector("srvloc", dissect_srvloc, proto_srvloc); + srvloc_tcp_handle = register_dissector("srvloc.tcp", dissect_srvloc_tcp, proto_srvloc); expert_srvloc = expert_register_protocol(proto_srvloc); expert_register_field_array(expert_srvloc, ei, array_length(ei)); srvloc_module = prefs_register_protocol(proto_srvloc, NULL); @@ -1869,11 +1874,7 @@ proto_register_srvloc(void) void proto_reg_handoff_srvloc(void) { - dissector_handle_t srvloc_handle, srvloc_tcp_handle; - srvloc_handle = create_dissector_handle(dissect_srvloc, proto_srvloc); dissector_add_uint_with_preference("udp.port", UDP_PORT_SRVLOC, srvloc_handle); - srvloc_tcp_handle = create_dissector_handle(dissect_srvloc_tcp, - proto_srvloc); dissector_add_uint_with_preference("tcp.port", TCP_PORT_SRVLOC, srvloc_tcp_handle); } diff --git a/epan/dissectors/packet-ssyncp.c b/epan/dissectors/packet-ssyncp.c index 310193a961..c5d1e09b17 100644 --- a/epan/dissectors/packet-ssyncp.c +++ b/epan/dissectors/packet-ssyncp.c @@ -42,6 +42,8 @@ void proto_reg_handoff_ssyncp(void); void proto_register_ssyncp(void); +static dissector_handle_t ssyncp_handle; + static int proto_ssyncp = -1; static int hf_ssyncp_direction = -1; static int hf_ssyncp_seq = -1; @@ -402,6 +404,9 @@ proto_register_ssyncp(void) /* Register the protocol name and description */ proto_ssyncp = proto_register_protocol("State Synchronization Protocol", "SSyncP", "ssyncp"); + /* Register the dissector handle */ + ssyncp_handle = register_dissector("ssyncp", dissect_ssyncp, proto_ssyncp); + /* Required function calls to register the header fields and subtrees */ proto_register_field_array(proto_ssyncp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); @@ -420,11 +425,9 @@ proto_register_ssyncp(void) void proto_reg_handoff_ssyncp(void) { - static dissector_handle_t ssyncp_handle; static gboolean initialized = FALSE; if (!initialized) { - ssyncp_handle = create_dissector_handle(dissect_ssyncp, proto_ssyncp); dissector_add_uint("udp.port", SSYNCP_UDP_PORT, ssyncp_handle); dissector_protobuf = find_dissector("protobuf"); diff --git a/epan/dissectors/packet-starteam.c b/epan/dissectors/packet-starteam.c index 61c5d5ac9a..d1eccb23ab 100644 --- a/epan/dissectors/packet-starteam.c +++ b/epan/dissectors/packet-starteam.c @@ -683,6 +683,8 @@ proto_register_starteam(void) proto_register_field_array(proto_starteam, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + starteam_tcp_handle = register_dissector("starteam", dissect_starteam_tcp, proto_starteam); + starteam_module = prefs_register_protocol(proto_starteam, NULL); prefs_register_bool_preference(starteam_module, "desegment", "Reassemble StarTeam messages spanning multiple TCP segments", @@ -696,7 +698,6 @@ void proto_reg_handoff_starteam(void) { heur_dissector_add("tcp", dissect_starteam_heur, "StarTeam over TCP", "starteam_tcp", proto_starteam, HEURISTIC_ENABLE); - starteam_tcp_handle = create_dissector_handle(dissect_starteam_tcp, proto_starteam); } /* diff --git a/epan/dissectors/packet-steam-ihs-discovery.c b/epan/dissectors/packet-steam-ihs-discovery.c index 9830979dca..8c5748b63f 100644 --- a/epan/dissectors/packet-steam-ihs-discovery.c +++ b/epan/dissectors/packet-steam-ihs-discovery.c @@ -29,6 +29,8 @@ void proto_reg_handoff_steam_ihs_discovery(void); void proto_register_steam_ihs_discovery(void); +static dissector_handle_t steam_ihs_discovery_handle; + static int proto_steam_ihs_discovery = -1; static int hf_steam_ihs_discovery_signature = -1; @@ -1404,6 +1406,9 @@ proto_register_steam_ihs_discovery(void) proto_steam_ihs_discovery = proto_register_protocol("Steam In-Home Streaming Discovery Protocol", "Steam IHS Discovery", "steam_ihs_discovery"); + /* Register the dissector handle */ + steam_ihs_discovery_handle = register_dissector("steam_ihs_discovery", dissect_steam_ihs_discovery, proto_steam_ihs_discovery); + /* Required function calls to register the header fields and subtrees */ proto_register_field_array(proto_steam_ihs_discovery, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); @@ -1419,10 +1424,6 @@ proto_register_steam_ihs_discovery(void) void proto_reg_handoff_steam_ihs_discovery(void) { - static dissector_handle_t steam_ihs_discovery_handle; - - steam_ihs_discovery_handle = create_dissector_handle(dissect_steam_ihs_discovery, proto_steam_ihs_discovery); - dissector_add_uint_with_preference("udp.port", STEAM_IHS_DISCOVERY_UDP_PORT, steam_ihs_discovery_handle); } diff --git a/epan/dissectors/packet-swipe.c b/epan/dissectors/packet-swipe.c index 40a42cf2b3..0c8fee0364 100644 --- a/epan/dissectors/packet-swipe.c +++ b/epan/dissectors/packet-swipe.c @@ -41,6 +41,7 @@ static int hf_swipe_authenticator = -1; /* Initialize the subtree pointers */ static gint ett_swipe = -1; +static dissector_handle_t swipe_handle; static dissector_handle_t ipv6_handle; static int @@ -104,6 +105,9 @@ proto_register_swipe(void) /* Register the protocol name and description */ proto_swipe = proto_register_protocol("swIPe IP Security Protocol", "swIPe", "swipe"); + /* Register the dissector handle */ + swipe_handle = register_dissector("swipe", dissect_swipe, proto_swipe); + /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_swipe, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); @@ -112,9 +116,6 @@ proto_register_swipe(void) void proto_reg_handoff_swipe(void) { - dissector_handle_t swipe_handle; - - swipe_handle = create_dissector_handle(dissect_swipe, proto_swipe ); dissector_add_uint("ip.proto", IP_PROTO_SWIPE, swipe_handle); ipv6_handle = find_dissector_add_dependency("ipv6", proto_swipe ); diff --git a/epan/dissectors/packet-synphasor.c b/epan/dissectors/packet-synphasor.c index b9c136a7fd..592be5b6f5 100644 --- a/epan/dissectors/packet-synphasor.c +++ b/epan/dissectors/packet-synphasor.c @@ -174,6 +174,7 @@ static expert_field ei_synphasor_data_error = EI_INIT; static expert_field ei_synphasor_pmu_not_sync = EI_INIT; static dissector_handle_t synphasor_udp_handle; +static dissector_handle_t synphasor_tcp_handle; /* the different frame types for this protocol */ enum FrameType { @@ -2346,6 +2347,7 @@ void proto_register_synphasor(void) /* Registering protocol to be called by another dissector */ synphasor_udp_handle = register_dissector("synphasor", dissect_udp, proto_synphasor); + synphasor_tcp_handle = register_dissector("synphasor.tcp", dissect_tcp, proto_synphasor); proto_register_field_array(proto_synphasor, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); @@ -2357,13 +2359,9 @@ void proto_register_synphasor(void) /* called at startup and when the preferences change */ void proto_reg_handoff_synphasor(void) { - dissector_handle_t synphasor_tcp_handle; - - synphasor_tcp_handle = create_dissector_handle(dissect_tcp, proto_synphasor); dissector_add_for_decode_as("rtacser.data", synphasor_udp_handle); dissector_add_uint_with_preference("udp.port", SYNPHASOR_UDP_PORT, synphasor_udp_handle); dissector_add_uint_with_preference("tcp.port", SYNPHASOR_TCP_PORT, synphasor_tcp_handle); - } /* proto_reg_handoff_synphasor() */ /* diff --git a/epan/dissectors/packet-sysdig-event.c b/epan/dissectors/packet-sysdig-event.c index 4973bd8380..c42e7f20a1 100644 --- a/epan/dissectors/packet-sysdig-event.c +++ b/epan/dissectors/packet-sysdig-event.c @@ -52,6 +52,8 @@ void proto_reg_handoff_sysdig_event(void); void proto_register_sysdig_event(void); +static dissector_handle_t sysdig_event_handle; + /* Initialize the protocol and registered fields */ static int proto_sysdig_event = -1; /* Add byte order? */ @@ -3225,20 +3227,12 @@ proto_register_sysdig_event(void) proto_register_field_array(proto_sysdig_event, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - register_dissector("sysdig", dissect_sysdig_event, proto_sysdig_event); + sysdig_event_handle = register_dissector("sysdig", dissect_sysdig_event, proto_sysdig_event); } void proto_reg_handoff_sysdig_event(void) { - dissector_handle_t sysdig_event_handle; - - /* Use create_dissector_handle() to indicate that dissect_sysdig_event() - * returns the number of bytes it dissected (or 0 if it thinks the packet - * does not belong to PROTONAME). - */ - sysdig_event_handle = create_dissector_handle(dissect_sysdig_event, - proto_sysdig_event); dissector_add_uint("pcapng.block_type", BLOCK_TYPE_SYSDIG_EVENT, sysdig_event_handle); dissector_add_uint("pcapng.block_type", BLOCK_TYPE_SYSDIG_EVENT_V2, sysdig_event_handle); dissector_add_uint("pcapng.block_type", BLOCK_TYPE_SYSDIG_EVENT_V2_LARGE, sysdig_event_handle); diff --git a/epan/dissectors/packet-tacacs.c b/epan/dissectors/packet-tacacs.c index 2caedc64f3..386773d2b4 100644 --- a/epan/dissectors/packet-tacacs.c +++ b/epan/dissectors/packet-tacacs.c @@ -34,9 +34,11 @@ void proto_reg_handoff_tacacs(void); void proto_register_tacacs(void); +static dissector_handle_t tacacs_handle; void proto_reg_handoff_tacplus(void); void proto_register_tacplus(void); +static dissector_handle_t tacplus_handle; static void md5_xor( guint8 *data, const char *key, int data_len, guint8 *session_id, guint8 version, guint8 seq_no ); static int dissect_tacplus_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data); @@ -261,14 +263,12 @@ proto_register_tacacs(void) proto_tacacs = proto_register_protocol("TACACS", "TACACS", "tacacs"); proto_register_field_array(proto_tacacs, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + tacacs_handle = register_dissector("tacacs", dissect_tacacs, proto_tacacs); } void proto_reg_handoff_tacacs(void) { - dissector_handle_t tacacs_handle; - - tacacs_handle = create_dissector_handle(dissect_tacacs, proto_tacacs); dissector_add_uint_with_preference("udp.port", UDP_PORT_TACACS, tacacs_handle); } @@ -1259,6 +1259,7 @@ proto_register_tacplus(void) proto_tacplus = proto_register_protocol("TACACS+", "TACACS+", "tacplus"); proto_register_field_array(proto_tacplus, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + tacplus_handle = register_dissector("tacplus", dissect_tacplus, proto_tacplus); expert_tacplus = expert_register_protocol(proto_tacplus); expert_register_field_array(expert_tacplus, ei, array_length(ei)); tacplus_module = prefs_register_protocol (proto_tacplus, tacplus_pref_cb ); @@ -1272,10 +1273,6 @@ proto_register_tacplus(void) void proto_reg_handoff_tacplus(void) { - dissector_handle_t tacplus_handle; - - tacplus_handle = create_dissector_handle(dissect_tacplus, - proto_tacplus); dissector_add_uint_with_preference("tcp.port", TCP_PORT_TACACS, tacplus_handle); } diff --git a/epan/dissectors/packet-tcp.c b/epan/dissectors/packet-tcp.c index c3052da4f5..5df6aabda6 100644 --- a/epan/dissectors/packet-tcp.c +++ b/epan/dissectors/packet-tcp.c @@ -735,6 +735,8 @@ static dissector_handle_t data_handle; static dissector_handle_t tcp_handle; static dissector_handle_t sport_handle; static dissector_handle_t tcp_opt_unknown_handle; +static capture_dissector_handle_t tcp_cap_handle; + static guint32 tcp_stream_count; static guint32 mptcp_stream_count; @@ -9780,6 +9782,7 @@ proto_register_tcp(void) proto_tcp = proto_register_protocol("Transmission Control Protocol", "TCP", "tcp"); tcp_handle = register_dissector("tcp", dissect_tcp, proto_tcp); + tcp_cap_handle = register_capture_dissector("tcp", capture_tcp, proto_tcp); proto_register_field_array(proto_tcp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_tcp = expert_register_protocol(proto_tcp); @@ -9968,8 +9971,6 @@ proto_register_tcp(void) void proto_reg_handoff_tcp(void) { - capture_dissector_handle_t tcp_cap_handle; - dissector_add_uint("ip.proto", IP_PROTO_TCP, tcp_handle); dissector_add_for_decode_as_with_preference("udp.port", tcp_handle); data_handle = find_dissector("data"); @@ -9977,7 +9978,6 @@ proto_reg_handoff_tcp(void) tcp_tap = register_tap("tcp"); tcp_follow_tap = register_tap("tcp_follow"); - tcp_cap_handle = create_capture_dissector_handle(capture_tcp, proto_tcp); capture_dissector_add_uint("ip.proto", IP_PROTO_TCP, tcp_cap_handle); /* Create dissection function handles for all TCP options */ diff --git a/epan/dissectors/packet-tcpcl.c b/epan/dissectors/packet-tcpcl.c index c23af88a2b..90aa722080 100644 --- a/epan/dissectors/packet-tcpcl.c +++ b/epan/dissectors/packet-tcpcl.c @@ -2187,7 +2187,7 @@ proto_register_tcpclv3(void) expert_tcpcl = expert_register_protocol(proto_tcpcl); expert_register_field_array(expert_tcpcl, ei_tcpcl, array_length(ei_tcpcl)); - tcpcl_handle = create_dissector_handle(dissect_tcpcl, proto_tcpcl); + tcpcl_handle = register_dissector("tcpcl", dissect_tcpcl, proto_tcpcl); sess_ext_dissectors = register_dissector_table("tcpcl.v4.sess_ext", "TCPCLv4 Session Extension", proto_tcpcl, FT_UINT16, BASE_HEX); xfer_ext_dissectors = register_dissector_table("tcpcl.v4.xfer_ext", "TCPCLv4 Transfer Extension", proto_tcpcl, FT_UINT16, BASE_HEX); diff --git a/epan/dissectors/packet-tcpros.c b/epan/dissectors/packet-tcpros.c index adeac4d817..d00106e004 100644 --- a/epan/dissectors/packet-tcpros.c +++ b/epan/dissectors/packet-tcpros.c @@ -566,6 +566,7 @@ proto_register_tcpros(void) proto_register_field_array(proto_tcpros, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + tcpros_handle = register_dissector("tcpros", dissect_tcpros, proto_tcpros); tcpros_module = prefs_register_protocol(proto_tcpros, NULL); @@ -616,7 +617,6 @@ dissect_tcpros_heur_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, voi void proto_reg_handoff_tcpros(void) { - tcpros_handle = create_dissector_handle(dissect_tcpros, proto_tcpros); dissector_add_for_decode_as_with_preference("tcp.port", tcpros_handle); /* for "decode-as" */ /* register as heuristic dissector */ diff --git a/epan/dissectors/packet-tdmoe.c b/epan/dissectors/packet-tdmoe.c index ef1a53993e..ab8bce02b6 100644 --- a/epan/dissectors/packet-tdmoe.c +++ b/epan/dissectors/packet-tdmoe.c @@ -22,6 +22,8 @@ void proto_reg_handoff_tdmoe(void); void proto_register_tdmoe(void); +static dissector_handle_t tdmoe_handle; + /* protocols and header fields */ static int proto_tdmoe = -1; @@ -151,6 +153,7 @@ proto_register_tdmoe(void) proto_tdmoe = proto_register_protocol("Digium TDMoE Protocol", "TDMoE", "tdmoe"); proto_register_field_array(proto_tdmoe, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + tdmoe_handle = register_dissector("tdmoe", dissect_tdmoe, proto_tdmoe); tdmoe_module = prefs_register_protocol(proto_tdmoe, NULL); prefs_register_uint_preference(tdmoe_module, "d_channel", "TDMoE D-Channel", @@ -161,9 +164,6 @@ proto_register_tdmoe(void) void proto_reg_handoff_tdmoe(void) { - dissector_handle_t tdmoe_handle; - - tdmoe_handle = create_dissector_handle(dissect_tdmoe, proto_tdmoe); dissector_add_uint("ethertype", ETHERTYPE_TDMOE, tdmoe_handle); lapd_handle = find_dissector_add_dependency("lapd-bitstream", proto_tdmoe); diff --git a/epan/dissectors/packet-tdmop.c b/epan/dissectors/packet-tdmop.c index 3bad31b0b9..34c9fb1cdb 100644 --- a/epan/dissectors/packet-tdmop.c +++ b/epan/dissectors/packet-tdmop.c @@ -24,6 +24,8 @@ void proto_register_tdmop(void); void proto_reg_handoff_tdmop(void); +static dissector_handle_t tdmop_handle; + static int proto_tdmop = -1; static gint ett_tdmop = -1; static gint ett_tdmop_channel = -1; @@ -303,6 +305,7 @@ void proto_register_tdmop(void) proto_tdmop = proto_register_protocol ("TDMoP protocol", "TDMoP", "tdmop"); proto_register_field_array(proto_tdmop, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + tdmop_handle = register_dissector("tdmop", dissect_tdmop, proto_tdmop); tdmop_module = prefs_register_protocol(proto_tdmop, proto_reg_handoff_tdmop); prefs_register_uint_preference(tdmop_module, "d_channel", "TDMoP D-Channel", @@ -320,12 +323,10 @@ void proto_register_tdmop(void) void proto_reg_handoff_tdmop(void) { - static dissector_handle_t tdmop_handle; static gboolean init = FALSE; static guint32 current_tdmop_ethertype; if (!init) { - tdmop_handle = create_dissector_handle(dissect_tdmop, proto_tdmop); dissector_add_for_decode_as_with_preference("udp.port", tdmop_handle); if (pref_tdmop_ethertype) { diff --git a/epan/dissectors/packet-teamspeak2.c b/epan/dissectors/packet-teamspeak2.c index 0b934d6dea..0a287d3077 100644 --- a/epan/dissectors/packet-teamspeak2.c +++ b/epan/dissectors/packet-teamspeak2.c @@ -94,6 +94,8 @@ void proto_reg_handoff_ts2(void); void proto_register_ts2(void); +static dissector_handle_t ts2_handle; + static int hf_msg_fragments = -1; static int hf_msg_fragment = -1; static int hf_msg_fragment_overlap = -1; @@ -1201,6 +1203,7 @@ void proto_register_ts2(void) proto_ts2 = proto_register_protocol ("Teamspeak2 Protocol", "TeamSpeak2", "ts2"); proto_register_field_array(proto_ts2, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + ts2_handle = register_dissector("ts2", dissect_ts2, proto_ts2); expert_ts2 = expert_register_protocol(proto_ts2); expert_register_field_array(expert_ts2, ei, array_length(ei)); @@ -1213,8 +1216,6 @@ void proto_register_ts2(void) * */ void proto_reg_handoff_ts2(void) { - dissector_handle_t ts2_handle; - ts2_handle = create_dissector_handle(dissect_ts2, proto_ts2); dissector_add_uint_with_preference("udp.port", TS2_PORT, ts2_handle); } diff --git a/epan/dissectors/packet-tecmp.c b/epan/dissectors/packet-tecmp.c index 0ca9624089..63ace9530f 100644 --- a/epan/dissectors/packet-tecmp.c +++ b/epan/dissectors/packet-tecmp.c @@ -38,6 +38,8 @@ void proto_reg_handoff_tecmp(void); void proto_register_tecmp_payload(void); void proto_reg_handoff_tecmp_payload(void); +static dissector_handle_t tecmp_handle; + static int proto_tecmp = -1; static int proto_tecmp_payload = -1; @@ -2811,6 +2813,7 @@ proto_register_tecmp(void) { proto_tecmp = proto_register_protocol("Technically Enhanced Capture Module Protocol", "TECMP", "tecmp"); proto_register_field_array(proto_tecmp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + tecmp_handle = register_dissector("tecmp", dissect_tecmp, proto_tecmp); tecmp_module = prefs_register_protocol(proto_tecmp, NULL); /* UATs */ @@ -2895,9 +2898,6 @@ proto_register_tecmp(void) { void proto_reg_handoff_tecmp(void) { - dissector_handle_t tecmp_handle; - - tecmp_handle = create_dissector_handle(dissect_tecmp, proto_tecmp); dissector_add_uint("ethertype", ETHERTYPE_TECMP, tecmp_handle); lin_subdissector_table = find_dissector_table("lin.frame_id"); diff --git a/epan/dissectors/packet-teimanagement.c b/epan/dissectors/packet-teimanagement.c index 224ffb7e7f..f0584b05d7 100644 --- a/epan/dissectors/packet-teimanagement.c +++ b/epan/dissectors/packet-teimanagement.c @@ -25,6 +25,8 @@ void proto_reg_handoff_teimanagement(void); void proto_register_teimanagement(void); +static dissector_handle_t teimanagement_handle; + static int proto_tei=-1; static int lm_entity_id=-1; @@ -115,15 +117,13 @@ proto_register_teimanagement(void) "TEI_MANAGEMENT", "tei_management"); proto_register_field_array (proto_tei, hf, array_length(hf)); proto_register_subtree_array(subtree, array_length(subtree)); + + teimanagement_handle = register_dissector("tei_management", dissect_teimanagement, proto_tei); } void proto_reg_handoff_teimanagement(void) { - dissector_handle_t teimanagement_handle; - - teimanagement_handle = create_dissector_handle(dissect_teimanagement, - proto_tei); dissector_add_uint("lapd.sapi", LAPD_SAPI_L2, teimanagement_handle); } diff --git a/epan/dissectors/packet-telkonet.c b/epan/dissectors/packet-telkonet.c index 25ae6a7642..5d30da4de0 100644 --- a/epan/dissectors/packet-telkonet.c +++ b/epan/dissectors/packet-telkonet.c @@ -30,6 +30,7 @@ static int hf_telkonet_type = -1; static gint ett_telkonet = -1; +static dissector_handle_t telkonet_handle; static dissector_handle_t eth_withoutfcs_handle; typedef enum { @@ -84,16 +85,14 @@ proto_register_telkonet(void) proto_telkonet = proto_register_protocol("Telkonet powerline", "TELKONET", "telkonet"); proto_register_field_array(proto_telkonet, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + telkonet_handle = register_dissector("telkonet", dissect_telkonet, proto_telkonet); } void proto_reg_handoff_telkonet(void) { - dissector_handle_t telkonet_handle; - eth_withoutfcs_handle = find_dissector_add_dependency("eth_withoutfcs", proto_telkonet); - telkonet_handle = create_dissector_handle(dissect_telkonet, proto_telkonet); dissector_add_uint("ethertype", ETHERTYPE_TELKONET, telkonet_handle); } diff --git a/epan/dissectors/packet-tfp.c b/epan/dissectors/packet-tfp.c index 81c94ad6cf..19af67a4ee 100644 --- a/epan/dissectors/packet-tfp.c +++ b/epan/dissectors/packet-tfp.c @@ -26,6 +26,8 @@ void proto_reg_handoff_tfp(void); void proto_register_tfp(void); +static dissector_handle_t tfp_handle_tcp; + /* variables for creating the tree */ static gint proto_tfp = -1; static gint ett_tfp = -1; @@ -391,16 +393,13 @@ proto_register_tfp(void) proto_register_field_array(proto_tfp, hf_tfp, array_length(hf_tfp)); proto_register_subtree_array(ett, array_length(ett)); + tfp_handle_tcp = register_dissector("tfp", dissect_tfp_tcp, proto_tfp); } /* handoff function */ void proto_reg_handoff_tfp(void) { - dissector_handle_t tfp_handle_tcp; - - tfp_handle_tcp = create_dissector_handle(dissect_tfp_tcp, proto_tfp); - dissector_add_uint_with_preference("tcp.port", tfp_PORT, tfp_handle_tcp); heur_dissector_add("usb.bulk", dissect_tfp_bulk_heur, "Tinkerforge USB bulk endpoint", "tfp_usb_bulk", proto_tfp, HEURISTIC_ENABLE); } diff --git a/epan/dissectors/packet-thrift.c b/epan/dissectors/packet-thrift.c index 52cd785f58..c8321992d4 100644 --- a/epan/dissectors/packet-thrift.c +++ b/epan/dissectors/packet-thrift.c @@ -70,6 +70,7 @@ void proto_reg_handoff_thrift(void); } } while (0) static dissector_handle_t thrift_handle; +static dissector_handle_t thrift_http_handle; static gboolean framed_desegment = TRUE; static guint thrift_tls_port = 0; @@ -3516,6 +3517,7 @@ proto_register_thrift(void) /* register dissector */ thrift_handle = register_dissector("thrift", dissect_thrift_transport, proto_thrift); + thrift_http_handle = register_dissector("thrift.http", dissect_thrift_heur, proto_thrift); thrift_module = prefs_register_protocol(proto_thrift, proto_reg_handoff_thrift); @@ -3561,11 +3563,8 @@ void proto_reg_handoff_thrift(void) { static guint saved_thrift_tls_port; - static dissector_handle_t thrift_http_handle; static gboolean thrift_initialized = FALSE; - thrift_http_handle = create_dissector_handle(dissect_thrift_heur, proto_thrift); - if (!thrift_initialized) { thrift_initialized = TRUE; heur_dissector_add("tcp", dissect_thrift_heur, "Thrift over TCP", "thrift_tcp", proto_thrift, HEURISTIC_ENABLE); diff --git a/epan/dissectors/packet-tibia.c b/epan/dissectors/packet-tibia.c index 070f3e9463..6dd65a4ea3 100644 --- a/epan/dissectors/packet-tibia.c +++ b/epan/dissectors/packet-tibia.c @@ -109,6 +109,9 @@ void proto_register_tibia(void); void proto_reg_handoff_tibia(void); +static int dissect_tibia_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_); + +static dissector_handle_t tibia_handle; /* preferences */ static gboolean try_otserv_key = TRUE, @@ -2603,6 +2606,7 @@ proto_register_tibia(void) ); proto_register_field_array(proto_tibia, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + tibia_handle = register_dissector("tibia", dissect_tibia_tcp, proto_tibia); expert_module_t *expert_tibia = expert_register_protocol(proto_tibia); expert_register_field_array (expert_tibia, ei, array_length (ei)); @@ -2731,8 +2735,6 @@ dissect_tibia_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *dat void proto_reg_handoff_tibia(void) { - dissector_handle_t tibia_handle = create_dissector_handle(dissect_tibia_tcp, proto_tibia); - dissector_add_uint_range_with_preference("tcp.port", TIBIA_DEFAULT_TCP_PORT_RANGE, tibia_handle); } diff --git a/epan/dissectors/packet-time.c b/epan/dissectors/packet-time.c index 75ddfad424..d7c2d7e34b 100644 --- a/epan/dissectors/packet-time.c +++ b/epan/dissectors/packet-time.c @@ -23,6 +23,8 @@ void proto_reg_handoff_time(void); void proto_register_time(void); +static dissector_handle_t time_handle; + static const enum_val_t time_display_types[] = { { "UTC", "UTC", ABSOLUTE_TIME_UTC }, { "Local", "Local", ABSOLUTE_TIME_LOCAL}, @@ -91,6 +93,7 @@ proto_register_time(void) proto_time = proto_register_protocol("Time Protocol", "TIME", "time"); proto_register_field_array(proto_time, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + time_handle = register_dissector("time", dissect_time, proto_time); time_pref = prefs_register_protocol(proto_time, NULL); prefs_register_enum_preference(time_pref, @@ -105,9 +108,6 @@ proto_register_time(void) void proto_reg_handoff_time(void) { - dissector_handle_t time_handle; - - time_handle = create_dissector_handle(dissect_time, proto_time); dissector_add_uint_with_preference("udp.port", TIME_PORT, time_handle); dissector_add_uint_with_preference("tcp.port", TIME_PORT, time_handle); } diff --git a/epan/dissectors/packet-tipc.c b/epan/dissectors/packet-tipc.c index 52541f496a..fb41797d0c 100644 --- a/epan/dissectors/packet-tipc.c +++ b/epan/dissectors/packet-tipc.c @@ -197,6 +197,7 @@ static gint handle_v2_as = V2_AS_ALL; static gboolean tipc_tcp_desegment = TRUE; static dissector_handle_t tipc_handle; +static dissector_handle_t tipc_tcp_handle; /* IANA have assigned port 6118 port for TIPC UDP transport. */ #define DEFAULT_TIPC_PORT_RANGE "6118" @@ -3100,6 +3101,7 @@ proto_register_tipc(void) /* Register by name */ tipc_handle = register_dissector("tipc", dissect_tipc, proto_tipc); + tipc_tcp_handle = register_dissector("tipc.tcp", dissect_tipc_tcp, proto_tipc); reassembly_table_register(&tipc_msg_reassembly_table, &addresses_reassembly_table_functions); @@ -3142,10 +3144,6 @@ proto_register_tipc(void) void proto_reg_handoff_tipc(void) { - dissector_handle_t tipc_tcp_handle; - - tipc_tcp_handle = create_dissector_handle(dissect_tipc_tcp, proto_tipc); - dissector_add_uint("ethertype", ETHERTYPE_TIPC, tipc_handle); dissector_add_for_decode_as_with_preference("tcp.port", tipc_tcp_handle); dissector_add_uint_range_with_preference("udp.port", DEFAULT_TIPC_PORT_RANGE, tipc_handle); diff --git a/epan/dissectors/packet-tivoconnect.c b/epan/dissectors/packet-tivoconnect.c index a0200d5f35..367b5d57b4 100644 --- a/epan/dissectors/packet-tivoconnect.c +++ b/epan/dissectors/packet-tivoconnect.c @@ -28,6 +28,9 @@ void proto_reg_handoff_tivoconnect(void); void proto_register_tivoconnect(void); +static dissector_handle_t tivoconnect_tcp_handle; +static dissector_handle_t tivoconnect_udp_handle; + #define TIVOCONNECT_PORT 2190 static int proto_tivoconnect = -1; @@ -220,16 +223,15 @@ proto_register_tivoconnect(void) proto_register_field_array(proto_tivoconnect, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + tivoconnect_tcp_handle = register_dissector("tivo.tcp", dissect_tivoconnect_tcp, proto_tivoconnect); + tivoconnect_udp_handle = register_dissector("tivo.udp", dissect_tivoconnect_udp, proto_tivoconnect); } void proto_reg_handoff_tivoconnect(void) { - dissector_handle_t tivoconnect_tcp_handle, tivoconnect_udp_handle; - - tivoconnect_tcp_handle = create_dissector_handle(dissect_tivoconnect_tcp, proto_tivoconnect); - tivoconnect_udp_handle = create_dissector_handle(dissect_tivoconnect_udp, proto_tivoconnect); dissector_add_uint_with_preference("udp.port", TIVOCONNECT_PORT, tivoconnect_udp_handle); dissector_add_uint_with_preference("tcp.port", TIVOCONNECT_PORT, tivoconnect_tcp_handle); } diff --git a/epan/dissectors/packet-tns.c b/epan/dissectors/packet-tns.c index aab3a62008..82efb4f4eb 100644 --- a/epan/dissectors/packet-tns.c +++ b/epan/dissectors/packet-tns.c @@ -66,6 +66,8 @@ void proto_register_tns(void); /* desegmentation of TNS over TCP */ static gboolean tns_desegment = TRUE; +static dissector_handle_t tns_handle; + static int proto_tns = -1; static int hf_tns_request = -1; static int hf_tns_response = -1; @@ -1639,6 +1641,7 @@ void proto_register_tns(void) "Transparent Network Substrate Protocol", "TNS", "tns"); proto_register_field_array(proto_tns, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + tns_handle = register_dissector("tns", dissect_tns, proto_tns); tns_module = prefs_register_protocol(proto_tns, NULL); prefs_register_bool_preference(tns_module, "desegment_tns_messages", @@ -1651,9 +1654,6 @@ void proto_register_tns(void) void proto_reg_handoff_tns(void) { - dissector_handle_t tns_handle; - - tns_handle = create_dissector_handle(dissect_tns, proto_tns); dissector_add_uint_with_preference("tcp.port", TCP_PORT_TNS, tns_handle); } diff --git a/epan/dissectors/packet-tplink-smarthome.c b/epan/dissectors/packet-tplink-smarthome.c index bfae270008..023c67e3b1 100644 --- a/epan/dissectors/packet-tplink-smarthome.c +++ b/epan/dissectors/packet-tplink-smarthome.c @@ -46,6 +46,9 @@ void proto_reg_handoff_tplink_smarthome(void); void proto_register_tplink_smarthome(void); +static dissector_handle_t tplink_smarthome_handle; +static dissector_handle_t tplink_smarthome_message_handle; + /* Initialize the protocol and registered fields */ static int proto_tplink_smarthome = -1; @@ -192,6 +195,10 @@ proto_register_tplink_smarthome(void) proto_tplink_smarthome = proto_register_protocol("TP-Link Smart Home Protocol", /* register the protocol name and description */ "TPLINK-SMARTHOME", "tplink-smarthome"); + tplink_smarthome_handle = register_dissector("tplink-smarthome", + dissect_tplink_smarthome, proto_tplink_smarthome); + tplink_smarthome_message_handle = register_dissector("tplink-smarthome-message", + dissect_tplink_smarthome_message, proto_tplink_smarthome); proto_register_field_array(proto_tplink_smarthome, hf, array_length(hf)); /* register the header fields */ proto_register_subtree_array(ett, array_length(ett)); /* and subtrees */ @@ -200,12 +207,9 @@ proto_register_tplink_smarthome(void) void proto_reg_handoff_tplink_smarthome(void) { - dissector_handle_t tplink_smarthome_handle; - tplink_smarthome_handle = create_dissector_handle(dissect_tplink_smarthome, proto_tplink_smarthome); dissector_add_uint_with_preference("tcp.port", TPLINK_SMARTHOME_PORT, tplink_smarthome_handle); - tplink_smarthome_handle = create_dissector_handle(dissect_tplink_smarthome_message, proto_tplink_smarthome); - dissector_add_uint_with_preference("udp.port", TPLINK_SMARTHOME_PORT, tplink_smarthome_handle); + dissector_add_uint_with_preference("udp.port", TPLINK_SMARTHOME_PORT, tplink_smarthome_message_handle); } /* diff --git a/epan/dissectors/packet-tpm20.c b/epan/dissectors/packet-tpm20.c index 11de2d4525..83a90c2d48 100644 --- a/epan/dissectors/packet-tpm20.c +++ b/epan/dissectors/packet-tpm20.c @@ -119,6 +119,8 @@ static expert_field ei_invalid_num_sessions = EI_INIT; void proto_register_tpm20(void); void proto_reg_handoff_tpm20(void); +static dissector_handle_t tpm20_handle; + #define TCP_TPM_PORT_PLATFORM_PORT 2321 #define TCP_TPM_PORT_COMMAND_PORT 2322 #define TCP_TPM_PORTS "2321-2322" @@ -1379,14 +1381,12 @@ proto_register_tpm20(void) expert_module_t* expert_mod = expert_register_protocol(proto_tpm20); expert_register_field_array(expert_mod, ei, array_length(ei)); register_init_routine(tpm_init); + tpm20_handle = register_dissector("tpm", dissect_tpm20, proto_tpm20); } void proto_reg_handoff_tpm20(void) { - dissector_handle_t tpm20_handle; - - tpm20_handle = create_dissector_handle(dissect_tpm20, proto_tpm20); dissector_add_uint_range_with_preference("tcp.port", TCP_TPM_PORTS, tpm20_handle); } diff --git a/epan/dissectors/packet-tpncp.c b/epan/dissectors/packet-tpncp.c index a9681d1eb3..998569cdf3 100644 --- a/epan/dissectors/packet-tpncp.c +++ b/epan/dissectors/packet-tpncp.c @@ -109,6 +109,7 @@ static gint ett_tpncp_body = -1; static gboolean global_tpncp_load_db = FALSE; static dissector_handle_t tpncp_handle; +static dissector_handle_t tpncp_tcp_handle; /* XXX: ToDo: allocate at runtime as needed * The following allocates something on the order of 2M of static memory ! @@ -931,16 +932,14 @@ proto_reg_handoff_tpncp(void) if (proto_tpncp == -1) return; if (!initialized) { - dissector_handle_t tpncp_udp_handle = create_dissector_handle(dissect_tpncp, proto_tpncp); - dissector_handle_t tpncp_tcp_handle = create_dissector_handle(dissect_tpncp_tcp, proto_tpncp); - dissector_add_uint_with_preference("udp.port", UDP_PORT_TPNCP_TRUNKPACK, tpncp_udp_handle); + dissector_add_uint_with_preference("udp.port", UDP_PORT_TPNCP_TRUNKPACK, tpncp_handle); dissector_add_uint_with_preference("tcp.port", TCP_PORT_TPNCP_TRUNKPACK, tpncp_tcp_handle); - dissector_add_uint("acdr.media_type", ACDR_PCIIF_COMMAND, tpncp_udp_handle); - dissector_add_uint("acdr.media_type", ACDR_COMMAND, tpncp_udp_handle); - dissector_add_uint("acdr.media_type", ACDR_Event, create_dissector_handle(dissect_acdr_event, -1)); + dissector_add_uint("acdr.media_type", ACDR_PCIIF_COMMAND, tpncp_handle); + dissector_add_uint("acdr.media_type", ACDR_COMMAND, tpncp_handle); + dissector_add_uint("acdr.media_type", ACDR_Event, create_dissector_handle(dissect_acdr_event, proto_tpncp)); dissector_add_uint("acdr.media_type", ACDR_TPNCP, - create_dissector_handle(dissect_acdr_tpncp_by_tracepoint, -1)); - dissector_add_uint("acdr.tls_application", TLS_APP_TPNCP, tpncp_udp_handle); + create_dissector_handle(dissect_acdr_tpncp_by_tracepoint, proto_tpncp)); + dissector_add_uint("acdr.tls_application", TLS_APP_TPNCP, tpncp_handle); initialized = TRUE; } /* If we weren't able to load the database (and thus the hf_ entries) @@ -1007,6 +1006,7 @@ proto_register_tpncp(void) "TPNCP", "tpncp"); tpncp_handle = register_dissector("tpncp", dissect_tpncp, proto_tpncp); + tpncp_tcp_handle = register_dissector("tpncp.tcp", dissect_tpncp_tcp, proto_tpncp); tpncp_module = prefs_register_protocol(proto_tpncp, proto_reg_handoff_tpncp); diff --git a/epan/dissectors/packet-trill.c b/epan/dissectors/packet-trill.c index 9cd36f93fd..755b272e59 100644 --- a/epan/dissectors/packet-trill.c +++ b/epan/dissectors/packet-trill.c @@ -21,6 +21,8 @@ void proto_register_trill(void); void proto_reg_handoff_trill(void); +static dissector_handle_t trill_handle; + static int proto_trill = -1 ; static gint ett_trill = -1 ; @@ -181,14 +183,12 @@ proto_register_trill(void) proto_trill = proto_register_protocol("TRILL", "TRILL", "trill"); proto_register_field_array(proto_trill, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + trill_handle = register_dissector("trill", dissect_trill, proto_trill); } void proto_reg_handoff_trill(void) { - dissector_handle_t trill_handle; - - trill_handle = create_dissector_handle(dissect_trill, proto_trill); dissector_add_uint("ethertype", ETHERTYPE_TRILL, trill_handle); /* diff --git a/epan/dissectors/packet-tsp.c b/epan/dissectors/packet-tsp.c index 65d41d8c12..43b76538c4 100644 --- a/epan/dissectors/packet-tsp.c +++ b/epan/dissectors/packet-tsp.c @@ -23,6 +23,8 @@ void proto_register_tsp(void); void proto_reg_handoff_tsp(void); +static dissector_handle_t tsp_handle; + static int proto_tsp = -1; static int hf_tsp_type = -1; static int hf_tsp_vers = -1; @@ -153,9 +155,6 @@ dissect_tsp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) void proto_reg_handoff_tsp(void) { - dissector_handle_t tsp_handle; - - tsp_handle = create_dissector_handle(dissect_tsp, proto_tsp); dissector_add_uint_with_preference("udp.port", UDP_PORT_TIMED, tsp_handle); } @@ -201,6 +200,7 @@ proto_register_tsp(void) "TSP", "tsp"); proto_register_field_array(proto_tsp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + tsp_handle = register_dissector("tsp", dissect_tsp, proto_tsp); } /* diff --git a/epan/dissectors/packet-tuxedo.c b/epan/dissectors/packet-tuxedo.c index 200738d88a..423f261989 100644 --- a/epan/dissectors/packet-tuxedo.c +++ b/epan/dissectors/packet-tuxedo.c @@ -167,13 +167,12 @@ proto_register_tuxedo(void) proto_register_field_array(proto_tuxedo, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - + tuxedo_handle = register_dissector("tuxedo", dissect_tuxedo, proto_tuxedo); } void proto_reg_handoff_tuxedo(void) { - tuxedo_handle = create_dissector_handle(dissect_tuxedo, proto_tuxedo); dissector_add_for_decode_as_with_preference("tcp.port", tuxedo_handle); heur_dissector_add("tcp", dissect_tuxedo_heur, "Tuxedo over TCP", "tuxedo_tcp", proto_tuxedo, HEURISTIC_ENABLE); } diff --git a/epan/dissectors/packet-twamp.c b/epan/dissectors/packet-twamp.c index 5211b077a7..8e5b482036 100644 --- a/epan/dissectors/packet-twamp.c +++ b/epan/dissectors/packet-twamp.c @@ -831,6 +831,9 @@ void proto_register_twamp(void) proto_register_subtree_array (ett_twamp_test_arr, array_length(ett_twamp_test_arr)); + /* Register the dissector handle */ + twamp_test_handle = register_dissector("twamp.test", dissect_twamp_test, proto_twamp_test); + /* Register the protocol */ proto_twamp_control = proto_register_protocol( "TwoWay Active Measurement Control Protocol", @@ -845,20 +848,21 @@ void proto_register_twamp(void) proto_register_subtree_array (ett_twamp_control_arr, array_length(ett_twamp_control_arr)); + /* Register the dissector handle */ + twamp_control_handle = register_dissector("twamp.control", dissect_twamp_server_greeting, proto_twamp_control); + + /* Register the protocol */ proto_owamp_test = proto_register_protocol( "One-way Active Measurement Protocol", "OWAMP-Test", "owamp.test"); + /* Register the dissector handle */ + owamp_test_handle = register_dissector("owamp.test", dissect_owamp_test, proto_owamp_test); } void proto_reg_handoff_twamp(void) { - twamp_test_handle = create_dissector_handle(dissect_twamp_test, proto_twamp_test); - - owamp_test_handle = create_dissector_handle(dissect_owamp_test, proto_owamp_test); - - twamp_control_handle = create_dissector_handle(dissect_twamp_server_greeting, proto_twamp_control); dissector_add_uint("tcp.port", TWAMP_CONTROL_PORT, twamp_control_handle); dissector_add_for_decode_as("udp.port", twamp_test_handle); diff --git a/epan/dissectors/packet-uavcan-can.c b/epan/dissectors/packet-uavcan-can.c index 7bfdf28467..0240bf986c 100644 --- a/epan/dissectors/packet-uavcan-can.c +++ b/epan/dissectors/packet-uavcan-can.c @@ -52,6 +52,8 @@ struct uavcan_proto_data void proto_register_uavcan(void); void proto_reg_handoff_uavcan(void); +static dissector_handle_t uavcan_handle; + static int proto_uavcan = -1; static int hf_uavcan_can_id = -1; @@ -622,6 +624,8 @@ proto_register_uavcan(void) proto_register_field_array(proto_uavcan, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + uavcan_handle = register_dissector("uavcan_can", dissect_uavcan, proto_uavcan); + expert_uavcan = expert_register_protocol(proto_uavcan); expert_register_field_array(expert_uavcan, ei, array_length(ei)); @@ -634,10 +638,6 @@ proto_register_uavcan(void) void proto_reg_handoff_uavcan(void) { - dissector_handle_t uavcan_handle; - - uavcan_handle = create_dissector_handle(dissect_uavcan, proto_uavcan); - dsdl_message_handle = find_dissector_add_dependency("uavcan_dsdl.message", proto_uavcan); dsdl_request_handle = find_dissector_add_dependency("uavcan_dsdl.request", proto_uavcan); dsdl_response_handle = find_dissector_add_dependency("uavcan_dsdl.response", proto_uavcan); diff --git a/epan/dissectors/packet-ucp.c b/epan/dissectors/packet-ucp.c index 8b028bdfa6..5032b831ba 100644 --- a/epan/dissectors/packet-ucp.c +++ b/epan/dissectors/packet-ucp.c @@ -2797,6 +2797,9 @@ proto_register_ucp(void) expert_ucp = expert_register_protocol(proto_ucp); expert_register_field_array(expert_ucp, ei, array_length(ei)); + /* Register the dissector handle */ + ucp_handle = register_dissector("ucp", dissect_ucp_tcp, proto_ucp); + /* Register for tapping */ ucp_tap = register_tap("ucp"); @@ -2824,7 +2827,6 @@ proto_reg_handoff_ucp(void) /* * Also register as a dissector that can be selected by a TCP port number via "decode as". */ - ucp_handle = create_dissector_handle(dissect_ucp_tcp, proto_ucp); dissector_add_for_decode_as_with_preference("tcp.port", ucp_handle); /* Tapping setup */ diff --git a/epan/dissectors/packet-udld.c b/epan/dissectors/packet-udld.c index f528553b27..b9e2de993b 100644 --- a/epan/dissectors/packet-udld.c +++ b/epan/dissectors/packet-udld.c @@ -29,6 +29,8 @@ void proto_register_udld(void); void proto_reg_handoff_udld(void); +static dissector_handle_t udld_handle; + static int proto_udld = -1; static int hf_udld_version = -1; static int hf_udld_opcode = -1; @@ -282,14 +284,12 @@ proto_register_udld(void) proto_register_subtree_array(ett, array_length(ett)); expert_udld = expert_register_protocol(proto_udld); expert_register_field_array(expert_udld, ei, array_length(ei)); + udld_handle = register_dissector("udld", dissect_udld, proto_udld); } void proto_reg_handoff_udld(void) { - dissector_handle_t udld_handle; - - udld_handle = create_dissector_handle(dissect_udld, proto_udld); dissector_add_uint("llc.cisco_pid", CISCO_PID_UDLD, udld_handle); dissector_add_uint("chdlc.protocol", 0x0111, udld_handle); } diff --git a/epan/dissectors/packet-udp.c b/epan/dissectors/packet-udp.c index 758557ee21..180c479899 100644 --- a/epan/dissectors/packet-udp.c +++ b/epan/dissectors/packet-udp.c @@ -40,6 +40,8 @@ void proto_reg_handoff_udp(void); static dissector_handle_t udp_handle; static dissector_handle_t udplite_handle; +static capture_dissector_handle_t udp_cap_handle; +static capture_dissector_handle_t udplite_cap_handle; static int udp_tap = -1; static int udp_follow_tap = -1; @@ -1415,11 +1417,13 @@ proto_register_udp(void) proto_udp = proto_register_protocol("User Datagram Protocol", "UDP", "udp"); proto_register_field_array(proto_udp, hf_udp, array_length(hf_udp)); udp_handle = register_dissector("udp", dissect_udp, proto_udp); + udp_cap_handle = register_capture_dissector("udp", capture_udp, proto_udp); expert_udp = expert_register_protocol(proto_udp); proto_udplite = proto_register_protocol("Lightweight User Datagram Protocol", "UDP-Lite", "udplite"); proto_register_field_array(proto_udplite, hf_udplite, array_length(hf_udplite)); - udplite_handle = create_dissector_handle(dissect_udplite, proto_udplite); + udplite_handle = register_dissector("udplite", dissect_udplite, proto_udplite); + udplite_cap_handle = register_capture_dissector("udplite", capture_udp, proto_udplite); proto_register_subtree_array(ett, array_length(ett)); expert_register_field_array(expert_udp, ei, array_length(ei)); @@ -1484,15 +1488,12 @@ proto_register_udp(void) void proto_reg_handoff_udp(void) { - capture_dissector_handle_t udp_cap_handle; dissector_add_uint("ip.proto", IP_PROTO_UDP, udp_handle); dissector_add_uint("ip.proto", IP_PROTO_UDPLITE, udplite_handle); - udp_cap_handle = create_capture_dissector_handle(capture_udp, proto_udp); capture_dissector_add_uint("ip.proto", IP_PROTO_UDP, udp_cap_handle); - udp_cap_handle = create_capture_dissector_handle(capture_udp, proto_udplite); - capture_dissector_add_uint("ip.proto", IP_PROTO_UDPLITE, udp_cap_handle); + capture_dissector_add_uint("ip.proto", IP_PROTO_UDPLITE, udplite_cap_handle); udp_tap = register_tap("udp"); udp_follow_tap = register_tap("udp_follow"); diff --git a/epan/dissectors/packet-udt.c b/epan/dissectors/packet-udt.c index eee8a8369d..38f1acfc95 100644 --- a/epan/dissectors/packet-udt.c +++ b/epan/dissectors/packet-udt.c @@ -587,15 +587,13 @@ void proto_register_udt(void) expert_udt = expert_register_protocol(proto_udt); expert_register_field_array(expert_udt, ei, array_length(ei)); - register_dissector("udt", dissect_udt, proto_udt); + udt_handle = register_dissector("udt", dissect_udt, proto_udt); heur_subdissector_list = register_heur_dissector_list("udt", proto_udt); } void proto_reg_handoff_udt(void) { - udt_handle = create_dissector_handle(dissect_udt, proto_udt); - heur_dissector_add("udp", dissect_udt_heur_udp, "UDT over UDP", "udt_udp", proto_udt, HEURISTIC_ENABLE); heur_dissector_add("dtls", dissect_udt_heur_dtls, "UDT over DTLS", "udt_dtls", proto_udt, HEURISTIC_ENABLE); dissector_add_for_decode_as_with_preference("udp.port", udt_handle); diff --git a/epan/dissectors/packet-uftp.c b/epan/dissectors/packet-uftp.c index 89626c73b9..4f7c6f51ab 100644 --- a/epan/dissectors/packet-uftp.c +++ b/epan/dissectors/packet-uftp.c @@ -125,6 +125,8 @@ void proto_register_uftp(void); void proto_reg_handoff_uftp(void); +static dissector_handle_t uftp_handle; + static int proto_uftp = -1; #define UFTP_PORT 1044 /* Not IANA registered */ @@ -2209,15 +2211,13 @@ void proto_register_uftp(void) proto_register_subtree_array(ett, array_length(ett)); expert_uftp = expert_register_protocol(proto_uftp); expert_register_field_array(expert_uftp, ei, array_length(ei)); + uftp_handle = register_dissector("uftp", dissect_uftp, proto_uftp); } void proto_reg_handoff_uftp(void) { - static dissector_handle_t uftp_handle; - uftp4_handle = find_dissector("uftp4"); uftp5_handle = find_dissector("uftp5"); - uftp_handle = create_dissector_handle(dissect_uftp, proto_uftp); dissector_add_uint_with_preference("udp.port", UFTP_PORT, uftp_handle); } diff --git a/epan/dissectors/packet-uhd.c b/epan/dissectors/packet-uhd.c index cc165a60e5..85ecf8cf06 100644 --- a/epan/dissectors/packet-uhd.c +++ b/epan/dissectors/packet-uhd.c @@ -139,6 +139,8 @@ static const value_string uhd_reg_actions[] = { void proto_reg_handoff_uhd(void); +static dissector_handle_t uhd_handle; + /* dissect a UHD header and hand payload off to respective dissector */ static int dissect_uhd(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) @@ -256,14 +258,12 @@ proto_register_uhd(void) proto_uhd = proto_register_protocol("UHD", "UHD", "uhd"); proto_register_field_array(proto_uhd, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + uhd_handle = register_dissector("uhd", dissect_uhd, proto_uhd); } void proto_reg_handoff_uhd(void) { - dissector_handle_t uhd_handle; - - uhd_handle = create_dissector_handle(dissect_uhd, proto_uhd); dissector_add_for_decode_as_with_preference("udp.port", uhd_handle); } diff --git a/epan/dissectors/packet-umts_fp.c b/epan/dissectors/packet-umts_fp.c index 9c1772da87..42bdff3bf3 100644 --- a/epan/dissectors/packet-umts_fp.c +++ b/epan/dissectors/packet-umts_fp.c @@ -237,6 +237,8 @@ static dissector_handle_t mac_fdd_edch_handle; static dissector_handle_t mac_fdd_edch_type2_handle; static dissector_handle_t mac_fdd_hsdsch_handle; static dissector_handle_t fp_handle; +static dissector_handle_t fp_aal2_handle; + static proto_tree *top_level_tree = NULL; @@ -7071,6 +7073,7 @@ void proto_register_fp(void) /* Allow other dissectors to find this one by name. */ fp_handle = register_dissector("fp", dissect_fp, proto_fp); + fp_aal2_handle = register_dissector("fp.aal2", dissect_fp_aal2, proto_fp); /* Preferences */ fp_module = prefs_register_protocol(proto_fp, NULL); @@ -7109,8 +7112,6 @@ void proto_register_fp(void) void proto_reg_handoff_fp(void) { - dissector_handle_t fp_aal2_handle; - rlc_bcch_handle = find_dissector_add_dependency("rlc.bcch", proto_fp); mac_fdd_rach_handle = find_dissector_add_dependency("mac.fdd.rach", proto_fp); mac_fdd_fach_handle = find_dissector_add_dependency("mac.fdd.fach", proto_fp); @@ -7123,7 +7124,6 @@ void proto_reg_handoff_fp(void) heur_dissector_add("udp", heur_dissect_fp, "FP over UDP", "fp_udp", proto_fp, HEURISTIC_DISABLE); heur_dissector_add("fp_mux", heur_dissect_fp, "FP over FP Mux", "fp_fp_mux", proto_fp, HEURISTIC_ENABLE); - fp_aal2_handle = create_dissector_handle(dissect_fp_aal2, proto_fp); dissector_add_uint("atm.aal2.type", TRAF_UMTS_FP, fp_aal2_handle); } diff --git a/epan/dissectors/packet-usb-audio.c b/epan/dissectors/packet-usb-audio.c index 2f1ad5496e..c69aa4dd2d 100644 --- a/epan/dissectors/packet-usb-audio.c +++ b/epan/dissectors/packet-usb-audio.c @@ -355,6 +355,8 @@ static gint ett_as_ep_gen_controls = -1; static dissector_handle_t sysex_handle; static dissector_handle_t usb_audio_bulk_handle; +static dissector_handle_t usb_audio_descr_handle; + #define AUDIO_IF_SUBCLASS_UNDEFINED 0x00 #define AUDIO_IF_SUBCLASS_AUDIOCONTROL 0x01 @@ -3131,15 +3133,12 @@ proto_register_usb_audio(void) &addresses_reassembly_table_functions); usb_audio_bulk_handle = register_dissector("usbaudio", dissect_usb_audio_bulk, proto_usb_audio); + usb_audio_descr_handle = register_dissector("usbaudio.bulk", dissect_usb_audio_descriptor, proto_usb_audio); } void proto_reg_handoff_usb_audio(void) { - dissector_handle_t usb_audio_descr_handle; - - usb_audio_descr_handle = create_dissector_handle( - dissect_usb_audio_descriptor, proto_usb_audio); dissector_add_uint("usb.descriptor", IF_CLASS_AUDIO, usb_audio_descr_handle); dissector_add_uint("usb.bulk", IF_CLASS_AUDIO, usb_audio_bulk_handle); diff --git a/epan/dissectors/packet-usb-ccid.c b/epan/dissectors/packet-usb-ccid.c index fc2c4d93ee..40e13233f3 100644 --- a/epan/dissectors/packet-usb-ccid.c +++ b/epan/dissectors/packet-usb-ccid.c @@ -114,6 +114,8 @@ static int hf_ccid_bIFSC = -1; static int hf_ccid_bNadValue = -1; static dissector_handle_t usb_ccid_handle; +static dissector_handle_t usb_ccid_descr_handle; + static int * const bVoltageLevel_fields[] = { &hf_ccid_bVoltageSupport18, @@ -1018,6 +1020,7 @@ proto_register_ccid(void) prefs_register_obsolete_preference(pref_mod, "prtype"); usb_ccid_handle = register_dissector("usbccid", dissect_ccid, proto_ccid); + usb_ccid_descr_handle = register_dissector("usbccid.descriptor", dissect_usb_ccid_descriptor, proto_ccid); subdissector_table = register_decode_as_next_proto(proto_ccid, "usbccid.subdissector", "USB CCID payload", NULL); } @@ -1026,10 +1029,6 @@ proto_register_ccid(void) void proto_reg_handoff_ccid(void) { - dissector_handle_t usb_ccid_descr_handle; - - usb_ccid_descr_handle = create_dissector_handle( - dissect_usb_ccid_descriptor, proto_ccid); dissector_add_uint("usb.descriptor", IF_CLASS_SMART_CARD, usb_ccid_descr_handle); dissector_add_uint("usb.bulk", IF_CLASS_SMART_CARD, usb_ccid_handle); diff --git a/epan/dissectors/packet-usb-com.c b/epan/dissectors/packet-usb-com.c index 305135e968..7f6b2632ad 100644 --- a/epan/dissectors/packet-usb-com.c +++ b/epan/dissectors/packet-usb-com.c @@ -120,6 +120,11 @@ static gint ett_usb_com_bitmap = -1; static gint ett_usb_com_descriptor_ecm_eth_stats = -1; static gint ett_usb_com_descriptor_ecm_nb_mc_filters = -1; +static dissector_handle_t usb_com_descriptor_handle; +static dissector_handle_t usb_com_control_handle; +static dissector_handle_t usb_com_bulk_handle; +static dissector_handle_t usb_com_interrupt_handle; + static dissector_handle_t mbim_control_handle; static dissector_handle_t mbim_descriptor_handle; static dissector_handle_t mbim_bulk_handle; @@ -1152,6 +1157,11 @@ proto_register_usb_com(void) proto_register_field_array(proto_usb_com, hf, array_length(hf)); proto_register_subtree_array(usb_com_subtrees, array_length(usb_com_subtrees)); + usb_com_descriptor_handle = register_dissector("usbcom.descriptor", dissect_usb_com_descriptor, proto_usb_com); + usb_com_control_handle = register_dissector("usbcom.control", dissect_usb_com_control, proto_usb_com); + usb_com_bulk_handle = register_dissector("usbcom.bulk", dissect_usb_com_bulk, proto_usb_com); + usb_com_interrupt_handle = register_dissector("usbcom.interrupt", dissect_usb_com_interrupt, proto_usb_com); + expert_usb_com = expert_register_protocol(proto_usb_com); expert_register_field_array(expert_usb_com, ei, array_length(ei)); } @@ -1159,16 +1169,9 @@ proto_register_usb_com(void) void proto_reg_handoff_usb_com(void) { - dissector_handle_t usb_com_descriptor_handle, usb_com_control_handle, - usb_com_bulk_handle, usb_com_interrupt_handle; - - usb_com_descriptor_handle = create_dissector_handle(dissect_usb_com_descriptor, proto_usb_com); dissector_add_uint("usb.descriptor", IF_CLASS_COMMUNICATIONS, usb_com_descriptor_handle); - usb_com_control_handle = create_dissector_handle(dissect_usb_com_control, proto_usb_com); dissector_add_uint("usb.control", IF_CLASS_COMMUNICATIONS, usb_com_control_handle); - usb_com_bulk_handle = create_dissector_handle(dissect_usb_com_bulk, proto_usb_com); dissector_add_uint("usb.bulk", IF_CLASS_CDC_DATA, usb_com_bulk_handle); - usb_com_interrupt_handle = create_dissector_handle(dissect_usb_com_interrupt, proto_usb_com); dissector_add_uint("usb.interrupt", IF_CLASS_COMMUNICATIONS, usb_com_interrupt_handle); mbim_control_handle = find_dissector_add_dependency("mbim.control", proto_usb_com); mbim_descriptor_handle = find_dissector_add_dependency("mbim.descriptor", proto_usb_com); diff --git a/epan/dissectors/packet-usb-dfu.c b/epan/dissectors/packet-usb-dfu.c index a4d8f5b06c..7f8deaee1f 100644 --- a/epan/dissectors/packet-usb-dfu.c +++ b/epan/dissectors/packet-usb-dfu.c @@ -53,6 +53,8 @@ static expert_field ei_descriptor_invalid_length = EI_INIT; static expert_field ei_invalid_command_for_request_type = EI_INIT; static dissector_handle_t usb_dfu_handle; +static dissector_handle_t usf_dfu_descriptor_handle; + static wmem_tree_t *command_info = NULL; @@ -541,6 +543,7 @@ proto_register_usb_dfu(void) proto_register_field_array(proto_usb_dfu, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); usb_dfu_handle = register_dissector("usb_dfu", dissect_usb_dfu, proto_usb_dfu); + usf_dfu_descriptor_handle = register_dissector("usb_dfu.descriptor", dissect_usb_dfu_descriptor, proto_usb_dfu); expert_module = expert_register_protocol(proto_usb_dfu); expert_register_field_array(expert_module, ei, array_length(ei)); @@ -557,9 +560,6 @@ proto_register_usb_dfu(void) void proto_reg_handoff_usb_dfu(void) { - dissector_handle_t usf_dfu_descriptor_handle; - - usf_dfu_descriptor_handle = create_dissector_handle(dissect_usb_dfu_descriptor, proto_usb_dfu); dissector_add_uint("usb.descriptor", IF_CLASS_APPLICATION_SPECIFIC, usf_dfu_descriptor_handle); dissector_add_uint("usb.control", RUNTIME_KEY, usb_dfu_handle); diff --git a/epan/dissectors/packet-usb-hid.c b/epan/dissectors/packet-usb-hid.c index 2c26ef9f0f..afd4bfd8e9 100644 --- a/epan/dissectors/packet-usb-hid.c +++ b/epan/dissectors/packet-usb-hid.c @@ -25,6 +25,11 @@ void proto_register_usb_hid(void); void proto_reg_handoff_usb_hid(void); +/* Dissector handles */ +static dissector_handle_t usb_hid_control_handle; +static dissector_handle_t usb_hid_interrupt_handle; +static dissector_handle_t usb_hid_descr_handle; + /* protocols and header fields */ static int proto_usb_hid = -1; static int hf_usb_hid_item_bSize = -1; @@ -5906,22 +5911,17 @@ proto_register_usb_hid(void) /*usb_hid_boot_keyboard_input_report_handle =*/ register_dissector("usbhid.boot_report.keyboard.input", dissect_usb_hid_boot_keyboard_input_report, proto_usb_hid); /*usb_hid_boot_keyboard_output_report_handle =*/ register_dissector("usbhid.boot_report.keyboard.output", dissect_usb_hid_boot_keyboard_output_report, proto_usb_hid); /*usb_hid_boot_mouse_input_report_handle =*/ register_dissector("usbhid.boot_report.mouse.input", dissect_usb_hid_boot_mouse_input_report, proto_usb_hid); - + usb_hid_control_handle = register_dissector("usbhid.control", dissect_usb_hid_control, proto_usb_hid); + usb_hid_interrupt_handle = register_dissector("usbhid.data", dissect_usb_hid_data, proto_usb_hid); + usb_hid_descr_handle = register_dissector("usbhid.class_descriptors", dissect_usb_hid_class_descriptors, proto_usb_hid); } void proto_reg_handoff_usb_hid(void) { - dissector_handle_t usb_hid_control_handle, usb_hid_interrupt_handle, usb_hid_descr_handle; - - usb_hid_control_handle = create_dissector_handle(dissect_usb_hid_control, proto_usb_hid); dissector_add_uint("usb.control", IF_CLASS_HID, usb_hid_control_handle); dissector_add_for_decode_as("usb.device", usb_hid_control_handle); - - usb_hid_interrupt_handle = create_dissector_handle(dissect_usb_hid_data, proto_usb_hid); dissector_add_uint("usb.interrupt", IF_CLASS_HID, usb_hid_interrupt_handle); - - usb_hid_descr_handle = create_dissector_handle(dissect_usb_hid_class_descriptors, proto_usb_hid); dissector_add_uint("usb.descriptor", IF_CLASS_HID, usb_hid_descr_handle); } diff --git a/epan/dissectors/packet-usb-hub.c b/epan/dissectors/packet-usb-hub.c index a45000fba6..0ecf2f5f10 100644 --- a/epan/dissectors/packet-usb-hub.c +++ b/epan/dissectors/packet-usb-hub.c @@ -21,6 +21,8 @@ void proto_register_usb_hub(void); void proto_reg_handoff_usb_hub(void); +static dissector_handle_t usb_hub_control_handle; + /* protocols and header fields */ static int proto_usb_hub = -1; @@ -820,14 +822,12 @@ proto_register_usb_hub(void) proto_usb_hub = proto_register_protocol("USB HUB", "USBHUB", "usbhub"); proto_register_field_array(proto_usb_hub, hf, array_length(hf)); proto_register_subtree_array(usb_hub_subtrees, array_length(usb_hub_subtrees)); + usb_hub_control_handle = register_dissector("usbhub", dissect_usb_hub_control, proto_usb_hub); } void proto_reg_handoff_usb_hub(void) { - dissector_handle_t usb_hub_control_handle; - - usb_hub_control_handle = create_dissector_handle(dissect_usb_hub_control, proto_usb_hub); dissector_add_uint("usb.control", IF_CLASS_HUB, usb_hub_control_handle); dissector_add_uint("usb.control", IF_CLASS_UNKNOWN, usb_hub_control_handle); } diff --git a/epan/dissectors/packet-usb-i1d3.c b/epan/dissectors/packet-usb-i1d3.c index 3295354fbc..66f0b5cc98 100644 --- a/epan/dissectors/packet-usb-i1d3.c +++ b/epan/dissectors/packet-usb-i1d3.c @@ -32,6 +32,8 @@ void proto_register_usb_i1d3(void); void proto_reg_handoff_usb_i1d3(void); +static dissector_handle_t usb_i1d3_dissector; + #define USB_I1D3_PACKET_LENGTH (64) #define USB_I1D3_CLOCK_FREQUENCY (12e6) // 12 MHz #define USB_I1D3_LED_OFFTIME_FACTOR (USB_I1D3_CLOCK_FREQUENCY / (1 << 19)) @@ -957,11 +959,11 @@ void proto_register_usb_i1d3(void) expert_module_t *expert_usb_i1d3 = expert_register_protocol( proto_usb_i1d3); expert_register_field_array(expert_usb_i1d3, ei, array_length(ei)); + usb_i1d3_dissector = register_dissector("i1d3", + dissect_usb_i1d3, proto_usb_i1d3); } void proto_reg_handoff_usb_i1d3(void) { - dissector_handle_t usb_i1d3_dissector = create_dissector_handle( - dissect_usb_i1d3, proto_usb_i1d3); dissector_add_for_decode_as("usb.device", usb_i1d3_dissector); dissector_add_uint("usb.product", 0x7655020, usb_i1d3_dissector); } diff --git a/epan/dissectors/packet-usb-masstorage.c b/epan/dissectors/packet-usb-masstorage.c index 6a4e69080d..62489e6046 100644 --- a/epan/dissectors/packet-usb-masstorage.c +++ b/epan/dissectors/packet-usb-masstorage.c @@ -16,6 +16,11 @@ static int proto_usb_ms = -1; +static dissector_handle_t usb_ms_bulk_handle; +static dissector_handle_t usb_ms_control_handle; +static dissector_handle_t usb_ms_interrupt_handle; +static dissector_handle_t usb_ms_descriptor_handle; + static dissector_table_t usb_ms_bulk_dissector_table; static dissector_table_t usb_ms_control_dissector_table; static dissector_table_t usb_ms_interrupt_dissector_table; @@ -113,6 +118,11 @@ proto_register_usb_ms(void) { proto_usb_ms = proto_register_protocol("USB Mass Storage Class", "USBMSClass", "usbmsclass"); + usb_ms_bulk_handle = register_dissector("usbmsclass.bulk", dissect_usb_ms_bulk, proto_usb_ms); + usb_ms_control_handle = register_dissector("usbmsclass.control", dissect_usb_ms_control, proto_usb_ms); + usb_ms_interrupt_handle = register_dissector("usbmsclass.interrupt", dissect_usb_ms_interrupt, proto_usb_ms); + usb_ms_descriptor_handle = register_dissector("usbmsclass.descriptor", dissect_usb_ms_descriptor, proto_usb_ms); + usb_ms_bulk_dissector_table = register_dissector_table("usbms.bulk", "USBMS bulk endpoint", proto_usb_ms, FT_UINT8, BASE_HEX); usb_ms_control_dissector_table = register_dissector_table("usbms.control", @@ -126,16 +136,6 @@ proto_register_usb_ms(void) void proto_reg_handoff_usb_ms(void) { - dissector_handle_t usb_ms_bulk_handle; - dissector_handle_t usb_ms_control_handle; - dissector_handle_t usb_ms_interrupt_handle; - dissector_handle_t usb_ms_descriptor_handle; - - usb_ms_bulk_handle = create_dissector_handle(dissect_usb_ms_bulk, proto_usb_ms); - usb_ms_control_handle = create_dissector_handle(dissect_usb_ms_control, proto_usb_ms); - usb_ms_interrupt_handle = create_dissector_handle(dissect_usb_ms_interrupt, proto_usb_ms); - usb_ms_descriptor_handle = create_dissector_handle(dissect_usb_ms_descriptor, proto_usb_ms); - dissector_add_uint("usb.bulk", IF_CLASS_MASS_STORAGE, usb_ms_bulk_handle); dissector_add_uint("usb.control", IF_CLASS_MASS_STORAGE, usb_ms_control_handle); dissector_add_uint("usb.interrupt", IF_CLASS_MASS_STORAGE, usb_ms_interrupt_handle); diff --git a/epan/dissectors/packet-usb-printer.c b/epan/dissectors/packet-usb-printer.c index a78d516dc9..d703133607 100644 --- a/epan/dissectors/packet-usb-printer.c +++ b/epan/dissectors/packet-usb-printer.c @@ -25,6 +25,8 @@ #include "packet-usb.h" #include <epan/value_string.h> +static dissector_handle_t usb_printer_ctl_handle; + static int proto_usb_printer = -1; static int hf_usb_printer_req = -1; @@ -163,16 +165,12 @@ void proto_register_usb_printer(void) "USB Printer", "USBPRINTER", "usbprinter"); proto_register_field_array(proto_usb_printer, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + usb_printer_ctl_handle = register_dissector("usbprinter", dissect_usb_printer_ctl, proto_usb_printer); } void proto_reg_handoff_usb_printer(void) { - dissector_handle_t usb_printer_ctl_handle; - - usb_printer_ctl_handle = create_dissector_handle( - dissect_usb_printer_ctl, proto_usb_printer); - dissector_add_uint("usb.control", IF_CLASS_PRINTER, usb_printer_ctl_handle); } diff --git a/epan/dissectors/packet-usb-video.c b/epan/dissectors/packet-usb-video.c index bafae5edd6..5e9d632c76 100644 --- a/epan/dissectors/packet-usb-video.c +++ b/epan/dissectors/packet-usb-video.c @@ -200,6 +200,11 @@ void proto_reg_handoff_usb_vid(void); #define USB_SETUP_GET_RES_ALL 0x94 /* UVC 1.5 */ #define USB_SETUP_GET_DEF_ALL 0x97 /* UVC 1.5 */ +/* dissector handles */ +static dissector_handle_t usb_vid_control_handle; +static dissector_handle_t usb_vid_descriptor_handle; +static dissector_handle_t usb_vid_interrupt_handle; + /* protocols and header fields */ static int proto_usb_vid = -1; @@ -3234,22 +3239,17 @@ proto_register_usb_vid(void) proto_register_subtree_array(usb_vid_subtrees, array_length(usb_vid_subtrees)); expert_usb_vid = expert_register_protocol(proto_usb_vid); expert_register_field_array(expert_usb_vid, ei, array_length(ei)); + + usb_vid_control_handle = register_dissector("usbvideo.control", dissect_usb_vid_control, proto_usb_vid); + usb_vid_descriptor_handle = register_dissector("usbvideo.descriptor", dissect_usb_vid_descriptor, proto_usb_vid); + usb_vid_interrupt_handle = register_dissector("usbvideo.interrupt", dissect_usb_vid_interrupt, proto_usb_vid); } void proto_reg_handoff_usb_vid(void) { - dissector_handle_t usb_vid_control_handle; - dissector_handle_t usb_vid_descriptor_handle; - dissector_handle_t usb_vid_interrupt_handle; - - usb_vid_control_handle = create_dissector_handle(dissect_usb_vid_control, proto_usb_vid); dissector_add_uint("usb.control", IF_CLASS_VIDEO, usb_vid_control_handle); - - usb_vid_descriptor_handle = create_dissector_handle(dissect_usb_vid_descriptor, proto_usb_vid); dissector_add_uint("usb.descriptor", IF_CLASS_VIDEO, usb_vid_descriptor_handle); - - usb_vid_interrupt_handle = create_dissector_handle(dissect_usb_vid_interrupt, proto_usb_vid); dissector_add_uint("usb.interrupt", IF_CLASS_VIDEO, usb_vid_interrupt_handle); } /* diff --git a/epan/dissectors/packet-usb.c b/epan/dissectors/packet-usb.c index e978fa1296..a8899da573 100644 --- a/epan/dissectors/packet-usb.c +++ b/epan/dissectors/packet-usb.c @@ -33,6 +33,14 @@ #include "packet-usbip.h" #include "packet-netmon.h" +/* dissector handles */ +static dissector_handle_t linux_usb_handle; +static dissector_handle_t linux_usb_mmapped_handle; +static dissector_handle_t win32_usb_handle; +static dissector_handle_t freebsd_usb_handle; +static dissector_handle_t darwin_usb_handle; +static dissector_handle_t netmon_usb_port_handle; + /* protocols and header fields */ static int proto_usb = -1; static int proto_usbport = -1; @@ -7366,6 +7374,13 @@ proto_register_usb(void) register_decode_as(&usb_product_da); register_decode_as(&usb_device_da); + linux_usb_handle = register_dissector("usb_linux", dissect_linux_usb, proto_usb); + linux_usb_mmapped_handle = register_dissector("usb_linux_mmapped", dissect_linux_usb_mmapped, proto_usb); + win32_usb_handle = register_dissector("usb_win32", dissect_win32_usb, proto_usb); + freebsd_usb_handle = register_dissector("usb_freebsd", dissect_freebsd_usb, proto_usb); + darwin_usb_handle = register_dissector("usb_darwin", dissect_darwin_usb, proto_usb); + netmon_usb_port_handle = register_dissector("usb_netmon", dissect_netmon_usb_port, proto_usbport); + usb_address_type = address_type_dissector_register("AT_USB", "USB Address", usb_addr_to_str, usb_addr_str_len, NULL, usb_col_filter_str, NULL, NULL, NULL); register_conversation_table(proto_usb, TRUE, usb_conversation_packet, usb_endpoint_packet); @@ -7374,30 +7389,15 @@ proto_register_usb(void) void proto_reg_handoff_usb(void) { - dissector_handle_t linux_usb_handle; - dissector_handle_t linux_usb_mmapped_handle; - dissector_handle_t win32_usb_handle; - dissector_handle_t freebsd_usb_handle; - dissector_handle_t darwin_usb_handle; - dissector_handle_t netmon_usb_port_handle; static guid_key usb_port_key = {{ 0xc88a4ef5, 0xd048, 0x4013, { 0x94, 0x08, 0xe0, 0x4b, 0x7d, 0xb2, 0x81, 0x4a }}, 0 }; - linux_usb_handle = create_dissector_handle(dissect_linux_usb, proto_usb); - linux_usb_mmapped_handle = create_dissector_handle(dissect_linux_usb_mmapped, - proto_usb); - win32_usb_handle = create_dissector_handle(dissect_win32_usb, proto_usb); - freebsd_usb_handle = create_dissector_handle(dissect_freebsd_usb, proto_usb); - darwin_usb_handle = create_dissector_handle(dissect_darwin_usb, proto_usb); - dissector_add_uint("wtap_encap", WTAP_ENCAP_USB_LINUX, linux_usb_handle); dissector_add_uint("wtap_encap", WTAP_ENCAP_USB_LINUX_MMAPPED, linux_usb_mmapped_handle); dissector_add_uint("wtap_encap", WTAP_ENCAP_USBPCAP, win32_usb_handle); dissector_add_uint("wtap_encap", WTAP_ENCAP_USB_FREEBSD, freebsd_usb_handle); dissector_add_uint("wtap_encap", WTAP_ENCAP_USB_DARWIN, darwin_usb_handle); - netmon_usb_port_handle = create_dissector_handle( dissect_netmon_usb_port, proto_usbport); dissector_add_guid( "netmon.provider_id", &usb_port_key, netmon_usb_port_handle); - } /* diff --git a/epan/dissectors/packet-usbip.c b/epan/dissectors/packet-usbip.c index 81526432b8..7509f46c57 100644 --- a/epan/dissectors/packet-usbip.c +++ b/epan/dissectors/packet-usbip.c @@ -34,6 +34,8 @@ void proto_register_usbip(void); void proto_reg_handoff_usbip(void); +static dissector_handle_t usbip_handle; + /* Initialize the protocol and registered fields */ static int proto_usbip = -1; @@ -1061,6 +1063,8 @@ proto_register_usbip(void) proto_register_field_array(proto_usbip, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + usbip_handle = register_dissector("usbip", dissect_usbip, proto_usbip); + expert_usbip = expert_register_protocol(proto_usbip); expert_register_field_array(expert_usbip, ei, array_length(ei)); @@ -1069,9 +1073,6 @@ proto_register_usbip(void) void proto_reg_handoff_usbip(void) { - dissector_handle_t usbip_handle; - - usbip_handle = create_dissector_handle(dissect_usbip, proto_usbip); dissector_add_for_decode_as_with_preference("tcp.port", usbip_handle); } diff --git a/epan/dissectors/packet-usbll.c b/epan/dissectors/packet-usbll.c index 476889223a..62ea463777 100644 --- a/epan/dissectors/packet-usbll.c +++ b/epan/dissectors/packet-usbll.c @@ -28,6 +28,11 @@ void proto_register_usbll(void); void proto_reg_handoff_usbll(void); +static dissector_handle_t unknown_speed_handle; +static dissector_handle_t low_speed_handle; +static dissector_handle_t full_speed_handle; +static dissector_handle_t high_speed_handle; + static int proto_usbll = -1; /* Fields defined by USB 2.0 standard */ @@ -2700,7 +2705,10 @@ proto_register_usbll(void) "Use specified speed if speed is not indicated in capture", &global_dissect_unknown_speed_as, dissect_unknown_speed_as, FALSE); - register_dissector("usbll", dissect_usbll_unknown_speed, proto_usbll); + unknown_speed_handle = register_dissector("usbll", dissect_usbll_unknown_speed, proto_usbll); + low_speed_handle = register_dissector("usbll.low_speed", dissect_usbll_low_speed, proto_usbll); + full_speed_handle = register_dissector("usbll.full_speed", dissect_usbll_full_speed, proto_usbll); + high_speed_handle = register_dissector("usbll.high_speed", dissect_usbll_high_speed, proto_usbll); register_cleanup_routine(usbll_cleanup_data); usbll_address_type = address_type_dissector_register("AT_USBLL", "USBLL Address", @@ -2713,11 +2721,6 @@ proto_register_usbll(void) void proto_reg_handoff_usbll(void) { - dissector_handle_t unknown_speed_handle = create_dissector_handle(dissect_usbll_unknown_speed, proto_usbll); - dissector_handle_t low_speed_handle = create_dissector_handle(dissect_usbll_low_speed, proto_usbll); - dissector_handle_t full_speed_handle = create_dissector_handle(dissect_usbll_full_speed, proto_usbll); - dissector_handle_t high_speed_handle = create_dissector_handle(dissect_usbll_high_speed, proto_usbll); - dissector_add_uint("wtap_encap", WTAP_ENCAP_USB_2_0, unknown_speed_handle); dissector_add_uint("wtap_encap", WTAP_ENCAP_USB_2_0_LOW_SPEED, low_speed_handle); dissector_add_uint("wtap_encap", WTAP_ENCAP_USB_2_0_FULL_SPEED, full_speed_handle); diff --git a/epan/dissectors/packet-usbms-bot.c b/epan/dissectors/packet-usbms-bot.c index 27abe36faf..d5d31fc0f2 100644 --- a/epan/dissectors/packet-usbms-bot.c +++ b/epan/dissectors/packet-usbms-bot.c @@ -39,6 +39,7 @@ static int hf_usbms_bot_maxlun = -1; static gint ett_usbms_bot = -1; static dissector_handle_t usbms_bot_bulk_handle; +static dissector_handle_t usbms_bot_control_handle; /* there is one such structure for each masstorage conversation */ typedef struct _usbms_bot_conv_info_t { @@ -510,16 +511,13 @@ proto_register_usbms_bot(void) proto_register_subtree_array(usbms_bot_subtrees, array_length(usbms_bot_subtrees)); usbms_bot_bulk_handle = register_dissector("usbms", dissect_usbms_bot_bulk, proto_usbms_bot); + usbms_bot_control_handle = register_dissector("usbms.control", dissect_usbms_bot_control, proto_usbms_bot); } void proto_reg_handoff_usbms_bot(void) { - dissector_handle_t usbms_bot_control_handle; - dissector_add_uint("usbms.bulk", IF_PROTOCOL_BULK_ONLY, usbms_bot_bulk_handle); - - usbms_bot_control_handle = create_dissector_handle(dissect_usbms_bot_control, proto_usbms_bot); dissector_add_uint("usbms.control", IF_PROTOCOL_BULK_ONLY, usbms_bot_control_handle); heur_dissector_add("usb.bulk", dissect_usbms_bot_bulk_heur, diff --git a/epan/dissectors/packet-usbms-uasp.c b/epan/dissectors/packet-usbms-uasp.c index 9e7ad6c66c..d3df7fe464 100644 --- a/epan/dissectors/packet-usbms-uasp.c +++ b/epan/dissectors/packet-usbms-uasp.c @@ -20,6 +20,9 @@ void proto_reg_handoff_uasp(void); #define IF_PROTOCOL_UAS 0x62 +static dissector_handle_t uasp_descriptor_handle; +static dissector_handle_t uasp_bulk_handle; + static int proto_uasp = -1; static int hf_pipe_usage_descr_pipe_id = -1; @@ -616,17 +619,14 @@ proto_register_uasp(void) proto_uasp = proto_register_protocol("USB Attached SCSI", "UASP", "uasp"); proto_register_field_array(proto_uasp, hf, array_length(hf)); proto_register_subtree_array(uasp_subtrees, array_length(uasp_subtrees)); + + uasp_descriptor_handle = register_dissector("uasp", dissect_uasp_descriptor, proto_uasp); + uasp_bulk_handle = register_dissector("uasp.bulk", dissect_uasp_bulk, proto_uasp); } void proto_reg_handoff_uasp(void) { - dissector_handle_t uasp_descriptor_handle; - dissector_handle_t uasp_bulk_handle; - - uasp_descriptor_handle = create_dissector_handle(dissect_uasp_descriptor, proto_uasp); dissector_add_uint("usbms.descriptor", IF_PROTOCOL_UAS, uasp_descriptor_handle); - - uasp_bulk_handle = create_dissector_handle(dissect_uasp_bulk, proto_uasp); dissector_add_uint("usbms.bulk", IF_PROTOCOL_UAS, uasp_bulk_handle); } diff --git a/epan/dissectors/packet-userlog.c b/epan/dissectors/packet-userlog.c index 4b36bcd382..b9d27d1769 100644 --- a/epan/dissectors/packet-userlog.c +++ b/epan/dissectors/packet-userlog.c @@ -29,6 +29,8 @@ void proto_register_userlog(void); void proto_reg_handoff_userlog(void); +static dissector_handle_t userlog_handle; + static int proto_userlog = -1; static int hf_userlog_version = -1; @@ -394,14 +396,12 @@ proto_register_userlog(void) proto_userlog = proto_register_protocol("UserLog Protocol", "UserLog", "userlog"); proto_register_field_array(proto_userlog, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + userlog_handle = register_dissector("userlog", dissect_userlog, proto_userlog); } void proto_reg_handoff_userlog(void) { - dissector_handle_t userlog_handle; - - userlog_handle = create_dissector_handle(dissect_userlog, proto_userlog); dissector_add_for_decode_as_with_preference("udp.port", userlog_handle); } diff --git a/epan/dissectors/packet-v5ua.c b/epan/dissectors/packet-v5ua.c index 150ee4a323..6844135deb 100644 --- a/epan/dissectors/packet-v5ua.c +++ b/epan/dissectors/packet-v5ua.c @@ -38,6 +38,8 @@ void proto_register_v5ua(void); void proto_reg_handoff_v5ua(void); +static dissector_handle_t v5ua_handle; + static int paddingl = 0; static int dlci_efa = -1; @@ -1619,6 +1621,9 @@ proto_register_v5ua(void) /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_v5ua, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + /* Register the dissector handle */ + v5ua_handle = register_dissector("v5ua", dissect_v5ua, proto_v5ua); } @@ -1629,9 +1634,6 @@ proto_register_v5ua(void) void proto_reg_handoff_v5ua(void) { - dissector_handle_t v5ua_handle; - - v5ua_handle = create_dissector_handle(dissect_v5ua, proto_v5ua); q931_handle = find_dissector_add_dependency("q931", proto_v5ua); v52_handle = find_dissector_add_dependency("v52", proto_v5ua); diff --git a/epan/dissectors/packet-vicp.c b/epan/dissectors/packet-vicp.c index 9ceb3e6667..001a5d7421 100644 --- a/epan/dissectors/packet-vicp.c +++ b/epan/dissectors/packet-vicp.c @@ -31,6 +31,8 @@ static gint ett_vicp = -1; void proto_register_vicp(void); void proto_reg_handoff_vicp(void); +static dissector_handle_t vicp_handle; + static int dissect_vicp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { proto_item *ti; @@ -98,12 +100,11 @@ void proto_register_vicp(void) proto_vicp = proto_register_protocol("LeCroy VICP", "VICP", "vicp"); proto_register_field_array(proto_vicp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + vicp_handle = register_dissector("vicp", dissect_vicp, proto_vicp); } void proto_reg_handoff_vicp(void) -{ dissector_handle_t vicp_handle; - - vicp_handle = create_dissector_handle(dissect_vicp, proto_vicp); +{ dissector_add_uint_with_preference("tcp.port", VICP_PORT, vicp_handle); } diff --git a/epan/dissectors/packet-vines.c b/epan/dissectors/packet-vines.c index c71b81df2c..9dd28fbdd5 100644 --- a/epan/dissectors/packet-vines.c +++ b/epan/dissectors/packet-vines.c @@ -112,11 +112,15 @@ static int hf_vines_frp_sequence_number = -1; static gint ett_vines_frp = -1; static gint ett_vines_frp_flags = -1; +static dissector_handle_t vines_frp_handle, vines_frp_new_handle; + static int proto_vines_llc = -1; static int hf_vines_llc_packet_type = -1; static gint ett_vines_llc = -1; +static dissector_handle_t vines_llc_handle; + static int proto_vines_ip = -1; static int hf_vines_ip_protocol = -1; static int hf_vines_ip_checksum = -1; @@ -134,12 +138,16 @@ static int hf_vines_tctl_hop_count = -1; static gint ett_vines_ip = -1; static gint ett_vines_ip_tctl = -1; +static dissector_handle_t vines_ip_handle; + static int proto_vines_echo = -1; static gint hf_vines_echo_data = -1; static gint ett_vines_echo = -1; +static dissector_handle_t vines_echo_handle; + static int proto_vines_ipc = -1; static int hf_vines_ipc_src_port = -1; static int hf_vines_ipc_dest_port = -1; @@ -159,6 +167,8 @@ static int hf_vines_ipc_error = -1; static gint ett_vines_ipc = -1; static gint ett_vines_ipc_control = -1; +static dissector_handle_t vines_ipc_handle; + static int proto_vines_spp = -1; static int hf_vines_spp_src_port = -1; static int hf_vines_spp_dest_port = -1; @@ -177,6 +187,8 @@ static int hf_vines_spp_window = -1; static gint ett_vines_spp = -1; static gint ett_vines_spp_control = -1; +static dissector_handle_t vines_spp_handle; + static int proto_vines_arp = -1; static int hf_vines_arp_address = -1; static int hf_vines_arp_version = -1; @@ -186,6 +198,8 @@ static int hf_vines_arp_sequence_number = -1; static gint ett_vines_arp = -1; +static dissector_handle_t vines_arp_handle; + static int proto_vines_rtp = -1; static int hf_vines_rtp_comp_flag = -1; static int hf_vines_rtp_comp_flag_neighbor_router = -1; @@ -246,6 +260,8 @@ static gint ett_vines_rtp_control_flags = -1; static gint ett_vines_rtp_mtype = -1; static gint ett_vines_rtp_flags = -1; +static dissector_handle_t vines_rtp_handle; + static int proto_vines = -1; static int proto_vines_icp = -1; static int hf_vines_icp_exception_code = -1; @@ -254,6 +270,10 @@ static int hf_vines_icp_packet_type = -1; static gint ett_vines_icp = -1; +static dissector_handle_t vines_icp_handle; +static capture_dissector_handle_t vines_echo_cap_handle; +static capture_dissector_handle_t vines_ip_cap_handle; + /* VINES IP structs and definitions */ enum { @@ -306,8 +326,6 @@ capture_vines(const guchar *pd _U_, int offset _U_, int len _U_, capture_packet_ return TRUE; } -static dissector_handle_t vines_ip_handle; - /* Control flags */ #define VINES_FRP_FIRST_FRAGMENT 0x01 #define VINES_FRP_LAST_FRAGMENT 0x02 @@ -402,19 +420,14 @@ proto_register_vines_frp(void) "Banyan Vines Fragmentation Protocol", "Vines FRP", "vines_frp"); proto_register_field_array(proto_vines_frp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + vines_frp_handle = register_dissector("vines_frp", dissect_vines_frp, proto_vines_frp); + vines_frp_new_handle = register_dissector("vines_frp.udp", dissect_vines_frp_new, proto_vines_frp); } void proto_reg_handoff_vines_frp(void) { - dissector_handle_t vines_frp_handle, vines_frp_new_handle; - - vines_frp_handle = create_dissector_handle(dissect_vines_frp, - proto_vines_frp); dissector_add_uint("ip.proto", IP_PROTO_VINES, vines_frp_handle); - - vines_frp_new_handle = create_dissector_handle(dissect_vines_frp_new, - proto_vines_frp); dissector_add_uint_with_preference("udp.port", UDP_PORT_VINES, vines_frp_new_handle); } @@ -477,6 +490,7 @@ proto_register_vines_llc(void) "Banyan Vines LLC", "Vines LLC", "vines_llc"); proto_register_field_array(proto_vines_llc, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + vines_llc_handle = register_dissector("vines_llc", dissect_vines_llc, proto_vines_llc); /* subdissector code */ vines_llc_dissector_table = register_dissector_table("vines_llc.ptype", @@ -486,10 +500,6 @@ proto_register_vines_llc(void) void proto_reg_handoff_vines_llc(void) { - dissector_handle_t vines_llc_handle; - - vines_llc_handle = create_dissector_handle(dissect_vines_llc, - proto_vines_llc); dissector_add_uint("llc.dsap", SAP_VINES2, vines_llc_handle); } @@ -686,7 +696,7 @@ proto_register_vines_ip(void) vines_ip_dissector_table = register_dissector_table("vines_ip.protocol", "Vines protocol", proto_vines_ip, FT_UINT8, BASE_HEX); - vines_ip_handle = create_dissector_handle(dissect_vines_ip, + vines_ip_handle = register_dissector("vines_ip", dissect_vines_ip, proto_vines_ip); } @@ -735,15 +745,13 @@ proto_register_vines_echo(void) "Banyan Vines Echo", "Vines Echo", "vines_echo"); proto_register_field_array(proto_vines_echo, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + vines_echo_handle = register_dissector("vines_echo", dissect_vines_echo, + proto_vines_echo); } void proto_reg_handoff_vines_echo(void) { - dissector_handle_t vines_echo_handle; - - vines_echo_handle = create_dissector_handle(dissect_vines_echo, - proto_vines_echo); dissector_add_uint("vines_llc.ptype", VINES_LLC_ECHO, vines_echo_handle); dissector_add_uint("ethertype", ETHERTYPE_VINES_ECHO, vines_echo_handle); } @@ -982,6 +990,8 @@ proto_register_vines_ipc(void) "Vines IPC", "vines_ipc"); proto_register_field_array(proto_vines_ipc, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + vines_ipc_handle = register_dissector("vines_ipc", dissect_vines_ipc, + proto_vines_ipc); vines_ipc_heur_subdissector_list = register_heur_dissector_list("vines_ipc", proto_vines_ipc); } @@ -989,10 +999,6 @@ proto_register_vines_ipc(void) void proto_reg_handoff_vines_ipc(void) { - dissector_handle_t vines_ipc_handle; - - vines_ipc_handle = create_dissector_handle(dissect_vines_ipc, - proto_vines_ipc); dissector_add_uint("vines_ip.protocol", VIP_PROTO_IPC, vines_ipc_handle); } @@ -1150,6 +1156,8 @@ proto_register_vines_spp(void) "Vines SPP", "vines_spp"); proto_register_field_array(proto_vines_spp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + vines_spp_handle = register_dissector("vines_spp", dissect_vines_spp, + proto_vines_spp); vines_spp_heur_subdissector_list = register_heur_dissector_list("vines_spp", proto_vines_spp); } @@ -1157,10 +1165,6 @@ proto_register_vines_spp(void) void proto_reg_handoff_vines_spp(void) { - dissector_handle_t vines_spp_handle; - - vines_spp_handle = create_dissector_handle(dissect_vines_spp, - proto_vines_spp); dissector_add_uint("vines_ip.protocol", VIP_PROTO_SPP, vines_spp_handle); } @@ -1287,15 +1291,13 @@ proto_register_vines_arp(void) "Banyan Vines ARP", "Vines ARP", "vines_arp"); proto_register_field_array(proto_vines_arp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + vines_arp_handle = register_dissector("vines_arp", dissect_vines_arp, + proto_vines_arp); } void proto_reg_handoff_vines_arp(void) { - dissector_handle_t vines_arp_handle; - - vines_arp_handle = create_dissector_handle(dissect_vines_arp, - proto_vines_arp); dissector_add_uint("vines_ip.protocol", VIP_PROTO_ARP, vines_arp_handle); } @@ -1883,15 +1885,13 @@ proto_register_vines_rtp(void) "Banyan Vines RTP", "Vines RTP", "vines_rtp"); proto_register_field_array(proto_vines_rtp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + vines_rtp_handle = register_dissector("vines_rtp", dissect_vines_rtp, + proto_vines_rtp); } void proto_reg_handoff_vines_rtp(void) { - dissector_handle_t vines_rtp_handle; - - vines_rtp_handle = create_dissector_handle(dissect_vines_rtp, - proto_vines_rtp); dissector_add_uint("vines_ip.protocol", VIP_PROTO_RTP, vines_rtp_handle); } @@ -1996,21 +1996,18 @@ proto_register_vines_icp(void) proto_vines = proto_register_protocol("VINES", "VINES", "vines"); proto_register_field_array(proto_vines_icp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + + vines_icp_handle = register_dissector("vines_icp", dissect_vines_icp, proto_vines_icp); + vines_ip_cap_handle = register_capture_dissector("vines.ip", capture_vines, proto_vines_ip); + vines_echo_cap_handle = register_capture_dissector("vines.echo", capture_vines, proto_vines_echo); } void proto_reg_handoff_vines_icp(void) { - dissector_handle_t vines_icp_handle; - capture_dissector_handle_t vines_echo_cap_handle; - capture_dissector_handle_t vines_ip_cap_handle; - - vines_icp_handle = create_dissector_handle(dissect_vines_icp, proto_vines_icp); dissector_add_uint("vines_ip.protocol", VIP_PROTO_ICP, vines_icp_handle); - vines_ip_cap_handle = create_capture_dissector_handle(capture_vines, proto_vines_ip); capture_dissector_add_uint("ethertype", ETHERTYPE_VINES_IP, vines_ip_cap_handle); - vines_echo_cap_handle = create_capture_dissector_handle(capture_vines, proto_vines_echo); capture_dissector_add_uint("ethertype", ETHERTYPE_VINES_ECHO, vines_echo_cap_handle); capture_dissector_add_uint("ppp_hdlc", PPP_VINES, vines_echo_cap_handle); capture_dissector_add_uint("ip.proto", PPP_VINES, vines_echo_cap_handle); diff --git a/epan/dissectors/packet-vj-comp.c b/epan/dissectors/packet-vj-comp.c index ebe4136df7..ad01793f55 100644 --- a/epan/dissectors/packet-vj-comp.c +++ b/epan/dissectors/packet-vj-comp.c @@ -87,6 +87,8 @@ typedef struct vjc_conv_s { wmem_map_t *vals; // Hash of frame_number => vjc_hdr_t* } vjc_conv_t; +static dissector_handle_t vjcu_handle; +static dissector_handle_t vjcc_handle; static dissector_handle_t ip_handle; void proto_register_vjc(void); @@ -841,6 +843,8 @@ proto_register_vjc(void) proto_register_subtree_array(ett, array_length(ett)); expert_vjc = expert_register_protocol(proto_vjc); expert_register_field_array(expert_vjc, ei, array_length(ei)); + vjcc_handle = register_dissector("vjc_compressed", dissect_vjc_comp, proto_vjc); + vjcu_handle = register_dissector("vjc_uncompressed", dissect_vjc_uncomp, proto_vjc); register_init_routine(&vjc_init_protocol); register_cleanup_routine(&vjc_cleanup_protocol); @@ -849,15 +853,9 @@ proto_register_vjc(void) void proto_reg_handoff_vjc(void) { - dissector_handle_t vjcu_handle; - dissector_handle_t vjcc_handle; - ip_handle = find_dissector("ip"); - vjcc_handle = create_dissector_handle(dissect_vjc_comp, proto_vjc); dissector_add_uint("ppp.protocol", PPP_VJC_COMP, vjcc_handle); - - vjcu_handle = create_dissector_handle(dissect_vjc_uncomp, proto_vjc); dissector_add_uint("ppp.protocol", PPP_VJC_UNCOMP, vjcu_handle); } diff --git a/epan/dissectors/packet-vmlab.c b/epan/dissectors/packet-vmlab.c index 4dfc8aa50b..41890b61ec 100644 --- a/epan/dissectors/packet-vmlab.c +++ b/epan/dissectors/packet-vmlab.c @@ -36,6 +36,7 @@ void proto_register_vmlab(void); void proto_reg_handoff_vmlab(void); +static dissector_handle_t vmlab_handle; static dissector_handle_t ethertype_handle; static int proto_vmlab = -1; @@ -156,15 +157,12 @@ proto_register_vmlab(void) proto_vmlab = proto_register_protocol("VMware Lab Manager", "VMLAB", "vmlab"); proto_register_field_array(proto_vmlab, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + vmlab_handle = register_dissector("vmlab", dissect_vmlab, proto_vmlab); } void proto_reg_handoff_vmlab(void) { - dissector_handle_t vmlab_handle; - - vmlab_handle = create_dissector_handle(dissect_vmlab, proto_vmlab); - dissector_add_uint("ethertype", ETHERTYPE_VMLAB, vmlab_handle); ethertype_handle = find_dissector_add_dependency("ethertype", proto_vmlab); diff --git a/epan/dissectors/packet-vntag.c b/epan/dissectors/packet-vntag.c index 8e03d2fc91..64fca81f5a 100644 --- a/epan/dissectors/packet-vntag.c +++ b/epan/dissectors/packet-vntag.c @@ -18,6 +18,7 @@ void proto_register_vntag(void); void proto_reg_handoff_vntag(void); +static dissector_handle_t vntag_handle; static dissector_handle_t ethertype_handle; static int proto_vntag = -1; @@ -165,15 +166,12 @@ proto_register_vntag(void) proto_register_subtree_array(ett, array_length(ett)); expert_vntag = expert_register_protocol(proto_vntag); expert_register_field_array(expert_vntag, ei, array_length(ei)); - + vntag_handle = register_dissector("vntag", dissect_vntag, proto_vntag); } void proto_reg_handoff_vntag(void) { - dissector_handle_t vntag_handle; - - vntag_handle = create_dissector_handle(dissect_vntag, proto_vntag); dissector_add_uint("ethertype", ETHERTYPE_VNTAG, vntag_handle); ethertype_handle = find_dissector_add_dependency("ethertype", proto_vntag); diff --git a/epan/dissectors/packet-vrrp.c b/epan/dissectors/packet-vrrp.c index c158d6c085..b12677137b 100644 --- a/epan/dissectors/packet-vrrp.c +++ b/epan/dissectors/packet-vrrp.c @@ -24,6 +24,8 @@ void proto_register_vrrp(void); void proto_reg_handoff_vrrp(void); +static dissector_handle_t vrrp_handle; + static gint proto_vrrp = -1; static gint ett_vrrp = -1; static gint ett_vrrp_ver_type = -1; @@ -317,6 +319,8 @@ void proto_register_vrrp(void) proto_register_field_array(proto_vrrp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + vrrp_handle = register_dissector("vrrp", dissect_vrrp, proto_vrrp); + expert_vrrp = expert_register_protocol(proto_vrrp); expert_register_field_array(expert_vrrp, ei, array_length(ei)); @@ -327,16 +331,11 @@ void proto_register_vrrp(void) "There is some ambiguity on how to calculate V3 checksums" "As in V3 will use a pseudo header(which may only be implemented for IPv6 by some manufacturers)", &g_vrrp_v3_checksum_as_in_v2); - - } void proto_reg_handoff_vrrp(void) { - dissector_handle_t vrrp_handle; - - vrrp_handle = create_dissector_handle(dissect_vrrp, proto_vrrp); dissector_add_uint("ip.proto", IP_PROTO_VRRP, vrrp_handle); } diff --git a/epan/dissectors/packet-vrt.c b/epan/dissectors/packet-vrt.c index 92cb269fdf..13c4cae752 100644 --- a/epan/dissectors/packet-vrt.c +++ b/epan/dissectors/packet-vrt.c @@ -23,6 +23,8 @@ void proto_register_vrt(void); void proto_reg_handoff_vrt(void); +static dissector_handle_t vrt_handle; + #define VITA_49_PORT 4991 #define DEFAULT_EPHEMERIS_FIELDS { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } #define DEFAULT_FORMATTED_GPS_INS_FIELDS { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } @@ -2445,6 +2447,8 @@ proto_register_vrt(void) proto_register_field_array(proto_vrt, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + vrt_handle = register_dissector("vrt", dissect_vrt, proto_vrt); + vrt_module = prefs_register_protocol(proto_vrt, NULL); prefs_register_bool_preference(vrt_module, "ettus_uhd_header_format", "Use Ettus UHD header format", @@ -2455,9 +2459,6 @@ proto_register_vrt(void) void proto_reg_handoff_vrt(void) { - dissector_handle_t vrt_handle; - - vrt_handle = create_dissector_handle(dissect_vrt, proto_vrt); dissector_add_uint_with_preference("udp.port", VITA_49_PORT, vrt_handle); dissector_add_string("rtp_dyn_payload_type","VITA 49", vrt_handle); diff --git a/epan/dissectors/packet-vsip.c b/epan/dissectors/packet-vsip.c index f6c0e4379f..455cb0b4ce 100644 --- a/epan/dissectors/packet-vsip.c +++ b/epan/dissectors/packet-vsip.c @@ -23,6 +23,8 @@ void proto_register_vsip(void); void proto_reg_handoff_vsip(void); +static dissector_handle_t vsip_handle; + static const value_string EVsipMessageType_vals[] = { { 1, "VSIP Ping Request"}, @@ -2060,13 +2062,11 @@ void proto_register_vsip(void) proto_register_subtree_array(ett, array_length(ett)); proto_register_field_array(proto_vsip, hf, array_length(hf)); + vsip_handle = register_dissector("vsip", dissect_vsip, proto_vsip); } void proto_reg_handoff_vsip(void) { - dissector_handle_t vsip_handle; - - vsip_handle = create_dissector_handle(dissect_vsip, proto_vsip); dissector_add_for_decode_as_with_preference("udp.port", vsip_handle); dissector_add_for_decode_as_with_preference("tcp.port", vsip_handle); } diff --git a/epan/dissectors/packet-vtp.c b/epan/dissectors/packet-vtp.c index 89d8118d9c..87d8791f70 100644 --- a/epan/dissectors/packet-vtp.c +++ b/epan/dissectors/packet-vtp.c @@ -24,6 +24,8 @@ void proto_register_vtp(void); void proto_reg_handoff_vtp(void); +static dissector_handle_t vtp_handle; + static int proto_vtp = -1; static int hf_vtp_version = -1; static int hf_vtp_code = -1; @@ -671,14 +673,12 @@ proto_register_vtp(void) proto_register_subtree_array(ett, array_length(ett)); expert_vtp = expert_register_protocol(proto_vtp); expert_register_field_array(expert_vtp, ei, array_length(ei)); + vtp_handle = register_dissector("vtp", dissect_vtp, proto_vtp); } void proto_reg_handoff_vtp(void) { - dissector_handle_t vtp_handle; - - vtp_handle = create_dissector_handle(dissect_vtp, proto_vtp); dissector_add_uint("llc.cisco_pid", CISCO_PID_VTP, vtp_handle); } diff --git a/epan/dissectors/packet-vxlan.c b/epan/dissectors/packet-vxlan.c index 8223075b8a..4bcc61dd62 100644 --- a/epan/dissectors/packet-vxlan.c +++ b/epan/dissectors/packet-vxlan.c @@ -25,6 +25,9 @@ void proto_register_vxlan(void); void proto_reg_handoff_vxlan(void); +static dissector_handle_t vxlan_handle; +static dissector_handle_t vxlan_gpe_handle; + static int proto_vxlan = -1; static int proto_vxlan_gpe = -1; @@ -273,15 +276,14 @@ proto_register_vxlan(void) 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); - + /* Register dissector handles */ + vxlan_handle = register_dissector("vxlan", dissect_vxlan, proto_vxlan); + vxlan_gpe_handle = register_dissector("vxlan_gpe", dissect_vxlan_gpe, proto_vxlan_gpe); } void proto_reg_handoff_vxlan(void) { - dissector_handle_t vxlan_handle; - dissector_handle_t vxlan_gpe_handle; - /* * RFC 7348 Figures 1 and 2, in the Payload section, say * @@ -292,8 +294,6 @@ proto_reg_handoff_vxlan(void) */ eth_handle = find_dissector_add_dependency("eth_withoutfcs", proto_vxlan); - vxlan_handle = create_dissector_handle(dissect_vxlan, proto_vxlan); - vxlan_gpe_handle = create_dissector_handle(dissect_vxlan_gpe, proto_vxlan_gpe); dissector_add_uint_with_preference("udp.port", UDP_PORT_VXLAN, vxlan_handle); dissector_add_uint_with_preference("udp.port", UDP_PORT_VXLAN_GPE, vxlan_gpe_handle); } |