r2518: Some long overdue changes:

 - Samba4-style code in lib/registry (struct registry_key instead of REG_KEY, etc)
 - Use hives (like Windows has drives) instead of one root key (like a Unix FS)
 - usability fixes in the GTK utilities (autodetect the username,
	enable/disable options, etc)
 - fix gwsam compile
 - several bugfixes in the registry rpc code
 - do charset conversion in nt4 registry backend
(This used to be commit 2762ed3b9bf1d67dd54d63e02cddbfd71ea89892)

16 files changed, 795 insertions, 1254 deletions

diff --git a/source4/lib/registry/TODO b/source4/lib/registry/TODO
index 695f786b69..1dea9d2650 100644
--- a/source4/lib/registry/TODO
+++ b/source4/lib/registry/TODO
@@ -1,4 +1,3 @@
-- support subtrees
 - ..\..\, \bla\blie support in regshell
 - finish rpc_server
 
diff --git a/source4/lib/registry/common/reg_interface.c b/source4/lib/registry/common/reg_interface.c
index f0a6807558..ec6188be71 100644
--- a/source4/lib/registry/common/reg_interface.c
+++ b/source4/lib/registry/common/reg_interface.c
@@ -19,7 +19,6 @@
 */
 
 #include "includes.h"
-#include "lib/registry/common/registry.h"
 
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_REGISTRY
@@ -29,10 +28,12 @@ static struct reg_init_function_entry *backends = NULL;
 
 static struct reg_init_function_entry *reg_find_backend_entry(const char *name);
 
