15 files changed, 416 insertions, 307 deletions

diff --git a/source4/lib/registry/README b/source4/lib/registry/README
new file mode 100644
index 0000000000..757029cdc2
--- /dev/null
+++ b/source4/lib/registry/README
@@ -0,0 +1,30 @@
+This is the registry library. The registry is basically a bunch of hives 
+(HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE, etc) that can be loaded from 
+different places.
+
+The various registry backends provide support for loading/saving specific types 
+of hives:
+ - ldb 
+ - w95 (USER.DAT-style files)
+ - nt4 (NTUSER.DAT-style files)
+ - gconf (GNOME configuration)
+ - rpc (Remote individual hives)
+
+Instead of opening individual hives, one can also open a 'complete' registry by 
+using one of these three functions:
+ 
+ - reg_open_local() - load local registry, see below
+ - reg_open_remote() - connect to remote registry over RPC
+ - reg_open_wine() (not working yet)
+
+reg_open_local() loads a set of hives based on smb.conf settings. 
+Lines in smb.conf should have the following syntax:
+
+registry:<hivename> = <backend>:<location>
+
+So an example usage could be:
+
+registry:HKEY_CURRENT_USER = nt4:NTUSER.DAT
+registry:HKEY_LOCAL_MACHINE = ldb:tdb://registry.tdb
+
+WERR_NOT_SUPPORTED will be returned for all hives that haven't been set.
diff --git a/source4/lib/registry/common/reg_interface.c b/source4/lib/registry/common/reg_interface.c
index f7d3af0705..740d849db1 100644
--- a/source4/lib/registry/common/reg_interface.c
+++ b/source4/lib/registry/common/reg_interface.c
@@ -30,32 +30,25 @@ 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)  
+NTSTATUS registry_register(const void *_hive_ops)  
 {
-	const struct registry_operations *functions = _function;
+	const struct hive_operations *hive_ops = _hive_ops;
 	struct reg_init_function_entry *entry = backends;
 
-	if (!functions || !functions->name) {
-		DEBUG(0, ("Invalid arguments while registering registry backend\n"));
-		return NT_STATUS_INVALID_PARAMETER;
-	}
-
-	DEBUG(5,("Attempting to register registry backend %s\n", functions->name));
+	DEBUG(5,("Attempting to register registry backend %s\n", hive_ops->name));
 
 	/* Check for duplicates */
-	if (reg_find_backend_entry(functions->name)) {
-		DEBUG(0,("There already is a registry backend registered with the name %s!\n", functions->name));
+	if (reg_find_backend_entry(hive_ops->name)) {
+		DEBUG(0,("There already is a registry backend registered with the name %s!\n", hive_ops->name));
 		return NT_STATUS_OBJECT_NAME_COLLISION;
 	}
 
-	entry = malloc_p(struct reg_init_function_entry);
-	entry->functions = functions;
+	entry = talloc_p(NULL, struct reg_init_function_entry);
+	entry->hive_functions = hive_ops;
 
 	DLIST_ADD(backends, entry);
-	DEBUG(5,("Successfully added registry backend '%s'\n", functions->name));
+	DEBUG(5,("Successfully added registry backend '%s'\n", hive_ops->name));
 	return NT_STATUS_OK;
 }
 
@@ -67,7 +60,7 @@ static struct reg_init_function_entry *reg_find_backend_entry(const char *name)
 	entry = backends;
 
 	while(entry) {
-		if (strcmp(entry->functions->name, name) == 0) return entry;
+		if (strcmp(entry->hive_functions->name, name) == 0) return entry;
 		entry = entry->next;
 	}
 
@@ -80,85 +73,83 @@ BOOL reg_has_backend(const char *backend)
 	return reg_find_backend_entry(backend) != NULL?True:False;
 }
 
-WERROR reg_create(struct registry_context **_ret)
+static struct {
+	uint32 hkey;
+	const char *name;
+} hkey_names[] = 
 {
-	TALLOC_CTX *mem_ctx;
-	struct registry_context *ret;
-	mem_ctx = talloc_init("registry handle");
-	ret = talloc_p(mem_ctx, 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)
+	{HKEY_CLASSES_ROOT,"HKEY_CLASSES_ROOT" },
+	{HKEY_CURRENT_USER,"HKEY_CURRENT_USER" },
+	{HKEY_LOCAL_MACHINE, "HKEY_LOCAL_MACHINE" },
+	{HKEY_PERFORMANCE_DATA, "HKEY_PERFORMANCE_DATA" },
+	{HKEY_USERS, "HKEY_USERS" },
+	{HKEY_CURRENT_CONFIG, "HKEY_CURRENT_CONFIG" },
+	{HKEY_DYN_DATA, "HKEY_DYN_DATA" },
+	{HKEY_PT, "HKEY_PT" },
+	{HKEY_PN, "HKEY_PN" },
+	{ 0, NULL }
+};
+
+int reg_list_hives(TALLOC_CTX *mem_ctx, char ***hives, uint32_t **hkeys)
 {
-	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;
-	}
+	int i;
+	*hives = talloc_array_p(mem_ctx, char *, ARRAY_SIZE(hkey_names));
+	*hkeys = talloc_array_p(mem_ctx, uint32_t, ARRAY_SIZE(hkey_names));
 
-	if(!entry->functions->list_available_hives) {
-		return WERR_NOT_SUPPORTED;
+	for (i = 0; hkey_names[i].name; i++) {
+		(*hives)[i] = talloc_strdup(mem_ctx, hkey_names[i].name);
+		(*hkeys)[i] = hkey_names[i].hkey;
 	}
 
-	return entry->functions->list_available_hives(mem_ctx, location, credentials, hives);
+	return i;
 }
 
-WERROR reg_open(struct registry_context **ret, const char *backend, const char *location, const char *credentials)
+const char *reg_get_hkey_name(uint32_t hkey)
 {
-	WERROR error = reg_create(ret), reterror = WERR_NO_MORE_ITEMS;
-	char **hives;
-	int i, j;
-	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);
+	int i;
+	for (i = 0; hkey_names[i].name; i++) {
+		if (hkey_names[i].hkey == hkey) return hkey_names[i].name;
 	}
-	   
-	if(!W_ERROR_IS_OK(error)) return error;
 
