s3-registry: use push_reg_sz().
[kai/samba.git] / source3 / registry / reg_backend_db.c
index b729e58dafa73349fe8a3a38991e34efb9b44024..b9ff5dc7fc63b8374ebad7591117de34880edd8e 100644 (file)
@@ -2,6 +2,7 @@
  *  Unix SMB/CIFS implementation.
  *  Virtual Windows Registry Layer
  *  Copyright (C) Gerald Carter                     2002-2005
+ *  Copyright (C) Michael Adam                      2007-2009
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
 static struct db_context *regdb = NULL;
 static int regdb_refcount;
 
-static bool regdb_key_exists(const char *key);
+static bool regdb_key_exists(struct db_context *db, const char *key);
 static bool regdb_key_is_base_key(const char *key);
+static WERROR regdb_fetch_keys_internal(struct db_context *db, const char *key,
+                                       struct regsubkey_ctr *ctr);
+static bool regdb_store_keys_internal(struct db_context *db, const char *key,
+                                     struct regsubkey_ctr *ctr);
+static int regdb_fetch_values_internal(struct db_context *db, const char* key,
+                                      struct regval_ctr *values);
+static bool regdb_store_values_internal(struct db_context *db, const char *key,
+                                       struct regval_ctr *values);
 
 /* List the deepest path into the registry.  All part components will be created.*/
 
