1
0
mirror of https://github.com/samba-team/samba.git synced 2024-12-24 21:34:56 +03:00
samba-mirror/source3/rpc_client/cli_winreg.c
Noel Power 9c16d8fb24 s3/rpc_client: clang: Fix 'Value stored during initialization is never read'
Fixes:

source3/rpc_client/cli_winreg.c:728:11: warning: Value stored to 'status' during its initialization is never read <--[clang]
        NTSTATUS status = NT_STATUS_OK;
                 ^~~~~~   ~~~~~~~~~~~~
/source3/rpc_client/cli_winreg.c:897:11: warning: Value stored to 'status' during its initialization is never read <--[clang]
        NTSTATUS status = NT_STATUS_OK;
                 ^~~~~~   ~~~~~~~~~~~~
Signed-off-by: Noel Power <noel.power@suse.com>
Reviewed-by: Jeremy Allison <jra@samba.org>
2019-09-26 18:41:27 +00:00

986 lines
20 KiB
C

/*
* Unix SMB/CIFS implementation.
*
* WINREG client routines
*
* Copyright (c) 2011 Andreas Schneider <asn@samba.org>
*
* 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 "../librpc/gen_ndr/ndr_winreg_c.h"
#include "../librpc/gen_ndr/ndr_security.h"
#include "rpc_client/cli_winreg.h"
#include "../libcli/registry/util_reg.h"
NTSTATUS dcerpc_winreg_query_dword(TALLOC_CTX *mem_ctx,
struct dcerpc_binding_handle *h,
struct policy_handle *key_handle,
const char *value,
uint32_t *data,
WERROR *pwerr)
{
struct winreg_String wvalue;
enum winreg_Type type = REG_NONE;
uint32_t value_len = 0;
uint32_t data_size = 0;
NTSTATUS status;
DATA_BLOB blob;
wvalue.name = value;
status = dcerpc_winreg_QueryValue(h,
mem_ctx,
key_handle,
&wvalue,
&type,
NULL,
&data_size,
&value_len,
pwerr);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
if (!W_ERROR_IS_OK(*pwerr)) {
return status;
}
if (type != REG_DWORD) {
return NT_STATUS_OBJECT_TYPE_MISMATCH;
}
if (data_size != 4) {
return NT_STATUS_INVALID_PARAMETER;
}
blob = data_blob_talloc_zero(mem_ctx, data_size);
if (blob.data == NULL) {
return NT_STATUS_NO_MEMORY;
}
value_len = 0;
status = dcerpc_winreg_QueryValue(h,
mem_ctx,
key_handle,
&wvalue,
&type,
blob.data,
&data_size,
&value_len,
pwerr);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
if (!W_ERROR_IS_OK(*pwerr)) {
return status;
}
if (data) {
*data = IVAL(blob.data, 0);
}
return status;
}
NTSTATUS dcerpc_winreg_query_binary(TALLOC_CTX *mem_ctx,
struct dcerpc_binding_handle *h,
struct policy_handle *key_handle,
const char *value,
DATA_BLOB *data,
WERROR *pwerr)
{
struct winreg_String wvalue;
enum winreg_Type type = REG_NONE;
uint32_t value_len = 0;
uint32_t data_size = 0;
NTSTATUS status;
DATA_BLOB blob;
ZERO_STRUCT(wvalue);
wvalue.name = value;
status = dcerpc_winreg_QueryValue(h,
mem_ctx,
key_handle,
&wvalue,
&type,
NULL,
&data_size,
&value_len,
pwerr);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
if (!W_ERROR_IS_OK(*pwerr)) {
return status;
}
if (type != REG_BINARY) {
return NT_STATUS_OBJECT_TYPE_MISMATCH;
}
blob = data_blob_talloc_zero(mem_ctx, data_size);
if (blob.data == NULL) {
return NT_STATUS_NO_MEMORY;
}
value_len = 0;
status = dcerpc_winreg_QueryValue(h,
mem_ctx,
key_handle,
&wvalue,
&type,
blob.data,
&data_size,
&value_len,
pwerr);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
if (!W_ERROR_IS_OK(*pwerr)) {
return status;
}
if (data) {
data->data = blob.data;
data->length = blob.length;
}
return status;
}
NTSTATUS dcerpc_winreg_query_multi_sz(TALLOC_CTX *mem_ctx,
struct dcerpc_binding_handle *h,
struct policy_handle *key_handle,
const char *value,
const char ***data,
WERROR *pwerr)
{
struct winreg_String wvalue;
enum winreg_Type type = REG_NONE;
uint32_t value_len = 0;
uint32_t data_size = 0;
NTSTATUS status;
DATA_BLOB blob;
wvalue.name = value;
status = dcerpc_winreg_QueryValue(h,
mem_ctx,
key_handle,
&wvalue,
&type,
NULL,
&data_size,
&value_len,
pwerr);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
if (!W_ERROR_IS_OK(*pwerr)) {
return status;
}
if (type != REG_MULTI_SZ) {
return NT_STATUS_OBJECT_TYPE_MISMATCH;
}
blob = data_blob_talloc_zero(mem_ctx, data_size);
if (blob.data == NULL) {
return NT_STATUS_NO_MEMORY;
}
value_len = 0;
status = dcerpc_winreg_QueryValue(h,
mem_ctx,
key_handle,
&wvalue,
&type,
blob.data,
&data_size,
&value_len,
pwerr);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
if (!W_ERROR_IS_OK(*pwerr)) {
return status;
}
if (data) {
bool ok;
ok = pull_reg_multi_sz(mem_ctx, &blob, data);
if (!ok) {
status = NT_STATUS_NO_MEMORY;
}
}
return status;
}
NTSTATUS dcerpc_winreg_query_sz(TALLOC_CTX *mem_ctx,
struct dcerpc_binding_handle *h,
struct policy_handle *key_handle,
const char *value,
const char **data,
WERROR *pwerr)
{
struct winreg_String wvalue;
enum winreg_Type type = REG_NONE;
uint32_t value_len = 0;
uint32_t data_size = 0;
NTSTATUS status;
DATA_BLOB blob;
wvalue.name = value;
status = dcerpc_winreg_QueryValue(h,
mem_ctx,
key_handle,
&wvalue,
&type,
NULL,
&data_size,
&value_len,
pwerr);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
if (!W_ERROR_IS_OK(*pwerr)) {
return status;
}
if (type != REG_SZ) {
return NT_STATUS_OBJECT_TYPE_MISMATCH;
}
blob = data_blob_talloc_zero(mem_ctx, data_size);
if (blob.data == NULL) {
return NT_STATUS_NO_MEMORY;
}
value_len = 0;
status = dcerpc_winreg_QueryValue(h,
mem_ctx,
key_handle,
&wvalue,
&type,
blob.data,
&data_size,
&value_len,
pwerr);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
if (!W_ERROR_IS_OK(*pwerr)) {
return status;
}
if (data) {
bool ok;
ok = pull_reg_sz(mem_ctx, &blob, data);
if (!ok) {
status = NT_STATUS_NO_MEMORY;
}
}
return status;
}
NTSTATUS dcerpc_winreg_query_sd(TALLOC_CTX *mem_ctx,
struct dcerpc_binding_handle *h,
struct policy_handle *key_handle,
const char *value,
struct security_descriptor **data,
WERROR *pwerr)
{
NTSTATUS status;
DATA_BLOB blob;
status = dcerpc_winreg_query_binary(mem_ctx,
h,
key_handle,
value,
&blob,
pwerr);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
if (!W_ERROR_IS_OK(*pwerr)) {
return status;
}
if (data) {
struct security_descriptor *sd;
enum ndr_err_code ndr_err;
sd = talloc_zero(mem_ctx, struct security_descriptor);
if (sd == NULL) {
return NT_STATUS_NO_MEMORY;
}
ndr_err = ndr_pull_struct_blob(&blob,
sd,
sd,
(ndr_pull_flags_fn_t) ndr_pull_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(2, ("dcerpc_winreg_query_sd: Failed to marshall "
"security descriptor\n"));
return NT_STATUS_NO_MEMORY;
}
*data = sd;
}
return status;
}
NTSTATUS dcerpc_winreg_set_dword(TALLOC_CTX *mem_ctx,
struct dcerpc_binding_handle *h,
struct policy_handle *key_handle,
const char *value,
uint32_t data,
WERROR *pwerr)
{
struct winreg_String wvalue;
DATA_BLOB blob;
NTSTATUS status;
ZERO_STRUCT(wvalue);
wvalue.name = value;
blob = data_blob_talloc_zero(mem_ctx, 4);
SIVAL(blob.data, 0, data);
status = dcerpc_winreg_SetValue(h,
mem_ctx,
key_handle,
wvalue,
REG_DWORD,
blob.data,
blob.length,
pwerr);
return status;
}
NTSTATUS dcerpc_winreg_set_sz(TALLOC_CTX *mem_ctx,
struct dcerpc_binding_handle *h,
struct policy_handle *key_handle,
const char *value,
const char *data,
WERROR *pwerr)
{
struct winreg_String wvalue = { 0, };
DATA_BLOB blob;
NTSTATUS status;
wvalue.name = value;
if (data == NULL) {
blob = data_blob_string_const("");
} else {
if (!push_reg_sz(mem_ctx, &blob, data)) {
DEBUG(2, ("dcerpc_winreg_set_sz: Could not marshall "
"string %s for %s\n",
data, wvalue.name));
return NT_STATUS_NO_MEMORY;
}
}
status = dcerpc_winreg_SetValue(h,
mem_ctx,
key_handle,
wvalue,
REG_SZ,
blob.data,
blob.length,
pwerr);
return status;
}
NTSTATUS dcerpc_winreg_set_expand_sz(TALLOC_CTX *mem_ctx,
struct dcerpc_binding_handle *h,
struct policy_handle *key_handle,
const char *value,
const char *data,
WERROR *pwerr)
{
struct winreg_String wvalue = { 0, };
DATA_BLOB blob;
NTSTATUS status;
wvalue.name = value;
if (data == NULL) {
blob = data_blob_string_const("");
} else {
if (!push_reg_sz(mem_ctx, &blob, data)) {
DEBUG(2, ("dcerpc_winreg_set_expand_sz: Could not marshall "
"string %s for %s\n",
data, wvalue.name));
return NT_STATUS_NO_MEMORY;
}
}
status = dcerpc_winreg_SetValue(h,
mem_ctx,
key_handle,
wvalue,
REG_EXPAND_SZ,
blob.data,
blob.length,
pwerr);
return status;
}
NTSTATUS dcerpc_winreg_set_multi_sz(TALLOC_CTX *mem_ctx,
struct dcerpc_binding_handle *h,
struct policy_handle *key_handle,
const char *value,
const char **data,
WERROR *pwerr)
{
struct winreg_String wvalue = { 0, };
DATA_BLOB blob;
NTSTATUS status;
wvalue.name = value;
if (!push_reg_multi_sz(mem_ctx, &blob, data)) {
DEBUG(2, ("dcerpc_winreg_set_multi_sz: Could not marshall "
"string multi sz for %s\n",
wvalue.name));
return NT_STATUS_NO_MEMORY;
}
status = dcerpc_winreg_SetValue(h,
mem_ctx,
key_handle,
wvalue,
REG_MULTI_SZ,
blob.data,
blob.length,
pwerr);
return status;
}
NTSTATUS dcerpc_winreg_set_binary(TALLOC_CTX *mem_ctx,
struct dcerpc_binding_handle *h,
struct policy_handle *key_handle,
const char *value,
DATA_BLOB *data,
WERROR *pwerr)
{
struct winreg_String wvalue = { 0, };
NTSTATUS status;
wvalue.name = value;
status = dcerpc_winreg_SetValue(h,
mem_ctx,
key_handle,
wvalue,
REG_BINARY,
data->data,
data->length,
pwerr);
return status;
}
NTSTATUS dcerpc_winreg_set_sd(TALLOC_CTX *mem_ctx,
struct dcerpc_binding_handle *h,
struct policy_handle *key_handle,
const char *value,
const struct security_descriptor *data,
WERROR *pwerr)
{
enum ndr_err_code ndr_err;
DATA_BLOB blob;
ndr_err = ndr_push_struct_blob(&blob,
mem_ctx,
data,
(ndr_push_flags_fn_t) ndr_push_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(2, ("dcerpc_winreg_set_sd: Failed to marshall security "
"descriptor\n"));
return NT_STATUS_NO_MEMORY;
}
return dcerpc_winreg_set_binary(mem_ctx,
h,
key_handle,
value,
&blob,
pwerr);
}
NTSTATUS dcerpc_winreg_add_multi_sz(TALLOC_CTX *mem_ctx,
struct dcerpc_binding_handle *h,
struct policy_handle *key_handle,
const char *value,
const char *data,
WERROR *pwerr)
{
const char **a = NULL;
const char **p;
uint32_t i;
NTSTATUS status;
status = dcerpc_winreg_query_multi_sz(mem_ctx,
h,
key_handle,
value,
&a,
pwerr);
/* count the elements */
for (p = a, i = 0; p && *p; p++, i++);
p = talloc_realloc(mem_ctx, a, const char *, i + 2);
if (p == NULL) {
return NT_STATUS_NO_MEMORY;
}
p[i] = data;
p[i + 1] = NULL;
status = dcerpc_winreg_set_multi_sz(mem_ctx,
h,
key_handle,
value,
p,
pwerr);
return status;
}
NTSTATUS dcerpc_winreg_enum_keys(TALLOC_CTX *mem_ctx,
struct dcerpc_binding_handle *h,
struct policy_handle *key_hnd,
uint32_t *pnum_subkeys,
const char ***psubkeys,
WERROR *pwerr)
{
const char **subkeys;
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;
NTSTATUS status;
TALLOC_CTX *tmp_ctx;
tmp_ctx = talloc_stackframe();
if (tmp_ctx == NULL) {
return NT_STATUS_NO_MEMORY;
}
ZERO_STRUCT(classname);
status = dcerpc_winreg_QueryInfoKey(h,
tmp_ctx,
key_hnd,
&classname,
&num_subkeys,
&max_subkeylen,
&max_classlen,
&num_values,
&max_valnamelen,
&max_valbufsize,
&secdescsize,
&last_changed_time,
pwerr);
if (!NT_STATUS_IS_OK(status)) {
goto error;
}
if (!W_ERROR_IS_OK(*pwerr)) {
goto error;
}
subkeys = talloc_zero_array(tmp_ctx, const char *, num_subkeys + 2);
if (subkeys == NULL) {
status = NT_STATUS_NO_MEMORY;
goto error;
}
if (num_subkeys == 0) {
subkeys[0] = talloc_strdup(subkeys, "");
if (subkeys[0] == NULL) {
status = NT_STATUS_NO_MEMORY;
goto error;
}
*pnum_subkeys = 0;
if (psubkeys) {
*psubkeys = talloc_move(mem_ctx, &subkeys);
}
TALLOC_FREE(tmp_ctx);
return NT_STATUS_OK;
}
for (i = 0; i < num_subkeys; i++) {
char c = '\0';
char n = '\0';
char *name = NULL;
struct winreg_StringBuf class_buf;
struct winreg_StringBuf name_buf;
NTTIME modtime;
class_buf.name = &c;
class_buf.size = max_classlen + 2;
class_buf.length = 0;
name_buf.name = &n;
name_buf.size = max_subkeylen + 2;
name_buf.length = 0;
ZERO_STRUCT(modtime);
status = dcerpc_winreg_EnumKey(h,
tmp_ctx,
key_hnd,
i,
&name_buf,
&class_buf,
&modtime,
pwerr);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(5, ("dcerpc_winreg_enum_keys: Could not enumerate keys: %s\n",
nt_errstr(status)));
goto error;
}
if (W_ERROR_EQUAL(*pwerr, WERR_NO_MORE_ITEMS)) {
*pwerr = WERR_OK;
break;
}
if (!W_ERROR_IS_OK(*pwerr)) {
DEBUG(5, ("dcerpc_winreg_enum_keys: Could not enumerate keys: %s\n",
win_errstr(*pwerr)));
goto error;
}
if (name_buf.name == NULL) {
*pwerr = WERR_INVALID_PARAMETER;
goto error;
}
name = talloc_strdup(subkeys, name_buf.name);
if (name == NULL) {
status = NT_STATUS_NO_MEMORY;
goto error;
}
subkeys[i] = name;
}
*pnum_subkeys = num_subkeys;
if (psubkeys) {
*psubkeys = talloc_move(mem_ctx, &subkeys);
}
error:
TALLOC_FREE(tmp_ctx);
return status;
}
NTSTATUS dcerpc_winreg_enumvals(TALLOC_CTX *mem_ctx,
struct dcerpc_binding_handle *h,
struct policy_handle *key_hnd,
uint32_t *pnum_values,
const char ***pnames,
enum winreg_Type **_type,
DATA_BLOB **pdata,
WERROR *pwerr)
{
TALLOC_CTX *tmp_ctx;
uint32_t num_subkeys = 0, max_subkeylen = 0, max_classlen = 0;
uint32_t num_values = 0, max_valnamelen = 0, max_valbufsize = 0;
uint32_t secdescsize = 0;
uint32_t i;
NTTIME last_changed_time = 0;
struct winreg_String classname;
const char **enum_names = NULL;
enum winreg_Type *enum_types = NULL;
DATA_BLOB *enum_data_blobs = NULL;
WERROR result = WERR_OK;
NTSTATUS status;
tmp_ctx = talloc_stackframe();
if (tmp_ctx == NULL) {
status = NT_STATUS_NO_MEMORY;
*pwerr = ntstatus_to_werror(status);
return status;
}
ZERO_STRUCT(classname);
status = dcerpc_winreg_QueryInfoKey(h,
tmp_ctx,
key_hnd,
&classname,
&num_subkeys,
&max_subkeylen,
&max_classlen,
&num_values,
&max_valnamelen,
&max_valbufsize,
&secdescsize,
&last_changed_time,
&result);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("dcerpc_winreg_enumvals: Could not query info: %s\n",
nt_errstr(status)));
goto error;
}
if (!W_ERROR_IS_OK(result)) {
DEBUG(0, ("dcerpc_winreg_enumvals: Could not query info: %s\n",
win_errstr(result)));
*pwerr = result;
goto error;
}
if (num_values == 0) {
*pnum_values = 0;
TALLOC_FREE(tmp_ctx);
*pwerr = WERR_OK;
return status;
}
enum_names = talloc_zero_array(tmp_ctx, const char *, num_values);
if (enum_names == NULL) {
*pwerr = WERR_NOT_ENOUGH_MEMORY;
goto error;
}
enum_types = talloc_zero_array(tmp_ctx, enum winreg_Type, num_values);
if (enum_types == NULL) {
*pwerr = WERR_NOT_ENOUGH_MEMORY;
goto error;
}
enum_data_blobs = talloc_zero_array(tmp_ctx, DATA_BLOB, num_values);
if (enum_data_blobs == NULL) {
*pwerr = WERR_NOT_ENOUGH_MEMORY;
goto error;
}
for (i = 0; i < num_values; i++) {
const char *name;
struct winreg_ValNameBuf name_buf;
enum winreg_Type type = REG_NONE;
uint8_t *data;
uint32_t data_size;
uint32_t length;
char n = '\0';
name_buf.name = &n;
name_buf.size = max_valnamelen + 2;
name_buf.length = 0;
data_size = max_valbufsize;
data = NULL;
if (data_size) {
data = (uint8_t *) TALLOC(tmp_ctx, data_size);
}
length = 0;
status = dcerpc_winreg_EnumValue(h,
tmp_ctx,
key_hnd,
i,
&name_buf,
&type,
data,
data_size ? &data_size : NULL,
&length,
&result);
if (W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS) ) {
result = WERR_OK;
status = NT_STATUS_OK;
break;
}
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("dcerpc_winreg_enumvals: Could not enumerate values: %s\n",
nt_errstr(status)));
goto error;
}
if (!W_ERROR_IS_OK(result)) {
DEBUG(0, ("dcerpc_winreg_enumvals: Could not enumerate values: %s\n",
win_errstr(result)));
*pwerr = result;
goto error;
}
if (name_buf.name == NULL) {
result = WERR_INVALID_PARAMETER;
*pwerr = result;
goto error;
}
name = talloc_strdup(enum_names, name_buf.name);
if (name == NULL) {
result = WERR_NOT_ENOUGH_MEMORY;
*pwerr = result;
goto error;
}
/* place name, type and datablob in the enum return params */
enum_data_blobs[i] = data_blob_talloc(enum_data_blobs, data, length);
enum_names[i] = name;
enum_types[i] = type;
}
/* move to the main mem context */
*pnum_values = num_values;
if (pnames) {
*pnames = talloc_move(mem_ctx, &enum_names);
}
/* can this fail in any way? */
if (_type) {
*_type = talloc_move(mem_ctx, &enum_types);
}
if (pdata){
*pdata = talloc_move(mem_ctx, &enum_data_blobs);
}
result = WERR_OK;
error:
TALLOC_FREE(tmp_ctx);
*pwerr = result;
return status;
}
NTSTATUS dcerpc_winreg_delete_subkeys_recursive(TALLOC_CTX *mem_ctx,
struct dcerpc_binding_handle *h,
struct policy_handle *hive_handle,
uint32_t access_mask,
const char *key,
WERROR *pwerr)
{
const char **subkeys = NULL;
uint32_t num_subkeys = 0;
struct policy_handle key_hnd;
struct winreg_String wkey = { 0, };
WERROR result = WERR_OK;
NTSTATUS status;
uint32_t i;
ZERO_STRUCT(key_hnd);
wkey.name = key;
DEBUG(2, ("dcerpc_winreg_delete_subkeys_recursive: delete key %s\n", key));
/* open the key */
status = dcerpc_winreg_OpenKey(h,
mem_ctx,
hive_handle,
wkey,
0,
access_mask,
&key_hnd,
&result);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("dcerpc_winreg_delete_subkeys_recursive: Could not open key %s: %s\n",
wkey.name, nt_errstr(status)));
goto done;
}
if (!W_ERROR_IS_OK(result)) {
DEBUG(0, ("dcerpc_winreg_delete_subkeys_recursive: Could not open key %s: %s\n",
wkey.name, win_errstr(result)));
*pwerr = result;
goto done;
}
status = dcerpc_winreg_enum_keys(mem_ctx,
h,
&key_hnd,
&num_subkeys,
&subkeys,
&result);
if (!NT_STATUS_IS_OK(status)) {
goto done;
}
if (!W_ERROR_IS_OK(result)) {
goto done;
}
for (i = 0; i < num_subkeys; i++) {
/* create key + subkey */
char *subkey = talloc_asprintf(mem_ctx, "%s\\%s", key, subkeys[i]);
if (subkey == NULL) {
goto done;
}
DEBUG(2, ("dcerpc_winreg_delete_subkeys_recursive: delete subkey %s\n", subkey));
status = dcerpc_winreg_delete_subkeys_recursive(mem_ctx,
h,
hive_handle,
access_mask,
subkey,
&result);
if (!W_ERROR_IS_OK(result)) {
goto done;
}
}
if (is_valid_policy_hnd(&key_hnd)) {
WERROR ignore;
dcerpc_winreg_CloseKey(h, mem_ctx, &key_hnd, &ignore);
}
wkey.name = key;
status = dcerpc_winreg_DeleteKey(h,
mem_ctx,
hive_handle,
wkey,
&result);
if (!NT_STATUS_IS_OK(status)) {
*pwerr = result;
goto done;
}
done:
if (is_valid_policy_hnd(&key_hnd)) {
WERROR ignore;
dcerpc_winreg_CloseKey(h, mem_ctx, &key_hnd, &ignore);
}
*pwerr = result;
return status;
}
/* vim: set ts=8 sw=8 noet cindent syntax=c.doxygen: */