s3-registry: use push_reg_sz().
[kai/samba.git] / source3 / registry / reg_backend_db.c
index 344bc4124d360797db07d06e4323c3e03fb0811e..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);
@@ -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;
@@ -552,7 +679,7 @@ static bool regdb_store_keys_internal(const char *key, REGSUBKEY_CTR *ctr)
                                DEBUG(0, ("regdb_store_keys: Failed to realloc "
                                          "memory of size [%u]\n",
                                          (unsigned int)(len+thistime)*2));
-                               ret = false;
+                               werr = WERR_NOMEM;
                                goto done;
                        }
                        buflen = (len+thistime)*2;
@@ -561,7 +688,7 @@ static bool regdb_store_keys_internal(const char *key, REGSUBKEY_CTR *ctr)
                                regsubkey_ctr_specific_key(ctr, i));
                        if (thistime2 != thistime) {
                                DEBUG(0, ("tdb_pack failed\n"));
-                               ret = false;
+                               werr = WERR_CAN_NOT_COMPLETE;
                                goto done;
                        }
                }
@@ -572,11 +699,9 @@ static bool regdb_store_keys_internal(const char *key, REGSUBKEY_CTR *ctr)
 
        dbuf.dptr = buffer;
        dbuf.dsize = len;
-       status = dbwrap_store_bystring(regdb, keyname, dbuf, TDB_REPLACE);
-       if (!NT_STATUS_IS_OK(status)) {
-               ret = false;
-               goto done;
-       }
+       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
@@ -584,14 +709,22 @@ static bool regdb_store_keys_internal(const char *key, REGSUBKEY_CTR *ctr)
         */
        keyname = talloc_asprintf(ctx, "%s/%s", REG_SORTED_SUBKEYS_PREFIX,
                                  keyname);
-       if (keyname != NULL) {
-               dbwrap_delete_bystring(regdb, 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;
 }
 
 /***********************************************************************
@@ -599,67 +732,37 @@ 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 *ctx = talloc_stackframe();
-       NTSTATUS status;
-
-       if (!regdb_key_is_base_key(key) && !regdb_key_exists(key)) {
-               goto fail;
-       }
-
-       /*
-        * fetch a list of the old subkeys so we can determine if anything has
-        * changed
-        */
-
-       if (!(old_subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR))) {
-               DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
-               return false;
-       }
-
-       regdb_fetch_keys(key, old_subkeys);
-
-       if ((ctr->num_subkeys && old_subkeys->num_subkeys) &&
-           (ctr->num_subkeys == old_subkeys->num_subkeys)) {
-
-               for (i = 0; i<ctr->num_subkeys; i++) {
-                       if (strcmp(ctr->subkeys[i],
-                                  old_subkeys->subkeys[i]) != 0) {
-                               break;
-                       }
-               }
-               if (i == ctr->num_subkeys) {
-                       /*
-                        * Nothing changed, no point to even start a tdb
-                        * transaction
-                        */
-                       TALLOC_FREE(old_subkeys);
-                       return true;
-               }
-       }
+       TALLOC_CTX *mem_ctx = talloc_stackframe();
 
-       TALLOC_FREE(old_subkeys);
-
-       if (regdb->transaction_start(regdb) != 0) {
-               DEBUG(0, ("regdb_store_keys: transaction_start failed\n"));
-               goto fail;
-       }
+       store_ctx = (struct regdb_store_keys_context *)private_data;
 
        /*
         * Re-fetch the old keys inside the transaction
         */
 
-       if (!(old_subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR))) {
-               DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
-               goto cancel;
-       }
+       werr = regsubkey_ctr_init(mem_ctx, &old_subkeys);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
 