@@ -94,7 +103,8 @@ static struct builtin_regkey_value builtin_registry_values[] = {
  * Initialize a key in the registry:
  * create each component key of the specified path.
  */
-static WERROR init_registry_key_internal(const char *add_path)
+static WERROR init_registry_key_internal(struct db_context *db,
+                                        const char *add_path)
 {
        WERROR werr;
        TALLOC_CTX *frame = talloc_stackframe();
@@ -103,7 +113,7 @@ static WERROR init_registry_key_internal(const char *add_path)
        char *remaining = NULL;
        char *keyname;
        char *subkeyname;
-       REGSUBKEY_CTR *subkeys;
+       struct regsubkey_ctr *subkeys;
        const char *p, *p2;
 
        DEBUG(6, ("init_registry_key: Adding [%s]\n", add_path));
@@ -167,20 +177,26 @@ static WERROR init_registry_key_internal(const char *add_path)
                 * since we are about to update the record.
                 * We just want any subkeys already present */
 
-               if (!(subkeys = TALLOC_ZERO_P(frame, REGSUBKEY_CTR))) {
+               werr = regsubkey_ctr_init(frame, &subkeys);
+               if (!W_ERROR_IS_OK(werr)) {
                        DEBUG(0,("talloc() failure!\n"));
-                       werr = WERR_NOMEM;
                        goto fail;
                }
 
-               regdb_fetch_keys(base, subkeys);
+               werr = regdb_fetch_keys_internal(db, base, subkeys);
+               if (!W_ERROR_IS_OK(werr) &&
+                   !W_ERROR_EQUAL(werr, WERR_NOT_FOUND))
+               {
+                       goto fail;
+               }
+
                if (*subkeyname) {
                        werr = regsubkey_ctr_addkey(subkeys, subkeyname);
                        if (!W_ERROR_IS_OK(werr)) {
                                goto fail;
                        }
                }
-               if (!regdb_store_keys( base, subkeys)) {
+               if (!regdb_store_keys_internal(db, base, subkeys)) {
                        werr = WERR_CAN_NOT_COMPLETE;
                        goto fail;
                }
@@ -193,6 +209,20 @@ fail:
        return werr;
 }
 
+struct init_registry_key_context {
+       const char *add_path;
+};
+
+static NTSTATUS init_registry_key_action(struct db_context *db,
+                                        void *private_data)
+{
+       struct init_registry_key_context *init_ctx =
+               (struct init_registry_key_context *)private_data;
+
+       return werror_to_ntstatus(init_registry_key_internal(
+                                       db, init_ctx->add_path));
+}
+
 /**
  * Initialize a key in the registry:
  * create each component key of the specified path,
@@ -200,67 +230,132 @@ fail:
  */
 WERROR init_registry_key(const char *add_path)
 {
-       WERROR werr;
+       struct init_registry_key_context init_ctx;
 
-       if (regdb_key_exists(add_path)) {
+       if (regdb_key_exists(regdb, add_path)) {
                return WERR_OK;
        }
 
-       if (regdb->transaction_start(regdb) != 0) {
-               DEBUG(0, ("init_registry_key: transaction_start failed\n"));
-               return WERR_REG_IO_FAILURE;
-       }
+       init_ctx.add_path = add_path;
 
-       werr = init_registry_key_internal(add_path);
-       if (!W_ERROR_IS_OK(werr)) {
-               goto fail;
+       return ntstatus_to_werror(dbwrap_trans_do(regdb,
+                                                 init_registry_key_action,
+                                                 &init_ctx));
+}
+
+/***********************************************************************
+ Open the registry data in the tdb
+ ***********************************************************************/
+
+static void regdb_ctr_add_value(struct regval_ctr *ctr,
+                               struct builtin_regkey_value *value)
+{
+       DATA_BLOB data;
+
+       switch(value->type) {
+       case REG_DWORD:
+               regval_ctr_addvalue(ctr, value->valuename, REG_DWORD,
+                                   (char*)&value->data.dw_value,
+                                   sizeof(uint32));
+               break;
+
+       case REG_SZ:
+               push_reg_sz(talloc_tos(), &data, value->data.string);
+               regval_ctr_addvalue(ctr, value->valuename, REG_SZ,
+                                   (char*)data.data,
+                                   data.length);
+               break;
+
+       default:
+               DEBUG(0, ("regdb_ctr_add_value: invalid value type in "
+                         "registry values [%d]\n", value->type));
        }
+}
 
-       if (regdb->transaction_commit(regdb) != 0) {
-               DEBUG(0, ("init_registry_key: Could not commit transaction\n"));
-               return WERR_REG_IO_FAILURE;
+static NTSTATUS init_registry_data_action(struct db_context *db,
+                                         void *private_data)
+{
+       NTSTATUS status;
+       TALLOC_CTX *frame = talloc_stackframe();
+       struct regval_ctr *values;
+       int i;
+
+       /* loop over all of the predefined paths and add each component */
+
+       for (i=0; builtin_registry_paths[i] != NULL; i++) {
+               if (regdb_key_exists(db, builtin_registry_paths[i])) {
+                       continue;
+               }
+               status = werror_to_ntstatus(init_registry_key_internal(db,
+                                                 builtin_registry_paths[i]));
+               if (!NT_STATUS_IS_OK(status)) {
+                       goto done;
+               }
        }
 
-       return WERR_OK;
+       /* loop over all of the predefined values and add each component */
 
-fail:
-       if (regdb->transaction_cancel(regdb) != 0) {
-               smb_panic("init_registry_key: transaction_cancel failed\n");
+       for (i=0; builtin_registry_values[i].path != NULL; i++) {
+
+               values = TALLOC_ZERO_P(frame, struct regval_ctr);
+               if (values == NULL) {
+                       status = NT_STATUS_NO_MEMORY;
+                       goto done;
+               }
+
+               regdb_fetch_values_internal(db,
+                                           builtin_registry_values[i].path,
+                                           values);
+
+               /* preserve existing values across restarts. Only add new ones */
+
+               if (!regval_ctr_key_exists(values,
+                                       builtin_registry_values[i].valuename))
+               {
+                       regdb_ctr_add_value(values,
+                                           &builtin_registry_values[i]);
+                       regdb_store_values_internal(db,
+                                       builtin_registry_values[i].path,
+                                       values);
+               }
+               TALLOC_FREE(values);
        }
 
-       return werr;
-}
+       status = NT_STATUS_OK;
 
-/***********************************************************************
- Open the registry data in the tdb
- ***********************************************************************/
+done:
+
+       TALLOC_FREE(frame);
+       return status;
+}
 
 WERROR init_registry_data(void)
 {
        WERROR werr;
        TALLOC_CTX *frame = talloc_stackframe();
-       REGVAL_CTR *values;
+       struct regval_ctr *values;
        int i;
-       UNISTR2 data;
 
        /*
         * First, check for the existence of the needed keys and values.
         * If all do already exist, we can save the writes.
         */
        for (i=0; builtin_registry_paths[i] != NULL; i++) {
-               if (!regdb_key_exists(builtin_registry_paths[i])) {
+               if (!regdb_key_exists(regdb, builtin_registry_paths[i])) {
                        goto do_init;
                }
        }
 
        for (i=0; builtin_registry_values[i].path != NULL; i++) {
-               values = TALLOC_ZERO_P(frame, REGVAL_CTR);
+               values = TALLOC_ZERO_P(frame, struct regval_ctr);
                if (values == NULL) {
                        werr = WERR_NOMEM;
                        goto done;
                }
 
-               regdb_fetch_values(builtin_registry_values[i].path, values);
+               regdb_fetch_values_internal(regdb,
+                                           builtin_registry_values[i].path,
+                                           values);
                if (!regval_ctr_key_exists(values,
                                        builtin_registry_values[i].valuename))
                {
@@ -284,89 +379,9 @@ do_init:
         * transaction behaviour.
         */
 
-       if (regdb->transaction_start(regdb) != 0) {
-               DEBUG(0, ("init_registry_data: tdb_transaction_start "
-                         "failed\n"));
-               werr = WERR_REG_IO_FAILURE;
-               goto done;
-       }
-
-       /* loop over all of the predefined paths and add each component */
-
-       for (i=0; builtin_registry_paths[i] != NULL; i++) {
-               if (regdb_key_exists(builtin_registry_paths[i])) {
-                       continue;
-               }
-               werr = init_registry_key_internal(builtin_registry_paths[i]);
-               if (!W_ERROR_IS_OK(werr)) {
-                       goto fail;
-               }
-       }
-
-       /* loop over all of the predefined values and add each component */
-
-       for (i=0; builtin_registry_values[i].path != NULL; i++) {
-
-               values = TALLOC_ZERO_P(frame, REGVAL_CTR);
-               if (values == NULL) {
-                       werr = WERR_NOMEM;
-                       goto fail;
-               }
-
-               regdb_fetch_values(builtin_registry_values[i].path, values);
-
-               /* preserve existing values across restarts. Only add new ones */
-
-               if (!regval_ctr_key_exists(values,
-                                       builtin_registry_values[i].valuename))
-               {
-                       switch(builtin_registry_values[i].type) {
-                       case REG_DWORD:
-                               regval_ctr_addvalue(values,
-                                       builtin_registry_values[i].valuename,
-                                       REG_DWORD,
-                                       (char*)&builtin_registry_values[i].data.dw_value,
-                                       sizeof(uint32));
-                               break;
-
-                       case REG_SZ:
-                               init_unistr2(&data,
-                                       builtin_registry_values[i].data.string,
-                                       UNI_STR_TERMINATE);
-                               regval_ctr_addvalue(values,
-                                       builtin_registry_values[i].valuename,
-                                       REG_SZ,
-                                       (char*)data.buffer,
-                                       data.uni_str_len*sizeof(uint16));
-                               break;
-
-                       default:
-                               DEBUG(0, ("init_registry_data: invalid value "
-                                         "type in builtin_registry_values "
-                                         "[%d]\n",
-                                         builtin_registry_values[i].type));
-                       }
-                       regdb_store_values(builtin_registry_values[i].path,
-                                          values);
-               }
-               TALLOC_FREE(values);
-       }
-
-       if (regdb->transaction_commit(regdb) != 0) {
-               DEBUG(0, ("init_registry_data: Could not commit "
-                         "transaction\n"));
-               werr = WERR_REG_IO_FAILURE;
-       } else {
-               werr = WERR_OK;
-       }
-
-       goto done;
-
-fail:
-       if (regdb->transaction_cancel(regdb) != 0) {
-               smb_panic("init_registry_data: tdb_transaction_cancel "
-                         "failed\n");
-       }
+       werr = ntstatus_to_werror(dbwrap_trans_do(regdb,
+                                                 init_registry_data_action,
+                                                 NULL));
 
 done:
        TALLOC_FREE(frame);
@@ -390,14 +405,14 @@ WERROR regdb_init(void)
                return WERR_OK;
        }
 
-       regdb = db_open_trans(NULL, state_path("registry.tdb"), 0,
+       regdb = db_open(NULL, state_path("registry.tdb"), 0,
                              REG_TDB_FLAGS, O_RDWR, 0600);
        if (!regdb) {
-               regdb = db_open_trans(NULL, state_path("registry.tdb"), 0,
+               regdb = db_open(NULL, state_path("registry.tdb"), 0,
                                      REG_TDB_FLAGS, O_RDWR|O_CREAT, 0600);
                if (!regdb) {
                        werr = ntstatus_to_werror(map_nt_error_from_unix(errno));
-                       DEBUG(0,("regdb_init: Failed to open registry %s (%s)\n",
+                       DEBUG(1,("regdb_init: Failed to open registry %s (%s)\n",
                                state_path("registry.tdb"), strerror(errno) ));
                        return werr;
                }
@@ -416,7 +431,7 @@ WERROR regdb_init(void)
                           vers_id, REGVER_V1));
                status = dbwrap_trans_store_int32(regdb, vstring, REGVER_V1);
                if (!NT_STATUS_IS_OK(status)) {
-                       DEBUG(0, ("regdb_init: error storing %s = %d: %s\n",
+                       DEBUG(1, ("regdb_init: error storing %s = %d: %s\n",
                                  vstring, REGVER_V1, nt_errstr(status)));
                        return ntstatus_to_werror(status);
                } else {
@@ -444,7 +459,7 @@ WERROR regdb_open( void )
        
        become_root();
 
-       regdb = db_open_trans(NULL, state_path("registry.tdb"), 0,
+       regdb = db_open(NULL, state_path("registry.tdb"), 0,
                              REG_TDB_FLAGS, O_RDWR, 0600);
        if ( !regdb ) {
                result = ntstatus_to_werror( map_nt_error_from_unix( errno ) );
@@ -482,6 +497,24 @@ int regdb_close( void )
        return 0;
 }
 
+WERROR regdb_transaction_start(void)
+{
+       return (regdb->transaction_start(regdb) == 0) ?
+               WERR_OK : WERR_REG_IO_FAILURE;
+}
+
+WERROR regdb_transaction_commit(void)
+{
+       return (regdb->transaction_commit(regdb) == 0) ?
+               WERR_OK : WERR_REG_IO_FAILURE;
+}
+
+WERROR regdb_transaction_cancel(void)
+{
+       return (regdb->transaction_cancel(regdb) == 0) ?
+               WERR_OK : WERR_REG_IO_FAILURE;
+}
+
 /***********************************************************************
  return the tdb sequence number of the registry tdb.
  this is an indicator for the content of the registry
@@ -492,39 +525,133 @@ int regdb_get_seqnum(void)
        return regdb->get_seqnum(regdb);
 }
 
+
+static WERROR regdb_delete_key_with_prefix(struct db_context *db,
+                                          const char *keyname,
+                                          const char *prefix)
+{
+       char *path;
+       WERROR werr = WERR_NOMEM;
+       TALLOC_CTX *mem_ctx = talloc_stackframe();
+
+       if (keyname == NULL) {
+               werr = WERR_INVALID_PARAM;
+               goto done;
+       }
+
+       if (prefix == NULL) {
+               path = discard_const_p(char, keyname);
+       } else {
+               path = talloc_asprintf(mem_ctx, "%s/%s", prefix, keyname);
+               if (path == NULL) {
+                       goto done;
+               }
+       }
+
+       path = normalize_reg_path(mem_ctx, path);
+       if (path == NULL) {
+               goto done;
+       }
+
+       werr = ntstatus_to_werror(dbwrap_delete_bystring(db, path));
+
+       /* treat "not" found" as ok */
+       if (W_ERROR_EQUAL(werr, WERR_NOT_FOUND)) {
+               werr = WERR_OK;
+       }
+
+done:
+       talloc_free(mem_ctx);
+       return werr;
+}
+
+
+static WERROR regdb_delete_values(struct db_context *db, const char *keyname)
+{
+       return regdb_delete_key_with_prefix(db, keyname, REG_VALUE_PREFIX);
+}
+
+static WERROR regdb_delete_secdesc(struct db_context *db, const char *keyname)
+{
+       return regdb_delete_key_with_prefix(db, keyname, REG_SECDESC_PREFIX);
+}
+
+static WERROR regdb_delete_subkeylist(struct db_context *db, const char *keyname)
+{
+       return regdb_delete_key_with_prefix(db, keyname, NULL);
+}
+
+static WERROR regdb_delete_key_lists(struct db_context *db, const char *keyname)
+{
+       WERROR werr;
+
+       werr = regdb_delete_values(db, keyname);
+       if (!W_ERROR_IS_OK(werr)) {
+               DEBUG(1, (__location__ " Deleting %s/%s failed: %s\n",
+                         REG_VALUE_PREFIX, keyname, win_errstr(werr)));
+               goto done;
+       }
+
+       werr = regdb_delete_secdesc(db, keyname);
+       if (!W_ERROR_IS_OK(werr)) {
+               DEBUG(1, (__location__ " Deleting %s/%s failed: %s\n",
+                         REG_SECDESC_PREFIX, keyname, win_errstr(werr)));
+               goto done;
+       }
+
+       werr = regdb_delete_subkeylist(db, keyname);
+       if (!W_ERROR_IS_OK(werr)) {
+               DEBUG(1, (__location__ " Deleting %s failed: %s\n",
+                         keyname, win_errstr(werr)));
+               goto done;
+       }
+
+done:
+       return werr;
+}
+
 /***********************************************************************
  Add subkey strings to the registry tdb under a defined key
  fmt is the same format as tdb_pack except this function only supports
  fstrings
  ***********************************************************************/
 
-static bool regdb_store_keys_internal(const char *key, REGSUBKEY_CTR *ctr)
+static WERROR regdb_store_keys_internal2(struct db_context *db,
+                                        const char *key,
+                                        struct regsubkey_ctr *ctr)
 {
        TDB_DATA dbuf;
        uint8 *buffer = NULL;
        int i = 0;
        uint32 len, buflen;
-       bool ret = true;
        uint32 num_subkeys = regsubkey_ctr_numkeys(ctr);
        char *keyname = NULL;
        TALLOC_CTX *ctx = talloc_stackframe();
-       NTSTATUS status;
+       WERROR werr;
 
        if (!key) {
-               return false;
+               werr = WERR_INVALID_PARAM;
+               goto done;
        }
 
        keyname = talloc_strdup(ctx, key);
        if (!keyname) {
-               return false;
+               werr = WERR_NOMEM;
+               goto done;
        }
+
        keyname = normalize_reg_path(ctx, keyname);
+       if (!keyname) {
+               werr = WERR_NOMEM;
+               goto done;
+       }
 
        /* allocate some initial memory */
 
        buffer = (uint8 *)SMB_MALLOC(1024);
        if (buffer == NULL) {
-               return false;
+               werr = WERR_NOMEM;
+               goto done;
        }
        buflen = 1024;
        len = 0;
@@ -536,37 +663,68 @@ static bool regdb_store_keys_internal(const char *key, REGSUBKEY_CTR *ctr)
        /* pack all the strings */
 
        for (i=0; i<num_subkeys; i++) {
-               len += tdb_pack(buffer+len, buflen-len, "f",
-                               regsubkey_ctr_specific_key(ctr, i));
-               if (len > buflen) {
-                       /* allocate some extra space */
-                       buffer = (uint8 *)SMB_REALLOC(buffer, len*2);
+               size_t thistime;
+
+               thistime = tdb_pack(buffer+len, buflen-len, "f",
+                                   regsubkey_ctr_specific_key(ctr, i));
+               if (len+thistime > buflen) {
+                       size_t thistime2;
+                       /*
+                        * tdb_pack hasn't done anything because of the short
+                        * buffer, allocate extra space.
+                        */
+                       buffer = SMB_REALLOC_ARRAY(buffer, uint8_t,
+                                                  (len+thistime)*2);
                        if(buffer == NULL) {
                                DEBUG(0, ("regdb_store_keys: Failed to realloc "
-                                         "memory of size [%d]\n", len*2));
-                               ret = false;
+                                         "memory of size [%u]\n",
+                                         (unsigned int)(len+thistime)*2));
+                               werr = WERR_NOMEM;
+                               goto done;
+                       }
+                       buflen = (len+thistime)*2;
+                       thistime2 = tdb_pack(
+                               buffer+len, buflen-len, "f",
+                               regsubkey_ctr_specific_key(ctr, i));
+                       if (thistime2 != thistime) {
+                               DEBUG(0, ("tdb_pack failed\n"));
+                               werr = WERR_CAN_NOT_COMPLETE;
                                goto done;
                        }
-                       buflen = len*2;
-                       len = tdb_pack(buffer+len, buflen-len, "f",
-                                      regsubkey_ctr_specific_key(ctr, i));
                }
+               len += thistime;
        }
 
        /* finally write out the data */
 
        dbuf.dptr = buffer;
        dbuf.dsize = len;
-       status = dbwrap_store_bystring(regdb, keyname, dbuf, TDB_REPLACE);
-       if (!NT_STATUS_IS_OK(status)) {
-               ret = false;
+       werr = ntstatus_to_werror(dbwrap_store_bystring(db, keyname, dbuf,
+                                                       TDB_REPLACE));
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+       /*
+        * Delete a sorted subkey cache for regdb_key_exists, will be
+        * recreated automatically
+        */
+       keyname = talloc_asprintf(ctx, "%s/%s", REG_SORTED_SUBKEYS_PREFIX,
+                                 keyname);
+       if (keyname == NULL) {
+               werr = WERR_NOMEM;
                goto done;
        }
 
+       werr = ntstatus_to_werror(dbwrap_delete_bystring(db, keyname));
+
+       /* don't treat WERR_NOT_FOUND as an error here */
+       if (W_ERROR_EQUAL(werr, WERR_NOT_FOUND)) {
+               werr = WERR_OK;
+       }
+
 done:
        TALLOC_FREE(ctx);
        SAFE_FREE(buffer);
-       return ret;
+       return werr;
 }
 
 /***********************************************************************
@@ -574,17 +732,160 @@ done:
  do not currently exist
  ***********************************************************************/
 
-bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr)
+struct regdb_store_keys_context {
+       const char *key;
+       struct regsubkey_ctr *ctr;
+};
+
+static NTSTATUS regdb_store_keys_action(struct db_context *db,
+                                       void *private_data)
 {
+       struct regdb_store_keys_context *store_ctx;
+       WERROR werr;
        int num_subkeys, i;
        char *path = NULL;
-       REGSUBKEY_CTR *subkeys = NULL, *old_subkeys = NULL;
+       struct regsubkey_ctr *subkeys = NULL, *old_subkeys = NULL;
        char *oldkeyname = NULL;
+       TALLOC_CTX *mem_ctx = talloc_stackframe();
+
+       store_ctx = (struct regdb_store_keys_context *)private_data;
+
+       /*
+        * Re-fetch the old keys inside the transaction
+        */
+
+       werr = regsubkey_ctr_init(mem_ctx, &old_subkeys);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+       werr = regdb_fetch_keys_internal(db, store_ctx->key, old_subkeys);
+       if (!W_ERROR_IS_OK(werr) &&
+           !W_ERROR_EQUAL(werr, WERR_NOT_FOUND))
+       {
+               goto done;
+       }
+
+       /*
+        * Make the store operation as safe as possible without transactions:
+        *
+        * (1) For each subkey removed from ctr compared with old_subkeys:
+        *
+        *     (a) First delete the value db entry.
+        *
+        *     (b) Next delete the secdesc db record.
+        *
+        *     (c) Then delete the subkey list entry.
+        *
+        * (2) Now write the list of subkeys of the parent key,
+        *     deleting removed entries and adding new ones.
+        *
+        * (3) Finally create the subkey list entries for the added keys.
+        *
+        * This way if we crash half-way in between deleting the subkeys
+        * and storing the parent's list of subkeys, no old data can pop up
+        * out of the blue when re-adding keys later on.
+        */
+
+       /* (1) delete removed keys' lists (values/secdesc/subkeys) */
+
+       num_subkeys = regsubkey_ctr_numkeys(old_subkeys);
+       for (i=0; i<num_subkeys; i++) {
+               oldkeyname = regsubkey_ctr_specific_key(old_subkeys, i);
+
+               if (regsubkey_ctr_key_exists(store_ctx->ctr, oldkeyname)) {
+                       /*
+                        * It's still around, don't delete
+                        */
+                       continue;
+               }
+
+               path = talloc_asprintf(mem_ctx, "%s/%s", store_ctx->key,
+                                      oldkeyname);
+               if (!path) {
+                       werr = WERR_NOMEM;
+                       goto done;
+               }
+
+               werr = regdb_delete_key_lists(db, path);
+               W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+               TALLOC_FREE(path);
+       }
+
+       TALLOC_FREE(old_subkeys);
+
+       /* (2) store the subkey list for the parent */
+
+       werr = regdb_store_keys_internal2(db, store_ctx->key, store_ctx->ctr);
+       if (!W_ERROR_IS_OK(werr)) {
+               DEBUG(0,("regdb_store_keys: Failed to store new subkey list "
+                        "for parent [%s]: %s\n", store_ctx->key,
+                        win_errstr(werr)));
+               goto done;
+       }
+
+       /* (3) now create records for any subkeys that don't already exist */
+
+       num_subkeys = regsubkey_ctr_numkeys(store_ctx->ctr);
+
+       if (num_subkeys == 0) {
+               werr = regsubkey_ctr_init(mem_ctx, &subkeys);
+               W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+               werr = regdb_store_keys_internal2(db, store_ctx->key, subkeys);
+               if (!W_ERROR_IS_OK(werr)) {
+                       DEBUG(0,("regdb_store_keys: Failed to store "
+                                "new record for key [%s]: %s\n",
+                                store_ctx->key, win_errstr(werr)));
+                       goto done;
+               }
+               TALLOC_FREE(subkeys);
+       }
+
+       for (i=0; i<num_subkeys; i++) {
+               path = talloc_asprintf(mem_ctx, "%s/%s", store_ctx->key,
+                               regsubkey_ctr_specific_key(store_ctx->ctr, i));
+               if (!path) {
+                       werr = WERR_NOMEM;
+                       goto done;
+               }
+               werr = regsubkey_ctr_init(mem_ctx, &subkeys);
+               W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+               werr = regdb_fetch_keys_internal(db, path, subkeys);
+               if (!W_ERROR_IS_OK(werr)) {
+                       /* create a record with 0 subkeys */
+                       werr = regdb_store_keys_internal2(db, path, subkeys);
+                       if (!W_ERROR_IS_OK(werr)) {
+                               DEBUG(0,("regdb_store_keys: Failed to store "
+                                        "new record for key [%s]: %s\n", path,
+                                        win_errstr(werr)));
+                               goto done;
+                       }
+               }
+
+               TALLOC_FREE(subkeys);
+               TALLOC_FREE(path);
+       }
+
+       werr = WERR_OK;
+
+done:
+       talloc_free(mem_ctx);
+       return werror_to_ntstatus(werr);
+}
+
+static bool regdb_store_keys_internal(struct db_context *db, const char *key,
+                                     struct regsubkey_ctr *ctr)
+{
+       int num_subkeys, old_num_subkeys, i;
+       struct regsubkey_ctr *old_subkeys = NULL;
        TALLOC_CTX *ctx = talloc_stackframe();
-       NTSTATUS status;
+       WERROR werr;
+       bool ret = false;
+       struct regdb_store_keys_context store_ctx;
 
-       if (!regdb_key_is_base_key(key) && !regdb_key_exists(key)) {
-               goto fail;
+       if (!regdb_key_is_base_key(key) && !regdb_key_exists(db, key)) {
+               goto done;
        }
 
        /*
@@ -592,194 +893,224 @@ bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr)
         * changed
         */
 
-       if (!(old_subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR))) {
+       werr = regsubkey_ctr_init(ctx, &old_subkeys);
+       if (!W_ERROR_IS_OK(werr)) {
                DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
-               return false;
+               goto done;
        }
 
-       regdb_fetch_keys(key, old_subkeys);
-
-       if ((ctr->num_subkeys && old_subkeys->num_subkeys) &&
-           (ctr->num_subkeys == old_subkeys->num_subkeys)) {
+       werr = regdb_fetch_keys_internal(db, key, old_subkeys);
+       if (!W_ERROR_IS_OK(werr) &&
+           !W_ERROR_EQUAL(werr, WERR_NOT_FOUND))
+       {
+               goto done;
+       }
 
-               for (i = 0; i<ctr->num_subkeys; i++) {
-                       if (strcmp(ctr->subkeys[i],
-                                  old_subkeys->subkeys[i]) != 0) {
+       num_subkeys = regsubkey_ctr_numkeys(ctr);
+       old_num_subkeys = regsubkey_ctr_numkeys(old_subkeys);
+       if ((num_subkeys && old_num_subkeys) &&
+           (num_subkeys == old_num_subkeys)) {
+
+               for (i = 0; i < num_subkeys; i++) {
+                       if (strcmp(regsubkey_ctr_specific_key(ctr, i),
+                                  regsubkey_ctr_specific_key(old_subkeys, i))
+                           != 0)
+                       {
                                break;
                        }
                }
-               if (i == ctr->num_subkeys) {
+               if (i == num_subkeys) {
                        /*
                         * Nothing changed, no point to even start a tdb
                         * transaction
                         */
-                       TALLOC_FREE(old_subkeys);
-                       return true;
+
+                       ret = true;
+                       goto done;
                }
        }
 
        TALLOC_FREE(old_subkeys);
 
-       if (regdb->transaction_start(regdb) != 0) {
-               DEBUG(0, ("regdb_store_keys: transaction_start failed\n"));
-               goto fail;
+       store_ctx.key = key;
+       store_ctx.ctr = ctr;
+
+       werr = ntstatus_to_werror(dbwrap_trans_do(db,
+                                                 regdb_store_keys_action,
+                                                 &store_ctx));
+
+       ret = W_ERROR_IS_OK(werr);
+
+done:
+       TALLOC_FREE(ctx);
+
+       return ret;
+}
+
+bool regdb_store_keys(const char *key, struct regsubkey_ctr *ctr)
+{
+       return regdb_store_keys_internal(regdb, key, ctr);
+}
+
+/**
+ * create a subkey of a given key
+ */
+
+struct regdb_create_subkey_context {
+       const char *key;
+       const char *subkey;
+};
+
+static NTSTATUS regdb_create_subkey_action(struct db_context *db,
+                                          void *private_data)
+{
+       WERROR werr;
+       struct regdb_create_subkey_context *create_ctx;
+       struct regsubkey_ctr *subkeys;
+       TALLOC_CTX *mem_ctx = talloc_stackframe();
+
+       create_ctx = (struct regdb_create_subkey_context *)private_data;
+
+       werr = regsubkey_ctr_init(mem_ctx, &subkeys);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+       werr = regdb_fetch_keys_internal(db, create_ctx->key, subkeys);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+       werr = regsubkey_ctr_addkey(subkeys, create_ctx->subkey);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+       werr = regdb_store_keys_internal2(db, create_ctx->key, subkeys);
+       if (!W_ERROR_IS_OK(werr)) {
+               DEBUG(0, (__location__ " failed to store new subkey list for "
+                        "parent key %s: %s\n", create_ctx->key,
+                        win_errstr(werr)));
        }
 
-       /*
-        * Re-fetch the old keys inside the transaction
-        */
+done:
+       talloc_free(mem_ctx);
+       return werror_to_ntstatus(werr);
+}
 
-       if (!(old_subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR))) {
-               DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
-               goto cancel;
-       }
+static WERROR regdb_create_subkey(const char *key, const char *subkey)
+{
+       WERROR werr;
+       struct regsubkey_ctr *subkeys;
+       TALLOC_CTX *mem_ctx = talloc_stackframe();
+       struct regdb_create_subkey_context create_ctx;
 
-       regdb_fetch_keys(key, old_subkeys);
+       if (!regdb_key_is_base_key(key) && !regdb_key_exists(regdb, key)) {
+               werr = WERR_NOT_FOUND;
+               goto done;
+       }
 
-       /*
-        * Make the store operation as safe as possible without transactions:
-        *
-        * (1) For each subkey removed from ctr compared with old_subkeys:
-        *
-        *     (a) First delete the value db entry.
-        *
-        *     (b) Next delete the secdesc db record.
-        *
-        *     (c) Then delete the subkey list entry.
-        *
-        * (2) Now write the list of subkeys of the parent key,
-        *     deleting removed entries and adding new ones.
-        *
-        * (3) Finally create the subkey list entries for the added keys.
-        *
-        * This way if we crash half-way in between deleting the subkeys
-        * and storing the parent's list of subkeys, no old data can pop up
-        * out of the blue when re-adding keys later on.
-        */
+       werr = regsubkey_ctr_init(mem_ctx, &subkeys);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
 
-       /* (1) delete removed keys' lists (values/secdesc/subkeys) */
+       werr = regdb_fetch_keys_internal(regdb, key, subkeys);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
 
-       num_subkeys = regsubkey_ctr_numkeys(old_subkeys);
-       for (i=0; i<num_subkeys; i++) {
-               oldkeyname = regsubkey_ctr_specific_key(old_subkeys, i);
+       if (regsubkey_ctr_key_exists(subkeys, subkey)) {
+               werr = WERR_OK;
+               goto done;
+       }
 
-               if (regsubkey_ctr_key_exists(ctr, oldkeyname)) {
-                       /*
-                        * It's still around, don't delete
-                        */
+       talloc_free(subkeys);
 
-                       continue;
-               }
+       create_ctx.key = key;
+       create_ctx.subkey = subkey;
 
-               path = talloc_asprintf(ctx, "%s/%s", key, oldkeyname);
-               if (!path) {
-                       goto cancel;
-               }
-               path = normalize_reg_path(ctx, path);
-               if (!path) {
-                       goto cancel;
-               }
-               status = dbwrap_delete_bystring(regdb, path);
-               if (!NT_STATUS_IS_OK(status)) {
-                       DEBUG(1, ("Deleting %s failed\n", path));
-                       goto cancel;
-               }
+       werr = ntstatus_to_werror(dbwrap_trans_do(regdb,
+                                                 regdb_create_subkey_action,
+                                                 &create_ctx));
 
-               TALLOC_FREE(path);
-               path = talloc_asprintf(ctx, "%s/%s/%s",
-                               REG_VALUE_PREFIX,
-                               key,
-                               oldkeyname );
-               if (!path) {
-                       goto cancel;
-               }
-               path = normalize_reg_path(ctx, path);
-               if (!path) {
-                       goto cancel;
-               }
+done:
+       talloc_free(mem_ctx);
+       return werr;
+}
 
-               /*
-                * Ignore errors here, we might have no values around
-                */
-               dbwrap_delete_bystring(regdb, path);
-               TALLOC_FREE(path);
-       }
+/**
+ * create a subkey of a given key
+ */
 
-       TALLOC_FREE(old_subkeys);
+struct regdb_delete_subkey_context {
+       const char *key;
+       const char *subkey;
+       const char *path;
+};
 
-       /* (2) store the subkey list for the parent */
+static NTSTATUS regdb_delete_subkey_action(struct db_context *db,
+                                          void *private_data)
+{
+       WERROR werr;
+       struct regdb_delete_subkey_context *delete_ctx;
+       struct regsubkey_ctr *subkeys;
+       TALLOC_CTX *mem_ctx = talloc_stackframe();
 
-       if (!regdb_store_keys_internal(key, ctr) ) {
-               DEBUG(0,("regdb_store_keys: Failed to store new subkey list "
-                        "for parent [%s]\n", key));
-               goto cancel;
-       }
+       delete_ctx = (struct regdb_delete_subkey_context *)private_data;
 
-       /* (3) now create records for any subkeys that don't already exist */
+       werr = regdb_delete_key_lists(db, delete_ctx->path);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
 
-       num_subkeys = regsubkey_ctr_numkeys(ctr);
+       werr = regsubkey_ctr_init(mem_ctx, &subkeys);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
 
-       if (num_subkeys == 0) {
-               if (!(subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR)) ) {
-                       DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
-                       goto cancel;
-               }
+       werr = regdb_fetch_keys_internal(db, delete_ctx->key, subkeys);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
 
-               if (!regdb_store_keys_internal(key, subkeys)) {
-                       DEBUG(0,("regdb_store_keys: Failed to store "
-                                "new record for key [%s]\n", key));
-                       goto cancel;
-               }
-               TALLOC_FREE(subkeys);
+       werr = regsubkey_ctr_delkey(subkeys, delete_ctx->subkey);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
 
+       werr = regdb_store_keys_internal2(db, delete_ctx->key, subkeys);
+       if (!W_ERROR_IS_OK(werr)) {
+               DEBUG(0, (__location__ " failed to store new subkey_list for "
+                        "parent key %s: %s\n", delete_ctx->key,
+                        win_errstr(werr)));
        }
 
-       for (i=0; i<num_subkeys; i++) {
-               path = talloc_asprintf(ctx, "%s/%s",
-                                       key,
-                                       regsubkey_ctr_specific_key(ctr, i));
-               if (!path) {
-                       goto cancel;
-               }
-               if (!(subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR)) ) {
-                       DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
-                       goto cancel;
-               }
+done:
+       talloc_free(mem_ctx);
+       return werror_to_ntstatus(werr);
+}
 
-               if (regdb_fetch_keys( path, subkeys ) == -1) {
-                       /* create a record with 0 subkeys */
-                       if (!regdb_store_keys_internal(path, subkeys)) {
-                               DEBUG(0,("regdb_store_keys: Failed to store "
-                                        "new record for key [%s]\n", path));
-                               goto cancel;
-                       }
-               }
+static WERROR regdb_delete_subkey(const char *key, const char *subkey)
+{
+       WERROR werr;
+       char *path;
+       struct regdb_delete_subkey_context delete_ctx;
+       TALLOC_CTX *mem_ctx = talloc_stackframe();
 
-               TALLOC_FREE(subkeys);
-               TALLOC_FREE(path);
+       if (!regdb_key_is_base_key(key) && !regdb_key_exists(regdb, key)) {
+               werr = WERR_NOT_FOUND;
+               goto done;
        }
 
-       if (regdb->transaction_commit(regdb) != 0) {
-               DEBUG(0, ("regdb_store_keys: Could not commit transaction\n"));
-               goto fail;
+       path = talloc_asprintf(mem_ctx, "%s/%s", key, subkey);
+       if (path == NULL) {
+               werr = WERR_NOMEM;
+               goto done;
        }
 
-       TALLOC_FREE(ctx);
-       return true;
-
-cancel:
-       if (regdb->transaction_cancel(regdb) != 0) {
-               smb_panic("regdb_store_keys: transaction_cancel failed\n");
+       if (!regdb_key_exists(regdb, path)) {
+               werr = WERR_OK;
+               goto done;
        }
 
-fail:
-       TALLOC_FREE(ctx);
+       delete_ctx.key = key;
+       delete_ctx.subkey = subkey;
+       delete_ctx.path = path;
 
-       return false;
-}
+       werr = ntstatus_to_werror(dbwrap_trans_do(regdb,
+                                                 regdb_delete_subkey_action,
+                                                 &delete_ctx));
 
+done:
+       talloc_free(mem_ctx);
+       return werr;
+}
 
-static TDB_DATA regdb_fetch_key_internal(TALLOC_CTX *mem_ctx, const char *key)
+static TDB_DATA regdb_fetch_key_internal(struct db_context *db,
+                                        TALLOC_CTX *mem_ctx, const char *key)
 {
        char *path = NULL;
        TDB_DATA data;
@@ -789,7 +1120,7 @@ static TDB_DATA regdb_fetch_key_internal(TALLOC_CTX *mem_ctx, const char *key)
                return make_tdb_data(NULL, 0);
        }
 
-       data = dbwrap_fetch_bystring(regdb, mem_ctx, path);
+       data = dbwrap_fetch_bystring(db, mem_ctx, path);
 
        TALLOC_FREE(path);
        return data;
@@ -827,6 +1158,235 @@ done:
        return ret;
 }
 
+/*
+ * regdb_key_exists() is a very frequent operation. It can be quite
+ * time-consuming to fully fetch the parent's subkey list, talloc_strdup all
+ * subkeys and then compare the keyname linearly to all the parent's subkeys.
+ *
+ * The following code tries to make this operation as efficient as possible:
+ * Per registry key we create a list of subkeys that is very efficient to
+ * search for existence of a subkey. Its format is:
+ *
+ * 4 bytes num_subkeys
+ * 4*num_subkey bytes offset into the string array
+ * then follows a sorted list of subkeys in uppercase
+ *
+ * This record is created by create_sorted_subkeys() on demand if it does not
+ * exist. scan_parent_subkeys() uses regdb->parse_record to search the sorted
+ * list, the parsing code and the binary search can be found in
+ * parent_subkey_scanner. The code uses parse_record() to avoid a memcpy of
+ * the potentially large subkey record.
+ *
+ * The sorted subkey record is deleted in regdb_store_keys_internal2 and
+ * recreated on demand.
+ */
+
+static int cmp_keynames(const void *p1, const void *p2)
+{
+       return StrCaseCmp(*((char **)p1), *((char **)p2));
+}
+
+struct create_sorted_subkeys_context {
+       const char *key;
+       const char *sorted_keyname;
+};
+
+static NTSTATUS create_sorted_subkeys_action(struct db_context *db,
+                                            void *private_data)
+{
+       char **sorted_subkeys;
+       struct regsubkey_ctr *ctr;
+       NTSTATUS status;
+       char *buf;
+       char *p;
+       int i;
+       size_t len;
+       int num_subkeys;
+       struct create_sorted_subkeys_context *sorted_ctx;
+
+       sorted_ctx = (struct create_sorted_subkeys_context *)private_data;
+
+       /*
+        * In this function, we only treat failing of the actual write to
+        * the db as a real error. All preliminary errors, at a stage when
+        * nothing has been written to the DB yet are treated as success
+        * to be committed (as an empty transaction).
+        *
+        * The reason is that this (disposable) call might be nested in other
+        * transactions. Doing a cancel here would destroy the possibility of
+        * a transaction_commit for transactions that we might be wrapped in.
+        */
+
+       status = werror_to_ntstatus(regsubkey_ctr_init(talloc_tos(), &ctr));
+       if (!NT_STATUS_IS_OK(status)) {
+               /* don't treat this as an error */
+               status = NT_STATUS_OK;
+               goto done;
+       }
+
+       status = werror_to_ntstatus(regdb_fetch_keys_internal(db,
+                                                             sorted_ctx->key,
+                                                             ctr));
+       if (!NT_STATUS_IS_OK(status)) {
+               /* don't treat this as an error */
+               status = NT_STATUS_OK;
+               goto done;
+       }
+
+       num_subkeys = regsubkey_ctr_numkeys(ctr);
+       sorted_subkeys = talloc_array(ctr, char *, num_subkeys);
+       if (sorted_subkeys == NULL) {
+               /* don't treat this as an error */
+               goto done;
+       }
+
+       len = 4 + 4*num_subkeys;
+
+       for (i = 0; i < num_subkeys; i++) {
+               sorted_subkeys[i] = talloc_strdup_upper(sorted_subkeys,
+                                       regsubkey_ctr_specific_key(ctr, i));
+               if (sorted_subkeys[i] == NULL) {
+                       /* don't treat this as an error */
+                       goto done;
+               }
+               len += strlen(sorted_subkeys[i])+1;
+       }
+
+       qsort(sorted_subkeys, num_subkeys, sizeof(char *), cmp_keynames);
+
+       buf = talloc_array(ctr, char, len);
+       if (buf == NULL) {
+               /* don't treat this as an error */
+               goto done;
+       }
+       p = buf + 4 + 4*num_subkeys;
+
+       SIVAL(buf, 0, num_subkeys);
+
+       for (i=0; i < num_subkeys; i++) {
+               ptrdiff_t offset = p - buf;
+               SIVAL(buf, 4 + 4*i, offset);
+               strlcpy(p, sorted_subkeys[i], len-offset);
+               p += strlen(sorted_subkeys[i]) + 1;
+       }
+
+       status = dbwrap_store_bystring(
+               db, sorted_ctx->sorted_keyname, make_tdb_data((uint8_t *)buf,
+               len),
+               TDB_REPLACE);
+
+done:
+       talloc_free(ctr);
+       return status;
+}
+
+static bool create_sorted_subkeys(const char *key, const char *sorted_keyname)
+{
+       NTSTATUS status;
+       struct create_sorted_subkeys_context sorted_ctx;
+
+       sorted_ctx.key = key;
+       sorted_ctx.sorted_keyname = sorted_keyname;
+
+       status = dbwrap_trans_do(regdb,
+                                create_sorted_subkeys_action,
+                                &sorted_ctx);
+
+       return NT_STATUS_IS_OK(status);
+}
+
+struct scan_subkey_state {
+       char *name;
+       bool scanned;
+       bool found;
+};
+
+static int parent_subkey_scanner(TDB_DATA key, TDB_DATA data,
+                                void *private_data)
+{
+       struct scan_subkey_state *state =
+               (struct scan_subkey_state *)private_data;
+       uint32_t num_subkeys;
+       uint32_t l, u;
+
+       if (data.dsize < sizeof(uint32_t)) {
+               return -1;
+       }
+
+       state->scanned = true;
+       state->found = false;
+
+       tdb_unpack(data.dptr, data.dsize, "d", &num_subkeys);
+
+       l = 0;
+       u = num_subkeys;
+
+       while (l < u) {
+               uint32_t idx = (l+u)/2;
+               char *s = (char *)data.dptr + IVAL(data.dptr, 4 + 4*idx);
+               int comparison = strcmp(state->name, s);
+
+               if (comparison < 0) {
+                       u = idx;
+               } else if (comparison > 0) {
+                       l = idx + 1;
+               } else {
+                       state->found = true;
+                       return 0;
+               }
+       }
+       return 0;
+}
+
+static bool scan_parent_subkeys(struct db_context *db, const char *parent,
+                               const char *name)
+{
+       char *path = NULL;
+       char *key = NULL;
+       struct scan_subkey_state state = { 0, };
+       bool result = false;
+       int res;
+
+       state.name = NULL;
+
+       path = normalize_reg_path(talloc_tos(), parent);
+       if (path == NULL) {
+               goto fail;
+       }
+
+       key = talloc_asprintf(talloc_tos(), "%s/%s",
+                             REG_SORTED_SUBKEYS_PREFIX, path);
+       if (key == NULL) {
+               goto fail;
+       }
+
+       state.name = talloc_strdup_upper(talloc_tos(), name);
+       if (state.name == NULL) {
+               goto fail;
+       }
+       state.scanned = false;
+
+       res = db->parse_record(db, string_term_tdb_data(key),
+                              parent_subkey_scanner, &state);
+
+       if (state.scanned) {
+               result = state.found;
+       } else {
+               if (!create_sorted_subkeys(path, key)) {
+                       goto fail;
+               }
+               res = db->parse_record(db, string_term_tdb_data(key),
+                                      parent_subkey_scanner, &state);
+               if ((res == 0) && (state.scanned)) {
+                       result = state.found;
+               }
+       }
+
+ fail:
+       TALLOC_FREE(path);
+       TALLOC_FREE(state.name);
+       return result;
+}
 
 /**
  * Check for the existence of a key.
@@ -836,7 +1396,7 @@ done:
  * The exeption of this are keys without a parent key,
  * i.e. the "base" keys (HKLM, HKCU, ...).
  */
-static bool regdb_key_exists(const char *key)
+static bool regdb_key_exists(struct db_context *db, const char *key)
 {
        TALLOC_CTX *mem_ctx = talloc_stackframe();
        TDB_DATA value;
@@ -860,29 +1420,11 @@ static bool regdb_key_exists(const char *key)
        p = strrchr(path, '/');
        if (p == NULL) {
                /* this is a base key */
-               value = regdb_fetch_key_internal(mem_ctx, path);
+               value = regdb_fetch_key_internal(db, mem_ctx, path);
                ret = (value.dptr != NULL);
        } else {
-               /* get the list of subkeys of the parent key */
-               uint32 num_items, len, i;
-               fstring subkeyname;
-
                *p = '\0';
-               p++;
-               value = regdb_fetch_key_internal(mem_ctx, path);
-               if (value.dptr == NULL) {
-                       goto done;
-               }
-
-               len = tdb_unpack(value.dptr, value.dsize, "d", &num_items);
-               for (i = 0; i < num_items; i++) {
-                       len += tdb_unpack(value.dptr +len, value.dsize -len,
-                                         "f", &subkeyname);
-                       if (strequal(subkeyname, p)) {
-                               ret = true;
-                               goto done;
-                       }
-               }
+               ret = scan_parent_subkeys(db, path, p+1);
        }
 
 done:
@@ -896,61 +1438,81 @@ done:
  released by the caller.
  ***********************************************************************/
 
-int regdb_fetch_keys(const char *key, REGSUBKEY_CTR *ctr)
+static WERROR regdb_fetch_keys_internal(struct db_context *db, const char *key,
+                                       struct regsubkey_ctr *ctr)
 {
        WERROR werr;
-       uint32 num_items;
+       uint32_t num_items;
        uint8 *buf;
        uint32 buflen, len;
        int i;
        fstring subkeyname;
-       int ret = -1;
        TALLOC_CTX *frame = talloc_stackframe();
        TDB_DATA value;
 
        DEBUG(11,("regdb_fetch_keys: Enter key => [%s]\n", key ? key : "NULL"));
 
-       if (!regdb_key_exists(key)) {
-               goto fail;
-       }
+       frame = talloc_stackframe();
 
-       ctr->seqnum = regdb_get_seqnum();
+       if (!regdb_key_exists(db, key)) {
+               DEBUG(10, ("key [%s] not found\n", key));
+               werr = WERR_NOT_FOUND;
+               goto done;
+       }
 
-       value = regdb_fetch_key_internal(frame, key);
+       werr = regsubkey_ctr_set_seqnum(ctr, db->get_seqnum(db));
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
 
-       buf = value.dptr;
-       buflen = value.dsize;
+       value = regdb_fetch_key_internal(db, frame, key);
 
-       if ( !buf ) {
-               DEBUG(5,("regdb_fetch_keys: tdb lookup failed to locate key [%s]\n", key));
-               goto fail;
+       if (value.dptr == NULL) {
+               DEBUG(10, ("regdb_fetch_keys: no subkeys found for key [%s]\n",
+                          key));
+               goto done;
        }
 
+       buf = value.dptr;
+       buflen = value.dsize;
        len = tdb_unpack( buf, buflen, "d", &num_items);
 
+       werr = regsubkey_ctr_reinit(ctr);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
+
        for (i=0; i<num_items; i++) {
                len += tdb_unpack(buf+len, buflen-len, "f", subkeyname);
                werr = regsubkey_ctr_addkey(ctr, subkeyname);
                if (!W_ERROR_IS_OK(werr)) {
                        DEBUG(5, ("regdb_fetch_keys: regsubkey_ctr_addkey "
-                                 "failed: %s\n", dos_errstr(werr)));
-                       goto fail;
+                                 "failed: %s\n", win_errstr(werr)));
+                       num_items = 0;
+                       goto done;
                }
        }
 
        DEBUG(11,("regdb_fetch_keys: Exit [%d] items\n", num_items));
 
-       ret = num_items;
- fail:
+done:
        TALLOC_FREE(frame);
-       return ret;
+       return werr;
+}
+
+int regdb_fetch_keys(const char *key, struct regsubkey_ctr *ctr)
+{
+       WERROR werr;
+
+       werr = regdb_fetch_keys_internal(regdb, key, ctr);
+       if (!W_ERROR_IS_OK(werr)) {
+               return -1;
+       }
+
+       return regsubkey_ctr_numkeys(ctr);
 }
 
 /****************************************************************************
  Unpack a list of registry values frem the TDB
  ***************************************************************************/
 
-static int regdb_unpack_values(REGVAL_CTR *values, uint8 *buf, int buflen)
+static int regdb_unpack_values(struct regval_ctr *values, uint8 *buf, int buflen)
 {
        int             len = 0;
        uint32          type;
@@ -995,11 +1557,11 @@ static int regdb_unpack_values(REGVAL_CTR *values, uint8 *buf, int buflen)
  Pack all values in all printer keys
  ***************************************************************************/
 
-static int regdb_pack_values(REGVAL_CTR *values, uint8 *buf, int buflen)
+static int regdb_pack_values(struct regval_ctr *values, uint8 *buf, int buflen)
 {
        int             len = 0;
        int             i;
-       REGISTRY_VALUE  *val;
+       struct regval_blob      *val;
        int             num_values;
 
        if ( !values )
@@ -1030,7 +1592,8 @@ static int regdb_pack_values(REGVAL_CTR *values, uint8 *buf, int buflen)
  released by the caller.
  ***********************************************************************/
 
-int regdb_fetch_values( const char* key, REGVAL_CTR *values )
+static int regdb_fetch_values_internal(struct db_context *db, const char* key,
+                                      struct regval_ctr *values)
 {
        char *keystr = NULL;
        TALLOC_CTX *ctx = talloc_stackframe();
@@ -1039,7 +1602,7 @@ int regdb_fetch_values( const char* key, REGVAL_CTR *values )
 
        DEBUG(10,("regdb_fetch_values: Looking for value of key [%s] \n", key));
 
-       if (!regdb_key_exists(key)) {
+       if (!regdb_key_exists(db, key)) {
                goto done;
        }
 
@@ -1048,9 +1611,9 @@ int regdb_fetch_values( const char* key, REGVAL_CTR *values )
                goto done;
        }
 
-       values->seqnum = regdb_get_seqnum();
+       values->seqnum = db->get_seqnum(db);
 
-       value = regdb_fetch_key_internal(ctx, keystr);
+       value = regdb_fetch_key_internal(db, ctx, keystr);
 
        if (!value.dptr) {
                /* all keys have zero values by default */
@@ -1065,7 +1628,13 @@ done:
        return ret;
 }
 
-bool regdb_store_values( const char *key, REGVAL_CTR *values )
+int regdb_fetch_values(const char* key, struct regval_ctr *values)
+{
+       return regdb_fetch_values_internal(regdb, key, values);
+}
+
+static bool regdb_store_values_internal(struct db_context *db, const char *key,
+                                       struct regval_ctr *values)
 {
        TDB_DATA old_data, data;
        char *keystr = NULL;
@@ -1076,7 +1645,7 @@ bool regdb_store_values( const char *key, REGVAL_CTR *values )
 
        DEBUG(10,("regdb_store_values: Looking for value of key [%s] \n", key));
 
-       if (!regdb_key_exists(key)) {
+       if (!regdb_key_exists(db, key)) {
                goto done;
        }
 
@@ -1104,7 +1673,7 @@ bool regdb_store_values( const char *key, REGVAL_CTR *values )
                goto done;
        }
 
-       old_data = dbwrap_fetch_bystring(regdb, ctx, keystr);
+       old_data = dbwrap_fetch_bystring(db, ctx, keystr);
 
        if ((old_data.dptr != NULL)
            && (old_data.dsize == data.dsize)
@@ -1114,8 +1683,7 @@ bool regdb_store_values( const char *key, REGVAL_CTR *values )
                goto done;
        }
 
-       status = dbwrap_trans_store(regdb, string_term_tdb_data(keystr), data,
-                                   TDB_REPLACE);
+       status = dbwrap_trans_store_bystring(db, keystr, data, TDB_REPLACE);
 
        result = NT_STATUS_IS_OK(status);
 
@@ -1124,6 +1692,11 @@ done:
        return result;
 }
 
+bool regdb_store_values(const char *key, struct regval_ctr *values)
+{
+       return regdb_store_values_internal(regdb, key, values);
+}
+
 static WERROR regdb_get_secdesc(TALLOC_CTX *mem_ctx, const char *key,
                                struct security_descriptor **psecdesc)
 {
@@ -1135,7 +1708,7 @@ static WERROR regdb_get_secdesc(TALLOC_CTX *mem_ctx, const char *key,
 
        DEBUG(10, ("regdb_get_secdesc: Getting secdesc of key [%s]\n", key));
 
-       if (!regdb_key_exists(key)) {
+       if (!regdb_key_exists(regdb, key)) {
                err = WERR_BADFILE;
                goto done;
        }
@@ -1172,11 +1745,10 @@ static WERROR regdb_set_secdesc(const char *key,
 {
        TALLOC_CTX *mem_ctx = talloc_stackframe();
        char *tdbkey;
-       NTSTATUS status;
        WERROR err = WERR_NOMEM;
        TDB_DATA tdbdata;
 
-       if (!regdb_key_exists(key)) {
+       if (!regdb_key_exists(regdb, key)) {
                err = WERR_BADFILE;
                goto done;
        }
@@ -1189,41 +1761,30 @@ static WERROR regdb_set_secdesc(const char *key,
 
        if (secdesc == NULL) {
                /* assuming a delete */
-               status = dbwrap_trans_delete(regdb,
-                                            string_term_tdb_data(tdbkey));
-               if (NT_STATUS_IS_OK(status)) {
-                       err = WERR_OK;
-               } else {
-                       err = ntstatus_to_werror(status);
-               }
+               err = ntstatus_to_werror(dbwrap_trans_delete_bystring(regdb,
+                                                                     tdbkey));
                goto done;
        }
 
        err = ntstatus_to_werror(marshall_sec_desc(mem_ctx, secdesc,
                                                   &tdbdata.dptr,
                                                   &tdbdata.dsize));
-       if (!W_ERROR_IS_OK(err)) {
-               goto done;
-       }
+       W_ERROR_NOT_OK_GOTO_DONE(err);
 
-       status = dbwrap_trans_store(regdb, string_term_tdb_data(tdbkey),
-                                   tdbdata, 0);
-       if (!NT_STATUS_IS_OK(status)) {
-               err = ntstatus_to_werror(status);
-               goto done;
-       }
+       err = ntstatus_to_werror(dbwrap_trans_store_bystring(regdb, tdbkey,
+                                                            tdbdata, 0));
 
  done:
        TALLOC_FREE(mem_ctx);
        return err;
 }
 
-bool regdb_subkeys_need_update(REGSUBKEY_CTR *subkeys)
+bool regdb_subkeys_need_update(struct regsubkey_ctr *subkeys)
 {
-       return (regdb_get_seqnum() != subkeys->seqnum);
+       return (regdb_get_seqnum() != regsubkey_ctr_get_seqnum(subkeys));
 }
 
-bool regdb_values_need_update(REGVAL_CTR *values)
+bool regdb_values_need_update(struct regval_ctr *values)
 {
        return (regdb_get_seqnum() != values->seqnum);
 }
@@ -1232,11 +1793,13 @@ bool regdb_values_need_update(REGVAL_CTR *values)
  * Table of function pointers for default access
  */
  
-REGISTRY_OPS regdb_ops = {
+struct registry_ops regdb_ops = {
        .fetch_subkeys = regdb_fetch_keys,
        .fetch_values = regdb_fetch_values,
        .store_subkeys = regdb_store_keys,
        .store_values = regdb_store_values,
+       .create_subkey = regdb_create_subkey,
+       .delete_subkey = regdb_delete_subkey,
        .get_secdesc = regdb_get_secdesc,
        .set_secdesc = regdb_set_secdesc,
        .subkeys_need_update = regdb_subkeys_need_update,