/* 
   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"


/*******************************************************************
 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 *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 access_mask,
				 struct policy_handle *hive_hnd,
				 struct policy_handle *key_hnd)
{
	uint32 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 *pnum_keys, char ***pnames,
				  char ***pclasses, NTTIME ***pmodtimes)
{
	TALLOC_CTX *mem_ctx;
	NTSTATUS status;
	WERROR werr;
	uint32 num_subkeys, max_subkeylen, max_classlen;
	uint32 num_values, max_valnamelen, max_valbufsize;
	uint32 i;
	NTTIME last_changed_time;
	uint32 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 *pnum_values, char ***pvalnames,
				    struct registry_value ***pvalues)
{
	TALLOC_CTX *mem_ctx;
	NTSTATUS status;
	WERROR werr;
	uint32 num_subkeys, max_subkeylen, max_classlen;
	uint32 num_values, max_valnamelen, max_valbufsize;
	uint32 i;
	NTTIME last_changed_time;
	uint32 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 *data = NULL;
		uint32 data_size;
		uint32 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 *)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 *pnum_values, char ***pvalnames,
				     struct regval_blob ***pvalues)
{
	TALLOC_CTX *mem_ctx;
	NTSTATUS status;
	WERROR werr;
	uint32 num_subkeys, max_subkeylen, max_classlen;
	uint32 num_values, max_valnamelen, max_valbufsize;
	uint32 i;
	NTTIME last_changed_time;
	uint32 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 *data = NULL;
		uint32 data_size;
		uint32 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 *)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")) {
		uint32_t v = strtoul(argv[3], NULL, 10);
		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.syntax_id, 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.syntax_id, 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.syntax_id, 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.syntax_id, 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 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.syntax_id, 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 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.syntax_id, 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 num_subkeys = 0;
	uint32 num_values = 0;
	char **names = NULL, **classes = NULL;
	NTTIME **modtimes = NULL;
	uint32 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.syntax_id, 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_GENERAL_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],
			  cli->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],
			  cli->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.syntax_id, 0,
		rpc_registry_save_internal, argc, argv );
}


/********************************************************************
********************************************************************/

static void dump_values( REGF_NK_REC *nk )
{
	int i, j;
	const char *data_str = NULL;
	uint32 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);
				pull_reg_sz(talloc_tos(), &blob, &data_str);
				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.syntax_id, 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 num_subkeys = 0;
	uint32 num_values = 0;
	char **names = NULL, **classes = NULL;
	NTTIME **modtimes = NULL;
	struct regval_blob **values = NULL;
	uint32 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.syntax_id, 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 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_NOMEM;
		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 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_GENERAL_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_PARAM;
	}

	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_PARAM;
	}

	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.syntax_id, 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 descriptior")
		},
		{
			"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);
}