summaryrefslogtreecommitdiff
path: root/source4/torture/rpc
diff options
context:
space:
mode:
Diffstat (limited to 'source4/torture/rpc')
-rw-r--r--source4/torture/rpc/atsvc.c102
-rw-r--r--source4/torture/rpc/dfs.c122
-rw-r--r--source4/torture/rpc/echo.c379
-rw-r--r--source4/torture/rpc/eventlog.c255
-rw-r--r--source4/torture/rpc/rpc.c173
-rw-r--r--source4/torture/rpc/rpc.h1
-rw-r--r--source4/torture/rpc/unixinfo.c65
-rw-r--r--source4/torture/rpc/wkssvc.c77
8 files changed, 545 insertions, 629 deletions
diff --git a/source4/torture/rpc/atsvc.c b/source4/torture/rpc/atsvc.c
index e586a1e98f..227e56a85b 100644
--- a/source4/torture/rpc/atsvc.c
+++ b/source4/torture/rpc/atsvc.c
@@ -24,7 +24,7 @@
#include "librpc/gen_ndr/ndr_atsvc_c.h"
#include "torture/rpc/rpc.h"
-static BOOL test_JobGetInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, uint32_t job_id)
+static bool test_JobGetInfo(struct dcerpc_pipe *p, struct torture_context *tctx, uint32_t job_id)
{
NTSTATUS status;
struct atsvc_JobGetInfo r;
@@ -32,17 +32,14 @@ static BOOL test_JobGetInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, uint32_t
r.in.servername = dcerpc_server_name(p);
r.in.job_id = job_id;
- status = dcerpc_atsvc_JobGetInfo(p, mem_ctx, &r);
+ status = dcerpc_atsvc_JobGetInfo(p, tctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("JobGetInfo failed - %s\n", nt_errstr(status));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, status, "JobGetInfo failed");
- return True;
+ return true;
}
-static BOOL test_JobDel(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, uint32_t min_job_id,
+static bool test_JobDel(struct dcerpc_pipe *p, struct torture_context *tctx, uint32_t min_job_id,
uint32_t max_job_id)
{
NTSTATUS status;
@@ -52,25 +49,20 @@ static BOOL test_JobDel(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, uint32_t min
r.in.min_job_id = min_job_id;
r.in.max_job_id = max_job_id;
- status = dcerpc_atsvc_JobDel(p, mem_ctx, &r);
+ status = dcerpc_atsvc_JobDel(p, tctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("JobDel failed - %s\n", nt_errstr(status));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, status, "JobDel failed");
- return True;
+ return true;
}
-static BOOL test_JobEnum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_JobEnum(struct torture_context *tctx, struct dcerpc_pipe *p)
{
NTSTATUS status;
struct atsvc_JobEnum r;
struct atsvc_enum_ctr ctr;
uint32_t resume_handle = 0, i;
- BOOL ret = True;
-
- printf("\ntesting JobEnum\n");
+ bool ret = true;
r.in.servername = dcerpc_server_name(p);
ctr.entries_read = 0;
@@ -79,15 +71,12 @@ static BOOL test_JobEnum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
r.in.preferred_max_len = 0xffffffff;
r.in.resume_handle = r.out.resume_handle = &resume_handle;
- status = dcerpc_atsvc_JobEnum(p, mem_ctx, &r);
+ status = dcerpc_atsvc_JobEnum(p, tctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("JobEnum failed - %s\n", nt_errstr(status));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, status, "JobEnum failed");
for (i = 0; i < r.out.ctr->entries_read; i++) {
- if (!test_JobGetInfo(p, mem_ctx, r.out.ctr->first_entry[i].job_id)) {
+ if (!test_JobGetInfo(p, tctx, r.out.ctr->first_entry[i].job_id)) {
ret = False;
}
}
@@ -95,14 +84,12 @@ static BOOL test_JobEnum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
return ret;
}
-static BOOL test_JobAdd(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_JobAdd(struct torture_context *tctx, struct dcerpc_pipe *p)
{
NTSTATUS status;
struct atsvc_JobAdd r;
struct atsvc_JobInfo info;
- printf("\ntesting JobAdd\n");
-
r.in.servername = dcerpc_server_name(p);
info.job_time = 0x050ae4c0; /* 11:30pm */
info.days_of_month = 0; /* n/a */
@@ -111,56 +98,39 @@ static BOOL test_JobAdd(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
info.command = "foo.exe";
r.in.job_info = &info;
- status = dcerpc_atsvc_JobAdd(p, mem_ctx, &r);
+ status = dcerpc_atsvc_JobAdd(p, tctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("JobAdd failed - %s\n", nt_errstr(status));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, status, "JobAdd failed");
/* Run EnumJobs again in case there were no jobs to begin with */
- if (!test_JobEnum(p, mem_ctx)) {
- return False;
+ if (!test_JobEnum(tctx, p)) {
+ return false;
}
- if (!test_JobGetInfo(p, mem_ctx, r.out.job_id)) {
- return False;
+ if (!test_JobGetInfo(p, tctx, r.out.job_id)) {
+ return false;
}
- if (!test_JobDel(p, mem_ctx, r.out.job_id, r.out.job_id)) {
- return False;
+ if (!test_JobDel(p, tctx, r.out.job_id, r.out.job_id)) {
+ return false;
}
- return True;
+ return true;
}
-BOOL torture_rpc_atsvc(struct torture_context *torture)
+struct torture_suite *torture_rpc_atsvc(void)
{
- NTSTATUS status;
- struct dcerpc_pipe *p;
- TALLOC_CTX *mem_ctx;
- BOOL ret = True;
-
- mem_ctx = talloc_init("torture_rpc_atsvc");
-
- status = torture_rpc_connection(mem_ctx, &p, &dcerpc_table_atsvc);
- if (!NT_STATUS_IS_OK(status)) {
- talloc_free(mem_ctx);
- return False;
- }
-
- if (!test_JobEnum(p, mem_ctx)) {
- talloc_free(mem_ctx);
- return False;
- }
-
- if (!test_JobAdd(p, mem_ctx)) {
- talloc_free(mem_ctx);
- return False;
- }
-
- talloc_free(mem_ctx);
-
- return ret;
+ struct torture_suite *suite = torture_suite_create(
+ talloc_autofree_context(),
+ "ATSVC");
+ struct torture_tcase *tcase;
+
+ tcase = torture_suite_add_rpc_iface_tcase(suite, "atsvc",
+ &dcerpc_table_atsvc);
+
+ torture_rpc_tcase_add_test(tcase, "JobEnum", test_JobEnum);
+ torture_rpc_tcase_add_test(tcase, "JobAdd", test_JobAdd);
+
+ return suite;
}
diff --git a/source4/torture/rpc/dfs.c b/source4/torture/rpc/dfs.c
index 3eebfc5e5d..6af65e4f44 100644
--- a/source4/torture/rpc/dfs.c
+++ b/source4/torture/rpc/dfs.c
@@ -30,6 +30,8 @@
#include "libcli/libcli.h"
#include "lib/cmdline/popt_common.h"
+#if 0
+
#define SMBTORTURE_DFS_SHARENAME "smbtorture_dfs_share"
#define SMBTORTURE_DFS_DIRNAME "\\smbtorture_dfs_dir"
#define SMBTORTURE_DFS_PATHNAME "C:"SMBTORTURE_DFS_DIRNAME
@@ -139,23 +141,20 @@ static BOOL test_DeleteDir(struct smbcli_state *cli, const char *dir)
return True;
}
-static BOOL test_GetManagerVersion(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, enum dfs_ManagerVersion *version)
+static BOOL test_GetManagerVersion(struct torture_context *tctx, struct dcerpc_pipe *p, enum dfs_ManagerVersion *version)
{
NTSTATUS status;
struct dfs_GetManagerVersion r;
r.out.version = version;
- status = dcerpc_dfs_GetManagerVersion(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("GetManagerVersion failed - %s\n", nt_errstr(status));
- return False;
- }
+ status = dcerpc_dfs_GetManagerVersion(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "GetManagerVersion failed");
- return True;
+ return true;
}
-static BOOL test_ManagerInitialize(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, const char *host)
+static BOOL test_ManagerInitialize(struct torture_context *tctx, struct dcerpc_pipe *p, const char *host)
{
NTSTATUS status;
enum dfs_ManagerVersion version;
@@ -163,14 +162,14 @@ static BOOL test_ManagerInitialize(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, c
printf("Testing ManagerInitialize\n");
- if (!test_GetManagerVersion(p, mem_ctx, &version)) {
+ if (!test_GetManagerVersion(tctx, p, &version)) {
return False;
}
r.in.servername = host;
r.in.flags = 0;
- status = dcerpc_dfs_ManagerInitialize(p, mem_ctx, &r);
+ status = dcerpc_dfs_ManagerInitialize(p, tctx, &r);
if (!NT_STATUS_IS_OK(status)) {
printf("ManagerInitialize failed - %s\n", nt_errstr(status));
return False;
@@ -183,33 +182,31 @@ static BOOL test_ManagerInitialize(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, c
return True;
}
-static BOOL test_GetInfoLevel(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, uint16_t level,
- const char *root)
+static BOOL test_GetInfoLevel(struct torture_context *tctx, struct dcerpc_pipe *p, uint16_t level, const char *root)
{
NTSTATUS status;
struct dfs_GetInfo r;
- printf("Testing GetInfo level %u on '%s'\n", level, root);
+ torture_comment(tctx,
+ talloc_asprintf(tctx, "Testing GetInfo level %u on '%s'\n", level, root));
- r.in.dfs_entry_path = talloc_strdup(mem_ctx, root);
+ r.in.dfs_entry_path = talloc_strdup(tctx, root);
r.in.servername = NULL;
r.in.sharename = NULL;
r.in.level = level;
- status = dcerpc_dfs_GetInfo(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("GetInfo failed - %s\n", nt_errstr(status));
- return False;
- } else if (!W_ERROR_IS_OK(r.out.result) &&
- !W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, r.out.result)) {
- printf("dfs_GetInfo failed - %s\n", win_errstr(r.out.result));
- return False;
- }
+ status = dcerpc_dfs_GetInfo(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "Info failed");
+ torture_assert(tctx, W_ERROR_IS_OK(r.out.result) ||
+ W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, r.out.result),
+ talloc_asprintf(tctx,
+ "dfs_GetInfo failed - %s", win_errstr(r.out.result)));
return True;
}
-static BOOL test_GetInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, const char *root)
+static bool test_Info(struct torture_context *tctx,
+ struct dcerpc_pipe *p, const char *root)
{
BOOL ret = True;
/* 103, 104, 105, 106 is only available on Set */
@@ -217,14 +214,15 @@ static BOOL test_GetInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, const char
int i;
for (i=0;i<ARRAY_SIZE(levels);i++) {
- if (!test_GetInfoLevel(p, mem_ctx, levels[i], root)) {
- ret = False;
+ if (!test_GetInfoLevel(tctx, p, levels[i], root)) {
+ ret = false;
}
}
return ret;
}
-static BOOL test_EnumLevelEx(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, uint16_t level, const char *dfs_name)
+static bool test_EnumLevel(struct torture_context *tctx,
+ struct dcerpc_pipe *p, uint16_t level)
{
NTSTATUS status;
struct dfs_EnumEx rex;
@@ -305,23 +303,18 @@ static BOOL test_EnumLevel(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, uint16_t
e.e.info1->s = &s;
s.path = NULL;
- printf("Testing Enum level %u\n", level);
-
- status = dcerpc_dfs_Enum(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("Enum failed - %s\n", nt_errstr(status));
- return False;
- } else if (!W_ERROR_IS_OK(r.out.result) &&
- !W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, r.out.result)) {
- printf("dfs_Enum failed - %s\n", win_errstr(r.out.result));
- return False;
- }
+ status = dcerpc_dfs_Enum(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "Enum failed - %s\n",
+ nt_errstr(status));
+ torture_assert(tctx, W_ERROR_IS_OK(r.out.result) ||
+ W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, r.out.result),
+ "dfs_Enum failed - %s", win_errstr(r.out.result));
if (level == 1 && r.out.total) {
int i;
for (i=0;i<*r.out.total;i++) {
const char *root = r.out.info->e.info1->s[i].path;
- if (!test_GetInfo(p, mem_ctx, root)) {
+ if (!test_GetInfo(tctx, p, root)) {
ret = False;
}
}
@@ -332,15 +325,16 @@ static BOOL test_EnumLevel(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, uint16_t
}
-static BOOL test_Enum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_Enum(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
BOOL ret = True;
uint16_t levels[] = {1, 2, 3, 4, 200, 300};
int i;
for (i=0;i<ARRAY_SIZE(levels);i++) {
- if (!test_EnumLevel(p, mem_ctx, levels[i])) {
- ret = False;
+ if (!test_EnumLevel(tctx, p, levels[i])) {
+ ret = false;
}
}
@@ -481,31 +475,35 @@ static BOOL test_StdRoot(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, const char
return ret;
}
-BOOL torture_rpc_dfs(struct torture_context *torture)
+#endif
+
+struct torture_suite *torture_rpc_dfs(void)
{
- NTSTATUS status;
- struct dcerpc_pipe *p;
- TALLOC_CTX *mem_ctx;
- BOOL ret = True;
- enum dfs_ManagerVersion version;
- const char *host = lp_parm_string(-1, "torture", "host");
+ struct torture_suite *suite = torture_suite_create(
+ talloc_autofree_context(), "RPC-DFS");
- mem_ctx = talloc_init("torture_rpc_dfs");
+#if 0
+ struct torture_tcase *tcase = torture_suite_add_rpc_iface_tcase(suite,
+ "dfs", &dcerpc_table_netdfs);
- status = torture_rpc_connection(mem_ctx,
- &p,
- &dcerpc_table_netdfs);
- if (!NT_STATUS_IS_OK(status)) {
- return False;
- }
+ torture_rpc_tcase_add_test(tcase, "GetManagerVersion",
+ test_GetManagerVersion);
- ret &= test_GetManagerVersion(p, mem_ctx, &version);
- ret &= test_ManagerInitialize(p, mem_ctx, host);
- ret &= test_Enum(p, mem_ctx);
- ret &= test_EnumEx(p, mem_ctx, host);
- ret &= test_StdRoot(p, mem_ctx, host);
+#if 0
+ torture_rpc_tcase_add_test(tcase, "Add",
+ test_Add);
+#endif
+
+ torture_rpc_tcase_add_test(tcase, "Enum", test_Enum);
+ torture_rpc_tcase_add_test(tcase, "EnumEx", test_EnumEx);
+ torture_rpc_tcase_add_test(tcase, "ManagerInitialize",
+ test_ManagerInitialize);
+ torture_rpc_tcase_add_test(tcase, "StdRoot",
+ test_StdRoot);
talloc_free(mem_ctx);
- return ret;
+#endif
+
+ return suite;
}
diff --git a/source4/torture/rpc/echo.c b/source4/torture/rpc/echo.c
index 02f255e5f8..fef9eb8c2b 100644
--- a/source4/torture/rpc/echo.c
+++ b/source4/torture/rpc/echo.c
@@ -31,49 +31,40 @@
/*
test the AddOne interface
*/
-#define TEST_ADDONE(value) do { \
+#define TEST_ADDONE(tctx, value) do { \
n = i = value; \
r.in.in_data = n; \
r.out.out_data = &n; \
- status = dcerpc_echo_AddOne(p, mem_ctx, &r); \
- if (!NT_STATUS_IS_OK(status)) { \
- printf("AddOne(%d) failed - %s\n", i, nt_errstr(status)); \
- return False; \
- } \
- if (n != i+1) { \
- printf("%d + 1 != %u (should be %u)\n", i, n, i+1); \
- ret = False; \
- } else { \
- printf("%d + 1 = %u\n", i, n); \
- } \
+ status = dcerpc_echo_AddOne(p, tctx, &r); \
+ torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx, "AddOne(%d) failed", i)); \
+ torture_assert (tctx, n == i+1, talloc_asprintf(tctx, "%d + 1 != %u (should be %u)\n", i, n, i+1)); \
+ torture_comment (tctx, "%d + 1 = %u\n", i, n); \
} while(0)
-static BOOL test_addone(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_addone(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
- BOOL ret = True;
uint32_t i;
NTSTATUS status;
uint32_t n;
struct echo_AddOne r;
- printf("\nTesting AddOne\n");
-
for (i=0;i<10;i++) {
- TEST_ADDONE(i);
+ TEST_ADDONE(tctx, i);
}
- TEST_ADDONE(0x7FFFFFFE);
- TEST_ADDONE(0xFFFFFFFE);
- TEST_ADDONE(0xFFFFFFFF);
- TEST_ADDONE(random() & 0xFFFFFFFF);
-
- return ret;
+ TEST_ADDONE(tctx, 0x7FFFFFFE);
+ TEST_ADDONE(tctx, 0xFFFFFFFE);
+ TEST_ADDONE(tctx, 0xFFFFFFFF);
+ TEST_ADDONE(tctx, random() & 0xFFFFFFFF);
+ return true;
}
/*
test the EchoData interface
*/
-static BOOL test_echodata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_echodata(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
int i;
NTSTATUS status;
@@ -81,17 +72,15 @@ static BOOL test_echodata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
int len;
struct echo_EchoData r;
- if (lp_parm_bool(-1, "torture", "quick", False) &&
+ if (torture_setting_bool(tctx, "quick", false) &&
(p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {
len = 1 + (random() % 500);
} else {
len = 1 + (random() % 5000);
}
- printf("\nTesting EchoData\n");
-
- data_in = talloc_size(mem_ctx, len);
- data_out = talloc_size(mem_ctx, len);
+ data_in = talloc_size(tctx, len);
+ data_out = talloc_size(tctx, len);
for (i=0;i<len;i++) {
data_in[i] = i;
}
@@ -99,73 +88,64 @@ static BOOL test_echodata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
r.in.len = len;
r.in.in_data = data_in;
- status = dcerpc_echo_EchoData(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("EchoData(%d) failed - %s\n", len, nt_errstr(status));
- return False;
- }
+ status = dcerpc_echo_EchoData(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx,
+ "EchoData(%d) failed\n", len));
data_out = r.out.out_data;
for (i=0;i<len;i++) {
if (data_in[i] != data_out[i]) {
- printf("Bad data returned for len %d at offset %d\n",
+ torture_comment(tctx, "Bad data returned for len %d at offset %d\n",
len, i);
- printf("in:\n");
+ torture_comment(tctx, "in:\n");
dump_data(0, data_in+i, MIN(len-i, 16));
- printf("out:\n");
+ torture_comment(tctx, "out:\n");
dump_data(0, data_out+i, MIN(len-1, 16));
- return False;
+ return false;
}
}
-
-
- return True;
+ return true;
}
-
/*
test the SourceData interface
*/
-static BOOL test_sourcedata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_sourcedata(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
int i;
NTSTATUS status;
int len;
struct echo_SourceData r;
- if (lp_parm_bool(-1, "torture", "quick", False) &&
+ if (torture_setting_bool(tctx, "quick", false) &&
(p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {
len = 100 + (random() % 500);
} else {
len = 200000 + (random() % 5000);
}
- printf("\nTesting SourceData\n");
-
r.in.len = len;
- status = dcerpc_echo_SourceData(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("SourceData(%d) failed - %s\n", len, nt_errstr(status));
- return False;
- }
+ status = dcerpc_echo_SourceData(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx,
+ "SourceData(%d) failed", len));
for (i=0;i<len;i++) {
uint8_t *v = (uint8_t *)r.out.data;
- if (v[i] != (i & 0xFF)) {
- printf("bad data 0x%x at %d\n", (uint8_t)r.out.data[i], i);
- return False;
- }
+ torture_assert(tctx, v[i] == (i & 0xFF),
+ talloc_asprintf(tctx,
+ "bad data 0x%x at %d\n", (uint8_t)r.out.data[i], i));
}
-
- return True;
+ return true;
}
/*
test the SinkData interface
*/
-static BOOL test_sinkdata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_sinkdata(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
int i;
NTSTATUS status;
@@ -173,16 +153,14 @@ static BOOL test_sinkdata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
int len;
struct echo_SinkData r;
- if (lp_parm_bool(-1, "torture", "quick", False) &&
+ if (torture_setting_bool(tctx, "quick", false) &&
(p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {
len = 100 + (random() % 5000);
} else {
len = 200000 + (random() % 5000);
}
- printf("\nTesting SinkData\n");
-
- data_in = talloc_size(mem_ctx, len);
+ data_in = talloc_size(tctx, len);
for (i=0;i<len;i++) {
data_in[i] = i+1;
}
@@ -190,74 +168,63 @@ static BOOL test_sinkdata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
r.in.len = len;
r.in.data = data_in;
- status = dcerpc_echo_SinkData(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("SinkData(%d) failed - %s\n", len, nt_errstr(status));
- return False;
- }
-
- printf("sunk %d bytes\n", len);
+ status = dcerpc_echo_SinkData(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx,
+ "SinkData(%d) failed",
+ len));
- return True;
+ torture_comment(tctx, "sunk %d bytes\n", len);
+ return true;
}
/*
test the testcall interface
*/
-static BOOL test_testcall(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_testcall(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
NTSTATUS status;
struct echo_TestCall r;
- char *s = NULL;
+ const char *s = NULL;
r.in.s1 = "input string";
r.out.s2 = &s;
- printf("\nTesting TestCall\n");
- status = dcerpc_echo_TestCall(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("TestCall failed - %s\n", nt_errstr(status));
- return False;
- }
+ status = dcerpc_echo_TestCall(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "TestCall failed");
- if (!strcmp(s, "input string")) {
- printf("Didn't receive back same string\n");
- return False;
- }
+ torture_assert_str_equal(tctx, s, "input string", "Didn't receive back same string");
- return True;
+ return true;
}
/*
test the testcall interface
*/
-static BOOL test_testcall2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_testcall2(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
NTSTATUS status;
struct echo_TestCall2 r;
int i;
- BOOL ret = True;
for (i=1;i<=7;i++) {
r.in.level = i;
- r.out.info = talloc(mem_ctx, union echo_Info);
+ r.out.info = talloc(tctx, union echo_Info);
- printf("\nTesting TestCall2 level %d\n", i);
- status = dcerpc_echo_TestCall2(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("TestCall2 failed - %s\n", nt_errstr(status));
- ret = False;
- }
+ torture_comment(tctx, "Testing TestCall2 level %d\n", i);
+ status = dcerpc_echo_TestCall2(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "TestCall2 failed");
}
-
- return ret;
+ return true;
}
/*
test the TestSleep interface
*/
-static BOOL test_sleep(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_sleep(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
int i;
NTSTATUS status;
@@ -270,31 +237,25 @@ static BOOL test_sleep(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
struct timeval diff[ASYNC_COUNT];
struct event_context *ctx;
int total_done = 0;
- BOOL ret = True;
- if (lp_parm_bool(-1, "torture", "quick", False)) {
- printf("TestSleep disabled - use \"torture:quick=no\" to enable\n");
- return True;
+ if (torture_setting_bool(tctx, "quick", false)) {
+ torture_skip(tctx, "TestSleep disabled - use \"torture:quick=no\" to enable\n");
}
- printf("Testing TestSleep - use \"torture:quick=no\" to disable\n");
+ torture_comment(tctx, "Testing TestSleep - use \"torture:quick=no\" to disable\n");
for (i=0;i<ASYNC_COUNT;i++) {
done[i] = False;
snd[i] = timeval_current();
rcv[i] = timeval_zero();
r[i].in.seconds = ASYNC_COUNT-i;
- req[i] = dcerpc_echo_TestSleep_send(p, mem_ctx, &r[i]);
- if (!req[i]) {
- printf("Failed to send async sleep request\n");
- return False;
- }
+ req[i] = dcerpc_echo_TestSleep_send(p, tctx, &r[i]);
+ torture_assert(tctx, req[i], "Failed to send async sleep request\n");
}
ctx = dcerpc_event_context(p);
while (total_done < ASYNC_COUNT) {
- if (event_loop_once(ctx) != 0) {
- return False;
- }
+ torture_assert(tctx, event_loop_once(ctx) == 0,
+ "Event context loop failed");
for (i=0;i<ASYNC_COUNT;i++) {
if (done[i] == False && req[i]->state == RPC_REQUEST_DONE) {
total_done++;
@@ -302,46 +263,39 @@ static BOOL test_sleep(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
rcv[i] = timeval_current();
diff[i] = timeval_until(&snd[i], &rcv[i]);
status = dcerpc_ndr_request_recv(req[i]);
- if (!NT_STATUS_IS_OK(status)) {
- printf("TestSleep(%d) failed - %s\n",
- i, nt_errstr(status));
- ret = False;
- } else if (r[i].out.result != r[i].in.seconds) {
- printf("Failed - Asked to sleep for %u seconds (server replied with %u seconds and the reply takes only %u seconds)\n",
- r[i].out.result, r[i].in.seconds, (uint_t)diff[i].tv_sec);
- ret = False;
+ torture_assert_ntstatus_ok(tctx, status,
+ talloc_asprintf(tctx, "TestSleep(%d) failed", i));
+ torture_assert(tctx, r[i].out.result == r[i].in.seconds,
+ talloc_asprintf(tctx, "Failed - Asked to sleep for %u seconds (server replied with %u seconds and the reply takes only %u seconds)",
+ r[i].out.result, r[i].in.seconds, (uint_t)diff[i].tv_sec));
+ torture_assert(tctx, r[i].out.result <= diff[i].tv_sec,
+ talloc_asprintf(tctx, "Failed - Slept for %u seconds (but reply takes only %u.%06u seconds)",
+ r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec));
+ if (r[i].out.result+1 == diff[i].tv_sec) {
+ torture_comment(tctx, "Slept for %u seconds (but reply takes %u.%06u seconds - busy server?)\n",
+ r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec);
+ } else if (r[i].out.result == diff[i].tv_sec) {
+ torture_comment(tctx, "Slept for %u seconds (reply takes %u.%06u seconds - ok)\n",
+ r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec);
} else {
- if (r[i].out.result > diff[i].tv_sec) {
- printf("Failed - Slept for %u seconds (but reply takes only %u.%06u seconds)\n",
- r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec);
- } else if (r[i].out.result+1 == diff[i].tv_sec) {
- printf("Slept for %u seconds (but reply takes %u.%06u seconds - busy server?)\n",
- r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec);
- } else if (r[i].out.result == diff[i].tv_sec) {
- printf("Slept for %u seconds (reply takes %u.%06u seconds - ok)\n",
- r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec);
- } else {
- printf("(Failed) - Not async - Slept for %u seconds (but reply takes %u.%06u seconds)\n",
- r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec);
- /* TODO: let the test fail here, when we support async rpc on ncacn_np
- ret = False;*/
- }
+ torture_comment(tctx, "(Failed) - Not async - Slept for %u seconds (but reply takes %u.%06u seconds)",
+ r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec);
+ /* TODO: let the test fail here, when we support async rpc on ncacn_np */
}
}
}
}
-
- return ret;
+ return true;
}
/*
test enum handling
*/
-static BOOL test_enum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_enum(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
NTSTATUS status;
struct echo_TestEnum r;
- BOOL ret = True;
enum echo_Enum1 v = ECHO_ENUM1;
struct echo_Enum2 e2;
union echo_Enum3 e3;
@@ -357,56 +311,45 @@ static BOOL test_enum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
e2.e2 = ECHO_ENUM1_32;
e3.e1 = ECHO_ENUM2;
- printf("\nTesting TestEnum\n");
- status = dcerpc_echo_TestEnum(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("TestEnum failed - %s\n", nt_errstr(status));
- ret = False;
- }
-
- return ret;
+ status = dcerpc_echo_TestEnum(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "TestEnum failed");
+ return true;
}
/*
test surrounding conformant array handling
*/
-static BOOL test_surrounding(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_surrounding(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
NTSTATUS status;
struct echo_TestSurrounding r;
- BOOL ret = True;
ZERO_STRUCT(r);
- r.in.data = talloc(mem_ctx, struct echo_Surrounding);
+ r.in.data = talloc(tctx, struct echo_Surrounding);
r.in.data->x = 20;
- r.in.data->surrounding = talloc_zero_array(mem_ctx, uint16_t, r.in.data->x);
+ r.in.data->surrounding = talloc_zero_array(tctx, uint16_t, r.in.data->x);
- r.out.data = talloc(mem_ctx, struct echo_Surrounding);
+ r.out.data = talloc(tctx, struct echo_Surrounding);
- printf("\nTesting TestSurrounding\n");
- status = dcerpc_echo_TestSurrounding(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("TestSurrounding failed - %s\n", nt_errstr(status));
- return False;
- }
+ status = dcerpc_echo_TestSurrounding(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "TestSurrounding failed");
- if (r.out.data->x != 2 * r.in.data->x) {
- printf("TestSurrounding did not make the array twice as large\n");
- ret = False;
- }
+ torture_assert(tctx, r.out.data->x == 2 * r.in.data->x,
+ "TestSurrounding did not make the array twice as large");
- return ret;
+ return true;
}
/*
test multiple levels of pointers
*/
-static BOOL test_doublepointer(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_doublepointer(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
NTSTATUS status;
struct echo_TestDoublePointer r;
- BOOL ret = True;
uint16_t value = 12;
uint16_t *pvalue = &value;
uint16_t **ppvalue = &pvalue;
@@ -414,112 +357,88 @@ static BOOL test_doublepointer(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
ZERO_STRUCT(r);
r.in.data = &ppvalue;
- printf("\nTesting TestDoublePointer\n");
- status = dcerpc_echo_TestDoublePointer(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("TestDoublePointer failed - %s\n", nt_errstr(status));
- ret = False;
- }
+ status = dcerpc_echo_TestDoublePointer(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "TestDoublePointer failed");
- if (value != r.out.result) {
- printf("TestDoublePointer did not return original value (%d != %d)\n", value, r.out.result);
- ret = False;
- }
-
- return ret;
+ torture_assert_int_equal(tctx, value, r.out.result,
+ "TestDoublePointer did not return original value");
+ return true;
}
/*
test request timeouts
*/
-static BOOL test_timeout(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_timeout(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
NTSTATUS status;
struct rpc_request *req;
struct echo_TestSleep r;
int timeout_saved = p->request_timeout;
- if (lp_parm_bool(-1, "torture", "quick", False)) {
- printf("timeout testing disabled - use \"torture:quick=no\" to enable\n");
- return True;
+ if (torture_setting_bool(tctx, "quick", false)) {
+ torture_skip(tctx, "timeout testing disabled - use \"torture:quick=no\" to enable\n");
}
- printf("testing request timeouts\n");
+ torture_comment(tctx, "testing request timeouts\n");
r.in.seconds = 2;
p->request_timeout = 1;
- req = dcerpc_echo_TestSleep_send(p, mem_ctx, &r);
- if (!req) {
- printf("Failed to send async sleep request\n");
- goto failed;
- }
+ torture_assert(tctx, req = dcerpc_echo_TestSleep_send(p, tctx, &r),
+ "Failed to send async sleep request");
status = dcerpc_ndr_request_recv(req);
- if (!NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
- printf("request should have timed out - %s\n", nt_errstr(status));
- goto failed;
- }
+ torture_assert_ntstatus_equal(tctx, status, NT_STATUS_IO_TIMEOUT,
+ "request should have timed out");
- printf("testing request destruction\n");
- req = dcerpc_echo_TestSleep_send(p, mem_ctx, &r);
+ torture_comment(tctx, "testing request destruction\n");
+ req = dcerpc_echo_TestSleep_send(p, tctx, &r);
if (!req) {
- printf("Failed to send async sleep request\n");
+ torture_comment(tctx, "Failed to send async sleep request\n");
goto failed;
}
talloc_free(req);
- req = dcerpc_echo_TestSleep_send(p, mem_ctx, &r);
+ req = dcerpc_echo_TestSleep_send(p, tctx, &r);
if (!req) {
- printf("Failed to send async sleep request\n");
+ torture_comment(tctx, "Failed to send async sleep request\n");
goto failed;
}
status = dcerpc_ndr_request_recv(req);
- if (!NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
- printf("request should have timed out - %s\n", nt_errstr(status));
- goto failed;
- }
+ torture_assert_ntstatus_equal(tctx, status, NT_STATUS_IO_TIMEOUT,
+ "request should have timed out");
p->request_timeout = timeout_saved;
- return test_addone(p, mem_ctx);
+
+ return test_addone(tctx, p);
failed:
p->request_timeout = timeout_saved;
- return False;
+ return false;
}
-BOOL torture_rpc_echo(struct torture_context *torture)
+struct torture_suite *torture_rpc_echo(void)
{
- NTSTATUS status;
- struct dcerpc_pipe *p;
- TALLOC_CTX *mem_ctx;
- BOOL ret = True;
-
- mem_ctx = talloc_init("torture_rpc_echo");
-
- status = torture_rpc_connection(mem_ctx,
- &p,
- &dcerpc_table_rpcecho);
- if (!NT_STATUS_IS_OK(status)) {
- return False;
- }
-
- ret &= test_addone(p, mem_ctx);
- ret &= test_sinkdata(p, mem_ctx);
- ret &= test_echodata(p, mem_ctx);
- ret &= test_sourcedata(p, mem_ctx);
- ret &= test_testcall(p, mem_ctx);
- ret &= test_testcall2(p, mem_ctx);
- ret &= test_enum(p, mem_ctx);
- ret &= test_surrounding(p, mem_ctx);
- ret &= test_doublepointer(p, mem_ctx);
- ret &= test_sleep(p, mem_ctx);
- ret &= test_timeout(p, mem_ctx);
-
- printf("\n");
-
- talloc_free(mem_ctx);
-
- return ret;
+ struct torture_suite *suite = torture_suite_create(
+ talloc_autofree_context(), "ECHO");
+ struct torture_tcase *tcase;
+
+ tcase = torture_suite_add_rpc_iface_tcase(suite, "echo",
+ &dcerpc_table_rpcecho);
+
+ torture_rpc_tcase_add_test(tcase, "addone", test_addone);
+ torture_rpc_tcase_add_test(tcase, "sinkdata", test_sinkdata);
+ torture_rpc_tcase_add_test(tcase, "echodata", test_echodata);
+ torture_rpc_tcase_add_test(tcase, "sourcedata", test_sourcedata);
+ torture_rpc_tcase_add_test(tcase, "testcall", test_testcall);
+ torture_rpc_tcase_add_test(tcase, "testcall2", test_testcall2);
+ torture_rpc_tcase_add_test(tcase, "enum", test_enum);
+ torture_rpc_tcase_add_test(tcase, "surrounding", test_surrounding);
+ torture_rpc_tcase_add_test(tcase, "doublepointer", test_doublepointer);
+ torture_rpc_tcase_add_test(tcase, "sleep", test_sleep);
+ torture_rpc_tcase_add_test(tcase, "timeout", test_timeout);
+
+ return suite;
}
diff --git a/source4/torture/rpc/eventlog.c b/source4/torture/rpc/eventlog.c
index 381b34a49c..3ecc1a422b 100644
--- a/source4/torture/rpc/eventlog.c
+++ b/source4/torture/rpc/eventlog.c
@@ -34,38 +34,72 @@ static void init_lsa_String(struct lsa_String *name, const char *s)
name->size = name->length;
}
-static BOOL test_GetNumRecords(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
- struct policy_handle *handle)
+static bool get_policy_handle(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle)
+{
+ struct eventlog_OpenEventLogW r;
+ struct eventlog_OpenUnknown0 unknown0;
+
+ unknown0.unknown0 = 0x005c;
+ unknown0.unknown1 = 0x0001;
+
+ r.in.unknown0 = &unknown0;
+ init_lsa_String(&r.in.logname, "dns server");
+ init_lsa_String(&r.in.servername, NULL);
+ r.in.unknown2 = 0x00000001;
+ r.in.unknown3 = 0x00000001;
+ r.out.handle = handle;
+
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_eventlog_OpenEventLogW(p, tctx, &r),
+ "OpenEventLog failed");
+
+ torture_assert_ntstatus_ok(tctx, r.out.result, "OpenEventLog failed");
+
+ return true;
+}
+
+
+
+static bool test_GetNumRecords(struct torture_context *tctx, struct dcerpc_pipe *p)
{
- NTSTATUS status;
struct eventlog_GetNumRecords r;
+ struct eventlog_CloseEventLog cr;
+ struct policy_handle handle;
- printf("\ntesting GetNumRecords\n");
+ if (!get_policy_handle(tctx, p, &handle))
+ return false;
- r.in.handle = handle;
+ r.in.handle = &handle;
- status = dcerpc_eventlog_GetNumRecords(p, mem_ctx, &r);
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_eventlog_GetNumRecords(p, tctx, &r),
+ "GetNumRecords failed");
- if (!NT_STATUS_IS_OK(status)) {
- printf("GetNumRecords failed - %s\n", nt_errstr(status));
- return False;
- }
+ torture_comment(tctx, talloc_asprintf(tctx, "%d records\n", r.out.number));
- printf("%d records\n", r.out.number);
+ cr.in.handle = cr.out.handle = &handle;
- return True;
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_eventlog_CloseEventLog(p, tctx, &cr),
+ "CloseEventLog failed");
+ return true;
}
-static BOOL test_ReadEventLog(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
- struct policy_handle *handle)
+static bool test_ReadEventLog(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
NTSTATUS status;
struct eventlog_ReadEventLogW r;
+ struct eventlog_CloseEventLog cr;
+ struct policy_handle handle;
- printf("\ntesting ReadEventLog\n");
+ if (!get_policy_handle(tctx, p, &handle))
+ return false;
r.in.offset = 0;
- r.in.handle = handle;
+ r.in.handle = &handle;
r.in.flags = EVENTLOG_BACKWARDS_READ|EVENTLOG_SEQUENTIAL_READ;
while (1) {
@@ -78,185 +112,142 @@ static BOOL test_ReadEventLog(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
r.in.number_of_bytes = 0;
r.out.data = NULL;
- status = dcerpc_eventlog_ReadEventLogW(p, mem_ctx, &r);
+ status = dcerpc_eventlog_ReadEventLogW(p, tctx, &r);
if (NT_STATUS_EQUAL(r.out.result, NT_STATUS_END_OF_FILE)) {
break;
}
- if (!NT_STATUS_EQUAL(r.out.result, NT_STATUS_BUFFER_TOO_SMALL)) {
- printf("ReadEventLog failed - %s\n", nt_errstr(r.out.result));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, status, "ReadEventLog failed");
+
+ torture_assert_ntstatus_equal(tctx, r.out.result, NT_STATUS_BUFFER_TOO_SMALL,
+ "ReadEventLog failed");
/* Now read the actual record */
r.in.number_of_bytes = r.out.real_size;
- r.out.data = talloc_size(mem_ctx, r.in.number_of_bytes);
+ r.out.data = talloc_size(tctx, r.in.number_of_bytes);
- status = dcerpc_eventlog_ReadEventLogW(p, mem_ctx, &r);
+ status = dcerpc_eventlog_ReadEventLogW(p, tctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("ReadEventLog failed - %s\n", nt_errstr(status));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, status, "ReadEventLog failed");
/* Decode a user-marshalled record */
blob.length = r.out.sent_size;
- blob.data = talloc_steal(mem_ctx, r.out.data);
+ blob.data = talloc_steal(tctx, r.out.data);
- ndr = ndr_pull_init_blob(&blob, mem_ctx);
+ ndr = ndr_pull_init_blob(&blob, tctx);
status = ndr_pull_eventlog_Record(
ndr, NDR_SCALARS|NDR_BUFFERS, &rec);
NDR_PRINT_DEBUG(eventlog_Record, &rec);
- if (!NT_STATUS_IS_OK(status)) {
- printf("ReadEventLog failed parsing event log record "
- "- %s\n", nt_errstr(status));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, status,
+ "ReadEventLog failed parsing event log record");
r.in.offset++;
}
- return True;
-}
-
-static BOOL test_CloseEventLog(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
- struct policy_handle *handle)
-{
- NTSTATUS status;
- struct eventlog_CloseEventLog r;
+ cr.in.handle = cr.out.handle = &handle;
- r.in.handle = r.out.handle = handle;
-
- printf("Testing CloseEventLog\n");
-
- status = dcerpc_eventlog_CloseEventLog(p, mem_ctx, &r);
-
- if (!NT_STATUS_IS_OK(status)) {
- printf("CloseEventLog failed - %s\n", nt_errstr(status));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_eventlog_CloseEventLog(p, tctx, &cr),
+ "CloseEventLog failed");
- return True;
+ return true;
}
-static BOOL test_FlushEventLog(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
- struct policy_handle *handle)
+static bool test_FlushEventLog(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
- NTSTATUS status;
struct eventlog_FlushEventLog r;
+ struct eventlog_CloseEventLog cr;
+ struct policy_handle handle;
- r.in.handle = handle;
-
- printf("Testing FlushEventLog\n");
+ if (!get_policy_handle(tctx, p, &handle))
+ return false;
- status = dcerpc_eventlog_FlushEventLog(p, mem_ctx, &r);
+ r.in.handle = &handle;
/* Huh? Does this RPC always return access denied? */
+ torture_assert_ntstatus_equal(tctx,
+ dcerpc_eventlog_FlushEventLog(p, tctx, &r),
+ NT_STATUS_ACCESS_DENIED,
+ "FlushEventLog failed");
- if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
- printf("FlushEventLog failed - %s\n", nt_errstr(status));
- return False;
- }
+ cr.in.handle = cr.out.handle = &handle;
+
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_eventlog_CloseEventLog(p, tctx, &cr),
+ "CloseEventLog failed");
- return True;
+ return true;
}
-static BOOL test_ClearEventLog(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
- struct policy_handle *handle)
+static bool test_ClearEventLog(struct dcerpc_pipe *p, TALLOC_CTX *tctx)
{
- NTSTATUS status;
struct eventlog_ClearEventLogW r;
+ struct eventlog_CloseEventLog cr;
+ struct policy_handle handle;
- r.in.handle = handle;
+ if (!get_policy_handle(tctx, p, &handle))
+ return false;
+
+ r.in.handle = &handle;
r.in.unknown = NULL;
- printf("Testing ClearEventLog\n");
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_eventlog_ClearEventLogW(p, tctx, &r),
+ "ClearEventLog failed");
- status = dcerpc_eventlog_ClearEventLogW(p, mem_ctx, &r);
+ cr.in.handle = cr.out.handle = &handle;
- if (!NT_STATUS_IS_OK(status)) {
- printf("ClearEventLog failed - %s\n", nt_errstr(status));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_eventlog_CloseEventLog(p, tctx, &cr),
+ "CloseEventLog failed");
- return True;
+ return true;
}
-static BOOL test_OpenEventLog(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
- struct policy_handle *handle)
+static bool test_OpenEventLog(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
- NTSTATUS status;
- struct eventlog_OpenEventLogW r;
- struct eventlog_OpenUnknown0 unknown0;
-
- printf("\ntesting OpenEventLog\n");
-
- unknown0.unknown0 = 0x005c;
- unknown0.unknown1 = 0x0001;
-
- r.in.unknown0 = &unknown0;
- init_lsa_String(&r.in.logname, "dns server");
- init_lsa_String(&r.in.servername, NULL);
- r.in.unknown2 = 0x00000001;
- r.in.unknown3 = 0x00000001;
- r.out.handle = handle;
+ struct policy_handle handle;
+ struct eventlog_CloseEventLog cr;
- status = dcerpc_eventlog_OpenEventLogW(p, mem_ctx, &r);
+ if (!get_policy_handle(tctx, p, &handle))
+ return false;
- if (!NT_STATUS_IS_OK(status)) {
- printf("OpenEventLog failed - %s\n", nt_errstr(status));
- return False;
- }
+ cr.in.handle = cr.out.handle = &handle;
- if (!NT_STATUS_IS_OK(r.out.result)) {
- printf("OpenEventLog failed - %s\n", nt_errstr(r.out.result));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_eventlog_CloseEventLog(p, tctx, &cr),
+ "CloseEventLog failed");
- return True;
+ return true;
}
-BOOL torture_rpc_eventlog(struct torture_context *torture)
+struct torture_suite *torture_rpc_eventlog(void)
{
- NTSTATUS status;
- struct dcerpc_pipe *p;
- struct policy_handle handle;
- TALLOC_CTX *mem_ctx;
- BOOL ret = True;
-
- mem_ctx = talloc_init("torture_rpc_atsvc");
+ struct torture_suite *suite;
+ struct torture_tcase *tcase;
- status = torture_rpc_connection(mem_ctx, &p, &dcerpc_table_eventlog);
+ suite = torture_suite_create(talloc_autofree_context(), "EVENTLOG");
+ tcase = torture_suite_add_rpc_iface_tcase(suite, "eventlog",
+ &dcerpc_table_eventlog);
- if (!NT_STATUS_IS_OK(status)) {
- talloc_free(mem_ctx);
- return False;
- }
-
- if (!test_OpenEventLog(p, mem_ctx, &handle)) {
- talloc_free(mem_ctx);
- return False;
- }
+ torture_rpc_tcase_add_test(tcase, "OpenEventLog", test_OpenEventLog);
#if 0
- ret &= test_ClearEventLog(p, mem_ctx, &handle); /* Destructive test */
+ /* Destructive test */
+ torture_rpc_tcase_add_test(tcase, "ClearEventLog", test_ClearEventLog);
#endif
- ret &= test_GetNumRecords(p, mem_ctx, &handle);
-
- ret &= test_ReadEventLog(p, mem_ctx, &handle);
-
- ret &= test_FlushEventLog(p, mem_ctx, &handle);
-
- ret &= test_CloseEventLog(p, mem_ctx, &handle);
-
- talloc_free(mem_ctx);
+ torture_rpc_tcase_add_test(tcase, "GetNumRecords", test_GetNumRecords);
+ torture_rpc_tcase_add_test(tcase, "ReadEventLog", test_ReadEventLog);
+ torture_rpc_tcase_add_test(tcase, "FlushEventLog", test_FlushEventLog);
- return ret;
+ return suite;
}
diff --git a/source4/torture/rpc/rpc.c b/source4/torture/rpc/rpc.c
index 754633e51b..6d3031ede9 100644
--- a/source4/torture/rpc/rpc.c
+++ b/source4/torture/rpc/rpc.c
@@ -26,6 +26,7 @@
#include "torture/rpc/rpc.h"
#include "torture/torture.h"
#include "librpc/rpc/dcerpc_table.h"
+#include "lib/util/dlinklist.h"
/* open a rpc connection to the chosen binding string */
_PUBLIC_ NTSTATUS torture_rpc_connection(TALLOC_CTX *parent_ctx,
@@ -89,64 +90,136 @@ NTSTATUS torture_rpc_connection_transport(TALLOC_CTX *parent_ctx,
return status;
}
+static bool torture_rpc_setup (struct torture_context *tctx, void **data)
+{
+ NTSTATUS status;
+
+ status = torture_rpc_connection(tctx,
+ (struct dcerpc_pipe **)data,
+ (const struct dcerpc_interface_table *)tctx->active_tcase->data);
+
+ torture_assert_ntstatus_ok(tctx, status, "Error connecting to server");
+
+ return true;
+}
+
+static bool torture_rpc_teardown (struct torture_context *tcase, void *data)
+{
+ talloc_free(data);
+ return true;
+}
+
+_PUBLIC_ struct torture_tcase *torture_suite_add_rpc_iface_tcase(struct torture_suite *suite,
+ const char *name,
+ const struct dcerpc_interface_table *table)
+{
+ struct torture_tcase *tcase = torture_suite_add_tcase(suite, name);
+
+ tcase->setup = torture_rpc_setup;
+ tcase->teardown = torture_rpc_teardown;
+ tcase->data = table;
+
+ return tcase;
+}
+
+static bool torture_rpc_wrap_test(struct torture_context *tctx,
+ struct torture_tcase *tcase,
+ struct torture_test *test)
+{
+ bool (*fn) (struct torture_context *, struct dcerpc_pipe *);
+
+ fn = test->fn;
+
+ return fn(tctx, (struct dcerpc_pipe *)tcase->data);
+}
+
+_PUBLIC_ struct torture_test *torture_rpc_tcase_add_test(
+ struct torture_tcase *tcase,
+ const char *name,
+ bool (*fn) (struct torture_context *, struct dcerpc_pipe *))
+{
+ struct torture_test *test;
+
+ test = talloc(tcase, struct torture_test);
+
+ test->name = talloc_strdup(test, name);
+ test->description = NULL;
+ test->run = torture_rpc_wrap_test;
+ test->dangerous = false;
+ test->data = NULL;
+ test->fn = fn;
+
+ DLIST_ADD(tcase->tests, test);
+
+ return test;
+}
+
NTSTATUS torture_rpc_init(void)
{
+ struct torture_suite *suite = torture_suite_create(
+ talloc_autofree_context(),
+ "RPC");
dcerpc_init();
dcerpc_table_init();
- register_torture_op("RPC-LSA", torture_rpc_lsa);
- register_torture_op("RPC-LSALOOKUP", torture_rpc_lsa_lookup);
- register_torture_op("RPC-LSA-GETUSER", torture_rpc_lsa_get_user);
- register_torture_op("RPC-SECRETS", torture_rpc_lsa_secrets);
- register_torture_op("RPC-ECHO", torture_rpc_echo);
- register_torture_op("RPC-DFS", torture_rpc_dfs);
- register_torture_op("RPC-SPOOLSS", torture_rpc_spoolss);
- register_torture_op("RPC-SAMR", torture_rpc_samr);
- register_torture_op("RPC-SAMR-USERS", torture_rpc_samr_users);
- register_torture_op("RPC-SAMR-PASSWORDS", torture_rpc_samr_passwords);
- register_torture_op("RPC-UNIXINFO", torture_rpc_unixinfo);
- register_torture_op("RPC-NETLOGON", torture_rpc_netlogon);
- register_torture_op("RPC-SAMLOGON", torture_rpc_samlogon);
- register_torture_op("RPC-SAMSYNC", torture_rpc_samsync);
- register_torture_op("RPC-SCHANNEL", torture_rpc_schannel);
- register_torture_op("RPC-WKSSVC", torture_rpc_wkssvc);
- register_torture_op("RPC-SRVSVC", torture_rpc_srvsvc);
- register_torture_op("RPC-SVCCTL", torture_rpc_svcctl);
- register_torture_op("RPC-ATSVC", torture_rpc_atsvc);
- register_torture_op("RPC-EVENTLOG", torture_rpc_eventlog);
- register_torture_op("RPC-EPMAPPER", torture_rpc_epmapper);
- register_torture_op("RPC-WINREG", torture_rpc_winreg);
- register_torture_op("RPC-INITSHUTDOWN", torture_rpc_initshutdown);
- register_torture_op("RPC-OXIDRESOLVE", torture_rpc_oxidresolve);
- register_torture_op("RPC-REMACT", torture_rpc_remact);
- register_torture_op("RPC-MGMT", torture_rpc_mgmt);
- register_torture_op("RPC-SCANNER", torture_rpc_scanner);
- register_torture_op("RPC-AUTOIDL", torture_rpc_autoidl);
- register_torture_op("RPC-COUNTCALLS", torture_rpc_countcalls);
- register_torture_op("RPC-MULTIBIND", torture_multi_bind);
- register_torture_op("RPC-AUTHCONTEXT", torture_bind_authcontext);
- register_torture_op("RPC-BINDSAMBA3", torture_bind_samba3);
- register_torture_op("RPC-NETLOGSAMBA3", torture_netlogon_samba3);
- register_torture_op("RPC-SAMBA3SESSIONKEY", torture_samba3_sessionkey);
- register_torture_op("RPC-SAMBA3-SRVSVC", torture_samba3_rpc_srvsvc);
- register_torture_op("RPC-SAMBA3-SHARESEC",
+ torture_suite_add_simple_test(suite, "LSA", torture_rpc_lsa);
+ torture_suite_add_simple_test(suite, "LSALOOKUP", torture_rpc_lsa_lookup);
+ torture_suite_add_simple_test(suite, "LSA-GETUSER", torture_rpc_lsa_get_user);
+ torture_suite_add_simple_test(suite, "SECRETS", torture_rpc_lsa_secrets);
+ torture_suite_add_suite(suite, torture_rpc_echo());
+ torture_suite_add_suite(suite, torture_rpc_dfs());
+ torture_suite_add_suite(suite, torture_rpc_unixinfo());
+ torture_suite_add_suite(suite, torture_rpc_eventlog());
+ torture_suite_add_suite(suite, torture_rpc_atsvc());
+ torture_suite_add_suite(suite, torture_rpc_wkssvc());
+ torture_suite_add_simple_test(suite, "SPOOLSS", torture_rpc_spoolss);
+ torture_suite_add_simple_test(suite, "SAMR", torture_rpc_samr);
+ torture_suite_add_simple_test(suite, "SAMR-USERS", torture_rpc_samr_users);
+ torture_suite_add_simple_test(suite, "SAMR-PASSWORDS", torture_rpc_samr_passwords);
+ torture_suite_add_simple_test(suite, "NETLOGON", torture_rpc_netlogon);
+ torture_suite_add_simple_test(suite, "SAMLOGON", torture_rpc_samlogon);
+ torture_suite_add_simple_test(suite, "SAMSYNC", torture_rpc_samsync);
+ torture_suite_add_simple_test(suite, "SCHANNEL", torture_rpc_schannel);
+ torture_suite_add_simple_test(suite, "SRVSVC", torture_rpc_srvsvc);
+ torture_suite_add_simple_test(suite, "SVCCTL", torture_rpc_svcctl);
+ torture_suite_add_simple_test(suite, "EPMAPPER", torture_rpc_epmapper);
+ torture_suite_add_simple_test(suite, "WINREG", torture_rpc_winreg);
+ torture_suite_add_simple_test(suite, "INITSHUTDOWN", torture_rpc_initshutdown);
+ torture_suite_add_simple_test(suite, "OXIDRESOLVE", torture_rpc_oxidresolve);
+ torture_suite_add_simple_test(suite, "REMACT", torture_rpc_remact);
+ torture_suite_add_simple_test(suite, "MGMT", torture_rpc_mgmt);
+ torture_suite_add_simple_test(suite, "SCANNER", torture_rpc_scanner);
+ torture_suite_add_simple_test(suite, "AUTOIDL", torture_rpc_autoidl);
+ torture_suite_add_simple_test(suite, "COUNTCALLS", torture_rpc_countcalls);
+ torture_suite_add_simple_test(suite, "MULTIBIND", torture_multi_bind);
+ torture_suite_add_simple_test(suite, "AUTHCONTEXT", torture_bind_authcontext);
+ torture_suite_add_simple_test(suite, "BINDSAMBA3", torture_bind_samba3);
+ torture_suite_add_simple_test(suite, "NETLOGSAMBA3", torture_netlogon_samba3);
+ torture_suite_add_simple_test(suite, "SAMBA3SESSIONKEY", torture_samba3_sessionkey);
+ torture_suite_add_simple_test(suite, "SAMBA3-SRVSVC", torture_samba3_rpc_srvsvc);
+ torture_suite_add_simple_test(suite, "SAMBA3-SHARESEC",
torture_samba3_rpc_sharesec);
- register_torture_op("RPC-SAMBA3-GETUSERNAME",
+ torture_suite_add_simple_test(suite, "SAMBA3-GETUSERNAME",
torture_samba3_rpc_getusername);
- register_torture_op("RPC-SAMBA3-LSA", torture_samba3_rpc_lsa);
- register_torture_op("RPC-SAMBA3-SPOOLSS", torture_samba3_rpc_spoolss);
- register_torture_op("RPC-SAMBA3-WKSSVC", torture_samba3_rpc_wkssvc);
- register_torture_op("RPC-SAMBA3-WINREG", torture_samba3_rpc_winreg);
- register_torture_op("RPC-DRSUAPI", torture_rpc_drsuapi);
- register_torture_op("RPC-CRACKNAMES", torture_rpc_drsuapi_cracknames);
- register_torture_op("RPC-ROT", torture_rpc_rot);
- register_torture_op("RPC-DSSETUP", torture_rpc_dssetup);
- register_torture_op("RPC-ALTERCONTEXT", torture_rpc_alter_context);
- register_torture_op("RPC-JOIN", torture_rpc_join);
- register_torture_op("RPC-DSSYNC", torture_rpc_dssync);
- register_torture_op("BENCH-RPC", torture_bench_rpc);
- register_torture_op("RPC-ASYNCBIND", torture_async_bind);
+ torture_suite_add_simple_test(suite, "SAMBA3-LSA", torture_samba3_rpc_lsa);
+ torture_suite_add_simple_test(suite, "SAMBA3-SPOOLSS", torture_samba3_rpc_spoolss);
+ torture_suite_add_simple_test(suite, "SAMBA3-WKSSVC", torture_samba3_rpc_wkssvc);
+ torture_suite_add_simple_test(suite, "RPC-SAMBA3-WINREG", torture_samba3_rpc_winreg);
+ torture_suite_add_simple_test(suite, "DRSUAPI", torture_rpc_drsuapi);
+ torture_suite_add_simple_test(suite, "CRACKNAMES", torture_rpc_drsuapi_cracknames);
+ torture_suite_add_simple_test(suite, "ROT", torture_rpc_rot);
+ torture_suite_add_simple_test(suite, "DSSETUP", torture_rpc_dssetup);
+ torture_suite_add_simple_test(suite, "ALTERCONTEXT", torture_rpc_alter_context);
+ torture_suite_add_simple_test(suite, "JOIN", torture_rpc_join);
+ torture_suite_add_simple_test(suite, "DSSYNC", torture_rpc_dssync);
+ torture_suite_add_simple_test(suite, "BENCH-RPC", torture_bench_rpc);
+ torture_suite_add_simple_test(suite, "ASYNCBIND", torture_async_bind);
+
+ suite->description = talloc_strdup(suite,
+ "DCE/RPC protocol and interface tests");
+
+ torture_register_suite(suite);
return NT_STATUS_OK;
}
diff --git a/source4/torture/rpc/rpc.h b/source4/torture/rpc/rpc.h
index 6d020bde88..934e1a214d 100644
--- a/source4/torture/rpc/rpc.h
+++ b/source4/torture/rpc/rpc.h
@@ -29,5 +29,6 @@
#include "librpc/rpc/dcerpc.h"
#include "libcli/raw/libcliraw.h"
#include "torture/rpc/proto.h"
+#include "torture/ui.h"
#endif /* __TORTURE_RPC_H__ */
diff --git a/source4/torture/rpc/unixinfo.c b/source4/torture/rpc/unixinfo.c
index 4bf27b916b..567a85fd44 100644
--- a/source4/torture/rpc/unixinfo.c
+++ b/source4/torture/rpc/unixinfo.c
@@ -51,24 +51,21 @@ static BOOL test_sidtouid(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
/*
test the UidToSid interface
*/
-static BOOL test_uidtosid(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_uidtosid(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
- NTSTATUS status;
struct unixinfo_UidToSid r;
r.in.uid = 1000;
- status = dcerpc_unixinfo_UidToSid(p, mem_ctx, &r);
- if (NT_STATUS_EQUAL(NT_STATUS_NO_SUCH_USER, status)) {
- } else if (!NT_STATUS_IS_OK(status)) {
- printf("UidToSid failed == %s\n", nt_errstr(status));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, dcerpc_unixinfo_UidToSid(p, tctx, &r),
+ "UidToSid failed");
- return True;
+ return true;
}
-static BOOL test_getpwuid(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_getpwuid(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
uint64_t uids[512];
uint32_t num_uids = ARRAY_SIZE(uids);
@@ -83,11 +80,13 @@ static BOOL test_getpwuid(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
r.in.count = &num_uids;
r.in.uids = uids;
r.out.count = &num_uids;
- r.out.infos = talloc_array(mem_ctx, struct unixinfo_GetPWUidInfo, num_uids);
+ r.out.infos = talloc_array(tctx, struct unixinfo_GetPWUidInfo, num_uids);
- result = dcerpc_unixinfo_GetPWUid(p, mem_ctx, &r);
+ result = dcerpc_unixinfo_GetPWUid(p, tctx, &r);
- return NT_STATUS_IS_OK(result);
+ torture_assert_ntstatus_ok(tctx, result, "GetPWUid failed");
+
+ return true;
}
/*
@@ -115,44 +114,32 @@ static BOOL test_sidtogid(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
/*
test the GidToSid interface
*/
-static BOOL test_gidtosid(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static BOOL test_gidtosid(struct torture_context *tctx, struct dcerpc_pipe *p)
{
NTSTATUS status;
struct unixinfo_GidToSid r;
r.in.gid = 1000;
- status = dcerpc_unixinfo_GidToSid(p, mem_ctx, &r);
+ status = dcerpc_unixinfo_GidToSid(p, tctx, &r);
if (NT_STATUS_EQUAL(NT_STATUS_NO_SUCH_GROUP, status)) {
- } else if (!NT_STATUS_IS_OK(status)) {
- printf("GidToSid failed == %s\n", nt_errstr(status));
- return False;
- }
+ } else torture_assert_ntstatus_ok(tctx, status, "GidToSid failed");
- return True;
+ return true;
}
-BOOL torture_rpc_unixinfo(struct torture_context *torture)
+struct torture_suite *torture_rpc_unixinfo(void)
{
- NTSTATUS status;
- struct dcerpc_pipe *p;
- TALLOC_CTX *mem_ctx;
- BOOL ret = True;
-
- mem_ctx = talloc_init("torture_rpc_unixinfo");
+ struct torture_suite *suite;
+ struct torture_tcase *tcase;
- status = torture_rpc_connection(mem_ctx, &p, &dcerpc_table_unixinfo);
- if (!NT_STATUS_IS_OK(status)) {
- return False;
- }
+ suite = torture_suite_create(talloc_autofree_context(), "UNIXINFO");
+ tcase = torture_suite_add_rpc_iface_tcase(suite, "unixinfo",
+ &dcerpc_table_unixinfo);
- ret &= test_uidtosid(p, mem_ctx);
- ret &= test_getpwuid(p, mem_ctx);
- ret &= test_gidtosid(p, mem_ctx);
-
- printf("\n");
-
- talloc_free(mem_ctx);
+ torture_rpc_tcase_add_test(tcase, "uidtosid", test_uidtosid);
+ torture_rpc_tcase_add_test(tcase, "getpwuid", test_getpwuid);
+ torture_rpc_tcase_add_test(tcase, "gidtosid", test_gidtosid);
- return ret;
+ return suite;
}
diff --git a/source4/torture/rpc/wkssvc.c b/source4/torture/rpc/wkssvc.c
index 4526b3f91b..e99cdada28 100644
--- a/source4/torture/rpc/wkssvc.c
+++ b/source4/torture/rpc/wkssvc.c
@@ -24,43 +24,37 @@
#include "librpc/gen_ndr/ndr_wkssvc_c.h"
#include "torture/rpc/rpc.h"
-
-static BOOL test_NetWkstaGetInfo(struct dcerpc_pipe *p,
- TALLOC_CTX *mem_ctx)
+static bool test_NetWkstaGetInfo(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
NTSTATUS status;
struct wkssvc_NetWkstaGetInfo r;
union wkssvc_NetWkstaInfo info;
uint16_t levels[] = {100, 101, 102, 502};
int i;
- BOOL ret = True;
r.in.server_name = dcerpc_server_name(p);
r.out.info = &info;
for (i=0;i<ARRAY_SIZE(levels);i++) {
r.in.level = levels[i];
- printf("testing NetWkstaGetInfo level %u\n", r.in.level);
- status = dcerpc_wkssvc_NetWkstaGetInfo(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("NetWkstaGetInfo level %u failed - %s\n", r.in.level, nt_errstr(status));
- ret = False;
- }
- if (!W_ERROR_IS_OK(r.out.result)) {
- printf("NetWkstaGetInfo level %u failed - %s\n", r.in.level, win_errstr(r.out.result));
- }
+ torture_comment(tctx, talloc_asprintf(tctx, "testing NetWkstaGetInfo level %u\n", r.in.level));
+ status = dcerpc_wkssvc_NetWkstaGetInfo(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status,
+ talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed", r.in.level));
+ torture_assert_werr_ok(tctx, r.out.result,
+ talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed", r.in.level));
}
- return ret;
+ return true;
}
-static BOOL test_NetWkstaTransportEnum(struct dcerpc_pipe *p,
- TALLOC_CTX *mem_ctx)
+static bool test_NetWkstaTransportEnum(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
NTSTATUS status;
struct wkssvc_NetWkstaTransportEnum r;
- BOOL ret = True;
uint32_t resume_handle = 0;
union wkssvc_NetWkstaTransportCtr ctr;
struct wkssvc_NetWkstaTransportCtr0 ctr0;
@@ -76,45 +70,28 @@ static BOOL test_NetWkstaTransportEnum(struct dcerpc_pipe *p,
r.out.ctr = &ctr;
r.out.resume_handle = &resume_handle;
- printf("testing NetWkstaTransportEnum\n");
- status = dcerpc_wkssvc_NetWkstaTransportEnum(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("NetWkstaTransportEnum failed - %s\n", nt_errstr(status));
- ret = False;
- }
- if (!W_ERROR_IS_OK(r.out.result)) {
- printf("NetWkstaTransportEnum level %u failed - %s\n", r.in.level, win_errstr(r.out.result));
- }
+ status = dcerpc_wkssvc_NetWkstaTransportEnum(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "NetWkstaTransportEnum failed");
+ torture_assert_werr_ok(tctx, r.out.result,
+ talloc_asprintf(tctx,
+ "NetWkstaTransportEnum level %u failed", r.in.level));
- return ret;
+ return true;
}
-BOOL torture_rpc_wkssvc(struct torture_context *torture)
+struct torture_suite *torture_rpc_wkssvc(void)
{
- NTSTATUS status;
- struct dcerpc_pipe *p;
- TALLOC_CTX *mem_ctx;
- BOOL ret = True;
-
- mem_ctx = talloc_init("torture_rpc_wkssvc");
-
- status = torture_rpc_connection(mem_ctx, &p, &dcerpc_table_wkssvc);
- if (!NT_STATUS_IS_OK(status)) {
- talloc_free(mem_ctx);
- return False;
- }
-
- if (!test_NetWkstaGetInfo(p, mem_ctx)) {
- ret = False;
- }
-
- if (!test_NetWkstaTransportEnum(p, mem_ctx)) {
- ret = False;
- }
+ struct torture_suite *suite;
+ struct torture_tcase *tcase;
- talloc_free(mem_ctx);
+ suite = torture_suite_create(talloc_autofree_context(), "WKSSVC");
+ tcase = torture_suite_add_rpc_iface_tcase(suite, "wkssvc",
+ &dcerpc_table_wkssvc);
- return ret;
+ torture_rpc_tcase_add_test(tcase, "NetWkstaGetInfo", test_NetWkstaGetInfo);
+ torture_rpc_tcase_add_test(tcase, "NetWkstaTransportEnum",
+ test_NetWkstaTransportEnum);
+ return suite;
}
generated by cgit (git 2.34.1) at 2024-07-21 01:31:04 +0000