diff options
Diffstat (limited to 'source4/torture/rpc/echo.c')
-rw-r--r-- | source4/torture/rpc/echo.c | 474 |
1 files changed, 474 insertions, 0 deletions
diff --git a/source4/torture/rpc/echo.c b/source4/torture/rpc/echo.c new file mode 100644 index 0000000..93fd408 --- /dev/null +++ b/source4/torture/rpc/echo.c @@ -0,0 +1,474 @@ +/* + Unix SMB/CIFS implementation. + test suite for echo rpc operations + + Copyright (C) Andrew Tridgell 2003 + Copyright (C) Stefan (metze) Metzmacher 2005 + Copyright (C) Jelmer Vernooij 2005 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include "includes.h" +#include "torture/rpc/torture_rpc.h" +#include "lib/events/events.h" +#include "librpc/gen_ndr/ndr_echo_c.h" + + +/* + test the AddOne interface +*/ +#define TEST_ADDONE(tctx, value) do { \ + n = i = value; \ + r.in.in_data = n; \ + r.out.out_data = &n; \ + 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) +{ + uint32_t i; + 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_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 torture_context *tctx, + struct dcerpc_pipe *p) +{ + int i; + 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() % 500); + } else { + len = 1 + (random() % 5000); + } + + 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; + + 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; + + for (i=0;i<len;i++) { + if (data_in[i] != data_out[i]) { + torture_comment(tctx, "Bad data returned for len %d at offset %d\n", + len, i); + torture_comment(tctx, "in:\n"); + dump_data(0, data_in+i, MIN(len-i, 16)); + torture_comment(tctx, "out:\n"); + dump_data(0, data_out+i, MIN(len-1, 16)); + return false; + } + } + return true; +} + +/* + test the SourceData interface +*/ +static bool test_sourcedata(struct torture_context *tctx, + struct dcerpc_pipe *p) +{ + int i; + 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)) { + len = 100 + (random() % 500); + } else { + len = 200000 + (random() % 5000); + } + + r.in.len = 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; + 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; +} + +/* + test the SinkData interface +*/ +static bool test_sinkdata(struct torture_context *tctx, + struct dcerpc_pipe *p) +{ + int i; + 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 = 100 + (random() % 5000); + } else { + len = 200000 + (random() % 5000); + } + + 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; + + 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 echo_TestCall r; + const char *s = NULL; + struct dcerpc_binding_handle *b = p->binding_handle; + + r.in.s1 = "input string"; + r.out.s2 = &s; + + 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"); + + return true; +} + +/* + test the testcall interface +*/ +static bool test_testcall2(struct torture_context *tctx, + struct dcerpc_pipe *p) +{ + 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); + 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) +{ + int i; +#define ASYNC_COUNT 3 + struct tevent_req *req[ASYNC_COUNT]; + struct echo_TestSleep r[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]; + 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=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++) { + 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_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]); + } + + while (total_done < ASYNC_COUNT) { + torture_assert(tctx, tevent_loop_once(tctx->ev) == 0, + "Event context loop failed"); + for (i=0;i<ASYNC_COUNT;i++) { + if (done2[i] == false && done1[i] == true) { + int rounded_tdiff; + total_done++; + 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)); + 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, (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, (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, (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, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec); + } else { + 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)); + } + } + } + } + torture_comment(tctx, "\n"); + return true; +} + +/* + test enum handling +*/ +static bool test_enum(struct torture_context *tctx, + struct dcerpc_pipe *p) +{ + 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; + r.in.foo3 = &e3; + r.out.foo1 = &v; + r.out.foo2 = &e2; + r.out.foo3 = &e3; + + e2.e1 = 76; + e2.e2 = ECHO_ENUM1_32; + e3.e1 = ECHO_ENUM2; + + torture_assert_ntstatus_ok(tctx, dcerpc_echo_TestEnum_r(b, tctx, &r), + "TestEnum failed"); + return true; +} + +/* + test surrounding conformant array handling +*/ +static bool test_surrounding(struct torture_context *tctx, + struct dcerpc_pipe *p) +{ + struct echo_TestSurrounding r; + struct dcerpc_binding_handle *b = p->binding_handle; + + ZERO_STRUCT(r); + r.in.data = talloc(tctx, struct echo_Surrounding); + + r.in.data->x = 20; + r.in.data->surrounding = talloc_zero_array(tctx, uint16_t, r.in.data->x); + + r.out.data = talloc(tctx, struct echo_Surrounding); + + 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"); + + return true; +} + +/* + test multiple levels of pointers +*/ +static bool test_doublepointer(struct torture_context *tctx, + struct dcerpc_pipe *p) +{ + 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; + + 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; +} + + +/* + 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) +{ + NTSTATUS status; + struct rpc_request *req; + struct echo_TestSleep r; + int timeout_saved = p->request_timeout; + + if (torture_setting_bool(tctx, "quick", false)) { + torture_skip(tctx, "timeout testing disabled - use \"torture:quick=no\" to enable\n"); + } + + torture_comment(tctx, "testing request timeouts\n"); + r.in.seconds = 2; + p->request_timeout = 1; + + req = dcerpc_echo_TestSleep_send(p, tctx, &r); + if (!req) { + torture_comment(tctx, "Failed to send async sleep request\n"); + goto failed; + } + 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"); + + torture_comment(tctx, "testing request destruction\n"); + req = dcerpc_echo_TestSleep_send(p, tctx, &r); + if (!req) { + torture_comment(tctx, "Failed to send async sleep request\n"); + goto failed; + } + talloc_free(req); + + req = dcerpc_echo_TestSleep_send(p, tctx, &r); + if (!req) { + torture_comment(tctx, "Failed to send async sleep request\n"); + goto failed; + } + 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 test_addone(tctx, p); + +failed: + 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_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); +#if 0 /* this test needs fixing to work over ncacn_np */ + torture_rpc_tcase_add_test(tcase, "timeout", test_timeout); +#endif + + return suite; +} |