-       regdb_fetch_keys(key, old_subkeys);
+       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:
@@ -688,74 +791,23 @@ bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr)
        for (i=0; i<num_subkeys; i++) {
                oldkeyname = regsubkey_ctr_specific_key(old_subkeys, i);
 
-               if (regsubkey_ctr_key_exists(ctr, oldkeyname)) {
+               if (regsubkey_ctr_key_exists(store_ctx->ctr, oldkeyname)) {
                        /*
                         * It's still around, don't delete
                         */
-
                        continue;
                }
 
-               /* (a) Delete the value list for this key */
-
-               path = talloc_asprintf(ctx, "%s/%s/%s",
-                               REG_VALUE_PREFIX,
-                               key,
-                               oldkeyname );
+               path = talloc_asprintf(mem_ctx, "%s/%s", store_ctx->key,
+                                      oldkeyname);
                if (!path) {
-                       goto cancel;
-               }
-               path = normalize_reg_path(ctx, path);
-               if (!path) {
-                       goto cancel;
-               }
-               /* Ignore errors here, we might have no values around */
-               dbwrap_delete_bystring(regdb, path);
-               TALLOC_FREE(path);
-
-               /* (b) Delete the secdesc for this key */
-
-               path = talloc_asprintf(ctx, "%s/%s/%s",
-                               REG_SECDESC_PREFIX,
-                               key,
-                               oldkeyname );
-               if (!path) {
-                       goto cancel;
-               }
-               path = normalize_reg_path(ctx, path);
-               if (!path) {
-                       goto cancel;
-               }
-               status = dbwrap_delete_bystring(regdb, path);
-               /* Don't fail if there are no values around. */
-               if (!NT_STATUS_IS_OK(status) &&
-                   !NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND))
-               {
-                       DEBUG(1, ("Deleting %s failed: %s\n", path,
-                                 nt_errstr(status)));
-                       goto cancel;
+                       werr = WERR_NOMEM;
+                       goto done;
                }
-               TALLOC_FREE(path);
 
-               /* (c) Delete the list of subkeys of this key */
+               werr = regdb_delete_key_lists(db, path);
+               W_ERROR_NOT_OK_GOTO_DONE(werr);
 
-               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);
-               /* Don't fail if the subkey record was not found. */
-               if (!NT_STATUS_IS_OK(status) &&
-                   !NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND))
-               {
-                       DEBUG(1, ("Deleting %s failed: %s\n", path,
-                                 nt_errstr(status)));
-                       goto cancel;
-               }
                TALLOC_FREE(path);
        }
 
@@ -763,49 +815,51 @@ bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr)
 
        /* (2) store the subkey list for the parent */
 
-       if (!regdb_store_keys_internal(key, ctr) ) {
+       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]\n", key));
-               goto cancel;
+                        "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(ctr);
+       num_subkeys = regsubkey_ctr_numkeys(store_ctx->ctr);
 
        if (num_subkeys == 0) {
-               if (!(subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR)) ) {
-                       DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
-                       goto cancel;
-               }
+               werr = regsubkey_ctr_init(mem_ctx, &subkeys);
+               W_ERROR_NOT_OK_GOTO_DONE(werr);
 
-               if (!regdb_store_keys_internal(key, subkeys)) {
+               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]\n", key));
-                       goto cancel;
+                                "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(ctx, "%s/%s",
-                                       key,
-                                       regsubkey_ctr_specific_key(ctr, i));
+               path = talloc_asprintf(mem_ctx, "%s/%s", store_ctx->key,
+                               regsubkey_ctr_specific_key(store_ctx->ctr, i));
                if (!path) {
-                       goto cancel;
-               }
-               if (!(subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR)) ) {
-                       DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
-                       goto cancel;
+                       werr = WERR_NOMEM;
+                       goto done;
                }
+               werr = regsubkey_ctr_init(mem_ctx, &subkeys);
+               W_ERROR_NOT_OK_GOTO_DONE(werr);
 
-               if (regdb_fetch_keys( path, subkeys ) == -1) {
+               werr = regdb_fetch_keys_internal(db, path, subkeys);
+               if (!W_ERROR_IS_OK(werr)) {
                        /* create a record with 0 subkeys */
-                       if (!regdb_store_keys_internal(path, 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]\n", path));
-                               goto cancel;
+                                        "new record for key [%s]: %s\n", path,
+                                        win_errstr(werr)));
+                               goto done;
                        }
                }
 
@@ -813,27 +867,250 @@ bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr)
                TALLOC_FREE(path);
        }
 
