#define TEST_KEY3 TEST_KEY_BASE "\\with a subkey"
#define TEST_SUBKEY TEST_KEY3 "\\subkey"
-static void init_initshutdown_String(TALLOC_CTX *mem_ctx,
- struct initshutdown_String *name,
- const char *s)
+static void init_initshutdown_String(TALLOC_CTX *mem_ctx,
+ struct initshutdown_String *name,
+ const char *s)
{
name->name = talloc(mem_ctx, struct initshutdown_String_sub);
name->name->name = s;
}
}
-static bool test_GetVersion(struct dcerpc_pipe *p,
- struct torture_context *tctx,
+static bool test_GetVersion(struct dcerpc_pipe *p,
+ struct torture_context *tctx,
struct policy_handle *handle)
{
struct winreg_GetVersion r;
return true;
}
-static bool test_NotifyChangeKeyValue(struct dcerpc_pipe *p,
- struct torture_context *tctx,
- struct policy_handle *handle)
+static bool test_NotifyChangeKeyValue(struct dcerpc_pipe *p,
+ struct torture_context *tctx,
+ struct policy_handle *handle)
{
struct winreg_NotifyChangeKeyValue r;
init_winreg_String(&r.in.string1, NULL);
init_winreg_String(&r.in.string2, NULL);
- torture_assert_ntstatus_ok(tctx,
- dcerpc_winreg_NotifyChangeKeyValue(p, tctx, &r),
- "NotifyChangeKeyValue failed");
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_winreg_NotifyChangeKeyValue(p, tctx, &r),
+ "NotifyChangeKeyValue failed");
if (!W_ERROR_IS_OK(r.out.result)) {
- torture_comment(tctx,
- "NotifyChangeKeyValue failed - %s - not considering\n", win_errstr(r.out.result));
+ torture_comment(tctx,
+ "NotifyChangeKeyValue failed - %s - not considering\n", win_errstr(r.out.result));
return true;
}
}
static bool test_CreateKey(struct dcerpc_pipe *p, struct torture_context *tctx,
- struct policy_handle *handle, const char *name,
+ struct policy_handle *handle, const char *name,
const char *class)
{
struct winreg_CreateKey r;
r.in.handle = handle;
r.out.new_handle = &newhandle;
- init_winreg_String(&r.in.name, name);
+ init_winreg_String(&r.in.name, name);
init_winreg_String(&r.in.keyclass, class);
r.in.options = 0x0;
r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
/*
createkey testing with a SD
*/
-static bool test_CreateKey_sd(struct dcerpc_pipe *p,
- struct torture_context *tctx,
- struct policy_handle *handle, const char *name,
+static bool test_CreateKey_sd(struct dcerpc_pipe *p,
+ struct torture_context *tctx,
+ struct policy_handle *handle, const char *name,
const char *class, struct policy_handle *newhandle)
{
struct winreg_CreateKey r;
SEC_ACE_FLAG_OBJECT_INHERIT,
NULL);
- torture_assert_ntstatus_ok(tctx,
- ndr_push_struct_blob(&sdblob, tctx, sd,
- (ndr_push_flags_fn_t)ndr_push_security_descriptor),
- "Failed to push security_descriptor ?!\n");
+ torture_assert_ntstatus_ok(tctx,
+ ndr_push_struct_blob(&sdblob, tctx, sd,
+ (ndr_push_flags_fn_t)ndr_push_security_descriptor),
+ "Failed to push security_descriptor ?!\n");
secbuf.sd.data = sdblob.data;
secbuf.sd.len = sdblob.length;
r.in.handle = handle;
r.out.new_handle = newhandle;
- init_winreg_String(&r.in.name, name);
+ init_winreg_String(&r.in.name, name);
init_winreg_String(&r.in.keyclass, class);
r.in.options = 0x0;
r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
return true;
}
-static bool test_GetKeySecurity(struct dcerpc_pipe *p,
- struct torture_context *tctx,
- struct policy_handle *handle)
+static bool test_GetKeySecurity(struct dcerpc_pipe *p,
+ struct torture_context *tctx,
+ struct policy_handle *handle)
{
struct winreg_GetKeySecurity r;
struct security_descriptor sd;
sdblob.data = r.out.sd->data;
sdblob.length = r.out.sd->len;
- torture_assert_ntstatus_ok(tctx,
- ndr_pull_struct_blob(&sdblob, tctx, &sd,
- (ndr_pull_flags_fn_t)ndr_pull_security_descriptor),
- "pull_security_descriptor failed");
+ torture_assert_ntstatus_ok(tctx,
+ ndr_pull_struct_blob(&sdblob, tctx, &sd,
+ (ndr_pull_flags_fn_t)ndr_pull_security_descriptor),
+ "pull_security_descriptor failed");
if (p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
NDR_PRINT_DEBUG(security_descriptor, &sd);
return true;
}
-static bool test_CloseKey(struct dcerpc_pipe *p, struct torture_context *tctx,
+static bool test_CloseKey(struct dcerpc_pipe *p, struct torture_context *tctx,
struct policy_handle *handle)
{
struct winreg_CloseKey r;
r.in.handle = r.out.handle = handle;
torture_assert_ntstatus_ok(tctx, dcerpc_winreg_CloseKey(p, tctx, &r),
- "CloseKey failed");
+ "CloseKey failed");
torture_assert_werr_ok(tctx, r.out.result, "CloseKey failed");
return true;
}
-static bool test_FlushKey(struct dcerpc_pipe *p, struct torture_context *tctx,
+static bool test_FlushKey(struct dcerpc_pipe *p, struct torture_context *tctx,
struct policy_handle *handle)
{
struct winreg_FlushKey r;
r.in.handle = handle;
torture_assert_ntstatus_ok(tctx, dcerpc_winreg_FlushKey(p, tctx, &r),
- "FlushKey failed");
+ "FlushKey failed");
torture_assert_werr_ok(tctx, r.out.result, "FlushKey failed");
r.out.handle = key_handle;
torture_assert_ntstatus_ok(tctx, dcerpc_winreg_OpenKey(p, tctx, &r),
- "OpenKey failed");
+ "OpenKey failed");
torture_assert_werr_ok(tctx, r.out.result, "OpenKey failed");
struct winreg_DeleteKey r;
r.in.handle = handle;
- init_winreg_String(&r.in.key, key);
+ init_winreg_String(&r.in.key, key);
status = dcerpc_winreg_DeleteKey(p, tctx, &r);
/* DeleteKey on a key with subkey(s) should
* return WERR_ACCESS_DENIED. */
-static bool test_DeleteKeyWithSubkey(struct dcerpc_pipe *p,
+static bool test_DeleteKeyWithSubkey(struct dcerpc_pipe *p,
struct torture_context *tctx,
struct policy_handle *handle, const char *key)
{
init_winreg_String(&r.in.key, key);
torture_assert_ntstatus_ok(tctx, dcerpc_winreg_DeleteKey(p, tctx, &r),
- "DeleteKeyWithSubkey failed");
+ "DeleteKeyWithSubkey failed");
- torture_assert_werr_equal(tctx, r.out.result, WERR_ACCESS_DENIED,
- "DeleteKeyWithSubkey failed");
+ torture_assert_werr_equal(tctx, r.out.result, WERR_ACCESS_DENIED,
+ "DeleteKeyWithSubkey failed");
return true;
}
-static bool test_QueryInfoKey(struct dcerpc_pipe *p,
- struct torture_context *tctx,
+static bool test_QueryInfoKey(struct dcerpc_pipe *p,
+ struct torture_context *tctx,
struct policy_handle *handle, char *class)
{
struct winreg_QueryInfoKey r;
r.out.last_changed_time = &last_changed_time;
r.out.classname = talloc(tctx, struct winreg_String);
-
+
r.in.classname = talloc(tctx, struct winreg_String);
init_winreg_String(r.in.classname, class);
-
- torture_assert_ntstatus_ok(tctx,
+
+ torture_assert_ntstatus_ok(tctx,
dcerpc_winreg_QueryInfoKey(p, tctx, &r),
"QueryInfoKey failed");
torture_assert_ntstatus_ok(tctx, status, "EnumKey failed");
- if (!W_ERROR_IS_OK(r.out.result) &&
+ if (!W_ERROR_IS_OK(r.out.result) &&
!W_ERROR_EQUAL(r.out.result, WERR_NO_MORE_ITEMS)) {
torture_fail(tctx, "EnumKey failed");
}
return true;
}
-static bool test_QueryMultipleValues(struct dcerpc_pipe *p,
- struct torture_context *tctx,
- struct policy_handle *handle,
- const char *valuename)
+static bool test_QueryMultipleValues(struct dcerpc_pipe *p,
+ struct torture_context *tctx,
+ struct policy_handle *handle,
+ const char *valuename)
{
struct winreg_QueryMultipleValues r;
NTSTATUS status;
r.in.num_values = 1;
r.in.buffer_size = r.out.buffer_size = talloc(tctx, uint32_t);
*r.in.buffer_size = bufsize;
- do {
+ do {
*r.in.buffer_size = bufsize;
- r.in.buffer = r.out.buffer = talloc_zero_array(tctx, uint8_t,
+ r.in.buffer = r.out.buffer = talloc_zero_array(tctx, uint8_t,
*r.in.buffer_size);
status = dcerpc_winreg_QueryMultipleValues(p, tctx, &r);
-
+
if(NT_STATUS_IS_ERR(status))
torture_fail(tctx, "QueryMultipleValues failed");
return true;
}
-static bool test_QueryValue(struct dcerpc_pipe *p,
- struct torture_context *tctx,
- struct policy_handle *handle,
- const char *valuename)
+static bool test_QueryValue(struct dcerpc_pipe *p,
+ struct torture_context *tctx,
+ struct policy_handle *handle,
+ const char *valuename)
{
struct winreg_QueryValue r;
NTSTATUS status;
}
static bool test_EnumValue(struct dcerpc_pipe *p, struct torture_context *tctx,
- struct policy_handle *handle, int max_valnamelen, int max_valbufsize)
+ struct policy_handle *handle, int max_valnamelen,
+ int max_valbufsize)
{
struct winreg_EnumValue r;
enum winreg_Type type = 0;
r.in.value = &buf8;
r.in.length = &zero;
r.in.size = &size;
-
+
do {
torture_assert_ntstatus_ok(tctx, dcerpc_winreg_EnumValue(p, tctx, &r),
- "EnumValue failed");
+ "EnumValue failed");
if (W_ERROR_IS_OK(r.out.result)) {
ret &= test_QueryValue(p, tctx, handle, r.out.name->name);
return ret;
}
-static bool test_AbortSystemShutdown(struct dcerpc_pipe *p,
- struct torture_context *tctx)
+static bool test_AbortSystemShutdown(struct dcerpc_pipe *p,
+ struct torture_context *tctx)
{
struct winreg_AbortSystemShutdown r;
uint16_t server = 0x0;
r.in.server = &server;
-
- torture_assert_ntstatus_ok(tctx,
- dcerpc_winreg_AbortSystemShutdown(p, tctx, &r),
- "AbortSystemShutdown failed");
+
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_winreg_AbortSystemShutdown(p, tctx, &r),
+ "AbortSystemShutdown failed");
torture_assert_werr_ok(tctx, r.out.result, "AbortSystemShutdown failed");
return true;
}
-static bool test_InitiateSystemShutdown(struct torture_context *tctx,
+static bool test_InitiateSystemShutdown(struct torture_context *tctx,
struct dcerpc_pipe *p)
{
struct winreg_InitiateSystemShutdown r;
r.in.timeout = 30;
r.in.reboot = 1;
- torture_assert_ntstatus_ok(tctx,
- dcerpc_winreg_InitiateSystemShutdown(p, tctx, &r),
- "InitiateSystemShutdown failed");
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_winreg_InitiateSystemShutdown(p, tctx, &r),
+ "InitiateSystemShutdown failed");
torture_assert_werr_ok(tctx, r.out.result, "InitiateSystemShutdown failed");
static bool test_InitiateSystemShutdownEx(struct torture_context *tctx,
- struct dcerpc_pipe *p)
+ struct dcerpc_pipe *p)
{
struct winreg_InitiateSystemShutdownEx r;
uint16_t hostname = 0x0;
r.in.reboot = 1;
r.in.reason = 0;
- torture_assert_ntstatus_ok(tctx,
+ torture_assert_ntstatus_ok(tctx,
dcerpc_winreg_InitiateSystemShutdownEx(p, tctx, &r),
"InitiateSystemShutdownEx failed");
- torture_assert_werr_ok(tctx, r.out.result,
- "InitiateSystemShutdownEx failed");
+ torture_assert_werr_ok(tctx, r.out.result,
+ "InitiateSystemShutdownEx failed");
return test_AbortSystemShutdown(p, tctx);
}
#define MAX_DEPTH 2 /* Only go this far down the tree */
-static bool test_key(struct dcerpc_pipe *p, struct torture_context *tctx,
+static bool test_key(struct dcerpc_pipe *p, struct torture_context *tctx,
struct policy_handle *handle, int depth)
{
if (depth == MAX_DEPTH)
if (!test_NotifyChangeKeyValue(p, tctx, handle)) {
}
-
+
if (!test_GetKeySecurity(p, tctx, handle)) {
}
typedef NTSTATUS (*winreg_open_fn)(struct dcerpc_pipe *, TALLOC_CTX *, void *);
-static bool test_Open(struct torture_context *tctx, struct dcerpc_pipe *p,
+static bool test_Open(struct torture_context *tctx, struct dcerpc_pipe *p,
void *userdata)
{
struct policy_handle handle, newhandle;
r.in.system_name = 0;
r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
r.out.handle = &handle;
-
- torture_assert_ntstatus_ok(tctx, open_fn(p, tctx, &r),
- "open");
+
+ torture_assert_ntstatus_ok(tctx, open_fn(p, tctx, &r),
+ "open");
test_Cleanup(p, tctx, &handle, TEST_KEY1);
test_Cleanup(p, tctx, &handle, TEST_KEY2);
}
if (created && !test_OpenKey(p, tctx, &handle, TEST_KEY1, &newhandle))
- torture_fail(tctx,
- "CreateKey failed (OpenKey after Create didn't work)\n");
+ torture_fail(tctx,
+ "CreateKey failed (OpenKey after Create didn't work)\n");
if (created && !test_DeleteKey(p, tctx, &handle, TEST_KEY1)) {
torture_comment(tctx, "DeleteKey failed\n");
ret = false;
}
- if (created && deleted &&
+ if (created && deleted &&
test_OpenKey(p, tctx, &handle, TEST_KEY1, &newhandle)) {
- torture_comment(tctx,
- "DeleteKey failed (OpenKey after Delete worked)\n");
+ torture_comment(tctx,
+ "DeleteKey failed (OpenKey after Delete worked)\n");
ret = false;
}
ret = false;
}
- if (created && test_CreateKey_sd(p, tctx, &handle, TEST_KEY2,
- NULL, &newhandle)) {
+ if (created && test_CreateKey_sd(p, tctx, &handle, TEST_KEY2,
+ NULL, &newhandle)) {
created2 = true;
}
created3 = true;
}
- if (created3 &&
- test_CreateKey(p, tctx, &handle, TEST_SUBKEY, NULL))
+ if (created3 &&
+ test_CreateKey(p, tctx, &handle, TEST_SUBKEY, NULL))
{
created_subkey = true;
}
- if (created_subkey &&
- !test_DeleteKeyWithSubkey(p, tctx, &handle, TEST_KEY3))
+ if (created_subkey &&
+ !test_DeleteKeyWithSubkey(p, tctx, &handle, TEST_KEY3))
{
printf("DeleteKeyWithSubkey failed "
"(DeleteKey didn't return ACCESS_DENIED)\n");
ret = false;
}
- if (created_subkey &&
+ if (created_subkey &&
!test_DeleteKey(p, tctx, &handle, TEST_SUBKEY))
{
printf("DeleteKey failed\n");
struct torture_suite *suite = torture_suite_create(mem_ctx, "WINREG");
struct torture_test *test;
- tcase = torture_suite_add_rpc_iface_tcase(suite, "winreg",
+ tcase = torture_suite_add_rpc_iface_tcase(suite, "winreg",
&ndr_table_winreg);
- test = torture_rpc_tcase_add_test(tcase, "InitiateSystemShutdown",
+ test = torture_rpc_tcase_add_test(tcase, "InitiateSystemShutdown",
test_InitiateSystemShutdown);
test->dangerous = true;
- test = torture_rpc_tcase_add_test(tcase, "InitiateSystemShutdownEx",
+ test = torture_rpc_tcase_add_test(tcase, "InitiateSystemShutdownEx",
test_InitiateSystemShutdownEx);
test->dangerous = true;
for (i = 0; i < ARRAY_SIZE(open_fns); i++) {
- torture_rpc_tcase_add_test_ex(tcase, open_fns[i].name, test_Open,
- open_fns[i].fn);
+ torture_rpc_tcase_add_test_ex(tcase, open_fns[i].name,
+ test_Open, open_fns[i].fn);
}
return suite;
git.samba.org / jelmer / samba4-debian.git / commitdiff