s4:RPC-ECHO: don't look at the internals of 'struct rpc_request'
[ira/wip.git] / source4 / torture / rpc / echo.c
index c141d4be9c0c9a962c3068330c9a382ecdac2ea6..2321500ca52c64857dc982f42c63ccf29b10b8f4 100644 (file)
@@ -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,
    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 <http://www.gnu.org/licenses/>.
 */
 
 #include "includes.h"
-#include "librpc/gen_ndr/ndr_echo.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_t 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;
        uint8_t *data_in, *data_out;
-       int len = 1 + (random() % 5000);
+       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_array(tctx, uint8_t, len);
+       data_out = talloc_array(tctx, uint8_t, len);
        for (i=0;i<len;i++) {
                data_in[i] = i;
        }
@@ -71,80 +86,79 @@ 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 = 200000 + (random() % 5000);
-       uint8_t *data_out;
+       int len;
        struct echo_SourceData r;
 
-       printf("\nTesting SourceData\n");
-
-       data_out = talloc(mem_ctx, len);
+       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;
-       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;i<len;i++) {
-               uint8_t *v = (uint8_t *)data_out;
-               if (v[i] != (i & 0xFF)) {
-                       printf("bad data 0x%x at %d\n", (uint8_t)data_out[i], i);
-                       return False;
-               }
+               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;
+       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;
        uint8_t *data_in;
-       int len = 200000 + (random() % 5000);
+       int len;
        struct echo_SinkData r;
 
-       printf("\nTesting SinkData\n");
+       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(mem_ctx, len);
+       data_in = talloc_array(tctx, uint8_t, len);
        for (i=0;i<len;i++) {
                data_in[i] = i+1;
        }
@@ -152,166 +166,299 @@ 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;
+       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");
 
-       return True;
+       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 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(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 true;
+}
 
-       return ret;
+static void test_sleep_done(struct rpc_request *rreq)
+{
+       bool *done1 = (bool *)rreq->async.private_data;
+       *done1 = true;
 }
 
-#if 0
 /*
   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;
-#define ASYNC_COUNT 5
+#define ASYNC_COUNT 3
        struct rpc_request *req[ASYNC_COUNT];
        struct echo_TestSleep r[ASYNC_COUNT];
-       int done[ASYNC_COUNT];
-       struct event_context *ctx;
+       bool done1[ASYNC_COUNT];
+       bool done2[ASYNC_COUNT];
+       struct timeval snd[ASYNC_COUNT];
+       struct timeval rcv[ASYNC_COUNT];
+       struct timeval diff[ASYNC_COUNT];
+       struct tevent_context *ctx;
        int total_done = 0;
-       BOOL ret = True;
 
-       printf("\nTesting TestSleep\n");
+       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");
 
        for (i=0;i<ASYNC_COUNT;i++) {
-               done[i] = 0;
+               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, 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");
+               req[i]->async.callback = test_sleep_done;
+               req[i]->async.private_data = &done1[i];
        }
 
        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] == 0 && req[i]->state == RPC_REQUEST_DONE) {
+                       if (done2[i] == false && done1[i] == true) {
+                               int rounded_tdiff;
                                total_done++;
-                               done[i] = 1;
-                               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;
+                               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_echo_TestSleep_recv(req[i]);
+                               torture_comment(tctx, "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, (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 {
-                                       printf("Sleep for %d seconds\n", 
-                                              r[i].out.result);
+                                               torture_comment(tctx, "(Failed) - Not async - Slept for %u seconds (but reply takes %u.%06u seconds)", 
+                                                       r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec);
+                                       /* TODO: let the test fail here, when we support async rpc on ncacn_np */
                                }
                        }
                }
        }
+       torture_comment(tctx, "\n");
+       return true;
+}
 
-       return ret;
+/*
+  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;
 }
-#endif
 
-BOOL torture_rpc_echo(void)
+/*
+  test surrounding conformant array handling
+*/
+static bool test_surrounding(struct torture_context *tctx,
+                                                 struct dcerpc_pipe *p)
 {
-        NTSTATUS status;
-        struct dcerpc_pipe *p;
-       TALLOC_CTX *mem_ctx;
-       BOOL ret = True;
-
-       mem_ctx = talloc_init("torture_rpc_echo");
-
-       status = torture_rpc_connection(&p, 
-                                       DCERPC_RPCECHO_NAME,
-                                       DCERPC_RPCECHO_UUID,
-                                       DCERPC_RPCECHO_VERSION);
-       if (!NT_STATUS_IS_OK(status)) {
-               return False;
-       }
+       NTSTATUS status;
+       struct echo_TestSurrounding r;
 
-       if (!test_addone(p, mem_ctx)) {
-               ret = False;
-       }
+       ZERO_STRUCT(r);
+       r.in.data = talloc(tctx, struct echo_Surrounding);
 
-       if (!test_sinkdata(p, mem_ctx)) {
-               ret = False;
-       }
+       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;
+}
 
-       if (!test_echodata(p, mem_ctx)) {
-               ret = False;
-       }
 
-       if (!test_sourcedata(p, mem_ctx)) {
-               ret = False;
+/*
+  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");
        }
 
-       if (!test_testcall(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;
        }
+       req->ignore_timeout = true;
 
-       if (!test_testcall2(p, mem_ctx)) {
-               ret = False;
+       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);
 
-/*
-       if (!test_sleep(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;
        }
-*/
-       printf("\n");
+       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;
        
-       talloc_free(mem_ctx);
+       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
 
-        torture_rpc_close(p);
-       return ret;
+       return suite;
 }