-       if (regdb->transaction_commit(regdb) != 0) {
-               DEBUG(0, ("regdb_store_keys: Could not commit transaction\n"));
-               goto fail;
+       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();
+       WERROR werr;
+       bool ret = false;
+       struct regdb_store_keys_context store_ctx;
+
+       if (!regdb_key_is_base_key(key) && !regdb_key_exists(db, key)) {
+               goto done;
        }
 
-       TALLOC_FREE(ctx);
-       return true;
+       /*
+        * fetch a list of the old subkeys so we can determine if anything has
+        * changed
+        */
+
+       werr = regsubkey_ctr_init(ctx, &old_subkeys);
+       if (!W_ERROR_IS_OK(werr)) {
+               DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
+               goto done;
+       }
 
-cancel:
-       if (regdb->transaction_cancel(regdb) != 0) {
-               smb_panic("regdb_store_keys: transaction_cancel failed\n");
+       werr = regdb_fetch_keys_internal(db, key, old_subkeys);
+       if (!W_ERROR_IS_OK(werr) &&
+           !W_ERROR_EQUAL(werr, WERR_NOT_FOUND))
+       {
+               goto done;
        }
 
-fail:
+       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 == num_subkeys) {
+                       /*
+                        * Nothing changed, no point to even start a tdb
+                        * transaction
+                        */
+
+                       ret = true;
+                       goto done;
+               }
+       }
+
+       TALLOC_FREE(old_subkeys);
+
+       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 false;
+       return ret;
 }
 
+bool regdb_store_keys(const char *key, struct regsubkey_ctr *ctr)
+{
+       return regdb_store_keys_internal(regdb, key, ctr);
+}
 
-static TDB_DATA regdb_fetch_key_internal(TALLOC_CTX *mem_ctx, const char *key)
+/**
+ * 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)));
+       }
+
+done:
+       talloc_free(mem_ctx);
+       return werror_to_ntstatus(werr);
+}
+
+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;
+
+       if (!regdb_key_is_base_key(key) && !regdb_key_exists(regdb, key)) {
+               werr = WERR_NOT_FOUND;
+               goto done;
+       }
+
+       werr = regsubkey_ctr_init(mem_ctx, &subkeys);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+       werr = regdb_fetch_keys_internal(regdb, key, subkeys);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+       if (regsubkey_ctr_key_exists(subkeys, subkey)) {
+               werr = WERR_OK;
+               goto done;
+       }
+
+       talloc_free(subkeys);
+
+       create_ctx.key = key;
+       create_ctx.subkey = subkey;
+
+       werr = ntstatus_to_werror(dbwrap_trans_do(regdb,
+                                                 regdb_create_subkey_action,
+                                                 &create_ctx));
+
+done:
+       talloc_free(mem_ctx);
+       return werr;
+}
+
+/**
+ * create a subkey of a given key
+ */
+
+struct regdb_delete_subkey_context {
+       const char *key;
+       const char *subkey;
+       const char *path;
+};
+
+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();
+
+       delete_ctx = (struct regdb_delete_subkey_context *)private_data;
+
+       werr = regdb_delete_key_lists(db, delete_ctx->path);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+       werr = regsubkey_ctr_init(mem_ctx, &subkeys);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+       werr = regdb_fetch_keys_internal(db, delete_ctx->key, subkeys);
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+       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)));
+       }
+
+done:
+       talloc_free(mem_ctx);
+       return werror_to_ntstatus(werr);
+}
+
+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();
+
+       if (!regdb_key_is_base_key(key) && !regdb_key_exists(regdb, key)) {
+               werr = WERR_NOT_FOUND;
+               goto done;
+       }
+
+       path = talloc_asprintf(mem_ctx, "%s/%s", key, subkey);
+       if (path == NULL) {
+               werr = WERR_NOMEM;
+               goto done;
+       }
+
+       if (!regdb_key_exists(regdb, path)) {
+               werr = WERR_OK;
+               goto done;
+       }
+
+       delete_ctx.key = key;
+       delete_ctx.subkey = subkey;
+       delete_ctx.path = path;
+
+       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(struct db_context *db,
+                                        TALLOC_CTX *mem_ctx, const char *key)
 {
        char *path = NULL;
        TDB_DATA data;
@@ -843,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;
@@ -900,7 +1177,7 @@ done:
  * 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_internal and
+ * The sorted subkey record is deleted in regdb_store_keys_internal2 and
  * recreated on demand.
  */
 
@@ -909,71 +1186,113 @@ static int cmp_keynames(const void *p1, const void *p2)
        return StrCaseCmp(*((char **)p1), *((char **)p2));
 }
 