-	j = 0;
-	for(i = 0; hives[i]; i++)
-	{
-		error = reg_import_hive(*ret, backend, location, credentials, hives[i]);
-		if (W_ERROR_IS_OK(error)) { 
-			reterror = WERR_OK;
-			(*ret)->hives[j]->name = talloc_strdup((*ret)->mem_ctx, hives[i]);
-			j++;
-		} else if (!W_ERROR_IS_OK(reterror)) reterror = error;
+	return NULL;
+}
+
+WERROR reg_get_hive_by_name(struct registry_context *ctx, const char *name, struct registry_key **key)
+{
+	int i;
+	
+	for (i = 0; hkey_names[i].name; i++) {
+		if (!strcmp(hkey_names[i].name, name)) return reg_get_hive(ctx, hkey_names[i].hkey, key);
 	}
 
-	return reterror;
+	DEBUG(1, ("No hive with name '%s'\n", name));
+	
+	return WERR_BADFILE;
 }
 
 WERROR reg_close (struct registry_context *ctx)
 {
-	int i;
-	for (i = 0; i < ctx->num_hives; i++) {
-		if (ctx->hives[i]->functions->close_hive) {
-			ctx->hives[i]->functions->close_hive(ctx->hives[i]);
-		}
-	}
 	talloc_destroy(ctx);
 
 	return WERR_OK;
 }
 
+WERROR reg_get_hive(struct registry_context *ctx, uint32_t hkey, struct registry_key **key)
+{
+	WERROR ret = ctx->get_hive(ctx, hkey, key);
+
+	if (W_ERROR_IS_OK(ret)) {
+		(*key)->name = talloc_strdup(*key, reg_get_hkey_name(hkey));
+		(*key)->path = ""; 
+	}
+
+	return ret;
+}
+
 /* 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)
+WERROR reg_open_hive(struct registry_context *parent_ctx, const char *backend, const char *location, const char *credentials, struct registry_key **root)
 {
 	struct registry_hive *ret;
-	TALLOC_CTX *mem_ctx;
 	struct reg_init_function_entry *entry;
 	WERROR werr;
 
@@ -169,24 +160,21 @@ WERROR reg_import_hive(struct registry_context *h, const char *backend, const ch
 		return WERR_GENERAL_FAILURE;
 	}
 
-	if(!entry->functions->open_hive) {
+	if(!entry->hive_functions || !entry->hive_functions->open_hive) {
 		return WERR_NOT_SUPPORTED;
 	}
 	
-	
-	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 = talloc_p(parent_ctx, struct registry_hive);
+	ret->location = location?talloc_strdup(ret, location):NULL;
+	ret->functions = entry->hive_functions;
 	ret->backend_data = NULL;
-	ret->reg_ctx = h;
-	ret->name = NULL;
+	ret->reg_ctx = parent_ctx;
 
-	werr = entry->functions->open_hive(mem_ctx, ret, &ret->root);
+	werr = entry->hive_functions->open_hive(ret, &ret->root);
 
-	if(!W_ERROR_IS_OK(werr)) return werr;
+	if(!W_ERROR_IS_OK(werr)) {
+		return werr;
+	}
 	
 	if(!ret->root) {
 		DEBUG(0, ("Backend %s didn't provide root key!\n", backend));
@@ -195,12 +183,9 @@ WERROR reg_import_hive(struct registry_context *h, const char *backend, const ch
 
 	ret->root->hive = ret;
 	ret->root->name = NULL;
-	ret->root->path = talloc_strdup(mem_ctx, "");
-
-	/* Add hive to context */
-	h->num_hives++;
-	h->hives = talloc_realloc_p(h, h->hives, struct registry_hive *, h->num_hives);
-	h->hives[h->num_hives-1] = ret;
+	ret->root->path = talloc_strdup(ret, "");
+	
+	*root = ret->root;
 
 	return WERR_OK;
 }
