*/
#include "includes.h"
-#include "torture/torture.h"
-#include "torture/rpc/rpc.h"
+#include "torture/rpc/torture_rpc.h"
#include "lib/events/events.h"
#include "librpc/gen_ndr/ndr_echo_c.h"
n = i = value; \
r.in.in_data = n; \
r.out.out_data = &n; \
- status = dcerpc_echo_AddOne(p, tctx, &r); \
- torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx, "AddOne(%d) failed", i)); \
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_AddOne_r(b, tctx, &r), \
+ 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 torture_context *tctx,
- struct dcerpc_pipe *p)
+ struct dcerpc_pipe *p)
{
uint32_t i;
- NTSTATUS status;
uint32_t n;
struct echo_AddOne r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
for (i=0;i<10;i++) {
TEST_ADDONE(tctx, i);
test the EchoData interface
*/
static bool test_echodata(struct torture_context *tctx,
- struct dcerpc_pipe *p)
+ struct dcerpc_pipe *p)
{
int i;
- NTSTATUS status;
uint8_t *data_in, *data_out;
int len;
struct echo_EchoData r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
if (torture_setting_bool(tctx, "quick", false) &&
(p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {
len = 1 + (random() % 5000);
}
- data_in = talloc_size(tctx, len);
- data_out = talloc_size(tctx, len);
+ data_in = talloc_array(tctx, uint8_t, len);
+ data_out = talloc_array(tctx, uint8_t, len);
for (i=0;i<len;i++) {
data_in[i] = i;
}
r.in.len = len;
r.in.in_data = data_in;
- status = dcerpc_echo_EchoData(p, tctx, &r);
- torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx,
- "EchoData(%d) failed\n", len));
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_EchoData_r(b, tctx, &r),
+ talloc_asprintf(tctx, "EchoData(%d) failed\n", len));
data_out = r.out.out_data;
test the SourceData interface
*/
static bool test_sourcedata(struct torture_context *tctx,
- struct dcerpc_pipe *p)
+ struct dcerpc_pipe *p)
{
int i;
- NTSTATUS status;
int len;
struct echo_SourceData r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
if (torture_setting_bool(tctx, "quick", false) &&
(p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {
r.in.len = len;
- status = dcerpc_echo_SourceData(p, tctx, &r);
- torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx,
- "SourceData(%d) failed", len));
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_SourceData_r(b, tctx, &r),
+ talloc_asprintf(tctx, "SourceData(%d) failed", len));
for (i=0;i<len;i++) {
uint8_t *v = (uint8_t *)r.out.data;
test the SinkData interface
*/
static bool test_sinkdata(struct torture_context *tctx,
- struct dcerpc_pipe *p)
+ struct dcerpc_pipe *p)
{
int i;
- NTSTATUS status;
uint8_t *data_in;
int len;
struct echo_SinkData r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
if (torture_setting_bool(tctx, "quick", false) &&
(p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {
len = 200000 + (random() % 5000);
}
- data_in = talloc_size(tctx, len);
+ data_in = talloc_array(tctx, uint8_t, len);
for (i=0;i<len;i++) {
data_in[i] = i+1;
}
r.in.len = len;
r.in.data = data_in;
- status = dcerpc_echo_SinkData(p, tctx, &r);
- torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx,
- "SinkData(%d) failed",
- len));
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_SinkData_r(b, tctx, &r),
+ talloc_asprintf(tctx, "SinkData(%d) failed", len));
torture_comment(tctx, "sunk %d bytes\n", len);
return true;
test the testcall interface
*/
static bool test_testcall(struct torture_context *tctx,
- struct dcerpc_pipe *p)
+ struct dcerpc_pipe *p)
{
- NTSTATUS status;
struct echo_TestCall r;
const char *s = NULL;
+ struct dcerpc_binding_handle *b = p->binding_handle;
r.in.s1 = "input string";
r.out.s2 = &s;
- status = dcerpc_echo_TestCall(p, tctx, &r);
- torture_assert_ntstatus_ok(tctx, status, "TestCall failed");
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_TestCall_r(b, tctx, &r),
+ "TestCall failed");
torture_assert_str_equal(tctx, s, "input string", "Didn't receive back same string");
test the testcall interface
*/
static bool test_testcall2(struct torture_context *tctx,
- struct dcerpc_pipe *p)
+ struct dcerpc_pipe *p)
{
- NTSTATUS status;
struct echo_TestCall2 r;
int i;
+ struct dcerpc_binding_handle *b = p->binding_handle;
for (i=1;i<=7;i++) {
r.in.level = i;
r.out.info = talloc(tctx, union echo_Info);
torture_comment(tctx, "Testing TestCall2 level %d\n", i);
- status = dcerpc_echo_TestCall2(p, tctx, &r);
- torture_assert_ntstatus_ok(tctx, status, "TestCall2 failed");
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_TestCall2_r(b, tctx, &r),
+ "TestCall2 failed");
+ torture_assert_ntstatus_ok(tctx, r.out.result, "TestCall2 failed");
}
return true;
}
+static void test_sleep_done(struct tevent_req *subreq)
+{
+ bool *done1 = (bool *)tevent_req_callback_data_void(subreq);
+ *done1 = true;
+}
+
/*
test the TestSleep interface
*/
static bool test_sleep(struct torture_context *tctx,
- struct dcerpc_pipe *p)
+ struct dcerpc_pipe *p)
{
int i;
- NTSTATUS status;
#define ASYNC_COUNT 3
- struct rpc_request *req[ASYNC_COUNT];
+ struct tevent_req *req[ASYNC_COUNT];
struct echo_TestSleep r[ASYNC_COUNT];
- BOOL done[ASYNC_COUNT];
+ bool done1[ASYNC_COUNT];
+ bool done2[ASYNC_COUNT];
struct timeval snd[ASYNC_COUNT];
struct timeval rcv[ASYNC_COUNT];
struct timeval diff[ASYNC_COUNT];
- struct event_context *ctx;
int total_done = 0;
+ struct dcerpc_binding_handle *b = p->binding_handle;
+ enum dcerpc_transport_t transport;
+ uint32_t assoc_group_id;
+ struct dcerpc_pipe *p2 = NULL;
+ NTSTATUS status;
if (torture_setting_bool(tctx, "quick", false)) {
torture_skip(tctx, "TestSleep disabled - use \"torture:quick=no\" to enable\n");
}
- torture_comment(tctx, "Testing TestSleep - use \"torture:quick=no\" to disable\n");
+ torture_comment(tctx, "Testing TestSleep - use \"torture:quick=yes\" to disable\n");
+
+ transport = dcerpc_binding_get_transport(p->binding);
+ assoc_group_id = dcerpc_binding_get_assoc_group_id(p->binding);
+
+ torture_comment(tctx, "connect echo connection 2 with "
+ "DCERPC_CONCURRENT_MULTIPLEX\n");
+ status = torture_rpc_connection_transport(tctx, &p2,
+ &ndr_table_rpcecho,
+ transport,
+ assoc_group_id,
+ DCERPC_CONCURRENT_MULTIPLEX);
+ torture_assert_ntstatus_ok(tctx, status, "opening echo connection 2");
+ b = p2->binding_handle;
for (i=0;i<ASYNC_COUNT;i++) {
- done[i] = False;
+ done1[i] = false;
+ done2[i] = false;
snd[i] = timeval_current();
rcv[i] = timeval_zero();
r[i].in.seconds = ASYNC_COUNT-i;
- req[i] = dcerpc_echo_TestSleep_send(p, tctx, &r[i]);
+ req[i] = dcerpc_echo_TestSleep_r_send(tctx, tctx->ev, b, &r[i]);
torture_assert(tctx, req[i], "Failed to send async sleep request\n");
+ tevent_req_set_callback(req[i], test_sleep_done, &done1[i]);
}
- ctx = dcerpc_event_context(p);
while (total_done < ASYNC_COUNT) {
- torture_assert(tctx, event_loop_once(ctx) == 0,
+ torture_assert(tctx, tevent_loop_once(tctx->ev) == 0,
"Event context loop failed");
for (i=0;i<ASYNC_COUNT;i++) {
- if (done[i] == False && req[i]->state == RPC_REQUEST_DONE) {
+ if (done2[i] == false && done1[i] == true) {
int rounded_tdiff;
total_done++;
- done[i] = True;
+ done2[i] = true;
rcv[i] = timeval_current();
diff[i] = timeval_until(&snd[i], &rcv[i]);
rounded_tdiff = (int)(0.5 + diff[i].tv_sec + (1.0e-6*diff[i].tv_usec));
- status = dcerpc_ndr_request_recv(req[i]);
- printf("rounded_tdiff=%d\n", rounded_tdiff);
- torture_assert_ntstatus_ok(tctx, status,
- talloc_asprintf(tctx, "TestSleep(%d) failed", i));
+ torture_comment(tctx, "rounded_tdiff=%d\n", rounded_tdiff);
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_echo_TestSleep_r_recv(req[i], tctx),
+ 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));
+ r[i].out.result, r[i].in.seconds, (unsigned int)diff[i].tv_sec));
torture_assert(tctx, r[i].out.result <= rounded_tdiff,
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));
+ r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec));
if (r[i].out.result+1 == rounded_tdiff) {
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);
+ r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec);
} else if (r[i].out.result == rounded_tdiff) {
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);
+ r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec);
} else {
- 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 */
+ torture_fail(tctx, talloc_asprintf(tctx,
+ "(Failed) - Not async - Slept for %u seconds (but reply takes %u.%06u seconds)\n",
+ r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec));
}
}
}
}
- printf("\n");
+ torture_comment(tctx, "\n");
return true;
}
static bool test_enum(struct torture_context *tctx,
struct dcerpc_pipe *p)
{
- NTSTATUS status;
struct echo_TestEnum r;
enum echo_Enum1 v = ECHO_ENUM1;
struct echo_Enum2 e2;
union echo_Enum3 e3;
+ struct dcerpc_binding_handle *b = p->binding_handle;
r.in.foo1 = &v;
r.in.foo2 = &e2;
e2.e2 = ECHO_ENUM1_32;
e3.e1 = ECHO_ENUM2;
- status = dcerpc_echo_TestEnum(p, tctx, &r);
- torture_assert_ntstatus_ok(tctx, status, "TestEnum failed");
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_TestEnum_r(b, tctx, &r),
+ "TestEnum failed");
return true;
}
static bool test_surrounding(struct torture_context *tctx,
struct dcerpc_pipe *p)
{
- NTSTATUS status;
struct echo_TestSurrounding r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
ZERO_STRUCT(r);
r.in.data = talloc(tctx, struct echo_Surrounding);
r.out.data = talloc(tctx, struct echo_Surrounding);
- status = dcerpc_echo_TestSurrounding(p, tctx, &r);
- torture_assert_ntstatus_ok(tctx, status, "TestSurrounding failed");
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_TestSurrounding_r(b, tctx, &r),
+ "TestSurrounding failed");
torture_assert(tctx, r.out.data->x == 2 * r.in.data->x,
"TestSurrounding did not make the array twice as large");
test multiple levels of pointers
*/
static bool test_doublepointer(struct torture_context *tctx,
- struct dcerpc_pipe *p)
+ struct dcerpc_pipe *p)
{
- NTSTATUS status;
struct echo_TestDoublePointer r;
uint16_t value = 12;
uint16_t *pvalue = &value;
uint16_t **ppvalue = &pvalue;
+ struct dcerpc_binding_handle *b = p->binding_handle;
ZERO_STRUCT(r);
r.in.data = &ppvalue;
- status = dcerpc_echo_TestDoublePointer(p, tctx, &r);
- torture_assert_ntstatus_ok(tctx, status, "TestDoublePointer failed");
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_TestDoublePointer_r(b, tctx, &r),
+ "TestDoublePointer failed");
torture_assert_int_equal(tctx, value, r.out.result,
"TestDoublePointer did not return original value");
return true;
}
+static bool test_bytepipein(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
+{
+ struct dcerpc_binding_handle *b = p->binding_handle;
+ struct echo_TestBytePipeIn r;
+ struct echo_BytePipe_chunk chunk;
+ struct echo_BytePipe *in_pipe;
+ struct tevent_req *subreq1;
+ struct tevent_req *subreq2;
+ size_t i;
+ uint8_t bytes[0x8000];
+ NTSTATUS status;
+
+ in_pipe = dcerpc_echo_BytePipe_create(tctx);
+
+ ZERO_STRUCT(r);
+ r.in.num_chunks = 1;
+ r.in.chunk_size = sizeof(bytes);
+ r.in.in_pipe = in_pipe;
+
+ ZERO_STRUCT(chunk);
+
+ subreq1 = dcerpc_echo_TestBytePipeIn_r_send(tctx, tctx->ev, b, &r);
+ for (i=0; i <= r.in.num_chunks; i++) {
+ struct timeval tv = timeval_current_ofs(0, 100);
+
+ memset(bytes, i, sizeof(bytes));
+ chunk.count = r.in.chunk_size;
+ chunk.array = bytes;
+
+ if (i == r.in.num_chunks) {
+ chunk.count = 0;
+ }
+
+ subreq2 = tevent_wakeup_send(tctx, tctx->ev, tv);
+ tevent_req_poll(subreq2, tctx->ev);
+ tevent_wakeup_recv(subreq2);
+ TALLOC_FREE(subreq2);
+
+ torture_comment(tctx, "chunk[%u] count[%u]\n", (unsigned)i, (unsigned)chunk.count);
+ subreq2 = dcerpc_echo_BytePipe_chunk_push_send(tctx, tctx->ev, in_pipe, &chunk);
+ tevent_req_poll(subreq2, tctx->ev);
+ status = dcerpc_echo_BytePipe_chunk_push_recv(subreq2);
+ TALLOC_FREE(subreq2);
+ torture_assert_ntstatus_ok(tctx, status, __location__);
+ }
+
+ tevent_req_poll(subreq1, tctx->ev);
+ status = dcerpc_echo_TestBytePipeIn_r_recv(subreq1, tctx);
+ TALLOC_FREE(subreq1);
+ torture_assert_ntstatus_ok(tctx, status, __location__);
+
+ return true;
+}
/*
test request timeouts
*/
+#if 0 /* this test needs fixing to work over ncacn_np */
static bool test_timeout(struct torture_context *tctx,
struct dcerpc_pipe *p)
{
torture_comment(tctx, "Failed to send async sleep request\n");
goto failed;
}
- req->ignore_timeout = True;
+ req->ignore_timeout = true;
- status = dcerpc_ndr_request_recv(req);
+ status = dcerpc_echo_TestSleep_recv(req);
torture_assert_ntstatus_equal(tctx, status, NT_STATUS_IO_TIMEOUT,
"request should have timed out");
torture_comment(tctx, "Failed to send async sleep request\n");
goto failed;
}
- req->ignore_timeout = True;
- status = dcerpc_ndr_request_recv(req);
+ req->ignore_timeout = true;
+ status = dcerpc_echo_TestSleep_recv(req);
torture_assert_ntstatus_equal(tctx, status, NT_STATUS_IO_TIMEOUT,
"request should have timed out");
p->request_timeout = timeout_saved;
return false;
}
-
+#endif
struct torture_suite *torture_rpc_echo(TALLOC_CTX *mem_ctx)
{
- struct torture_suite *suite = torture_suite_create(
- mem_ctx, "ECHO");
+ struct torture_suite *suite = torture_suite_create(mem_ctx, "echo");
struct torture_rpc_tcase *tcase;
tcase = torture_suite_add_rpc_iface_tcase(suite, "echo",
&ndr_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, "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, "bytepipein", test_bytepipein);
+#if 0 /* this test needs fixing to work over ncacn_np */
torture_rpc_tcase_add_test(tcase, "timeout", test_timeout);
+#endif
return suite;
}
git.samba.org / metze / samba / wip.git / blobdiff