-static bool create_sorted_subkeys(const char *key, const char *sorted_keyname)
+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;
-       REGSUBKEY_CTR *ctr;
-       bool result = false;
+       struct regsubkey_ctr *ctr;
        NTSTATUS status;
        char *buf;
        char *p;
-       int i, res;
+       int i;
        size_t len;
+       int num_subkeys;
+       struct create_sorted_subkeys_context *sorted_ctx;
+
+       sorted_ctx = (struct create_sorted_subkeys_context *)private_data;
 
-       ctr = talloc(talloc_tos(), REGSUBKEY_CTR);
-       if (ctr == NULL) {
-               return false;
+       /*
+        * 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;
        }
 
-       res = regdb_fetch_keys(key, ctr);
-       if (res == -1) {
-               goto fail;
+       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;
        }
 
-       sorted_subkeys = talloc_array(ctr, char *, ctr->num_subkeys);
+       num_subkeys = regsubkey_ctr_numkeys(ctr);
+       sorted_subkeys = talloc_array(ctr, char *, num_subkeys);
        if (sorted_subkeys == NULL) {
-               goto fail;
+               /* don't treat this as an error */
+               goto done;
        }
 
-       len = 4 + 4*ctr->num_subkeys;
+       len = 4 + 4*num_subkeys;
 
-       for (i = 0; i<ctr->num_subkeys; i++) {
+       for (i = 0; i < num_subkeys; i++) {
                sorted_subkeys[i] = talloc_strdup_upper(sorted_subkeys,
-                                                       ctr->subkeys[i]);
+                                       regsubkey_ctr_specific_key(ctr, i));
                if (sorted_subkeys[i] == NULL) {
-                       goto fail;
+                       /* don't treat this as an error */
+                       goto done;
                }
                len += strlen(sorted_subkeys[i])+1;
        }
 
-       qsort(sorted_subkeys, ctr->num_subkeys, sizeof(char *), cmp_keynames);
+       qsort(sorted_subkeys, num_subkeys, sizeof(char *), cmp_keynames);
 
        buf = talloc_array(ctr, char, len);
        if (buf == NULL) {
-               goto fail;
+               /* don't treat this as an error */
+               goto done;
        }
-       p = buf + 4 + 4*ctr->num_subkeys;
+       p = buf + 4 + 4*num_subkeys;
 
-       SIVAL(buf, 0, ctr->num_subkeys);
+       SIVAL(buf, 0, num_subkeys);
 
