along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "includes.h"
-#include "popt_common.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/cli_winreg.h"
-#include "registry/reg_objects.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 rpccli_winreg_Connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+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)
{
switch (reg_type)
{
case HKEY_CLASSES_ROOT:
- return rpccli_winreg_OpenHKCR( cli, mem_ctx, NULL,
+ return dcerpc_winreg_OpenHKCR(b, mem_ctx, NULL,
access_mask, reg_hnd, werr);
case HKEY_LOCAL_MACHINE:
- return rpccli_winreg_OpenHKLM( cli, mem_ctx, NULL,
+ return dcerpc_winreg_OpenHKLM(b, mem_ctx, NULL,
access_mask, reg_hnd, werr);
case HKEY_USERS:
- return rpccli_winreg_OpenHKU( cli, mem_ctx, NULL,
+ return dcerpc_winreg_OpenHKU(b, mem_ctx, NULL,
access_mask, reg_hnd, werr);
case HKEY_CURRENT_USER:
- return rpccli_winreg_OpenHKCU( cli, mem_ctx, NULL,
+ return dcerpc_winreg_OpenHKCU(b, mem_ctx, NULL,
access_mask, reg_hnd, werr);
case HKEY_PERFORMANCE_DATA:
- return rpccli_winreg_OpenHKPD( cli, mem_ctx, NULL,
+ return dcerpc_winreg_OpenHKPD(b, mem_ctx, NULL,
access_mask, reg_hnd, werr);
default:
}
static bool reg_hive_key(TALLOC_CTX *ctx, const char *fullname,
- uint32 *reg_type, const char **key_name)
+ uint32_t *reg_type, const char **key_name)
{
WERROR werr;
char *hivename = NULL;
static NTSTATUS registry_openkey(TALLOC_CTX *mem_ctx,
struct rpc_pipe_client *pipe_hnd,
- const char *name, uint32 access_mask,
+ const char *name, uint32_t access_mask,
struct policy_handle *hive_hnd,
struct policy_handle *key_hnd)
{
- uint32 hive;
+ uint32_t hive;
NTSTATUS status;
+ WERROR werr;
struct winreg_String key;
+ struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
ZERO_STRUCT(key);
return NT_STATUS_INVALID_PARAMETER;
}
- status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive, access_mask,
- hive_hnd, NULL);
+ 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 = rpccli_winreg_OpenKey(pipe_hnd, mem_ctx, hive_hnd, key, 0,
- access_mask, key_hnd, NULL);
+ status = dcerpc_winreg_OpenKey(b, mem_ctx, hive_hnd, key, 0,
+ access_mask, key_hnd, &werr);
if (!(NT_STATUS_IS_OK(status))) {
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, hive_hnd, NULL);
+ 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,
+ uint32_t *pnum_keys, char ***pnames,
char ***pclasses, NTTIME ***pmodtimes)
{
TALLOC_CTX *mem_ctx;
NTSTATUS status;
- uint32 num_subkeys, max_subkeylen, max_classlen;
- uint32 num_values, max_valnamelen, max_valbufsize;
- uint32 i;
+ 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 secdescsize;
+ 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 = rpccli_winreg_QueryInfoKey(
- pipe_hnd, mem_ctx, key_hnd, &classname, &num_subkeys,
+ 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, NULL );
+ &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;
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 *,
+ 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;
struct winreg_StringBuf class_buf;
struct winreg_StringBuf name_buf;
NTTIME modtime;
- WERROR werr;
c = '\0';
class_buf.name = &c;
ZERO_STRUCT(modtime);
- status = rpccli_winreg_EnumKey(pipe_hnd, mem_ctx, key_hnd,
+ 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 (!NT_STATUS_IS_OK(status)) {
+ if (!W_ERROR_IS_OK(werr)) {
+ status = werror_to_ntstatus(werr);
goto error;
}
static NTSTATUS registry_enumvalues(TALLOC_CTX *ctx,
struct rpc_pipe_client *pipe_hnd,
struct policy_handle *key_hnd,
- uint32 *pnum_values, char ***pvalnames,
+ uint32_t *pnum_values, char ***pvalnames,
struct registry_value ***pvalues)
{
TALLOC_CTX *mem_ctx;
NTSTATUS status;
- uint32 num_subkeys, max_subkeylen, max_classlen;
- uint32 num_values, max_valnamelen, max_valbufsize;
- uint32 i;
+ 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 secdescsize;
+ uint32_t secdescsize;
struct winreg_String classname;
struct registry_value **values;
char **names;
+ struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
if (!(mem_ctx = talloc_new(ctx))) {
return NT_STATUS_NO_MEMORY;
}
ZERO_STRUCT(classname);
- status = rpccli_winreg_QueryInfoKey(
- pipe_hnd, mem_ctx, key_hnd, &classname, &num_subkeys,
+ 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, NULL );
+ &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;
return NT_STATUS_OK;
}
- if ((!(names = TALLOC_ARRAY(mem_ctx, char *, num_values))) ||
- (!(values = TALLOC_ARRAY(mem_ctx, struct registry_value *,
+ 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;
+ uint8_t *data = NULL;
+ uint32_t data_size;
+ uint32_t value_length;
char n;
struct winreg_ValNameBuf name_buf;
name_buf.size = max_valnamelen + 2;
data_size = max_valbufsize;
- data = (uint8 *)TALLOC(mem_ctx, data_size);
+ data = (uint8_t *)TALLOC(mem_ctx, data_size);
value_length = 0;
- status = rpccli_winreg_EnumValue(pipe_hnd, mem_ctx, key_hnd,
+ 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) ) {
break;
}
- if (!(NT_STATUS_IS_OK(status))) {
+ if (!W_ERROR_IS_OK(err)) {
+ status = werror_to_ntstatus(err);
goto error;
}
static NTSTATUS registry_enumvalues2(TALLOC_CTX *ctx,
struct rpc_pipe_client *pipe_hnd,
struct policy_handle *key_hnd,
- uint32 *pnum_values, char ***pvalnames,
+ uint32_t *pnum_values, char ***pvalnames,
struct regval_blob ***pvalues)
{
TALLOC_CTX *mem_ctx;
NTSTATUS status;
- uint32 num_subkeys, max_subkeylen, max_classlen;
- uint32 num_values, max_valnamelen, max_valbufsize;
- uint32 i;
+ 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 secdescsize;
+ 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 = rpccli_winreg_QueryInfoKey(
- pipe_hnd, mem_ctx, key_hnd, &classname, &num_subkeys,
+ 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, NULL );
+ &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;
return NT_STATUS_OK;
}
- if ((!(names = TALLOC_ARRAY(mem_ctx, char *, num_values))) ||
- (!(values = TALLOC_ARRAY(mem_ctx, struct regval_blob *,
+ 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;
+ uint8_t *data = NULL;
+ uint32_t data_size;
+ uint32_t value_length;
char n;
struct winreg_ValNameBuf name_buf;
name_buf.size = max_valnamelen + 2;
data_size = max_valbufsize;
- data = (uint8 *)TALLOC(mem_ctx, data_size);
+ data = (uint8_t *)TALLOC(mem_ctx, data_size);
value_length = 0;
- status = rpccli_winreg_EnumValue(pipe_hnd, mem_ctx, key_hnd,
+ 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 (!(NT_STATUS_IS_OK(status))) {
+ if (!W_ERROR_IS_OK(err)) {
+ status = werror_to_ntstatus(err);
goto error;
}
goto error;
}
- assert(value_length<=data_size); //???
+ assert(value_length<=data_size); /*??? */
values[i] = regval_compose(values,
name_buf.name,
}
static NTSTATUS registry_getsd(TALLOC_CTX *mem_ctx,
- struct rpc_pipe_client *pipe_hnd,
+ struct dcerpc_binding_handle *b,
struct policy_handle *key_hnd,
uint32_t sec_info,
- struct KeySecurityData *sd)
+ struct KeySecurityData *sd,
+ WERROR *werr)
{
- return rpccli_winreg_GetKeySecurity(pipe_hnd, mem_ctx, key_hnd,
- sec_info, sd, NULL);
+ return dcerpc_winreg_GetKeySecurity(b, mem_ctx, key_hnd,
+ sec_info, sd, werr);
}
{
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 = rpccli_winreg_SetValue(pipe_hnd, mem_ctx, key_hnd,
+ result = dcerpc_winreg_SetValue(b, mem_ctx, key_hnd,
name_string, value->type,
- value->data.data, value->data.length, NULL);
- return result;
+ 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,
{
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,
}
if (strequal(argv[2], "dword")) {
- uint32_t v = strtoul(argv[3], NULL, 10);
+ 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);
}
error:
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &key_hnd, NULL);
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
+ dcerpc_winreg_CloseKey(b, mem_ctx, &key_hnd, &werr);
+ dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &werr);
return NT_STATUS_OK;
}
return -1;
}
- return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
+ return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
rpc_registry_setvalue_internal, argc, 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);
valuename.name = argv[1];
- status = rpccli_winreg_DeleteValue(pipe_hnd, mem_ctx, &key_hnd,
- valuename, NULL);
-
+ 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));
+ }
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &key_hnd, NULL);
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
+ dcerpc_winreg_CloseKey(b, mem_ctx, &key_hnd, &werr);
+ dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &werr);
return status;
}
return -1;
}
- return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
+ return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
rpc_registry_deletevalue_internal, argc, 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);
* needed memory size to be allocated, then allocate
* data buffer and call again.
*/
- status = rpccli_winreg_QueryValue(pipe_hnd, tmp_ctx, &key_hnd,
+ status = dcerpc_winreg_QueryValue(b, tmp_ctx, &key_hnd,
&valuename,
&type,
NULL,
&data_size,
&value_length,
- NULL);
+ &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 = rpccli_winreg_QueryValue(pipe_hnd, tmp_ctx, &key_hnd,
+ status = dcerpc_winreg_QueryValue(b, tmp_ctx, &key_hnd,
&valuename,
&type,
value->data.data,
&data_size,
&value_length,
- NULL);
+ &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:
- rpccli_winreg_CloseKey(pipe_hnd, tmp_ctx, &key_hnd, NULL);
- rpccli_winreg_CloseKey(pipe_hnd, tmp_ctx, &hive_hnd, NULL);
+ dcerpc_winreg_CloseKey(b, tmp_ctx, &key_hnd, &werr);
+ dcerpc_winreg_CloseKey(b, tmp_ctx, &hive_hnd, &werr);
TALLOC_FREE(tmp_ctx);
return -1;
}
- return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
+ return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
rpc_registry_getvalue_full, argc, argv);
}
return -1;
}
- return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
+ return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
rpc_registry_getvalue_raw, argc, argv);
}
int argc,
const char **argv )
{
- uint32 hive;
+ 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);
return NT_STATUS_INVALID_PARAMETER;
}
- status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive,
+ status = dcerpc_winreg_Connect(b, mem_ctx, hive,
SEC_FLAG_MAXIMUM_ALLOWED,
- &hive_hnd, NULL);
+ &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 = rpccli_winreg_CreateKey(pipe_hnd, mem_ctx, &hive_hnd, key,
+ status = dcerpc_winreg_CreateKey(b, mem_ctx, &hive_hnd, key,
keyclass, 0, REG_KEY_READ, NULL,
- &key_hnd, &action, NULL);
+ &key_hnd, &action, &werr);
if (!NT_STATUS_IS_OK(status)) {
d_fprintf(stderr, _("createkey returned %s\n"),
nt_errstr(status));
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
+ 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:
break;
}
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &key_hnd, NULL);
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
+ dcerpc_winreg_CloseKey(b, mem_ctx, &key_hnd, &werr);
+ dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &werr);
return status;
}
return -1;
}
- return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
+ return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
rpc_registry_createkey_internal, argc, argv );
}
int argc,
const char **argv )
{
- uint32 hive;
+ 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);
return NT_STATUS_INVALID_PARAMETER;
}
- status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive,
+ status = dcerpc_winreg_Connect(b, mem_ctx, hive,
SEC_FLAG_MAXIMUM_ALLOWED,
- &hive_hnd, NULL);
+ &hive_hnd, &werr);
if (!(NT_STATUS_IS_OK(status))) {
return status;
}
+ if (!W_ERROR_IS_OK(werr)) {
+ return werror_to_ntstatus(werr);
+ }
- status = rpccli_winreg_DeleteKey(pipe_hnd, mem_ctx, &hive_hnd, key, NULL);
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
+ 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;
return -1;
}
- return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
+ return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
rpc_registry_deletekey_internal, argc, argv );
}
{
struct policy_handle pol_hive, pol_key;
NTSTATUS status;
- uint32 num_subkeys = 0;
- uint32 num_values = 0;
+ WERROR werr;
+ uint32_t num_subkeys = 0;
+ uint32_t num_values = 0;
char **names = NULL, **classes = NULL;
NTTIME **modtimes = NULL;
- uint32 i;
+ 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",
print_registry_value_with_name(names[i], values[i]);
}
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key, NULL);
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive, NULL);
+ 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,
+ return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
rpc_registry_enumerate_internal, argc, argv );
}
int argc,
const char **argv )
{
- WERROR result = WERR_GENERAL_FAILURE;
+ WERROR result = WERR_GEN_FAILURE;
struct policy_handle pol_hive, pol_key;
NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
struct winreg_String filename;
+ struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
if (argc != 2 || c->display_usage) {
d_printf("%s\n%s",
}
filename.name = argv[1];
- status = rpccli_winreg_SaveKey( pipe_hnd, mem_ctx, &pol_key, &filename, NULL, NULL);
- if ( !W_ERROR_IS_OK(result) ) {
+ 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],
- cli->desthost, argv[1]);
+ pipe_hnd->desthost, argv[1]);
}
/* cleanup */
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key, NULL);
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive, NULL);
+ 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,
+ return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
rpc_registry_save_internal, argc, argv );
}
{
int i, j;
const char *data_str = NULL;
- uint32 data_size, data;
+ uint32_t data_size, data;
DATA_BLOB blob;
if ( !nk->values )
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 (!pull_reg_sz(talloc_tos(), &blob,
+ &data_str)) {
+ data_str = NULL;
+ }
if (!data_str) {
break;
}
{
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;
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",
return status;
}
- sd = TALLOC_ZERO_P(mem_ctx, struct KeySecurityData);
+ sd = talloc_zero(mem_ctx, struct KeySecurityData);
if (!sd) {
status = NT_STATUS_NO_MEMORY;
goto out;
sec_info = SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL;
}
- status = registry_getsd(mem_ctx, pipe_hnd, &pol_key, sec_info, sd);
+ 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;
display_sec_desc(&sec_desc);
out:
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key, NULL);
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive, NULL);
+ 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,
+ return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
rpc_registry_getsd_internal, argc, argv);
}
const char* name)
{
NTSTATUS status;
- uint32 num_subkeys = 0;
- uint32 num_values = 0;
+ uint32_t num_subkeys = 0;
+ uint32_t num_values = 0;
char **names = NULL, **classes = NULL;
NTTIME **modtimes = NULL;
struct regval_blob **values = NULL;
- uint32 i;
+ uint32_t i;
+ struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
TALLOC_CTX* mem_ctx = talloc_new(ctx);
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 = rpccli_winreg_OpenKey(pipe_hnd, mem_ctx, key_hnd, key,
+ status = dcerpc_winreg_OpenKey(b, mem_ctx, key_hnd, key,
0, REG_KEY_READ,
- &subkey_hnd, NULL);
- if (NT_STATUS_IS_OK(status)) {
- 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));
-
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx,
- &subkey_hnd, NULL);
- } else {
+ &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,
- _("rpccli_winreg_OpenKey failed: %s %s\n"),
+ _("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);
{
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",
if (!NT_STATUS_IS_OK(status))
return status;
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key, NULL);
- rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive, NULL);
+ 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,
+ return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
rpc_registry_export_internal, argc, argv );
}
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;
+ uint32_t hive_idx = 0;
if (!reg_hive_key(mem_ctx, name, &hive_idx, &keyname.name)) {
werr = WERR_FOOBAR;
goto done;
}
- status = rpccli_winreg_Connect(ctx->pipe_hnd, mem_ctx,
+ status = dcerpc_winreg_Connect(b, mem_ctx,
hive_idx, SEC_FLAG_MAXIMUM_ALLOWED,
&hive, &werr);
if (!NT_STATUS_IS_OK(status)) {
- d_fprintf(stderr, _("rpccli_winreg_Connect returned %s\n"),
+ 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;
+ werr = WERR_NOT_ENOUGH_MEMORY;
goto done;
}
ZERO_STRUCT(keyclass);
keyclass.name = "";
- status = rpccli_winreg_CreateKey(ctx->pipe_hnd, mem_ctx,
+ status = dcerpc_winreg_CreateKey(b, mem_ctx,
parent, keyname,
keyclass, 0, REG_KEY_READ, NULL,
key, &action, &werr);
if (!NT_STATUS_IS_OK(status)) {
- d_fprintf(stderr, _("rpccli_winreg_CreateKey returned %s\n"),
+ 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:
done:
if ( parent == &hive ) {
- rpccli_winreg_CloseKey(ctx->pipe_hnd, mem_ctx,
- parent, NULL);
+ WERROR _result;
+ dcerpc_winreg_CloseKey(b, mem_ctx,
+ parent, &_result);
}
if (pkey!=NULL) {
WERROR werr;
NTSTATUS status;
void* mem_ctx = talloc_new(ctx->mem_ctx);
- struct winreg_String keyname;
+ 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;
+ uint32_t hive_idx;
if (!reg_hive_key(mem_ctx, name, &hive_idx, &keyname.name)) {
werr = WERR_FOOBAR;
goto done;
}
- status = rpccli_winreg_Connect(ctx->pipe_hnd, mem_ctx, hive_idx,
+ status = dcerpc_winreg_Connect(b, mem_ctx, hive_idx,
SEC_FLAG_MAXIMUM_ALLOWED, &hive,
&werr);
if (!NT_STATUS_IS_OK(status)) {
- d_fprintf(stderr, _("rpccli_winreg_Connect returned %s\n"),
+ 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 = rpccli_winreg_DeleteKey(ctx->pipe_hnd, mem_ctx, parent,
+ status = dcerpc_winreg_DeleteKey(b, mem_ctx, parent,
keyname, &werr);
if (!NT_STATUS_IS_OK(status)) {
- d_fprintf(stderr, _("rpccli_winreg_DeleteKey returned %s\n"),
+ 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 ) {
- rpccli_winreg_CloseKey(ctx->pipe_hnd, mem_ctx, parent, NULL);
+ WERROR _result;
+ dcerpc_winreg_CloseKey(b, mem_ctx, parent, &_result);
}
talloc_free(mem_ctx);
WERROR werr;
NTSTATUS status;
void* mem_ctx = talloc_new(ctx->mem_ctx);
+ struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
- status = rpccli_winreg_CloseKey(ctx->pipe_hnd, mem_ctx, key, &werr);
+ status = dcerpc_winreg_CloseKey(b, mem_ctx, key, &werr);
if (!NT_STATUS_IS_OK(status)) {
- d_fprintf(stderr, _("rpccli_winreg_CloseKey returned %s\n"),
+ 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;
+ werr = (talloc_free(key) == 0) ? WERR_OK : WERR_GEN_FAILURE;
done:
talloc_free(mem_ctx);
return 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;
+ return WERR_INVALID_PARAMETER;
}
ZERO_STRUCT(valuename);
valuename.name = name;
- status = rpccli_winreg_SetValue(ctx->pipe_hnd, mem_ctx, parent,
+ 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);
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;
+ return WERR_INVALID_PARAMETER;
}
ZERO_STRUCT(valuename);
valuename.name = name;
- status = rpccli_winreg_DeleteValue(ctx->pipe_hnd, mem_ctx,
+ 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;
.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 = {
+ .blob = (reg_import_callback_setval_blob_t)&import_create_val,
+ },
.setval_type = BLOB,
.data = &import_ctx
};
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,
+ return run_rpc_command(c, NULL, &ndr_table_winreg, 0,
rpc_registry_import_internal, argc, argv );
}
NET_TRANSPORT_RPC,
N_("Get security descriptor"),
N_("net rpc registry getsd\n"
- " Get security descriptior")
+ " Get security descriptor")
},
{
"import",
"export",
rpc_registry_export,
NET_TRANSPORT_RPC,
- N_("net registry export\n"
+ N_("Export .reg file"),
+ N_("net rpc registry export\n"
" Export .reg file")
},
{NULL, NULL, 0, NULL, NULL}