2 Unix SMB/CIFS implementation.
3 test suite for echo rpc operations
5 Copyright (C) Andrew Tridgell 2003
6 Copyright (C) Stefan (metze) Metzmacher 2005
7 Copyright (C) Jelmer Vernooij 2005
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "torture/rpc/rpc.h"
25 #include "lib/events/events.h"
26 #include "librpc/gen_ndr/ndr_echo_c.h"
30 test the AddOne interface
32 #define TEST_ADDONE(tctx, value) do { \
35 r.out.out_data = &n; \
36 status = dcerpc_echo_AddOne(p, tctx, &r); \
37 torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx, "AddOne(%d) failed", i)); \
38 torture_assert (tctx, n == i+1, talloc_asprintf(tctx, "%d + 1 != %u (should be %u)\n", i, n, i+1)); \
39 torture_comment (tctx, "%d + 1 = %u\n", i, n); \
42 static bool test_addone(struct torture_context
*tctx
,
43 struct dcerpc_pipe
*p
)
54 TEST_ADDONE(tctx
, 0x7FFFFFFE);
55 TEST_ADDONE(tctx
, 0xFFFFFFFE);
56 TEST_ADDONE(tctx
, 0xFFFFFFFF);
57 TEST_ADDONE(tctx
, random() & 0xFFFFFFFF);
62 test the EchoData interface
64 static bool test_echodata(struct torture_context
*tctx
,
65 struct dcerpc_pipe
*p
)
69 uint8_t *data_in
, *data_out
;
71 struct echo_EchoData r
;
73 if (torture_setting_bool(tctx
, "quick", false) &&
74 (p
->conn
->flags
& DCERPC_DEBUG_VALIDATE_BOTH
)) {
75 len
= 1 + (random() % 500);
77 len
= 1 + (random() % 5000);
80 data_in
= talloc_array(tctx
, uint8_t, len
);
81 data_out
= talloc_array(tctx
, uint8_t, len
);
87 r
.in
.in_data
= data_in
;
89 status
= dcerpc_echo_EchoData(p
, tctx
, &r
);
90 torture_assert_ntstatus_ok(tctx
, status
, talloc_asprintf(tctx
,
91 "EchoData(%d) failed\n", len
));
93 data_out
= r
.out
.out_data
;
96 if (data_in
[i
] != data_out
[i
]) {
97 torture_comment(tctx
, "Bad data returned for len %d at offset %d\n",
99 torture_comment(tctx
, "in:\n");
100 dump_data(0, data_in
+i
, MIN(len
-i
, 16));
101 torture_comment(tctx
, "out:\n");
102 dump_data(0, data_out
+i
, MIN(len
-1, 16));
110 test the SourceData interface
112 static bool test_sourcedata(struct torture_context
*tctx
,
113 struct dcerpc_pipe
*p
)
118 struct echo_SourceData r
;
120 if (torture_setting_bool(tctx
, "quick", false) &&
121 (p
->conn
->flags
& DCERPC_DEBUG_VALIDATE_BOTH
)) {
122 len
= 100 + (random() % 500);
124 len
= 200000 + (random() % 5000);
129 status
= dcerpc_echo_SourceData(p
, tctx
, &r
);
130 torture_assert_ntstatus_ok(tctx
, status
, talloc_asprintf(tctx
,
131 "SourceData(%d) failed", len
));
133 for (i
=0;i
<len
;i
++) {
134 uint8_t *v
= (uint8_t *)r
.out
.data
;
135 torture_assert(tctx
, v
[i
] == (i
& 0xFF),
136 talloc_asprintf(tctx
,
137 "bad data 0x%x at %d\n", (uint8_t)r
.out
.data
[i
], i
));
143 test the SinkData interface
145 static bool test_sinkdata(struct torture_context
*tctx
,
146 struct dcerpc_pipe
*p
)
152 struct echo_SinkData r
;
154 if (torture_setting_bool(tctx
, "quick", false) &&
155 (p
->conn
->flags
& DCERPC_DEBUG_VALIDATE_BOTH
)) {
156 len
= 100 + (random() % 5000);
158 len
= 200000 + (random() % 5000);
161 data_in
= talloc_array(tctx
, uint8_t, len
);
162 for (i
=0;i
<len
;i
++) {
169 status
= dcerpc_echo_SinkData(p
, tctx
, &r
);
170 torture_assert_ntstatus_ok(tctx
, status
, talloc_asprintf(tctx
,
171 "SinkData(%d) failed",
174 torture_comment(tctx
, "sunk %d bytes\n", len
);
180 test the testcall interface
182 static bool test_testcall(struct torture_context
*tctx
,
183 struct dcerpc_pipe
*p
)
186 struct echo_TestCall r
;
187 const char *s
= NULL
;
189 r
.in
.s1
= "input string";
192 status
= dcerpc_echo_TestCall(p
, tctx
, &r
);
193 torture_assert_ntstatus_ok(tctx
, status
, "TestCall failed");
195 torture_assert_str_equal(tctx
, s
, "input string", "Didn't receive back same string");
201 test the testcall interface
203 static bool test_testcall2(struct torture_context
*tctx
,
204 struct dcerpc_pipe
*p
)
207 struct echo_TestCall2 r
;
212 r
.out
.info
= talloc(tctx
, union echo_Info
);
214 torture_comment(tctx
, "Testing TestCall2 level %d\n", i
);
215 status
= dcerpc_echo_TestCall2(p
, tctx
, &r
);
216 torture_assert_ntstatus_ok(tctx
, status
, "TestCall2 failed");
222 test the TestSleep interface
224 static bool test_sleep(struct torture_context
*tctx
,
225 struct dcerpc_pipe
*p
)
229 #define ASYNC_COUNT 3
230 struct rpc_request
*req
[ASYNC_COUNT
];
231 struct echo_TestSleep r
[ASYNC_COUNT
];
232 bool done
[ASYNC_COUNT
];
233 struct timeval snd
[ASYNC_COUNT
];
234 struct timeval rcv
[ASYNC_COUNT
];
235 struct timeval diff
[ASYNC_COUNT
];
236 struct tevent_context
*ctx
;
239 if (torture_setting_bool(tctx
, "quick", false)) {
240 torture_skip(tctx
, "TestSleep disabled - use \"torture:quick=no\" to enable\n");
242 torture_comment(tctx
, "Testing TestSleep - use \"torture:quick=yes\" to disable\n");
244 for (i
=0;i
<ASYNC_COUNT
;i
++) {
246 snd
[i
] = timeval_current();
247 rcv
[i
] = timeval_zero();
248 r
[i
].in
.seconds
= ASYNC_COUNT
-i
;
249 req
[i
] = dcerpc_echo_TestSleep_send(p
, tctx
, &r
[i
]);
250 torture_assert(tctx
, req
[i
], "Failed to send async sleep request\n");
253 ctx
= dcerpc_event_context(p
);
254 while (total_done
< ASYNC_COUNT
) {
255 torture_assert(tctx
, event_loop_once(ctx
) == 0,
256 "Event context loop failed");
257 for (i
=0;i
<ASYNC_COUNT
;i
++) {
258 if (done
[i
] == false && req
[i
]->state
== RPC_REQUEST_DONE
) {
262 rcv
[i
] = timeval_current();
263 diff
[i
] = timeval_until(&snd
[i
], &rcv
[i
]);
264 rounded_tdiff
= (int)(0.5 + diff
[i
].tv_sec
+ (1.0e-6*diff
[i
].tv_usec
));
265 status
= dcerpc_ndr_request_recv(req
[i
]);
266 torture_comment(tctx
, "rounded_tdiff=%d\n", rounded_tdiff
);
267 torture_assert_ntstatus_ok(tctx
, status
,
268 talloc_asprintf(tctx
, "TestSleep(%d) failed", i
));
269 torture_assert(tctx
, r
[i
].out
.result
== r
[i
].in
.seconds
,
270 talloc_asprintf(tctx
, "Failed - Asked to sleep for %u seconds (server replied with %u seconds and the reply takes only %u seconds)",
271 r
[i
].out
.result
, r
[i
].in
.seconds
, (uint_t
)diff
[i
].tv_sec
));
272 torture_assert(tctx
, r
[i
].out
.result
<= rounded_tdiff
,
273 talloc_asprintf(tctx
, "Failed - Slept for %u seconds (but reply takes only %u.%06u seconds)",
274 r
[i
].out
.result
, (uint_t
)diff
[i
].tv_sec
, (uint_t
)diff
[i
].tv_usec
));
275 if (r
[i
].out
.result
+1 == rounded_tdiff
) {
276 torture_comment(tctx
, "Slept for %u seconds (but reply takes %u.%06u seconds - busy server?)\n",
277 r
[i
].out
.result
, (uint_t
)diff
[i
].tv_sec
, (uint_t
)diff
[i
].tv_usec
);
278 } else if (r
[i
].out
.result
== rounded_tdiff
) {
279 torture_comment(tctx
, "Slept for %u seconds (reply takes %u.%06u seconds - ok)\n",
280 r
[i
].out
.result
, (uint_t
)diff
[i
].tv_sec
, (uint_t
)diff
[i
].tv_usec
);
282 torture_comment(tctx
, "(Failed) - Not async - Slept for %u seconds (but reply takes %u.%06u seconds)",
283 r
[i
].out
.result
, (uint_t
)diff
[i
].tv_sec
, (uint_t
)diff
[i
].tv_usec
);
284 /* TODO: let the test fail here, when we support async rpc on ncacn_np */
289 torture_comment(tctx
, "\n");
296 static bool test_enum(struct torture_context
*tctx
,
297 struct dcerpc_pipe
*p
)
300 struct echo_TestEnum r
;
301 enum echo_Enum1 v
= ECHO_ENUM1
;
302 struct echo_Enum2 e2
;
313 e2
.e2
= ECHO_ENUM1_32
;
316 status
= dcerpc_echo_TestEnum(p
, tctx
, &r
);
317 torture_assert_ntstatus_ok(tctx
, status
, "TestEnum failed");
322 test surrounding conformant array handling
324 static bool test_surrounding(struct torture_context
*tctx
,
325 struct dcerpc_pipe
*p
)
328 struct echo_TestSurrounding r
;
331 r
.in
.data
= talloc(tctx
, struct echo_Surrounding
);
334 r
.in
.data
->surrounding
= talloc_zero_array(tctx
, uint16_t, r
.in
.data
->x
);
336 r
.out
.data
= talloc(tctx
, struct echo_Surrounding
);
338 status
= dcerpc_echo_TestSurrounding(p
, tctx
, &r
);
339 torture_assert_ntstatus_ok(tctx
, status
, "TestSurrounding failed");
341 torture_assert(tctx
, r
.out
.data
->x
== 2 * r
.in
.data
->x
,
342 "TestSurrounding did not make the array twice as large");
348 test multiple levels of pointers
350 static bool test_doublepointer(struct torture_context
*tctx
,
351 struct dcerpc_pipe
*p
)
354 struct echo_TestDoublePointer r
;
356 uint16_t *pvalue
= &value
;
357 uint16_t **ppvalue
= &pvalue
;
360 r
.in
.data
= &ppvalue
;
362 status
= dcerpc_echo_TestDoublePointer(p
, tctx
, &r
);
363 torture_assert_ntstatus_ok(tctx
, status
, "TestDoublePointer failed");
365 torture_assert_int_equal(tctx
, value
, r
.out
.result
,
366 "TestDoublePointer did not return original value");
372 test request timeouts
374 #if 0 /* this test needs fixing to work over ncacn_np */
375 static bool test_timeout(struct torture_context
*tctx
,
376 struct dcerpc_pipe
*p
)
379 struct rpc_request
*req
;
380 struct echo_TestSleep r
;
381 int timeout_saved
= p
->request_timeout
;
383 if (torture_setting_bool(tctx
, "quick", false)) {
384 torture_skip(tctx
, "timeout testing disabled - use \"torture:quick=no\" to enable\n");
387 torture_comment(tctx
, "testing request timeouts\n");
389 p
->request_timeout
= 1;
391 req
= dcerpc_echo_TestSleep_send(p
, tctx
, &r
);
393 torture_comment(tctx
, "Failed to send async sleep request\n");
396 req
->ignore_timeout
= true;
398 status
= dcerpc_ndr_request_recv(req
);
399 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_IO_TIMEOUT
,
400 "request should have timed out");
402 torture_comment(tctx
, "testing request destruction\n");
403 req
= dcerpc_echo_TestSleep_send(p
, tctx
, &r
);
405 torture_comment(tctx
, "Failed to send async sleep request\n");
410 req
= dcerpc_echo_TestSleep_send(p
, tctx
, &r
);
412 torture_comment(tctx
, "Failed to send async sleep request\n");
415 req
->ignore_timeout
= true;
416 status
= dcerpc_ndr_request_recv(req
);
417 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_IO_TIMEOUT
,
418 "request should have timed out");
420 p
->request_timeout
= timeout_saved
;
422 return test_addone(tctx
, p
);
425 p
->request_timeout
= timeout_saved
;
430 struct torture_suite
*torture_rpc_echo(TALLOC_CTX
*mem_ctx
)
432 struct torture_suite
*suite
= torture_suite_create(
434 struct torture_rpc_tcase
*tcase
;
436 tcase
= torture_suite_add_rpc_iface_tcase(suite
, "echo",
439 torture_rpc_tcase_add_test(tcase
, "addone", test_addone
);
440 torture_rpc_tcase_add_test(tcase
, "sinkdata", test_sinkdata
);
441 torture_rpc_tcase_add_test(tcase
, "echodata", test_echodata
);
442 torture_rpc_tcase_add_test(tcase
, "sourcedata", test_sourcedata
);
443 torture_rpc_tcase_add_test(tcase
, "testcall", test_testcall
);
444 torture_rpc_tcase_add_test(tcase
, "testcall2", test_testcall2
);
445 torture_rpc_tcase_add_test(tcase
, "enum", test_enum
);
446 torture_rpc_tcase_add_test(tcase
, "surrounding", test_surrounding
);
447 torture_rpc_tcase_add_test(tcase
, "doublepointer", test_doublepointer
);
448 torture_rpc_tcase_add_test(tcase
, "sleep", test_sleep
);
449 #if 0 /* this test needs fixing to work over ncacn_np */
450 torture_rpc_tcase_add_test(tcase
, "timeout", test_timeout
);