r5393: trigger timed events not to early, better do it a bit to late
[samba.git] / source4 / torture / rpc / echo.c
1 /* 
2    Unix SMB/CIFS implementation.
3    test suite for echo rpc operations
4
5    Copyright (C) Andrew Tridgell 2003
6    Copyright (C) Stefan (metze) Metzmacher 2005
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include "includes.h"
24 #include "lib/events/events.h"
25 #include "librpc/gen_ndr/ndr_echo.h"
26
27
28 /*
29   test the AddOne interface
30 */
31 static BOOL test_addone(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
32 {
33         int i;
34         NTSTATUS status;
35
36         printf("\nTesting AddOne\n");
37
38         for (i=0;i<10;i++) {
39                 uint32_t n = i;
40                 struct echo_AddOne r;
41                 r.in.v = &n;
42                 r.out.v = &n;
43                 status = dcerpc_echo_AddOne(p, mem_ctx, &r);
44                 if (!NT_STATUS_IS_OK(status)) {
45                         printf("AddOne(%d) failed - %s\n", i, nt_errstr(status));
46                         return False;
47                 }
48                 printf("%d + 1 = %u\n", i, n);
49         }
50
51         return True;
52 }
53
54 /*
55   test the EchoData interface
56 */
57 static BOOL test_echodata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
58 {
59         int i;
60         NTSTATUS status;
61         uint8_t *data_in, *data_out;
62         int len = 1 + (random() % 5000);
63         struct echo_EchoData r;
64
65         printf("\nTesting EchoData\n");
66
67         data_in = talloc_size(mem_ctx, len);
68         data_out = talloc_size(mem_ctx, len);
69         for (i=0;i<len;i++) {
70                 data_in[i] = i;
71         }
72         
73         r.in.len = len;
74         r.in.in_data = data_in;
75
76         status = dcerpc_echo_EchoData(p, mem_ctx, &r);
77         if (!NT_STATUS_IS_OK(status)) {
78                 printf("EchoData(%d) failed - %s\n", len, nt_errstr(status));
79                 return False;
80         }
81
82         data_out = r.out.out_data;
83
84         for (i=0;i<len;i++) {
85                 if (data_in[i] != data_out[i]) {
86                         printf("Bad data returned for len %d at offset %d\n", 
87                                len, i);
88                         printf("in:\n");
89                         dump_data(0, data_in+i, MIN(len-i, 16));
90                         printf("out:\n");
91                         dump_data(0, data_out+i, MIN(len-1, 16));
92                         return False;
93                 }
94         }
95
96
97         return True;
98 }
99
100
101 /*
102   test the SourceData interface
103 */
104 static BOOL test_sourcedata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
105 {
106         int i;
107         NTSTATUS status;
108         int len = 200000 + (random() % 5000);
109         uint8_t *data_out;
110         struct echo_SourceData r;
111
112         printf("\nTesting SourceData\n");
113
114         data_out = talloc_size(mem_ctx, len);
115
116         r.in.len = len;
117         r.out.data = data_out;
118
119         status = dcerpc_echo_SourceData(p, mem_ctx, &r);
120         if (!NT_STATUS_IS_OK(status)) {
121                 printf("SourceData(%d) failed - %s\n", len, nt_errstr(status));
122                 return False;
123         }
124
125         for (i=0;i<len;i++) {
126                 uint8_t *v = (uint8_t *)data_out;
127                 if (v[i] != (i & 0xFF)) {
128                         printf("bad data 0x%x at %d\n", (uint8_t)data_out[i], i);
129                         return False;
130                 }
131         }
132
133         return True;
134 }
135
136 /*
137   test the SinkData interface
138 */
139 static BOOL test_sinkdata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
140 {
141         int i;
142         NTSTATUS status;
143         uint8_t *data_in;
144         int len = 200000 + (random() % 5000);
145         struct echo_SinkData r;
146
147         printf("\nTesting SinkData\n");
148
149         data_in = talloc_size(mem_ctx, len);
150         for (i=0;i<len;i++) {
151                 data_in[i] = i+1;
152         }
153
154         r.in.len = len;
155         r.in.data = data_in;
156
157         status = dcerpc_echo_SinkData(p, mem_ctx, &r);
158         if (!NT_STATUS_IS_OK(status)) {
159                 printf("SinkData(%d) failed - %s\n", len, nt_errstr(status));
160                 return False;
161         }
162
163         printf("sunk %d bytes\n", len);
164
165         return True;
166 }
167
168
169 /*
170   test the testcall interface
171 */
172 static BOOL test_testcall(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
173 {
174         NTSTATUS status;
175         struct echo_TestCall r;
176
177         r.in.s1 = "input string";
178
179         printf("\nTesting TestCall\n");
180         status = dcerpc_echo_TestCall(p, mem_ctx, &r);
181         if (!NT_STATUS_IS_OK(status)) {
182                 printf("TestCall failed - %s\n", nt_errstr(status));
183                 return False;
184         }
185
186         return True;
187 }
188
189 /*
190   test the testcall interface
191 */
192 static BOOL test_testcall2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
193 {
194         NTSTATUS status;
195         struct echo_TestCall2 r;
196         int i;
197         BOOL ret = True;
198
199         for (i=1;i<=7;i++) {
200                 r.in.level = i;
201
202                 printf("\nTesting TestCall2 level %d\n", i);
203                 status = dcerpc_echo_TestCall2(p, mem_ctx, &r);
204                 if (!NT_STATUS_IS_OK(status)) {
205                         printf("TestCall2 failed - %s\n", nt_errstr(status));
206                         ret = False;
207                 }
208         }
209
210         return ret;
211 }
212
213 /*
214   test the TestSleep interface
215 */
216 static BOOL test_sleep(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
217 {
218         int i;
219         NTSTATUS status;
220 #define ASYNC_COUNT 3
221         struct rpc_request *req[ASYNC_COUNT];
222         struct echo_TestSleep r[ASYNC_COUNT];
223         BOOL done[ASYNC_COUNT];
224         struct timeval snd[ASYNC_COUNT];
225         struct timeval rcv[ASYNC_COUNT];
226         struct timeval diff[ASYNC_COUNT];
227         struct event_context *ctx;
228         int total_done = 0;
229         BOOL ret = True;
230
231         printf("\nTesting TestSleep\n");
232
233         for (i=0;i<ASYNC_COUNT;i++) {
234                 done[i]         = False;
235                 snd[i]          = timeval_current();
236                 rcv[i]          = timeval_zero();
237                 r[i].in.seconds = ASYNC_COUNT-i;
238                 req[i] = dcerpc_echo_TestSleep_send(p, mem_ctx, &r[i]);
239                 if (!req[i]) {
240                         printf("Failed to send async sleep request\n");
241                         return False;
242                 }
243         }
244
245         ctx = dcerpc_event_context(p);
246         while (total_done < ASYNC_COUNT) {
247                 if (event_loop_once(ctx) != 0) {
248                         return False;
249                 }
250                 for (i=0;i<ASYNC_COUNT;i++) {
251                         if (done[i] == False && req[i]->state == RPC_REQUEST_DONE) {
252                                 total_done++;
253                                 done[i] = True;
254                                 rcv[i]  = timeval_current();
255                                 diff[i] = timeval_diff(&rcv[i], &snd[i]);
256                                 status  = dcerpc_ndr_request_recv(req[i]);
257                                 if (!NT_STATUS_IS_OK(status)) {
258                                         printf("TestSleep(%d) failed - %s\n",
259                                                i, nt_errstr(status));
260                                         ret = False;
261                                 } else if (r[i].out.result != r[i].in.seconds) {
262                                         printf("Failed - Sleeped for %u seconds (but we said %u seconds and the reply takes only %u seconds)\n", 
263                                                 r[i].out.result, r[i].in.seconds, (uint_t)diff[i].tv_sec);
264                                         ret = False;
265                                 } else {
266                                         if (r[i].out.result > diff[i].tv_sec+1) {
267                                                 printf("Failed - Sleeped for %u seconds (but reply takes only %u seconds)\n", 
268                                                         r[i].out.result, (uint_t)diff[i].tv_sec);
269                                                 ret = False;
270                                         } else if (r[i].out.result+1 == diff[i].tv_sec) {
271                                                 printf("Sleeped for %u seconds (but reply takes %u seconds - busy server?)\n", 
272                                                         r[i].out.result, (uint_t)diff[i].tv_sec);
273                                         } else if (r[i].out.result == diff[i].tv_sec) {
274                                                 printf("Sleeped for %u seconds (reply takes %u seconds - ok)\n", 
275                                                         r[i].out.result, (uint_t)diff[i].tv_sec);
276                                         } else {
277                                                 printf("(Failed) - Not async - Sleeped for %u seconds (but reply takes %u seconds)\n", 
278                                                         r[i].out.result, (uint_t)diff[i].tv_sec);
279                                                 /* TODO: let the test fail here, when we support async rpc on ncacn_np
280                                                 ret = False;*/
281                                         }
282                                 }
283                         }
284                 }
285         }
286
287         return ret;
288 }
289
290 /*
291   test enum handling
292 */
293 static BOOL test_enum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
294 {
295         NTSTATUS status;
296         struct echo_TestEnum r;
297         BOOL ret = True;
298         enum echo_Enum1 v = ECHO_ENUM1;
299         struct echo_Enum2 e2;
300         union echo_Enum3 e3;
301
302         r.in.foo1 = &v;
303         r.in.foo2 = &e2;
304         r.in.foo3 = &e3;
305         r.out.foo1 = &v;
306         r.out.foo2 = &e2;
307         r.out.foo3 = &e3;
308
309         e2.e1 = 76;
310         e2.e2 = ECHO_ENUM1_32;
311         e3.e1 = ECHO_ENUM2;
312
313         printf("\nTesting TestEnum\n");
314         status = dcerpc_echo_TestEnum(p, mem_ctx, &r);
315         if (!NT_STATUS_IS_OK(status)) {
316                 printf("TestEnum failed - %s\n", nt_errstr(status));
317                 ret = False;
318         }
319
320         return ret;
321 }
322
323 BOOL torture_rpc_echo(void)
324 {
325         NTSTATUS status;
326         struct dcerpc_pipe *p;
327         TALLOC_CTX *mem_ctx;
328         BOOL ret = True;
329
330         mem_ctx = talloc_init("torture_rpc_echo");
331
332         status = torture_rpc_connection(&p, 
333                                         DCERPC_RPCECHO_NAME,
334                                         DCERPC_RPCECHO_UUID,
335                                         DCERPC_RPCECHO_VERSION);
336         if (!NT_STATUS_IS_OK(status)) {
337                 return False;
338         }
339
340         ret &= test_addone(p, mem_ctx);
341         ret &= test_sinkdata(p, mem_ctx);
342         ret &= test_echodata(p, mem_ctx);
343         ret &= test_sourcedata(p, mem_ctx);
344         ret &= test_testcall(p, mem_ctx);
345         ret &= test_testcall2(p, mem_ctx);
346         ret &= test_enum(p, mem_ctx);
347         ret &= test_sleep(p, mem_ctx);
348
349         printf("\n");
350         
351         talloc_free(mem_ctx);
352
353         torture_rpc_close(p);
354         return ret;
355 }