From 4f5791ebd03eaec1c7da0865a383175b05102712 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 5 May 2024 19:47:29 +0200 Subject: Adding upstream version 2:4.17.12+dfsg. Signed-off-by: Daniel Baumann --- source3/utils/net_rpc_registry.c | 2126 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 2126 insertions(+) create mode 100644 source3/utils/net_rpc_registry.c (limited to 'source3/utils/net_rpc_registry.c') 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 . */ + +#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 +#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; ibinding_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; itype = 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; ibinding_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 " + " []+\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 \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 \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 \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 \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 \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 \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; ibinding_handle; + + if (argc != 2 || c->display_usage) { + d_printf("%s\n%s", + _("Usage:"), + _("net rpc registry backup \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; inum_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; jvalues[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; jvalues[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(®path, "%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; inum_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 \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 \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 \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; ibinding_handle; + + if (argc < 2 || argc > 3 || c->display_usage) { + d_printf("%s\n%s", + _("Usage:"), + _("net rpc registry export [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 [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); +} -- cgit v1.2.3