2 Unix SMB/CIFS implementation.
4 libcli composite function testing
6 Copyright (C) Andrew Tridgell 2005
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.
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.
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/>.
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 #include "libcli/resolve/resolve.h"
36 #define BASEDIR "\\composite"
38 static void loadfile_complete(struct composite_context
*c
)
40 int *count
= talloc_get_type(c
->async
.private_data
, int);
45 test a simple savefile/loadfile combination
47 static bool test_loadfile(struct smbcli_state
*cli
, struct torture_context
*tctx
)
49 const char *fname
= BASEDIR
"\\test.txt";
51 struct smb_composite_savefile io1
;
52 struct smb_composite_loadfile io2
;
53 struct composite_context
**c
;
55 size_t len
= random() % 100000;
56 const int num_ops
= 50;
58 int *count
= talloc_zero(tctx
, int);
60 data
= talloc_array(tctx
, uint8_t, len
);
62 generate_random_buffer(data
, len
);
68 printf("Testing savefile\n");
70 status
= smb_composite_savefile(cli
->tree
, &io1
);
71 if (!NT_STATUS_IS_OK(status
)) {
72 printf("(%s) savefile failed: %s\n", __location__
,nt_errstr(status
));
78 printf("Testing parallel loadfile with %d ops\n", num_ops
);
80 c
= talloc_array(tctx
, struct composite_context
*, num_ops
);
82 for (i
=0;i
<num_ops
;i
++) {
83 c
[i
] = smb_composite_loadfile_send(cli
->tree
, &io2
);
84 c
[i
]->async
.fn
= loadfile_complete
;
85 c
[i
]->async
.private_data
= count
;
88 printf("waiting for completion\n");
89 while (*count
!= num_ops
) {
90 event_loop_once(cli
->transport
->socket
->event
.ctx
);
91 if (torture_setting_bool(tctx
, "progress", true)) {
92 printf("(%s) count=%d\r", __location__
, *count
);
96 printf("count=%d\n", *count
);
98 for (i
=0;i
<num_ops
;i
++) {
99 status
= smb_composite_loadfile_recv(c
[i
], tctx
);
100 if (!NT_STATUS_IS_OK(status
)) {
101 printf("(%s) loadfile[%d] failed - %s\n", __location__
, i
, nt_errstr(status
));
105 if (io2
.out
.size
!= len
) {
106 printf("(%s) wrong length in returned data - %d should be %d\n",__location__
,
107 io2
.out
.size
, (int)len
);
111 if (memcmp(io2
.out
.data
, data
, len
) != 0) {
112 printf("(%s) wrong data in loadfile!\n",__location__
);
123 test a simple savefile/loadfile combination
125 static bool test_fetchfile(struct smbcli_state
*cli
, struct torture_context
*tctx
)
127 const char *fname
= BASEDIR
"\\test.txt";
129 struct smb_composite_savefile io1
;
130 struct smb_composite_fetchfile io2
;
131 struct composite_context
**c
;
134 size_t len
= random() % 10000;
135 extern int torture_numops
;
136 struct tevent_context
*event_ctx
;
137 int *count
= talloc_zero(tctx
, int);
140 data
= talloc_array(tctx
, uint8_t, len
);
142 generate_random_buffer(data
, len
);
144 io1
.in
.fname
= fname
;
148 printf("Testing savefile\n");
150 status
= smb_composite_savefile(cli
->tree
, &io1
);
151 if (!NT_STATUS_IS_OK(status
)) {
152 printf("(%s) savefile failed: %s\n",__location__
, nt_errstr(status
));
156 io2
.in
.dest_host
= torture_setting_string(tctx
, "host", NULL
);
157 io2
.in
.ports
= lp_smb_ports(tctx
->lp_ctx
);
158 io2
.in
.called_name
= torture_setting_string(tctx
, "host", NULL
);
159 io2
.in
.service
= torture_setting_string(tctx
, "share", NULL
);
160 io2
.in
.service_type
= "A:";
162 io2
.in
.credentials
= cmdline_credentials
;
163 io2
.in
.workgroup
= lp_workgroup(tctx
->lp_ctx
);
164 io2
.in
.filename
= fname
;
165 io2
.in
.resolve_ctx
= lp_resolve_context(tctx
->lp_ctx
);
166 io2
.in
.gensec_settings
= lp_gensec_settings(tctx
, tctx
->lp_ctx
);
167 lp_smbcli_options(tctx
->lp_ctx
, &io2
.in
.options
);
168 lp_smbcli_session_options(tctx
->lp_ctx
, &io2
.in
.session_options
);
170 printf("Testing parallel fetchfile with %d ops\n", torture_numops
);
172 event_ctx
= cli
->transport
->socket
->event
.ctx
;
173 c
= talloc_array(tctx
, struct composite_context
*, torture_numops
);
175 for (i
=0; i
<torture_numops
; i
++) {
176 c
[i
] = smb_composite_fetchfile_send(&io2
, event_ctx
);
177 c
[i
]->async
.fn
= loadfile_complete
;
178 c
[i
]->async
.private_data
= count
;
181 printf("waiting for completion\n");
183 while (*count
!= torture_numops
) {
184 event_loop_once(event_ctx
);
185 if (torture_setting_bool(tctx
, "progress", true)) {
186 printf("(%s) count=%d\r", __location__
, *count
);
190 printf("count=%d\n", *count
);
192 for (i
=0;i
<torture_numops
;i
++) {
193 status
= smb_composite_fetchfile_recv(c
[i
], tctx
);
194 if (!NT_STATUS_IS_OK(status
)) {
195 printf("(%s) loadfile[%d] failed - %s\n", __location__
, i
,
201 if (io2
.out
.size
!= len
) {
202 printf("(%s) wrong length in returned data - %d "
203 "should be %d\n", __location__
,
204 io2
.out
.size
, (int)len
);
209 if (memcmp(io2
.out
.data
, data
, len
) != 0) {
210 printf("(%s) wrong data in loadfile!\n", __location__
);
222 static bool test_appendacl(struct smbcli_state
*cli
, struct torture_context
*tctx
)
224 struct smb_composite_appendacl
**io
;
225 struct smb_composite_appendacl
**io_orig
;
226 struct composite_context
**c
;
227 struct tevent_context
*event_ctx
;
229 struct security_descriptor
*test_sd
;
230 struct security_ace
*ace
;
231 struct dom_sid
*test_sid
;
233 const int num_ops
= 50;
234 int *count
= talloc_zero(tctx
, int);
235 struct smb_composite_savefile io1
;
240 io_orig
= talloc_array(tctx
, struct smb_composite_appendacl
*, num_ops
);
242 printf ("creating %d empty files and getting their acls with appendacl\n", num_ops
);
244 for (i
= 0; i
< num_ops
; i
++) {
245 io1
.in
.fname
= talloc_asprintf(io_orig
, BASEDIR
"\\test%d.txt", i
);
249 status
= smb_composite_savefile(cli
->tree
, &io1
);
250 if (!NT_STATUS_IS_OK(status
)) {
251 printf("(%s) savefile failed: %s\n", __location__
, nt_errstr(status
));
255 io_orig
[i
] = talloc (io_orig
, struct smb_composite_appendacl
);
256 io_orig
[i
]->in
.fname
= talloc_steal(io_orig
[i
], io1
.in
.fname
);
257 io_orig
[i
]->in
.sd
= security_descriptor_initialise(io_orig
[i
]);
258 status
= smb_composite_appendacl(cli
->tree
, io_orig
[i
], io_orig
[i
]);
259 if (!NT_STATUS_IS_OK(status
)) {
260 printf("(%s) appendacl failed: %s\n", __location__
, nt_errstr(status
));
266 /* fill Security Descriptor with aces to be added */
268 test_sd
= security_descriptor_initialise(tctx
);
269 test_sid
= dom_sid_parse_talloc (tctx
, "S-1-5-32-1234-5432");
271 ace
= talloc_zero(tctx
, struct security_ace
);
273 ace
->type
= SEC_ACE_TYPE_ACCESS_ALLOWED
;
275 ace
->access_mask
= SEC_STD_ALL
;
276 ace
->trustee
= *test_sid
;
278 status
= security_descriptor_dacl_add(test_sd
, ace
);
279 if (!NT_STATUS_IS_OK(status
)) {
280 printf("(%s) appendacl failed: %s\n", __location__
, nt_errstr(status
));
284 /* set parameters for appendacl async call */
286 printf("Testing parallel appendacl with %d ops\n", num_ops
);
288 c
= talloc_array(tctx
, struct composite_context
*, num_ops
);
289 io
= talloc_array(tctx
, struct smb_composite_appendacl
*, num_ops
);
291 for (i
=0; i
< num_ops
; i
++) {
292 io
[i
] = talloc (io
, struct smb_composite_appendacl
);
293 io
[i
]->in
.sd
= test_sd
;
294 io
[i
]->in
.fname
= talloc_asprintf(io
[i
], BASEDIR
"\\test%d.txt", i
);
296 c
[i
] = smb_composite_appendacl_send(cli
->tree
, io
[i
]);
297 c
[i
]->async
.fn
= loadfile_complete
;
298 c
[i
]->async
.private_data
= count
;
301 event_ctx
= tctx
->ev
;
302 printf("waiting for completion\n");
303 while (*count
!= num_ops
) {
304 event_loop_once(event_ctx
);
305 if (torture_setting_bool(tctx
, "progress", true)) {
306 printf("(%s) count=%d\r", __location__
, *count
);
310 printf("count=%d\n", *count
);
312 for (i
=0; i
< num_ops
; i
++) {
313 status
= smb_composite_appendacl_recv(c
[i
], io
[i
]);
314 if (!NT_STATUS_IS_OK(status
)) {
315 printf("(%s) appendacl[%d] failed - %s\n", __location__
, i
, nt_errstr(status
));
319 security_descriptor_dacl_add(io_orig
[i
]->out
.sd
, ace
);
320 if (!security_acl_equal(io_orig
[i
]->out
.sd
->dacl
, io
[i
]->out
.sd
->dacl
)) {
321 printf("(%s) appendacl[%d] failed - needed acl isn't set\n", __location__
, i
);
328 talloc_free (test_sid
);
329 talloc_free (test_sd
);
334 /* test a query FS info by asking for share's GUID */
335 static bool test_fsinfo(struct smbcli_state
*cli
, struct torture_context
*tctx
)
339 struct smb_composite_fsinfo io1
;
340 struct composite_context
**c
;
343 extern int torture_numops
;
344 struct tevent_context
*event_ctx
;
345 int *count
= talloc_zero(tctx
, int);
348 io1
.in
.dest_host
= torture_setting_string(tctx
, "host", NULL
);
349 io1
.in
.dest_ports
= lp_smb_ports(tctx
->lp_ctx
);
350 io1
.in
.socket_options
= lp_socket_options(tctx
->lp_ctx
);
351 io1
.in
.called_name
= torture_setting_string(tctx
, "host", NULL
);
352 io1
.in
.service
= torture_setting_string(tctx
, "share", NULL
);
353 io1
.in
.service_type
= "A:";
354 io1
.in
.credentials
= cmdline_credentials
;
355 io1
.in
.workgroup
= lp_workgroup(tctx
->lp_ctx
);
356 io1
.in
.level
= RAW_QFS_OBJECTID_INFORMATION
;
357 io1
.in
.gensec_settings
= lp_gensec_settings(tctx
, tctx
->lp_ctx
);
359 printf("Testing parallel queryfsinfo [Object ID] with %d ops\n",
362 event_ctx
= tctx
->ev
;
363 c
= talloc_array(tctx
, struct composite_context
*, torture_numops
);
365 for (i
=0; i
<torture_numops
; i
++) {
366 c
[i
] = smb_composite_fsinfo_send(cli
->tree
, &io1
, lp_resolve_context(tctx
->lp_ctx
));
367 c
[i
]->async
.fn
= loadfile_complete
;
368 c
[i
]->async
.private_data
= count
;
371 printf("waiting for completion\n");
373 while (*count
< torture_numops
) {
374 event_loop_once(event_ctx
);
375 if (torture_setting_bool(tctx
, "progress", true)) {
376 printf("(%s) count=%d\r", __location__
, *count
);
380 printf("count=%d\n", *count
);
382 for (i
=0;i
<torture_numops
;i
++) {
383 status
= smb_composite_fsinfo_recv(c
[i
], tctx
);
384 if (!NT_STATUS_IS_OK(status
)) {
385 printf("(%s) fsinfo[%d] failed - %s\n", __location__
, i
, nt_errstr(status
));
390 if (io1
.out
.fsinfo
->generic
.level
!= RAW_QFS_OBJECTID_INFORMATION
) {
391 printf("(%s) wrong level in returned info - %d "
392 "should be %d\n", __location__
,
393 io1
.out
.fsinfo
->generic
.level
, RAW_QFS_OBJECTID_INFORMATION
);
398 guid
=GUID_string(tctx
, &io1
.out
.fsinfo
->objectid_information
.out
.guid
);
399 printf("[%d] GUID: %s\n", i
, guid
);
409 basic testing of libcli composite calls
411 bool torture_raw_composite(struct torture_context
*tctx
,
412 struct smbcli_state
*cli
)
416 if (!torture_setup_dir(cli
, BASEDIR
)) {
420 ret
&= test_fetchfile(cli
, tctx
);
421 ret
&= test_loadfile(cli
, tctx
);
422 ret
&= test_appendacl(cli
, tctx
);
423 ret
&= test_fsinfo(cli
, tctx
);
425 smb_raw_exit(cli
->session
);
426 smbcli_deltree(cli
->tree
, BASEDIR
);