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);
 }