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/torture_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 torture_assert_ntstatus_ok(tctx, dcerpc_echo_AddOne_r(b, tctx, &r), \
37 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
)
48 struct dcerpc_binding_handle
*b
= p
->binding_handle
;
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
)
68 uint8_t *data_in
, *data_out
;
70 struct echo_EchoData r
;
71 struct dcerpc_binding_handle
*b
= p
->binding_handle
;
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 torture_assert_ntstatus_ok(tctx
, dcerpc_echo_EchoData_r(b
, tctx
, &r
),
90 talloc_asprintf(tctx
, "EchoData(%d) failed\n", len
));
92 data_out
= r
.out
.out_data
;
95 if (data_in
[i
] != data_out
[i
]) {
96 torture_comment(tctx
, "Bad data returned for len %d at offset %d\n",
98 torture_comment(tctx
, "in:\n");
99 dump_data(0, data_in
+i
, MIN(len
-i
, 16));
100 torture_comment(tctx
, "out:\n");
101 dump_data(0, data_out
+i
, MIN(len
-1, 16));
109 test the SourceData interface
111 static bool test_sourcedata(struct torture_context
*tctx
,
112 struct dcerpc_pipe
*p
)
116 struct echo_SourceData r
;
117 struct dcerpc_binding_handle
*b
= p
->binding_handle
;
119 if (torture_setting_bool(tctx
, "quick", false) &&
120 (p
->conn
->flags
& DCERPC_DEBUG_VALIDATE_BOTH
)) {
121 len
= 100 + (random() % 500);
123 len
= 200000 + (random() % 5000);
128 torture_assert_ntstatus_ok(tctx
, dcerpc_echo_SourceData_r(b
, tctx
, &r
),
129 talloc_asprintf(tctx
, "SourceData(%d) failed", len
));
131 for (i
=0;i
<len
;i
++) {
132 uint8_t *v
= (uint8_t *)r
.out
.data
;
133 torture_assert(tctx
, v
[i
] == (i
& 0xFF),
134 talloc_asprintf(tctx
,
135 "bad data 0x%x at %d\n", (uint8_t)r
.out
.data
[i
], i
));
141 test the SinkData interface
143 static bool test_sinkdata(struct torture_context
*tctx
,
144 struct dcerpc_pipe
*p
)
149 struct echo_SinkData r
;
150 struct dcerpc_binding_handle
*b
= p
->binding_handle
;
152 if (torture_setting_bool(tctx
, "quick", false) &&
153 (p
->conn
->flags
& DCERPC_DEBUG_VALIDATE_BOTH
)) {
154 len
= 100 + (random() % 5000);
156 len
= 200000 + (random() % 5000);
159 data_in
= talloc_array(tctx
, uint8_t, len
);
160 for (i
=0;i
<len
;i
++) {
167 torture_assert_ntstatus_ok(tctx
, dcerpc_echo_SinkData_r(b
, tctx
, &r
),
168 talloc_asprintf(tctx
, "SinkData(%d) failed", len
));
170 torture_comment(tctx
, "sunk %d bytes\n", len
);
176 test the testcall interface
178 static bool test_testcall(struct torture_context
*tctx
,
179 struct dcerpc_pipe
*p
)
181 struct echo_TestCall r
;
182 const char *s
= NULL
;
183 struct dcerpc_binding_handle
*b
= p
->binding_handle
;
185 r
.in
.s1
= "input string";
188 torture_assert_ntstatus_ok(tctx
, dcerpc_echo_TestCall_r(b
, tctx
, &r
),
191 torture_assert_str_equal(tctx
, s
, "input string", "Didn't receive back same string");
197 test the testcall interface
199 static bool test_testcall2(struct torture_context
*tctx
,
200 struct dcerpc_pipe
*p
)
202 struct echo_TestCall2 r
;
204 struct dcerpc_binding_handle
*b
= p
->binding_handle
;
208 r
.out
.info
= talloc(tctx
, union echo_Info
);
210 torture_comment(tctx
, "Testing TestCall2 level %d\n", i
);
211 torture_assert_ntstatus_ok(tctx
, dcerpc_echo_TestCall2_r(b
, tctx
, &r
),
213 torture_assert_ntstatus_ok(tctx
, r
.out
.result
, "TestCall2 failed");
218 static void test_sleep_done(struct tevent_req
*subreq
)
220 bool *done1
= (bool *)tevent_req_callback_data_void(subreq
);
225 test the TestSleep interface
227 static bool test_sleep(struct torture_context
*tctx
,
228 struct dcerpc_pipe
*p
)
231 #define ASYNC_COUNT 3
232 struct tevent_req
*req
[ASYNC_COUNT
];
233 struct echo_TestSleep r
[ASYNC_COUNT
];
234 bool done1
[ASYNC_COUNT
];
235 bool done2
[ASYNC_COUNT
];
236 struct timeval snd
[ASYNC_COUNT
];
237 struct timeval rcv
[ASYNC_COUNT
];
238 struct timeval diff
[ASYNC_COUNT
];
240 struct dcerpc_binding_handle
*b
= p
->binding_handle
;
241 enum dcerpc_transport_t transport
;
242 uint32_t assoc_group_id
;
243 struct dcerpc_pipe
*p2
= NULL
;
246 if (torture_setting_bool(tctx
, "quick", false)) {
247 torture_skip(tctx
, "TestSleep disabled - use \"torture:quick=no\" to enable\n");
249 torture_comment(tctx
, "Testing TestSleep - use \"torture:quick=yes\" to disable\n");
251 transport
= dcerpc_binding_get_transport(p
->binding
);
252 assoc_group_id
= dcerpc_binding_get_assoc_group_id(p
->binding
);
254 torture_comment(tctx
, "connect echo connection 2 with "
255 "DCERPC_CONCURRENT_MULTIPLEX\n");
256 status
= torture_rpc_connection_transport(tctx
, &p2
,
260 DCERPC_CONCURRENT_MULTIPLEX
);
261 torture_assert_ntstatus_ok(tctx
, status
, "opening echo connection 2");
262 b
= p2
->binding_handle
;
264 for (i
=0;i
<ASYNC_COUNT
;i
++) {
267 snd
[i
] = timeval_current();
268 rcv
[i
] = timeval_zero();
269 r
[i
].in
.seconds
= ASYNC_COUNT
-i
;
270 req
[i
] = dcerpc_echo_TestSleep_r_send(tctx
, tctx
->ev
, b
, &r
[i
]);
271 torture_assert(tctx
, req
[i
], "Failed to send async sleep request\n");
272 tevent_req_set_callback(req
[i
], test_sleep_done
, &done1
[i
]);
275 while (total_done
< ASYNC_COUNT
) {
276 torture_assert(tctx
, tevent_loop_once(tctx
->ev
) == 0,
277 "Event context loop failed");
278 for (i
=0;i
<ASYNC_COUNT
;i
++) {
279 if (done2
[i
] == false && done1
[i
] == true) {
283 rcv
[i
] = timeval_current();
284 diff
[i
] = tevent_timeval_until(
286 rounded_tdiff
= (int)(0.5 + diff
[i
].tv_sec
+ (1.0e-6*diff
[i
].tv_usec
));
287 torture_comment(tctx
, "rounded_tdiff=%d\n", rounded_tdiff
);
288 torture_assert_ntstatus_ok(tctx
,
289 dcerpc_echo_TestSleep_r_recv(req
[i
], tctx
),
290 talloc_asprintf(tctx
, "TestSleep(%d) failed", i
));
291 torture_assert(tctx
, r
[i
].out
.result
== r
[i
].in
.seconds
,
292 talloc_asprintf(tctx
, "Failed - Asked to sleep for %u seconds (server replied with %u seconds and the reply takes only %u seconds)",
293 r
[i
].out
.result
, r
[i
].in
.seconds
, (unsigned int)diff
[i
].tv_sec
));
294 torture_assert(tctx
, r
[i
].out
.result
<= rounded_tdiff
,
295 talloc_asprintf(tctx
, "Failed - Slept for %u seconds (but reply takes only %u.%06u seconds)",
296 r
[i
].out
.result
, (unsigned int)diff
[i
].tv_sec
, (unsigned int)diff
[i
].tv_usec
));
297 if (r
[i
].out
.result
+1 == rounded_tdiff
) {
298 torture_comment(tctx
, "Slept for %u seconds (but reply takes %u.%06u seconds - busy server?)\n",
299 r
[i
].out
.result
, (unsigned int)diff
[i
].tv_sec
, (unsigned int)diff
[i
].tv_usec
);
300 } else if (r
[i
].out
.result
== rounded_tdiff
) {
301 torture_comment(tctx
, "Slept for %u seconds (reply takes %u.%06u seconds - ok)\n",
302 r
[i
].out
.result
, (unsigned int)diff
[i
].tv_sec
, (unsigned int)diff
[i
].tv_usec
);
304 torture_fail(tctx
, talloc_asprintf(tctx
,
305 "(Failed) - Not async - Slept for %u seconds (but reply takes %u.%06u seconds)\n",
306 r
[i
].out
.result
, (unsigned int)diff
[i
].tv_sec
, (unsigned int)diff
[i
].tv_usec
));
311 torture_comment(tctx
, "\n");
318 static bool test_enum(struct torture_context
*tctx
,
319 struct dcerpc_pipe
*p
)
321 struct echo_TestEnum r
;
322 enum echo_Enum1 v
= ECHO_ENUM1
;
323 struct echo_Enum2 e2
;
325 struct dcerpc_binding_handle
*b
= p
->binding_handle
;
335 e2
.e2
= ECHO_ENUM1_32
;
338 torture_assert_ntstatus_ok(tctx
, dcerpc_echo_TestEnum_r(b
, tctx
, &r
),
344 test surrounding conformant array handling
346 static bool test_surrounding(struct torture_context
*tctx
,
347 struct dcerpc_pipe
*p
)
349 struct echo_TestSurrounding r
;
350 struct dcerpc_binding_handle
*b
= p
->binding_handle
;
353 r
.in
.data
= talloc(tctx
, struct echo_Surrounding
);
356 r
.in
.data
->surrounding
= talloc_zero_array(tctx
, uint16_t, r
.in
.data
->x
);
358 r
.out
.data
= talloc(tctx
, struct echo_Surrounding
);
360 torture_assert_ntstatus_ok(tctx
, dcerpc_echo_TestSurrounding_r(b
, tctx
, &r
),
361 "TestSurrounding failed");
363 torture_assert(tctx
, r
.out
.data
->x
== 2 * r
.in
.data
->x
,
364 "TestSurrounding did not make the array twice as large");
370 test multiple levels of pointers
372 static bool test_doublepointer(struct torture_context
*tctx
,
373 struct dcerpc_pipe
*p
)
375 struct echo_TestDoublePointer r
;
377 uint16_t *pvalue
= &value
;
378 uint16_t **ppvalue
= &pvalue
;
379 struct dcerpc_binding_handle
*b
= p
->binding_handle
;
382 r
.in
.data
= &ppvalue
;
384 torture_assert_ntstatus_ok(tctx
, dcerpc_echo_TestDoublePointer_r(b
, tctx
, &r
),
385 "TestDoublePointer failed");
387 torture_assert_int_equal(tctx
, value
, r
.out
.result
,
388 "TestDoublePointer did not return original value");
394 test request timeouts
396 #if 0 /* this test needs fixing to work over ncacn_np */
397 static bool test_timeout(struct torture_context
*tctx
,
398 struct dcerpc_pipe
*p
)
401 struct rpc_request
*req
;
402 struct echo_TestSleep r
;
403 int timeout_saved
= p
->request_timeout
;
405 if (torture_setting_bool(tctx
, "quick", false)) {
406 torture_skip(tctx
, "timeout testing disabled - use \"torture:quick=no\" to enable\n");
409 torture_comment(tctx
, "testing request timeouts\n");
411 p
->request_timeout
= 1;
413 req
= dcerpc_echo_TestSleep_send(p
, tctx
, &r
);
415 torture_comment(tctx
, "Failed to send async sleep request\n");
418 req
->ignore_timeout
= true;
420 status
= dcerpc_echo_TestSleep_recv(req
);
421 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_IO_TIMEOUT
,
422 "request should have timed out");
424 torture_comment(tctx
, "testing request destruction\n");
425 req
= dcerpc_echo_TestSleep_send(p
, tctx
, &r
);
427 torture_comment(tctx
, "Failed to send async sleep request\n");
432 req
= dcerpc_echo_TestSleep_send(p
, tctx
, &r
);
434 torture_comment(tctx
, "Failed to send async sleep request\n");
437 req
->ignore_timeout
= true;
438 status
= dcerpc_echo_TestSleep_recv(req
);
439 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_IO_TIMEOUT
,
440 "request should have timed out");
442 p
->request_timeout
= timeout_saved
;
444 return test_addone(tctx
, p
);
447 p
->request_timeout
= timeout_saved
;
452 struct torture_suite
*torture_rpc_echo(TALLOC_CTX
*mem_ctx
)
454 struct torture_suite
*suite
= torture_suite_create(mem_ctx
, "echo");
455 struct torture_rpc_tcase
*tcase
;
457 tcase
= torture_suite_add_rpc_iface_tcase(suite
, "echo",
460 torture_rpc_tcase_add_test(tcase
, "addone", test_addone
);
461 torture_rpc_tcase_add_test(tcase
, "sinkdata", test_sinkdata
);
462 torture_rpc_tcase_add_test(tcase
, "echodata", test_echodata
);
463 torture_rpc_tcase_add_test(tcase
, "sourcedata", test_sourcedata
);
464 torture_rpc_tcase_add_test(tcase
, "testcall", test_testcall
);
465 torture_rpc_tcase_add_test(tcase
, "testcall2", test_testcall2
);
466 torture_rpc_tcase_add_test(tcase
, "enum", test_enum
);
467 torture_rpc_tcase_add_test(tcase
, "surrounding", test_surrounding
);
468 torture_rpc_tcase_add_test(tcase
, "doublepointer", test_doublepointer
);
469 torture_rpc_tcase_add_test(tcase
, "sleep", test_sleep
);
470 #if 0 /* this test needs fixing to work over ncacn_np */
471 torture_rpc_tcase_add_test(tcase
, "timeout", test_timeout
);