-       for (i=0; i<ctr->num_subkeys; i++) {
+       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_trans_store_bystring(
-               regdb, sorted_keyname, make_tdb_data((uint8_t *)buf, len),
+       status = dbwrap_store_bystring(
+               db, sorted_ctx->sorted_keyname, make_tdb_data((uint8_t *)buf,
+               len),
                TDB_REPLACE);
-       if (!NT_STATUS_IS_OK(status)) {
-               goto fail;
-       }
 
-       result = true;
- fail:
-       TALLOC_FREE(ctr);
-       return result;
+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 {
@@ -1019,7 +1338,8 @@ static int parent_subkey_scanner(TDB_DATA key, TDB_DATA data,
        return 0;
 }
 
-static bool scan_parent_subkeys(const char *parent, const char *name)
+static bool scan_parent_subkeys(struct db_context *db, const char *parent,
+                               const char *name)
 {
        char *path = NULL;
        char *key = NULL;
@@ -1046,8 +1366,8 @@ static bool scan_parent_subkeys(const char *parent, const char *name)
        }
        state.scanned = false;
 
-       res = regdb->parse_record(regdb, string_term_tdb_data(key),
-                                 parent_subkey_scanner, &state);
+       res = db->parse_record(db, string_term_tdb_data(key),
+                              parent_subkey_scanner, &state);
 
        if (state.scanned) {
                result = state.found;
@@ -1055,8 +1375,8 @@ static bool scan_parent_subkeys(const char *parent, const char *name)
                if (!create_sorted_subkeys(path, key)) {
                        goto fail;
                }
-               res = regdb->parse_record(regdb, string_term_tdb_data(key),
-                                         parent_subkey_scanner, &state);
+               res = db->parse_record(db, string_term_tdb_data(key),
+                                      parent_subkey_scanner, &state);
                if ((res == 0) && (state.scanned)) {
                        result = state.found;
                }
@@ -1076,7 +1396,7 @@ static bool scan_parent_subkeys(const char *parent, const char *name)
  * 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;
@@ -1100,11 +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 {
                *p = '\0';
-               ret = scan_parent_subkeys(path, p+1);
+               ret = scan_parent_subkeys(db, path, p+1);
        }
 
 done:
@@ -1118,31 +1438,36 @@ 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)
 {
-       uint32 num_items;
+       WERROR werr;
+       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)) {
+       frame = talloc_stackframe();
+
+       if (!regdb_key_exists(db, key)) {
+               DEBUG(10, ("key [%s] not found\n", key));
+               werr = WERR_NOT_FOUND;
                goto done;
        }
 
-       ctr->seqnum = regdb_get_seqnum();
+       werr = regsubkey_ctr_set_seqnum(ctr, db->get_seqnum(db));
+       W_ERROR_NOT_OK_GOTO_DONE(werr);
 
-       value = regdb_fetch_key_internal(frame, key);
+       value = regdb_fetch_key_internal(db, frame, key);
 
        if (value.dptr == NULL) {
                DEBUG(10, ("regdb_fetch_keys: no subkeys found for key [%s]\n",
                           key));
-               ret = 0;
                goto done;
        }
 
@@ -1150,52 +1475,44 @@ int regdb_fetch_keys(const char *key, REGSUBKEY_CTR *ctr)
        buflen = value.dsize;
        len = tdb_unpack( buf, buflen, "d", &num_items);
 
-       /*
-        * The following code breaks the abstraction that reg_objects.c sets
-        * up with regsubkey_ctr_addkey(). But if we use that with the current
-        * data structure of ctr->subkeys being an unsorted array, we end up
-        * with an O(n^2) algorithm for retrieving keys from the tdb
-        * file. This is pretty pointless, as we have to trust the data
-        * structure on disk not to have duplicates anyway. The alternative to
-        * breaking this abstraction would be to set up a more sophisticated
-        * data structure in REGSUBKEY_CTR.
-        *
-        * This makes "net conf list" for a registry with >1000 shares
-        * actually usable :-)
-        */
-
-       ctr->subkeys = talloc_array(ctr, char *, num_items);
-       if (ctr->subkeys == NULL) {
-               DEBUG(5, ("regdb_fetch_keys: could not allocate subkeys\n"));
-               goto done;
-       }
-       ctr->num_subkeys = 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);
-               ctr->subkeys[i] = talloc_strdup(ctr->subkeys, subkeyname);
-               if (ctr->subkeys[i] == NULL) {
-                       DEBUG(5, ("regdb_fetch_keys: could not allocate "
-                                 "subkeyname\n"));
-                       TALLOC_FREE(ctr->subkeys);
-                       ctr->num_subkeys = 0;
+               werr = regsubkey_ctr_addkey(ctr, subkeyname);
+               if (!W_ERROR_IS_OK(werr)) {
+                       DEBUG(5, ("regdb_fetch_keys: regsubkey_ctr_addkey "
+                                 "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;
 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;
@@ -1240,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 )
@@ -1275,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();
@@ -1284,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;
        }
 
@@ -1293,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 */
@@ -1310,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;
@@ -1321,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;
        }
 
@@ -1349,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)
@@ -1359,7 +1683,7 @@ bool regdb_store_values( const char *key, REGVAL_CTR *values )
                goto done;
        }
 
-       status = dbwrap_trans_store_bystring(regdb, keystr, data, TDB_REPLACE);
+       status = dbwrap_trans_store_bystring(db, keystr, data, TDB_REPLACE);
 
        result = NT_STATUS_IS_OK(status);
 
@@ -1368,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)
 {
@@ -1379,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;
        }
@@ -1416,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;
        }
@@ -1433,39 +1761,30 @@ static WERROR regdb_set_secdesc(const char *key,
 
        if (secdesc == NULL) {
                /* assuming a delete */
-               status = dbwrap_trans_delete_bystring(regdb, 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_bystring(regdb, 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);
 }
@@ -1474,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,