r26238: Add a loadparm context parameter to torture_context, remove more uses of...
[gd/samba-autobuild/.git] / source4 / torture / raw / composite.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    libcli composite function testing
5
6    Copyright (C) Andrew Tridgell 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 3 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, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "torture/torture.h"
24 #include "lib/events/events.h"
25 #include "libcli/raw/libcliraw.h"
26 #include "libcli/libcli.h"
27 #include "libcli/security/security.h"
28 #include "libcli/composite/composite.h"
29 #include "libcli/smb_composite/smb_composite.h"
30 #include "librpc/gen_ndr/ndr_misc.h"
31 #include "lib/cmdline/popt_common.h"
32 #include "torture/util.h"
33 #include "param/param.h"
34
35 #define BASEDIR "\\composite"
36
37 static void loadfile_complete(struct composite_context *c)
38 {
39         int *count = talloc_get_type(c->async.private_data, int);
40         (*count)++;
41 }
42
43 /*
44   test a simple savefile/loadfile combination
45 */
46 static bool test_loadfile(struct smbcli_state *cli, struct torture_context *tctx)
47 {
48         const char *fname = BASEDIR "\\test.txt";
49         NTSTATUS status;
50         struct smb_composite_savefile io1;
51         struct smb_composite_loadfile io2;
52         struct composite_context **c;
53         uint8_t *data;
54         size_t len = random() % 100000;
55         const int num_ops = 50;
56         int i;
57         int *count = talloc_zero(tctx, int);
58
59         data = talloc_array(tctx, uint8_t, len);
60
61         generate_random_buffer(data, len);
62
63         io1.in.fname = fname;
64         io1.in.data  = data;
65         io1.in.size  = len;
66
67         printf("testing savefile\n");
68
69         status = smb_composite_savefile(cli->tree, &io1);
70         if (!NT_STATUS_IS_OK(status)) {
71                 printf("(%s) savefile failed: %s\n", __location__,nt_errstr(status));
72                 return false;
73         }
74
75         io2.in.fname = fname;
76
77         printf("testing parallel loadfile with %d ops\n", num_ops);
78
79         c = talloc_array(tctx, struct composite_context *, num_ops);
80
81         for (i=0;i<num_ops;i++) {
82                 c[i] = smb_composite_loadfile_send(cli->tree, &io2);
83                 c[i]->async.fn = loadfile_complete;
84                 c[i]->async.private_data = count;
85         }
86
87         printf("waiting for completion\n");
88         while (*count != num_ops) {
89                 event_loop_once(cli->transport->socket->event.ctx);
90                 if (torture_setting_bool(tctx, "progress", true)) {
91                         printf("(%s) count=%d\r", __location__, *count);
92                         fflush(stdout);
93                 }
94         }
95         printf("count=%d\n", *count);
96         
97         for (i=0;i<num_ops;i++) {
98                 status = smb_composite_loadfile_recv(c[i], tctx);
99                 if (!NT_STATUS_IS_OK(status)) {
100                         printf("(%s) loadfile[%d] failed - %s\n", __location__, i, nt_errstr(status));
101                         return false;
102                 }
103
104                 if (io2.out.size != len) {
105                         printf("(%s) wrong length in returned data - %d should be %d\n",__location__,
106                                io2.out.size, (int)len);
107                         return false;
108                 }
109                 
110                 if (memcmp(io2.out.data, data, len) != 0) {
111                         printf("(%s) wrong data in loadfile!\n",__location__);
112                         return false;
113                 }
114         }
115
116         talloc_free(data);
117
118         return true;
119 }
120
121 /*
122   test a simple savefile/loadfile combination
123 */
124 static bool test_fetchfile(struct smbcli_state *cli, struct torture_context *tctx)
125 {
126         const char *fname = BASEDIR "\\test.txt";
127         NTSTATUS status;
128         struct smb_composite_savefile io1;
129         struct smb_composite_fetchfile io2;
130         struct composite_context **c;
131         uint8_t *data;
132         int i;
133         size_t len = random() % 10000;
134         extern int torture_numops;
135         struct event_context *event_ctx;
136         int *count = talloc_zero(tctx, int);
137         bool ret = true;
138
139         data = talloc_array(tctx, uint8_t, len);
140
141         generate_random_buffer(data, len);
142
143         io1.in.fname = fname;
144         io1.in.data  = data;
145         io1.in.size  = len;
146
147         printf("testing savefile\n");
148
149         status = smb_composite_savefile(cli->tree, &io1);
150         if (!NT_STATUS_IS_OK(status)) {
151                 printf("(%s) savefile failed: %s\n",__location__, nt_errstr(status));
152                 return false;
153         }
154
155         io2.in.dest_host = torture_setting_string(tctx, "host", NULL);
156         io2.in.port = 0;
157         io2.in.called_name = torture_setting_string(tctx, "host", NULL);
158         io2.in.service = torture_setting_string(tctx, "share", NULL);
159         io2.in.service_type = "A:";
160
161         io2.in.credentials = cmdline_credentials;
162         io2.in.workgroup  = lp_workgroup(tctx->lp_ctx);
163         io2.in.filename = fname;
164
165         printf("testing parallel fetchfile with %d ops\n", torture_numops);
166
167         event_ctx = cli->transport->socket->event.ctx;
168         c = talloc_array(tctx, struct composite_context *, torture_numops);
169
170         for (i=0; i<torture_numops; i++) {
171                 c[i] = smb_composite_fetchfile_send(&io2, event_ctx);
172                 c[i]->async.fn = loadfile_complete;
173                 c[i]->async.private_data = count;
174         }
175
176         printf("waiting for completion\n");
177
178         while (*count != torture_numops) {
179                 event_loop_once(event_ctx);
180                 if (torture_setting_bool(tctx, "progress", true)) {
181                         printf("(%s) count=%d\r", __location__, *count);
182                         fflush(stdout);
183                 }
184         }
185         printf("count=%d\n", *count);
186
187         for (i=0;i<torture_numops;i++) {
188                 status = smb_composite_fetchfile_recv(c[i], tctx);
189                 if (!NT_STATUS_IS_OK(status)) {
190                         printf("(%s) loadfile[%d] failed - %s\n", __location__, i,
191                                nt_errstr(status));
192                         ret = false;
193                         continue;
194                 }
195
196                 if (io2.out.size != len) {
197                         printf("(%s) wrong length in returned data - %d "
198                                "should be %d\n", __location__,
199                                io2.out.size, (int)len);
200                         ret = false;
201                         continue;
202                 }
203                 
204                 if (memcmp(io2.out.data, data, len) != 0) {
205                         printf("(%s) wrong data in loadfile!\n", __location__);
206                         ret = false;
207                         continue;
208                 }
209         }
210
211         return ret;
212 }
213
214 /*
215   test setfileacl
216 */
217 static bool test_appendacl(struct smbcli_state *cli, struct torture_context *tctx)
218 {
219         struct smb_composite_appendacl **io;
220         struct smb_composite_appendacl **io_orig;
221         struct composite_context **c;
222         struct event_context *event_ctx;
223
224         struct security_descriptor *test_sd;
225         struct security_ace *ace;
226         struct dom_sid *test_sid;
227
228         const int num_ops = 50;
229         int *count = talloc_zero(tctx, int);
230         struct smb_composite_savefile io1;
231
232         NTSTATUS status;
233         int i;
234
235         io_orig = talloc_array(tctx, struct smb_composite_appendacl *, num_ops);
236
237         printf ("creating %d empty files and getting their acls with appendacl\n", num_ops);
238
239         for (i = 0; i < num_ops; i++) {
240                 io1.in.fname = talloc_asprintf(io_orig, BASEDIR "\\test%d.txt", i);
241                 io1.in.data  = NULL;
242                 io1.in.size  = 0;
243           
244                 status = smb_composite_savefile(cli->tree, &io1);
245                 if (!NT_STATUS_IS_OK(status)) {
246                         printf("(%s) savefile failed: %s\n", __location__, nt_errstr(status));
247                         return false;
248                 }
249
250                 io_orig[i] = talloc (io_orig, struct smb_composite_appendacl);
251                 io_orig[i]->in.fname = talloc_steal(io_orig[i], io1.in.fname);
252                 io_orig[i]->in.sd = security_descriptor_initialise(io_orig[i]);
253                 status = smb_composite_appendacl(cli->tree, io_orig[i], io_orig[i]);
254                 if (!NT_STATUS_IS_OK(status)) {
255                         printf("(%s) appendacl failed: %s\n", __location__, nt_errstr(status));
256                         return false;
257                 }
258         }
259         
260
261         /* fill Security Descriptor with aces to be added */
262
263         test_sd = security_descriptor_initialise(tctx);
264         test_sid = dom_sid_parse_talloc (tctx, "S-1-5-32-1234-5432");
265
266         ace = talloc_zero(tctx, struct security_ace);
267
268         ace->type = SEC_ACE_TYPE_ACCESS_ALLOWED;
269         ace->flags = 0;
270         ace->access_mask = SEC_STD_ALL;
271         ace->trustee = *test_sid;
272
273         status = security_descriptor_dacl_add(test_sd, ace);
274         if (!NT_STATUS_IS_OK(status)) {
275                 printf("(%s) appendacl failed: %s\n", __location__, nt_errstr(status));
276                 return false;
277         }
278
279         /* set parameters for appendacl async call */
280
281         printf("testing parallel appendacl with %d ops\n", num_ops);
282
283         c = talloc_array(tctx, struct composite_context *, num_ops);
284         io = talloc_array(tctx, struct  smb_composite_appendacl *, num_ops);
285
286         for (i=0; i < num_ops; i++) {
287                 io[i] = talloc (io, struct smb_composite_appendacl);
288                 io[i]->in.sd = test_sd;
289                 io[i]->in.fname = talloc_asprintf(io[i], BASEDIR "\\test%d.txt", i);
290
291                 c[i] = smb_composite_appendacl_send(cli->tree, io[i]);
292                 c[i]->async.fn = loadfile_complete;
293                 c[i]->async.private_data = count;
294         }
295
296         event_ctx = talloc_reference(tctx, cli->tree->session->transport->socket->event.ctx);
297         printf("waiting for completion\n");
298         while (*count != num_ops) {
299                 event_loop_once(event_ctx);
300                 if (torture_setting_bool(tctx, "progress", true)) {
301                         printf("(%s) count=%d\r", __location__, *count);
302                         fflush(stdout);
303                 }
304         }
305         printf("count=%d\n", *count);
306
307         for (i=0; i < num_ops; i++) {
308                 status = smb_composite_appendacl_recv(c[i], io[i]);
309                 if (!NT_STATUS_IS_OK(status)) {
310                         printf("(%s) appendacl[%d] failed - %s\n", __location__, i, nt_errstr(status));
311                         return false;
312                 }
313                 
314                 security_descriptor_dacl_add(io_orig[i]->out.sd, ace);
315                 if (!security_acl_equal(io_orig[i]->out.sd->dacl, io[i]->out.sd->dacl)) {
316                         printf("(%s) appendacl[%d] failed - needed acl isn't set\n", __location__, i);
317                         return false;
318                 }
319         }
320         
321
322         talloc_free (ace);
323         talloc_free (test_sid);
324         talloc_free (test_sd);
325                 
326         return true;
327 }
328
329 /* test a query FS info by asking for share's GUID */
330 static bool test_fsinfo(struct smbcli_state *cli, struct torture_context *tctx)
331 {
332         char *guid = NULL;
333         NTSTATUS status;
334         struct smb_composite_fsinfo io1;
335         struct composite_context **c;
336
337         int i;
338         extern int torture_numops;
339         struct event_context *event_ctx;
340         int *count = talloc_zero(tctx, int);
341         bool ret = true;
342
343         io1.in.dest_host = torture_setting_string(tctx, "host", NULL);
344         io1.in.port = 0;
345         io1.in.called_name = torture_setting_string(tctx, "host", NULL);
346         io1.in.service = torture_setting_string(tctx, "share", NULL);
347         io1.in.service_type = "A:";
348         io1.in.credentials = cmdline_credentials;
349         io1.in.workgroup = lp_workgroup(tctx->lp_ctx);
350         io1.in.level = RAW_QFS_OBJECTID_INFORMATION;
351
352         printf("testing parallel queryfsinfo [Object ID] with %d ops\n", torture_numops);
353
354         event_ctx = talloc_reference(tctx, cli->tree->session->transport->socket->event.ctx);
355         c = talloc_array(tctx, struct composite_context *, torture_numops);
356
357         for (i=0; i<torture_numops; i++) {
358                 c[i] = smb_composite_fsinfo_send(cli->tree,&io1);
359                 c[i]->async.fn = loadfile_complete;
360                 c[i]->async.private_data = count;
361         }
362
363         printf("waiting for completion\n");
364
365         while (*count < torture_numops) {
366                 event_loop_once(event_ctx);
367                 if (torture_setting_bool(tctx, "progress", true)) {
368                         printf("(%s) count=%d\r", __location__, *count);
369                         fflush(stdout);
370                 }
371         }
372         printf("count=%d\n", *count);
373
374         for (i=0;i<torture_numops;i++) {
375                 status = smb_composite_fsinfo_recv(c[i], tctx);
376                 if (!NT_STATUS_IS_OK(status)) {
377                         printf("(%s) fsinfo[%d] failed - %s\n", __location__, i, nt_errstr(status));
378                         ret = false;
379                         continue;
380                 }
381
382                 if (io1.out.fsinfo->generic.level != RAW_QFS_OBJECTID_INFORMATION) {
383                         printf("(%s) wrong level in returned info - %d "
384                                "should be %d\n", __location__,
385                                io1.out.fsinfo->generic.level, RAW_QFS_OBJECTID_INFORMATION);
386                         ret = false;
387                         continue;
388                 }
389
390                 guid=GUID_string(tctx, &io1.out.fsinfo->objectid_information.out.guid);
391                 printf("[%d] GUID: %s\n", i, guid);
392
393                 
394         }
395
396         return ret;
397 }
398
399
400 /* 
401    basic testing of libcli composite calls
402 */
403 bool torture_raw_composite(struct torture_context *tctx, 
404                            struct smbcli_state *cli)
405 {
406         bool ret = true;
407
408         if (!torture_setup_dir(cli, BASEDIR)) {
409                 return false;
410         }
411
412         ret &= test_fetchfile(cli, tctx);
413         ret &= test_loadfile(cli, tctx);
414         ret &= test_appendacl(cli, tctx);
415         ret &= test_fsinfo(cli, tctx);
416
417         smb_raw_exit(cli->session);
418         smbcli_deltree(cli->tree, BASEDIR);
419
420         return ret;
421 }