1740. [bug] Replace rbt's hash algorithm as it performed badly

                        with certain zones. [RT #12729]

diff --git a/CHANGES b/CHANGES
index 83b00b5306b3f26d89eb4bfd5fa6525de5a19bcb..0fe23a4e497072083f50a23ed4bc7be4ecd2fd6d 100644 (file)
--- a/CHANGES
+++ b/CHANGES
@@ -36,7 +36,12 @@
 1741.  [bug]           Deleting all records at a node in a secure zone
                        using a update-policy grant failed. [RT #12787]
 
-1740.  [placeholder]   rt12729
+1740.  [bug]           Replace rbt's hash algorithm as it performed badly
+                       with certain zones. [RT #12729]
+                       
+                       NOTE: a hash context now needs to be established
+                       via isc_hash_create() if the application was not
+                       already doing this.
 
 1739.  [bug]           dns_rbt_deletetree() could incorrectly return
                        ISC_R_QUOTA.  [RT #12695]

diff --git a/bin/check/named-checkzone.c b/bin/check/named-checkzone.c
index a201b6c61e0a054e792d0197f6319d6a4bb15aca..e4f93d2aa3fb73ff9f8f284172f761495f4caa14 100644 (file)
--- a/bin/check/named-checkzone.c
+++ b/bin/check/named-checkzone.c
@@ -15,7 +15,7 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
-/* $Id: named-checkzone.c,v 1.30 2004/10/06 05:56:28 marka Exp $ */
+/* $Id: named-checkzone.c,v 1.31 2004/10/25 01:27:53 marka Exp $ */
 
 #include <config.h>
 
@@ -24,6 +24,8 @@
 #include <isc/app.h>
 #include <isc/commandline.h>
 #include <isc/dir.h>
+#include <isc/entropy.h>
+#include <isc/hash.h>
 #include <isc/log.h>
 #include <isc/mem.h>
 #include <isc/socket.h>
@@ -44,6 +46,7 @@
 
 static int quiet = 0;
 static isc_mem_t *mctx = NULL;
+static isc_entropy_t *ectx = NULL;
 dns_zone_t *zone = NULL;
 dns_zonetype_t zonetype = dns_zone_master;
 static int dumpzone = 0;
@@ -185,6 +188,9 @@ main(int argc, char **argv) {
                dns_log_init(lctx);
                dns_log_setcontext(lctx);
        }
+       RUNTIME_CHECK(isc_entropy_create(mctx, &ectx) == ISC_R_SUCCESS);
+       RUNTIME_CHECK(isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE)
+                     == ISC_R_SUCCESS);
 
        dns_result_register();
 
@@ -201,6 +207,8 @@ main(int argc, char **argv) {
        destroy();
        if (lctx != NULL)
                isc_log_destroy(&lctx);
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
        return ((result == ISC_R_SUCCESS) ? 0 : 1);
 }

diff --git a/bin/dnssec/dnssec-signzone.c b/bin/dnssec/dnssec-signzone.c
index c15b952712133fa84f1724cedde4307cd077781e..e582205c82e3bbd001a56fae0f37dedefe6dae16 100644 (file)
--- a/bin/dnssec/dnssec-signzone.c
+++ b/bin/dnssec/dnssec-signzone.c
@@ -16,7 +16,7 @@
  * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-/* $Id: dnssec-signzone.c,v 1.182 2004/08/28 06:16:51 marka Exp $ */
+/* $Id: dnssec-signzone.c,v 1.183 2004/10/25 01:27:53 marka Exp $ */
 
 #include <config.h>
 
@@ -28,6 +28,7 @@
 #include <isc/entropy.h>
 #include <isc/event.h>
 #include <isc/file.h>
+#include <isc/hash.h>
 #include <isc/mem.h>
 #include <isc/mutex.h>
 #include <isc/os.h>
@@ -1824,6 +1825,11 @@ main(int argc, char *argv[]) {
        eflags = ISC_ENTROPY_BLOCKING;
        if (!pseudorandom)
                eflags |= ISC_ENTROPY_GOODONLY;
+
+       result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (result != ISC_R_SUCCESS)
+               fatal("could not create hash context");
+
        result = dst_lib_init(mctx, ectx, eflags);
        if (result != ISC_R_SUCCESS)
                fatal("could not initialize dst");
@@ -2086,6 +2092,7 @@ main(int argc, char *argv[]) {
 
        cleanup_logging(&log);
        dst_lib_destroy();
+       isc_hash_destroy();
        cleanup_entropy(&ectx);
        if (verbose > 10)
                isc_mem_stats(mctx, stdout);

diff --git a/bin/tests/db/t_db.c b/bin/tests/db/t_db.c
index 3b002015334f2f49d3c23b78fdebcb28ee42e719..c0a033816817d7f7d978edc86267a0b9b6664f66 100644 (file)
--- a/bin/tests/db/t_db.c
+++ b/bin/tests/db/t_db.c
@@ -15,13 +15,15 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
-/* $Id: t_db.c,v 1.31 2004/03/05 04:58:42 marka Exp $ */
+/* $Id: t_db.c,v 1.32 2004/10/25 01:27:54 marka Exp $ */
 
 #include <config.h>
 
 #include <ctype.h>
 #include <stdlib.h>
 
+#include <isc/entropy.h>
+#include <isc/hash.h>
 #include <isc/mem.h>
 #include <isc/string.h>
 #include <isc/util.h>
@@ -104,6 +106,7 @@ t_dns_db_load(char **av) {
        isc_result_t            dns_result;
        isc_result_t            isc_result;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        dns_dbnode_t            *nodep;
        isc_textregion_t        textregion;
        isc_buffer_t            findname_buffer;
@@ -118,6 +121,7 @@ t_dns_db_load(char **av) {
        result = T_UNRESOLVED;
        db = NULL;
        mctx = NULL;
+       ectx = NULL;
        filename = T_ARG(0);
        db_type = T_ARG(1);
        origin = T_ARG(2);
@@ -140,8 +144,27 @@ t_dns_db_load(char **av) {
                return(T_UNRESOLVED);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        dns_result = t_create(db_type, origin, class, model, mctx, &db);
        if (dns_result != ISC_R_SUCCESS) {
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -152,6 +175,8 @@ t_dns_db_load(char **av) {
                                dns_result_totext(dns_result),
                                dns_result_totext(exp_load_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_FAIL);
        }
@@ -170,6 +195,8 @@ t_dns_db_load(char **av) {
                t_info("dns_name_fromtext failed %s\n",
                        dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -182,6 +209,8 @@ t_dns_db_load(char **av) {
                                find_type,
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -222,6 +251,8 @@ t_dns_db_load(char **av) {
                dns_db_closeversion(db, &versionp, ISC_FALSE);
  cleanup_db:
        dns_db_detach(&db);
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
        return(result);
 }
@@ -255,6 +286,7 @@ t_dns_db_zc_x(char *filename, char *db_type, char *origin, char *class,
        isc_result_t            dns_result;
        isc_result_t            isc_result;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        dns_rdataclass_t        rdataclass;
        isc_textregion_t        textregion;
        isc_buffer_t            origin_buffer;
@@ -264,6 +296,7 @@ t_dns_db_zc_x(char *filename, char *db_type, char *origin, char *class,
 
        db = NULL;
        mctx = NULL;
+       ectx = NULL;
 
        t_info("testing using file %s\n", filename);
 
@@ -295,12 +328,31 @@ t_dns_db_zc_x(char *filename, char *db_type, char *origin, char *class,
                return(T_UNRESOLVED);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        dns_result = dns_db_create(mctx, db_type,
                                   dns_fixedname_name(&dns_origin),
                                   dbtype, rdataclass, 0, NULL, &db);
        if (dns_result != ISC_R_SUCCESS) {
                t_info("dns_db_create failed %s\n",
                       dns_result_totext(dns_result));
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -318,6 +370,8 @@ t_dns_db_zc_x(char *filename, char *db_type, char *origin, char *class,
        }
 
        dns_db_detach(&db);
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
        return(result);
 }
@@ -460,6 +514,7 @@ t_dns_db_origin(char **av) {
        isc_result_t            dns_result;
        isc_result_t            isc_result;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        dns_db_t                *db;
        dns_fixedname_t         dns_origin;
        dns_fixedname_t         dns_dborigin;
@@ -467,7 +522,7 @@ t_dns_db_origin(char **av) {
 
        db = NULL;
        mctx = NULL;
-
+       ectx = NULL;
 
        filename = T_ARG(0);
        origin = T_ARG(1);
@@ -482,10 +537,29 @@ t_dns_db_origin(char **av) {
                return(T_UNRESOLVED);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        dns_result = t_create("rbt", origin, "in", "isc_true", mctx, &db);
        if (dns_result != ISC_R_SUCCESS) {
                t_info("t_create failed %s\n",
                        dns_result_totext(dns_result));
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -501,6 +575,8 @@ t_dns_db_origin(char **av) {
                t_info("dns_db_load failed %s\n",
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -511,6 +587,8 @@ t_dns_db_origin(char **av) {
                t_info("dns_name_fromtext failed %s\n",
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -524,6 +602,8 @@ t_dns_db_origin(char **av) {
        }
 
        dns_db_detach(&db);
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
        return(result);
 
@@ -558,6 +638,7 @@ t_dns_db_class(char **av) {
        isc_result_t            dns_result;
        isc_result_t            isc_result;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        dns_db_t                *db;
        dns_rdataclass_t        rdataclass;
        dns_rdataclass_t        db_rdataclass;
@@ -567,7 +648,7 @@ t_dns_db_class(char **av) {
        class = T_ARG(1);
        db = NULL;
        mctx = NULL;
-
+       ectx = NULL;
 
        t_info("testing with database %s and class %s\n",
                        filename, class);
@@ -588,10 +669,29 @@ t_dns_db_class(char **av) {
                return(T_UNRESOLVED);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        dns_result = t_create("rbt", ".", class, "isc_true", mctx, &db);
        if (dns_result != ISC_R_SUCCESS) {
                t_info("t_create failed %s\n",
                        dns_result_totext(dns_result));
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -601,6 +701,8 @@ t_dns_db_class(char **av) {
                t_info("dns_db_load failed %s\n",
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -618,6 +720,8 @@ t_dns_db_class(char **av) {
        }
 
        dns_db_detach(&db);
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
        return(result);
 
@@ -652,6 +756,7 @@ t_dns_db_currentversion(char **av) {
        isc_result_t            dns_result;
        isc_result_t            isc_result;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        dns_dbnode_t            *nodep;
        isc_textregion_t        textregion;
        isc_buffer_t            findname_buffer;
@@ -673,6 +778,7 @@ t_dns_db_currentversion(char **av) {
        findtype = T_ARG(6);
        db = NULL;
        mctx = NULL;
+       ectx = NULL;
 
        t_info("testing using file %s and name %s\n", filename, findname);
 
@@ -683,8 +789,27 @@ t_dns_db_currentversion(char **av) {
                return(T_UNRESOLVED);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        dns_result = t_create(db_type, origin, class, model, mctx, &db);
        if (dns_result != ISC_R_SUCCESS) {
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -694,6 +819,8 @@ t_dns_db_currentversion(char **av) {
                t_info("dns_db_load returned %s\n",
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -708,6 +835,8 @@ t_dns_db_currentversion(char **av) {
                t_info("dns_name_fromtext failed %s\n",
                        dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -720,6 +849,8 @@ t_dns_db_currentversion(char **av) {
                                findtype,
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -748,6 +879,8 @@ t_dns_db_currentversion(char **av) {
                t_info("unable to find %s using current version\n", findname);
                dns_db_closeversion(db, &cversionp, ISC_FALSE);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -770,6 +903,8 @@ t_dns_db_currentversion(char **av) {
                dns_rdataset_disassociate(&rdataset);
                dns_db_closeversion(db, &cversionp, ISC_FALSE);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -786,6 +921,8 @@ t_dns_db_currentversion(char **av) {
                dns_db_closeversion(db, &nversionp, ISC_FALSE);
                dns_db_closeversion(db, &cversionp, ISC_FALSE);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -816,6 +953,8 @@ t_dns_db_currentversion(char **av) {
                dns_db_closeversion(db, &cversionp, ISC_FALSE);
                dns_db_closeversion(db, &nversionp, ISC_FALSE);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_FAIL);
        }
@@ -842,6 +981,8 @@ t_dns_db_currentversion(char **av) {
                t_info("cound not find %s using current version\n", findname);
                dns_db_closeversion(db, &cversionp, ISC_FALSE);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                result = T_FAIL;
        }
@@ -851,6 +992,8 @@ t_dns_db_currentversion(char **av) {
 
        dns_db_closeversion(db, &cversionp, ISC_FALSE);
        dns_db_detach(&db);
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
 
        return(result);
@@ -888,6 +1031,7 @@ t_dns_db_newversion(char **av) {
        isc_result_t            dns_result;
        isc_result_t            isc_result;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        dns_dbnode_t            *nodep;
        dns_dbnode_t            *found_nodep;
        isc_textregion_t        textregion;
@@ -915,6 +1059,7 @@ t_dns_db_newversion(char **av) {
        newtype = T_ARG(6);
        db = NULL;
        mctx = NULL;
+       ectx = NULL;
 
        /*
         * Open a new version, add some data, commit it,
@@ -931,8 +1076,27 @@ t_dns_db_newversion(char **av) {
                return(T_UNRESOLVED);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        dns_result = t_create(db_type, origin, class, model, mctx, &db);
        if (dns_result != ISC_R_SUCCESS) {
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -942,6 +1106,8 @@ t_dns_db_newversion(char **av) {
                t_info("dns_db_load returned %s\n",
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -960,6 +1126,8 @@ t_dns_db_newversion(char **av) {
                t_info("dns_name_fromtext failed %s\n",
                        dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -971,6 +1139,8 @@ t_dns_db_newversion(char **av) {
                t_info("dns_db_findnode failed %s\n",
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -989,6 +1159,8 @@ t_dns_db_newversion(char **av) {
                                dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1001,6 +1173,8 @@ t_dns_db_newversion(char **av) {
                                dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1026,6 +1200,8 @@ t_dns_db_newversion(char **av) {
                                dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1037,6 +1213,8 @@ t_dns_db_newversion(char **av) {
                                dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1049,6 +1227,8 @@ t_dns_db_newversion(char **av) {
                dns_db_closeversion(db, &nversionp, ISC_FALSE);
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1088,6 +1268,8 @@ t_dns_db_newversion(char **av) {
                if (dns_rdataset_isassociated(&found_rdataset))
                        dns_rdataset_disassociate(&found_rdataset);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_FAIL);
        }
@@ -1101,6 +1283,8 @@ t_dns_db_newversion(char **av) {
                        dns_rdataset_disassociate(&found_rdataset);
                dns_db_closeversion(db, &nversionp, ISC_FALSE);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_FAIL);
        }
@@ -1126,6 +1310,8 @@ t_dns_db_newversion(char **av) {
                dns_rdataset_disassociate(&found_rdataset);
        dns_db_detachnode(db, &found_nodep);
        dns_db_detach(&db);
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
 
        return(result);
@@ -1166,6 +1352,7 @@ t_dns_db_closeversion_1(char **av) {
        isc_result_t            dns_result;
        isc_result_t            isc_result;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        dns_dbnode_t            *nodep;
        isc_textregion_t        textregion;
        isc_buffer_t            name_buffer;
@@ -1198,6 +1385,7 @@ t_dns_db_closeversion_1(char **av) {
        result = T_UNRESOLVED;
        db = NULL;
        mctx = NULL;
+       ectx = NULL;
 
        /*
         * Open a new version, add some data,
@@ -1214,8 +1402,27 @@ t_dns_db_closeversion_1(char **av) {
                return(T_UNRESOLVED);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        dns_result = t_create(db_type, origin, class, model, mctx, &db);
        if (dns_result != ISC_R_SUCCESS) {
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1225,6 +1432,8 @@ t_dns_db_closeversion_1(char **av) {
                t_info("dns_db_load returned %s\n",
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1243,6 +1452,8 @@ t_dns_db_closeversion_1(char **av) {
                t_info("dns_name_fromtext failed %s\n",
                        dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1256,6 +1467,8 @@ t_dns_db_closeversion_1(char **av) {
                                dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1267,6 +1480,8 @@ t_dns_db_closeversion_1(char **av) {
                t_info("dns_db_findnode %s\n",
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1279,6 +1494,8 @@ t_dns_db_closeversion_1(char **av) {
                                dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1291,6 +1508,8 @@ t_dns_db_closeversion_1(char **av) {
                dns_db_closeversion(db, &nversionp, ISC_FALSE);
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1313,6 +1532,8 @@ t_dns_db_closeversion_1(char **av) {
                        dns_result_totext(dns_result));
                dns_db_closeversion(db, &nversionp, ISC_FALSE);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1324,6 +1545,8 @@ t_dns_db_closeversion_1(char **av) {
                                dns_result_totext(dns_result));
                dns_db_closeversion(db, &nversionp, ISC_FALSE);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1341,6 +1564,8 @@ t_dns_db_closeversion_1(char **av) {
                                dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1353,6 +1578,8 @@ t_dns_db_closeversion_1(char **av) {
                                dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1378,6 +1605,8 @@ t_dns_db_closeversion_1(char **av) {
                                dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1390,6 +1619,8 @@ t_dns_db_closeversion_1(char **av) {
                dns_db_closeversion(db, &nversionp, ISC_FALSE);
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1425,6 +1656,8 @@ t_dns_db_closeversion_1(char **av) {
                if (dns_rdataset_isassociated(&found_rdataset))
                        dns_rdataset_disassociate(&found_rdataset);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_FAIL);
        }
@@ -1438,6 +1671,8 @@ t_dns_db_closeversion_1(char **av) {
                        dns_rdataset_disassociate(&found_rdataset);
                dns_db_closeversion(db, &cversionp, ISC_FALSE);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_FAIL);
        }
@@ -1481,6 +1716,8 @@ t_dns_db_closeversion_1(char **av) {
 
        dns_db_closeversion(db, &cversionp, ISC_FALSE);
        dns_db_detach(&db);
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
 
        if (nfails == 0)
@@ -1527,6 +1764,7 @@ t_dns_db_closeversion_2(char **av) {
        isc_result_t            dns_result;
        isc_result_t            isc_result;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        dns_dbnode_t            *nodep;
        isc_textregion_t        textregion;
        isc_buffer_t            name_buffer;
@@ -1559,6 +1797,7 @@ t_dns_db_closeversion_2(char **av) {
        result = T_UNRESOLVED;
        db = NULL;
        mctx = NULL;
+       ectx = NULL;
 
        /*
         * Open a new version, add some data,
@@ -1575,8 +1814,27 @@ t_dns_db_closeversion_2(char **av) {
                return(T_UNRESOLVED);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        dns_result = t_create(db_type, origin, class, model, mctx, &db);
        if (dns_result != ISC_R_SUCCESS) {
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1586,6 +1844,8 @@ t_dns_db_closeversion_2(char **av) {
                t_info("dns_db_load returned %s\n",
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1604,6 +1864,8 @@ t_dns_db_closeversion_2(char **av) {
                t_info("dns_name_fromtext failed %s\n",
                        dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1617,6 +1879,8 @@ t_dns_db_closeversion_2(char **av) {
                                dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1628,6 +1892,8 @@ t_dns_db_closeversion_2(char **av) {
                t_info("dns_db_findnode %s\n",
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1642,6 +1908,8 @@ t_dns_db_closeversion_2(char **av) {
                                dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1654,6 +1922,8 @@ t_dns_db_closeversion_2(char **av) {
                dns_db_closeversion(db, &nversionp, ISC_FALSE);
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1676,6 +1946,8 @@ t_dns_db_closeversion_2(char **av) {
                       dns_result_totext(dns_result));
                dns_db_closeversion(db, &nversionp, ISC_FALSE);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1687,6 +1959,8 @@ t_dns_db_closeversion_2(char **av) {
                       dns_result_totext(dns_result));
                dns_db_closeversion(db, &nversionp, ISC_FALSE);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1699,6 +1973,8 @@ t_dns_db_closeversion_2(char **av) {
                       new_type, dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1711,6 +1987,8 @@ t_dns_db_closeversion_2(char **av) {
                       dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1736,6 +2014,8 @@ t_dns_db_closeversion_2(char **av) {
                       dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1748,6 +2028,8 @@ t_dns_db_closeversion_2(char **av) {
                dns_db_closeversion(db, &nversionp, ISC_FALSE);
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -1779,6 +2061,8 @@ t_dns_db_closeversion_2(char **av) {
                if (dns_rdataset_isassociated(&found_rdataset))
                        dns_rdataset_disassociate(&found_rdataset);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_FAIL);
        }
@@ -1792,6 +2076,8 @@ t_dns_db_closeversion_2(char **av) {
                        dns_rdataset_disassociate(&found_rdataset);
                dns_db_closeversion(db, &nversionp, ISC_FALSE);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_FAIL);
        }
@@ -1871,6 +2157,8 @@ t_dns_db_closeversion_2(char **av) {
                dns_db_detachnode(db, &nodep);
                dns_db_closeversion(db, &cversionp, ISC_FALSE);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_FAIL);
        }
@@ -1903,6 +2191,8 @@ t_dns_db_closeversion_2(char **av) {
        dns_rdataset_disassociate(&found_rdataset);
        dns_db_closeversion(db, &cversionp, ISC_FALSE);
        dns_db_detach(&db);
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
 
        if (nfails == 0)
@@ -1946,6 +2236,7 @@ t_dns_db_expirenode(char **av) {
        isc_result_t            exp_result;
        isc_result_t            isc_result;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        dns_dbnode_t            *nodep;
        isc_buffer_t            name_buffer;
        dns_fixedname_t         dns_foundname;
@@ -1963,6 +2254,8 @@ t_dns_db_expirenode(char **av) {
        node_xtime = T_ARG(5);
        find_xtime = T_ARG(6);
        exp_find_result = T_ARG(7);
+       mctx = NULL;
+       ectx = NULL;
 
        result = T_UNRESOLVED;
 
@@ -1991,7 +2284,6 @@ t_dns_db_expirenode(char **av) {
                return(T_UNRESOLVED);
        }
 
-       mctx = NULL;
        isc_result = isc_mem_create(0, 0, &mctx);
        if (isc_result != ISC_R_SUCCESS) {
                t_info("isc_mem_create failed %s\n",
@@ -1999,9 +2291,28 @@ t_dns_db_expirenode(char **av) {
                return(T_UNRESOLVED);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        db = NULL;
        dns_result = t_create(db_type, origin, class, "cache", mctx, &db);
        if (dns_result != ISC_R_SUCCESS) {
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -2011,6 +2322,8 @@ t_dns_db_expirenode(char **av) {
                t_info("dns_db_load returned %s\n",
                       dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -2025,6 +2338,8 @@ t_dns_db_expirenode(char **av) {
        if (dns_result != ISC_R_SUCCESS) {
                t_info("unable to find %s\n", existing_name);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -2041,6 +2356,8 @@ t_dns_db_expirenode(char **av) {
                       dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_FAIL);
        }
@@ -2084,6 +2401,8 @@ t_dns_db_expirenode(char **av) {
 
 
        dns_db_detach(&db);
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
 
        return(result);
@@ -2121,6 +2440,7 @@ t_dns_db_findnode_1(char **av) {
        isc_result_t            dns_result;
        isc_result_t            isc_result;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        dns_dbnode_t            *nodep;
        isc_buffer_t            name_buffer;
        dns_rdataset_t          rdataset;
@@ -2141,6 +2461,7 @@ t_dns_db_findnode_1(char **av) {
 
        db = NULL;
        mctx = NULL;
+       ectx = NULL;
        result = T_UNRESOLVED;
 
        t_info("testing using file %s and name %s\n", filename, find_name);
@@ -2164,6 +2485,22 @@ t_dns_db_findnode_1(char **av) {
                return(T_UNRESOLVED);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        dns_result = t_create(db_type, origin, class, model, mctx, &db);
        if (dns_result != ISC_R_SUCCESS) {
                isc_mem_destroy(&mctx);
@@ -2230,6 +2567,8 @@ t_dns_db_findnode_1(char **av) {
        }
 
        dns_db_detach(&db);
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
 
        return(result);
@@ -2266,6 +2605,7 @@ t_dns_db_findnode_2(char **av) {
        isc_result_t            dns_result;
        isc_result_t            isc_result;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        dns_dbnode_t            *nodep;
        dns_dbnode_t            *newnodep;
        isc_buffer_t            name_buffer;
@@ -2284,6 +2624,7 @@ t_dns_db_findnode_2(char **av) {
        result = T_UNRESOLVED;
        db = NULL;
        mctx = NULL;
+       ectx = NULL;
        nfails = 0;
 
        t_info("testing using file %s and name %s\n", filename, newname);
@@ -2295,8 +2636,24 @@ t_dns_db_findnode_2(char **av) {
                return(T_UNRESOLVED);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create failed %s\n",
+                               isc_result_totext(isc_result));
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create failed %s\n",
+                               isc_result_totext(isc_result));
+               return(T_UNRESOLVED);
+       }
+
        dns_result = t_create(db_type, origin, class, model, mctx, &db);
        if (dns_result != ISC_R_SUCCESS) {
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -2306,6 +2663,8 @@ t_dns_db_findnode_2(char **av) {
                t_info("dns_db_load returned %s\n",
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -2331,6 +2690,8 @@ t_dns_db_findnode_2(char **av) {
                       dns_result_totext(dns_result));
                dns_db_detachnode(db, &nodep);
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -2344,6 +2705,8 @@ t_dns_db_findnode_2(char **av) {
                t_info("dns_db_findnode %s\n",
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_FAIL);
        }
@@ -2397,6 +2760,8 @@ t_dns_db_findnode_2(char **av) {
        dns_db_detachnode(db, &nodep);
        dns_db_closeversion(db, &cversionp, ISC_FALSE);
        dns_db_detach(&db);
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
 
        if (nfails == 0)
@@ -2439,6 +2804,7 @@ t_dns_db_find_x(char **av) {
        isc_stdtime_t           now;
        isc_result_t            exp_result;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        dns_dbnode_t            *nodep;
        isc_textregion_t        textregion;
        isc_buffer_t            findname_buffer;
@@ -2462,6 +2828,7 @@ t_dns_db_find_x(char **av) {
        expected_result = T_ARG(9);
        db = NULL;
        mctx = NULL;
+       ectx = NULL;
        opts = 0;
 
        t_info("testing using %s, name %s, type %s\n", dbfile, findname,
@@ -2474,8 +2841,27 @@ t_dns_db_find_x(char **av) {
                return(T_UNRESOLVED);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create failed %s\n",
+                               isc_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        dns_result = t_create(dbtype, dborigin, dbclass, dbmodel, mctx, &db);
        if (dns_result != ISC_R_SUCCESS) {
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -2485,6 +2871,8 @@ t_dns_db_find_x(char **av) {
                t_info("dns_db_load returned %s\n",
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -2501,6 +2889,8 @@ t_dns_db_find_x(char **av) {
                t_info("dns_name_fromtext failed %s\n",
                        dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -2513,6 +2903,8 @@ t_dns_db_find_x(char **av) {
                                findtype,
                                dns_result_totext(dns_result));
                dns_db_detach(&db);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(T_UNRESOLVED);
        }
@@ -2567,6 +2959,8 @@ t_dns_db_find_x(char **av) {
        if (dns_db_iszone(db))
                dns_db_closeversion(db, &cversionp, ISC_FALSE);
        dns_db_detach(&db);
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
 
        return(result);

diff --git a/bin/tests/rbt/t_rbt.c b/bin/tests/rbt/t_rbt.c
index 5f33725ebb02ae238635c5d70e05df3d4a1bb813..ea5e78f14d422301d06ef291c0dd82fb88ee90bd 100644 (file)
--- a/bin/tests/rbt/t_rbt.c
+++ b/bin/tests/rbt/t_rbt.c
@@ -15,14 +15,17 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
-/* $Id: t_rbt.c,v 1.25 2004/03/05 04:59:03 marka Exp $ */
+/* $Id: t_rbt.c,v 1.26 2004/10/25 01:27:54 marka Exp $ */
 
 #include <config.h>
 
 #include <ctype.h>
 #include <stdlib.h>
 
+#include <isc/entropy.h>
 #include <isc/mem.h>
+#include <isc/util.h>
+#include <isc/hash.h>
 #include <isc/string.h>
 
 #include <dns/fixedname.h>
@@ -308,6 +311,7 @@ test_rbt_gen(char *filename, char *command, char *testname,
        isc_result_t    isc_result;
        isc_result_t    dns_result;
        isc_mem_t       *mctx;
+       isc_entropy_t   *ectx;
        dns_name_t      *dns_name;
 
        result = T_UNRESOLVED;
@@ -316,6 +320,8 @@ test_rbt_gen(char *filename, char *command, char *testname,
                t_info("testing using name %s\n", testname);
 
        mctx = NULL;
+       ectx = NULL;
+
        isc_result = isc_mem_create(0, 0, &mctx);
        if (isc_result != ISC_R_SUCCESS) {
                t_info("isc_mem_create: %s: exiting\n",
@@ -323,10 +329,29 @@ test_rbt_gen(char *filename, char *command, char *testname,
                return(T_UNRESOLVED);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create: %s: exiting\n",
+                      dns_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create: %s: exiting\n",
+                      dns_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        rbt = NULL;
        if (rbt_init(filename, &rbt, mctx) != 0) {
                if (strcmp(command, "create") == 0)
                        result = T_FAIL;
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(result);
        }
@@ -412,6 +437,8 @@ test_rbt_gen(char *filename, char *command, char *testname,
        }
 
        dns_rbt_destroy(&rbt);
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
        return(result);
 }
@@ -733,6 +760,7 @@ t_dns_rbtnodechain_init(char *dbfile, char *findname,
        dns_rbtnode_t           *node;
        dns_rbtnodechain_t      chain;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        isc_result_t            isc_result;
        isc_result_t            dns_result;
        dns_fixedname_t         dns_findname;
@@ -748,6 +776,8 @@ t_dns_rbtnodechain_init(char *dbfile, char *findname,
 
        nfails = 0;
        mctx = NULL;
+       ectx = NULL;
+
        isc_result = isc_mem_create(0, 0, &mctx);
        if (isc_result != ISC_R_SUCCESS) {
                t_info("isc_mem_create failed %s\n",
@@ -755,11 +785,30 @@ t_dns_rbtnodechain_init(char *dbfile, char *findname,
                return(result);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create: %s: exiting\n",
+                      dns_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create: %s: exiting\n",
+                      dns_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        dns_rbtnodechain_init(&chain, mctx);
 
        rbt = NULL;
        if (rbt_init(dbfile, &rbt, mctx)) {
                t_info("rbt_init %s failed\n", dbfile);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(result);
        }
@@ -897,6 +946,8 @@ t_dns_rbtnodechain_init(char *dbfile, char *findname,
        dns_rbtnodechain_invalidate(&chain);
        dns_rbt_destroy(&rbt);
 
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
 
        return(result);
@@ -991,6 +1042,7 @@ t_dns_rbtnodechain_first(char *dbfile, char *expected_firstname,
        dns_rbt_t               *rbt;
        dns_rbtnodechain_t      chain;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        isc_result_t            isc_result;
        isc_result_t            dns_result;
        dns_fixedname_t         dns_name;
@@ -1001,6 +1053,7 @@ t_dns_rbtnodechain_first(char *dbfile, char *expected_firstname,
 
        nfails = 0;
        mctx = NULL;
+       ectx = NULL;
 
        dns_fixedname_init(&dns_name);
        dns_fixedname_init(&dns_origin);
@@ -1012,11 +1065,30 @@ t_dns_rbtnodechain_first(char *dbfile, char *expected_firstname,
                return(result);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create: %s: exiting\n",
+                      dns_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create: %s: exiting\n",
+                      dns_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        dns_rbtnodechain_init(&chain, mctx);
 
        rbt = NULL;
        if (rbt_init(dbfile, &rbt, mctx)) {
                t_info("rbt_init %s failed\n", dbfile);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(result);
        }
@@ -1062,6 +1134,8 @@ t_dns_rbtnodechain_first(char *dbfile, char *expected_firstname,
        dns_rbtnodechain_invalidate(&chain);
 
        dns_rbt_destroy(&rbt);
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
        return(result);
 }
@@ -1157,6 +1231,7 @@ t_dns_rbtnodechain_last(char *dbfile, char *expected_lastname,
        dns_rbt_t               *rbt;
        dns_rbtnodechain_t      chain;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        isc_result_t            isc_result;
        isc_result_t            dns_result;
        dns_fixedname_t         dns_name;
@@ -1167,6 +1242,7 @@ t_dns_rbtnodechain_last(char *dbfile, char *expected_lastname,
 
        nfails = 0;
        mctx = NULL;
+       ectx = NULL;
 
        dns_fixedname_init(&dns_name);
        dns_fixedname_init(&dns_origin);
@@ -1178,11 +1254,30 @@ t_dns_rbtnodechain_last(char *dbfile, char *expected_lastname,
                return(result);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create: %s: exiting\n",
+                      dns_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create: %s: exiting\n",
+                      dns_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        dns_rbtnodechain_init(&chain, mctx);
 
        rbt = NULL;
        if (rbt_init(dbfile, &rbt, mctx)) {
                t_info("rbt_init %s failed\n", dbfile);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(result);
        }
@@ -1229,6 +1324,8 @@ t_dns_rbtnodechain_last(char *dbfile, char *expected_lastname,
        dns_rbtnodechain_invalidate(&chain);
        dns_rbt_destroy(&rbt);
 
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
 
        return(result);
@@ -1325,6 +1422,7 @@ t_dns_rbtnodechain_next(char *dbfile, char *findname,
        dns_rbtnode_t           *node;
        dns_rbtnodechain_t      chain;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx;
        isc_result_t            isc_result;
        isc_result_t            dns_result;
        dns_fixedname_t         dns_findname;
@@ -1337,6 +1435,8 @@ t_dns_rbtnodechain_next(char *dbfile, char *findname,
 
        nfails = 0;
        mctx = NULL;
+       ectx = NULL;
+
        isc_result = isc_mem_create(0, 0, &mctx);
        if (isc_result != ISC_R_SUCCESS) {
                t_info("isc_mem_create failed %s\n",
@@ -1344,11 +1444,30 @@ t_dns_rbtnodechain_next(char *dbfile, char *findname,
                return(result);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create: %s: exiting\n",
+                      dns_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create: %s: exiting\n",
+                      dns_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        dns_rbtnodechain_init(&chain, mctx);
 
        rbt = NULL;
        if (rbt_init(dbfile, &rbt, mctx)) {
                t_info("rbt_init %s failed\n", dbfile);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(result);
        }
@@ -1411,6 +1530,8 @@ t_dns_rbtnodechain_next(char *dbfile, char *findname,
        dns_rbtnodechain_invalidate(&chain);
        dns_rbt_destroy(&rbt);
 
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
 
        return(result);
@@ -1506,6 +1627,7 @@ t_dns_rbtnodechain_prev(char *dbfile, char *findname, char *prevname,
        dns_rbtnode_t           *node;
        dns_rbtnodechain_t      chain;
        isc_mem_t               *mctx;
+       isc_entropy_t           *ectx = NULL;
        isc_result_t            isc_result;
        isc_result_t            dns_result;
        dns_fixedname_t         dns_findname;
@@ -1518,6 +1640,8 @@ t_dns_rbtnodechain_prev(char *dbfile, char *findname, char *prevname,
 
        nfails = 0;
        mctx = NULL;
+       ectx = NULL;
+
        isc_result = isc_mem_create(0, 0, &mctx);
        if (isc_result != ISC_R_SUCCESS) {
                t_info("isc_mem_create failed %s\n",
@@ -1525,11 +1649,30 @@ t_dns_rbtnodechain_prev(char *dbfile, char *findname, char *prevname,
                return(result);
        }
 
+       isc_result = isc_entropy_create(mctx, &ectx);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_entropy_create: %s: exiting\n",
+                      dns_result_totext(isc_result));
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
+       isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
+       if (isc_result != ISC_R_SUCCESS) {
+               t_info("isc_hash_create: %s: exiting\n",
+                      dns_result_totext(isc_result));
+               isc_entropy_detach(&ectx);
+               isc_mem_destroy(&mctx);
+               return(T_UNRESOLVED);
+       }
+
        dns_rbtnodechain_init(&chain, mctx);
 
        rbt = NULL;
        if (rbt_init(dbfile, &rbt, mctx)) {
                t_info("rbt_init %s failed\n", dbfile);
+               isc_hash_destroy();
+               isc_entropy_detach(&ectx);
                isc_mem_destroy(&mctx);
                return(result);
        }
@@ -1592,6 +1735,8 @@ t_dns_rbtnodechain_prev(char *dbfile, char *findname, char *prevname,
        dns_rbtnodechain_invalidate(&chain);
        dns_rbt_destroy(&rbt);
 
+       isc_hash_destroy();
+       isc_entropy_detach(&ectx);
        isc_mem_destroy(&mctx);
 
        return(result);

diff --git a/lib/dns/rbt.c b/lib/dns/rbt.c
index fa6684d440442e68dd72cb2b73716db925ddf011..86f4d303e385cb87391497496b6fa78e56cca4db 100644 (file)
--- a/lib/dns/rbt.c
+++ b/lib/dns/rbt.c
@@ -15,7 +15,7 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
-/* $Id: rbt.c,v 1.129 2004/10/11 05:49:28 marka Exp $ */
+/* $Id: rbt.c,v 1.130 2004/10/25 01:27:54 marka Exp $ */
 
 /* Principal Authors: DCL */
 
@@ -64,7 +64,6 @@ struct dns_rbt {
        unsigned int            nodecount;
        unsigned int            hashsize;
        dns_rbtnode_t **        hashtable;
-       unsigned int            quantum;
 };
 
 #define RED 0
@@ -180,25 +179,6 @@ find_up(dns_rbtnode_t *node) {
        return (PARENT(root));
 }
 
-#ifdef DNS_RBT_USEHASH
-static inline void
-compute_node_hash(dns_rbtnode_t *node) {
-       unsigned int hash;
-       dns_name_t name;
-       dns_rbtnode_t *up_node;
-
-       dns_name_init(&name, NULL);
-       NODENAME(node, &name);
-       hash = dns_name_hashbylabel(&name, ISC_FALSE);
-
-       up_node = find_up(node);
-       if (up_node != NULL)
-               hash += HASHVAL(up_node);
-
-       HASHVAL(node) = hash;
-}
-#endif
-
 /*
  * Forward declarations.
  */
@@ -207,11 +187,11 @@ create_node(isc_mem_t *mctx, dns_name_t *name, dns_rbtnode_t **nodep);
 
 #ifdef DNS_RBT_USEHASH
 static inline void
-hash_node(dns_rbt_t *rbt, dns_rbtnode_t *node);
+hash_node(dns_rbt_t *rbt, dns_rbtnode_t *node, dns_name_t *name);
 static inline void
 unhash_node(dns_rbt_t *rbt, dns_rbtnode_t *node);
 #else
-#define hash_node(rbt, node) (ISC_R_SUCCESS)
+#define hash_node(rbt, node, name) (ISC_R_SUCCESS)
 #define unhash_node(rbt, node)
 #endif
 
@@ -231,7 +211,8 @@ static isc_result_t
 dns_rbt_deletetree(dns_rbt_t *rbt, dns_rbtnode_t *node);
 
 static void
-dns_rbt_deletetreeflat(dns_rbt_t *rbt, dns_rbtnode_t **nodep);
+dns_rbt_deletetreeflat(dns_rbt_t *rbt, unsigned int quantum,
+                      dns_rbtnode_t **nodep);
 
 /*
  * Initialize a red/black tree of trees.
@@ -268,7 +249,6 @@ dns_rbt_create(isc_mem_t *mctx, void (*deleter)(void *, void *),
                return (result);
        }
 #endif
-       rbt->quantum = 0;
        rbt->magic = RBT_MAGIC;
 
        *rbtp = rbt;
@@ -292,9 +272,7 @@ dns_rbt_destroy2(dns_rbt_t **rbtp, unsigned int quantum) {
 
        rbt = *rbtp;
 
-       rbt->quantum = quantum;
-
-       dns_rbt_deletetreeflat(rbt, &rbt->root);
+       dns_rbt_deletetreeflat(rbt, quantum, &rbt->root);
        if (rbt->root != NULL)
                return (ISC_R_QUOTA);
 
@@ -377,13 +355,14 @@ dns_rbt_addnode(dns_rbt_t *rbt, dns_name_t *name, dns_rbtnode_t **nodep) {
         * Does this thing have too many variables or what?
         */
        dns_rbtnode_t **root, *parent, *child, *current, *new_current;
-       dns_name_t *add_name, current_name, *prefix, *suffix;
-       dns_fixedname_t fixedcopy, fixedprefix, fixedsuffix;
+       dns_name_t *add_name, *new_name, current_name, *prefix, *suffix;
+       dns_fixedname_t fixedcopy, fixedprefix, fixedsuffix, fnewname;
        dns_offsets_t current_offsets;
        dns_namereln_t compared;
        isc_result_t result = ISC_R_SUCCESS;
        dns_rbtnodechain_t chain;
        unsigned int common_labels;
+       unsigned int nlabels, hlabels;
        int order;
 
        REQUIRE(VALID_RBT(rbt));
@@ -405,7 +384,7 @@ dns_rbt_addnode(dns_rbt_t *rbt, dns_name_t *name, dns_rbtnode_t **nodep) {
                        new_current->is_root = 1;
                        rbt->root = new_current;
                        *nodep = new_current;
-                       hash_node(rbt, new_current);
+                       hash_node(rbt, new_current, name);
                }
                return (result);
        }
@@ -423,6 +402,10 @@ dns_rbt_addnode(dns_rbt_t *rbt, dns_name_t *name, dns_rbtnode_t **nodep) {
        current = NULL;
        child = *root;
        dns_name_init(&current_name, current_offsets);
+       dns_fixedname_init(&fnewname);
+       new_name = dns_fixedname_name(&fnewname);
+       nlabels = dns_name_countlabels(name);
+       hlabels = 0;
 
        do {
                current = child;
@@ -462,6 +445,7 @@ dns_rbt_addnode(dns_rbt_t *rbt, dns_name_t *name, dns_rbtnode_t **nodep) {
                         * the non-common parts of these two names should
                         * start a new tree.
                         */
+                       hlabels += common_labels;
                        if (compared == dns_namereln_subdomain) {
                                /*
                                 * All of the existing labels are in common,
@@ -588,7 +572,10 @@ dns_rbt_addnode(dns_rbt_t *rbt, dns_name_t *name, dns_rbtnode_t **nodep) {
                                ATTRS(current) &= ~DNS_NAMEATTR_ABSOLUTE;
 
                                rbt->nodecount++;
-                               hash_node(rbt, new_current);
+                               dns_name_getlabelsequence(name,
+                                                         nlabels - hlabels,
+                                                         hlabels, new_name);
+                               hash_node(rbt, new_current, new_name);
 
                                if (common_labels ==
                                    dns_name_countlabels(add_name)) {
@@ -635,7 +622,7 @@ dns_rbt_addnode(dns_rbt_t *rbt, dns_name_t *name, dns_rbtnode_t **nodep) {
                dns_rbt_addonlevel(new_current, current, order, root);
                rbt->nodecount++;
                *nodep = new_current;
-               hash_node(rbt, new_current);
+               hash_node(rbt, new_current, name);
        }
 
        return (result);
@@ -687,6 +674,7 @@ dns_rbt_findnode(dns_rbt_t *rbt, dns_name_t *name, dns_name_t *foundname,
        dns_namereln_t compared;
        isc_result_t result, saved_result;
        unsigned int common_labels;
+       unsigned int hlabels = 0;
        int order;
 
        REQUIRE(VALID_RBT(rbt));
@@ -782,11 +770,17 @@ dns_rbt_findnode(dns_rbt_t *rbt, dns_name_t *name, dns_name_t *foundname,
                        dns_name_init(&hash_name, NULL);
 
                hashagain:
+                       /* 
+                        * Hash includes tail.
+                        */
+                       dns_name_getlabelsequence(name,
+                                                 nlabels - tlabels,
+                                                 hlabels + tlabels,
+                                                 &hash_name);
+                       hash = dns_name_fullhash(&hash_name, ISC_FALSE);
                        dns_name_getlabelsequence(search_name,
                                                  nlabels - tlabels,
                                                  tlabels, &hash_name);
-                       hash = HASHVAL(up_current) +
-                              dns_name_hashbylabel(&hash_name, ISC_FALSE);
 
                        for (hnode = rbt->hashtable[hash % rbt->hashsize];
                             hnode != NULL;
@@ -863,6 +857,7 @@ dns_rbt_findnode(dns_rbt_t *rbt, dns_name_t *name, dns_name_t *foundname,
                                 */
                                dns_name_split(search_name, common_labels,
                                               search_name, NULL);
+                               hlabels += common_labels;
                                /*
                                 * This might be the closest enclosing name.
                                 */
@@ -1475,10 +1470,10 @@ create_node(isc_mem_t *mctx, dns_name_t *name, dns_rbtnode_t **nodep) {
 
 #ifdef DNS_RBT_USEHASH
 static inline void
-hash_add_node(dns_rbt_t *rbt, dns_rbtnode_t *node) {
+hash_add_node(dns_rbt_t *rbt, dns_rbtnode_t *node, dns_name_t *name) {
        unsigned int hash;
 
-       compute_node_hash(node);
+       HASHVAL(node) = dns_name_fullhash(name, ISC_FALSE);
 
        hash = HASHVAL(node) % rbt->hashsize;
        HASHNEXT(node) = rbt->hashtable[hash];
@@ -1539,14 +1534,14 @@ rehash(dns_rbt_t *rbt) {
 }
 
 static inline void
-hash_node(dns_rbt_t *rbt, dns_rbtnode_t *node) {
+hash_node(dns_rbt_t *rbt, dns_rbtnode_t *node, dns_name_t *name) {
 
        REQUIRE(DNS_RBTNODE_VALID(node));
 
        if (rbt->nodecount >= (rbt->hashsize *3))
                rehash(rbt);
 
-       hash_add_node(rbt, node);
+       hash_add_node(rbt, node, name);
 }
 
 static inline void
@@ -2035,7 +2030,9 @@ dns_rbt_deletetree(dns_rbt_t *rbt, dns_rbtnode_t *node) {
 }
 
 static void
-dns_rbt_deletetreeflat(dns_rbt_t *rbt, dns_rbtnode_t **nodep) {
+dns_rbt_deletetreeflat(dns_rbt_t *rbt, unsigned int quantum,
+                      dns_rbtnode_t **nodep)
+{
        dns_rbtnode_t *parent;
        dns_rbtnode_t *node = *nodep;
        REQUIRE(VALID_RBT(rbt));
@@ -2079,7 +2076,7 @@ dns_rbt_deletetreeflat(dns_rbt_t *rbt, dns_rbtnode_t **nodep) {
        isc_mem_put(rbt->mctx, node, NODE_SIZE(node));
        rbt->nodecount--;
        node = parent;
-       if (rbt->quantum != 0 && --rbt->quantum == 0) {
+       if (quantum != 0 && --quantum == 0) {
                *nodep = node;
                return;
        }