?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Backport FSCTL codes from master
[Samba.git] / source4 / torture / util_smb.c
blobdf2716f3160ef9bf4cbd9f93da9d825efd33252f
1 /*
2 Unix SMB/CIFS implementation.
3 SMB torture tester utility functions
4 Copyright (C) Andrew Tridgell 2003
5 Copyright (C) Jelmer Vernooij 2006
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "lib/cmdline/popt_common.h"
23 #include "libcli/raw/libcliraw.h"
24 #include "libcli/raw/raw_proto.h"
25 #include "libcli/raw/ioctl.h"
26 #include "libcli/libcli.h"
27 #include "system/filesys.h"
28 #include "system/shmem.h"
29 #include "system/wait.h"
30 #include "system/time.h"
31 #include "torture/torture.h"
32 #include "../lib/util/dlinklist.h"
33 #include "libcli/resolve/resolve.h"
34 #include "param/param.h"
35 #include "libcli/security/security.h"
36 #include "libcli/util/clilsa.h"
37
38
39 /**
40 setup a directory ready for a test
41 */
42 _PUBLIC_ bool torture_setup_dir(struct smbcli_state *cli, const char *dname)
43 {
44 smb_raw_exit(cli->session);
45 if (smbcli_deltree(cli->tree, dname) == -1 ||
46 NT_STATUS_IS_ERR(smbcli_mkdir(cli->tree, dname))) {
47 printf("Unable to setup %s - %s\n", dname, smbcli_errstr(cli->tree));
48 return false;
49 }
50 return true;
51 }
52
53 /*
54 create a directory, returning a handle to it
55 */
56 NTSTATUS create_directory_handle(struct smbcli_tree *tree, const char *dname, int *fnum)
57 {
58 NTSTATUS status;
59 union smb_open io;
60 TALLOC_CTX *mem_ctx;
61
62 mem_ctx = talloc_named_const(tree, 0, "create_directory_handle");
63
64 io.generic.level = RAW_OPEN_NTCREATEX;
65 io.ntcreatex.in.root_fid.fnum = 0;
66 io.ntcreatex.in.flags = 0;
67 io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
68 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
69 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
70 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE | NTCREATEX_SHARE_ACCESS_DELETE;
71 io.ntcreatex.in.alloc_size = 0;
72 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
73 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
74 io.ntcreatex.in.security_flags = 0;
75 io.ntcreatex.in.fname = dname;
76
77 status = smb_raw_open(tree, mem_ctx, &io);
78 talloc_free(mem_ctx);
79
80 if (NT_STATUS_IS_OK(status)) {
81 *fnum = io.ntcreatex.out.file.fnum;
82 }
83
84 return status;
85 }
86
87
88 /**
89 sometimes we need a fairly complex file to work with, so we can test
90 all possible attributes.
91 */
92 _PUBLIC_ int create_complex_file(struct smbcli_state *cli, TALLOC_CTX *mem_ctx, const char *fname)
93 {
94 int fnum;
95 char buf[7] = "abc";
96 union smb_setfileinfo setfile;
97 union smb_fileinfo fileinfo;
98 time_t t = (time(NULL) & ~1);
99 NTSTATUS status;
100
101 smbcli_unlink(cli->tree, fname);
102 fnum = smbcli_nt_create_full(cli->tree, fname, 0,
103 SEC_RIGHTS_FILE_ALL,
104 FILE_ATTRIBUTE_NORMAL,
105 NTCREATEX_SHARE_ACCESS_DELETE|
106 NTCREATEX_SHARE_ACCESS_READ|
107 NTCREATEX_SHARE_ACCESS_WRITE,
108 NTCREATEX_DISP_OVERWRITE_IF,
109 0, 0);
110 if (fnum == -1) return -1;
111
112 smbcli_write(cli->tree, fnum, 0, buf, 0, sizeof(buf));
113
114 if (strchr(fname, ':') == NULL) {
115 /* setup some EAs */
116 setfile.generic.level = RAW_SFILEINFO_EA_SET;
117 setfile.generic.in.file.fnum = fnum;
118 setfile.ea_set.in.num_eas = 2;
119 setfile.ea_set.in.eas = talloc_array(mem_ctx, struct ea_struct, 2);
120 setfile.ea_set.in.eas[0].flags = 0;
121 setfile.ea_set.in.eas[0].name.s = "EAONE";
122 setfile.ea_set.in.eas[0].value = data_blob_talloc(mem_ctx, "VALUE1", 6);
123 setfile.ea_set.in.eas[1].flags = 0;
124 setfile.ea_set.in.eas[1].name.s = "SECONDEA";
125 setfile.ea_set.in.eas[1].value = data_blob_talloc(mem_ctx, "ValueTwo", 8);
126 status = smb_raw_setfileinfo(cli->tree, &setfile);
127 if (!NT_STATUS_IS_OK(status)) {
128 printf("Failed to setup EAs\n");
129 }
130 }
131
132 /* make sure all the timestamps aren't the same */
133 ZERO_STRUCT(setfile);
134 setfile.generic.level = RAW_SFILEINFO_BASIC_INFO;
135 setfile.generic.in.file.fnum = fnum;
136
137 unix_to_nt_time(&setfile.basic_info.in.create_time,
138 t + 9*30*24*60*60);
139 unix_to_nt_time(&setfile.basic_info.in.access_time,
140 t + 6*30*24*60*60);
141 unix_to_nt_time(&setfile.basic_info.in.write_time,
142 t + 3*30*24*60*60);
143
144 status = smb_raw_setfileinfo(cli->tree, &setfile);
145 if (!NT_STATUS_IS_OK(status)) {
146 printf("Failed to setup file times - %s\n", nt_errstr(status));
147 }
148
149 /* make sure all the timestamps aren't the same */
150 fileinfo.generic.level = RAW_FILEINFO_BASIC_INFO;
151 fileinfo.generic.in.file.fnum = fnum;
152
153 status = smb_raw_fileinfo(cli->tree, mem_ctx, &fileinfo);
154 if (!NT_STATUS_IS_OK(status)) {
155 printf("Failed to query file times - %s\n", nt_errstr(status));
156 }
157
158 if (setfile.basic_info.in.create_time != fileinfo.basic_info.out.create_time) {
159 printf("create_time not setup correctly\n");
160 }
161 if (setfile.basic_info.in.access_time != fileinfo.basic_info.out.access_time) {
162 printf("access_time not setup correctly\n");
163 }
164 if (setfile.basic_info.in.write_time != fileinfo.basic_info.out.write_time) {
165 printf("write_time not setup correctly\n");
166 }
167
168 return fnum;
169 }
170
171
172 /*
173 sometimes we need a fairly complex directory to work with, so we can test
174 all possible attributes.
175 */
176 int create_complex_dir(struct smbcli_state *cli, TALLOC_CTX *mem_ctx, const char *dname)
177 {
178 int fnum;
179 union smb_setfileinfo setfile;
180 union smb_fileinfo fileinfo;
181 time_t t = (time(NULL) & ~1);
182 NTSTATUS status;
183
184 smbcli_deltree(cli->tree, dname);
185 fnum = smbcli_nt_create_full(cli->tree, dname, 0,
186 SEC_RIGHTS_DIR_ALL,
187 FILE_ATTRIBUTE_DIRECTORY,
188 NTCREATEX_SHARE_ACCESS_READ|
189 NTCREATEX_SHARE_ACCESS_WRITE,
190 NTCREATEX_DISP_OPEN_IF,
191 NTCREATEX_OPTIONS_DIRECTORY, 0);
192 if (fnum == -1) return -1;
193
194 if (strchr(dname, ':') == NULL) {
195 /* setup some EAs */
196 setfile.generic.level = RAW_SFILEINFO_EA_SET;
197 setfile.generic.in.file.fnum = fnum;
198 setfile.ea_set.in.num_eas = 2;
199 setfile.ea_set.in.eas = talloc_array(mem_ctx, struct ea_struct, 2);
200 setfile.ea_set.in.eas[0].flags = 0;
201 setfile.ea_set.in.eas[0].name.s = "EAONE";
202 setfile.ea_set.in.eas[0].value = data_blob_talloc(mem_ctx, "VALUE1", 6);
203 setfile.ea_set.in.eas[1].flags = 0;
204 setfile.ea_set.in.eas[1].name.s = "SECONDEA";
205 setfile.ea_set.in.eas[1].value = data_blob_talloc(mem_ctx, "ValueTwo", 8);
206 status = smb_raw_setfileinfo(cli->tree, &setfile);
207 if (!NT_STATUS_IS_OK(status)) {
208 printf("Failed to setup EAs\n");
209 }
210 }
211
212 /* make sure all the timestamps aren't the same */
213 ZERO_STRUCT(setfile);
214 setfile.generic.level = RAW_SFILEINFO_BASIC_INFO;
215 setfile.generic.in.file.fnum = fnum;
216
217 unix_to_nt_time(&setfile.basic_info.in.create_time,
218 t + 9*30*24*60*60);
219 unix_to_nt_time(&setfile.basic_info.in.access_time,
220 t + 6*30*24*60*60);
221 unix_to_nt_time(&setfile.basic_info.in.write_time,
222 t + 3*30*24*60*60);
223
224 status = smb_raw_setfileinfo(cli->tree, &setfile);
225 if (!NT_STATUS_IS_OK(status)) {
226 printf("Failed to setup file times - %s\n", nt_errstr(status));
227 }
228
229 /* make sure all the timestamps aren't the same */
230 fileinfo.generic.level = RAW_FILEINFO_BASIC_INFO;
231 fileinfo.generic.in.file.fnum = fnum;
232
233 status = smb_raw_fileinfo(cli->tree, mem_ctx, &fileinfo);
234 if (!NT_STATUS_IS_OK(status)) {
235 printf("Failed to query file times - %s\n", nt_errstr(status));
236 }
237
238 if (setfile.basic_info.in.create_time != fileinfo.basic_info.out.create_time) {
239 printf("create_time not setup correctly\n");
240 }
241 if (setfile.basic_info.in.access_time != fileinfo.basic_info.out.access_time) {
242 printf("access_time not setup correctly\n");
243 }
244 if (setfile.basic_info.in.write_time != fileinfo.basic_info.out.write_time) {
245 printf("write_time not setup correctly\n");
246 }
247
248 return fnum;
249 }
250
251
252
253 /* return a pointer to a anonymous shared memory segment of size "size"
254 which will persist across fork() but will disappear when all processes
255 exit
256
257 The memory is not zeroed
258
259 This function uses system5 shared memory. It takes advantage of a property
260 that the memory is not destroyed if it is attached when the id is removed
261 */
262 void *shm_setup(int size)
263 {
264 int shmid;
265 void *ret;
266
267 #ifdef __QNXNTO__
268 shmid = shm_open("private", O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
269 if (shmid == -1) {
270 printf("can't get shared memory\n");
271 exit(1);
272 }
273 shm_unlink("private");
274 if (ftruncate(shmid, size) == -1) {
275 printf("can't set shared memory size\n");
276 exit(1);
277 }
278 ret = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, shmid, 0);
279 if (ret == MAP_FAILED) {
280 printf("can't map shared memory\n");
281 exit(1);
282 }
283 #else
284 shmid = shmget(IPC_PRIVATE, size, SHM_R | SHM_W);
285 if (shmid == -1) {
286 printf("can't get shared memory\n");
287 exit(1);
288 }
289 ret = (void *)shmat(shmid, 0, 0);
290 if (!ret || ret == (void *)-1) {
291 printf("can't attach to shared memory\n");
292 return NULL;
293 }
294 /* the following releases the ipc, but note that this process
295 and all its children will still have access to the memory, its
296 just that the shmid is no longer valid for other shm calls. This
297 means we don't leave behind lots of shm segments after we exit
298
299 See Stevens "advanced programming in unix env" for details
300 */
301 shmctl(shmid, IPC_RMID, 0);
302 #endif
303
304 return ret;
305 }
306
307
308 /**
309 check that a wire string matches the flags specified
310 not 100% accurate, but close enough for testing
311 */
312 bool wire_bad_flags(struct smb_wire_string *str, int flags,
313 struct smbcli_transport *transport)
314 {
315 bool server_unicode;
316 int len;
317 if (!str || !str->s) return true;
318 len = strlen(str->s);
319 if (flags & STR_TERMINATE) len++;
320
321 server_unicode = (transport->negotiate.capabilities&CAP_UNICODE)?true:false;
322 if (getenv("CLI_FORCE_ASCII") || !transport->options.unicode) {
323 server_unicode = false;
324 }
325
326 if ((flags & STR_UNICODE) || server_unicode) {
327 len *= 2;
328 } else if (flags & STR_TERMINATE_ASCII) {
329 len++;
330 }
331 if (str->private_length != len) {
332 printf("Expected wire_length %d but got %d for '%s'\n",
333 len, str->private_length, str->s);
334 return true;
335 }
336 return false;
337 }
338
339 /*
340 dump a all_info QFILEINFO structure
341 */
342 void dump_all_info(TALLOC_CTX *mem_ctx, union smb_fileinfo *finfo)
343 {
344 d_printf("\tcreate_time: %s\n", nt_time_string(mem_ctx, finfo->all_info.out.create_time));
345 d_printf("\taccess_time: %s\n", nt_time_string(mem_ctx, finfo->all_info.out.access_time));
346 d_printf("\twrite_time: %s\n", nt_time_string(mem_ctx, finfo->all_info.out.write_time));
347 d_printf("\tchange_time: %s\n", nt_time_string(mem_ctx, finfo->all_info.out.change_time));
348 d_printf("\tattrib: 0x%x\n", finfo->all_info.out.attrib);
349 d_printf("\talloc_size: %llu\n", (long long)finfo->all_info.out.alloc_size);
350 d_printf("\tsize: %llu\n", (long long)finfo->all_info.out.size);
351 d_printf("\tnlink: %u\n", finfo->all_info.out.nlink);
352 d_printf("\tdelete_pending: %u\n", finfo->all_info.out.delete_pending);
353 d_printf("\tdirectory: %u\n", finfo->all_info.out.directory);
354 d_printf("\tea_size: %u\n", finfo->all_info.out.ea_size);
355 d_printf("\tfname: '%s'\n", finfo->all_info.out.fname.s);
356 }
357
358 /*
359 dump file infor by name
360 */
361 void torture_all_info(struct smbcli_tree *tree, const char *fname)
362 {
363 TALLOC_CTX *mem_ctx = talloc_named(tree, 0, "%s", fname);
364 union smb_fileinfo finfo;
365 NTSTATUS status;
366
367 finfo.generic.level = RAW_FILEINFO_ALL_INFO;
368 finfo.generic.in.file.path = fname;
369 status = smb_raw_pathinfo(tree, mem_ctx, &finfo);
370 if (!NT_STATUS_IS_OK(status)) {
371 d_printf("%s - %s\n", fname, nt_errstr(status));
372 return;
373 }
374
375 d_printf("%s:\n", fname);
376 dump_all_info(mem_ctx, &finfo);
377 talloc_free(mem_ctx);
378 }
379
380
381 /*
382 set a attribute on a file
383 */
384 bool torture_set_file_attribute(struct smbcli_tree *tree, const char *fname, uint16_t attrib)
385 {
386 union smb_setfileinfo sfinfo;
387 NTSTATUS status;
388
389 ZERO_STRUCT(sfinfo.basic_info.in);
390 sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFORMATION;
391 sfinfo.basic_info.in.file.path = fname;
392 sfinfo.basic_info.in.attrib = attrib;
393 status = smb_raw_setpathinfo(tree, &sfinfo);
394 return NT_STATUS_IS_OK(status);
395 }
396
397
398 /*
399 set a file descriptor as sparse
400 */
401 NTSTATUS torture_set_sparse(struct smbcli_tree *tree, int fnum)
402 {
403 union smb_ioctl nt;
404 NTSTATUS status;
405 TALLOC_CTX *mem_ctx;
406
407 mem_ctx = talloc_named_const(tree, 0, "torture_set_sparse");
408 if (!mem_ctx) {
409 return NT_STATUS_NO_MEMORY;
410 }
411
412 nt.ntioctl.level = RAW_IOCTL_NTIOCTL;
413 nt.ntioctl.in.function = FSCTL_SET_SPARSE;
414 nt.ntioctl.in.file.fnum = fnum;
415 nt.ntioctl.in.fsctl = true;
416 nt.ntioctl.in.filter = 0;
417 nt.ntioctl.in.max_data = 0;
418 nt.ntioctl.in.blob = data_blob(NULL, 0);
419
420 status = smb_raw_ioctl(tree, mem_ctx, &nt);
421
422 talloc_free(mem_ctx);
423
424 return status;
425 }
426
427 /*
428 check that an EA has the right value
429 */
430 NTSTATUS torture_check_ea(struct smbcli_state *cli,
431 const char *fname, const char *eaname, const char *value)
432 {
433 union smb_fileinfo info;
434 NTSTATUS status;
435 struct ea_name ea;
436 TALLOC_CTX *mem_ctx = talloc_new(cli);
437
438 info.ea_list.level = RAW_FILEINFO_EA_LIST;
439 info.ea_list.in.file.path = fname;
440 info.ea_list.in.num_names = 1;
441 info.ea_list.in.ea_names = &ea;
442
443 ea.name.s = eaname;
444
445 status = smb_raw_pathinfo(cli->tree, mem_ctx, &info);
446 if (!NT_STATUS_IS_OK(status)) {
447 talloc_free(mem_ctx);
448 return status;
449 }
450
451 if (info.ea_list.out.num_eas != 1) {
452 printf("Expected 1 ea in ea_list\n");
453 talloc_free(mem_ctx);
454 return NT_STATUS_EA_CORRUPT_ERROR;
455 }
456
457 if (strcasecmp_m(eaname, info.ea_list.out.eas[0].name.s) != 0) {
458 printf("Expected ea '%s' not '%s' in ea_list\n",
459 eaname, info.ea_list.out.eas[0].name.s);
460 talloc_free(mem_ctx);
461 return NT_STATUS_EA_CORRUPT_ERROR;
462 }
463
464 if (value == NULL) {
465 if (info.ea_list.out.eas[0].value.length != 0) {
466 printf("Expected zero length ea for %s\n", eaname);
467 talloc_free(mem_ctx);
468 return NT_STATUS_EA_CORRUPT_ERROR;
469 }
470 talloc_free(mem_ctx);
471 return NT_STATUS_OK;
472 }
473
474 if (strlen(value) == info.ea_list.out.eas[0].value.length &&
475 memcmp(value, info.ea_list.out.eas[0].value.data,
476 info.ea_list.out.eas[0].value.length) == 0) {
477 talloc_free(mem_ctx);
478 return NT_STATUS_OK;
479 }
480
481 printf("Expected value '%s' not '%*.*s' for ea %s\n",
482 value,
483 (int)info.ea_list.out.eas[0].value.length,
484 (int)info.ea_list.out.eas[0].value.length,
485 info.ea_list.out.eas[0].value.data,
486 eaname);
487
488 talloc_free(mem_ctx);
489
490 return NT_STATUS_EA_CORRUPT_ERROR;
491 }
492
493 _PUBLIC_ bool torture_open_connection_share(TALLOC_CTX *mem_ctx,
494 struct smbcli_state **c,
495 struct torture_context *tctx,
496 const char *hostname,
497 const char *sharename,
498 struct tevent_context *ev)
499 {
500 NTSTATUS status;
501
502 struct smbcli_options options;
503 struct smbcli_session_options session_options;
504
505 lpcfg_smbcli_options(tctx->lp_ctx, &options);
506 lpcfg_smbcli_session_options(tctx->lp_ctx, &session_options);
507
508 options.use_oplocks = torture_setting_bool(tctx, "use_oplocks", true);
509 options.use_level2_oplocks = torture_setting_bool(tctx, "use_level2_oplocks", true);
510
511 status = smbcli_full_connection(mem_ctx, c, hostname,
512 lpcfg_smb_ports(tctx->lp_ctx),
513 sharename, NULL,
514 lpcfg_socket_options(tctx->lp_ctx),
515 cmdline_credentials,
516 lpcfg_resolve_context(tctx->lp_ctx),
517 ev, &options, &session_options,
518 lpcfg_gensec_settings(tctx, tctx->lp_ctx));
519 if (!NT_STATUS_IS_OK(status)) {
520 printf("Failed to open connection - %s\n", nt_errstr(status));
521 return false;
522 }
523
524 return true;
525 }
526
527 _PUBLIC_ bool torture_get_conn_index(int conn_index,
528 TALLOC_CTX *mem_ctx,
529 struct torture_context *tctx,
530 char **host, char **share)
531 {
532 char **unc_list = NULL;
533 int num_unc_names = 0;
534 const char *p;
535
536 (*host) = talloc_strdup(mem_ctx, torture_setting_string(tctx, "host", NULL));
537 (*share) = talloc_strdup(mem_ctx, torture_setting_string(tctx, "share", NULL));
538
539 p = torture_setting_string(tctx, "unclist", NULL);
540 if (!p) {
541 return true;
542 }
543
544 unc_list = file_lines_load(p, &num_unc_names, 0, NULL);
545 if (!unc_list || num_unc_names <= 0) {
546 DEBUG(0,("Failed to load unc names list from '%s'\n", p));
547 return false;
548 }
549
550 p = unc_list[conn_index % num_unc_names];
551 if (p[0] != '/' && p[0] != '\\') {
552 /* allow UNC lists of hosts */
553 (*host) = talloc_strdup(mem_ctx, p);
554 } else if (!smbcli_parse_unc(p, mem_ctx, host, share)) {
555 DEBUG(0, ("Failed to parse UNC name %s\n",
556 unc_list[conn_index % num_unc_names]));
557 return false;
558 }
559
560 talloc_free(unc_list);
561 return true;
562 }
563
564
565
566 _PUBLIC_ bool torture_open_connection_ev(struct smbcli_state **c,
567 int conn_index,
568 struct torture_context *tctx,
569 struct tevent_context *ev)
570 {
571 char *host, *share;
572 bool ret;
573
574 if (!torture_get_conn_index(conn_index, ev, tctx, &host, &share)) {
575 return false;
576 }
577
578 ret = torture_open_connection_share(NULL, c, tctx, host, share, ev);
579 talloc_free(host);
580 talloc_free(share);
581
582 return ret;
583 }
584
585 _PUBLIC_ bool torture_open_connection(struct smbcli_state **c, struct torture_context *tctx, int conn_index)
586 {
587 return torture_open_connection_ev(c, conn_index, tctx, tctx->ev);
588 }
589
590
591
592 _PUBLIC_ bool torture_close_connection(struct smbcli_state *c)
593 {
594 bool ret = true;
595 if (!c) return true;
596 if (NT_STATUS_IS_ERR(smbcli_tdis(c))) {
597 printf("tdis failed (%s)\n", smbcli_errstr(c->tree));
598 ret = false;
599 }
600 talloc_free(c);
601 return ret;
602 }
603
604
605 /* check if the server produced the expected error code */
606 _PUBLIC_ bool check_error(const char *location, struct smbcli_state *c,
607 uint8_t eclass, uint32_t ecode, NTSTATUS nterr)
608 {
609 NTSTATUS status;
610
611 status = smbcli_nt_error(c->tree);
612 if (NT_STATUS_IS_DOS(status)) {
613 int classnum, num;
614 classnum = NT_STATUS_DOS_CLASS(status);
615 num = NT_STATUS_DOS_CODE(status);
616 if (eclass != classnum || ecode != num) {
617 printf("unexpected error code %s\n", nt_errstr(status));
618 printf(" expected %s or %s (at %s)\n",
619 nt_errstr(NT_STATUS_DOS(eclass, ecode)),
620 nt_errstr(nterr), location);
621 return false;
622 }
623 } else {
624 if (!NT_STATUS_EQUAL(nterr, status)) {
625 printf("unexpected error code %s\n", nt_errstr(status));
626 printf(" expected %s (at %s)\n", nt_errstr(nterr), location);
627 return false;
628 }
629 }
630
631 return true;
632 }
633
634 static struct smbcli_state *current_cli;
635 static int procnum; /* records process count number when forking */
636
637 static void sigcont(int sig)
638 {
639 }
640
641 double torture_create_procs(struct torture_context *tctx,
642 bool (*fn)(struct torture_context *, struct smbcli_state *, int), bool *result)
643 {
644 int i, status;
645 volatile pid_t *child_status;
646 volatile bool *child_status_out;
647 int synccount;
648 int tries = 8;
649 int torture_nprocs = torture_setting_int(tctx, "nprocs", 4);
650 double start_time_limit = 10 + (torture_nprocs * 1.5);
651 struct timeval tv;
652
653 *result = true;
654
655 synccount = 0;
656
657 signal(SIGCONT, sigcont);
658
659 child_status = (volatile pid_t *)shm_setup(sizeof(pid_t)*torture_nprocs);
660 if (!child_status) {
661 printf("Failed to setup shared memory\n");
662 return -1;
663 }
664
665 child_status_out = (volatile bool *)shm_setup(sizeof(bool)*torture_nprocs);
666 if (!child_status_out) {
667 printf("Failed to setup result status shared memory\n");
668 return -1;
669 }
670
671 for (i = 0; i < torture_nprocs; i++) {
672 child_status[i] = 0;
673 child_status_out[i] = true;
674 }
675
676 tv = timeval_current();
677
678 for (i=0;i<torture_nprocs;i++) {
679 procnum = i;
680 if (fork() == 0) {
681 char *myname;
682
683 pid_t mypid = getpid();
684 srandom(((int)mypid) ^ ((int)time(NULL)));
685
686 if (asprintf(&myname, "CLIENT%d", i) == -1) {
687 printf("asprintf failed\n");
688 return -1;
689 }
690 lpcfg_set_cmdline(tctx->lp_ctx, "netbios name", myname);
691 free(myname);
692
693
694 while (1) {
695 if (torture_open_connection(&current_cli, tctx, i)) {
696 break;
697 }
698 if (tries-- == 0) {
699 printf("pid %d failed to start\n", (int)getpid());
700 _exit(1);
701 }
702 smb_msleep(100);
703 }
704
705 child_status[i] = getpid();
706
707 pause();
708
709 if (child_status[i]) {
710 printf("Child %d failed to start!\n", i);
711 child_status_out[i] = 1;
712 _exit(1);
713 }
714
715 child_status_out[i] = fn(tctx, current_cli, i);
716 _exit(0);
717 }
718 }
719
720 do {
721 synccount = 0;
722 for (i=0;i<torture_nprocs;i++) {
723 if (child_status[i]) synccount++;
724 }
725 if (synccount == torture_nprocs) break;
726 smb_msleep(100);
727 } while (timeval_elapsed(&tv) < start_time_limit);
728
729 if (synccount != torture_nprocs) {
730 printf("FAILED TO START %d CLIENTS (started %d)\n", torture_nprocs, synccount);
731 *result = false;
732 return timeval_elapsed(&tv);
733 }
734
735 printf("Starting %d clients\n", torture_nprocs);
736
737 /* start the client load */
738 tv = timeval_current();
739 for (i=0;i<torture_nprocs;i++) {
740 child_status[i] = 0;
741 }
742
743 printf("%d clients started\n", torture_nprocs);
744
745 kill(0, SIGCONT);
746
747 for (i=0;i<torture_nprocs;i++) {
748 int ret;
749 while ((ret=waitpid(0, &status, 0)) == -1 && errno == EINTR) /* noop */ ;
750 if (ret == -1 || WEXITSTATUS(status) != 0) {
751 *result = false;
752 }
753 }
754
755 printf("\n");
756
757 for (i=0;i<torture_nprocs;i++) {
758 if (!child_status_out[i]) {
759 *result = false;
760 }
761 }
762 return timeval_elapsed(&tv);
763 }
764
765 static bool wrap_smb_multi_test(struct torture_context *torture,
766 struct torture_tcase *tcase,
767 struct torture_test *test)
768 {
769 bool (*fn)(struct torture_context *, struct smbcli_state *, int ) = test->fn;
770 bool result;
771
772 torture_create_procs(torture, fn, &result);
773
774 return result;
775 }
776
777 _PUBLIC_ struct torture_test *torture_suite_add_smb_multi_test(
778 struct torture_suite *suite,
779 const char *name,
780 bool (*run) (struct torture_context *,
781 struct smbcli_state *,
782 int i))
783 {
784 struct torture_test *test;
785 struct torture_tcase *tcase;
786
787 tcase = torture_suite_add_tcase(suite, name);
788
789 test = talloc(tcase, struct torture_test);
790
791 test->name = talloc_strdup(test, name);
792 test->description = NULL;
793 test->run = wrap_smb_multi_test;
794 test->fn = run;
795 test->dangerous = false;
796
797 DLIST_ADD_END(tcase->tests, test, struct torture_test *);
798
799 return test;
800
801 }
802
803 static bool wrap_simple_2smb_test(struct torture_context *torture_ctx,
804 struct torture_tcase *tcase,
805 struct torture_test *test)
806 {
807 bool (*fn) (struct torture_context *, struct smbcli_state *,
808 struct smbcli_state *);
809 bool ret;
810
811 struct smbcli_state *cli1, *cli2;
812
813 if (!torture_open_connection(&cli1, torture_ctx, 0) ||
814 !torture_open_connection(&cli2, torture_ctx, 1))
815 return false;
816
817 fn = test->fn;
818
819 ret = fn(torture_ctx, cli1, cli2);
820
821 talloc_free(cli1);
822 talloc_free(cli2);
823
824 return ret;
825 }
826
827
828
829 _PUBLIC_ struct torture_test *torture_suite_add_2smb_test(
830 struct torture_suite *suite,
831 const char *name,
832 bool (*run) (struct torture_context *,
833 struct smbcli_state *,
834 struct smbcli_state *))
835 {
836 struct torture_test *test;
837 struct torture_tcase *tcase;
838
839 tcase = torture_suite_add_tcase(suite, name);
840
841 test = talloc(tcase, struct torture_test);
842
843 test->name = talloc_strdup(test, name);
844 test->description = NULL;
845 test->run = wrap_simple_2smb_test;
846 test->fn = run;
847 test->dangerous = false;
848
849 DLIST_ADD_END(tcase->tests, test, struct torture_test *);
850
851 return test;
852
853 }
854
855 static bool wrap_simple_1smb_test(struct torture_context *torture_ctx,
856 struct torture_tcase *tcase,
857 struct torture_test *test)
858 {
859 bool (*fn) (struct torture_context *, struct smbcli_state *);
860 bool ret;
861
862 struct smbcli_state *cli1;
863
864 if (!torture_open_connection(&cli1, torture_ctx, 0))
865 return false;
866
867 fn = test->fn;
868
869 ret = fn(torture_ctx, cli1);
870
871 talloc_free(cli1);
872
873 return ret;
874 }
875
876 _PUBLIC_ struct torture_test *torture_suite_add_1smb_test(
877 struct torture_suite *suite,
878 const char *name,
879 bool (*run) (struct torture_context *, struct smbcli_state *))
880 {
881 struct torture_test *test;
882 struct torture_tcase *tcase;
883
884 tcase = torture_suite_add_tcase(suite, name);
885
886 test = talloc(tcase, struct torture_test);
887
888 test->name = talloc_strdup(test, name);
889 test->description = NULL;
890 test->run = wrap_simple_1smb_test;
891 test->fn = run;
892 test->dangerous = false;
893
894 DLIST_ADD_END(tcase->tests, test, struct torture_test *);
895
896 return test;
897 }
898
899
900 NTSTATUS torture_second_tcon(TALLOC_CTX *mem_ctx,
901 struct smbcli_session *session,
902 const char *sharename,
903 struct smbcli_tree **res)
904 {
905 union smb_tcon tcon;
906 struct smbcli_tree *result;
907 TALLOC_CTX *tmp_ctx;
908 NTSTATUS status;
909
910 if ((tmp_ctx = talloc_new(mem_ctx)) == NULL) {
911 return NT_STATUS_NO_MEMORY;
912 }
913
914 result = smbcli_tree_init(session, tmp_ctx, false);
915 if (result == NULL) {
916 talloc_free(tmp_ctx);
917 return NT_STATUS_NO_MEMORY;
918 }
919
920 tcon.generic.level = RAW_TCON_TCONX;
921 tcon.tconx.in.flags = 0;
922
923 /* Ignore share mode security here */
924 tcon.tconx.in.password = data_blob(NULL, 0);
925 tcon.tconx.in.path = sharename;
926 tcon.tconx.in.device = "?????";
927
928 status = smb_raw_tcon(result, tmp_ctx, &tcon);
929 if (!NT_STATUS_IS_OK(status)) {
930 talloc_free(tmp_ctx);
931 return status;
932 }
933
934 result->tid = tcon.tconx.out.tid;
935 *res = talloc_steal(mem_ctx, result);
936 talloc_free(tmp_ctx);
937 return NT_STATUS_OK;
938 }
939
940 /*
941 a wrapper around smblsa_sid_check_privilege, that tries to take
942 account of the fact that the lsa privileges calls don't expand
943 group memberships, using an explicit check for administrator. There
944 must be a better way ...
945 */
946 NTSTATUS torture_check_privilege(struct smbcli_state *cli,
947 const char *sid_str,
948 const char *privilege)
949 {
950 struct dom_sid *sid;
951 TALLOC_CTX *tmp_ctx = talloc_new(cli);
952 uint32_t rid;
953 NTSTATUS status;
954
955 sid = dom_sid_parse_talloc(tmp_ctx, sid_str);
956 if (sid == NULL) {
957 talloc_free(tmp_ctx);
958 return NT_STATUS_INVALID_SID;
959 }
960
961 status = dom_sid_split_rid(tmp_ctx, sid, NULL, &rid);
962 NT_STATUS_NOT_OK_RETURN_AND_FREE(status, tmp_ctx);
963
964 if (rid == DOMAIN_RID_ADMINISTRATOR) {
965 /* assume the administrator has them all */
966 return NT_STATUS_OK;
967 }
968
969 talloc_free(tmp_ctx);
970
971 return smblsa_sid_check_privilege(cli, sid_str, privilege);
972 }
Samba GIT mirror