+#define reg_make_path(mem_ctx, parent, name) (((parent)->hive->root == (parent))?talloc_strdup(mem_ctx, name):talloc_asprintf(mem_ctx, "%s\\%s", parent->path, name))
+
 /* Register new backend */
 NTSTATUS registry_register(const void *_function)  
 {
-	const struct registry_ops *functions = _function;
+	const struct registry_operations *functions = _function;
 	struct reg_init_function_entry *entry = backends;
 
 	if (!functions || !functions->name) {
@@ -91,90 +92,157 @@ BOOL reg_has_backend(const char *backend)
 	return reg_find_backend_entry(backend) != NULL?True:False;
 }
 
-/* Open a registry file/host/etc */
-WERROR reg_open(const char *backend, const char *location, const char *credentials, REG_HANDLE **h)
+WERROR reg_create(struct registry_context **_ret)
+{
+	TALLOC_CTX *mem_ctx;
+	struct registry_context *ret;
+	mem_ctx = talloc_init("registry handle");
+	ret = talloc(mem_ctx, sizeof(struct registry_context));
+	ret->mem_ctx = mem_ctx;
+	ZERO_STRUCTP(ret);	
+	*_ret = ret;
+	return WERR_OK;
+}
+
+WERROR reg_list_available_hives(TALLOC_CTX *mem_ctx, const char *backend, const char *location, const char *credentials, char ***hives)
 {
 	struct reg_init_function_entry *entry;
+	
+	entry = reg_find_backend_entry(backend);
+	
+	if (!entry) {
+		DEBUG(0, ("No such registry backend '%s' loaded!\n", backend));
+		return WERR_GENERAL_FAILURE;
+	}
+
+	if(!entry->functions->list_available_hives) {
+		return WERR_NOT_SUPPORTED;
+	}
+
+	return entry->functions->list_available_hives(mem_ctx, location, credentials, hives);
+}
+
+WERROR reg_open(struct registry_context **ret, const char *backend, const char *location, const char *credentials)
+{
+	WERROR error = reg_create(ret);
+	char **hives;
+	int i;
+	TALLOC_CTX *mem_ctx = talloc_init("reg_open");
+
+	if(!W_ERROR_IS_OK(error)) return error;
+
+	error = reg_list_available_hives(mem_ctx, backend, location, credentials, &hives);
+
+	if(W_ERROR_EQUAL(error, WERR_NOT_SUPPORTED)) {
+		return reg_import_hive(*ret, backend, location, credentials, NULL);
+	}
+	   
+	if(!W_ERROR_IS_OK(error)) return error;
+
+	for(i = 0; hives[i]; i++)
+	{
+		error = reg_import_hive(*ret, backend, location, credentials, hives[i]);
+		if(!W_ERROR_IS_OK(error)) return error;
+		(*ret)->hives[i]->name = talloc_strdup((*ret)->mem_ctx, hives[i]);
+	}
+
+	return WERR_OK;
+}
+
+/* Open a registry file/host/etc */
+WERROR reg_import_hive(struct registry_context *h, const char *backend, const char *location, const char *credentials, const char *hivename)
+{
+	struct registry_hive *ret;
 	TALLOC_CTX *mem_ctx;
-	REG_HANDLE *ret;
+	struct reg_init_function_entry *entry;
 	WERROR werr;
-	
+
 	entry = reg_find_backend_entry(backend);
 	
 	if (!entry) {
 		DEBUG(0, ("No such registry backend '%s' loaded!\n", backend));
 		return WERR_GENERAL_FAILURE;
 	}
+
+	if(!entry->functions->open_hive) {
+		return WERR_NOT_SUPPORTED;
+	}
 	
-	mem_ctx = talloc_init(backend);
-	ret = talloc(mem_ctx, sizeof(REG_HANDLE));
-	ZERO_STRUCTP(ret);	
+	
+	mem_ctx = h->mem_ctx;
+	ret = talloc_p(mem_ctx, struct registry_hive);
 	ret->location = location?talloc_strdup(mem_ctx, location):NULL;
+	ret->backend_hivename = hivename?talloc_strdup(mem_ctx, hivename):NULL;
 	ret->credentials = credentials?talloc_strdup(mem_ctx, credentials):NULL;
 	ret->functions = entry->functions;
 	ret->backend_data = NULL;
-	ret->mem_ctx = mem_ctx;
-	*h = ret;
+	ret->reg_ctx = h;
 
-	if(!entry->functions->open_registry) {
-		return WERR_OK;
-	}
+	werr = entry->functions->open_hive(mem_ctx, ret, &ret->root);
+
+	if(!W_ERROR_IS_OK(werr)) return werr;
 	
-	werr = entry->functions->open_registry(ret, location, credentials);
+	if(!ret->root) return WERR_GENERAL_FAILURE;
 
-	if(W_ERROR_IS_OK(werr)) 
-		return WERR_OK;
+	ret->root->hive = ret;
+	ret->root->name = NULL;
+	ret->root->path = "";
 
-	talloc_destroy(mem_ctx);
-	return werr;
+	/* Add hive to context */
+	h->num_hives++;
+	h->hives = talloc_realloc_p(h->hives, struct registry_hive *, h->num_hives);
+	h->hives[h->num_hives-1] = ret;
+
+	return WERR_OK;
 }
 
 /* Open a key by name (including the hive name!) */
-WERROR reg_open_key_abs(REG_HANDLE *handle, const char *name, REG_KEY **result)
+WERROR reg_open_key_abs(TALLOC_CTX *mem_ctx, struct registry_context *handle, const char *name, struct registry_key **result)
 {
-	REG_KEY *hive;
+	struct registry_key *hive;
 	WERROR error;
-	int i, hivelength;
+	int hivelength;
+	char *hivename;
 
 	if(strchr(name, '\\')) hivelength = strchr(name, '\\')-name;
 	else hivelength = strlen(name);
 
-	for(i = 0; W_ERROR_IS_OK(error); i++) {
-		error = reg_get_hive(handle, i, &hive);
-		if(W_ERROR_IS_OK(error) && !strncmp(reg_key_name(hive), name, hivelength)) {
-			return reg_open_key(hive, name, result);
-		}
+	hivename = strndup(name, hivelength);
+	error = reg_get_hive(handle, hivename, &hive);
+	SAFE_FREE(hivename);
+
+	if(!W_ERROR_IS_OK(error)) {
+		return error;
 	}
 
-	return error;
+	return reg_open_key(mem_ctx, hive, name, result);
 }
 
 /* Open a key 
  * First tries to use the open_key function from the backend
  * then falls back to get_subkey_by_name and later get_subkey_by_index 
  */
-WERROR reg_open_key(REG_KEY *parent, const char *name, REG_KEY **result)
+WERROR reg_open_key(TALLOC_CTX *mem_ctx, struct registry_key *parent, const char *name, struct registry_key **result)
 {
 	char *fullname;
 	WERROR error;
-	TALLOC_CTX *mem_ctx;
 
 	if(!parent) {
 		DEBUG(0, ("Invalid parent key specified"));
 		return WERR_INVALID_PARAM;
 	}
 
-	if(!parent->handle->functions->open_key && 
-	   (parent->handle->functions->get_subkey_by_name || 
-	   parent->handle->functions->get_subkey_by_index)) {
+	if(!parent->hive->functions->open_key && 
+	   (parent->hive->functions->get_subkey_by_name || 
+	   parent->hive->functions->get_subkey_by_index)) {
 		char *orig = strdup(name), 
 			 *curbegin = orig, 
 			 *curend = strchr(orig, '\\');
-		REG_KEY *curkey = parent;
+		struct registry_key *curkey = parent;
 
 		while(curbegin && *curbegin) {
 			if(curend)*curend = '\0';
-			error = reg_key_get_subkey_by_name(curkey, curbegin, result);
+			error = reg_key_get_subkey_by_name(mem_ctx, curkey, curbegin, &curkey);
 			if(!W_ERROR_IS_OK(error)) {
 				SAFE_FREE(orig);
 				return error;
@@ -184,94 +252,63 @@ WERROR reg_open_key(REG_KEY *parent, const char *name, REG_KEY **result)
 			curend = strchr(curbegin, '\\');
 		}
 		SAFE_FREE(orig);
-		
+
 		*result = curkey;
+		
 		return WERR_OK;
 	}
 
-	if(!parent->handle->functions->open_key) {
+	if(!parent->hive->functions->open_key) {
 		DEBUG(0, ("Registry backend doesn't have get_subkey_by_name nor open_key!\n"));
 		return WERR_NOT_SUPPORTED;
 	}
 
-	mem_ctx = talloc_init("mem_ctx");
+	fullname = reg_make_path(mem_ctx, parent, name);
 
-	fullname = talloc_asprintf(mem_ctx, "%s%s%s", 
-						reg_key_get_path(parent), 
-						strlen(reg_key_get_path(parent))?"\\":"", 
-						name);
+	error = parent->hive->functions->open_key(mem_ctx, parent->hive, fullname, result);
 
-	error = parent->handle->functions->open_key(parent->handle, 
-												parent->hive, fullname, result);
-
-	if(!W_ERROR_IS_OK(error)) {
-		talloc_destroy(mem_ctx);
-		return error;
-	}
+	if(!W_ERROR_IS_OK(error)) return error;
 		
-	(*result)->handle = parent->handle;
-	(*result)->path = talloc_asprintf((*result)->mem_ctx, "%s\\%s", 
-								 reg_key_get_path_abs(parent), (*result)->name);
 	(*result)->hive = parent->hive;
-	talloc_steal((*result)->mem_ctx, fullname);
-
-	talloc_destroy(mem_ctx);
+	(*result)->path = fullname;
+	(*result)->hive = parent->hive;
 
 	return WERR_OK;
 }
 
-WERROR reg_key_get_value_by_index(REG_KEY *key, int idx, REG_VAL **val)
+WERROR reg_key_get_value_by_index(TALLOC_CTX *mem_ctx, struct registry_key *key, int idx, struct registry_value **val)
 {
 	if(!key) return WERR_INVALID_PARAM;
 
-	if(key->handle->functions->get_value_by_index) {
-		WERROR status = key->handle->functions->get_value_by_index(key, idx, val);
+	if(key->hive->functions->get_value_by_index) {
+		WERROR status = key->hive->functions->get_value_by_index(mem_ctx, key, idx, val);
 		if(!W_ERROR_IS_OK(status)) 
 			return status;
-
-	} else if(key->handle->functions->fetch_values) {
-		if(!key->cache_values)
-			key->handle->functions->fetch_values(key, 
-								&key->cache_values_count, &key->cache_values);
-		
-		if(idx < key->cache_values_count && idx >= 0) {
-			*val = reg_val_dup(key->cache_values[idx]);
-		} else {
-			return WERR_NO_MORE_ITEMS;
-		}
 	} else {
 		return WERR_NOT_SUPPORTED;
 	}
 	
 	(*val)->parent = key;
-	(*val)->handle = key->handle;
+	(*val)->hive = key->hive;
 	return WERR_OK;
 }
 
-WERROR reg_key_num_subkeys(REG_KEY *key, int *count)
+WERROR reg_key_num_subkeys(struct registry_key *key, int *count)
 {
 	if(!key) return WERR_INVALID_PARAM;
 	
-	if(key->handle->functions->num_subkeys) {
-		return key->handle->functions->num_subkeys(key, count);
+	if(key->hive->functions->num_subkeys) {
+		return key->hive->functions->num_subkeys(key, count);
 	}
 
-	if(key->handle->functions->fetch_subkeys) {
-		if(!key->cache_subkeys) 
-			key->handle->functions->fetch_subkeys(key, 
-							&key->cache_subkeys_count, &key->cache_subkeys);
-
-		*count = key->cache_subkeys_count;
-		return WERR_OK;
-	}
-
-	if(key->handle->functions->get_subkey_by_index) {
+	if(key->hive->functions->get_subkey_by_index) {
 		int i;
 		WERROR error;
-		REG_KEY *dest;
-		for(i = 0; W_ERROR_IS_OK(error = key->handle->functions->get_subkey_by_index(key, i, &dest)); i++) {
-			reg_key_free(dest);
-		}
+		struct registry_key *dest;
+		TALLOC_CTX *mem_ctx = talloc_init("num_subkeys");
+		
+		for(i = 0; W_ERROR_IS_OK(error = key->hive->functions->get_subkey_by_index(mem_ctx, key, i, &dest)); i++);
+		talloc_destroy(mem_ctx);
 
 		*count = i;
 		if(W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) return WERR_OK;
@@ -281,74 +318,49 @@ WERROR reg_key_num_subkeys(REG_KEY *key, int *count)
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR reg_key_num_values(REG_KEY *key, int *count)
+WERROR reg_key_num_values(struct registry_key *key, int *count)
 {
 	
 	if(!key) return WERR_INVALID_PARAM;
 	
-	if(!key->handle->functions->num_values) {
-		if(!key->handle->functions->fetch_values) {
-			DEBUG(1, ("Backend '%s' doesn't support enumerating values\n", key->handle->functions->name));
-			return WERR_NOT_SUPPORTED;
-		}
-		
-		if(!key->cache_values) 
-			key->handle->functions->fetch_values(key, &key->cache_values_count, &key->cache_values);
-
-		*count = key->cache_values_count;
-		return WERR_OK;
-	}
-
-	
-	return key->handle->functions->num_values(key, count);
+	return key->hive->functions->num_values(key, count);
 }
 
-WERROR reg_key_get_subkey_by_index(REG_KEY *key, int idx, REG_KEY **subkey)
+WERROR reg_key_get_subkey_by_index(TALLOC_CTX *mem_ctx, struct registry_key *key, int idx, struct registry_key **subkey)
 {
 	if(!key) return WERR_INVALID_PARAM;
 
-	if(key->handle->functions->get_subkey_by_index) {
-		WERROR status = key->handle->functions->get_subkey_by_index(key, idx, subkey);
+	if(key->hive->functions->get_subkey_by_index) {
+		WERROR status = key->hive->functions->get_subkey_by_index(mem_ctx, key, idx, subkey);
 		if(!NT_STATUS_IS_OK(status)) return status;
-	} else if(key->handle->functions->fetch_subkeys) {
-		if(!key->cache_subkeys) 
-			key->handle->functions->fetch_subkeys(key, 
-								&key->cache_subkeys_count, &key->cache_subkeys);
-
-		if(idx < key->cache_subkeys_count) {
-			*subkey = reg_key_dup(key->cache_subkeys[idx]);
-		} else {
-			return WERR_NO_MORE_ITEMS;
-		}
 	} else {
 		return WERR_NOT_SUPPORTED;
 	}
 
-	(*subkey)->path = talloc_asprintf((*subkey)->mem_ctx, "%s\\%s", 
-									reg_key_get_path_abs(key), (*subkey)->name);
-	(*subkey)->handle = key->handle;
-	(*subkey)->hive = key->hive;
-
+	if(key->hive->root == key) 
+		(*subkey)->path = talloc_strdup(mem_ctx, (*subkey)->name);
+	else 
+		(*subkey)->path = talloc_asprintf(mem_ctx, "%s\\%s", key->path, (*subkey)->name);
 
+	(*subkey)->hive = key->hive;
 	return WERR_OK;;
 }
 
-WERROR reg_key_get_subkey_by_name(REG_KEY *key, const char *name, REG_KEY **subkey)
+WERROR reg_key_get_subkey_by_name(TALLOC_CTX *mem_ctx, struct registry_key *key, const char *name, struct registry_key **subkey)
 {
 	int i;
 	WERROR error = WERR_OK;
 
 	if(!key) return WERR_INVALID_PARAM;
 
-	if(key->handle->functions->get_subkey_by_name) {
-		error = key->handle->functions->get_subkey_by_name(key,name,subkey);
-	} else if(key->handle->functions->get_subkey_by_index || key->handle->functions->fetch_subkeys) {
+	if(key->hive->functions->get_subkey_by_name) {
+		error = key->hive->functions->get_subkey_by_name(mem_ctx, key,name,subkey);
+	} else if(key->hive->functions->get_subkey_by_index) {
 		for(i = 0; W_ERROR_IS_OK(error); i++) {
-			error = reg_key_get_subkey_by_index(key, i, subkey);
+			error = reg_key_get_subkey_by_index(mem_ctx, key, i, subkey);
 			if(W_ERROR_IS_OK(error) && !strcmp((*subkey)->name, name)) {
 				return error;
 			}
-			reg_key_free(*subkey);
 		}
 	} else {
 		return WERR_NOT_SUPPORTED;
@@ -356,29 +368,27 @@ WERROR reg_key_get_subkey_by_name(REG_KEY *key, const char *name, REG_KEY **subk
 
 	if(!W_ERROR_IS_OK(error)) return error;
 
-	(*subkey)->path = talloc_asprintf((*subkey)->mem_ctx, "%s\\%s", reg_key_get_path_abs(key), (*subkey)->name);
-	(*subkey)->handle = key->handle;
+	(*subkey)->path = talloc_asprintf(mem_ctx, "%s\\%s", key->path, (*subkey)->name);
 	(*subkey)->hive = key->hive;
 
 	return WERR_OK; 
 }
 
-WERROR reg_key_get_value_by_name(REG_KEY *key, const char *name, REG_VAL **val)
+WERROR reg_key_get_value_by_name(TALLOC_CTX *mem_ctx, struct registry_key *key, const char *name, struct registry_value **val)
 {
 	int i;
 	WERROR error = WERR_OK;
 
 	if(!key) return WERR_INVALID_PARAM;
 
-	if(key->handle->functions->get_value_by_name) {
-		error = key->handle->functions->get_value_by_name(key,name, val);
+	if(key->hive->functions->get_value_by_name) {
+		error = key->hive->functions->get_value_by_name(mem_ctx, key,name, val);
 	} else {
 		for(i = 0; W_ERROR_IS_OK(error); i++) {
-			error = reg_key_get_value_by_index(key, i, val);
+			error = reg_key_get_value_by_index(mem_ctx, key, i, val);
 			if(W_ERROR_IS_OK(error) && StrCaseCmp((*val)->name, name)) {
 				break;
 			}
-			reg_val_free(*val);
 		}
 	}
 
@@ -386,52 +396,49 @@ WERROR reg_key_get_value_by_name(REG_KEY *key, const char *name, REG_VAL **val)
 		return error;
 	
 	(*val)->parent = key;
-	(*val)->handle = key->handle;
+	(*val)->hive = key->hive;
 	
 	return WERR_OK;
 }
 
-WERROR reg_key_del(REG_KEY *key)
+WERROR reg_key_del(struct registry_key *key)
 {
 	WERROR error;
 	if(!key) return WERR_INVALID_PARAM;
 	
 	
-	if(!key->handle->functions->del_key)
+	if(!key->hive->functions->del_key)
 		return WERR_NOT_SUPPORTED;
 	
-	error = key->handle->functions->del_key(key);
+	error = key->hive->functions->del_key(key);
 	if(!W_ERROR_IS_OK(error)) return error;
 
-	/* Invalidate cache */
-	key->cache_subkeys = NULL;
-	key->cache_subkeys_count = 0;
 	return WERR_OK;
 }
 
-WERROR reg_sync(REG_KEY *h, const char *location)
-{
-	if(!h->handle->functions->sync_key)
-		return WERR_OK;
-
-	return h->handle->functions->sync_key(h, location);
-}
-
-WERROR reg_key_del_recursive(REG_KEY *key)
+WERROR reg_key_del_recursive(struct registry_key *key)
 {
 	WERROR error = WERR_OK;
 	int i;
+
+	TALLOC_CTX *mem_ctx = talloc_init("del_recursive");
 	
 	/* Delete all values for specified key */
 	for(i = 0; W_ERROR_IS_OK(error); i++) {
-		REG_VAL *val;
-		error = reg_key_get_value_by_index(key, i, &val);
+		struct registry_value *val;
+		error = reg_key_get_value_by_index(mem_ctx, key, i, &val);
 		if(!W_ERROR_IS_OK(error) && !W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) 
+		{
+			talloc_destroy(mem_ctx);			
 			return error;
+		}
 
 		if(W_ERROR_IS_OK(error)) {
-			error = reg_val_del(val);
-			if(!W_ERROR_IS_OK(error)) return error;
+			error = reg_del_value(val);
+			if(!W_ERROR_IS_OK(error)) {
+				talloc_destroy(mem_ctx);
+				return error;
+			}
 		}
 	}
 
@@ -439,204 +446,150 @@ WERROR reg_key_del_recursive(REG_KEY *key)
 
 	/* Delete all keys below this one */
 	for(i = 0; W_ERROR_IS_OK(error); i++) {
-		REG_KEY *subkey;
+		struct registry_key *subkey;
 
-		error = reg_key_get_subkey_by_index(key, i, &subkey);
-		if(!W_ERROR_IS_OK(error)) return error;
+		error = reg_key_get_subkey_by_index(mem_ctx, key, i, &subkey);
+		if(!W_ERROR_IS_OK(error)) { talloc_destroy(mem_ctx); return error; }
 
 		error = reg_key_del_recursive(subkey);
-		if(!W_ERROR_IS_OK(error)) return error;
+		if(!W_ERROR_IS_OK(error)) { talloc_destroy(mem_ctx); return error; }
 	}
 
+	talloc_destroy(mem_ctx);
 	return reg_key_del(key);
 }
 
-WERROR reg_val_del(REG_VAL *val)
-{
-	WERROR error;
-	if (!val) return WERR_INVALID_PARAM;
-
-	if (!val->handle->functions->del_value) {
-		DEBUG(1, ("Backend '%s' doesn't support method del_value\n", val->handle->functions->name));
-		return WERR_NOT_SUPPORTED;
-	}
-	
-	error = val->handle->functions->del_value(val);
-
-	if(!W_ERROR_IS_OK(error)) return error;
-
-	val->parent->cache_values = NULL;
-	val->parent->cache_values_count = 0;
-
-	return WERR_OK;
-}
-
-WERROR reg_key_add_name_recursive_abs(REG_HANDLE *handle, const char *name)
+WERROR reg_key_add_name_recursive_abs(struct registry_context *handle, const char *name)
 {
-	REG_KEY *hive;
+	struct registry_key *hive;
 	WERROR error;
-	int i, hivelength;
+	int hivelength;
+	char *hivename;
 
 	if(strchr(name, '\\')) hivelength = strchr(name, '\\')-name;
 	else hivelength = strlen(name);
 
-	for(i = 0; W_ERROR_IS_OK(error); i++) {
-		error = reg_get_hive(handle, i, &hive);
-		if(W_ERROR_IS_OK(error) && !strncmp(reg_key_name(hive), name, hivelength)) {
-			return reg_key_add_name_recursive(hive, name);
-		}
-	}
+	hivename = strndup(name, hivelength);
+	error = reg_get_hive(handle, hivename, &hive);
+	SAFE_FREE(hivename);
 
-	return error;
+	if(!W_ERROR_IS_OK(error)) return error;
+
+	return reg_key_add_name_recursive(hive, name);
 }
 
-WERROR reg_key_add_name_recursive(REG_KEY *parent, const char *path)
+WERROR reg_key_add_name_recursive(struct registry_key *parent, const char *path)
 {
-	REG_KEY *cur, *prevcur = parent;
-	WERROR error;
-	/* FIXME: we should never write to a 'const char *' !!! --metze */
-	char *begin = (char *)path, *end;
+	struct registry_key *cur, *prevcur = parent;
+	WERROR error = WERR_OK;
+	char *dup, *begin, *end;
+	TALLOC_CTX *mem_ctx = talloc_init("add_recursive");
+
+	begin = dup = strdup(path);
 
 	while(1) { 
 		end = strchr(begin, '\\');
 		if(end) *end = '\0';
 		
-		error = reg_key_get_subkey_by_name(prevcur, begin, &cur);
+		error = reg_key_get_subkey_by_name(mem_ctx, prevcur, begin, &cur);
 
 		/* Key is not there, add it */
 		if(W_ERROR_EQUAL(error, WERR_DEST_NOT_FOUND)) {
-			error = reg_key_add_name(prevcur, begin, 0, NULL, &cur);
-			if(!W_ERROR_IS_OK(error)) return error;
+			error = reg_key_add_name(mem_ctx, prevcur, begin, 0, NULL, &cur);
+			if(!W_ERROR_IS_OK(error)) break;
 		}
 
 		if(!W_ERROR_IS_OK(error)) {
 			if(end) *end = '\\';
-			return error;
+			break;
 		}
 		
-		if(!end) break;
+		if(!end) { 
+			error = WERR_OK; 
+			break; 
+		}
+
 		*end = '\\';
 		begin = end+1;
 		prevcur = cur;
 	}
-	return WERR_OK;
+	SAFE_FREE(dup);
+	talloc_destroy(mem_ctx);
+	return error;
 }
 
-WERROR reg_key_add_name(REG_KEY *parent, const char *name, uint32_t access_mask, SEC_DESC *desc, REG_KEY **newkey)
+WERROR reg_key_add_name(TALLOC_CTX *mem_ctx, struct registry_key *parent, const char *name, uint32_t access_mask, SEC_DESC *desc, struct registry_key **newkey)
 {
 	WERROR error;
 	
 	if (!parent) return WERR_INVALID_PARAM;
 	
-	if (!parent->handle->functions->add_key) {
-		DEBUG(1, ("Backend '%s' doesn't support method add_key\n", parent->handle->functions->name));
+	if (!parent->hive->functions->add_key) {
+		DEBUG(1, ("Backend '%s' doesn't support method add_key\n", parent->hive->functions->name));
 		return WERR_NOT_SUPPORTED;
 	}
 
-	error = parent->handle->functions->add_key(parent, name, access_mask, desc, newkey);
+	error = parent->hive->functions->add_key(mem_ctx, parent, name, access_mask, desc, newkey);
 
 	if(!W_ERROR_IS_OK(error)) return error;
 	
-	(*newkey)->handle = parent->handle;
-	(*newkey)->backend_data = talloc_asprintf((*newkey)->mem_ctx, "%s\\%s", reg_key_get_path(parent), name);
+	(*newkey)->hive = parent->hive;
+	(*newkey)->backend_data = talloc_asprintf(mem_ctx, "%s\\%s", parent->path, name);
 
-	parent->cache_subkeys = NULL;
-	parent->cache_subkeys_count = 0;
 	return WERR_OK;
 }
 
-WERROR reg_val_update(REG_VAL *val, int type, void *data, int len)
+WERROR reg_val_set(struct registry_key *key, const char *value, int type, void *data, int len)
 {
-	WERROR error;
-	
-	/* A 'real' update function has preference */
-	if (val->handle->functions->update_value) 
-		return val->handle->functions->update_value(val, type, data, len);
-
-	/* Otherwise, just remove and add again */
-	if (val->handle->functions->add_value && 
-		val->handle->functions->del_value) {
-		REG_VAL *new;
-		if(!W_ERROR_IS_OK(error = val->handle->functions->del_value(val))) 
-			return error;
-		
-		error = val->handle->functions->add_value(val->parent, val->name, type, data, len);
-		if(!W_ERROR_IS_OK(error)) return error;
-		memcpy(val, new, sizeof(REG_VAL));
-		val->parent->cache_values = NULL;
-		val->parent->cache_values_count = 0;
-		return WERR_OK;
-	}
-		
-	DEBUG(1, ("Backend '%s' doesn't support method update_value\n", val->handle->functions->name));
-	return WERR_NOT_SUPPORTED;
-}
-
-void reg_free(REG_HANDLE *h)
-{
-	if(!h->functions->close_registry) return;
+	/* A 'real' set function has preference */
+	if (key->hive->functions->set_value) 
+		return key->hive->functions->set_value(key, value, type, data, len);
 
-	h->functions->close_registry(h);
+	DEBUG(1, ("Backend '%s' doesn't support method set_value\n", key->hive->functions->name));
+	return WERR_NOT_SUPPORTED;
 }
 
-WERROR reg_get_hive(REG_HANDLE *h, int hivenum, REG_KEY **key) 
+WERROR reg_get_hive(struct registry_context *h, const char *name, struct registry_key **key) 
 {
-	WERROR ret;
-	
-	if(h->functions->get_hive) {
-		ret = h->functions->get_hive(h, hivenum, key);
-	} else if(h->functions->open_key) {
-		if(hivenum == 0) ret = h->functions->open_key(h, hivenum, "", key);
-		else ret = WERR_NO_MORE_ITEMS;
-	} else {
-		DEBUG(0, ("Backend '%s' has neither open_root_key nor open_key or get_hive method implemented\n", h->functions->name));
-		ret = WERR_NOT_SUPPORTED;
-	}
-
-	if(W_ERROR_IS_OK(ret)) {
-		(*key)->handle = h;
-		if(!(*key)->path) {
-			(*key)->path = talloc_strdup((*key)->mem_ctx, (*key)->name);
+	int i;
+	for(i = 0; i < h->num_hives; i++)
+	{
+		if(!strcmp(h->hives[i]->name, name)) {
+			*key = h->hives[i]->root;
+			return WERR_OK;
 		}
-		(*key)->hive = hivenum;
 	}
 
-	return ret;
+	return WERR_NO_MORE_ITEMS;
 }
 
-WERROR reg_key_add_value(REG_KEY *key, const char *name, int type, void *value, size_t vallen)
+WERROR reg_del_value(struct registry_value *val)
 {
 	WERROR ret = WERR_OK;
-	if(!key->handle->functions->add_value)
+	if(!val->hive->functions->del_value)
 		return WERR_NOT_SUPPORTED;
 
-	ret = key->handle->functions->add_value(key, name, type, value, vallen);
+	ret = val->hive->functions->del_value(val);
 
 	if(!W_ERROR_IS_OK(ret)) return ret;
 
-	/* Invalidate the cache */
-	key->cache_values = NULL;
-	key->cache_values_count = 0;
 	return ret;
 }
 
-WERROR reg_save(REG_HANDLE *h, const char *location)
+WERROR reg_save(struct registry_context *h, const char *location)
 {
 	/* FIXME */	
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR reg_key_get_parent(REG_KEY *key, REG_KEY **parent)
+WERROR reg_key_get_parent(TALLOC_CTX *mem_ctx, struct registry_key *key, struct registry_key **parent)
 {
 	char *parent_name;
 	char *last;
-	REG_KEY *root;
+	struct registry_key *root;
 	WERROR error;
 
-	error = reg_get_hive(key->handle, key->hive, &root);
-	if(!W_ERROR_IS_OK(error)) return error;
-
-	parent_name = strdup(reg_key_get_path(key));
+	parent_name = strdup(key->path);
 	last = strrchr(parent_name, '\\');
 
 	if(!last) {
@@ -645,7 +598,7 @@ WERROR reg_key_get_parent(REG_KEY *key, REG_KEY **parent)
 	}
 	*last = '\0';
 
-	error = reg_open_key(root, parent_name, parent);
+	error = reg_open_key(mem_ctx, root, parent_name, parent);
 	SAFE_FREE(parent_name);
 	return error;
 }
diff --git a/source4/lib/registry/common/reg_objects.c b/source4/lib/registry/common/reg_objects.c
deleted file mode 100644
index d911b4650b..0000000000
--- a/source4/lib/registry/common/reg_objects.c
+++ /dev/null
@@ -1,213 +0,0 @@
-/* 
- *  Unix SMB/CIFS implementation.
- *  RPC Pipe client / server routines
- *  Copyright (C) Gerald Carter                     2002.
- *  Copyright (C) Jelmer Vernooij					2003-2004.
- *
- *  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
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *  
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *  
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-/* Implementation of registry frontend view functions. */
-
-#include "includes.h"
-#include "lib/registry/common/registry.h"
-
-#undef DBGC_CLASS
-#define DBGC_CLASS DBGC_RPC_SRV
-
-/***********************************************************************
- allocate memory for and duplicate a REG_VAL.
- This is malloc'd memory so the caller should free it when done
- **********************************************************************/
-
-REG_VAL* reg_val_dup( REG_VAL *val )
-{
-	val->ref++;
-	return val;	
-}
-
-/**********************************************************************
- free the memory allocated to a REG_VAL 
- *********************************************************************/
- 
-void reg_val_free( REG_VAL *val )
-{
-	if ( !val )
-		return;
-
-	val->ref--;
-	if(val->ref) return;
-
-	if(val->handle->functions->free_val_backend_data)
-		val->handle->functions->free_val_backend_data(val);
-		
-	talloc_destroy( val->mem_ctx );
-
-	return;
-}
-
-/**********************************************************************
- *********************************************************************/
-
-uint8_t * reg_val_data_blk( REG_VAL *val )
-{
-	return val->data_blk;
-}
-
-/**********************************************************************
- *********************************************************************/
-
-int reg_val_size( REG_VAL *val )
-{
-	return val->data_len;
-}
-
-/**********************************************************************
- *********************************************************************/
-
-char *reg_val_name( REG_VAL *val )
-{
-	return val->name;
-}
-
-/**********************************************************************
- *********************************************************************/
-
-uint32_t reg_val_type( REG_VAL *val )
-{
-	return val->data_type;
-}
-
-/**********************************************************************
- *********************************************************************/
-
-REG_HANDLE *reg_key_handle (REG_KEY *key) 
-{
-	return key->handle;
-}
-
-char *reg_key_name( REG_KEY *key )
-{
-	return key->name;
-}
-
-char *reg_key_class( REG_KEY *key )
-{
-	return key->class_name;
-}
-
-NTTIME reg_key_last_modified( REG_KEY *key )
-{
-	return key->last_mod;
-}
-
-REG_KEY *reg_key_dup(REG_KEY *key)
-{
-	key->ref++;
-	return key;
-}
-
-void reg_key_free(REG_KEY *key)
-{
-	if(!key)
-		return;
-	
-	key->ref--;
-	if(key->ref) return;
-	
-	if(key->handle->functions->free_key_backend_data)
-		key->handle->functions->free_key_backend_data(key);
-
-	if(key->cache_values) {
-		int i;
-		for(i = 0; i < key->cache_values_count; i++) {
-			reg_val_free(key->cache_values[i]);
-		}
-	}
-
-	if(key->cache_subkeys) {
-		int i;
-		for(i = 0; i < key->cache_subkeys_count; i++) {
-			reg_key_free(key->cache_subkeys[i]);
-		}
-	}
-
-	talloc_destroy(key->mem_ctx);
-}
-
-char *reg_val_get_path(REG_VAL *v)
-{
-	/* FIXME */
-	return NULL;
-}
-
-const char *reg_key_get_path(REG_KEY *k)
-{
-	SMB_REG_ASSERT(k);
-	return strchr(k->path, '\\')?strchr(k->path, '\\')+1:"";
-}
-
-const char *reg_key_get_path_abs(REG_KEY *k)
-{
-	SMB_REG_ASSERT(k);
-	return k->path;
-}
-
-/* For use by the backends _ONLY_ */
-REG_KEY *reg_key_new_abs(const char *path, REG_HANDLE *h, void *data)
-{
-	REG_KEY *r;
-	TALLOC_CTX *mem_ctx = talloc_init(path);
-	r = talloc(mem_ctx, sizeof(REG_KEY));
-	ZERO_STRUCTP(r);
-	r->handle = h;
-	r->mem_ctx = mem_ctx;
-	r->path = talloc_strdup(mem_ctx, path);
-	r->name = talloc_strdup(mem_ctx, strrchr(path, '\\')?strrchr(path,'\\')+1:path);
-	r->backend_data = data;
-	r->ref = 1;
-	return r;
-}
-
-REG_KEY *reg_key_new_rel(const char *name, REG_KEY *k, void *data)
-{
-	REG_KEY *r;
-	const char *parent_path = k?reg_key_get_path(k):"";
-	TALLOC_CTX *mem_ctx = talloc_init(name);
-	r = talloc(mem_ctx, sizeof(REG_KEY));
-	ZERO_STRUCTP(r);
-	r->handle = k->handle;
-	r->hive = k->hive;
-	r->name = talloc_strdup(mem_ctx, name);
-	
-	r->path = talloc_asprintf(mem_ctx, "%s%s%s", parent_path, *parent_path && parent_path[strlen(parent_path)-1] != '\\'?"\\":"", name);
-	r->backend_data = data;
-	r->mem_ctx = mem_ctx;
-	r->ref = 1;
-	return r;
-}
-
-REG_VAL *reg_val_new(REG_KEY *parent, void *data)
-{
-	REG_VAL *r;
-	TALLOC_CTX *mem_ctx = talloc_init("value");
-	r = talloc(mem_ctx, sizeof(REG_VAL));
-	ZERO_STRUCTP(r);
-	r->mem_ctx = mem_ctx;
-	r->handle = parent->handle;
-	r->backend_data = data;
-	r->ref = 1;
-	return r;
-}
diff --git a/source4/lib/registry/common/reg_util.c b/source4/lib/registry/common/reg_util.c
index db5e97bf7f..21c925deab 100644
--- a/source4/lib/registry/common/reg_util.c
+++ b/source4/lib/registry/common/reg_util.c
@@ -34,90 +34,68 @@ const char *str_regtype(int type)
 	return "Unknown";
 }
 
-char *reg_val_data_string(REG_VAL *v)
+char *reg_val_data_string(TALLOC_CTX *mem_ctx, struct registry_value *v)
 { 
   char *asciip;
   char *ret = NULL;
   int i;
 
-  if(reg_val_size(v) == 0) return strdup("");
+  if(v->data_len == 0) return talloc_strdup(mem_ctx, "");
 
-  switch (reg_val_type(v)) {
+  switch (v->data_type) {
   case REG_SZ:
-	  /* FIXME: Convert to ascii */
-	  return strndup(reg_val_data_blk(v), reg_val_size(v));
+	  return talloc_strndup(mem_ctx, v->data_blk, v->data_len);
 
   case REG_EXPAND_SZ:
-	  return strndup(reg_val_data_blk(v), reg_val_size(v));
+	  return talloc_strndup(mem_ctx, v->data_blk, v->data_len);
 
   case REG_BINARY:
-	  ret = malloc(reg_val_size(v) * 3 + 2);
+	  ret = talloc(mem_ctx, v->data_len * 3 + 2);
 	  asciip = ret;
-	  for (i=0; i<reg_val_size(v); i++) { 
-		  int str_rem = reg_val_size(v) * 3 - (asciip - ret);
-		  asciip += snprintf(asciip, str_rem, "%02x", *(uint8_t *)(reg_val_data_blk(v)+i));
-		  if (i < reg_val_size(v) && str_rem > 0)
+	  for (i=0; i<v->data_len; i++) { 
+		  int str_rem = v->data_len * 3 - (asciip - ret);
+		  asciip += snprintf(asciip, str_rem, "%02x", *(uint8_t *)(v->data_blk+i));
+		  if (i < v->data_len && str_rem > 0)
 			  *asciip = ' '; asciip++;	
 	  }
 	  *asciip = '\0';
 	  return ret;
-	  break;
 
   case REG_DWORD:
-	  if (*(int *)reg_val_data_blk(v) == 0)
-		  ret = strdup("0");
-	  else
-		  asprintf(&ret, "0x%x", *(int *)reg_val_data_blk(v));
-	  break;
+	  if (*(int *)v->data_blk == 0)
+		  return talloc_strdup(mem_ctx, "0");
+
+	  return talloc_asprintf(mem_ctx, "0x%x", *(int *)v->data_blk);
 
   case REG_MULTI_SZ:
 	/* FIXME */
     break;
 
   default:
-    return 0;
     break;
   } 
 
   return ret;
 }
 
-char *reg_val_description(REG_VAL *val) 
+char *reg_val_description(TALLOC_CTX *mem_ctx, struct registry_value *val) 
 {
-	char *ret, *ds = reg_val_data_string(val);
-	asprintf(&ret, "%s = %s : %s", reg_val_name(val)?reg_val_name(val):"<No Name>", str_regtype(reg_val_type(val)), ds);
-	free(ds);
-	return ret;
+	return talloc_asprintf(mem_ctx, "%s = %s : %s", val->name?val->name:"<No Name>", str_regtype(val->data_type), reg_val_data_string(mem_ctx, val));
 }
 
-BOOL reg_val_set_string(REG_VAL *val, char *str)
+BOOL reg_val_set_string(struct registry_value *val, char *str)
 {
 	/* FIXME */
 	return False;
 }
 
-WERROR reg_key_get_subkey_val(REG_KEY *key, const char *subname, const char *valname, REG_VAL **val)
+WERROR reg_key_get_subkey_val(TALLOC_CTX *mem_ctx, struct registry_key *key, const char *subname, const char *valname, struct registry_value **val)
 {
-	REG_KEY *k;
-	WERROR error = reg_key_get_subkey_by_name(key, subname, &k);
-	if(!W_ERROR_IS_OK(error)) return error;
-	
-	return reg_key_get_value_by_name(k, valname, val);
-}
-
-WERROR reg_key_set_subkey_val(REG_KEY *key, const char *subname, const char *valname, uint32_t type, uint8_t *data, int real_len)
-{
-	REG_KEY *k;
-	REG_VAL *v;
-	WERROR error;
-
-	error = reg_key_get_subkey_by_name(key, subname, &k);
-	if(!W_ERROR_IS_OK(error)) return error;
-
-	error = reg_key_get_value_by_name(k, valname, &v);
+	struct registry_key *k;
+	WERROR error = reg_key_get_subkey_by_name(mem_ctx, key, subname, &k);
 	if(!W_ERROR_IS_OK(error)) return error;
 	
-	return reg_val_update(v, type, data, real_len);
+	return reg_key_get_value_by_name(mem_ctx, k, valname, val);
 }
 
 /***********************************************************************
diff --git a/source4/lib/registry/common/registry.h b/source4/lib/registry/common/registry.h
deleted file mode 100644
index 89d0ac6b14..0000000000
--- a/source4/lib/registry/common/registry.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   Registry interface
-   This file contains the _internal_ structs for the registry 
-   subsystem. Backends and the subsystem itself are the only
-   files that need to include this file.
-   Copyright (C) Gerald Carter                        2002.
-   Copyright (C) Jelmer Vernooij					  2003-2004.
-   
-   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
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-   
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-   
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#ifndef _REGISTRY_REGISTRY_H /* _REGISTRY_REGISTRY_H */
-#define _REGISTRY_REGISTRY_H 
-
-#define REGISTRY_INTERFACE_VERSION 1
-
-/* structure to store the registry handles */
-struct reg_key_s {
-  char *name;         /* Name of the key                    */
-  char *path;		  /* Full path to the key */
-  char *class_name; /* Name of key class */
-  NTTIME last_mod; /* Time last modified                 */
-  SEC_DESC *security;
-  REG_HANDLE *handle;
-  void *backend_data;
-  REG_VAL **cache_values; 
-  int cache_values_count;
-  REG_KEY **cache_subkeys; 
-  int cache_subkeys_count;
-  int hive;
-  TALLOC_CTX *mem_ctx;
-  int ref;
-};
-
-struct reg_val_s {
-  char *name;
-  int has_name;
-  int data_type;
-  int data_len;
-  void *data_blk;    /* Might want a separate block */
-  REG_HANDLE *handle;
-  REG_KEY *parent;
-  void *backend_data;
-  TALLOC_CTX *mem_ctx;
-  int ref;
-};
-
-/* FIXME */
-typedef void (*key_notification_function) (void);
-typedef void (*value_notification_function) (void);
-
-/* 
- * Container for function pointers to enumeration routines
- * for virtual registry view 
- *
- * Backends can provide :
- *  - just one hive (example: nt4, w95)
- *  - several hives (example: rpc)
- * 
- */ 
- 
-struct registry_ops {
-	const char *name;
-	WERROR (*open_registry) (REG_HANDLE *, const char *location, const char *credentials);
-	WERROR (*sync_key)(REG_KEY *, const char *location);
-	WERROR (*close_registry) (REG_HANDLE *);
-
-	/* Implement this one */
-	WERROR (*get_hive) (REG_HANDLE *, int , REG_KEY **);
-
-	/* Or this one */
-	WERROR (*open_key) (REG_HANDLE *, int hive, const char *name, REG_KEY **);
-
-	/* Either implement these */
-	WERROR (*num_subkeys) (REG_KEY *, int *count);
-	WERROR (*num_values) (REG_KEY *, int *count);
-	WERROR (*get_subkey_by_index) (REG_KEY *, int idx, REG_KEY **);
-	/* Can not contain more then one level */
-	WERROR (*get_subkey_by_name) (REG_KEY *, const char *name, REG_KEY **);
-	WERROR (*get_value_by_index) (REG_KEY *, int idx, REG_VAL **);
-	/* Can not contain more then one level */
-	WERROR (*get_value_by_name) (REG_KEY *, const char *name, REG_VAL **);
-
-	/* Or these */
-	WERROR (*fetch_subkeys) (REG_KEY *, int *count, REG_KEY ***);
-	WERROR (*fetch_values) (REG_KEY *, int *count, REG_VAL ***);
-
-	/* Security control */
-	WERROR (*key_get_sec_desc) (REG_KEY *, SEC_DESC **);
-	WERROR (*key_set_sec_desc) (REG_KEY *, SEC_DESC *);
-
-	/* Notification */
-	WERROR (*request_key_change_notify) (REG_KEY *, key_notification_function);
-	WERROR (*request_value_change_notify) (REG_VAL *, value_notification_function);
-
-	/* Key management */
-	WERROR (*add_key)(REG_KEY *, const char *name, uint32_t access_mask, SEC_DESC *, REG_KEY **);
-	WERROR (*del_key)(REG_KEY *);
-
-	/* Value management */
-	WERROR (*add_value)(REG_KEY *, const char *name, int type, void *data, int len);
-	WERROR (*del_value)(REG_VAL *);
- 	
-	/* If update is not available, value will first be deleted and then added 
-	 * again */
-	WERROR (*update_value)(REG_VAL *, int type, void *data, int len); 
-
-	void (*free_key_backend_data) (REG_KEY *);
-	void (*free_val_backend_data) (REG_VAL *);
-};
-
-struct reg_handle_s {
-	const struct registry_ops *functions;
-	char *location;
-	char *credentials;
-	void *backend_data;
-	TALLOC_CTX *mem_ctx;
-};
-
-struct reg_init_function_entry {
-	/* Function to create a member of the pdb_methods list */
-	const struct registry_ops *functions;
-	struct reg_init_function_entry *prev, *next;
-};
-
-/* Used internally */
-#define SMB_REG_ASSERT(a) { if(!(a)) { DEBUG(0,("%s failed! (%s:%d)", #a, __FILE__, __LINE__)); }}
-
-#endif /* _REGISTRY_H */
diff --git a/source4/lib/registry/config.mk b/source4/lib/registry/config.mk
index 8100c798e6..659e705d5d 100644
--- a/source4/lib/registry/config.mk
+++ b/source4/lib/registry/config.mk
@@ -60,7 +60,6 @@ REQUIRED_SUBSYSTEMS = \
 INIT_OBJ_FILES = \
 		lib/registry/common/reg_interface.o
 ADD_OBJ_FILES = \
-		lib/registry/common/reg_objects.o \
 		lib/registry/common/reg_util.o
 REQUIRED_SUBSYSTEMS = \
 		LIBBASIC
diff --git a/source4/lib/registry/reg_backend_dir/reg_backend_dir.c b/source4/lib/registry/reg_backend_dir/reg_backend_dir.c
index b2bd34bf71..95d4c47af0 100644
--- a/source4/lib/registry/reg_backend_dir/reg_backend_dir.c
+++ b/source4/lib/registry/reg_backend_dir/reg_backend_dir.c
@@ -19,13 +19,12 @@
 */
 
 #include "includes.h"
-#include "lib/registry/common/registry.h"
 
-static WERROR reg_dir_add_key(REG_KEY *parent, const char *name, uint32_t access_mask, SEC_DESC *desc, REG_KEY **result)
+static WERROR reg_dir_add_key(TALLOC_CTX *mem_ctx, struct registry_key *parent, const char *name, uint32_t access_mask, SEC_DESC *desc, struct registry_key **result)
 {
 	char *path;
 	int ret;
-	asprintf(&path, "%s%s\\%s", parent->handle->location, reg_key_get_path(parent), name);
+	asprintf(&path, "%s%s\\%s", parent->hive->location, parent->path, name);
 	path = reg_path_win2unix(path);
 	ret = mkdir(path, 0700);
 	SAFE_FREE(path);
@@ -33,19 +32,16 @@ static WERROR reg_dir_add_key(REG_KEY *parent, const char *name, uint32_t access
 	return WERR_INVALID_PARAM;
 }
 
-static WERROR reg_dir_del_key(REG_KEY *k)
+static WERROR reg_dir_del_key(struct registry_key *k)
 {
 	return (rmdir((char *)k->backend_data) == 0)?WERR_OK:WERR_GENERAL_FAILURE;
 }
 
-static WERROR reg_dir_open_key(REG_HANDLE *h, int hive, const char *name, REG_KEY **subkey)
+static WERROR reg_dir_open_key(TALLOC_CTX *mem_ctx, struct registry_hive *h, const char *name, struct registry_key **subkey)
 {
 	DIR *d;
 	char *fullpath;
-	REG_KEY *ret;
-	TALLOC_CTX *mem_ctx;
-	
-	if(hive != 0) return WERR_NO_MORE_ITEMS;
+	struct registry_key *ret;
 	
 	if(!name) {
 		DEBUG(0, ("NULL pointer passed as directory name!"));
@@ -53,33 +49,28 @@ static WERROR reg_dir_open_key(REG_HANDLE *h, int hive, const char *name, REG_KE
 	}
 
 	
-	mem_ctx = talloc_init("tmp");
 	fullpath = talloc_asprintf(mem_ctx, "%s%s", h->location, name);
 	fullpath = reg_path_win2unix(fullpath);
 	
 	d = opendir(fullpath);
 	if(!d) {
 		DEBUG(3,("Unable to open '%s': %s\n", fullpath, strerror(errno)));
-		talloc_destroy(mem_ctx);
 		return WERR_BADFILE;
 	}
 	closedir(d);
-	ret = reg_key_new_abs(name, h, fullpath);
-	talloc_steal(ret->mem_ctx, fullpath);
-	talloc_destroy(mem_ctx);
+	ret = talloc_p(mem_ctx, struct registry_key);
+	ret->hive = h;
+	ret->path = fullpath;
 	*subkey = ret;
 	return WERR_OK;
 }
 
-static WERROR reg_dir_fetch_subkeys(REG_KEY *k, int *count, REG_KEY ***r)
+static WERROR reg_dir_key_by_index(TALLOC_CTX *mem_ctx, struct registry_key *k, int idx, struct registry_key **key)
 {
 	struct dirent *e;
-	int max = 200;
 	char *fullpath = k->backend_data;
-	REG_KEY **ar;
+	int i = 0;
 	DIR *d;
-	(*count) = 0;
-	ar = talloc(k->mem_ctx, sizeof(REG_KEY *) * max);
 
 	d = opendir(fullpath);
 
@@ -96,13 +87,15 @@ static WERROR reg_dir_fetch_subkeys(REG_KEY *k, int *count, REG_KEY ***r)
 			stat(thispath, &stbuf);
 
 			if(S_ISDIR(stbuf.st_mode)) {
-				ar[(*count)] = reg_key_new_rel(e->d_name, k, NULL);
-				ar[(*count)]->backend_data = talloc_strdup(ar[*count]->mem_ctx, thispath);
-				if(ar[(*count)])(*count)++;
-
-				if((*count) == max) {
-					max+=200;
-					ar = realloc(ar, sizeof(REG_KEY *) * max);
+				i++;
+				if(i == idx) {
+					(*key) = talloc_p(mem_ctx, struct registry_key);
+					(*key)->name = e->d_name;
+					(*key)->path = NULL;
+					(*key)->backend_data = talloc_strdup(mem_ctx, thispath);
+					SAFE_FREE(thispath);
+					closedir(d);
+					return WERR_OK;
 				}
 			}
 
@@ -112,44 +105,38 @@ static WERROR reg_dir_fetch_subkeys(REG_KEY *k, int *count, REG_KEY ***r)
 
 	closedir(d);
 
-	*r = ar;
-	return WERR_OK;
+	return WERR_NO_MORE_ITEMS;
 }
 
-static WERROR reg_dir_open(REG_HANDLE *h, const char *loc, const char *credentials) {
-	if(!loc) return WERR_INVALID_PARAM;
+static WERROR reg_dir_open(TALLOC_CTX *mem_ctx, struct registry_hive *h, struct registry_key **key)
+{
+	if(!h->location) return WERR_INVALID_PARAM;
+
+	*key = talloc_p(mem_ctx, struct registry_key);
+	(*key)->backend_data = talloc_strdup(mem_ctx, h->location);
 	return WERR_OK;
 }
 
-static WERROR reg_dir_add_value(REG_KEY *p, const char *name, int type, void *data, int len)
+static WERROR reg_dir_set_value(struct registry_key *p, const char *name, int type, void *data, int len)
 {
 	/* FIXME */
 	return WERR_NOT_SUPPORTED;
 }
 
-static WERROR reg_dir_get_hive(REG_HANDLE *h, int hive, REG_KEY **key)
-{
-	if(hive != 0) return WERR_NO_MORE_ITEMS;
-	*key = reg_key_new_abs("", h, NULL);
-	(*key)->backend_data = talloc_strdup((*key)->mem_ctx, h->location);
-	return WERR_OK;
-}
-
-static WERROR reg_dir_del_value(REG_VAL *v)
+static WERROR reg_dir_del_value(struct registry_value *v)
 {
 	/* FIXME*/
 	return WERR_NOT_SUPPORTED;
 }
 
-static struct registry_ops reg_backend_dir = {
+static struct registry_operations reg_backend_dir = {
 	.name = "dir",
-	.open_registry = reg_dir_open,
+	.open_hive = reg_dir_open,
 	.open_key = reg_dir_open_key,
-	.get_hive = reg_dir_get_hive,
-	.fetch_subkeys = reg_dir_fetch_subkeys,
 	.add_key = reg_dir_add_key,
 	.del_key = reg_dir_del_key,
-	.add_value = reg_dir_add_value,
+	.get_subkey_by_index = reg_dir_key_by_index,
+	.set_value = reg_dir_set_value,
 	.del_value = reg_dir_del_value,
 };
 
diff --git a/source4/lib/registry/reg_backend_gconf/reg_backend_gconf.c b/source4/lib/registry/reg_backend_gconf/reg_backend_gconf.c
index 15a8319711..d8c8d951c1 100644
--- a/source4/lib/registry/reg_backend_gconf/reg_backend_gconf.c
+++ b/source4/lib/registry/reg_backend_gconf/reg_backend_gconf.c
@@ -19,7 +19,6 @@
 */
 
 #include "includes.h"
-#include "lib/registry/common/registry.h"
 #include <gconf/gconf-client.h>
 
 static WERROR gerror_to_werror(GError *error)
@@ -29,33 +28,24 @@ static WERROR gerror_to_werror(GError *error)
 	return WERR_FOOBAR;
 }
 
-static WERROR reg_open_gconf(REG_HANDLE *h, const char *location, const char *credentials) 
+static WERROR reg_open_gconf_hive(TALLOC_CTX *mem_ctx, struct registry_hive *h, struct registry_key **k)
 {
+	g_type_init();
 	h->backend_data = (void *)gconf_client_get_default();
 	if(!h->backend_data) return WERR_FOOBAR;
+	
+	*k = talloc_p(mem_ctx, struct registry_key);
+	(*k)->name = "";
+	(*k)->path = "";
+	(*k)->backend_data = talloc_strdup(mem_ctx, "/");
 	return WERR_OK;
 }
 
-static WERROR reg_close_gconf(REG_HANDLE *h) 
-{
-	return WERR_OK;
-}
-
-static WERROR gconf_get_hive (REG_HANDLE *h, int hivenum, REG_KEY **key)
-{
-	if(hivenum != 0) return WERR_NO_MORE_ITEMS;
-	*key = reg_key_new_abs("", h, NULL);
-	(*key)->backend_data = talloc_strdup((*key)->mem_ctx, "/");
-	return WERR_OK;
-}
-
-static WERROR gconf_open_key (REG_HANDLE *h, int hivenum, const char *name, REG_KEY **key) 
+static WERROR gconf_open_key (TALLOC_CTX *mem_ctx, struct registry_hive *h, const char *name, struct registry_key **key) 
 {
-	REG_KEY *ret;
+	struct registry_key *ret;
 	char *fullpath;
 	
-	if(hivenum != 0) return WERR_NO_MORE_ITEMS;
-	
 	fullpath = reg_path_win2unix(strdup(name));
 
 	/* Check if key exists */
@@ -63,143 +53,134 @@ static WERROR gconf_open_key (REG_HANDLE *h, int hivenum, const char *name, REG_
 		SAFE_FREE(fullpath);
 		return WERR_DEST_NOT_FOUND;
 	}
-	ret = reg_key_new_abs(name, h, NULL);
-	ret->backend_data = talloc_strdup(ret->mem_ctx, fullpath);
+
+	ret = talloc_p(mem_ctx, struct registry_key);
+	ret->backend_data = talloc_strdup(mem_ctx, fullpath);
 	SAFE_FREE(fullpath);
 
 	*key = ret;
 	return WERR_OK;
 }
 
-static WERROR gconf_fetch_values(REG_KEY *p, int *count, REG_VAL ***vals)
+static WERROR gconf_get_value_by_id(TALLOC_CTX *mem_ctx, struct registry_key *p, int idx, struct registry_value **val)
 {
 	GSList *entries;
 	GSList *cur;
-	REG_VAL **ar = talloc(p->mem_ctx, sizeof(REG_VAL *));
+	GConfEntry *entry;
+	GConfValue *value;
+	struct registry_value *newval;
 	char *fullpath = p->backend_data;
-	cur = entries = gconf_client_all_entries((GConfClient*)p->handle->backend_data, fullpath, NULL);
-
-	(*count) = 0;
-	while(cur) {
-		GConfEntry *entry = cur->data;
-		GConfValue *value = gconf_entry_get_value(entry);
-		REG_VAL *newval = reg_val_new(p, NULL);
-		newval->name = talloc_strdup(newval->mem_ctx, strrchr(gconf_entry_get_key(entry), '/')+1);
-		if(value) {
-			switch(value->type) {
-			case GCONF_VALUE_INVALID: 
-				newval->data_type = REG_NONE;
-				break;
-
-			case GCONF_VALUE_STRING:
-				newval->data_type = REG_SZ;
-				newval->data_blk = talloc_strdup(newval->mem_ctx, gconf_value_get_string(value));
-				newval->data_len = strlen(newval->data_blk);
-				break;
-
-			case GCONF_VALUE_INT:
-				newval->data_type = REG_DWORD;
-				newval->data_blk = talloc(newval->mem_ctx, sizeof(long));
-				*((long *)newval->data_blk) = gconf_value_get_int(value);
-				newval->data_len = sizeof(long);
-				break;
-
-			case GCONF_VALUE_FLOAT:
-				newval->data_blk = talloc(newval->mem_ctx, sizeof(double));
-				newval->data_type = REG_BINARY;
-				*((double *)newval->data_blk) = gconf_value_get_float(value);
-				newval->data_len = sizeof(double);
-				break;
-
-			case GCONF_VALUE_BOOL:
-				newval->data_blk = talloc(newval->mem_ctx, sizeof(BOOL));
-				newval->data_type = REG_BINARY;
-				*((BOOL *)newval->data_blk) = gconf_value_get_bool(value);
-				newval->data_len = sizeof(BOOL);
-				break;
-
-			default:
-				newval->data_type = REG_NONE;
-				DEBUG(0, ("Not implemented..\n"));
-				break;
-			}
-		} else newval->data_type = REG_NONE; 
-
-		ar[(*count)] = newval;
-		ar = talloc_realloc(ar, sizeof(REG_VAL *) * ((*count)+2));
-		(*count)++;
-		g_free(cur->data);
-		cur = cur->next;
-	}
+	int i;
+	cur = entries = gconf_client_all_entries((GConfClient*)p->hive->backend_data, fullpath, NULL);
+
+	for(i = 0; i < idx && cur; i++) cur = cur->next;
+
+	if(!cur) return WERR_NO_MORE_ITEMS;
+
+	entry = cur->data;
+	value = gconf_entry_get_value(entry);
+		
+	newval = talloc_p(mem_ctx, struct registry_value);
+	newval->name = talloc_strdup(mem_ctx, strrchr(gconf_entry_get_key(entry), '/')+1);
+	if(value) {
+		switch(value->type) {
+		case GCONF_VALUE_INVALID: 
+			newval->data_type = REG_NONE;
+			break;
+
+		case GCONF_VALUE_STRING:
+			newval->data_type = REG_SZ;
+			newval->data_blk = talloc_strdup(mem_ctx, gconf_value_get_string(value));
+			newval->data_len = strlen(newval->data_blk);
+			break;
+
+		case GCONF_VALUE_INT:
+			newval->data_type = REG_DWORD;
+			newval->data_blk = talloc_p(mem_ctx, long);
+			*((long *)newval->data_blk) = gconf_value_get_int(value);
+			newval->data_len = sizeof(long);
+			break;
+
+		case GCONF_VALUE_FLOAT:
+			newval->data_blk = talloc_p(mem_ctx, double);
+			newval->data_type = REG_BINARY;
+			*((double *)newval->data_blk) = gconf_value_get_float(value);
+			newval->data_len = sizeof(double);
+			break;
+
+		case GCONF_VALUE_BOOL:
+			newval->data_blk = talloc_p(mem_ctx, BOOL);
+			newval->data_type = REG_BINARY;
+			*((BOOL *)newval->data_blk) = gconf_value_get_bool(value);
+			newval->data_len = sizeof(BOOL);
+			break;
+
+		default:
+			newval->data_type = REG_NONE;
+			DEBUG(0, ("Not implemented..\n"));
+			break;
+		}
+	} else newval->data_type = REG_NONE; 
 
 	g_slist_free(entries);
-	*vals = ar;
+	*val = newval;
 	return WERR_OK;
 }
 
-static WERROR gconf_fetch_subkeys(REG_KEY *p, int *count, REG_KEY ***subs) 
+static WERROR gconf_get_subkey_by_id(TALLOC_CTX *mem_ctx, struct registry_key *p, int idx, struct registry_key **sub) 
 {
 	GSList *dirs;
 	GSList *cur;
-	REG_KEY **ar = talloc_array_p(p->mem_ctx, REG_KEY *, 1);
+	int i;
 	char *fullpath = p->backend_data;
-	cur = dirs = gconf_client_all_dirs((GConfClient*)p->handle->backend_data, fullpath,NULL);
-
-	(*count) = 0;
-	while(cur) {
-		char *winpath = reg_path_unix2win(strdup((char *)cur->data));
-		ar[(*count)] = reg_key_new_abs(winpath, p->handle,NULL);
-		free(winpath);
-		ar[(*count)]->backend_data = reg_path_win2unix(talloc_strdup(ar[*count]->mem_ctx, cur->data));
-		ar = talloc_realloc_p(ar, REG_KEY *, (*count)+2);
-		(*count)++;
-		g_free(cur->data);
-		cur = cur->next;
-	}
+	cur = dirs = gconf_client_all_dirs((GConfClient*)p->hive->backend_data, fullpath,NULL);
+
+	for(i = 0; i < idx && cur; i++) cur = cur->next;
+	
+	if(!cur) return WERR_NO_MORE_ITEMS;
+	
+	*sub = talloc_p(mem_ctx, struct registry_key);	
+	(*sub)->name = talloc_strdup(mem_ctx, strrchr((char *)cur->data, '/')+1);
+	(*sub)->backend_data = talloc_strdup(mem_ctx, cur->data);
 
 	g_slist_free(dirs);
-	*subs = ar;
 	return WERR_OK;
 }
 
-static WERROR gconf_update_value(REG_VAL *val, int type, void *data, int len)
+static WERROR gconf_set_value(struct registry_key *key, const char *valname, int type, void *data, int len)
 {
 	GError *error = NULL;
-	char *keypath = val->backend_data;
 	char *valpath;
-	if(val->name)asprintf(&valpath, "%s/%s", keypath, val->name);
-	else valpath = strdup(keypath);
+	asprintf(&valpath, "%s/%s", key->path, valname);
 	
 	switch(type) {
 	case REG_SZ:
 	case REG_EXPAND_SZ:
-		gconf_client_set_string((GConfClient *)val->handle->backend_data, valpath, data, &error);
-		free(valpath);
+		gconf_client_set_string((GConfClient *)key->hive->backend_data, valpath, data, &error);
+		SAFE_FREE(valpath);
 		return gerror_to_werror(error);
 
 	case REG_DWORD:
-		gconf_client_set_int((GConfClient *)val->handle->backend_data, valpath, 
+		gconf_client_set_int((GConfClient *)key->hive->backend_data, valpath, 
  *((int *)data), &error);
-		free(valpath);
+		SAFE_FREE(valpath);
 		return gerror_to_werror(error);
 	default:
 		DEBUG(0, ("Unsupported type: %d\n", type));
-		free(valpath);
+		SAFE_FREE(valpath);
 		return WERR_NOT_SUPPORTED;
 	}
 
 	return WERR_NOT_SUPPORTED;
 }
 
-static struct registry_ops reg_backend_gconf = {
+static struct registry_operations reg_backend_gconf = {
 	.name = "gconf",
-	.open_registry = reg_open_gconf,
-	.close_registry = reg_close_gconf,
-	.get_hive = gconf_get_hive,
+	.open_hive = reg_open_gconf_hive,
 	.open_key = gconf_open_key,
-	.fetch_subkeys = gconf_fetch_subkeys,
-	.fetch_values = gconf_fetch_values,
-	.update_value = gconf_update_value,
+	.get_subkey_by_index = gconf_get_subkey_by_id,
+	.get_value_by_index = gconf_get_value_by_id,
+	.set_value = gconf_set_value,
 	
 	/* Note: 
 	 * since GConf uses schemas for what keys and values are allowed, there 
diff --git a/source4/lib/registry/reg_backend_ldb/reg_backend_ldb.c b/source4/lib/registry/reg_backend_ldb/reg_backend_ldb.c
index 47cb60d711..e0f65f2c37 100644
--- a/source4/lib/registry/reg_backend_ldb/reg_backend_ldb.c
+++ b/source4/lib/registry/reg_backend_ldb/reg_backend_ldb.c
@@ -19,7 +19,6 @@
 */
 
 #include "includes.h"
-#include "lib/registry/common/registry.h"
 
 static char *reg_path_to_ldb(TALLOC_CTX *mem_ctx, const char *path, const char *add)
 {
@@ -55,40 +54,46 @@ static char *reg_path_to_ldb(TALLOC_CTX *mem_ctx, const char *path, const char *
 	return ret;
 }
 
+
+static int ldb_close_registry(void *data) 
+{
+	ldb_close((struct ldb_context *)data);
+	return 0;
+}
+
+
 /* 
  * Saves the dn as private_data for every key/val
  */
 
-static WERROR ldb_open_registry(REG_HANDLE *handle, const char *location, const char *credentials)
+static WERROR ldb_open_hive(TALLOC_CTX *mem_ctx, struct registry_hive *hive, struct registry_key **k)
 {
 	struct ldb_context *c;
 
-	if (!location) return WERR_INVALID_PARAM;
-	c = ldb_connect(location, 0, NULL);
+	if (!hive->location) return WERR_INVALID_PARAM;
+	c = ldb_connect(hive->location, 0, NULL);
 
 	ldb_set_debug_stderr(c);
 
+
 	if(!c) return WERR_FOOBAR;
 
-	handle->backend_data = c;
+	hive->backend_data = c;
+	talloc_set_destructor(c, ldb_close_registry);
 	
 	return WERR_OK;
 }
 
-static WERROR ldb_close_registry(REG_HANDLE *h) 
-{
-	ldb_close((struct ldb_context *)h->backend_data);
-	return WERR_OK;
-}
-
-static WERROR ldb_add_key(REG_KEY *p, const char *name, uint32_t access_mask, SEC_DESC *sec, REG_KEY **new)
+static WERROR ldb_add_key(TALLOC_CTX *mem_ctx, struct registry_key *p, const char *name, uint32_t access_mask, SEC_DESC *sec, struct registry_key **new)
 {
 	return WERR_NOT_SUPPORTED;	
 }
 
-static WERROR ldb_fetch_subkeys(REG_KEY *k, int *count, REG_KEY ***subkeys)
+#if 0
+FIXME
+static WERROR ldb_fetch_subkeys(struct registry_key *k, int *count, struct registry_key ***subkeys)
 {
-	struct ldb_context *c = k->handle->backend_data;
+	struct ldb_context *c = k->hive->backend_data;
 	int ret, i, j;
 	struct ldb_message **msg;
 
@@ -99,7 +104,7 @@ static WERROR ldb_fetch_subkeys(REG_KEY *k, int *count, REG_KEY ***subkeys)
 		return WERR_FOOBAR;
 	}
 
-	*subkeys = talloc_array_p(k->mem_ctx, REG_KEY *, ret);
+	*subkeys = talloc_array_p(k->mem_ctx, struct registry_key *, ret);
 	j = 0;
 	for(i = 0; i < ret; i++) {
 		struct ldb_message_element *el;
@@ -121,9 +126,9 @@ static WERROR ldb_fetch_subkeys(REG_KEY *k, int *count, REG_KEY ***subkeys)
 	return WERR_OK;
 }
 
-static WERROR ldb_fetch_values(REG_KEY *k, int *count, REG_VAL ***values)
+static WERROR ldb_fetch_values(struct registry_key *k, int *count, REG_VAL ***values)
 {
-	struct ldb_context *c = k->handle->backend_data;
+	struct ldb_context *c = k->hive->backend_data;
 	int ret, i, j;
 	struct ldb_message **msg;
 
@@ -156,21 +161,14 @@ static WERROR ldb_fetch_values(REG_KEY *k, int *count, REG_VAL ***values)
 	return WERR_OK;
 }
 
-static WERROR ldb_get_hive(REG_HANDLE *h, int num, REG_KEY **key)
-{
-	if(num != 0) return WERR_NO_MORE_ITEMS;
-	*key = reg_key_new_abs("", h, NULL);
-	return WERR_OK;
-}
+#endif
 
-static WERROR ldb_open_key(REG_HANDLE *h, int num, const char *name, REG_KEY **key)
+static WERROR ldb_open_key(TALLOC_CTX *mem_ctx, struct registry_hive *h, const char *name, struct registry_key **key)
 {
 	struct ldb_context *c = h->backend_data;
 	struct ldb_message **msg;
 	char *ldap_path;
 	int ret;
-	TALLOC_CTX *mem_ctx = talloc_init("ldb_path");
-	if(num != 0) return WERR_NO_MORE_ITEMS;
 	ldap_path = reg_path_to_ldb(mem_ctx, name, NULL);
 	
 	ret = ldb_search(c, ldap_path, LDB_SCOPE_BASE, "*", NULL,&msg);
@@ -182,25 +180,20 @@ static WERROR ldb_open_key(REG_HANDLE *h, int num, const char *name, REG_KEY **k
 		return WERR_FOOBAR;
 	}
 
-	*key = reg_key_new_abs(name, h, ldap_path);
-	talloc_steal((*key)->mem_ctx, ldap_path);
-	printf("Got something!\n");
+	*key = talloc_p(mem_ctx, struct registry_key);
 	/* FIXME */
 
 	ldb_search_free(c, msg);
-	talloc_destroy(mem_ctx);
 
 	return WERR_OK;
 }
 
-static struct registry_ops reg_backend_ldb = {
+static struct registry_operations reg_backend_ldb = {
 	.name = "ldb",
-	.open_registry = ldb_open_registry,
-	.get_hive = ldb_get_hive,
-	.close_registry = ldb_close_registry,
+	.open_hive = ldb_open_hive,
 	.open_key = ldb_open_key,
-	.fetch_subkeys = ldb_fetch_subkeys,
-	.fetch_values = ldb_fetch_values,
+/*	.fetch_subkeys = ldb_fetch_subkeys,
+	.fetch_values = ldb_fetch_values,*/
 	.add_key = ldb_add_key,
 };
 
diff --git a/source4/lib/registry/reg_backend_nt4/reg_backend_nt4.c b/source4/lib/registry/reg_backend_nt4/reg_backend_nt4.c
index ee9f8bf24f..c271c55991 100644
--- a/source4/lib/registry/reg_backend_nt4/reg_backend_nt4.c
+++ b/source4/lib/registry/reg_backend_nt4/reg_backend_nt4.c
@@ -304,9 +304,9 @@ Hope this helps....  (Although it was "fun" for me to uncover this things,
 *************************************************************************/
 
 #include "includes.h"
-#include "lib/registry/common/registry.h"
 
 #define REG_KEY_LIST_SIZE 10
+#define FLAG_HAS_NAME	  0x01
 /*FIXME*/
 
 /*
@@ -514,7 +514,7 @@ static BOOL nt_create_ace(SEC_ACE *ace, int type, int flags, uint32_t perms, con
 /*
  * Create a default ACL
  */
-static SEC_ACL *nt_create_default_acl(REG_HANDLE *regf)
+static SEC_ACL *nt_create_default_acl(struct registry_hive *regf)
 {
   SEC_ACE aces[8];
 
@@ -534,7 +534,7 @@ static SEC_ACL *nt_create_default_acl(REG_HANDLE *regf)
  * Create a default security descriptor. We pull in things from env
  * if need be 
  */
-static SEC_DESC *nt_create_def_sec_desc(REG_HANDLE *regf)
+static SEC_DESC *nt_create_def_sec_desc(struct registry_hive *regf)
 {
   SEC_DESC *tmp;
 
@@ -559,7 +559,7 @@ static SEC_DESC *nt_create_def_sec_desc(REG_HANDLE *regf)
  * says, but the Owner and Group SIDs can be overwridden from the command line
  * and additional ACEs can be applied from the command line etc.
  */
-static KEY_SEC_DESC *nt_inherit_security(REG_KEY *key)
+static KEY_SEC_DESC *nt_inherit_security(struct registry_key *key)
 {
 
   if (!key) return NULL;
@@ -570,7 +570,7 @@ static KEY_SEC_DESC *nt_inherit_security(REG_KEY *key)
  * Create an initial security descriptor and init other structures, if needed
  * We assume that the initial security stuff is empty ...
  */
-static KEY_SEC_DESC *nt_create_init_sec(REG_HANDLE *h)
+static KEY_SEC_DESC *nt_create_init_sec(struct registry_hive *h)
 {
 	REGF *regf = h->backend_data;
 	KEY_SEC_DESC *tsec = NULL;
@@ -618,7 +618,7 @@ static KEY_SEC_DESC *nt_create_init_sec(REG_HANDLE *h)
 /* Get the header of the registry. Return a pointer to the structure 
  * If the mmap'd area has not been allocated, then mmap the input file
  */
-static REGF_HDR *nt_get_regf_hdr(REG_HANDLE *h)
+static REGF_HDR *nt_get_regf_hdr(struct registry_hive *h)
 {
 	REGF *regf = h->backend_data;
 	SMB_REG_ASSERT(regf);
@@ -676,7 +676,7 @@ static int valid_regf_hdr(REGF_HDR *regf_hdr)
 /*
  * Create a new entry in the map, and increase the size of the map if needed
  */
-static SK_MAP *alloc_sk_map_entry(REG_HANDLE *h, KEY_SEC_DESC *tmp, int sk_off)
+static SK_MAP *alloc_sk_map_entry(struct registry_hive *h, KEY_SEC_DESC *tmp, int sk_off)
 {
 	REGF *regf = h->backend_data;
 	if (!regf->sk_map) { /* Allocate a block of 10 */
@@ -731,7 +731,7 @@ KEY_SEC_DESC *lookup_sec_key(SK_MAP *sk_map, int count, int sk_off)
 /*
  * Allocate a KEY_SEC_DESC if we can't find one in the map
  */
-static KEY_SEC_DESC *lookup_create_sec_key(REG_HANDLE *h, SK_MAP *sk_map, int sk_off)
+static KEY_SEC_DESC *lookup_create_sec_key(struct registry_hive *h, SK_MAP *sk_map, int sk_off)
 {
 	REGF *regf = h->backend_data;
 	KEY_SEC_DESC *tmp = lookup_sec_key(regf->sk_map, regf->sk_count, sk_off);
@@ -750,7 +750,7 @@ static KEY_SEC_DESC *lookup_create_sec_key(REG_HANDLE *h, SK_MAP *sk_map, int sk
 	}
 }
 
-static SEC_DESC *process_sec_desc(REG_HANDLE *regf, SEC_DESC *sec_desc)
+static SEC_DESC *process_sec_desc(struct registry_hive *regf, SEC_DESC *sec_desc)
 {
 	SEC_DESC *tmp = NULL;
 
@@ -790,7 +790,7 @@ static SEC_DESC *process_sec_desc(REG_HANDLE *regf, SEC_DESC *sec_desc)
 	return tmp;
 }
 
-static KEY_SEC_DESC *process_sk(REG_HANDLE *regf, SK_HDR *sk_hdr, int sk_off, int size)
+static KEY_SEC_DESC *process_sk(struct registry_hive *regf, SK_HDR *sk_hdr, int sk_off, int size)
 {
 	KEY_SEC_DESC *tmp = NULL;
 	int sk_next_off, sk_prev_off, sk_size;
@@ -879,38 +879,34 @@ static KEY_SEC_DESC *process_sk(REG_HANDLE *regf, SK_HDR *sk_hdr, int sk_off, in
 /*
  * Process a VK header and return a value
  */
-static WERROR vk_to_val(REG_KEY *parent, VK_HDR *vk_hdr, int size, REG_VAL **value)
+static WERROR vk_to_val(TALLOC_CTX *mem_ctx, struct registry_key *parent, VK_HDR *vk_hdr, int size, struct registry_value **value)
 {
-	char val_name[1024];
-	REGF *regf = parent->handle->backend_data;
+	REGF *regf = parent->hive->backend_data;
 	int nam_len, dat_len, flag, dat_type, dat_off, vk_id;
-	REG_VAL *tmp = NULL; 
+	struct registry_value *tmp = NULL; 
 
 	if (!vk_hdr) return WERR_INVALID_PARAM;
 
 	if ((vk_id = SVAL(&vk_hdr->VK_ID,0)) != str_to_dword("vk")) {
 		DEBUG(0, ("Unrecognized VK header ID: %0X, block: %0X, %s\n",
-				  vk_id, (int)vk_hdr, parent->handle->location));
+				  vk_id, (int)vk_hdr, parent->hive->location));
 		return WERR_GENERAL_FAILURE;
 	}
 
 	nam_len = SVAL(&vk_hdr->nam_len,0);
-	val_name[nam_len] = '\0';
 	flag = SVAL(&vk_hdr->flag,0);
 	dat_type = IVAL(&vk_hdr->dat_type,0);
 	dat_len = IVAL(&vk_hdr->dat_len,0);  /* If top bit, offset contains data */
 	dat_off = IVAL(&vk_hdr->dat_off,0);
 
-	tmp = reg_val_new(parent, NULL);
-	tmp->has_name = flag;
+	tmp = talloc_p(mem_ctx, struct registry_value);
 	tmp->data_type = dat_type;
 
-	if (flag & 0x01) {
-		strncpy(val_name, vk_hdr->dat_name, nam_len);
-		tmp->name = strdup(val_name);
+	if (flag & FLAG_HAS_NAME) {
+		tmp->name = talloc_strndup(mem_ctx, vk_hdr->dat_name, nam_len);
+	} else {
+		tmp->name = NULL;
 	}
-	else
-		strncpy(val_name, "<No Name>", 10);
 
 	/*
 	 * Allocate space and copy the data as a BLOB
@@ -918,9 +914,7 @@ static WERROR vk_to_val(REG_KEY *parent, VK_HDR *vk_hdr, int size, REG_VAL **val
 
 	if (dat_len&0x7FFFFFFF) {
 
-		char *dtmp = (char *)talloc(tmp->mem_ctx, dat_len&0x7FFFFFFF);
-
-		tmp->data_blk = dtmp;
+		char *dtmp = (char *)talloc(mem_ctx, dat_len&0x7FFFFFFF);
 
 		if ((dat_len&0x80000000) == 0) { /* The data is pointed to by the offset */
 			char *dat_ptr = LOCN(regf->base, dat_off);
@@ -937,6 +931,15 @@ static WERROR vk_to_val(REG_KEY *parent, VK_HDR *vk_hdr, int size, REG_VAL **val
 			memcpy(dtmp, &dat_off, dat_len);
 		}
 
+
+		if(tmp->data_type == REG_SZ) {
+			char *ret;
+	    	dat_len = convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX, dtmp, dat_len, (const void **)&ret);
+			dtmp = ret;
+		}
+
+
+		tmp->data_blk = dtmp;
 		tmp->data_len = dat_len;
 	}
 
@@ -958,7 +961,7 @@ static BOOL vl_verify(VL_TYPE vl, int count, int size)
 
 #endif
 
-static WERROR lf_verify(REG_HANDLE *h, LF_HDR *lf_hdr, int size)
+static WERROR lf_verify(struct registry_hive *h, LF_HDR *lf_hdr, int size)
 {
 	int lf_id;
 	if ((lf_id = SVAL(&lf_hdr->LF_ID,0)) != str_to_dword("lf")) {
@@ -969,7 +972,7 @@ static WERROR lf_verify(REG_HANDLE *h, LF_HDR *lf_hdr, int size)
 	return WERR_OK;
 }
 
-static WERROR lf_num_entries(REG_HANDLE *h, LF_HDR *lf_hdr, int size, int *count)
+static WERROR lf_num_entries(struct registry_hive *h, LF_HDR *lf_hdr, int size, int *count)
 {
 	WERROR error;
 
@@ -986,23 +989,23 @@ static WERROR lf_num_entries(REG_HANDLE *h, LF_HDR *lf_hdr, int size, int *count
 }
 
 
-static WERROR nk_to_key(REG_HANDLE *regf, NK_HDR *nk_hdr, int size, REG_KEY *parent, REG_KEY **);
+static WERROR nk_to_key(TALLOC_CTX *, struct registry_hive *regf, NK_HDR *nk_hdr, int size, struct registry_key *parent, struct registry_key **);
 
 
 
 /*
  * Process an LF Header and return a list of sub-keys
  */
-static WERROR lf_get_entry(REG_KEY *parent, LF_HDR *lf_hdr, int size, int n, REG_KEY **key)
+static WERROR lf_get_entry(TALLOC_CTX *mem_ctx, struct registry_key *parent, LF_HDR *lf_hdr, int size, int n, struct registry_key **key)
 {
-	REGF *regf = parent->handle->backend_data;
+	REGF *regf = parent->hive->backend_data;
 	int count, nk_off;
 	NK_HDR *nk_hdr;
 	WERROR error;
 
 	if (!lf_hdr) return WERR_INVALID_PARAM;
 
-	error = lf_verify(parent->handle, lf_hdr, size);
+	error = lf_verify(parent->hive, lf_hdr, size);
 	if(!W_ERROR_IS_OK(error)) return error;
 
 	SMB_REG_ASSERT(size < 0);
@@ -1015,13 +1018,13 @@ static WERROR lf_get_entry(REG_KEY *parent, LF_HDR *lf_hdr, int size, int n, REG
 	nk_off = IVAL(&lf_hdr->hr[n].nk_off,0);
 	DEBUG(2, ("NK Offset: %0X\n", nk_off));
 	nk_hdr = (NK_HDR *)LOCN(regf->base, nk_off);
-	return nk_to_key(parent->handle, nk_hdr, BLK_SIZE(nk_hdr), parent, key);
+	return nk_to_key(mem_ctx, parent->hive, nk_hdr, BLK_SIZE(nk_hdr), parent, key);
 }
 
-static WERROR nk_to_key(REG_HANDLE *h, NK_HDR *nk_hdr, int size, REG_KEY *parent, REG_KEY **key)
+static WERROR nk_to_key(TALLOC_CTX *mem_ctx, struct registry_hive *h, NK_HDR *nk_hdr, int size, struct registry_key *parent, struct registry_key **key)
 {
 	REGF *regf = h->backend_data;
-	REG_KEY *tmp = NULL, *own;
+	struct registry_key *tmp = NULL, *own;
 	int namlen, clsname_len, sk_off, own_off;
 	uint_t nk_id;
 	SK_HDR *sk_hdr;
@@ -1032,7 +1035,7 @@ static WERROR nk_to_key(REG_HANDLE *h, NK_HDR *nk_hdr, int size, REG_KEY *parent
 
 	if ((nk_id = SVAL(&nk_hdr->NK_ID,0)) != str_to_dword("nk")) {
 		DEBUG(0, ("Unrecognized NK Header format: %08X, Block: %0X. %s\n", 
-				  nk_id, (int)nk_hdr, parent->handle->location));
+				  nk_id, (int)nk_hdr, parent->hive->location));
 		return WERR_INVALID_PARAM;
 	}
 
@@ -1071,8 +1074,9 @@ static WERROR nk_to_key(REG_HANDLE *h, NK_HDR *nk_hdr, int size, REG_KEY *parent
 		return WERR_GENERAL_FAILURE;
 	}
 
-	if(type == REG_ROOT_KEY) tmp = reg_key_new_abs(key_name, h, nk_hdr);
-	else tmp = reg_key_new_rel(key_name, parent, nk_hdr);
+	tmp = talloc_p(mem_ctx, struct registry_key);
+	tmp->name = talloc_strdup(mem_ctx, key_name);
+	tmp->backend_data = nk_hdr;
 
 	DEBUG(2, ("Key name: %s\n", key_name));
 
@@ -1089,7 +1093,7 @@ static WERROR nk_to_key(REG_HANDLE *h, NK_HDR *nk_hdr, int size, REG_KEY *parent
 		clsnamep = (smb_ucs2_t *)LOCN(regf->base, clsnam_off);
 		DEBUG(2, ("Class Name Offset: %0X\n", clsnam_off));
 
-		pull_ucs2_talloc(tmp->mem_ctx, &tmp->class_name, clsnamep);
+		pull_ucs2_talloc(mem_ctx, &tmp->class_name, clsnamep);
 
 		DEBUGADD(2,("  Class Name: %s\n", cls_name));
 
@@ -1100,7 +1104,7 @@ static WERROR nk_to_key(REG_HANDLE *h, NK_HDR *nk_hdr, int size, REG_KEY *parent
 	 */
 
 	own_off = IVAL(&nk_hdr->own_off,0);
-	own = (REG_KEY *)LOCN(regf->base, own_off);
+	own = (struct registry_key *)LOCN(regf->base, own_off);
 	DEBUG(2, ("Owner Offset: %0X\n", own_off));
 
 	DEBUGADD(2, ("  Owner locn: %0X, Our locn: %0X\n", 
@@ -1136,7 +1140,7 @@ static WERROR nk_to_key(REG_HANDLE *h, NK_HDR *nk_hdr, int size, REG_KEY *parent
 /*
  * Allocate a new hbin block, set up the header for the block etc 
  */
-static HBIN_BLK *nt_create_hbin_blk(REG_HANDLE *h, int size)
+static HBIN_BLK *nt_create_hbin_blk(struct registry_hive *h, int size)
 {
 	REGF *regf = h->backend_data;
 	HBIN_BLK *tmp;
@@ -1185,7 +1189,7 @@ static HBIN_BLK *nt_create_hbin_blk(REG_HANDLE *h, int size)
  * Allocate a unit of space ... and return a pointer as function param
  * and the block's offset as a side effect
  */
-static void *nt_alloc_regf_space(REG_HANDLE *h, int size, uint_t *off)
+static void *nt_alloc_regf_space(struct registry_hive *h, int size, uint_t *off)
 {
 	REGF *regf = h->backend_data;
 	int tmp = 0;
@@ -1268,7 +1272,7 @@ static void *nt_alloc_regf_space(REG_HANDLE *h, int size, uint_t *off)
 /*
  * Store a SID at the location provided
  */
-static int nt_store_SID(REG_HANDLE *regf, DOM_SID *sid, uint8_t *locn)
+static int nt_store_SID(struct registry_hive *regf, DOM_SID *sid, uint8_t *locn)
 {
 	int i;
 	uint8_t *p = locn;
@@ -1290,7 +1294,7 @@ static int nt_store_SID(REG_HANDLE *regf, DOM_SID *sid, uint8_t *locn)
 
 }
 
-static int nt_store_ace(REG_HANDLE *regf, SEC_ACE *ace, uint8_t *locn)
+static int nt_store_ace(struct registry_hive *regf, SEC_ACE *ace, uint8_t *locn)
 {
 	int size = 0;
 	SEC_ACE *reg_ace = (SEC_ACE *)locn;
@@ -1321,7 +1325,7 @@ static int nt_store_ace(REG_HANDLE *regf, SEC_ACE *ace, uint8_t *locn)
 /*
  * Store an ACL at the location provided
  */
-static int nt_store_acl(REG_HANDLE *regf, SEC_ACL *acl, uint8_t *locn) {
+static int nt_store_acl(struct registry_hive *regf, SEC_ACL *acl, uint8_t *locn) {
 	int size = 0, i;
 	uint8_t *p = locn, *s;
 
@@ -1357,7 +1361,7 @@ static int nt_store_acl(REG_HANDLE *regf, SEC_ACL *acl, uint8_t *locn) {
  * that first, then the owner, then the group SID. So, we do it that way
  * too.
  */
-static uint_t nt_store_sec_desc(REG_HANDLE *regf, SEC_DESC *sd, char *locn)
+static uint_t nt_store_sec_desc(struct registry_hive *regf, SEC_DESC *sd, char *locn)
 {
 	SEC_DESC *rsd = (SEC_DESC *)locn;
 	uint_t size = 0, off = 0;
@@ -1424,7 +1428,7 @@ static uint_t nt_store_sec_desc(REG_HANDLE *regf, SEC_DESC *sd, char *locn)
  * If it has already been stored, just get its offset from record
  * otherwise, store it and record its offset
  */
-static uint_t nt_store_security(REG_HANDLE *regf, KEY_SEC_DESC *sec)
+static uint_t nt_store_security(struct registry_hive *regf, KEY_SEC_DESC *sec)
 {
 	int size = 0;
 	uint_t sk_off;
@@ -1480,7 +1484,7 @@ static uint_t nt_store_security(REG_HANDLE *regf, KEY_SEC_DESC *sec)
  * We return the offset of the NK struct
  * FIXME, FIXME, FIXME: Convert to using SIVAL and SSVAL ...
  */
-static int nt_store_reg_key(REG_HANDLE *regf, REG_KEY *key)
+static int nt_store_reg_key(struct registry_hive *regf, struct registry_key *key)
 {
 	NK_HDR *nk_hdr; 
 	uint_t nk_off, sk_off, size;
@@ -1543,7 +1547,7 @@ error:
  * We actually create the registry header block and link it to the chain
  * of output blocks.
  */
-static REGF_HDR *nt_get_reg_header(REG_HANDLE *h) {
+static REGF_HDR *nt_get_reg_header(struct registry_hive *h) {
 	REGF *regf = h->backend_data;
 	HBIN_BLK *tmp = NULL;
 
@@ -1567,7 +1571,7 @@ error:
 
 #endif
 
-static WERROR nt_close_registry (REG_HANDLE *h) 
+static WERROR nt_close_registry (struct registry_hive *h) 
 {
 	REGF *regf = h->backend_data;
 	if (regf->base) munmap(regf->base, regf->sbuf.st_size);
@@ -1577,16 +1581,16 @@ static WERROR nt_close_registry (REG_HANDLE *h)
 	return WERR_OK;
 }
 
-static WERROR nt_open_registry (REG_HANDLE *h, const char *location, const char *credentials) 
+static WERROR nt_open_hive (TALLOC_CTX *mem_ctx, struct registry_hive *h, struct registry_key **key)
 {
 	REGF *regf;
 	REGF_HDR *regf_hdr;
 	uint_t regf_id, hbin_id;
 	HBIN_HDR *hbin_hdr;
 
-	regf = (REGF *)talloc_p(h->mem_ctx, REGF);
+	regf = (REGF *)talloc_p(mem_ctx, REGF);
 	memset(regf, 0, sizeof(REGF));
-	regf->owner_sid_str = credentials;
+	regf->owner_sid_str = h->credentials;
 	h->backend_data = regf;
 
 	DEBUG(5, ("Attempting to load registry file\n"));
@@ -1659,18 +1663,13 @@ static WERROR nt_open_registry (REG_HANDLE *h, const char *location, const char
 
 	h->backend_data = regf;
 
-	return WERR_OK;
+	return nk_to_key(mem_ctx, h, ((REGF *)h->backend_data)->first_key, BLK_SIZE(((REGF *)h->backend_data)->first_key), NULL, key);
 }
 
-static WERROR nt_get_root_key(REG_HANDLE *h, int hive, REG_KEY **key) 
-{ 
-	if(hive != 0) return WERR_NO_MORE_ITEMS;
-	return nk_to_key(h, ((REGF *)h->backend_data)->first_key, BLK_SIZE(((REGF *)h->backend_data)->first_key), NULL, key);
-}
 
-static WERROR nt_num_subkeys(REG_KEY *k, int *num) 
+static WERROR nt_num_subkeys(struct registry_key *k, int *num) 
 {
-	REGF *regf = k->handle->backend_data;
+	REGF *regf = k->hive->backend_data;
 	LF_HDR *lf_hdr;
 	int lf_off;
 	NK_HDR *nk_hdr = k->backend_data;
@@ -1682,23 +1681,23 @@ static WERROR nt_num_subkeys(REG_KEY *k, int *num)
 	}
 	lf_hdr = (LF_HDR *)LOCN(regf->base, lf_off);
 
-	return lf_num_entries(k->handle, lf_hdr, BLK_SIZE(lf_hdr), num);
+	return lf_num_entries(k->hive, lf_hdr, BLK_SIZE(lf_hdr), num);
 }
 
-static WERROR nt_num_values(REG_KEY *k, int *count)
+static WERROR nt_num_values(struct registry_key *k, int *count)
 {
 	NK_HDR *nk_hdr = k->backend_data;
 	*count = IVAL(&nk_hdr->val_cnt,0);
 	return WERR_OK;
 }
 
-static WERROR nt_value_by_index(REG_KEY *k, int n, REG_VAL **value)
+static WERROR nt_value_by_index(TALLOC_CTX *mem_ctx, struct registry_key *k, int n, struct registry_value **value)
 {
 	VL_TYPE *vl;
 	int val_off, vk_off;
 	int val_count;
 	VK_HDR *vk_hdr;
-	REGF *regf = k->handle->backend_data;
+	REGF *regf = k->hive->backend_data;
 	NK_HDR *nk_hdr = k->backend_data;
 	val_count = IVAL(&nk_hdr->val_cnt,0);
 	val_off = IVAL(&nk_hdr->val_off,0);
@@ -1709,12 +1708,12 @@ static WERROR nt_value_by_index(REG_KEY *k, int n, REG_VAL **value)
 
 	vk_off = IVAL(&vl[n],0);
 	vk_hdr = (VK_HDR *)LOCN(regf->base, vk_off);
-	return vk_to_val(k, vk_hdr, BLK_SIZE(vk_hdr), value);
+	return vk_to_val(mem_ctx, k, vk_hdr, BLK_SIZE(vk_hdr), value);
 }
 
-static WERROR nt_key_by_index(REG_KEY *k, int n, REG_KEY **subkey)
+static WERROR nt_key_by_index(TALLOC_CTX *mem_ctx, struct registry_key *k, int n, struct registry_key **subkey)
 {
-	REGF *regf = k->handle->backend_data;
+	REGF *regf = k->hive->backend_data;
 	int lf_off;
 	NK_HDR *nk_hdr = k->backend_data;
 	LF_HDR *lf_hdr;
@@ -1727,17 +1726,15 @@ static WERROR nt_key_by_index(REG_KEY *k, int n, REG_KEY **subkey)
 
 	if (lf_off != -1) {
 		lf_hdr = (LF_HDR *)LOCN(regf->base, lf_off);
-		return lf_get_entry(k, lf_hdr, BLK_SIZE(lf_hdr), n, subkey);
+		return lf_get_entry(mem_ctx, k, lf_hdr, BLK_SIZE(lf_hdr), n, subkey);
 	}
 
 	return WERR_NO_MORE_ITEMS;
 }
 
-static struct registry_ops reg_backend_nt4 = {
+static struct registry_operations reg_backend_nt4 = {
 	.name = "nt4",
-	.open_registry = nt_open_registry,
-	.close_registry = nt_close_registry,
-	.get_hive = nt_get_root_key,
+	.open_hive = nt_open_hive,
 	.num_subkeys = nt_num_subkeys,
 	.num_values = nt_num_values,
 	.get_subkey_by_index = nt_key_by_index,
diff --git a/source4/lib/registry/reg_backend_rpc/reg_backend_rpc.c b/source4/lib/registry/reg_backend_rpc/reg_backend_rpc.c
index 0d8d935a4a..1c887fc411 100644
--- a/source4/lib/registry/reg_backend_rpc/reg_backend_rpc.c
+++ b/source4/lib/registry/reg_backend_rpc/reg_backend_rpc.c
@@ -18,7 +18,6 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  
 #include "includes.h"
-#include "lib/registry/common/registry.h"
 
 /**
  * This is the RPC backend for the registry library.
@@ -37,7 +36,7 @@ static void init_winreg_String(struct winreg_String *name, const char *s)
 }
 
 
-#define openhive(u) static WERROR open_ ## u(struct dcerpc_pipe *p, REG_KEY *h, struct policy_handle *hnd) \
+#define openhive(u) static WERROR open_ ## u(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct policy_handle *hnd) \
 { \
 	struct winreg_Open ## u r; \
 	struct winreg_OpenUnknown unknown; \
@@ -49,7 +48,7 @@ static void init_winreg_String(struct winreg_String *name, const char *s)
 	r.in.access_required = SEC_RIGHTS_MAXIMUM_ALLOWED; \
 	r.out.handle = hnd;\
 	\
-	status = dcerpc_winreg_Open ## u(p, h->mem_ctx, &r); \
+	status = dcerpc_winreg_Open ## u(p, mem_ctx, &r); \
 	if (NT_STATUS_IS_ERR(status)) {\
 		DEBUG(0,("Error executing open\n"));\
 		return ntstatus_to_werror(status);\
@@ -74,7 +73,7 @@ struct rpc_key_data {
 
 struct {
 	const char *name;
-	WERROR (*open) (struct dcerpc_pipe *p, REG_KEY *k, struct policy_handle *h);
+	WERROR (*open) (struct dcerpc_pipe *p, TALLOC_CTX *, struct policy_handle *h);
 } known_hives[] = {
 { "HKEY_LOCAL_MACHINE", open_HKLM },
 { "HKEY_CURRENT_USER", open_HKCU },
@@ -84,122 +83,124 @@ struct {
 { NULL, NULL }
 };
 
-static WERROR rpc_query_key(REG_KEY *k);
+static WERROR rpc_query_key(struct registry_key *k);
 
-static WERROR rpc_open_registry(REG_HANDLE *h, const char *location, const char *credentials)
+WERROR rpc_list_hives (TALLOC_CTX *mem_ctx, const char *location, const char *credentials, char ***hives)
+{
+	int i = 0;
+	*hives = talloc_p(mem_ctx, char *);
+	for(i = 0; known_hives[i].name; i++) {
+		*hives = talloc_realloc_p(*hives, char *, i+2);
+		(*hives)[i] = talloc_strdup(mem_ctx, known_hives[i].name);
+	}
+	(*hives)[i] = NULL;
+	return WERR_OK;
+}
+
+static WERROR rpc_open_hive(TALLOC_CTX *mem_ctx, struct registry_hive *h, struct registry_key **k)
 {
 	NTSTATUS status;
 	char *user, *pass;
+	struct rpc_key_data *mykeydata;
+	struct dcerpc_pipe *p;
+	int n;
 
-	if(!credentials || !location) return WERR_INVALID_PARAM;
+	if(!h->credentials || !h->location) return WERR_INVALID_PARAM;
 
-	user = talloc_strdup(h->mem_ctx, credentials);
+	user = talloc_strdup(mem_ctx, h->credentials);
 	pass = strchr(user, '%');
-	*pass = '\0'; pass++;
+	if(pass) 
+	{
+		*pass = '\0'; pass++;
+	} else {
+		pass = "";
+	}
 
-	status = dcerpc_pipe_connect((struct dcerpc_pipe **)&h->backend_data, h->location, 
+	status = dcerpc_pipe_connect(&p, h->location, 
                     DCERPC_WINREG_UUID,
                     DCERPC_WINREG_VERSION,
                      lp_workgroup(),
                      user, pass);
-	
-	return ntstatus_to_werror(status);
-}
 
-static WERROR rpc_get_hive(REG_HANDLE *h, int n, REG_KEY **k)
-{
-	struct rpc_key_data *mykeydata;
-	WERROR error;
+	h->backend_data = p;
+
+	if(NT_STATUS_IS_ERR(status)) return ntstatus_to_werror(status);
+
+	for(n = 0; known_hives[n].name; n++) 
+	{
+		if(!strcmp(known_hives[n].name, h->backend_hivename)) break;
+	}
+	
 	if(!known_hives[n].name) return WERR_NO_MORE_ITEMS;
-	*k = reg_key_new_abs(known_hives[n].name, h, NULL);
-	(*k)->backend_data = mykeydata = talloc_p((*k)->mem_ctx, struct rpc_key_data);
+	
+	*k = talloc_p(mem_ctx, struct registry_key);
+	(*k)->backend_data = mykeydata = talloc_p(mem_ctx, struct rpc_key_data);
 	mykeydata->num_values = -1;
 	mykeydata->num_subkeys = -1;
-	error = known_hives[n].open((struct dcerpc_pipe *)h->backend_data, *k, &mykeydata->pol);
-	return error;
+	return known_hives[n].open((struct dcerpc_pipe *)h->backend_data, *k, &(mykeydata->pol));
 }
 
-static WERROR rpc_close_registry(REG_HANDLE *h)
+static WERROR rpc_close_registry(struct registry_hive *h)
 {
 	dcerpc_pipe_close((struct dcerpc_pipe *)h->backend_data);
 	return WERR_OK;
 }
 
-static WERROR rpc_key_put_rpc_data(REG_KEY *k, struct rpc_key_data **data)
+static WERROR rpc_key_put_rpc_data(TALLOC_CTX *mem_ctx, struct registry_key *k)
 {
     struct winreg_OpenKey r;
-	WERROR error;
-	REG_KEY *hivekey;
 	struct rpc_key_data *mykeydata;
 
-	if(k->backend_data) { 
-		*data = k->backend_data; 
-		return WERR_OK;
-	}
-
-	k->backend_data = mykeydata = talloc_p(k->mem_ctx, struct rpc_key_data);
-	*data = mykeydata;
+	k->backend_data = mykeydata = talloc_p(mem_ctx, struct rpc_key_data);
 	mykeydata->num_values = -1;
 	mykeydata->num_subkeys = -1;
 
 	/* Then, open the handle using the hive */
 
 	memset(&r, 0, sizeof(struct winreg_OpenKey));
-	error = rpc_get_hive(k->handle, k->hive, &hivekey);
-	if(!W_ERROR_IS_OK(error))return error;
-    r.in.handle = &(((struct rpc_key_data *)hivekey->backend_data)->pol);
-    init_winreg_String(&r.in.keyname, reg_key_get_path(k));
+    r.in.handle = &(((struct rpc_key_data *)k->hive->root->backend_data)->pol);
+    init_winreg_String(&r.in.keyname, k->path);
     r.in.unknown = 0x00000000;
     r.in.access_mask = 0x02000000;
     r.out.handle = &mykeydata->pol;
 
-    dcerpc_winreg_OpenKey((struct dcerpc_pipe *)k->handle->backend_data, k->mem_ctx, &r);
+    dcerpc_winreg_OpenKey((struct dcerpc_pipe *)k->hive->backend_data, mem_ctx, &r);
 
 	return r.out.result;
 }
 
-static WERROR rpc_open_key(REG_HANDLE *h, int hive, const char *name, REG_KEY **key)
+static WERROR rpc_open_key(TALLOC_CTX *mem_ctx, struct registry_hive *h, const char *name, struct registry_key **key)
 {
 	struct rpc_key_data *mykeydata;
     struct winreg_OpenKey r;
-	REG_KEY *hivekey;
-	WERROR error;
-	
-	*key = reg_key_new_abs(name, h, NULL);
 
-	(*key)->backend_data = mykeydata = talloc_p((*key)->mem_ctx, struct rpc_key_data);
+	*key = talloc_p(mem_ctx, struct registry_key);
+	(*key)->name = talloc_strdup(mem_ctx, name);
+
+	(*key)->backend_data = mykeydata = talloc_p(mem_ctx, struct rpc_key_data);
 	mykeydata->num_values = -1;
 	mykeydata->num_subkeys = -1;
 
 	/* Then, open the handle using the hive */
 
 	memset(&r, 0, sizeof(struct winreg_OpenKey));
-	error = rpc_get_hive(h, hive, &hivekey);
-	if(!W_ERROR_IS_OK(error))return error;
-    r.in.handle = &(((struct rpc_key_data *)hivekey->backend_data)->pol);
+    r.in.handle = &(((struct rpc_key_data *)h->root->backend_data)->pol);
     init_winreg_String(&r.in.keyname, name);
     r.in.unknown = 0x00000000;
     r.in.access_mask = 0x02000000;
     r.out.handle = &mykeydata->pol;
 
-    dcerpc_winreg_OpenKey((struct dcerpc_pipe *)(*key)->handle->backend_data, (*key)->mem_ctx, &r);
+    dcerpc_winreg_OpenKey((struct dcerpc_pipe *)(h->backend_data), mem_ctx, &r);
 
 	return r.out.result;
 }
 
-static WERROR rpc_get_value_by_index(REG_KEY *parent, int n, REG_VAL **value)  
+static WERROR rpc_get_value_by_index(TALLOC_CTX *mem_ctx, struct registry_key *parent, int n, struct registry_value **value)  
 {
-	struct winreg_EnumValue r;
-	struct winreg_Uint8buf vb;
-	struct winreg_EnumValueName vn;
-	NTSTATUS status;
-	struct rpc_key_data *mykeydata;
-	uint32_t type = 0x0, requested_len = 0, returned_len = 0;
+	struct rpc_key_data *mykeydata = parent->backend_data;
+	uint32_t requested_len = 0;
 	WERROR error;
 
-	error = rpc_key_put_rpc_data(parent, &mykeydata);
-	if(!W_ERROR_IS_OK(error)) return error;
-
 	if(mykeydata->num_values == -1) {
 		error = rpc_query_key(parent);
 		if(!W_ERROR_IS_OK(error)) return error;
@@ -207,6 +208,7 @@ static WERROR rpc_get_value_by_index(REG_KEY *parent, int n, REG_VAL **value)
 
 	requested_len = mykeydata->max_valdatalen;
 
+#if 0 /* EnumValue is not working yet ... */
 	r.in.handle = &mykeydata->pol;
 	r.in.enum_index = n;
 	r.in.type = r.out.type = &type;
@@ -225,7 +227,7 @@ static WERROR rpc_get_value_by_index(REG_KEY *parent, int n, REG_VAL **value)
 	vb.max_len = mykeydata->max_valdatalen;
 	vb.offset = 0x0;
 	vb.len = 0x0;
-	vb.buffer = talloc_array_p(parent->mem_ctx, uint8, mykeydata->max_valdatalen);
+	vb.buffer = talloc_array_p(mem_ctx, uint8, mykeydata->max_valdatalen);
 	r.in.value = r.out.value = &vb;
 
 	status = dcerpc_winreg_EnumValue((struct dcerpc_pipe *)parent->handle->backend_data, parent->mem_ctx, &r);
@@ -242,23 +244,20 @@ static WERROR rpc_get_value_by_index(REG_KEY *parent, int n, REG_VAL **value)
 		exit(1);
 		return WERR_OK;
 	}
+#endif
 	
-	return r.out.result;
+	return WERR_NOT_SUPPORTED;
 }
 
-static WERROR rpc_get_subkey_by_index(REG_KEY *parent, int n, REG_KEY **subkey) 
+static WERROR rpc_get_subkey_by_index(TALLOC_CTX *mem_ctx, struct registry_key *parent, int n, struct registry_key **subkey) 
 {
 	struct winreg_EnumKey r;
 	struct winreg_EnumKeyNameRequest keyname;
 	struct winreg_String classname;
 	struct winreg_Time tm;
 	struct rpc_key_data *mykeydata = parent->backend_data;
-	WERROR error;
 	NTSTATUS status;
 
-	error = rpc_key_put_rpc_data(parent, &mykeydata);
-	if(!W_ERROR_IS_OK(error)) return error;
-
 	r.in.handle = &mykeydata->pol;
 	keyname.unknown = 0x0000020a;
 	init_winreg_String(&keyname.key_name, NULL);
@@ -271,40 +270,33 @@ static WERROR rpc_get_subkey_by_index(REG_KEY *parent, int n, REG_KEY **subkey)
 	r.in.enum_index = n;
 	r.in.unknown = r.out.unknown = 0x0414;
 	r.in.key_name_len = r.out.key_name_len = 0;
-	status = dcerpc_winreg_EnumKey((struct dcerpc_pipe *)parent->handle->backend_data, parent->mem_ctx, &r);
+	status = dcerpc_winreg_EnumKey((struct dcerpc_pipe *)parent->hive->backend_data, mem_ctx, &r);
 	if(NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(r.out.result)) {
-		*subkey = reg_key_new_rel(r.out.out_name->name, parent, NULL);
+		if(parent->hive->root == parent)
+			return rpc_open_key(mem_ctx, parent->hive, talloc_strdup(mem_ctx, r.out.out_name->name), subkey);
+		return rpc_open_key(mem_ctx, parent->hive, talloc_asprintf(mem_ctx, "%s\\%s", parent->path, r.out.out_name->name), subkey);
 	}
 
 	return r.out.result;
 }
 
-static WERROR rpc_add_key(REG_KEY *parent, const char *name, uint32_t access_mask, SEC_DESC *sec, REG_KEY **key)
+static WERROR rpc_add_key(TALLOC_CTX *mem_ctx, struct registry_key *parent, const char *name, uint32_t access_mask, SEC_DESC *sec, struct registry_key **key)
 {
-	struct rpc_key_data *mykeydata;
-	WERROR error;
-
-	error = rpc_key_put_rpc_data(parent, &mykeydata);
-	if(!W_ERROR_IS_OK(error)) return error;
-
-	/* FIXME */
 	return WERR_NOT_SUPPORTED;
 }
 
-static WERROR rpc_query_key(REG_KEY *k)
+static WERROR rpc_query_key(struct registry_key *k)
 {
     NTSTATUS status;
-	WERROR error;
     struct winreg_QueryInfoKey r;
-    struct rpc_key_data *mykeydata;
-
-	error = rpc_key_put_rpc_data(k, &mykeydata);
-	if(!W_ERROR_IS_OK(error)) return error;
+    struct rpc_key_data *mykeydata = k->backend_data;
+	TALLOC_CTX *mem_ctx = talloc_init("query_key");
 
     init_winreg_String(&r.in.class, NULL);
     r.in.handle = &mykeydata->pol;
 	
-    status = dcerpc_winreg_QueryInfoKey((struct dcerpc_pipe *)k->handle->backend_data, k->mem_ctx, &r);
+    status = dcerpc_winreg_QueryInfoKey((struct dcerpc_pipe *)(k->hive->backend_data), mem_ctx, &r);
+	talloc_destroy(mem_ctx);
 
     if (!NT_STATUS_IS_OK(status)) {
         printf("QueryInfoKey failed - %s\n", nt_errstr(status));
@@ -321,40 +313,37 @@ static WERROR rpc_query_key(REG_KEY *k)
 	return r.out.result;
 }
 
-static WERROR rpc_del_key(REG_KEY *k)
+static WERROR rpc_del_key(struct registry_key *k)
 {
 	NTSTATUS status;
 	struct rpc_key_data *mykeydata = k->backend_data;
 	struct winreg_DeleteKey r;
-	REG_KEY *parent;
+	struct registry_key *parent;
 	WERROR error;
+	TALLOC_CTX *mem_ctx = talloc_init("del_key");
 	
-	error = reg_key_get_parent(k, &parent);
-	if(!W_ERROR_IS_OK(error)) return error;
+	error = reg_key_get_parent(mem_ctx, k, &parent);
+	if(!W_ERROR_IS_OK(error)) { 
+		talloc_destroy(mem_ctx); 
+		return error; 
+	}
+
+	mykeydata = parent->backend_data;
 
-	error = rpc_key_put_rpc_data(parent, &mykeydata);
-	if(!W_ERROR_IS_OK(error)) return error;
-	
     r.in.handle = &mykeydata->pol;
     init_winreg_String(&r.in.key, k->name);
  
-    status = dcerpc_winreg_DeleteKey((struct dcerpc_pipe *)k->handle->backend_data, k->mem_ctx, &r);
+    status = dcerpc_winreg_DeleteKey((struct dcerpc_pipe *)k->hive->backend_data, mem_ctx, &r);
 
-	return r.out.result;
-}
+	talloc_destroy(mem_ctx);
 
-static void rpc_close_key(REG_KEY *k)
-{
-	reg_key_free(k);
+	return r.out.result;
 }
 
-static WERROR rpc_num_values(REG_KEY *key, int *count) {
+static WERROR rpc_num_values(struct registry_key *key, int *count) {
 	struct rpc_key_data *mykeydata = key->backend_data;
 	WERROR error;
 		
-	error = rpc_key_put_rpc_data(key, &mykeydata);
-	if(!W_ERROR_IS_OK(error)) return error;
-
 	if(mykeydata->num_values == -1) {
 		error = rpc_query_key(key);
 		if(!W_ERROR_IS_OK(error)) return error;
@@ -364,13 +353,10 @@ static WERROR rpc_num_values(REG_KEY *key, int *count) {
 	return WERR_OK;
 }
 
-static WERROR rpc_num_subkeys(REG_KEY *key, int *count) {
+static WERROR rpc_num_subkeys(struct registry_key *key, int *count) {
 	struct rpc_key_data *mykeydata = key->backend_data;
 	WERROR error;
 
-	error = rpc_key_put_rpc_data(key, &mykeydata);
-	if(!W_ERROR_IS_OK(error)) return error;
-	
 	if(mykeydata->num_subkeys == -1) {
 		error = rpc_query_key(key);
 		if(!W_ERROR_IS_OK(error)) return error;
@@ -380,19 +366,17 @@ static WERROR rpc_num_subkeys(REG_KEY *key, int *count) {
 	return WERR_OK;
 }
 
-static struct registry_ops reg_backend_rpc = {
+static struct registry_operations reg_backend_rpc = {
 	.name = "rpc",
-	.open_registry = rpc_open_registry,
-	.close_registry = rpc_close_registry,
-	.get_hive = rpc_get_hive,
+	.open_hive = rpc_open_hive,
 	.open_key = rpc_open_key,
 	.get_subkey_by_index = rpc_get_subkey_by_index,
 	.get_value_by_index = rpc_get_value_by_index,
 	.add_key = rpc_add_key,
 	.del_key = rpc_del_key,
-	.free_key_backend_data = rpc_close_key,
 	.num_subkeys = rpc_num_subkeys,
 	.num_values = rpc_num_values,
+	.list_available_hives = rpc_list_hives,
 };
 
 NTSTATUS registry_rpc_init(void)
diff --git a/source4/lib/registry/reg_backend_w95/reg_backend_w95.c b/source4/lib/registry/reg_backend_w95/reg_backend_w95.c
index f392759b8d..2184a8855d 100644
--- a/source4/lib/registry/reg_backend_w95/reg_backend_w95.c
+++ b/source4/lib/registry/reg_backend_w95/reg_backend_w95.c
@@ -20,7 +20,6 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 #include "includes.h"
-#include "lib/registry/common/registry.h"
 
 /**
  * The registry starts with a header that contains pointers to 
@@ -179,67 +178,18 @@ static void parse_rgdb_block(CREG *creg, RGDB_HDR *rgdb_hdr)
 	}
 }
 
-static WERROR w95_open_root (REG_HANDLE *h, int hive, REG_KEY **key)
-{
-	CREG *creg = h->backend_data;
-
-	if(hive != 0) return WERR_NO_MORE_ITEMS;
-	
-	/* First element in rgkn should be root key */
-	*key = reg_key_new_abs("", h, LOCN_RGKN(creg, sizeof(RGKN_HDR)));
-	
-	return WERR_OK;
-}
-
-static WERROR w95_get_subkey_by_index (REG_KEY *parent, int n, REG_KEY **key)
-{
-	CREG *creg = parent->handle->backend_data;
-	RGKN_KEY *rgkn_key = parent->backend_data;
-	RGKN_KEY *child;
-	DWORD child_offset;
-	DWORD cur = 0;
-	
-	/* Get id of first child */
-	child_offset = rgkn_key->first_child_offset;
-
-	while(child_offset != 0xFFFFFFFF) {
-		child = LOCN_RGKN(creg, child_offset);
-
-		/* n == cur ? return! */
-		if(cur == n) {
-			RGDB_KEY *rgdb_key;
-			char *name;
-			rgdb_key = LOCN_RGDB_KEY(creg, child->id.rgdb, child->id.id);
-			if(!rgdb_key) {
-				DEBUG(0, ("Can't find %d,%d in RGDB table!\n", child->id.rgdb, child->id.id));
-				return WERR_FOOBAR;
-			}
-			name = strndup((char *)rgdb_key + sizeof(RGDB_KEY), rgdb_key->name_len);
-			*key = reg_key_new_rel(name, parent, child);
-			SAFE_FREE(name);
-			return WERR_OK;
-		}
-
-		cur++;
-		
-		child_offset = child->next_offset;
-	}
-
-	return WERR_NO_MORE_ITEMS;
-}
-
-static WERROR w95_open_reg (REG_HANDLE *h, const char *location, const char *credentials)
+static WERROR w95_open_reg (TALLOC_CTX *mem_ctx, struct registry_hive *h, struct registry_key **root)
 {
 	CREG *creg;
 	DWORD creg_id, rgkn_id;
 	DWORD i;
 	DWORD offset;
 
-	creg = talloc_p(h->mem_ctx, CREG);
+	creg = talloc_p(mem_ctx, CREG);
 	memset(creg, 0, sizeof(CREG));
 	h->backend_data = creg;
 
-	if((creg->fd = open(location, O_RDONLY, 0000)) < 0) {
+	if((creg->fd = open(h->location, O_RDONLY, 0000)) < 0) {
 		return WERR_FOOBAR;
 	}
 
@@ -250,7 +200,7 @@ static WERROR w95_open_reg (REG_HANDLE *h, const char *location, const char *cre
     creg->base = mmap(0, creg->sbuf.st_size, PROT_READ, MAP_SHARED, creg->fd, 0);
                                                                                                                                               
     if ((int)creg->base == 1) {
-		DEBUG(0,("Could not mmap file: %s, %s\n", location, strerror(errno)));
+		DEBUG(0,("Could not mmap file: %s, %s\n", h->location, strerror(errno)));
         return WERR_FOOBAR;
     }
 
@@ -258,7 +208,7 @@ static WERROR w95_open_reg (REG_HANDLE *h, const char *location, const char *cre
 
 	if ((creg_id = IVAL(&creg->creg_hdr->CREG_ID,0)) != str_to_dword("CREG")) {
 		DEBUG(0, ("Unrecognized Windows 95 registry header id: 0x%0X, %s\n", 
-				  creg_id, location));
+				  creg_id, h->location));
 		return WERR_FOOBAR;
 	}
 
@@ -266,7 +216,7 @@ static WERROR w95_open_reg (REG_HANDLE *h, const char *location, const char *cre
 
 	if ((rgkn_id = IVAL(&creg->rgkn_hdr->RGKN_ID,0)) != str_to_dword("RGKN")) {
 		DEBUG(0, ("Unrecognized Windows 95 registry key index id: 0x%0X, %s\n", 
-				  rgkn_id, location));
+				  rgkn_id, h->location));
 		return WERR_FOOBAR;
 	}
 
@@ -282,7 +232,7 @@ static WERROR w95_open_reg (REG_HANDLE *h, const char *location, const char *cre
 	}
 #endif
 
-	creg->rgdb_keys = talloc_array_p(h->mem_ctx, RGDB_KEY **, creg->creg_hdr->num_rgdb);
+	creg->rgdb_keys = talloc_array_p(mem_ctx, RGDB_KEY **, creg->creg_hdr->num_rgdb);
 
 	offset = 0;
 	DEBUG(3, ("Reading %d rgdb entries\n", creg->creg_hdr->num_rgdb));
@@ -291,14 +241,14 @@ static WERROR w95_open_reg (REG_HANDLE *h, const char *location, const char *cre
 		
 		if(strncmp((char *)&(rgdb_hdr->RGDB_ID), "RGDB", 4)) {
 			DEBUG(0, ("unrecognized rgdb entry: %4d, %s\n", 
-					  rgdb_hdr->RGDB_ID, location));
+					  rgdb_hdr->RGDB_ID, h->location));
 			return WERR_FOOBAR;
 		} else {
 			DEBUG(3, ("Valid rgdb entry, first free id: %d, max id: %d\n", rgdb_hdr->first_free_id, rgdb_hdr->max_id));
 		}
 
 
-		creg->rgdb_keys[i] = talloc_array_p(h->mem_ctx, RGDB_KEY *, rgdb_hdr->max_id+1);
+		creg->rgdb_keys[i] = talloc_array_p(mem_ctx, RGDB_KEY *, rgdb_hdr->max_id+1);
 		memset(creg->rgdb_keys[i], 0, sizeof(RGDB_KEY *) * (rgdb_hdr->max_id+1));
 
 		parse_rgdb_block(creg, rgdb_hdr);
@@ -306,11 +256,51 @@ static WERROR w95_open_reg (REG_HANDLE *h, const char *location, const char *cre
 		offset+=rgdb_hdr->size;
 	}
 	
-
+	/* First element in rgkn should be root key */
+	*root = talloc_p(mem_ctx, struct registry_key);
+	(*root)->name = NULL;
+	(*root)->backend_data = LOCN_RGKN(creg, sizeof(RGKN_HDR));
+	
 	return WERR_OK;
 }
 
-static WERROR w95_close_reg(REG_HANDLE *h)
+static WERROR w95_get_subkey_by_index (TALLOC_CTX *mem_ctx, struct registry_key *parent, int n, struct registry_key **key)
+{
+	CREG *creg = parent->hive->backend_data;
+	RGKN_KEY *rgkn_key = parent->backend_data;
+	RGKN_KEY *child;
+	DWORD child_offset;
+	DWORD cur = 0;
+	
+	/* Get id of first child */
+	child_offset = rgkn_key->first_child_offset;
+
+	while(child_offset != 0xFFFFFFFF) {
+		child = LOCN_RGKN(creg, child_offset);
+
+		/* n == cur ? return! */
+		if(cur == n) {
+			RGDB_KEY *rgdb_key;
+			rgdb_key = LOCN_RGDB_KEY(creg, child->id.rgdb, child->id.id);
+			if(!rgdb_key) {
+				DEBUG(0, ("Can't find %d,%d in RGDB table!\n", child->id.rgdb, child->id.id));
+				return WERR_FOOBAR;
+			}
+			*key = talloc_p(mem_ctx, struct registry_key);
+			(*key)->backend_data = child;
+			(*key)->name = talloc_strndup(mem_ctx, (char *)rgdb_key + sizeof(RGDB_KEY), rgdb_key->name_len);
+			return WERR_OK;
+		}
+
+		cur++;
+		
+		child_offset = child->next_offset;
+	}
+
+	return WERR_NO_MORE_ITEMS;
+}
+
+static WERROR w95_close_reg(struct registry_hive *h)
 {
 	CREG *creg = h->backend_data;
 	if (creg->base) munmap(creg->base, creg->sbuf.st_size);
@@ -319,47 +309,51 @@ static WERROR w95_close_reg(REG_HANDLE *h)
 	return WERR_OK;
 }
 
+static WERROR w95_num_values(struct registry_key *k, int *count)
+{
+	RGKN_KEY *rgkn_key = k->backend_data;
+	RGDB_KEY *rgdb_key = LOCN_RGDB_KEY((CREG *)k->hive->backend_data, rgkn_key->id.rgdb, rgkn_key->id.id);
+
+	if(!rgdb_key) return WERR_FOOBAR;
+	
+	*count = rgdb_key->num_values;
+	
+	return WERR_OK;
+}
 
-static WERROR w95_fetch_values(REG_KEY *k, int *count, REG_VAL ***values)
+static WERROR w95_get_value_by_id(TALLOC_CTX *mem_ctx, struct registry_key *k, int idx, struct registry_value **value)
 {
 	RGKN_KEY *rgkn_key = k->backend_data;
 	DWORD i;
 	DWORD offset = 0;
-	RGDB_KEY *rgdb_key = LOCN_RGDB_KEY((CREG *)k->handle->backend_data, rgkn_key->id.rgdb, rgkn_key->id.id);
+	RGDB_KEY *rgdb_key = LOCN_RGDB_KEY((CREG *)k->hive->backend_data, rgkn_key->id.rgdb, rgkn_key->id.id);
+	RGDB_VALUE *curval;
 
 	if(!rgdb_key) return WERR_FOOBAR;
 	
-	*count = rgdb_key->num_values;
+	if(idx >= rgdb_key->num_values) return WERR_NO_MORE_ITEMS;
 	
-	if((*count) == 0) return WERR_OK;
+	for(i = 0; i < idx; i++) {
+		curval = (RGDB_VALUE *)(((char *)rgdb_key) + sizeof(RGDB_KEY) + rgdb_key->name_len + offset);
+		offset+=sizeof(RGDB_VALUE) + curval->name_len + curval->data_len;
+	}
 
-	(*values) = talloc_array_p(k->mem_ctx, REG_VAL *, (*count)+1);
-	for(i = 0; i < rgdb_key->num_values; i++) {
-		RGDB_VALUE *val = (RGDB_VALUE *)(((char *)rgdb_key) + sizeof(RGDB_KEY) + rgdb_key->name_len + offset);
-		(*values)[i] = reg_val_new(k, val);
-		
-		/* Name */
-		(*values)[i]->name = talloc_strndup(k->mem_ctx, (char *)val+sizeof(RGDB_VALUE), val->name_len);
+	*value = talloc_p(mem_ctx, struct registry_value);
+	(*value)->backend_data = curval;
+	(*value)->name = talloc_strndup(mem_ctx, (char *)curval+sizeof(RGDB_VALUE), curval->name_len);
 		
-		/* Value */
-		(*values)[i]->data_len = val->data_len;
-		(*values)[i]->data_blk = talloc_memdup((*values)[i]->mem_ctx, (char *)val+sizeof(RGDB_VALUE)+val->name_len, val->data_len);
-
-		/* Type */
-		(*values)[i]->data_type = val->type;
-
-		offset+=sizeof(RGDB_VALUE) + val->name_len + val->data_len;
-	}
+	(*value)->data_len = curval->data_len;
+	(*value)->data_blk = talloc_memdup(mem_ctx, (char *)curval+sizeof(RGDB_VALUE)+curval->name_len, curval->data_len);
+	(*value)->data_type = curval->type;
 	
 	return WERR_OK;
 }
 
-static struct registry_ops reg_backend_w95 = {
+static struct registry_operations reg_backend_w95 = {
 	.name = "w95",
-	.open_registry = w95_open_reg,
-	.close_registry = w95_close_reg,
-	.get_hive = w95_open_root,
-	.fetch_values = w95_fetch_values,
+	.open_hive = w95_open_reg,
+	.get_value_by_index = w95_get_value_by_id,
+	.num_values = w95_num_values,
 	.get_subkey_by_index = w95_get_subkey_by_index,
 };
 
diff --git a/source4/lib/registry/tools/regdiff.c b/source4/lib/registry/tools/regdiff.c
index c46411ae31..524e538591 100644
--- a/source4/lib/registry/tools/regdiff.c
+++ b/source4/lib/registry/tools/regdiff.c
@@ -21,47 +21,57 @@
 
 #include "includes.h"
 
-static void writediff(REG_KEY *oldkey, REG_KEY *newkey, FILE *out)
+static void writediff(struct registry_key *oldkey, struct registry_key *newkey, FILE *out)
 {
 	int i;
-	REG_KEY *t1, *t2;
-	REG_VAL *v1, *v2;
+	struct registry_key *t1, *t2;
+	struct registry_value *v1, *v2;
 	WERROR error1, error2;
+	TALLOC_CTX *mem_ctx = talloc_init("writediff");
 
-	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_subkey_by_index(oldkey, i, &t1)); i++) {
-		error2 = reg_key_get_subkey_by_name(newkey, reg_key_name(t1), &t2);
+	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_subkey_by_index(mem_ctx, oldkey, i, &t1)); i++) {
+		error2 = reg_key_get_subkey_by_name(mem_ctx, newkey, t1->name, &t2);
 		if(W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
-			fprintf(out, "-%s\n", reg_key_get_path(t1)+1);
+			fprintf(out, "-%s\n", t1->path+1);
 		} else if(!W_ERROR_IS_OK(error2)) {
 			DEBUG(0, ("Error occured while getting subkey by name: %d\n", W_ERROR_V(error2)));
 		}
 	}
 
+	talloc_destroy(mem_ctx);
+
 	if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
 		DEBUG(0, ("Error occured while getting subkey by index: %d\n", W_ERROR_V(error1)));
 		return;
 	}
 
-	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_subkey_by_index(newkey, i, &t1)); i++) {
-		error2 = reg_key_get_subkey_by_name(oldkey, reg_key_name(t1), &t2);
+	mem_ctx = talloc_init("writediff");
+
+	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_subkey_by_index(mem_ctx, newkey, i, &t1)); i++) {
+		error2 = reg_key_get_subkey_by_name(mem_ctx, oldkey, t1->name, &t2);
 		if(W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
-			fprintf(out, "\n[%s]\n", reg_key_get_path(t1)+1);
+			fprintf(out, "\n[%s]\n", t1->path+1);
 		} else if(!W_ERROR_IS_OK(error2)) {
 			DEBUG(0, ("Error occured while getting subkey by name: %d\n", W_ERROR_V(error2)));
 		}
 		writediff(t2, t1, out);
 	}
 
+	talloc_destroy(mem_ctx);
+
 	if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
 		DEBUG(0, ("Error occured while getting subkey by index: %d\n", W_ERROR_V(error1)));
 		return;
 	}
 
-	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_value_by_index(newkey, i, &v1)); i++) {
-		error2 = reg_key_get_value_by_name(oldkey, reg_val_name(v1), &v2);
-		if ((W_ERROR_IS_OK(error2) && (reg_val_size(v2) != reg_val_size(v1) || memcmp(reg_val_data_blk(v1), reg_val_data_blk(v2), reg_val_size(v1)))) 
+
+	mem_ctx = talloc_init("writediff");
+
+	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_value_by_index(mem_ctx, newkey, i, &v1)); i++) {
+		error2 = reg_key_get_value_by_name(mem_ctx, oldkey, v1->name, &v2);
+		if ((W_ERROR_IS_OK(error2) && (v2->data_len != v1->data_len || memcmp(v1->data_blk, v2->data_blk, v1->data_len))) 
 			|| W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
-			fprintf(out, "\"%s\"=%s:%s\n", reg_val_name(v1), str_regtype(reg_val_type(v1)), reg_val_data_string(v1));
+			fprintf(out, "\"%s\"=%s:%s\n", v1->name, str_regtype(v1->data_type), reg_val_data_string(mem_ctx, v1));
 		}
 
 		if(!W_ERROR_IS_OK(error2) && !W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
@@ -69,22 +79,27 @@ static void writediff(REG_KEY *oldkey, REG_KEY *newkey, FILE *out)
 		}
 	}
 
+	talloc_destroy(mem_ctx);
+
 	if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
 		DEBUG(0, ("Error occured while getting value by index: %d\n", W_ERROR_V(error1)));
 		return;
 	}
 
+	mem_ctx = talloc_init("writediff");
 
-	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_value_by_index(oldkey, i, &v1)); i++) {
-		error2 = reg_key_get_value_by_name(newkey, reg_val_name(v1), &v2);
+	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_value_by_index(mem_ctx, oldkey, i, &v1)); i++) {
+		error2 = reg_key_get_value_by_name(mem_ctx, newkey, v1->name, &v2);
 		if(W_ERROR_IS_OK(error2)) {
 		} else if(W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
-			fprintf(out, "\"%s\"=-\n", reg_val_name(v1));
+			fprintf(out, "\"%s\"=-\n", v1->name);
 		} else {
 			DEBUG(0, ("Error occured while getting value by name: %d\n", W_ERROR_V(error2)));
 		}
 	}
 
+	talloc_destroy(mem_ctx);
+
 	if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
 		DEBUG(0, ("Error occured while getting value by index: %d\n", W_ERROR_V(error1)));
 		return;
@@ -100,8 +115,7 @@ static void writediff(REG_KEY *oldkey, REG_KEY *newkey, FILE *out)
 	const char *credentials1= NULL, *credentials2 = NULL;
 	char *outputfile = NULL;
 	FILE *fd = stdout;
-	REG_HANDLE *h1, *h2;
-	REG_KEY *root1 = NULL, *root2;
+	struct registry_context *h1, *h2;
 	int from_null = 0;
 	int i;
 	WERROR error, error2;
@@ -114,6 +128,12 @@ static void writediff(REG_KEY *oldkey, REG_KEY *newkey, FILE *out)
 		POPT_TABLEEND
 	};
 
+
+	if (!lp_load(dyn_CONFIGFILE,True,False,False)) {
+		fprintf(stderr, "Can't load %s - run testparm to debug it\n", dyn_CONFIGFILE);
+	}
+
+
 	pc = poptGetContext(argv[0], argc, (const char **) argv, long_options,0);
 
 	while((opt = poptGetNextOpt(pc)) != -1) {
@@ -140,7 +160,7 @@ static void writediff(REG_KEY *oldkey, REG_KEY *newkey, FILE *out)
 
 		if(!backend1) backend1 = "dir";
 
-		error = reg_open(backend1, location1, credentials1, &h1);
+		error = reg_open(&h1, backend1, location1, credentials1);
 		if(!W_ERROR_IS_OK(error)) {
 			fprintf(stderr, "Unable to open '%s' with backend '%s'\n", location1, backend1);
 			return 1;
@@ -155,7 +175,7 @@ static void writediff(REG_KEY *oldkey, REG_KEY *newkey, FILE *out)
 
 	if(!backend2) backend2 = "dir";
 
-	error = reg_open(backend2, location2, credentials2, &h2);
+	error = reg_open(&h2, backend2, location2, credentials2);
 	if(!W_ERROR_IS_OK(error)) {
 		fprintf(stderr, "Unable to open '%s' with backend '%s'\n", location2, backend2);
 		return 1;
@@ -176,20 +196,8 @@ static void writediff(REG_KEY *oldkey, REG_KEY *newkey, FILE *out)
 
 	error2 = error = WERR_OK; 
 
-	for(i = 0; ; i++) {
-		if(backend1) error = reg_get_hive(h1, i, &root1);
-		else root1 = NULL;
-
-		if(!W_ERROR_IS_OK(error)) break;
-
-		if(backend2) error2 = reg_get_hive(h2, i, &root2);
-		else root2 = NULL;
-
-		if(!W_ERROR_IS_OK(error2)) break;
-
-		writediff(root1, root2, fd); 
-
-		if(!root1 && !root2) break;
+	for(i = 0; i < h1->num_hives && i < h2->num_hives; i++) {
+		writediff(h1->hives[i]->root, h2->hives[i]->root, fd); 
 	}
 
 	fclose(fd);
diff --git a/source4/lib/registry/tools/regpatch.c b/source4/lib/registry/tools/regpatch.c
index 7eddea2b93..1b33628a71 100644
--- a/source4/lib/registry/tools/regpatch.c
+++ b/source4/lib/registry/tools/regpatch.c
@@ -664,12 +664,13 @@ static CMD_FILE *cmd_file_create(const char *file)
 
 char *str_type(uint8_t type);
 
-static int nt_apply_reg_command_file(REG_HANDLE *r, const char *cmd_file_name)
+static int nt_apply_reg_command_file(struct registry_context *r, const char *cmd_file_name)
 {
 	CMD *cmd;
 	BOOL modified = False;
 	CMD_FILE *cmd_file = NULL;
-	REG_KEY *tmp = NULL;
+	TALLOC_CTX *mem_ctx = talloc_init("apply_cmd_file");
+	struct registry_key *tmp = NULL;
 	WERROR error;
 	cmd_file = cmd_file_create(cmd_file_name);
 
@@ -680,12 +681,12 @@ static int nt_apply_reg_command_file(REG_HANDLE *r, const char *cmd_file_name)
 		 */
 		switch (cmd->cmd) {
 		case CMD_ADD_KEY: 
-		  error = reg_open_key_abs(r, cmd->key, &tmp);
+		  error = reg_open_key_abs(mem_ctx, r, cmd->key, &tmp);
 
 		  /* If we found it, apply the other bits, else create such a key */
 		  if (W_ERROR_EQUAL(error, WERR_DEST_NOT_FOUND)) {
 			  if(W_ERROR_IS_OK(reg_key_add_name_recursive_abs(r, cmd->key))) {
-				  error = reg_open_key_abs(r, cmd->key, &tmp);
+				  error = reg_open_key_abs(mem_ctx, r, cmd->key, &tmp);
 				  if(!W_ERROR_IS_OK(error)) {
 					DEBUG(0, ("Error finding new key '%s' after it has been added\n", cmd->key));
 					continue;
@@ -699,12 +700,12 @@ static int nt_apply_reg_command_file(REG_HANDLE *r, const char *cmd_file_name)
 
 		  while (cmd->val_count) {
 			  VAL_SPEC_LIST *val = cmd->val_spec_list;
-			  REG_VAL *reg_val = NULL;
+			  struct registry_value *reg_val = NULL;
 
 			  if (val->type == REG_DELETE) {
-				  error = reg_key_get_value_by_name( tmp, val->name, &reg_val);
+				  error = reg_key_get_value_by_name( mem_ctx, tmp, val->name, &reg_val);
 				  if(W_ERROR_IS_OK(error)) {
-					  error = reg_val_del(reg_val);
+					  error = reg_del_value(reg_val);
 				  }
 				  if(!W_ERROR_IS_OK(error)) {
 					DEBUG(0, ("Error removing value '%s'\n", val->name));
@@ -712,7 +713,7 @@ static int nt_apply_reg_command_file(REG_HANDLE *r, const char *cmd_file_name)
 				  modified = True;
 			  }
 			  else {
-				  if(!W_ERROR_IS_OK(reg_key_add_value(tmp, val->name, val->type, val->val, strlen(val->val)))) {
+				  if(!W_ERROR_IS_OK(reg_val_set(tmp, val->name, val->type, val->val, strlen(val->val)))) {
 					  DEBUG(0, ("Error adding new value '%s'\n", val->name));
 					  continue;
 				  }
@@ -732,7 +733,7 @@ static int nt_apply_reg_command_file(REG_HANDLE *r, const char *cmd_file_name)
 		   * Find the key if it exists, and delete it ...
 		   */
 
-		  error = reg_open_key_abs(r, cmd->key, &tmp);
+		  error = reg_open_key_abs(mem_ctx, r, cmd->key, &tmp);
 		  if(!W_ERROR_IS_OK(error)) {
 			  DEBUG(0, ("Unable to open key '%s'\n", cmd->key));
 			  continue;
@@ -760,7 +761,7 @@ static int nt_apply_reg_command_file(REG_HANDLE *r, const char *cmd_file_name)
 	const char *credentials = NULL;
 	const char *patch;
 	const char *backend = "dir";
-	REG_HANDLE *h;
+	struct registry_context *h;
 	WERROR error;
 	struct poptOption long_options[] = {
 		POPT_AUTOHELP
@@ -769,6 +770,12 @@ static int nt_apply_reg_command_file(REG_HANDLE *r, const char *cmd_file_name)
 		POPT_TABLEEND
 	};
 
+
+	if (!lp_load(dyn_CONFIGFILE,True,False,False)) {
+		fprintf(stderr, "Can't load %s - run testparm to debug it\n", dyn_CONFIGFILE);
+	}
+
+
 	pc = poptGetContext(argv[0], argc, (const char **) argv, long_options,0);
 
 	while((opt = poptGetNextOpt(pc)) != -1) {
@@ -782,7 +789,7 @@ static int nt_apply_reg_command_file(REG_HANDLE *r, const char *cmd_file_name)
 		return 1;
 	}
 
-	error = reg_open(backend, location, credentials, &h);
+	error = reg_open(&h, backend, location, credentials);
 	if(!h) {
 		fprintf(stderr, "Unable to open '%s' with backend '%s'\n", location, backend);
 		return 1;
@@ -794,7 +801,7 @@ static int nt_apply_reg_command_file(REG_HANDLE *r, const char *cmd_file_name)
 
 	nt_apply_reg_command_file(h, patch);
 
-	reg_free(h);
+	talloc_destroy(h->mem_ctx);
 
 	return 0;
 }
diff --git a/source4/lib/registry/tools/regshell.c b/source4/lib/registry/tools/regshell.c
index 638ed70d5e..78fe36f1a0 100644
--- a/source4/lib/registry/tools/regshell.c
+++ b/source4/lib/registry/tools/regshell.c
@@ -33,96 +33,96 @@
  * exit
  */
 
-static REG_KEY *cmd_info(REG_KEY *cur, int argc, char **argv)
+static struct registry_key *cmd_info(TALLOC_CTX *mem_ctx, struct registry_key *cur, int argc, char **argv)
 {
 	time_t last_mod;
-	printf("Name: %s\n", reg_key_name(cur));
-	printf("Full path: %s\n", reg_key_get_path(cur));
-	printf("Key Class: %s\n", reg_key_class(cur));
-	last_mod = nt_time_to_unix(reg_key_last_modified(cur));
+	printf("Name: %s\n", cur->name);
+	printf("Full path: %s\n", cur->path);
+	printf("Key Class: %s\n", cur->class_name);
+	last_mod = nt_time_to_unix(cur->last_mod);
 	printf("Time Last Modified: %s\n", ctime(&last_mod));
 	/* FIXME: Security info */
 	return cur;
 }
 
-static REG_KEY *cmd_pwd(REG_KEY *cur, int argc, char **argv)
+static struct registry_key *cmd_pwd(TALLOC_CTX *mem_ctx, struct registry_key *cur, int argc, char **argv)
 {
-	printf("%s\n", reg_key_get_path_abs(cur));
+	printf("%s\n", cur->path);
 	return cur;
 }
 
-static REG_KEY *cmd_set(REG_KEY *cur, int argc, char **argv)
+static struct registry_key *cmd_set(TALLOC_CTX *mem_ctx, struct registry_key *cur, int argc, char **argv)
 {
 	/* FIXME */
 	return NULL;
 }
 
-static REG_KEY *cmd_ck(REG_KEY *cur, int argc, char **argv)
+static struct registry_key *cmd_ck(TALLOC_CTX *mem_ctx, struct registry_key *cur, int argc, char **argv)
 { 
-	REG_KEY *new = NULL;
+	struct registry_key *new = NULL;
 	WERROR error;
 	if(argc < 2) {
 		new = cur;
 	} else {
-		error = reg_open_key(cur, argv[1], &new);
+		error = reg_open_key(mem_ctx, cur, argv[1], &new);
 		if(!W_ERROR_IS_OK(error)) {
 			DEBUG(0, ("Error opening specified key: %s\n", win_errstr(error)));
 			return NULL;
 		}
 	} 
 
-	printf("Current path is: %s\n", reg_key_get_path_abs(new));
+	printf("Current path is: %s\n", new->path);
 	
 	return new;
 }
 
-static REG_KEY *cmd_ls(REG_KEY *cur, int argc, char **argv)
+static struct registry_key *cmd_ls(TALLOC_CTX *mem_ctx, struct registry_key *cur, int argc, char **argv)
 {
 	int i;
 	WERROR error;
-	REG_VAL *value;
-	REG_KEY *sub;
-	for(i = 0; W_ERROR_IS_OK(error = reg_key_get_subkey_by_index(cur, i, &sub)); i++) {
-		printf("K %s\n", reg_key_name(sub));
+	struct registry_value *value;
+	struct registry_key *sub;
+	for(i = 0; W_ERROR_IS_OK(error = reg_key_get_subkey_by_index(mem_ctx, cur, i, &sub)); i++) {
+		printf("K %s\n", sub->name);
 	}
 
 	if(!W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) {
 		DEBUG(0, ("Error occured while browsing thru keys: %s\n", win_errstr(error)));
 	}
 
-	for(i = 0; W_ERROR_IS_OK(error = reg_key_get_value_by_index(cur, i, &value)); i++) {
-		printf("V \"%s\" %s %s\n", reg_val_name(value), str_regtype(reg_val_type(value)), reg_val_data_string(value));
+	for(i = 0; W_ERROR_IS_OK(error = reg_key_get_value_by_index(mem_ctx, cur, i, &value)); i++) {
+		printf("V \"%s\" %s %s\n", value->name, str_regtype(value->data_type), reg_val_data_string(mem_ctx, value));
 	}
 	
 	return NULL; 
 }
-static REG_KEY *cmd_mkkey(REG_KEY *cur, int argc, char **argv)
+static struct registry_key *cmd_mkkey(TALLOC_CTX *mem_ctx, struct registry_key *cur, int argc, char **argv)
 { 
-	REG_KEY *tmp;
+	struct registry_key *tmp;
 	if(argc < 2) {
 		fprintf(stderr, "Usage: mkkey <keyname>\n");
 		return NULL;
 	}
 	
-	if(!W_ERROR_IS_OK(reg_key_add_name(cur, argv[1], 0, NULL, &tmp))) {
+	if(!W_ERROR_IS_OK(reg_key_add_name(mem_ctx, cur, argv[1], 0, NULL, &tmp))) {
 		fprintf(stderr, "Error adding new subkey '%s'\n", argv[1]);
 		return NULL;
 	}
 
-	fprintf(stderr, "Successfully added new subkey '%s' to '%s'\n", argv[1], reg_key_get_path_abs(cur));
+	fprintf(stderr, "Successfully added new subkey '%s' to '%s'\n", argv[1], cur->path);
 	
 	return NULL; 
 }
 
-static REG_KEY *cmd_rmkey(REG_KEY *cur, int argc, char **argv)
+static struct registry_key *cmd_rmkey(TALLOC_CTX *mem_ctx, struct registry_key *cur, int argc, char **argv)
 { 
-	REG_KEY *key;
+	struct registry_key *key;
 	if(argc < 2) {
 		fprintf(stderr, "Usage: rmkey <name>\n");
 		return NULL;
 	}
 
-	if(!W_ERROR_IS_OK(reg_open_key(cur, argv[1], &key))) {
+	if(!W_ERROR_IS_OK(reg_open_key(mem_ctx, cur, argv[1], &key))) {
 		fprintf(stderr, "No such subkey '%s'\n", argv[1]);
 		return NULL;
 	}
@@ -136,20 +136,20 @@ static REG_KEY *cmd_rmkey(REG_KEY *cur, int argc, char **argv)
 	return NULL; 
 }
 
-static REG_KEY *cmd_rmval(REG_KEY *cur, int argc, char **argv)
+static struct registry_key *cmd_rmval(TALLOC_CTX *mem_ctx, struct registry_key *cur, int argc, char **argv)
 { 
-	REG_VAL *val;
+	struct registry_value *val;
 	if(argc < 2) {
 		fprintf(stderr, "Usage: rmval <valuename>\n");
 		return NULL;
 	}
 
-	if(!W_ERROR_IS_OK(reg_key_get_value_by_name(cur, argv[1], &val))) {
+	if(!W_ERROR_IS_OK(reg_key_get_value_by_name(mem_ctx, cur, argv[1], &val))) {
 		fprintf(stderr, "No such value '%s'\n", argv[1]);
 		return NULL;
 	}
 
-	if(!W_ERROR_IS_OK(reg_val_del(val))) {
+	if(!W_ERROR_IS_OK(reg_del_value(val))) {
 		fprintf(stderr, "Error deleting value '%s'\n", argv[1]);
 	} else {
 		fprintf(stderr, "Successfully deleted value '%s'\n", argv[1]);
@@ -158,38 +158,33 @@ static REG_KEY *cmd_rmval(REG_KEY *cur, int argc, char **argv)
 	return NULL; 
 }
 
-static REG_KEY *cmd_hive(REG_KEY *cur, int argc, char **argv)
+static struct registry_key *cmd_hive(TALLOC_CTX *mem_ctx, struct registry_key *cur, int argc, char **argv)
 {
 	int i;
-	WERROR error = WERR_OK;
-	for(i = 0; W_ERROR_IS_OK(error); i++) {
-		REG_KEY *hive;
-		error = reg_get_hive(reg_key_handle(cur), i, &hive);
-		if(!W_ERROR_IS_OK(error)) break;
+	for(i = 0; i < cur->hive->reg_ctx->num_hives; i++) {
 
 		if(argc == 1) {
-			printf("%s\n", reg_key_name(hive));
-		} else if(!strcmp(reg_key_name(hive), argv[1])) {
-			return hive;
+			printf("%s\n", cur->hive->reg_ctx->hives[i]->name);
+		} else if(!strcmp(cur->hive->reg_ctx->hives[i]->name, argv[1])) {
+			return cur->hive->reg_ctx->hives[i]->root;
 		} 
-		reg_key_free(hive);
 	}
 	return NULL;
 }
 
-static REG_KEY *cmd_exit(REG_KEY *cur, int argc, char **argv)
+static struct registry_key *cmd_exit(TALLOC_CTX *mem_ctx, struct registry_key *cur, int argc, char **argv)
 {
 	exit(0);
 	return NULL; 
 }
 
-static REG_KEY *cmd_help(REG_KEY *, int, char **);
+static struct registry_key *cmd_help(TALLOC_CTX *mem_ctx, struct registry_key *, int, char **);
 
 struct {
 	const char *name;
 	const char *alias;
 	const char *help;
-	REG_KEY *(*handle)(REG_KEY *, int argc, char **argv);
+	struct registry_key *(*handle)(TALLOC_CTX *mem_ctx, struct registry_key *, int argc, char **argv);
 } regshell_cmds[] = {
 	{"ck", "cd", "Change current key", cmd_ck },
 	{"ch", "hive", "Change current hive", cmd_hive },
@@ -205,7 +200,7 @@ struct {
 	{NULL }
 };
 
-static REG_KEY *cmd_help(REG_KEY *cur, int argc, char **argv)
+static struct registry_key *cmd_help(TALLOC_CTX *mem_ctx, struct registry_key *cur, int argc, char **argv)
 {
 	int i;
 	printf("Available commands:\n");
@@ -215,7 +210,7 @@ static REG_KEY *cmd_help(REG_KEY *cur, int argc, char **argv)
 	return NULL;
 } 
 
-static REG_KEY *process_cmd(REG_KEY *k, char *line)
+static struct registry_key *process_cmd(TALLOC_CTX *mem_ctx, struct registry_key *k, char *line)
 {
 	int argc;
 	char **argv = NULL;
@@ -229,7 +224,7 @@ static REG_KEY *process_cmd(REG_KEY *k, char *line)
 	for(i = 0; regshell_cmds[i].name; i++) {
 		if(!strcmp(regshell_cmds[i].name, argv[0]) || 
 		   (regshell_cmds[i].alias && !strcmp(regshell_cmds[i].alias, argv[0]))) {
-			return regshell_cmds[i].handle(k, argc, argv);
+			return regshell_cmds[i].handle(mem_ctx, k, argc, argv);
 		}
 	}
 
@@ -240,7 +235,7 @@ static REG_KEY *process_cmd(REG_KEY *k, char *line)
 
 #define MAX_COMPLETIONS 100
 
-static REG_KEY *current_key = NULL;
+static struct registry_key *current_key = NULL;
 
 static char **reg_complete_command(const char *text, int end)
 {
@@ -295,10 +290,11 @@ cleanup:
 
 static char **reg_complete_key(const char *text, int end)
 {
-	REG_KEY *subkey;
+	struct registry_key *subkey;
 	int i, j = 0;
 	int len;
 	char **matches;
+	TALLOC_CTX *mem_ctx;
 	/* Complete argument */
 
 	matches = (char **)malloc(sizeof(matches[0])*MAX_COMPLETIONS);
@@ -306,22 +302,24 @@ static char **reg_complete_key(const char *text, int end)
 	matches[0] = NULL;
 
 	len = strlen(text);
+	mem_ctx = talloc_init("completion");
 	for(i = 0; j < MAX_COMPLETIONS-1; i++) {
-		WERROR status = reg_key_get_subkey_by_index(current_key, i, &subkey);
+		WERROR status = reg_key_get_subkey_by_index(mem_ctx, current_key, i, &subkey);
 		if(W_ERROR_IS_OK(status)) {
-			if(!strncmp(text, reg_key_name(subkey), len)) {
-				matches[j] = strdup(reg_key_name(subkey));
+			if(!strncmp(text, subkey->name, len)) {
+				matches[j] = strdup(subkey->name);
 				j++;
 			}
-			reg_key_free(subkey);
 		} else if(W_ERROR_EQUAL(status, WERR_NO_MORE_ITEMS)) {
 			break;
 		} else {
 			printf("Error creating completion list: %s\n", win_errstr(status));
+			talloc_destroy(mem_ctx);
 			return NULL;
 		}
 	}
 	matches[j] = NULL;
+	talloc_destroy(mem_ctx);
 	return matches;
 }
 
@@ -341,10 +339,11 @@ static char **reg_completion(const char *text, int start, int end)
 	int opt;
 	const char *backend = "dir";
 	const char *credentials = NULL;
-	REG_KEY *curkey = NULL;
+	struct registry_key *curkey = NULL;
 	poptContext pc;
 	WERROR error;
-	REG_HANDLE *h;
+	TALLOC_CTX *mem_ctx = talloc_init("cmd");
+	struct registry_context *h;
 	struct poptOption long_options[] = {
 		POPT_AUTOHELP
 		POPT_COMMON_SAMBA
@@ -352,13 +351,19 @@ static char **reg_completion(const char *text, int start, int end)
 		{"credentials", 'c', POPT_ARG_STRING, &credentials, 0, "credentials", NULL},
 		POPT_TABLEEND
 	};
+
+
+	if (!lp_load(dyn_CONFIGFILE,True,False,False)) {
+		fprintf(stderr, "Can't load %s - run testparm to debug it\n", dyn_CONFIGFILE);
+	}
+
 	
 	pc = poptGetContext(argv[0], argc, (const char **) argv, long_options,0);
 	
 	while((opt = poptGetNextOpt(pc)) != -1) {
 	}
 
-	error = reg_open(backend, poptPeekArg(pc), credentials, &h);
+	error = reg_open(&h, backend, poptPeekArg(pc), credentials);
 	if(!W_ERROR_IS_OK(error)) {
 		fprintf(stderr, "Unable to open '%s' with backend '%s'\n", poptGetArg(pc), backend);
 		return 1;
@@ -367,14 +372,16 @@ static char **reg_completion(const char *text, int start, int end)
 
     setup_logging("regtree", True);
 
-	error = reg_get_hive(h, 0, &curkey);
-
-	if(!W_ERROR_IS_OK(error)) return 1;
+	curkey = h->hives[0]->root;
 
 	while(True) {
 		char *line, *prompt;
 		
-		asprintf(&prompt, "%s> ", reg_key_get_path_abs(curkey));
+		if(curkey->hive->name) {
+			asprintf(&prompt, "%s:%s> ", curkey->hive->name, curkey->path);
+		} else {
+			asprintf(&prompt, "%s> ", curkey->path);
+		}
 		
 		current_key = curkey; 		/* No way to pass a void * pointer 
 									   via readline :-( */
@@ -384,10 +391,11 @@ static char **reg_completion(const char *text, int start, int end)
 			break;
 
 		if(line[0] != '\n') {
-			REG_KEY *new = process_cmd(curkey, line);
+			struct registry_key *new = process_cmd(mem_ctx, curkey, line);
 			if(new)curkey = new;
 		}
 	}
+	talloc_destroy(mem_ctx);
 
 	return 0;
 }
diff --git a/source4/lib/registry/tools/regtree.c b/source4/lib/registry/tools/regtree.c
index b1ca9b3fb2..9748ca3438 100644
--- a/source4/lib/registry/tools/regtree.c
+++ b/source4/lib/registry/tools/regtree.c
@@ -21,39 +21,45 @@
 
 #include "includes.h"
 
-static void print_tree(int l, REG_KEY *p, int fullpath, int novals)
+static void print_tree(int l, struct registry_key *p, int fullpath, int novals)
 {
-	REG_KEY *subkey;
-	REG_VAL *value;
+	struct registry_key *subkey;
+	struct registry_value *value;
 	WERROR error;
 	int i;
+	TALLOC_CTX *mem_ctx;
 
 	for(i = 0; i < l; i++) putchar(' ');
-	if(fullpath) printf("%s\n", reg_key_get_path_abs(p));
-	else printf("%s\n", reg_key_name(p));
+	
+	/* Hive name */
+	if(p->hive->root == p) printf("%s\n", p->hive->name);
+	else if(!p->name) printf("<No Name>\n");
+	else if(fullpath) printf("%s\n", p->path);
+	else printf("%s\n", p->name);
 
-	for(i = 0; W_ERROR_IS_OK(error = reg_key_get_subkey_by_index(p, i, &subkey)); i++) {
+	mem_ctx = talloc_init("print_tree");
+	for(i = 0; W_ERROR_IS_OK(error = reg_key_get_subkey_by_index(mem_ctx, p, i, &subkey)); i++) {
 		print_tree(l+1, subkey, fullpath, novals);
-		reg_key_free(subkey);
 	}
+	talloc_destroy(mem_ctx);
 
 	if(!W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) {
-		DEBUG(0, ("Error occured while fetching subkeys for '%s': %s\n", reg_key_get_path_abs(p), win_errstr(error)));
+		DEBUG(0, ("Error occured while fetching subkeys for '%s': %s\n", p->path, win_errstr(error)));
 	}
 
 	if(!novals) {
-		for(i = 0; W_ERROR_IS_OK(error = reg_key_get_value_by_index(p, i, &value)); i++) {
+		mem_ctx = talloc_init("print_tree");
+		for(i = 0; W_ERROR_IS_OK(error = reg_key_get_value_by_index(mem_ctx, p, i, &value)); i++) {
 			int j;
 			char *desc;
 			for(j = 0; j < l+1; j++) putchar(' ');
-			desc = reg_val_description(value);
+			desc = reg_val_description(mem_ctx, value);
 			printf("%s\n", desc);
-			free(desc);
-			reg_val_free(value);
 		}
+		talloc_destroy(mem_ctx);
 
 		if(!W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) {
-			DEBUG(0, ("Error occured while fetching values for '%s': %s\n", reg_key_get_path_abs(p), win_errstr(error)));
+			DEBUG(0, ("Error occured while fetching values for '%s': %s\n", p->path, win_errstr(error)));
 		}
 	}
 }
@@ -64,8 +70,7 @@ static void print_tree(int l, REG_KEY *p, int fullpath, int novals)
 	const char *backend = "dir";
 	const char *credentials = NULL;
 	poptContext pc;
-	REG_KEY *root;
-	REG_HANDLE *h;
+	struct registry_context *h;
 	WERROR error;
 	int fullpath = 0, no_values = 0;
 	struct poptOption long_options[] = {
@@ -77,6 +82,12 @@ static void print_tree(int l, REG_KEY *p, int fullpath, int novals)
 		POPT_TABLEEND
 	};
 
+
+	if (!lp_load(dyn_CONFIGFILE,True,False,False)) {
+		fprintf(stderr, "Can't load %s - run testparm to debug it\n", dyn_CONFIGFILE);
+	}
+
+
 	pc = poptGetContext(argv[0], argc, (const char **) argv, long_options,0);
 	
 	while((opt = poptGetNextOpt(pc)) != -1) {
@@ -84,7 +95,7 @@ static void print_tree(int l, REG_KEY *p, int fullpath, int novals)
 
 	setup_logging("regtree", True);
 
-	error = reg_open(backend, poptPeekArg(pc), credentials, &h);
+	error = reg_open(&h, backend, poptPeekArg(pc), credentials);
 	if(!W_ERROR_IS_OK(error)) {
 		fprintf(stderr, "Unable to open '%s' with backend '%s':%s \n", poptGetArg(pc), backend, win_errstr(error));
 		return 1;
@@ -93,11 +104,8 @@ static void print_tree(int l, REG_KEY *p, int fullpath, int novals)
 
 	error = WERR_OK;
 
-	for(i = 0; W_ERROR_IS_OK(error); i++) {
-		error = reg_get_hive(h, i, &root);
-		if(!W_ERROR_IS_OK(error)) return 1;
-
-		print_tree(0, root, fullpath, no_values);
+	for(i = 0; i < h->num_hives; i++) {
+		print_tree(0, h->hives[i]->root, fullpath, no_values);
 	}
 	
 	return 0;