X-Git-Url: http://git.samba.org/samba.git/?a=blobdiff_plain;f=source%2Ftorture%2Frpc%2Fecho.c;h=3608f82686c98b2c10549b14a5fec6d240428930;hb=84651aee81aaabbebf52ffc3fbcbabb2eec6eed5;hp=be70939de1c2fbd3e1838b7ac31f9d752b1dba3f;hpb=bd3dcfe5820489a838e19b244266bd9126af5eb4;p=ira%2Fwip.git
diff --git a/source/torture/rpc/echo.c b/source/torture/rpc/echo.c
index be70939de1c..3608f82686c 100644
--- a/source/torture/rpc/echo.c
+++ b/source/torture/rpc/echo.c
@@ -3,10 +3,12 @@
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 2 of the License, or
+ 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,
@@ -15,54 +17,69 @@
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, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see .
*/
#include "includes.h"
+#include "torture/torture.h"
+#include "torture/rpc/rpc.h"
+#include "lib/events/events.h"
+#include "librpc/gen_ndr/ndr_echo_c.h"
/*
test the AddOne interface
*/
-static BOOL test_addone(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+#define TEST_ADDONE(tctx, value) do { \
+ 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 (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)
{
- int i;
+ uint32_t i;
NTSTATUS status;
-
- printf("\nTesting AddOne\n");
+ uint32_t n;
+ struct echo_AddOne r;
for (i=0;i<10;i++) {
- uint32 n = i;
- struct echo_AddOne r;
- r.in.v = &n;
- r.out.v = &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;
- }
- printf("%d + 1 = %u\n", i, n);
+ TEST_ADDONE(tctx, i);
}
- return True;
+ 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;
- char *data_in, *data_out;
- int len = 1 + (random() % 5000);
+ uint8_t *data_in, *data_out;
+ int len;
struct echo_EchoData r;
- printf("\nTesting EchoData\n");
+ 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(mem_ctx, len);
- data_out = talloc(mem_ctx, len);
+ data_in = talloc_size(tctx, len);
+ data_out = talloc_size(tctx, len);
for (i=0;iconn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {
+ len = 100 + (random() % 500);
+ } else {
+ len = 200000 + (random() % 5000);
+ }
r.in.len = len;
- r.out.data = data_out;
- 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;iconn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {
+ len = 100 + (random() % 5000);
+ } else {
+ len = 200000 + (random() % 5000);
+ }
- data_in = talloc(mem_ctx, len);
+ data_in = talloc_size(tctx, len);
for (i=0;istate == RPC_REQUEST_DONE) {
+ int rounded_tdiff;
+ total_done++;
+ done[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_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 <= 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));
+ 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);
+ } 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);
+ } 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 */
+ }
+ }
+ }
}
+ return true;
+}
+
+/*
+ test enum handling
+*/
+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;
+
+ 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;
+
+ status = dcerpc_echo_TestEnum(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "TestEnum failed");
+ return true;
+}
- if (!test_sourcedata(p, mem_ctx)) {
- ret = False;
+/*
+ test surrounding conformant array handling
+*/
+static bool test_surrounding(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
+{
+ NTSTATUS status;
+ struct echo_TestSurrounding r;
+
+ 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);
+
+ status = dcerpc_echo_TestSurrounding(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "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)
+{
+ NTSTATUS status;
+ struct echo_TestDoublePointer r;
+ uint16_t value = 12;
+ uint16_t *pvalue = &value;
+ uint16_t **ppvalue = &pvalue;
+
+ ZERO_STRUCT(r);
+ r.in.data = &ppvalue;
+
+ status = dcerpc_echo_TestDoublePointer(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "TestDoublePointer failed");
+
+ 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 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");
}
- if (!test_sinkdata(p, mem_ctx)) {
- ret = False;
+ 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;
}
-#endif
+ req->ignore_timeout = True;
- p->flags |= DCERPC_DEBUG_PRINT_BOTH;
+ status = dcerpc_ndr_request_recv(req);
+ torture_assert_ntstatus_equal(tctx, status, NT_STATUS_IO_TIMEOUT,
+ "request should have timed out");
- if (!test_testcall(p, mem_ctx)) {
- ret = False;
+ 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);
- if (!test_testcall2(p, mem_ctx)) {
- ret = False;
+ 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_ndr_request_recv(req);
+ torture_assert_ntstatus_equal(tctx, status, NT_STATUS_IO_TIMEOUT,
+ "request should have timed out");
- printf("\n");
+ p->request_timeout = timeout_saved;
- talloc_destroy(mem_ctx);
+ return test_addone(tctx, p);
- torture_rpc_close(p);
- return ret;
+failed:
+ p->request_timeout = timeout_saved;
+ return false;
+}
+
+
+struct torture_suite *torture_rpc_echo(void)
+{
+ struct torture_suite *suite = torture_suite_create(
+ talloc_autofree_context(), "ECHO");
+ struct torture_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, "timeout", test_timeout);
+
+ return suite;
}