@@ -217,7 +202,7 @@ WERROR reg_open_key_abs(TALLOC_CTX *mem_ctx, struct registry_context *handle, co
 	else hivelength = strlen(name);
 
 	hivename = strndup(name, hivelength);
-	error = reg_get_hive(handle, hivename, &hive);
+	error = reg_get_hive_by_name(handle, hivename, &hive);
 	SAFE_FREE(hivename);
 
 	if(!W_ERROR_IS_OK(error)) {
@@ -272,7 +257,8 @@ WERROR reg_open_key(TALLOC_CTX *mem_ctx, struct registry_key *parent, const char
 		return WERR_NOT_SUPPORTED;
 	}
 
-	fullname = reg_make_path(mem_ctx, parent, name);
+
+	fullname = ((parent->hive->root == parent)?talloc_strdup(mem_ctx, name):talloc_asprintf(mem_ctx, "%s\\%s", parent->path, name));
 
 	error = parent->hive->functions->open_key(mem_ctx, parent->hive, fullname, result);
 
@@ -499,7 +485,7 @@ WERROR reg_key_add_name_recursive_abs(struct registry_context *handle, const cha
 	else hivelength = strlen(name);
 
 	hivename = strndup(name, hivelength);
-	error = reg_get_hive(handle, hivename, &hive);
+	error = reg_get_hive_by_name(handle, hivename, &hive);
 	SAFE_FREE(hivename);
 
 	if(!W_ERROR_IS_OK(error)) return error;
@@ -578,19 +564,7 @@ WERROR reg_val_set(struct registry_key *key, const char *value, int type, void *
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR reg_get_hive(struct registry_context *h, const char *name, struct registry_key **key) 
-{
-	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;
-		}
-	}
 
-	return WERR_NO_MORE_ITEMS;
-}
 
 WERROR reg_del_value(struct registry_value *val)
 {
diff --git a/source4/lib/registry/config.mk b/source4/lib/registry/config.mk
index b91ec647a0..af9fb83bab 100644
--- a/source4/lib/registry/config.mk
+++ b/source4/lib/registry/config.mk
@@ -6,7 +6,7 @@
 INIT_FUNCTION = registry_nt4_init
 SUBSYSTEM = REGISTRY
 INIT_OBJ_FILES = \
-		lib/registry/reg_backend_nt4/reg_backend_nt4.o
+		lib/registry/reg_backend_nt4.o
 # End MODULE registry_nt4
 ################################################
 
@@ -16,7 +16,7 @@ INIT_OBJ_FILES = \
 INIT_FUNCTION = registry_w95_init
 SUBSYSTEM = REGISTRY
 INIT_OBJ_FILES = \
-		lib/registry/reg_backend_w95/reg_backend_w95.o
+		lib/registry/reg_backend_w95.o
 # End MODULE registry_w95
 ################################################
 
@@ -26,7 +26,7 @@ INIT_OBJ_FILES = \
 INIT_FUNCTION = registry_dir_init
 SUBSYSTEM = REGISTRY
 INIT_OBJ_FILES = \
-		lib/registry/reg_backend_dir/reg_backend_dir.o
+		lib/registry/reg_backend_dir.o
 # End MODULE registry_dir
 ################################################
 
@@ -36,18 +36,20 @@ INIT_OBJ_FILES = \
 INIT_FUNCTION = registry_rpc_init
 SUBSYSTEM = REGISTRY
 INIT_OBJ_FILES = \
-		lib/registry/reg_backend_rpc/reg_backend_rpc.o
+		lib/registry/reg_backend_rpc.o
 REQUIRED_SUBSYSTEMS = RPC_NDR_WINREG
 # End MODULE registry_rpc
 ################################################
 
+
+
 ################################################
 # Start MODULE registry_gconf
 [MODULE::registry_gconf]
 INIT_FUNCTION = registry_gconf_init
 SUBSYSTEM = REGISTRY
 INIT_OBJ_FILES = \
-		lib/registry/reg_backend_gconf/reg_backend_gconf.o
+		lib/registry/reg_backend_gconf.o
 REQUIRED_SUBSYSTEMS = EXT_LIB_gconf
 # End MODULE registry_gconf
 ################################################
@@ -58,7 +60,7 @@ REQUIRED_SUBSYSTEMS = EXT_LIB_gconf
 INIT_FUNCTION = registry_ldb_init
 SUBSYSTEM = REGISTRY
 INIT_OBJ_FILES = \
-		lib/registry/reg_backend_ldb/reg_backend_ldb.o
+		lib/registry/reg_backend_ldb.o
 REQUIRED_SUBSYSTEMS = \
 		LIBLDB
 # End MODULE registry_ldb
@@ -70,7 +72,8 @@ REQUIRED_SUBSYSTEMS = \
 INIT_OBJ_FILES = \
 		lib/registry/common/reg_interface.o
 ADD_OBJ_FILES = \
-		lib/registry/common/reg_util.o
+		lib/registry/common/reg_util.o \
+		lib/registry/reg_samba.o
 REQUIRED_SUBSYSTEMS = \
 		LIBBASIC
 # End MODULE registry_ldb
diff --git a/source4/lib/registry/reg_backend_dir/reg_backend_dir.c b/source4/lib/registry/reg_backend_dir.c
index 8712e7ce7c..5c3ed3c44c 100644
--- a/source4/lib/registry/reg_backend_dir/reg_backend_dir.c
+++ b/source4/lib/registry/reg_backend_dir.c
@@ -110,12 +110,12 @@ static WERROR reg_dir_key_by_index(TALLOC_CTX *mem_ctx, struct registry_key *k,
 	return WERR_NO_MORE_ITEMS;
 }
 
-static WERROR reg_dir_open(TALLOC_CTX *mem_ctx, struct registry_hive *h, struct registry_key **key)
+static WERROR reg_dir_open(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);
+	*key = talloc_p(h, struct registry_key);
+	(*key)->backend_data = talloc_strdup(*key, h->location);
 	return WERR_OK;
 }
 
@@ -131,7 +131,7 @@ static WERROR reg_dir_del_value(struct registry_value *v)
 	return WERR_NOT_SUPPORTED;
 }
 
-static struct registry_operations reg_backend_dir = {
+static struct hive_operations reg_backend_dir = {
 	.name = "dir",
 	.open_hive = reg_dir_open,
 	.open_key = reg_dir_open_key,
diff --git a/source4/lib/registry/reg_backend_gconf/reg_backend_gconf.c b/source4/lib/registry/reg_backend_gconf.c
index fd258ca285..2fed2417b7 100644
--- a/source4/lib/registry/reg_backend_gconf/reg_backend_gconf.c
+++ b/source4/lib/registry/reg_backend_gconf.c
@@ -29,16 +29,16 @@ static WERROR gerror_to_werror(GError *error)
 	return WERR_FOOBAR;
 }
 
-static WERROR reg_open_gconf_hive(TALLOC_CTX *mem_ctx, struct registry_hive *h, struct registry_key **k)
+static WERROR reg_open_gconf_hive(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 = talloc_strdup(mem_ctx, "");
-	(*k)->path = talloc_strdup(mem_ctx, "");
-	(*k)->backend_data = talloc_strdup(mem_ctx, "/");
+	*k = talloc_p(h, struct registry_key);
+	(*k)->name = talloc_strdup(*k, "");
+	(*k)->path = talloc_strdup(*k, "");
+	(*k)->backend_data = talloc_strdup(*k, "/");
 	return WERR_OK;
 }
 
@@ -173,7 +173,7 @@ static WERROR gconf_set_value(struct registry_key *key, const char *valname, int
 	return WERR_NOT_SUPPORTED;
 }
 
-static struct registry_operations reg_backend_gconf = {
+static struct hive_operations reg_backend_gconf = {
 	.name = "gconf",
 	.open_hive = reg_open_gconf_hive,
 	.open_key = gconf_open_key,
diff --git a/source4/lib/registry/reg_backend_ldb/reg_backend_ldb.c b/source4/lib/registry/reg_backend_ldb.c
index 380a8010f2..7eaf6194a5 100644
--- a/source4/lib/registry/reg_backend_ldb/reg_backend_ldb.c
+++ b/source4/lib/registry/reg_backend_ldb.c
@@ -137,7 +137,7 @@ static WERROR ldb_open_key(TALLOC_CTX *mem_ctx, struct registry_hive *h, const c
 	return WERR_OK;
 }
 
-static WERROR ldb_open_hive(TALLOC_CTX *mem_ctx, struct registry_hive *hive, struct registry_key **k)
+static WERROR ldb_open_hive(struct registry_hive *hive, struct registry_key **k)
 {
 	struct ldb_context *c;
 
@@ -151,8 +151,8 @@ static WERROR ldb_open_hive(TALLOC_CTX *mem_ctx, struct registry_hive *hive, str
 	ldb_set_debug_stderr(c);
 	hive->backend_data = c;
 
-	hive->root = talloc_zero_p(mem_ctx, struct registry_key);
-	hive->root->name = talloc_strdup(mem_ctx, "");
+	hive->root = talloc_zero_p(hive, struct registry_key);
+	hive->root->name = talloc_strdup(hive->root, "");
 
 	return WERR_OK;
 }
@@ -202,7 +202,7 @@ static WERROR ldb_close_hive (struct registry_hive *hive)
 	return WERR_OK;
 }
 
-static struct registry_operations reg_backend_ldb = {
+static struct hive_operations reg_backend_ldb = {
 	.name = "ldb",
 	.add_key = ldb_add_key,
 	.del_key = ldb_del_key,
diff --git a/source4/lib/registry/reg_backend_nt4/reg_backend_nt4.c b/source4/lib/registry/reg_backend_nt4.c
index 381f0c3bcf..117d8d1b81 100644
--- a/source4/lib/registry/reg_backend_nt4/reg_backend_nt4.c
+++ b/source4/lib/registry/reg_backend_nt4.c
@@ -1573,16 +1573,16 @@ error:
 
 #endif
 
-static WERROR nt_open_hive (TALLOC_CTX *mem_ctx, struct registry_hive *h, struct registry_key **key)
+static WERROR nt_open_hive (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(mem_ctx, REGF);
+	regf = (REGF *)talloc_p(h, REGF);
 	memset(regf, 0, sizeof(REGF));
-	regf->owner_sid_str = h->credentials;
+	regf->owner_sid_str = NULL; /* FIXME: Fill in */
 	h->backend_data = regf;
 
 	DEBUG(5, ("Attempting to load registry file\n"));
@@ -1655,7 +1655,7 @@ static WERROR nt_open_hive (TALLOC_CTX *mem_ctx, struct registry_hive *h, struct
 
 	h->backend_data = regf;
 
-	return nk_to_key(mem_ctx, h, ((REGF *)h->backend_data)->first_key, BLK_SIZE(((REGF *)h->backend_data)->first_key), NULL, key);
+	return nk_to_key(h, h, ((REGF *)h->backend_data)->first_key, BLK_SIZE(((REGF *)h->backend_data)->first_key), NULL, key);
 }
 
 
@@ -1724,7 +1724,7 @@ static WERROR nt_key_by_index(TALLOC_CTX *mem_ctx, struct registry_key *k, int n
 	return WERR_NO_MORE_ITEMS;
 }
 
-static struct registry_operations reg_backend_nt4 = {
+static struct hive_operations reg_backend_nt4 = {
 	.name = "nt4",
 	.open_hive = nt_open_hive,
 	.num_subkeys = nt_num_subkeys,
diff --git a/source4/lib/registry/reg_backend_rpc/reg_backend_rpc.c b/source4/lib/registry/reg_backend_rpc.c
index 3969a763e0..18563b2478 100644
--- a/source4/lib/registry/reg_backend_rpc/reg_backend_rpc.c
+++ b/source4/lib/registry/reg_backend_rpc.c
@@ -21,6 +21,8 @@
 #include "registry.h"
 #include "librpc/gen_ndr/ndr_winreg.h"
 
+static struct hive_operations reg_backend_rpc;
+
 /**
  * This is the RPC backend for the registry library.
  */
@@ -76,93 +78,56 @@ struct rpc_key_data {
 };
 
 struct {
-	const char *name;
+	uint32 hkey;
 	WERROR (*open) (struct dcerpc_pipe *p, TALLOC_CTX *, struct policy_handle *h);
 } known_hives[] = {
-{ "HKEY_LOCAL_MACHINE", open_HKLM },
-{ "HKEY_CURRENT_USER", open_HKCU },
-{ "HKEY_CLASSES_ROOT", open_HKCR },
-{ "HKEY_PERFORMANCE_DATA", open_HKPD },
-{ "HKEY_USERS", open_HKU },
-{ "HKEY_DYN_DATA", open_HKDD },
-{ "HKEY_CURRENT_CONFIG", open_HKCC },
-{ NULL, NULL }
+{ HKEY_LOCAL_MACHINE, open_HKLM },
+{ HKEY_CURRENT_USER, open_HKCU },
+{ HKEY_CLASSES_ROOT, open_HKCR },
+{ HKEY_PERFORMANCE_DATA, open_HKPD },
+{ HKEY_USERS, open_HKU },
+{ HKEY_DYN_DATA, open_HKDD },
+{ HKEY_CURRENT_CONFIG, open_HKCC },
+{ 0, NULL }
 };
 
 static WERROR rpc_query_key(struct registry_key *k);
 
-static 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(mem_ctx, *hives, char *, i+2);
-		(*hives)[i] = talloc_strdup(mem_ctx, known_hives[i].name);
-	}
-	(*hives)[i] = NULL;
-	return WERR_OK;
-}
-
-static WERROR rpc_close_hive (struct registry_hive *h)
+static WERROR rpc_get_hive (struct registry_context *ctx, uint32 hkey_type, struct registry_key **k)
 {
-	dcerpc_pipe_close(h->backend_data);
-	return WERR_OK;
-}
-
-static WERROR rpc_open_hive(TALLOC_CTX *mem_ctx, struct registry_hive *h, struct registry_key **k)
-{
-	NTSTATUS status;
-	char *user;
-	char *pass;
-	struct rpc_key_data *mykeydata;
-	struct dcerpc_pipe *p;
 	int n;
+	struct registry_hive *h;
+	struct rpc_key_data *mykeydata;
 
-	if (!h->credentials) return WERR_INVALID_PARAM;
-
-	/* Default to local smbd if no connection is specified */
-	if (!h->location) {
-		h->location = talloc_strdup(mem_ctx, "ncalrpc:");
-	}
-
-	user = talloc_strdup(mem_ctx, h->credentials);
-	pass = strchr(user, '%');
-	if (pass) {
-		*pass = '\0';
-		pass = strdup(pass+1);
-	} else {
-		pass = strdup("");
-	}
-
-	status = dcerpc_pipe_connect(&p, h->location, 
-				     DCERPC_WINREG_UUID,
-				     DCERPC_WINREG_VERSION,
-				     lp_workgroup(),
-				     user, pass);
-	free(pass);
-
-	h->backend_data = p;
-
-	if(NT_STATUS_IS_ERR(status)) {
-		DEBUG(1, ("Unable to open '%s': %s\n", h->location, nt_errstr(status)));
-		return ntstatus_to_werror(status);
-	}
-
-	for(n = 0; known_hives[n].name; n++) 
+	for(n = 0; known_hives[n].hkey; n++) 
 	{
-		if(!strcmp(known_hives[n].name, h->backend_hivename)) break;
+		if(known_hives[n].hkey == hkey_type) break;
 	}
 	
-	if(!known_hives[n].name)  {
-		DEBUG(1, ("No such hive %s\n", known_hives[n].name));
+	if(!known_hives[n].open)  {
+		DEBUG(1, ("No such hive %d\n", hkey_type));
 		return WERR_NO_MORE_ITEMS;
 	}
+
+	h = talloc_p(ctx, struct registry_hive);
+	h->functions = &reg_backend_rpc;
+	h->location = NULL;
+	h->backend_data = ctx->backend_data;
+	h->reg_ctx = ctx;
 	
-	*k = talloc_p(mem_ctx, struct registry_key);
-	(*k)->backend_data = mykeydata = talloc_p(mem_ctx, struct rpc_key_data);
+	(*k) = h->root = talloc_p(h, struct registry_key);
+	(*k)->hive = h;
+	(*k)->backend_data = mykeydata = talloc_p(*k, struct rpc_key_data);
 	mykeydata->num_values = -1;
 	mykeydata->num_subkeys = -1;
-	return known_hives[n].open((struct dcerpc_pipe *)h->backend_data, *k, &(mykeydata->pol));
+	return known_hives[n].open((struct dcerpc_pipe *)ctx->backend_data, *k, &(mykeydata->pol));
+}
+
+static int rpc_close (void *_h)
+{
+	struct registry_context *h = _h;
+	dcerpc_pipe_close(h->backend_data);
+	return 0;
 }
 
 #if 0
@@ -385,10 +350,8 @@ static WERROR rpc_num_subkeys(struct registry_key *key, int *count) {
 	return WERR_OK;
 }
 
-static struct registry_operations reg_backend_rpc = {
+static struct hive_operations reg_backend_rpc = {
 	.name = "rpc",
-	.open_hive = rpc_open_hive,
-	.close_hive = rpc_close_hive,
 	.open_key = rpc_open_key,
 	.get_subkey_by_index = rpc_get_subkey_by_index,
 	.get_value_by_index = rpc_get_value_by_index,
@@ -396,9 +359,39 @@ static struct registry_operations reg_backend_rpc = {
 	.del_key = rpc_del_key,
 	.num_subkeys = rpc_num_subkeys,
 	.num_values = rpc_num_values,
-	.list_available_hives = rpc_list_hives,
 };
 
+WERROR reg_open_remote (struct registry_context **ctx, const char *user, const char *pass, const char *location)
+{
+	NTSTATUS status;
+	struct dcerpc_pipe *p;
+
+	*ctx = talloc_p(NULL, struct registry_context);
+
+	/* Default to local smbd if no connection is specified */
+	if (!location) {
+		location = talloc_strdup(ctx, "ncalrpc:");
+	}
+
+	status = dcerpc_pipe_connect(&p, location, 
+				     DCERPC_WINREG_UUID,
+				     DCERPC_WINREG_VERSION,
+				     lp_workgroup(),
+				     user, pass);
+	(*ctx)->backend_data = p;
+
+	if(NT_STATUS_IS_ERR(status)) {
+		DEBUG(1, ("Unable to open '%s': %s\n", location, nt_errstr(status)));
+		return ntstatus_to_werror(status);
+	}
+
+	(*ctx)->get_hive = rpc_get_hive;
+
+	talloc_set_destructor(*ctx, rpc_close);
+
+	return WERR_OK;
+}
+
 NTSTATUS registry_rpc_init(void)
 {
 	return registry_register(&reg_backend_rpc);
diff --git a/source4/lib/registry/reg_backend_w95/reg_backend_w95.c b/source4/lib/registry/reg_backend_w95.c
index 445d13a99c..a94ad86c2c 100644
--- a/source4/lib/registry/reg_backend_w95/reg_backend_w95.c
+++ b/source4/lib/registry/reg_backend_w95.c
@@ -180,14 +180,14 @@ static void parse_rgdb_block(CREG *creg, RGDB_HDR *rgdb_hdr)
 	}
 }
 
-static WERROR w95_open_reg (TALLOC_CTX *mem_ctx, struct registry_hive *h, struct registry_key **root)
+static WERROR w95_open_reg (struct registry_hive *h, struct registry_key **root)
 {
 	CREG *creg;
 	DWORD creg_id, rgkn_id;
 	DWORD i;
 	DWORD offset;
 
-	creg = talloc_p(mem_ctx, CREG);
+	creg = talloc_p(h, CREG);
 	memset(creg, 0, sizeof(CREG));
 	h->backend_data = creg;
 
@@ -234,7 +234,7 @@ static WERROR w95_open_reg (TALLOC_CTX *mem_ctx, struct registry_hive *h, struct
 	}
 #endif
 
-	creg->rgdb_keys = talloc_array_p(mem_ctx, RGDB_KEY **, creg->creg_hdr->num_rgdb);
+	creg->rgdb_keys = talloc_array_p(h, RGDB_KEY **, creg->creg_hdr->num_rgdb);
 
 	offset = 0;
 	DEBUG(3, ("Reading %d rgdb entries\n", creg->creg_hdr->num_rgdb));
@@ -250,7 +250,7 @@ static WERROR w95_open_reg (TALLOC_CTX *mem_ctx, struct registry_hive *h, struct
 		}
 
 
-		creg->rgdb_keys[i] = talloc_array_p(mem_ctx, RGDB_KEY *, rgdb_hdr->max_id+1);
+		creg->rgdb_keys[i] = talloc_array_p(h, 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);
@@ -259,7 +259,7 @@ static WERROR w95_open_reg (TALLOC_CTX *mem_ctx, struct registry_hive *h, struct
 	}
 	
 	/* First element in rgkn should be root key */
-	*root = talloc_p(mem_ctx, struct registry_key);
+	*root = talloc_p(h, struct registry_key);
 	(*root)->name = NULL;
 	(*root)->backend_data = LOCN_RGKN(creg, sizeof(RGKN_HDR));
 	
@@ -342,7 +342,7 @@ static WERROR w95_get_value_by_id(TALLOC_CTX *mem_ctx, struct registry_key *k, i
 	return WERR_OK;
 }
 
-static struct registry_operations reg_backend_w95 = {
+static struct hive_operations reg_backend_w95 = {
 	.name = "w95",
 	.open_hive = w95_open_reg,
 	.get_value_by_index = w95_get_value_by_id,
diff --git a/source4/lib/registry/reg_backend_wine/reg_backend_wine.c b/source4/lib/registry/reg_backend_wine.c
index 249af27e13..8a3458b52c 100644
--- a/source4/lib/registry/reg_backend_wine/reg_backend_wine.c
+++ b/source4/lib/registry/reg_backend_wine.c
@@ -22,8 +22,17 @@
 #include "lib/registry/common/registry.h"
 #include "windows/registry.h"
 
+static WERROR wine_open_reg (struct registry_hive *h, struct registry_key **key)
+{
+	/* FIXME: Open h->location and mmap it */
+}
+
+
+
 static REG_OPS reg_backend_wine = {
 	.name = "wine",
+	.open_hive = wine_open_reg,
+	
 };
 
 NTSTATUS registry_wine_init(void)
@@ -31,3 +40,9 @@ NTSTATUS registry_wine_init(void)
 	register_backend("registry", &reg_backend_wine);
 	return NT_STATUS_OK;
 }
+
+WERROR reg_open_wine(struct registry_key **ctx)
+{
+	/* FIXME: Open ~/.wine/system.reg, etc */
+	return WERR_NOT_SUPPORTED;
+}
diff --git a/source4/lib/registry/reg_samba.c b/source4/lib/registry/reg_samba.c
new file mode 100644
index 0000000000..a19029524d
--- /dev/null
+++ b/source4/lib/registry/reg_samba.c
@@ -0,0 +1,62 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Copyright (C) Jelmer Vernooij			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.
+*/
+
+#include "includes.h"
+#include "registry.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_REGISTRY
+
+static WERROR reg_samba_get_hive (struct registry_context *ctx, uint32 hkey, struct registry_key **k)
+{
+	WERROR error;
+	const char *conf;
+	char *backend, *location;
+	const char *hivename = reg_get_hkey_name(hkey);
+
+	*k = NULL;
+
+	conf = lp_parm_string(-1, "registry", hivename);
+	
+	if (!conf) {
+		return WERR_NOT_SUPPORTED;
+	}
+
+	backend = talloc_strdup(NULL, conf);
+	location = strchr(backend, ':');
+
+	if (location) {
+		*location = '\0';
+		location++;
+	}
+	
+	error = reg_open_hive(ctx, backend, location, NULL, k);
+
+	talloc_destroy(backend);
+
+	return error;
+}
+
+WERROR reg_open_local (struct registry_context **ctx)
+{
+	*ctx = talloc_p(NULL, struct registry_context);
+	(*ctx)->get_hive = reg_samba_get_hive;
+	
+	return WERR_OK;
+}
diff --git a/source4/lib/registry/tools/regdiff.c b/source4/lib/registry/tools/regdiff.c
index 55c8f1e72f..fc2954b6af 100644
--- a/source4/lib/registry/tools/regdiff.c
+++ b/source4/lib/registry/tools/regdiff.c
@@ -113,21 +113,19 @@ static void writediff(struct registry_key *oldkey, struct registry_key *newkey,
 {
 	int opt;
 	poptContext pc;
-	const char *backend1 = NULL, *backend2 = NULL;
-	const char *location2;
-	const char *credentials1= NULL, *credentials2 = NULL;
 	char *outputfile = NULL;
 	FILE *fd = stdout;
-	struct registry_context *h1 = NULL, *h2;
+	struct registry_context *h1 = NULL, *h2 = NULL;
 	int from_null = 0;
 	int i;
 	WERROR error, error2;
 	struct poptOption long_options[] = {
 		POPT_AUTOHELP
-		{"backend", 'b', POPT_ARG_STRING, NULL, 'b', "backend to use", NULL},
-		{"credentials", 'c', POPT_ARG_STRING, NULL, 'c', "credentials", NULL},
+		POPT_COMMON_CREDENTIALS
 		{"output", 'o', POPT_ARG_STRING, &outputfile, 'o', "output file to use", NULL },
-		{"null", 'n', POPT_ARG_NONE, &from_null, 'n', "Diff from NULL" },
+		{"null", 'n', POPT_ARG_NONE, &from_null, 'n', "Diff from NULL", NULL },
+		{"remote", 'R', POPT_ARG_STRING, NULL, 0, "Connect to remote server" , NULL },
+		{"local", 'L', POPT_ARG_NONE, NULL, 0, "Open local registry", NULL },
 		POPT_TABLEEND
 	};
 
@@ -141,49 +139,24 @@ static void writediff(struct registry_key *oldkey, struct registry_key *newkey,
 	pc = poptGetContext(argv[0], argc, (const char **) argv, long_options,0);
 
 	while((opt = poptGetNextOpt(pc)) != -1) {
+		error = WERR_OK;
 		switch(opt)	{
-		case 'c':
-			if(!credentials1 && !from_null) credentials1 = poptGetOptArg(pc);
-			else if(!credentials2) credentials2 = poptGetOptArg(pc);
+		case 'L':
+			if (!h1 && !from_null) error = reg_open_local(&h1);
+			else if (!h2) error = reg_open_local(&h2);
 			break;
-		case 'b':
-			if(!backend1 && !from_null) backend1 = poptGetOptArg(pc);
-			else if(!backend2) backend2 = poptGetOptArg(pc);
+		case 'R':
+			if (!h1 && !from_null) error = reg_open_remote(&h1, cmdline_get_username(), cmdline_get_userpassword(), poptGetOptArg(pc));
+			else if (!h2) error = reg_open_remote(&h2, cmdline_get_username(), cmdline_get_userpassword(), poptGetOptArg(pc));
 			break;
 		}
-	}
-	setup_logging(argv[0], True);
 
-	if(!from_null) {
-		const char *location1;
-		location1 = poptGetArg(pc);
-		if(!location1) {
-			poptPrintUsage(pc, stderr, 0);
+		if (!W_ERROR_IS_OK(error)) {
+			fprintf(stderr, "Error: %s\n", win_errstr(error));
 			return 1;
 		}
-
-		if(!backend1) backend1 = "rpc";
-
-		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;
-		}
-	} 
-
-	location2 = poptGetArg(pc);
-	if(!location2) {
-		poptPrintUsage(pc, stderr, 0);
-		return 2;
-	}
-
-	if(!backend2) backend2 = "rpc";
-
-	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;
 	}
+	setup_logging(argv[0], True);
 
 	poptFreeContext(pc);
 
@@ -196,12 +169,25 @@ static void writediff(struct registry_key *oldkey, struct registry_key *newkey,
 	}
 
 	fprintf(fd, "REGEDIT4\n\n");
-	fprintf(fd, "; Generated using regdiff\n");
+	fprintf(fd, "; Generated using regdiff, part of Samba\n");
 
 	error2 = error = WERR_OK; 
 
-	for(i = 0; (!h1 || i < h1->num_hives) && i < h2->num_hives; i++) {
-		writediff(h1?h1->hives[i]->root:NULL, h2->hives[i]->root, fd); 
+	for(i = HKEY_CLASSES_ROOT; i <= HKEY_PN; i++) {
+		struct registry_key *r1, *r2;
+		error = reg_get_hive(h1, i, &r1);
+		if (!W_ERROR_IS_OK(error)) {
+			DEBUG(0, ("Unable to open hive %s for backend 1\n", reg_get_hkey_name(i)));
+			continue;
+		}
+		
+		error = reg_get_hive(h2, i, &r2);
+		if (!W_ERROR_IS_OK(error)) {
+			DEBUG(0, ("Unable to open hive %s for backend 2\n", reg_get_hkey_name(i)));
+			continue;
+		}
+
+		writediff(r1, r2, fd); 
 	}
 
 	fclose(fd);
diff --git a/source4/lib/registry/tools/regpatch.c b/source4/lib/registry/tools/regpatch.c
index be60b96019..a4a4649c96 100644
--- a/source4/lib/registry/tools/regpatch.c
+++ b/source4/lib/registry/tools/regpatch.c
@@ -758,16 +758,14 @@ static int nt_apply_reg_command_file(struct registry_context *r, const char *cmd
 {
 	int opt;
 	poptContext pc;
-	const char *location;
-	const char *credentials = NULL;
 	const char *patch;
-	const char *backend = "rpc";
 	struct registry_context *h;
+	const char *remote = NULL;
 	WERROR error;
 	struct poptOption long_options[] = {
 		POPT_AUTOHELP
-		{"backend", 'b', POPT_ARG_STRING, &backend, 'b', "backend to use", NULL},
-		{"credentials", 'c', POPT_ARG_STRING, &credentials, 'c', "credentials (user%password", NULL},
+		POPT_COMMON_CREDENTIALS
+		{"remote", 'R', POPT_ARG_STRING, &remote, 0, "connect to specified remote server", NULL},
 		POPT_TABLEEND
 	};
 
@@ -785,25 +783,22 @@ static int nt_apply_reg_command_file(struct registry_context *r, const char *cmd
 
 	setup_logging(argv[0], True);
 
-	location = poptGetArg(pc);
-	if(!location) {
-		poptPrintUsage(pc, stderr, 0);
-		return 1;
+	if (remote) {
+		error = reg_open_remote (&h, cmdline_get_username(), cmdline_get_userpassword(), remote);
+	} else {
+		error = reg_open_local (&h);
 	}
 
-	error = reg_open(&h, backend, location, credentials);
-	if(!h) {
-		fprintf(stderr, "Unable to open '%s' with backend '%s'\n", location, backend);
+	if (W_ERROR_IS_OK(error)) {
+		fprintf(stderr, "Error: %s\n", win_errstr(error));
 		return 1;
 	}
-
+		
 	patch = poptGetArg(pc);
 	if(!patch) patch = "/dev/stdin";
 	poptFreeContext(pc);
 
 	nt_apply_reg_command_file(h, patch);
 
-	talloc_destroy(h->mem_ctx);
-
 	return 0;
 }
diff --git a/source4/lib/registry/tools/regshell.c b/source4/lib/registry/tools/regshell.c
index f18b012720..3fd9dab268 100644
--- a/source4/lib/registry/tools/regshell.c
+++ b/source4/lib/registry/tools/regshell.c
@@ -164,15 +164,23 @@ static struct registry_key *cmd_rmval(TALLOC_CTX *mem_ctx, struct registry_key *
 
 static struct registry_key *cmd_hive(TALLOC_CTX *mem_ctx, struct registry_key *cur, int argc, char **argv)
 {
-	int i;
-	for(i = 0; i < cur->hive->reg_ctx->num_hives; i++) {
+	if (!cur->hive->reg_ctx) {
+		fprintf(stderr, "Only one hive loaded\n");
+		return cur;
+	}
 
-		if(argc == 1) {
-			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;
-		} 
+	if (argc == 1) {
+		printf("%s\n", cur->hive->root->name);
+	} else {
+		struct registry_key *newroot;
+		WERROR error = reg_get_hive_by_name(cur->hive->reg_ctx, argv[1], &newroot);
+		if (W_ERROR_IS_OK(error)) {
+			return newroot;
+		} else {
+			fprintf(stderr, "Can't switch to hive %s: %s\n", cur->hive->root->name, win_errstr(error));
+		}
 	}
+
 	return NULL;
 }
 
@@ -274,11 +282,7 @@ static char **reg_complete_command(const char *text, int end)
 		matches[0] = strdup(matches[1]);
 		break;
 	default:
-		matches[0] = malloc(samelen+1);
-		if (!matches[0])
-			goto cleanup;
-		strncpy(matches[0], matches[1], samelen);
-		matches[0][samelen] = 0;
+		matches[0] = strndup(matches[1], samelen);
 	}
 	matches[count] = NULL;
 	return matches;
@@ -295,11 +299,11 @@ cleanup:
 static char **reg_complete_key(const char *text, int end)
 {
 	struct registry_key *subkey;
-	int i, j = 0;
+	int i, j = 1;
+	int samelen = 0;
 	int len;
 	char **matches;
 	TALLOC_CTX *mem_ctx;
-	/* Complete argument */
 
 	matches = malloc_array_p(char *, MAX_COMPLETIONS);
 	if (!matches) return NULL;
@@ -313,6 +317,12 @@ static char **reg_complete_key(const char *text, int end)
 			if(!strncmp(text, subkey->name, len)) {
 				matches[j] = strdup(subkey->name);
 				j++;
+
+				if (j == 1)
+					samelen = strlen(matches[j]);
+				else
+					while (strncmp(matches[j], matches[j-1], samelen) != 0)
+						samelen--;
 			}
 		} else if(W_ERROR_EQUAL(status, WERR_NO_MORE_ITEMS)) {
 			break;
@@ -322,8 +332,20 @@ static char **reg_complete_key(const char *text, int end)
 			return NULL;
 		}
 	}
-	matches[j] = NULL;
 	talloc_destroy(mem_ctx);
+
+	if (j == 1) { /* No matches at all */
+		SAFE_FREE(matches);
+		return NULL;
+	}
+
+	if (j == 2) { /* Exact match */
+		matches[0] = strdup(matches[1]);
+	} else {
+		matches[0] = strndup(matches[1], samelen);
+	}		
+
+	matches[j] = NULL;
 	return matches;
 }
 
@@ -341,18 +363,18 @@ static char **reg_completion(const char *text, int start, int end)
  int main(int argc, char **argv)
 {
 	int opt;
-	const char *backend = "rpc";
-	const char *credentials = NULL;
+	const char *backend = NULL;
 	struct registry_key *curkey = NULL;
 	poptContext pc;
 	WERROR error;
 	TALLOC_CTX *mem_ctx = talloc_init("cmd");
-	struct registry_context *h;
+	const char *remote = NULL;
+	struct registry_context *h = NULL;
 	struct poptOption long_options[] = {
 		POPT_AUTOHELP
-		POPT_COMMON_SAMBA
+		POPT_COMMON_CREDENTIALS
 		{"backend", 'b', POPT_ARG_STRING, &backend, 0, "backend to use", NULL},
-		{"credentials", 'c', POPT_ARG_STRING, &credentials, 0, "credentials", NULL},
+		{"remote", 'R', POPT_ARG_STRING, &remote, 0, "connect to specified remote server", NULL},
 		POPT_TABLEEND
 	};
 
@@ -370,20 +392,31 @@ static char **reg_completion(const char *text, int start, int end)
 
     setup_logging("regtree", True);
 
-	error = reg_open(&h, backend, poptPeekArg(pc), credentials);
+	if (remote) {
+		error = reg_open_remote (&h, cmdline_get_username(), cmdline_get_userpassword(), remote); 
+	} else if (backend) {
+		error = reg_open_hive(NULL, backend, poptGetArg(pc), NULL, &curkey);
+	} else {
+		error = reg_open_local(&h);
+	}
+
 	if(!W_ERROR_IS_OK(error)) {
-		fprintf(stderr, "Unable to open '%s' with backend '%s'\n", poptGetArg(pc), backend);
+		fprintf(stderr, "Unable to open registry\n");
 		return 1;
 	}
-	poptFreeContext(pc);
-
-	curkey = h->hives[0]->root;
 
+	if (h) {
+		/*FIXME: What if HKEY_CLASSES_ROOT is not present ? */
+		reg_get_hive(h, HKEY_CLASSES_ROOT, &curkey);
+	}
+	
+	poptFreeContext(pc);
+	
 	while(True) {
 		char *line, *prompt;
 		
-		if(curkey->hive->name) {
-			asprintf(&prompt, "%s:%s> ", curkey->hive->name, curkey->path);
+		if(curkey->hive->root->name) {
+			asprintf(&prompt, "%s:%s> ", curkey->hive->root->name, curkey->path);
 		} else {
 			asprintf(&prompt, "%s> ", curkey->path);
 		}
diff --git a/source4/lib/registry/tools/regtree.c b/source4/lib/registry/tools/regtree.c
index ced7a00f94..8ff68229eb 100644
--- a/source4/lib/registry/tools/regtree.c
+++ b/source4/lib/registry/tools/regtree.c
@@ -36,7 +36,7 @@ static void print_tree(int l, struct registry_key *p, int fullpath, int novals)
 	
 	/* Hive name */
 	if(p->hive->root == p) {
-		if(p->hive->name) printf("%s\n", p->hive->name); else printf("<No Name>\n");
+		if(p->hive->root->name) printf("%s\n", p->hive->root->name); else printf("<No Name>\n");
 	} else {
 		if(!p->name) printf("<No Name>\n");
 		if(fullpath) printf("%s\n", p->path);
@@ -73,17 +73,19 @@ static void print_tree(int l, struct registry_key *p, int fullpath, int novals)
  int main(int argc, char **argv)
 {
 	int opt, i;
-	const char *backend = "rpc";
-	const char *credentials = NULL;
+	const char *backend = NULL;
+	const char *remote = NULL;
 	poptContext pc;
-	struct registry_context *h;
+	struct registry_context *h = NULL;
+	struct registry_key *root = NULL;
 	WERROR error;
 	int fullpath = 0, no_values = 0;
 	struct poptOption long_options[] = {
 		POPT_AUTOHELP
+		POPT_COMMON_CREDENTIALS	
 		{"backend", 'b', POPT_ARG_STRING, &backend, 0, "backend to use", NULL},
 		{"fullpath", 'f', POPT_ARG_NONE, &fullpath, 0, "show full paths", NULL},
-		{"credentials", 'c', POPT_ARG_STRING, &credentials, 0, "credentials (user%password)", NULL},
+		{"remote", 'R', POPT_ARG_STRING, &remote, 0, "connect to specified remote server", NULL },
 		{"no-values", 'V', POPT_ARG_NONE, &no_values, 0, "don't show values", NULL},
 		POPT_TABLEEND
 	};
@@ -102,7 +104,14 @@ static void print_tree(int l, struct registry_key *p, int fullpath, int novals)
 
 	setup_logging("regtree", True);
 
-	error = reg_open(&h, backend, poptPeekArg(pc), credentials);
+	if (remote) {
+		error = reg_open_remote(&h, cmdline_get_username(), cmdline_get_userpassword(), remote);
+	} else if (backend) {
+	    error = reg_open_hive(NULL, backend, poptGetArg(pc), NULL, &root);
+	} else {
+		error = reg_open_local (&h);
+	}
+
 	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;
@@ -110,10 +119,19 @@ static void print_tree(int l, struct registry_key *p, int fullpath, int novals)
 	poptFreeContext(pc);
 
 	error = WERR_OK;
-
-	for(i = 0; i < h->num_hives; i++) {
-		print_tree(0, h->hives[i]->root, fullpath, no_values);
-	}
 	
+	if (!h) {
+		print_tree(0, root, fullpath, no_values);
+	} else {
+		for(i = HKEY_CLASSES_ROOT; i < HKEY_PN; i++) {
+			error = reg_get_hive(h, i, &root);
+			if (!W_ERROR_IS_OK(error)) {
+				fprintf(stderr, "Skipping %s\n", reg_get_hkey_name(i));
+				continue;
+			}
+			print_tree(0, root, fullpath, no_values);
+		}
+	}
+
 	return 0;
 }