Adding upstream version 2:4.17.12+dfsg.upstream/2%4.17.12+dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2126 insertions, 0 deletions

diff --git a/source3/utils/net_rpc_registry.c b/source3/utils/net_rpc_registry.c
new file mode 100644
index 0000000..cec5459
--- /dev/null
+++ b/source3/utils/net_rpc_registry.c
@@ -0,0 +1,2126 @@
+/* 
+   Samba Unix/Linux SMB client library 
+   Distributed SMB/CIFS Server Management Utility 
+
+   Copyright (C) Gerald (Jerry) Carter          2005-2006
+
+   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 3 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, see <http://www.gnu.org/licenses/>.  */
+ 
+#include "includes.h"
+#include "system/filesys.h"
+#include "rpc_client/rpc_client.h"
+#include "registry.h"
+#include "utils/net.h"
+#include "utils/net_registry_util.h"
+#include "registry/regfio.h"
+#include "../librpc/gen_ndr/ndr_winreg_c.h"
+#include "../librpc/gen_ndr/ndr_security.h"
+#include "registry/reg_format.h"
+#include "registry/reg_import.h"
+#include <assert.h>
+#include "../libcli/security/display_sec.h"
+#include "../libcli/registry/util_reg.h"
+#include "client.h"
+#include "lib/util/smb_strtox.h"
+
+
+/*******************************************************************
+ connect to a registry hive root (open a registry policy)
+*******************************************************************/
+
+static NTSTATUS dcerpc_winreg_Connect(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
+				      uint32_t reg_type, uint32_t access_mask,
+				      struct policy_handle *reg_hnd, WERROR *werr)
+{
+	ZERO_STRUCTP(reg_hnd);
+
+	switch (reg_type)
+	{
+	case HKEY_CLASSES_ROOT:
+		return dcerpc_winreg_OpenHKCR(b, mem_ctx, NULL,
+			access_mask, reg_hnd, werr);
+
+	case HKEY_LOCAL_MACHINE:
+		return dcerpc_winreg_OpenHKLM(b, mem_ctx, NULL,
+			access_mask, reg_hnd, werr);
+
+	case HKEY_USERS:
+		return dcerpc_winreg_OpenHKU(b, mem_ctx, NULL,
+			access_mask, reg_hnd, werr);
+
+	case HKEY_CURRENT_USER:
+		return dcerpc_winreg_OpenHKCU(b, mem_ctx, NULL,
+			access_mask, reg_hnd, werr);
+
+	case HKEY_PERFORMANCE_DATA:
+		return dcerpc_winreg_OpenHKPD(b, mem_ctx, NULL,
+			access_mask, reg_hnd, werr);
+
+	default:
+		/* fall through to end of function */
+		break;
+	}
+
+	return NT_STATUS_INVALID_PARAMETER;
+}
+
+static bool reg_hive_key(TALLOC_CTX *ctx, const char *fullname,
+			 uint32_t *reg_type, const char **key_name)
+{
+	WERROR werr;
+	char *hivename = NULL;
+	char *tmp_keyname = NULL;
+	bool ret = false;
+	TALLOC_CTX *tmp_ctx = talloc_stackframe();
+
+	werr = split_hive_key(tmp_ctx, fullname, &hivename, &tmp_keyname);
+	if (!W_ERROR_IS_OK(werr)) {
+		goto done;
+	}
+
+	*key_name = talloc_strdup(ctx, tmp_keyname);
+	if (*key_name == NULL) {
+		goto done;
+	}
+
+	if (strequal(hivename, "HKLM") ||
+	    strequal(hivename, "HKEY_LOCAL_MACHINE"))
+	{
+		(*reg_type) = HKEY_LOCAL_MACHINE;
+	} else if (strequal(hivename, "HKCR") ||
+		   strequal(hivename, "HKEY_CLASSES_ROOT"))
+	{
+		(*reg_type) = HKEY_CLASSES_ROOT;
+	} else if (strequal(hivename, "HKU") ||
+		   strequal(hivename, "HKEY_USERS"))
+	{
+		(*reg_type) = HKEY_USERS;
+	} else if (strequal(hivename, "HKCU") ||
+		   strequal(hivename, "HKEY_CURRENT_USER"))
+	{
+		(*reg_type) = HKEY_CURRENT_USER;
+	} else if (strequal(hivename, "HKPD") ||
+		   strequal(hivename, "HKEY_PERFORMANCE_DATA"))
+	{
+		(*reg_type) = HKEY_PERFORMANCE_DATA;
+	} else {
+		DEBUG(10,("reg_hive_key: unrecognised hive key %s\n",
+			  fullname));
+		goto done;
+	}
+
+	ret = true;
+
+done:
+	TALLOC_FREE(tmp_ctx);
+	return ret;
+}
+
+static NTSTATUS registry_openkey(TALLOC_CTX *mem_ctx,
+				 struct rpc_pipe_client *pipe_hnd,
+				 const char *name, uint32_t access_mask,
+				 struct policy_handle *hive_hnd,
+				 struct policy_handle *key_hnd)
+{
+	uint32_t hive;
+	NTSTATUS status;
+	WERROR werr;
+	struct winreg_String key;
+	struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+	ZERO_STRUCT(key);
+
+	if (!reg_hive_key(mem_ctx, name, &hive, &key.name)) {
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	status = dcerpc_winreg_Connect(b, mem_ctx, hive, access_mask,
+				       hive_hnd, &werr);
+	if (!(NT_STATUS_IS_OK(status))) {
+		return status;
+	}
+	if (!W_ERROR_IS_OK(werr)) {
+		return werror_to_ntstatus(werr);
+	}
+
+	status = dcerpc_winreg_OpenKey(b, mem_ctx, hive_hnd, key, 0,
+				       access_mask, key_hnd, &werr);
+	if (!(NT_STATUS_IS_OK(status))) {
+		dcerpc_winreg_CloseKey(b, mem_ctx, hive_hnd, &werr);
+		return status;
+	}
+	if (!(W_ERROR_IS_OK(werr))) {
+		WERROR _werr;
+		dcerpc_winreg_CloseKey(b, mem_ctx, hive_hnd, &_werr);
+		return werror_to_ntstatus(werr);
+	}
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS registry_enumkeys(TALLOC_CTX *ctx,
+				  struct rpc_pipe_client *pipe_hnd,
+				  struct policy_handle *key_hnd,
+				  uint32_t *pnum_keys, char ***pnames,
+				  char ***pclasses, NTTIME ***pmodtimes)
+{
+	TALLOC_CTX *mem_ctx;
+	NTSTATUS status;
+	WERROR werr;
+	uint32_t num_subkeys, max_subkeylen, max_classlen;
+	uint32_t num_values, max_valnamelen, max_valbufsize;
+	uint32_t i;
+	NTTIME last_changed_time;
+	uint32_t secdescsize;
+	struct winreg_String classname;
+	char **names, **classes;
+	NTTIME **modtimes;
+	struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+	if (!(mem_ctx = talloc_new(ctx))) {
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	ZERO_STRUCT(classname);
+	status = dcerpc_winreg_QueryInfoKey(
+		b, mem_ctx, key_hnd, &classname, &num_subkeys,
+		&max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
+		&max_valbufsize, &secdescsize, &last_changed_time, &werr);
+
+	if (!NT_STATUS_IS_OK(status)) {
+		goto error;
+	}
+	if (!W_ERROR_IS_OK(werr)) {
+		status = werror_to_ntstatus(werr);
+		goto error;
+	}
+
+	if (num_subkeys == 0) {
+		*pnum_keys = 0;
+		TALLOC_FREE(mem_ctx);
+		return NT_STATUS_OK;
+	}
+
+	if ((!(names = talloc_zero_array(mem_ctx, char *, num_subkeys))) ||
+	    (!(classes = talloc_zero_array(mem_ctx, char *, num_subkeys))) ||
+	    (!(modtimes = talloc_zero_array(mem_ctx, NTTIME *,
+					    num_subkeys)))) {
+		status = NT_STATUS_NO_MEMORY;
+		goto error;
+	}
+
+	for (i=0; i<num_subkeys; i++) {
+		char c, n;
+		struct winreg_StringBuf class_buf;
+		struct winreg_StringBuf name_buf;
+		NTTIME modtime;
+
+		c = '\0';
+		class_buf.name = &c;
+		class_buf.size = max_classlen+2;
+
+		n = '\0';
+		name_buf.name = &n;
+		name_buf.size = max_subkeylen+2;
+
+		ZERO_STRUCT(modtime);
+
+		status = dcerpc_winreg_EnumKey(b, mem_ctx, key_hnd,
+					       i, &name_buf, &class_buf,
+					       &modtime, &werr);
+		if (!NT_STATUS_IS_OK(status)) {
+			goto error;
+		}
+		if (W_ERROR_EQUAL(werr,
+				  WERR_NO_MORE_ITEMS) ) {
+			status = NT_STATUS_OK;
+			break;
+		}
+		if (!W_ERROR_IS_OK(werr)) {
+			status = werror_to_ntstatus(werr);
+			goto error;
+		}
+
+		classes[i] = NULL;
+
+		if (class_buf.name &&
+		    (!(classes[i] = talloc_strdup(classes, class_buf.name)))) {
+			status = NT_STATUS_NO_MEMORY;
+			goto error;
+		}
+
+		if (!(names[i] = talloc_strdup(names, name_buf.name))) {
+			status = NT_STATUS_NO_MEMORY;
+			goto error;
+		}
+
+		if ((!(modtimes[i] = (NTTIME *)talloc_memdup(
+			       modtimes, &modtime, sizeof(modtime))))) {
+			status = NT_STATUS_NO_MEMORY;
+			goto error;
+		}
+	}
+
+	*pnum_keys = num_subkeys;
+
+	if (pnames) {
+		*pnames = talloc_move(ctx, &names);
+	}
+	if (pclasses) {
+		*pclasses = talloc_move(ctx, &classes);
+	}
+	if (pmodtimes) {
+		*pmodtimes = talloc_move(ctx, &modtimes);
+	}
+
+	status = NT_STATUS_OK;
+
+ error:
+	TALLOC_FREE(mem_ctx);
+	return status;
+}
+
+static NTSTATUS registry_enumvalues(TALLOC_CTX *ctx,
+				    struct rpc_pipe_client *pipe_hnd,
+				    struct policy_handle *key_hnd,
+				    uint32_t *pnum_values, char ***pvalnames,
+				    struct registry_value ***pvalues)
+{
+	TALLOC_CTX *mem_ctx;
+	NTSTATUS status;
+	WERROR werr;
+	uint32_t num_subkeys, max_subkeylen, max_classlen;
+	uint32_t num_values, max_valnamelen, max_valbufsize;
+	uint32_t i;
+	NTTIME last_changed_time;
+	uint32_t secdescsize;
+	struct winreg_String classname;
+	struct registry_value **values;
+	char **names;
+	struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+	if (!(mem_ctx = talloc_new(ctx))) {
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	ZERO_STRUCT(classname);
+	status = dcerpc_winreg_QueryInfoKey(
+		b, mem_ctx, key_hnd, &classname, &num_subkeys,
+		&max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
+		&max_valbufsize, &secdescsize, &last_changed_time, &werr);
+
+	if (!NT_STATUS_IS_OK(status)) {
+		goto error;
+	}
+	if (!W_ERROR_IS_OK(werr)) {
+		status = werror_to_ntstatus(werr);
+		goto error;
+	}
+
+	if (num_values == 0) {
+		*pnum_values = 0;
+		TALLOC_FREE(mem_ctx);
+		return NT_STATUS_OK;
+	}
+
+	if ((!(names = talloc_array(mem_ctx, char *, num_values))) ||
+	    (!(values = talloc_array(mem_ctx, struct registry_value *,
+				     num_values)))) {
+		status = NT_STATUS_NO_MEMORY;
+		goto error;
+	}
+
+	for (i=0; i<num_values; i++) {
+		enum winreg_Type type = REG_NONE;
+		uint8_t *data = NULL;
+		uint32_t data_size;
+		uint32_t value_length;
+
+		char n;
+		struct winreg_ValNameBuf name_buf;
+		WERROR err;
+
+		n = '\0';
+		name_buf.name = &n;
+		name_buf.size = max_valnamelen + 2;
+
+		data_size = max_valbufsize;
+		data = (uint8_t *)TALLOC(mem_ctx, data_size);
+		value_length = 0;
+
+		status = dcerpc_winreg_EnumValue(b, mem_ctx, key_hnd,
+						 i, &name_buf, &type,
+						 data, &data_size,
+						 &value_length, &err);
+		if (!(NT_STATUS_IS_OK(status))) {
+			goto error;
+		}
+
+		if ( W_ERROR_EQUAL(err,
+				   WERR_NO_MORE_ITEMS) ) {
+			status = NT_STATUS_OK;
+			break;
+		}
+
+		if (!W_ERROR_IS_OK(err)) {
+			status = werror_to_ntstatus(err);
+			goto error;
+		}
+
+		if (name_buf.name == NULL) {
+			status = NT_STATUS_INVALID_PARAMETER;
+			goto error;
+		}
+
+		if (!(names[i] = talloc_strdup(names, name_buf.name))) {
+			status = NT_STATUS_NO_MEMORY;
+			goto error;
+		}
+
+		values[i] = talloc_zero(values, struct registry_value);
+		if (values[i] == NULL) {
+			status = NT_STATUS_NO_MEMORY;
+			goto error;
+		}
+
+		values[i]->type	= type;
+		values[i]->data = data_blob_talloc(values[i], data, data_size);
+	}
+
+	*pnum_values = num_values;
+
+	if (pvalnames) {
+		*pvalnames = talloc_move(ctx, &names);
+	}
+	if (pvalues) {
+		*pvalues = talloc_move(ctx, &values);
+	}
+
+	status = NT_STATUS_OK;
+
+ error:
+	TALLOC_FREE(mem_ctx);
+	return status;
+}
+
+static NTSTATUS registry_enumvalues2(TALLOC_CTX *ctx,
+				     struct rpc_pipe_client *pipe_hnd,
+				     struct policy_handle *key_hnd,
+				     uint32_t *pnum_values, char ***pvalnames,
+				     struct regval_blob ***pvalues)
+{
+	TALLOC_CTX *mem_ctx;
+	NTSTATUS status;
+	WERROR werr;
+	uint32_t num_subkeys, max_subkeylen, max_classlen;
+	uint32_t num_values, max_valnamelen, max_valbufsize;
+	uint32_t i;
+	NTTIME last_changed_time;
+	uint32_t secdescsize;
+	struct winreg_String classname;
+	struct regval_blob **values;
+	char **names;
+	struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+	if (!(mem_ctx = talloc_new(ctx))) {
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	ZERO_STRUCT(classname);
+	status = dcerpc_winreg_QueryInfoKey(
+		b, mem_ctx, key_hnd, &classname, &num_subkeys,
+		&max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
+		&max_valbufsize, &secdescsize, &last_changed_time, &werr);
+
+	if (!NT_STATUS_IS_OK(status)) {
+		goto error;
+	}
+	if (!W_ERROR_IS_OK(werr)) {
+		status = werror_to_ntstatus(werr);
+		goto error;
+	}
+
+	if (num_values == 0) {
+		*pnum_values = 0;
+		TALLOC_FREE(mem_ctx);
+		return NT_STATUS_OK;
+	}
+
+	if ((!(names = talloc_array(mem_ctx, char *, num_values))) ||
+	    (!(values = talloc_array(mem_ctx, struct regval_blob *,
+				     num_values)))) {
+		status = NT_STATUS_NO_MEMORY;
+		goto error;
+	}
+
+	for (i=0; i<num_values; i++) {
+		enum winreg_Type type = REG_NONE;
+		uint8_t *data = NULL;
+		uint32_t data_size;
+		uint32_t value_length;
+
+		char n;
+		struct winreg_ValNameBuf name_buf;
+		WERROR err;
+
+		n = '\0';
+		name_buf.name = &n;
+		name_buf.size = max_valnamelen + 2;
+
+		data_size = max_valbufsize;
+		data = (uint8_t *)TALLOC(mem_ctx, data_size);
+		value_length = 0;
+
+		status = dcerpc_winreg_EnumValue(b, mem_ctx, key_hnd,
+						 i, &name_buf, &type,
+						 data, &data_size,
+						 &value_length, &err);
+		if (!(NT_STATUS_IS_OK(status))) {
+			goto error;
+		}
+
+		if ( W_ERROR_EQUAL(err, WERR_NO_MORE_ITEMS) ) {
+			status = NT_STATUS_OK;
+			break;
+		}
+
+		if (!W_ERROR_IS_OK(err)) {
+			status = werror_to_ntstatus(err);
+			goto error;
+		}
+
+		if (name_buf.name == NULL) {
+			status = NT_STATUS_INVALID_PARAMETER;
+			goto error;
+		}
+
+		if (!(names[i] = talloc_strdup(names, name_buf.name))) {
+			status = NT_STATUS_NO_MEMORY;
+			goto error;
+		}
+
+		assert(value_length<=data_size); /*??? */
+
+		values[i] = regval_compose(values,
+					   name_buf.name,
+					   type,
+					   data, value_length);
+		if (!values[i]) {
+			status = NT_STATUS_NO_MEMORY;
+			goto error;
+		}
+	}
+
+	*pnum_values = num_values;
+
+	if (pvalnames) {
+		*pvalnames = talloc_move(ctx, &names);
+	}
+	if (pvalues) {
+		*pvalues = talloc_move(ctx, &values);
+	}
+
+	status = NT_STATUS_OK;
+
+ error:
+	TALLOC_FREE(mem_ctx);
+	return status;
+}
+
+static NTSTATUS registry_getsd(TALLOC_CTX *mem_ctx,
+			       struct dcerpc_binding_handle *b,
+			       struct policy_handle *key_hnd,
+			       uint32_t sec_info,
+			       struct KeySecurityData *sd,
+			       WERROR *werr)
+{
+	return dcerpc_winreg_GetKeySecurity(b, mem_ctx, key_hnd,
+					    sec_info, sd, werr);
+}
+
+
+static NTSTATUS registry_setvalue(TALLOC_CTX *mem_ctx,
+				  struct rpc_pipe_client *pipe_hnd,
+				  struct policy_handle *key_hnd,
+				  const char *name,
+				  const struct registry_value *value)
+{
+	struct winreg_String name_string;
+	NTSTATUS result;
+	WERROR werr;
+	struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+	ZERO_STRUCT(name_string);
+
+	name_string.name = name;
+	result = dcerpc_winreg_SetValue(b, mem_ctx, key_hnd,
+					name_string, value->type,
+					value->data.data, value->data.length, &werr);
+	if (!NT_STATUS_IS_OK(result)) {
+		return result;
+	}
+
+	return werror_to_ntstatus(werr);
+}
+
+static NTSTATUS rpc_registry_setvalue_internal(struct net_context *c,
+					       const struct dom_sid *domain_sid,
+					       const char *domain_name,
+					       struct cli_state *cli,
+					       struct rpc_pipe_client *pipe_hnd,
+					       TALLOC_CTX *mem_ctx,
+					       int argc,
+					       const char **argv )
+{
+	struct policy_handle hive_hnd, key_hnd;
+	NTSTATUS status;
+	WERROR werr;
+	struct registry_value value;
+	struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+	status = registry_openkey(mem_ctx, pipe_hnd, argv[0],
+				  SEC_FLAG_MAXIMUM_ALLOWED,
+				  &hive_hnd, &key_hnd);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("registry_openkey failed: %s\n"),
+			  nt_errstr(status));
+		return status;
+	}
+
+	if (!strequal(argv[2], "multi_sz") && (argc != 4)) {
+		d_fprintf(stderr, _("Too many args for type %s\n"), argv[2]);
+		return NT_STATUS_NOT_IMPLEMENTED;
+	}
+
+	if (strequal(argv[2], "dword")) {
+		int error = 0;
+		uint32_t v;
+
+		v = smb_strtoul(argv[3], NULL, 10, &error, SMB_STR_STANDARD);
+		if (error != 0) {
+			goto error;
+		}
+
+		value.type = REG_DWORD;
+		value.data = data_blob_talloc(mem_ctx, NULL, 4);
+		SIVAL(value.data.data, 0, v);
+	}
+	else if (strequal(argv[2], "sz")) {
+		value.type = REG_SZ;
+		if (!push_reg_sz(mem_ctx, &value.data, argv[3])) {
+			status = NT_STATUS_NO_MEMORY;
+			goto error;
+		}
+	}
+	else {
+		d_fprintf(stderr, _("type \"%s\" not implemented\n"), argv[2]);
+		status = NT_STATUS_NOT_IMPLEMENTED;
+		goto error;
+	}
+
+	status = registry_setvalue(mem_ctx, pipe_hnd, &key_hnd,
+				   argv[1], &value);
+
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("registry_setvalue failed: %s\n"),
+			  nt_errstr(status));
+	}
+
+ error:
+	dcerpc_winreg_CloseKey(b, mem_ctx, &key_hnd, &werr);
+	dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &werr);
+
+	return NT_STATUS_OK;
+}
+
+static int rpc_registry_setvalue(struct net_context *c, int argc,
+				 const char **argv )
+{
+	if (argc < 4 || c->display_usage) {
+		d_fprintf(stderr, "%s\n%s",
+			  _("Usage:"),
+			  _("net rpc registry setvalue <key> <valuename> "
+			    "<type> [<val>]+\n"));
+		return -1;
+	}
+
+	return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
+		rpc_registry_setvalue_internal, argc, argv );
+}
+
+static NTSTATUS rpc_registry_deletevalue_internal(struct net_context *c,
+						  const struct dom_sid *domain_sid,
+						  const char *domain_name,
+						  struct cli_state *cli,
+						  struct rpc_pipe_client *pipe_hnd,
+						  TALLOC_CTX *mem_ctx,
+						  int argc,
+						  const char **argv )
+{
+	struct policy_handle hive_hnd, key_hnd;
+	NTSTATUS status;
+	WERROR werr;
+	struct winreg_String valuename;
+	struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+	ZERO_STRUCT(valuename);
+
+	status = registry_openkey(mem_ctx, pipe_hnd, argv[0],
+				  SEC_FLAG_MAXIMUM_ALLOWED,
+				  &hive_hnd, &key_hnd);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("registry_openkey failed: %s\n"),
+			  nt_errstr(status));
+		return status;
+	}
+
+	valuename.name = argv[1];
+
+	status = dcerpc_winreg_DeleteValue(b, mem_ctx, &key_hnd,
+					   valuename, &werr);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("registry_deletevalue failed: %s\n"),
+			  nt_errstr(status));
+	}
+	if (!W_ERROR_IS_OK(werr)) {
+		status = werror_to_ntstatus(werr);
+		d_fprintf(stderr, _("registry_deletevalue failed: %s\n"),
+			  win_errstr(werr));
+	}
+
+	dcerpc_winreg_CloseKey(b, mem_ctx, &key_hnd, &werr);
+	dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &werr);
+
+	return status;
+}
+
+static int rpc_registry_deletevalue(struct net_context *c, int argc,
+				    const char **argv )
+{
+	if (argc != 2 || c->display_usage) {
+		d_fprintf(stderr, "%s\n%s",
+			  _("Usage:"),
+			  _("net rpc registry deletevalue <key> <valuename>\n"));
+		return -1;
+	}
+
+	return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
+		rpc_registry_deletevalue_internal, argc, argv );
+}
+
+static NTSTATUS rpc_registry_getvalue_internal(struct net_context *c,
+					       const struct dom_sid *domain_sid,
+					       const char *domain_name,
+					       struct cli_state *cli,
+					       struct rpc_pipe_client *pipe_hnd,
+					       TALLOC_CTX *mem_ctx,
+					       bool raw,
+					       int argc,
+					       const char **argv)
+{
+	struct policy_handle hive_hnd, key_hnd;
+	NTSTATUS status;
+	WERROR werr;
+	struct winreg_String valuename;
+	struct registry_value *value = NULL;
+	enum winreg_Type type = REG_NONE;
+	uint32_t data_size = 0;
+	uint32_t value_length = 0;
+	TALLOC_CTX *tmp_ctx = talloc_stackframe();
+	struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+	ZERO_STRUCT(valuename);
+
+	status = registry_openkey(tmp_ctx, pipe_hnd, argv[0],
+				  SEC_FLAG_MAXIMUM_ALLOWED,
+				  &hive_hnd, &key_hnd);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("registry_openkey failed: %s\n"),
+			  nt_errstr(status));
+		return status;
+	}
+
+	valuename.name = argv[1];
+
+	value = talloc_zero(tmp_ctx, struct registry_value);
+	if (value == NULL) {
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	/*
+	 * call QueryValue once with data == NULL to get the
+	 * needed memory size to be allocated, then allocate
+	 * data buffer and call again.
+	 */
+	status = dcerpc_winreg_QueryValue(b, tmp_ctx, &key_hnd,
+					  &valuename,
+					  &type,
+					  NULL,
+					  &data_size,
+					  &value_length,
+					  &werr);
+
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("registry_queryvalue failed: %s\n"),
+			  nt_errstr(status));
+		goto done;
+	}
+	if (!W_ERROR_IS_OK(werr)) {
+		status = werror_to_ntstatus(werr);
+		d_fprintf(stderr, _("registry_queryvalue failed: %s\n"),
+			  nt_errstr(status));
+		goto done;
+	}
+
+	value->data = data_blob_talloc(tmp_ctx, NULL, data_size);
+
+	status = dcerpc_winreg_QueryValue(b, tmp_ctx, &key_hnd,
+					  &valuename,
+					  &type,
+					  value->data.data,
+					  &data_size,
+					  &value_length,
+					  &werr);
+
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("registry_queryvalue failed: %s\n"),
+			  nt_errstr(status));
+		goto done;
+	}
+	if (!W_ERROR_IS_OK(werr)) {
+		status = werror_to_ntstatus(werr);
+		d_fprintf(stderr, _("registry_queryvalue failed: %s\n"),
+			  win_errstr(werr));
+		goto done;
+	}
+
+
+	value->type = type;
+
+	print_registry_value(value, raw);
+
+done:
+	dcerpc_winreg_CloseKey(b, tmp_ctx, &key_hnd, &werr);
+	dcerpc_winreg_CloseKey(b, tmp_ctx, &hive_hnd, &werr);
+
+	TALLOC_FREE(tmp_ctx);
+
+	return status;
+}
+
+static NTSTATUS rpc_registry_getvalue_full(struct net_context *c,
+					   const struct dom_sid *domain_sid,
+					   const char *domain_name,
+					   struct cli_state *cli,
+					   struct rpc_pipe_client *pipe_hnd,
+					   TALLOC_CTX *mem_ctx,
+					   int argc,
+					   const char **argv)
+{
+	return rpc_registry_getvalue_internal(c, domain_sid, domain_name,
+					      cli, pipe_hnd, mem_ctx, false,
+					      argc, argv);
+}
+
+static int rpc_registry_getvalue(struct net_context *c, int argc,
+				 const char **argv)
+{
+	if (argc != 2 || c->display_usage) {
+		d_fprintf(stderr, "%s\n%s",
+			  _("Usage:"),
+			  _("net rpc registry getvalue <key> <valuename>\n"));
+		return -1;
+	}
+
+	return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
+		rpc_registry_getvalue_full, argc, argv);
+}
+
+static NTSTATUS rpc_registry_getvalue_raw(struct net_context *c,
+					  const struct dom_sid *domain_sid,
+					  const char *domain_name,
+					  struct cli_state *cli,
+					  struct rpc_pipe_client *pipe_hnd,
+					  TALLOC_CTX *mem_ctx,
+					  int argc,
+					  const char **argv)
+{
+	return rpc_registry_getvalue_internal(c, domain_sid, domain_name,
+					      cli, pipe_hnd, mem_ctx, true,
+					      argc, argv);
+}
+
+static int rpc_registry_getvalueraw(struct net_context *c, int argc,
+				    const char **argv)
+{
+	if (argc != 2 || c->display_usage) {
+		d_fprintf(stderr, "%s\n%s",
+			  _("Usage:"),
+			  _("net rpc registry getvalue <key> <valuename>\n"));
+		return -1;
+	}
+
+	return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
+		rpc_registry_getvalue_raw, argc, argv);
+}
+
+static NTSTATUS rpc_registry_createkey_internal(struct net_context *c,
+						const struct dom_sid *domain_sid,
+						const char *domain_name,
+						struct cli_state *cli,
+						struct rpc_pipe_client *pipe_hnd,
+						TALLOC_CTX *mem_ctx,
+						int argc,
+						const char **argv )
+{
+	uint32_t hive;
+	struct policy_handle hive_hnd, key_hnd;
+	struct winreg_String key, keyclass;
+	enum winreg_CreateAction action;
+	NTSTATUS status;
+	WERROR werr;
+	struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+	ZERO_STRUCT(key);
+	ZERO_STRUCT(keyclass);
+
+	if (!reg_hive_key(mem_ctx, argv[0], &hive, &key.name)) {
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	status = dcerpc_winreg_Connect(b, mem_ctx, hive,
+				       SEC_FLAG_MAXIMUM_ALLOWED,
+				       &hive_hnd, &werr);
+	if (!(NT_STATUS_IS_OK(status))) {
+		return status;
+	}
+	if (!W_ERROR_IS_OK(werr)) {
+		return werror_to_ntstatus(werr);
+	}
+
+	action = REG_ACTION_NONE;
+	keyclass.name = "";
+
+	status = dcerpc_winreg_CreateKey(b, mem_ctx, &hive_hnd, key,
+					 keyclass, 0, REG_KEY_READ, NULL,
+					 &key_hnd, &action, &werr);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("createkey returned %s\n"),
+			  nt_errstr(status));
+		dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &werr);
+		return status;
+	}
+	if (!W_ERROR_IS_OK(werr)) {
+		WERROR _werr;
+		d_fprintf(stderr, _("createkey returned %s\n"),
+			  win_errstr(werr));
+		dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &_werr);
+		return werror_to_ntstatus(werr);
+	}
+
+	switch (action) {
+		case REG_ACTION_NONE:
+			d_printf(_("createkey did nothing -- huh?\n"));
+			break;
+		case REG_CREATED_NEW_KEY:
+			d_printf(_("createkey created %s\n"), argv[0]);
+			break;
+		case REG_OPENED_EXISTING_KEY:
+			d_printf(_("createkey opened existing %s\n"), argv[0]);
+			break;
+	}
+
+	dcerpc_winreg_CloseKey(b, mem_ctx, &key_hnd, &werr);
+	dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &werr);
+
+	return status;
+}
+
+static int rpc_registry_createkey(struct net_context *c, int argc,
+				  const char **argv )
+{
+	if (argc != 1 || c->display_usage) {
+		d_fprintf(stderr, "%s\n%s",
+			  _("Usage:"),
+			  _("net rpc registry createkey <key>\n"));
+		return -1;
+	}
+
+	return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
+		rpc_registry_createkey_internal, argc, argv );
+}
+
+static NTSTATUS rpc_registry_deletekey_internal(struct net_context *c,
+						const struct dom_sid *domain_sid,
+						const char *domain_name,
+						struct cli_state *cli,
+						struct rpc_pipe_client *pipe_hnd,
+						TALLOC_CTX *mem_ctx,
+						int argc,
+						const char **argv )
+{
+	uint32_t hive;
+	struct policy_handle hive_hnd;
+	struct winreg_String key;
+	NTSTATUS status;
+	WERROR werr;
+	struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+	ZERO_STRUCT(key);
+
+	if (!reg_hive_key(mem_ctx, argv[0], &hive, &key.name)) {
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	status = dcerpc_winreg_Connect(b, mem_ctx, hive,
+				       SEC_FLAG_MAXIMUM_ALLOWED,
+				       &hive_hnd, &werr);
+	if (!(NT_STATUS_IS_OK(status))) {
+		return status;
+	}
+	if (!W_ERROR_IS_OK(werr)) {
+		return werror_to_ntstatus(werr);
+	}
+
+	status = dcerpc_winreg_DeleteKey(b, mem_ctx, &hive_hnd, key, &werr);
+	if (is_valid_policy_hnd(&hive_hnd)) {
+		WERROR _werr;
+		dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &_werr);
+	}
+
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("deletekey returned %s\n"),
+			  nt_errstr(status));
+		return status;
+	}
+
+	if (!W_ERROR_IS_OK(werr)) {
+		d_fprintf(stderr, _("deletekey returned %s\n"),
+			  win_errstr(werr));
+		return werror_to_ntstatus(werr);
+	}
+
+	return status;
+}
+
+static int rpc_registry_deletekey(struct net_context *c, int argc, const char **argv )
+{
+	if (argc != 1 || c->display_usage) {
+		d_fprintf(stderr, "%s\n%s",
+			  _("Usage:"),
+			  _("net rpc registry deletekey <key>\n"));
+		return -1;
+	}
+
+	return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
+		rpc_registry_deletekey_internal, argc, argv );
+}
+
+/********************************************************************
+********************************************************************/
+
+static NTSTATUS rpc_registry_enumerate_internal(struct net_context *c,
+						const struct dom_sid *domain_sid,
+						const char *domain_name,
+						struct cli_state *cli,
+						struct rpc_pipe_client *pipe_hnd,
+						TALLOC_CTX *mem_ctx,
+						int argc,
+						const char **argv )
+{
+	struct policy_handle pol_hive, pol_key;
+	NTSTATUS status;
+	WERROR werr;
+	uint32_t num_subkeys = 0;
+	uint32_t num_values = 0;
+	char **names = NULL, **classes = NULL;
+	NTTIME **modtimes = NULL;
+	uint32_t i;
+	struct registry_value **values = NULL;
+	struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+	if (argc != 1 || c->display_usage) {
+		d_printf("%s\n%s",
+			 _("Usage:"),
+			 _("net rpc registry enumerate <path>\n"));
+		d_printf("%s  net rpc registry enumerate "
+			 "'HKLM\\Software\\Samba'\n", _("Example:"));
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_READ,
+				  &pol_hive, &pol_key);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("registry_openkey failed: %s\n"),
+			  nt_errstr(status));
+		return status;
+	}
+
+	status = registry_enumkeys(mem_ctx, pipe_hnd, &pol_key, &num_subkeys,
+				   &names, &classes, &modtimes);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("enumerating keys failed: %s\n"),
+			  nt_errstr(status));
+		return status;
+	}
+
+	for (i=0; i<num_subkeys; i++) {
+		print_registry_key(names[i], modtimes[i]);
+	}
+
+	status = registry_enumvalues(mem_ctx, pipe_hnd, &pol_key, &num_values,
+				     &names, &values);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("enumerating values failed: %s\n"),
+			  nt_errstr(status));
+		return status;
+	}
+
+	for (i=0; i<num_values; i++) {
+		print_registry_value_with_name(names[i], values[i]);
+	}
+
+	dcerpc_winreg_CloseKey(b, mem_ctx, &pol_key, &werr);
+	dcerpc_winreg_CloseKey(b, mem_ctx, &pol_hive, &werr);
+
+	return status;
+}
+
+/********************************************************************
+********************************************************************/
+
+static int rpc_registry_enumerate(struct net_context *c, int argc,
+				  const char **argv )
+{
+	return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
+		rpc_registry_enumerate_internal, argc, argv );
+}
+
+/********************************************************************
+********************************************************************/
+
+static NTSTATUS rpc_registry_save_internal(struct net_context *c,
+					const struct dom_sid *domain_sid,
+					const char *domain_name,
+					struct cli_state *cli,
+					struct rpc_pipe_client *pipe_hnd,
+					TALLOC_CTX *mem_ctx,
+					int argc,
+					const char **argv )
+{
+	WERROR result = WERR_GEN_FAILURE;
+	struct policy_handle pol_hive, pol_key;
+	NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
+	struct winreg_String filename;
+	struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+	if (argc != 2 || c->display_usage) {
+		d_printf("%s\n%s",
+			 _("Usage:"),
+			 _("net rpc registry backup <path> <file> \n"));
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_ALL,
+				  &pol_hive, &pol_key);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("registry_openkey failed: %s\n"),
+			  nt_errstr(status));
+		return status;
+	}
+
+	filename.name = argv[1];
+	status = dcerpc_winreg_SaveKey(b, mem_ctx, &pol_key, &filename, NULL, &result);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("Unable to save [%s] to %s:%s\n"), argv[0],
+			  pipe_hnd->desthost, argv[1]);
+	}
+	if (!W_ERROR_IS_OK(result)) {
+		status = werror_to_ntstatus(result);
+		d_fprintf(stderr, _("Unable to save [%s] to %s:%s\n"), argv[0],
+			  pipe_hnd->desthost, argv[1]);
+	}
+
+	/* cleanup */
+
+	dcerpc_winreg_CloseKey(b, mem_ctx, &pol_key, &result);
+	dcerpc_winreg_CloseKey(b, mem_ctx, &pol_hive, &result);
+
+	return status;
+}
+
+/********************************************************************
+********************************************************************/
+
+static int rpc_registry_save(struct net_context *c, int argc, const char **argv )
+{
+	return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
+		rpc_registry_save_internal, argc, argv );
+}
+
+
+/********************************************************************
+********************************************************************/
+
+static void dump_values( REGF_NK_REC *nk )
+{
+	int i, j;
+	const char *data_str = NULL;
+	uint32_t data_size, data;
+	DATA_BLOB blob;
+
+	if ( !nk->values )
+		return;
+
+	for ( i=0; i<nk->num_values; i++ ) {
+		d_printf( "\"%s\" = ", nk->values[i].valuename ? nk->values[i].valuename : "(default)" );
+		d_printf( "(%s) ", str_regtype( nk->values[i].type ) );
+
+		data_size = nk->values[i].data_size & ~VK_DATA_IN_OFFSET;
+		switch ( nk->values[i].type ) {
+			case REG_SZ:
+				blob = data_blob_const(nk->values[i].data, data_size);
+				if (!pull_reg_sz(talloc_tos(), &blob,
+						 &data_str)) {
+					data_str = NULL;
+				}
+				if (!data_str) {
+					break;
+				}
+				d_printf( "%s", data_str );
+				break;
+			case REG_MULTI_SZ:
+			case REG_EXPAND_SZ:
+				for ( j=0; j<data_size; j++ ) {
+					d_printf( "%c", nk->values[i].data[j] );
+				}
+				break;
+			case REG_DWORD:
+				data = IVAL( nk->values[i].data, 0 );
+				d_printf("0x%x", data );
+				break;
+			case REG_BINARY:
+				for ( j=0; j<data_size; j++ ) {
+					d_printf( "%x", nk->values[i].data[j] );
+				}
+				break;
+			default:
+				d_printf(_("unknown"));
+				break;
+		}
+
+		d_printf( "\n" );
+	}
+
+}
+
+/********************************************************************
+********************************************************************/
+
+static bool dump_registry_tree( REGF_FILE *file, REGF_NK_REC *nk, const char *parent )
+{
+	REGF_NK_REC *key;
+
+	/* depth first dump of the registry tree */
+
+	while ( (key = regfio_fetch_subkey( file, nk )) ) {
+		char *regpath;
+		if (asprintf(&regpath, "%s\\%s", parent, key->keyname) < 0) {
+			break;
+		}
+		d_printf("[%s]\n", regpath );
+		dump_values( key );
+		d_printf("\n");
+		dump_registry_tree( file, key, regpath );
+		SAFE_FREE(regpath);
+	}
+
+	return true;
+}
+
+/********************************************************************
+********************************************************************/
+
+static bool write_registry_tree( REGF_FILE *infile, REGF_NK_REC *nk,
+                                 REGF_NK_REC *parent, REGF_FILE *outfile,
+			         const char *parentpath )
+{
+	REGF_NK_REC *key, *subkey;
+	struct regval_ctr *values = NULL;
+	struct regsubkey_ctr *subkeys = NULL;
+	int i;
+	char *path = NULL;
+	WERROR werr;
+
+	werr = regsubkey_ctr_init(infile->mem_ctx, &subkeys);
+	if (!W_ERROR_IS_OK(werr)) {
+		DEBUG(0, ("write_registry_tree: regsubkey_ctr_init failed: "
+			  "%s\n", win_errstr(werr)));
+		return false;
+	}
+
+	werr = regval_ctr_init(subkeys, &values);
+	if (!W_ERROR_IS_OK(werr)) {
+		DEBUG(0,("write_registry_tree: talloc() failed!\n"));
+		TALLOC_FREE(subkeys);
+		return false;
+	}
+
+	/* copy values into the struct regval_ctr */
+
+	for ( i=0; i<nk->num_values; i++ ) {
+		regval_ctr_addvalue( values, nk->values[i].valuename, nk->values[i].type,
+			nk->values[i].data, (nk->values[i].data_size & ~VK_DATA_IN_OFFSET) );
+	}
+
+	/* copy subkeys into the struct regsubkey_ctr */
+
+	while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
+		regsubkey_ctr_addkey( subkeys, subkey->keyname );
+	}
+
+	key = regfio_write_key( outfile, nk->keyname, values, subkeys, nk->sec_desc->sec_desc, parent );
+
+	/* write each one of the subkeys out */
+
+	path = talloc_asprintf(subkeys,
+			"%s%s%s",
+			parentpath,
+			parent ? "\\" : "",
+			nk->keyname);
+	if (!path) {
+		TALLOC_FREE(subkeys);
+		return false;
+	}
+
+	nk->subkey_index = 0;
+	while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
+		write_registry_tree( infile, subkey, key, outfile, path );
+	}
+
+	d_printf("[%s]\n", path );
+	TALLOC_FREE(subkeys);
+
+	return true;
+}
+
+/********************************************************************
+********************************************************************/
+
+static int rpc_registry_dump(struct net_context *c, int argc, const char **argv)
+{
+	REGF_FILE   *registry;
+	REGF_NK_REC *nk;
+
+	if (argc != 1 || c->display_usage) {
+		d_printf("%s\n%s",
+			 _("Usage:"),
+			 _("net rpc registry dump <file> \n"));
+		return -1;
+	}
+
+	d_printf(_("Opening %s...."), argv[0]);
+	if ( !(registry = regfio_open( argv[0], O_RDONLY, 0)) ) {
+		d_fprintf(stderr, _("Failed to open %s for reading\n"),argv[0]);
+		return 1;
+	}
+	d_printf(_("ok\n"));
+
+	/* get the root of the registry file */
+
+	if ((nk = regfio_rootkey( registry )) == NULL) {
+		d_fprintf(stderr, _("Could not get rootkey\n"));
+		regfio_close( registry );
+		return 1;
+	}
+	d_printf("[%s]\n", nk->keyname);
+	dump_values( nk );
+	d_printf("\n");
+
+	dump_registry_tree( registry, nk, nk->keyname );
+
+#if 0
+	talloc_report_full( registry->mem_ctx, stderr );
+#endif
+	d_printf(_("Closing registry..."));
+	regfio_close( registry );
+	d_printf(_("ok\n"));
+
+	return 0;
+}
+
+/********************************************************************
+********************************************************************/
+
+static int rpc_registry_copy(struct net_context *c, int argc, const char **argv )
+{
+	REGF_FILE   *infile = NULL, *outfile = NULL;
+	REGF_NK_REC *nk;
+	int result = 1;
+
+	if (argc != 2 || c->display_usage) {
+		d_printf("%s\n%s",
+			 _("Usage:"),
+			 _("net rpc registry copy <srcfile> <newfile>\n"));
+		return -1;
+	}
+
+	d_printf(_("Opening %s...."), argv[0]);
+	if ( !(infile = regfio_open( argv[0], O_RDONLY, 0 )) ) {
+		d_fprintf(stderr, _("Failed to open %s for reading\n"),argv[0]);
+		return 1;
+	}
+	d_printf(_("ok\n"));
+
+	d_printf(_("Opening %s...."), argv[1]);
+	if ( !(outfile = regfio_open( argv[1], (O_RDWR|O_CREAT|O_TRUNC),
+				      (S_IRUSR|S_IWUSR) )) ) {
+		d_fprintf(stderr, _("Failed to open %s for writing\n"),argv[1]);
+		goto out;
+	}
+	d_printf(_("ok\n"));
+
+	/* get the root of the registry file */
+
+	if ((nk = regfio_rootkey( infile )) == NULL) {
+		d_fprintf(stderr, _("Could not get rootkey\n"));
+		goto out;
+	}
+	d_printf(_("RootKey: [%s]\n"), nk->keyname);
+
+	write_registry_tree( infile, nk, NULL, outfile, "" );
+
+	result = 0;
+
+out:
+
+	d_printf(_("Closing %s..."), argv[1]);
+	if (outfile) {
+		regfio_close( outfile );
+	}
+	d_printf(_("ok\n"));
+
+	d_printf(_("Closing %s..."), argv[0]);
+	if (infile) {
+		regfio_close( infile );
+	}
+	d_printf(_("ok\n"));
+
+	return( result);
+}
+
+/********************************************************************
+********************************************************************/
+
+static NTSTATUS rpc_registry_getsd_internal(struct net_context *c,
+					    const struct dom_sid *domain_sid,
+					    const char *domain_name,
+					    struct cli_state *cli,
+					    struct rpc_pipe_client *pipe_hnd,
+					    TALLOC_CTX *mem_ctx,
+					    int argc,
+					    const char **argv)
+{
+	struct policy_handle pol_hive, pol_key;
+	NTSTATUS status;
+	WERROR werr;
+	enum ndr_err_code ndr_err;
+	struct KeySecurityData *sd = NULL;
+	uint32_t sec_info;
+	DATA_BLOB blob;
+	struct security_descriptor sec_desc;
+	uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED |
+			       SEC_FLAG_SYSTEM_SECURITY;
+	struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+	if (argc <1 || argc > 2 || c->display_usage) {
+		d_printf("%s\n%s",
+			 _("Usage:"),
+			 _("net rpc registry getsd <path> <secinfo>\n"));
+		d_printf("%s  net rpc registry getsd "
+			   "'HKLM\\Software\\Samba'\n", _("Example:"));
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	status = registry_openkey(mem_ctx, pipe_hnd, argv[0],
+				  access_mask,
+				  &pol_hive, &pol_key);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("registry_openkey failed: %s\n"),
+			  nt_errstr(status));
+		return status;
+	}
+
+	sd = talloc_zero(mem_ctx, struct KeySecurityData);
+	if (!sd) {
+		status = NT_STATUS_NO_MEMORY;
+		goto out;
+	}
+
+	sd->size = 0x1000;
+
+	if (argc >= 2) {
+		sscanf(argv[1], "%x", &sec_info);
+	} else {
+		sec_info = SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL;
+	}
+
+	status = registry_getsd(mem_ctx, b, &pol_key, sec_info, sd, &werr);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("getting sd failed: %s\n"),
+			  nt_errstr(status));
+		goto out;
+	}
+	if (!W_ERROR_IS_OK(werr)) {
+		status = werror_to_ntstatus(werr);
+		d_fprintf(stderr, _("getting sd failed: %s\n"),
+			  win_errstr(werr));
+		goto out;
+	}
+
+	blob.data = sd->data;
+	blob.length = sd->size;
+
+	ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &sec_desc,
+				       (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		status = ndr_map_error2ntstatus(ndr_err);
+		goto out;
+	}
+	status = NT_STATUS_OK;
+
+	display_sec_desc(&sec_desc);
+
+ out:
+	dcerpc_winreg_CloseKey(b, mem_ctx, &pol_key, &werr);
+	dcerpc_winreg_CloseKey(b, mem_ctx, &pol_hive, &werr);
+
+	return status;
+}
+
+
+static int rpc_registry_getsd(struct net_context *c, int argc, const char **argv)
+{
+	return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
+		rpc_registry_getsd_internal, argc, argv);
+}
+
+/********************************************************************
+ ********************************************************************/
+/**
+ * @defgroup net_rpc_registry net rpc registry
+ */
+
+/**
+ * @defgroup net_rpc_registry_export Export
+ * @ingroup net_rpc_registry
+ * @{
+ */
+
+static NTSTATUS registry_export(struct rpc_pipe_client* pipe_hnd,
+				TALLOC_CTX* ctx,
+				struct policy_handle* key_hnd,
+				struct reg_format* f,
+				const char* parentfullname,
+				const char* name)
+{
+	NTSTATUS status;
+	uint32_t num_subkeys = 0;
+	uint32_t num_values = 0;
+	char **names = NULL, **classes = NULL;
+	NTTIME **modtimes = NULL;
+	struct regval_blob **values = NULL;
+	uint32_t i;
+	struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+	TALLOC_CTX* mem_ctx = talloc_new(ctx);
+
+
+	const char* fullname = name
+		? talloc_asprintf(mem_ctx, "%s\\%s", parentfullname, name)
+		: parentfullname;
+	reg_format_key(f, &fullname, 1, false);
+
+	status = registry_enumvalues2(mem_ctx, pipe_hnd, key_hnd, &num_values,
+				      &names, &values);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("enumerating values failed: %s\n"),
+			  nt_errstr(status));
+		goto done;
+	}
+
+	for (i=0; i<num_values; i++) {
+		reg_format_regval_blob(f, names[i], values[i]);
+	}
+
+
+	status = registry_enumkeys(mem_ctx, pipe_hnd, key_hnd, &num_subkeys,
+				   &names, &classes, &modtimes);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("enumerating keys failed: %s\n"),
+			  nt_errstr(status));
+		goto done;
+	}
+
+	for (i=0; i<num_subkeys; i++) {
+		struct policy_handle subkey_hnd;
+		struct winreg_String key;
+		WERROR werr;
+		ZERO_STRUCT(key);
+		/* key.name = talloc_strdup(mem_ctx, names[i]); ??? */
+		key.name = names[i];
+
+		status = dcerpc_winreg_OpenKey(b, mem_ctx, key_hnd, key,
+					       0, REG_KEY_READ,
+					       &subkey_hnd, &werr);
+		if (!NT_STATUS_IS_OK(status)) {
+			d_fprintf(stderr,
+				  _("dcerpc_winreg_OpenKey failed: %s %s\n"),
+				  names[i], nt_errstr(status));
+			continue;
+		}
+		if (!W_ERROR_IS_OK(werr)) {
+			status = werror_to_ntstatus(werr);
+			d_fprintf(stderr,
+				  _("dcerpc_winreg_OpenKey failed: %s %s\n"),
+				  names[i], win_errstr(werr));
+			continue;
+		}
+
+		status = registry_export(pipe_hnd, mem_ctx, &subkey_hnd,
+					 f, fullname, names[i]);
+		if (!(NT_STATUS_IS_OK(status))) {
+			d_fprintf(stderr,
+				  _("export key failed: %s %s\n"),
+				  names[i], nt_errstr(status));
+		}
+		dcerpc_winreg_CloseKey(b, mem_ctx,
+				       &subkey_hnd, &werr);
+	}
+done:
+	talloc_free(mem_ctx);
+	return status;
+}
+
+static NTSTATUS rpc_registry_export_internal(struct net_context *c,
+					     const struct dom_sid *domain_sid,
+					     const char *domain_name,
+					     struct cli_state *cli,
+					     struct rpc_pipe_client *pipe_hnd,
+					     TALLOC_CTX *mem_ctx,
+					     int argc,
+					     const char **argv )
+{
+	struct policy_handle pol_hive, pol_key;
+	NTSTATUS status;
+	WERROR werr;
+	struct reg_format* f;
+	struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+	if (argc < 2 || argc > 3 || c->display_usage) {
+		d_printf("%s\n%s",
+			 _("Usage:"),
+			 _("net rpc registry export <path> <file> [opt]\n"));
+		d_printf("%s  net rpc registry export "
+			 "'HKLM\\Software\\Samba' samba.reg\n", _("Example:"));
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_READ,
+				  &pol_hive, &pol_key);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("registry_openkey failed: %s\n"),
+			  nt_errstr(status));
+		return status;
+	}
+
+	f = reg_format_file(mem_ctx, argv[1], (argc > 2) ? argv[2] : NULL);
+	if (f == NULL) {
+		d_fprintf(stderr, _("open file failed: %s\n"), strerror(errno));
+		return map_nt_error_from_unix(errno);
+	}
+
+	status = registry_export(pipe_hnd, mem_ctx, &pol_key,
+				 f, argv[0], NULL );
+	if (!NT_STATUS_IS_OK(status))
+		return status;
+
+	dcerpc_winreg_CloseKey(b, mem_ctx, &pol_key, &werr);
+	dcerpc_winreg_CloseKey(b, mem_ctx, &pol_hive, &werr);
+
+	return status;
+}
+/********************************************************************
+ ********************************************************************/
+
+static int rpc_registry_export(struct net_context *c, int argc,
+			       const char **argv )
+{
+	return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
+			       rpc_registry_export_internal, argc, argv );
+}
+
+/**@}*/
+
+/********************************************************************
+ ********************************************************************/
+
+/**
+ * @defgroup net_rpc_registry_import Import
+ * @ingroup net_rpc_registry
+ * @{
+ */
+
+struct import_ctx {
+	struct rpc_pipe_client *pipe_hnd;
+	TALLOC_CTX *mem_ctx;
+};
+
+static WERROR import_create_key(struct import_ctx* ctx,
+				struct policy_handle* parent, const char* name,
+				void** pkey, bool* existing)
+{
+	WERROR werr;
+	NTSTATUS status;
+	void* mem_ctx = talloc_new(ctx->mem_ctx);
+
+	struct policy_handle* key = NULL;
+	struct policy_handle  hive;
+	struct winreg_String  keyclass, keyname;
+	enum winreg_CreateAction action = REG_ACTION_NONE;
+	struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
+
+	ZERO_STRUCT(keyname);
+	keyname.name = name;
+
+	if (parent == NULL) {
+		uint32_t hive_idx = 0;
+		if (!reg_hive_key(mem_ctx, name, &hive_idx, &keyname.name)) {
+			werr = WERR_FOOBAR;
+			goto done;
+		}
+
+		status = dcerpc_winreg_Connect(b, mem_ctx,
+					       hive_idx, SEC_FLAG_MAXIMUM_ALLOWED,
+					       &hive, &werr);
+		if (!NT_STATUS_IS_OK(status)) {
+			werr = ntstatus_to_werror(status);
+			d_fprintf(stderr, _("dcerpc_winreg_Connect returned %s\n"),
+				  nt_errstr(status));
+			goto done;
+		}
+		if (!W_ERROR_IS_OK(werr)) {
+			d_fprintf(stderr, _("dcerpc_winreg_Connect returned %s\n"),
+				  win_errstr(werr));
+			goto done;
+		}
+
+		parent = &hive;
+	}
+
+	key = talloc_zero(mem_ctx, struct policy_handle);
+	if (key == NULL) {
+		werr = WERR_NOT_ENOUGH_MEMORY;
+		goto done;
+	}
+
+	ZERO_STRUCT(keyclass);
+	keyclass.name = "";
+
+	status = dcerpc_winreg_CreateKey(b, mem_ctx,
+					 parent, keyname,
+					 keyclass, 0, REG_KEY_READ, NULL,
+					 key, &action, &werr);
+	if (!NT_STATUS_IS_OK(status)) {
+		werr = ntstatus_to_werror(status);
+		d_fprintf(stderr, _("dcerpc_winreg_CreateKey returned %s\n"),
+			  nt_errstr(status));
+		goto done;
+	}
+	if (!W_ERROR_IS_OK(werr)) {
+		d_fprintf(stderr, _("dcerpc_winreg_CreateKey returned %s\n"),
+			  win_errstr(werr));
+		goto done;
+	}
+
+	switch (action) {
+	case REG_CREATED_NEW_KEY:
+		d_printf(_("createkey created %s\n"), name);
+		if (existing != NULL)
+			*existing = false;
+		break;
+
+	case REG_OPENED_EXISTING_KEY:
+		d_printf(_("createkey opened existing %s\n"), name);
+		if (existing != NULL)
+			*existing = true;
+		break;
+
+	case REG_ACTION_NONE:
+		d_printf(_("createkey did nothing -- huh?\n"));
+		werr = WERR_CREATE_FAILED;
+		break;
+	default:
+		assert(false);
+	}
+
+done:
+	if ( parent == &hive ) {
+		WERROR _result;
+		dcerpc_winreg_CloseKey(b, mem_ctx,
+				       parent, &_result);
+	}
+
+	if (pkey!=NULL) {
+		*pkey = talloc_steal(ctx->mem_ctx, key);
+	}
+
+	talloc_free(mem_ctx);
+	return werr;
+}
+
+static WERROR import_delete_key(struct import_ctx* ctx,
+				struct policy_handle* parent, const char* name)
+{
+	WERROR werr;
+	NTSTATUS status;
+	void* mem_ctx = talloc_new(ctx->mem_ctx);
+	struct winreg_String  keyname = { 0, };
+	struct policy_handle  hive;
+	struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
+
+	keyname.name = name;
+
+	if (parent == NULL) {
+		uint32_t hive_idx;
+		if (!reg_hive_key(mem_ctx, name, &hive_idx, &keyname.name)) {
+			werr = WERR_FOOBAR;
+			goto done;
+		}
+
+		status = dcerpc_winreg_Connect(b, mem_ctx, hive_idx,
+					       SEC_FLAG_MAXIMUM_ALLOWED, &hive,
+					       &werr);
+		if (!NT_STATUS_IS_OK(status)) {
+			werr = ntstatus_to_werror(status);
+			d_fprintf(stderr, _("dcerpc_winreg_Connect returned %s\n"),
+				  nt_errstr(status));
+			goto done;
+		}
+		if (!W_ERROR_IS_OK(werr)) {
+			d_fprintf(stderr, _("dcerpc_winreg_Connect returned %s\n"),
+				  win_errstr(werr));
+			goto done;
+		}
+
+		parent = &hive;
+	}
+
+	status = dcerpc_winreg_DeleteKey(b, mem_ctx, parent,
+					 keyname, &werr);
+	if (!NT_STATUS_IS_OK(status)) {
+		werr = ntstatus_to_werror(status);
+		d_fprintf(stderr, _("dcerpc_winreg_DeleteKey returned %s\n"),
+			  nt_errstr(status));
+		goto done;
+	}
+	if (!W_ERROR_IS_OK(werr)) {
+		d_fprintf(stderr, _("dcerpc_winreg_DeleteKey returned %s\n"),
+			  win_errstr(werr));
+		goto done;
+	}
+
+done:
+	if ( parent == &hive ) {
+		WERROR _result;
+		dcerpc_winreg_CloseKey(b, mem_ctx, parent, &_result);
+	}
+
+	talloc_free(mem_ctx);
+	return werr;
+}
+
+static WERROR import_close_key(struct import_ctx* ctx,
+			       struct policy_handle* key)
+{
+	WERROR werr;
+	NTSTATUS status;
+	void* mem_ctx = talloc_new(ctx->mem_ctx);
+	struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
+
+	status = dcerpc_winreg_CloseKey(b, mem_ctx, key, &werr);
+	if (!NT_STATUS_IS_OK(status)) {
+		werr = ntstatus_to_werror(status);
+		d_fprintf(stderr, _("dcerpc_winreg_CloseKey returned %s\n"),
+			  nt_errstr(status));
+		goto done;
+	}
+	if (!W_ERROR_IS_OK(werr)) {
+		d_fprintf(stderr, _("dcerpc_winreg_CloseKey returned %s\n"),
+			  win_errstr(werr));
+		goto done;
+	}
+
+	werr = (talloc_free(key) == 0) ? WERR_OK : WERR_GEN_FAILURE;
+done:
+	talloc_free(mem_ctx);
+	return werr;
+}
+
+static WERROR import_create_val(struct import_ctx* ctx,
+				struct policy_handle* parent, const char* name,
+				uint32_t type, const uint8_t* val, uint32_t len)
+{
+	WERROR werr;
+	NTSTATUS status;
+	void* mem_ctx = talloc_new(ctx->mem_ctx);
+	struct winreg_String valuename;
+	struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
+
+	if (parent == NULL) {
+		return WERR_INVALID_PARAMETER;
+	}
+
+	ZERO_STRUCT(valuename);
+	valuename.name = name;
+
+	status = dcerpc_winreg_SetValue(b, mem_ctx, parent,
+					valuename, type,
+					(uint8_t *)discard_const(val), len, &werr);
+	if (!NT_STATUS_IS_OK(status)) {
+		werr = ntstatus_to_werror(status);
+		d_fprintf(stderr, _("registry_setvalue failed: %s\n"),
+			  nt_errstr(status));
+		goto done;
+	}
+	if (!W_ERROR_IS_OK(werr)) {
+		d_fprintf(stderr, _("registry_setvalue failed: %s\n"),
+			  win_errstr(werr));
+		goto done;
+	}
+
+done:
+	talloc_free(mem_ctx);
+	return werr;
+}
+
+static WERROR import_delete_val(struct import_ctx* ctx,
+				struct policy_handle* parent, const char* name)
+{
+	WERROR werr;
+	NTSTATUS status;
+	void* mem_ctx = talloc_new(ctx->mem_ctx);
+	struct winreg_String valuename;
+	struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
+
+	if (parent == NULL) {
+		return WERR_INVALID_PARAMETER;
+	}
+
+	ZERO_STRUCT(valuename);
+	valuename.name = name;
+
+	status = dcerpc_winreg_DeleteValue(b, mem_ctx,
+					   parent, valuename, &werr);
+
+	if (!NT_STATUS_IS_OK(status)) {
+		werr = ntstatus_to_werror(status);
+		d_fprintf(stderr, _("registry_deletevalue failed: %s\n"),
+			  nt_errstr(status));
+		goto done;
+	}
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, _("registry_deletevalue failed: %s\n"),
+			  win_errstr(werr));
+		goto done;
+	}
+
+done:
+	talloc_free(mem_ctx);
+	return werr;
+}
+
+
+
+static NTSTATUS rpc_registry_import_internal(struct net_context *c,
+					     const struct dom_sid *domain_sid,
+					     const char *domain_name,
+					     struct cli_state *cli,
+					     struct rpc_pipe_client *pipe_hnd,
+					     TALLOC_CTX *mem_ctx,
+					     int argc,
+					     const char **argv )
+{
+	struct import_ctx import_ctx;
+
+	struct reg_import_callback import_callback = {
+		.openkey     = NULL,
+		.closekey    = (reg_import_callback_closekey_t)&import_close_key,
+		.createkey   = (reg_import_callback_createkey_t)&import_create_key,
+		.deletekey   = (reg_import_callback_deletekey_t)&import_delete_key,
+		.deleteval   = (reg_import_callback_deleteval_t)&import_delete_val,
+		.setval      = {
+			.blob = (reg_import_callback_setval_blob_t)&import_create_val,
+		},
+		.setval_type = BLOB,
+		.data = &import_ctx
+	};
+
+	int ret;
+	if (argc < 1 || argc > 2 || c->display_usage) {
+		d_printf("%s\n%s",
+			 _("Usage:"),
+			 _("net rpc registry import <file> [options]\n"));
+		d_printf("%s  net rpc registry export "
+			 "samba.reg enc=CP1252,flags=0\n", _("Example:"));
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+	ZERO_STRUCT(import_ctx);
+	import_ctx.pipe_hnd = pipe_hnd;
+	import_ctx.mem_ctx  = mem_ctx;
+	ret = reg_parse_file(argv[0],
+			     reg_import_adapter(import_ctx.mem_ctx,
+						import_callback
+				     ),
+			     (argc > 1) ? argv[1] : NULL
+		);
+
+	return ret==0 ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
+}
+
+/********************************************************************
+ ********************************************************************/
+
+static int rpc_registry_import(struct net_context *c, int argc,
+			       const char **argv )
+{
+	return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
+			       rpc_registry_import_internal, argc, argv );
+}
+
+/**@}*/
+/********************************************************************
+ ********************************************************************/
+
+int net_rpc_registry(struct net_context *c, int argc, const char **argv)
+{
+	struct functable func[] = {
+		{
+			"enumerate",
+			rpc_registry_enumerate,
+			NET_TRANSPORT_RPC,
+			N_("Enumerate registry keys and values"),
+			N_("net rpc registry enumerate\n"
+			   "    Enumerate registry keys and values")
+		},
+		{
+			"createkey",
+			rpc_registry_createkey,
+			NET_TRANSPORT_RPC,
+			N_("Create a new registry key"),
+			N_("net rpc registry createkey\n"
+			   "    Create a new registry key")
+		},
+		{
+			"deletekey",
+			rpc_registry_deletekey,
+			NET_TRANSPORT_RPC,
+			N_("Delete a registry key"),
+			N_("net rpc registry deletekey\n"
+			   "    Delete a registry key")
+		},
+		{
+			"getvalue",
+			rpc_registry_getvalue,
+			NET_TRANSPORT_RPC,
+			N_("Print a registry value"),
+			N_("net rpc registry getvalue\n"
+			   "    Print a registry value")
+		},
+		{
+			"getvalueraw",
+			rpc_registry_getvalueraw,
+			NET_TRANSPORT_RPC,
+			N_("Print a registry value"),
+			N_("net rpc registry getvalueraw\n"
+			   "    Print a registry value (raw version)")
+		},
+		{
+			"setvalue",
+			rpc_registry_setvalue,
+			NET_TRANSPORT_RPC,
+			N_("Set a new registry value"),
+			N_("net rpc registry setvalue\n"
+			   "    Set a new registry value")
+		},
+		{
+			"deletevalue",
+			rpc_registry_deletevalue,
+			NET_TRANSPORT_RPC,
+			N_("Delete a registry value"),
+			N_("net rpc registry deletevalue\n"
+			   "    Delete a registry value")
+		},
+		{
+			"save",
+			rpc_registry_save,
+			NET_TRANSPORT_RPC,
+			N_("Save a registry file"),
+			N_("net rpc registry save\n"
+			   "    Save a registry file")
+		},
+		{
+			"dump",
+			rpc_registry_dump,
+			NET_TRANSPORT_RPC,
+			N_("Dump a registry file"),
+			N_("net rpc registry dump\n"
+			   "    Dump a registry file")
+		},
+		{
+			"copy",
+			rpc_registry_copy,
+			NET_TRANSPORT_RPC,
+			N_("Copy a registry file"),
+			N_("net rpc registry copy\n"
+			   "    Copy a registry file")
+		},
+		{
+			"getsd",
+			rpc_registry_getsd,
+			NET_TRANSPORT_RPC,
+			N_("Get security descriptor"),
+			N_("net rpc registry getsd\n"
+			   "    Get security descriptor")
+		},
+		{
+			"import",
+			rpc_registry_import,
+			NET_TRANSPORT_RPC,
+			N_("Import .reg file"),
+			N_("net rpc registry import\n"
+			   "    Import .reg file")
+		},
+		{
+			"export",
+			rpc_registry_export,
+			NET_TRANSPORT_RPC,
+			N_("Export .reg file"),
+			N_("net rpc registry export\n"
+			   "    Export .reg file")
+		},
+		{NULL, NULL, 0, NULL, NULL}
+	};
+	return net_run_function(c, argc, argv, "net rpc registry", func);
+}