?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
lib/util/charset: We do not use fucntions from wchar.h any more
[Samba/vl.git] / source4 / torture / gentest.c
blob91b60e2c4e795c7adf462a1a65e13cab37b1abec
1 /*
2 Unix SMB/CIFS implementation.
3
4 generic testing tool - version with both SMB and SMB2 support
5
6 Copyright (C) Andrew Tridgell 2003-2008
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 "lib/cmdline/popt_common.h"
24 #include "lib/events/events.h"
25 #include "system/time.h"
26 #include "system/filesys.h"
27 #include "libcli/raw/request.h"
28 #include "libcli/libcli.h"
29 #include "libcli/raw/libcliraw.h"
30 #include "libcli/smb2/smb2.h"
31 #include "libcli/smb2/smb2_calls.h"
32 #include "librpc/gen_ndr/security.h"
33 #include "librpc/gen_ndr/ndr_security.h"
34 #include "auth/credentials/credentials.h"
35 #include "libcli/resolve/resolve.h"
36 #include "auth/gensec/gensec.h"
37 #include "param/param.h"
38 #include "dynconfig/dynconfig.h"
39 #include "libcli/security/security.h"
40 #include "libcli/raw/raw_proto.h"
41 #include "../libcli/smb/smbXcli_base.h"
42
43 #define NSERVERS 2
44 #define NINSTANCES 2
45
46 /* global options */
47 static struct gentest_options {
48 int showall;
49 int analyze;
50 int analyze_always;
51 int analyze_continuous;
52 unsigned int max_open_handles;
53 unsigned int seed;
54 unsigned int numops;
55 int use_oplocks;
56 char **ignore_patterns;
57 const char *seeds_file;
58 int use_preset_seeds;
59 int fast_reconnect;
60 int mask_indexing;
61 int no_eas;
62 int no_acls;
63 int skip_cleanup;
64 int valid;
65 int smb2;
66 } options;
67
68 /* mapping between open handles on the server and local handles */
69 static struct {
70 bool active;
71 unsigned int instance;
72 struct smb2_handle smb2_handle[NSERVERS]; /* SMB2 */
73 uint16_t smb_handle[NSERVERS]; /* SMB */
74 const char *name;
75 } *open_handles;
76 static unsigned int num_open_handles;
77
78 /* state information for the servers. We open NINSTANCES connections to
79 each server */
80 static struct {
81 struct smb2_tree *smb2_tree[NINSTANCES];
82 struct smbcli_tree *smb_tree[NINSTANCES];
83 char *server_name;
84 char *share_name;
85 struct cli_credentials *credentials;
86 } servers[NSERVERS];
87
88 /* the seeds and flags for each operation */
89 static struct {
90 unsigned int seed;
91 bool disabled;
92 } *op_parms;
93
94
95 /* oplock break info */
96 static struct {
97 bool got_break;
98 struct smb2_handle smb2_handle;
99 uint16_t smb_handle;
100 uint16_t handle;
101 uint8_t level;
102 bool do_close;
103 } oplocks[NSERVERS][NINSTANCES];
104
105 /* change notify reply info */
106 static struct {
107 int notify_count;
108 NTSTATUS status;
109 union smb_notify notify;
110 } notifies[NSERVERS][NINSTANCES];
111
112 /* info relevant to the current operation */
113 static struct {
114 const char *name;
115 unsigned int seed;
116 NTSTATUS status;
117 unsigned int opnum;
118 TALLOC_CTX *mem_ctx;
119 const char *mismatch;
120 } current_op;
121
122 static struct smb2_handle bad_smb2_handle;
123
124
125 #define BAD_HANDLE 0xFFFE
126
127 static bool oplock_handler_smb2(struct smb2_transport *transport, const struct smb2_handle *handle,
128 uint8_t level, void *private_data);
129 static void idle_func_smb2(struct smb2_transport *transport, void *private_data);
130 static bool oplock_handler_smb(struct smbcli_transport *transport, uint16_t tid, uint16_t fnum, uint8_t level, void *private_data);
131 static void idle_func_smb(struct smbcli_transport *transport, void *private_data);
132
133 /*
134 check if a string should be ignored. This is used as the basis
135 for all error ignore settings
136 */
137 static bool ignore_pattern(const char *str)
138 {
139 int i;
140 if (!options.ignore_patterns) return false;
141
142 for (i=0;options.ignore_patterns[i];i++) {
143 if (strcmp(options.ignore_patterns[i], str) == 0 ||
144 gen_fnmatch(options.ignore_patterns[i], str) == 0) {
145 DEBUG(2,("Ignoring '%s'\n", str));
146 return true;
147 }
148 }
149 return false;
150 }
151
152 /*****************************************************
153 connect to the servers
154 *******************************************************/
155 static bool connect_servers_fast(void)
156 {
157 int h, i;
158
159 /* close all open files */
160 for (h=0;h<options.max_open_handles;h++) {
161 if (!open_handles[h].active) continue;
162 for (i=0;i<NSERVERS;i++) {
163 NTSTATUS status;
164 if (options.smb2) {
165 status = smb2_util_close(servers[i].smb2_tree[open_handles[h].instance],
166 open_handles[h].smb2_handle[i]);
167 } else {
168 status = smbcli_close(servers[i].smb_tree[open_handles[h].instance],
169 open_handles[h].smb_handle[i]);
170 }
171 if (NT_STATUS_IS_ERR(status)) {
172 return false;
173 }
174 open_handles[h].active = false;
175 }
176 }
177
178 return true;
179 }
180
181
182
183
184 /*****************************************************
185 connect to the servers
186 *******************************************************/
187 static bool connect_servers(struct tevent_context *ev,
188 struct loadparm_context *lp_ctx)
189 {
190 int i, j;
191
192 if (options.fast_reconnect && servers[0].smb2_tree[0]) {
193 if (connect_servers_fast()) {
194 return true;
195 }
196 }
197
198 /* close any existing connections */
199 for (i=0;i<NSERVERS;i++) {
200 for (j=0;j<NINSTANCES;j++) {
201 if (servers[i].smb2_tree[j]) {
202 smb2_tdis(servers[i].smb2_tree[j]);
203 talloc_free(servers[i].smb2_tree[j]);
204 servers[i].smb2_tree[j] = NULL;
205 }
206 if (servers[i].smb_tree[j]) {
207 smb_tree_disconnect(servers[i].smb_tree[j]);
208 talloc_free(servers[i].smb_tree[j]);
209 servers[i].smb_tree[j] = NULL;
210 }
211 }
212 }
213
214 for (i=0;i<NSERVERS;i++) {
215 for (j=0;j<NINSTANCES;j++) {
216 NTSTATUS status;
217 struct smbcli_options smb_options;
218 struct smbcli_session_options smb_session_options;
219 lpcfg_smbcli_options(lp_ctx, &smb_options);
220 lpcfg_smbcli_session_options(lp_ctx, &smb_session_options);
221
222 printf("Connecting to \\\\%s\\%s as %s - instance %d\n",
223 servers[i].server_name, servers[i].share_name,
224 servers[i].credentials->username, j);
225
226 cli_credentials_set_workstation(servers[i].credentials,
227 "gentest", CRED_SPECIFIED);
228
229 if (options.smb2) {
230 status = smb2_connect(NULL, servers[i].server_name,
231 lpcfg_smb_ports(lp_ctx),
232 servers[i].share_name,
233 lpcfg_resolve_context(lp_ctx),
234 servers[i].credentials,
235 &servers[i].smb2_tree[j],
236 ev, &smb_options,
237 lpcfg_socket_options(lp_ctx),
238 lpcfg_gensec_settings(lp_ctx, lp_ctx)
239 );
240 } else {
241 status = smbcli_tree_full_connection(NULL,
242 &servers[i].smb_tree[j],
243 servers[i].server_name,
244 lpcfg_smb_ports(lp_ctx),
245 servers[i].share_name, "A:",
246 lpcfg_socket_options(lp_ctx),
247 servers[i].credentials,
248 lpcfg_resolve_context(lp_ctx), ev,
249 &smb_options,
250 &smb_session_options,
251 lpcfg_gensec_settings(lp_ctx, lp_ctx));
252 }
253 if (!NT_STATUS_IS_OK(status)) {
254 printf("Failed to connect to \\\\%s\\%s - %s\n",
255 servers[i].server_name, servers[i].share_name,
256 nt_errstr(status));
257 return false;
258 }
259
260 if (options.smb2) {
261 servers[i].smb2_tree[j]->session->transport->oplock.handler = oplock_handler_smb2;
262 servers[i].smb2_tree[j]->session->transport->oplock.private_data = (void *)(uintptr_t)((i<<8)|j);
263 smb2_transport_idle_handler(servers[i].smb2_tree[j]->session->transport,
264 idle_func_smb2, 50000, NULL);
265 } else {
266 smbcli_oplock_handler(servers[i].smb_tree[j]->session->transport, oplock_handler_smb,
267 (void *)(uintptr_t)((i<<8)|j));
268 smbcli_transport_idle_handler(servers[i].smb_tree[j]->session->transport, idle_func_smb,
269 50000, (void *)(uintptr_t)((i<<8)|j));
270 }
271 }
272 }
273
274 return true;
275 }
276
277 /*
278 work out the time skew between the servers - be conservative
279 */
280 static unsigned int time_skew(void)
281 {
282 unsigned int ret;
283 NTTIME nt0, nt1;
284
285 if (options.smb2) {
286 struct smbXcli_conn *c0, *c1;
287
288 c0 = servers[0].smb2_tree[0]->session->transport->conn;
289 c1 = servers[1].smb2_tree[0]->session->transport->conn;
290
291 nt0 = smbXcli_conn_server_system_time(c0);
292 nt1 = smbXcli_conn_server_system_time(c1);
293 } else {
294 nt0 = servers[0].smb_tree[0]->session->transport->negotiate.server_time;
295 nt1 = servers[1].smb_tree[0]->session->transport->negotiate.server_time;
296 }
297 ret = labs(nt0 - nt1);
298 return ret + 300;
299 }
300
301
302 static bool smb2_handle_equal(const struct smb2_handle *h1, const struct smb2_handle *h2)
303 {
304 return memcmp(h1, h2, sizeof(struct smb2_handle)) == 0;
305 }
306
307 /*
308 turn a server handle into a local handle
309 */
310 static unsigned int fnum_to_handle_smb2(int server, int instance, struct smb2_handle server_handle)
311 {
312 unsigned int i;
313 for (i=0;i<options.max_open_handles;i++) {
314 if (!open_handles[i].active ||
315 instance != open_handles[i].instance) continue;
316 if (smb2_handle_equal(&open_handles[i].smb2_handle[server], &server_handle)) {
317 return i;
318 }
319 }
320 printf("Invalid server handle in fnum_to_handle on server %d instance %d\n",
321 server, instance);
322 return BAD_HANDLE;
323 }
324
325 /*
326 turn a server handle into a local handle
327 */
328 static unsigned int fnum_to_handle_smb(int server, int instance, uint16_t server_handle)
329 {
330 unsigned int i;
331 for (i=0;i<options.max_open_handles;i++) {
332 if (!open_handles[i].active ||
333 instance != open_handles[i].instance) continue;
334 if (open_handles[i].smb_handle[server] == server_handle) {
335 return i;
336 }
337 }
338 printf("Invalid server handle in fnum_to_handle on server %d instance %d\n",
339 server, instance);
340 return BAD_HANDLE;
341 }
342
343 /*
344 add some newly opened handles
345 */
346 static void gen_add_handle_smb2(int instance, const char *name, struct smb2_handle handles[NSERVERS])
347 {
348 int i, h;
349 for (h=0;h<options.max_open_handles;h++) {
350 if (!open_handles[h].active) break;
351 }
352 if (h == options.max_open_handles) {
353 /* we have to force close a random handle */
354 h = random() % options.max_open_handles;
355 for (i=0;i<NSERVERS;i++) {
356 NTSTATUS status;
357 status = smb2_util_close(servers[i].smb2_tree[open_handles[h].instance],
358 open_handles[h].smb2_handle[i]);
359 if (NT_STATUS_IS_ERR(status)) {
360 printf("INTERNAL ERROR: Close failed when recovering handle! - %s\n",
361 nt_errstr(status));
362 }
363 }
364 printf("Recovered handle %d\n", h);
365 num_open_handles--;
366 }
367 for (i=0;i<NSERVERS;i++) {
368 open_handles[h].smb2_handle[i] = handles[i];
369 open_handles[h].instance = instance;
370 open_handles[h].active = true;
371 open_handles[h].name = name;
372 }
373 num_open_handles++;
374
375 printf("OPEN num_open_handles=%d h=%d (%s)\n",
376 num_open_handles, h, name);
377 }
378
379 /*
380 add some newly opened handles
381 */
382 static void gen_add_handle_smb(int instance, const char *name, uint16_t handles[NSERVERS])
383 {
384 int i, h;
385 for (h=0;h<options.max_open_handles;h++) {
386 if (!open_handles[h].active) break;
387 }
388 if (h == options.max_open_handles) {
389 /* we have to force close a random handle */
390 h = random() % options.max_open_handles;
391 for (i=0;i<NSERVERS;i++) {
392 NTSTATUS status;
393 status = smbcli_close(servers[i].smb_tree[open_handles[h].instance],
394 open_handles[h].smb_handle[i]);
395 if (NT_STATUS_IS_ERR(status)) {
396 printf("INTERNAL ERROR: Close failed when recovering handle! - %s\n",
397 nt_errstr(status));
398 }
399 }
400 printf("Recovered handle %d\n", h);
401 num_open_handles--;
402 }
403 for (i=0;i<NSERVERS;i++) {
404 open_handles[h].smb_handle[i] = handles[i];
405 open_handles[h].instance = instance;
406 open_handles[h].active = true;
407 open_handles[h].name = name;
408 }
409 num_open_handles++;
410
411 printf("OPEN num_open_handles=%d h=%d (%s)\n",
412 num_open_handles, h, name);
413 }
414
415
416 /*
417 remove a closed handle
418 */
419 static void gen_remove_handle_smb2(int instance, struct smb2_handle handles[NSERVERS])
420 {
421 int h;
422 for (h=0;h<options.max_open_handles;h++) {
423 if (instance == open_handles[h].instance &&
424 smb2_handle_equal(&open_handles[h].smb2_handle[0], &handles[0])) {
425 open_handles[h].active = false;
426 num_open_handles--;
427 printf("CLOSE num_open_handles=%d h=%d (%s)\n",
428 num_open_handles, h,
429 open_handles[h].name);
430 return;
431 }
432 }
433 printf("Removing invalid handle!?\n");
434 exit(1);
435 }
436
437 /*
438 remove a closed handle
439 */
440 static void gen_remove_handle_smb(int instance, uint16_t handles[NSERVERS])
441 {
442 int h;
443 for (h=0;h<options.max_open_handles;h++) {
444 if (instance == open_handles[h].instance &&
445 open_handles[h].smb_handle[0] == handles[0]) {
446 open_handles[h].active = false;
447 num_open_handles--;
448 printf("CLOSE num_open_handles=%d h=%d (%s)\n",
449 num_open_handles, h,
450 open_handles[h].name);
451 return;
452 }
453 }
454 printf("Removing invalid handle!?\n");
455 exit(1);
456 }
457
458 /*
459 return true with 'chance' probability as a percentage
460 */
461 static bool gen_chance(unsigned int chance)
462 {
463 return ((random() % 100) <= chance);
464 }
465
466 /*
467 map an internal handle number to a server handle
468 */
469 static struct smb2_handle gen_lookup_handle_smb2(int server, uint16_t handle)
470 {
471 if (handle == BAD_HANDLE) return bad_smb2_handle;
472 return open_handles[handle].smb2_handle[server];
473 }
474
475 /*
476 map an internal handle number to a server handle
477 */
478 static uint16_t gen_lookup_handle_smb(int server, uint16_t handle)
479 {
480 if (handle == BAD_HANDLE) return BAD_HANDLE;
481 return open_handles[handle].smb_handle[server];
482 }
483
484 /*
485 return a file handle
486 */
487 static uint16_t gen_fnum(int instance)
488 {
489 uint16_t h;
490 int count = 0;
491
492 if (gen_chance(20)) return BAD_HANDLE;
493
494 while (num_open_handles > 0 && count++ < 10*options.max_open_handles) {
495 h = random() % options.max_open_handles;
496 if (open_handles[h].active &&
497 open_handles[h].instance == instance) {
498 return h;
499 }
500 }
501 return BAD_HANDLE;
502 }
503
504 /*
505 return a file handle, but skewed so we don't close the last
506 couple of handles too readily
507 */
508 static uint16_t gen_fnum_close(int instance)
509 {
510 if (num_open_handles < 5) {
511 if (gen_chance(90)) return BAD_HANDLE;
512 }
513
514 return gen_fnum(instance);
515 }
516
517 /*
518 generate an integer in a specified range
519 */
520 static int gen_int_range(uint64_t min, uint64_t max)
521 {
522 unsigned int r = random();
523 return min + (r % (1+max-min));
524 }
525
526 /*
527 return a fnum for use as a root fid
528 be careful to call GEN_SET_FNUM() when you use this!
529 */
530 static uint16_t gen_root_fid(int instance)
531 {
532 if (gen_chance(5)) return gen_fnum(instance);
533 return 0;
534 }
535
536 /*
537 generate a file offset
538 */
539 static int gen_offset(void)
540 {
541 if (gen_chance(20)) return 0;
542 // if (gen_chance(5)) return gen_int_range(0, 0xFFFFFFFF);
543 return gen_int_range(0, 1024*1024);
544 }
545
546 /*
547 generate a io count
548 */
549 static int gen_io_count(void)
550 {
551 if (gen_chance(20)) return 0;
552 // if (gen_chance(5)) return gen_int_range(0, 0xFFFFFFFF);
553 return gen_int_range(0, 4096);
554 }
555
556 /*
557 generate a filename
558 */
559 static const char *gen_fname(void)
560 {
561 const char *names[] = {"gentest\\gentest.dat",
562 "gentest\\foo",
563 "gentest\\foo2.sym",
564 "gentest\\foo3.dll",
565 "gentest\\foo4",
566 "gentest\\foo4:teststream1",
567 "gentest\\foo4:teststream2",
568 "gentest\\foo5.exe",
569 "gentest\\foo5.exe:teststream3",
570 "gentest\\foo5.exe:teststream4",
571 "gentest\\foo6.com",
572 "gentest\\blah",
573 "gentest\\blah\\blergh.txt",
574 "gentest\\blah\\blergh2",
575 "gentest\\blah\\blergh3.txt",
576 "gentest\\blah\\blergh4",
577 "gentest\\blah\\blergh5.txt",
578 "gentest\\blah\\blergh5",
579 "gentest\\blah\\.",
580 "gentest\\blah\\..",
581 "gentest\\a_very_long_name.bin",
582 "gentest\\x.y",
583 "gentest\\blah"};
584 int i;
585
586 do {
587 i = gen_int_range(0, ARRAY_SIZE(names)-1);
588 } while (ignore_pattern(names[i]));
589
590 return names[i];
591 }
592
593 /*
594 generate a filename with a higher chance of choosing an already
595 open file
596 */
597 static const char *gen_fname_open(int instance)
598 {
599 uint16_t h;
600 h = gen_fnum(instance);
601 if (h == BAD_HANDLE) {
602 return gen_fname();
603 }
604 return open_handles[h].name;
605 }
606
607 /*
608 generate a wildcard pattern
609 */
610 static const char *gen_pattern(void)
611 {
612 int i;
613 const char *names[] = {"gentest\\*.dat",
614 "gentest\\*",
615 "gentest\\*.*",
616 "gentest\\blah\\*.*",
617 "gentest\\blah\\*",
618 "gentest\\?"};
619
620 if (gen_chance(50)) return gen_fname();
621
622 do {
623 i = gen_int_range(0, ARRAY_SIZE(names)-1);
624 } while (ignore_pattern(names[i]));
625
626 return names[i];
627 }
628
629 static uint32_t gen_bits_levels(int nlevels, ...)
630 {
631 va_list ap;
632 uint32_t pct;
633 uint32_t mask;
634 int i;
635 va_start(ap, nlevels);
636 for (i=0;i<nlevels;i++) {
637 pct = va_arg(ap, uint32_t);
638 mask = va_arg(ap, uint32_t);
639 if (pct == 100 || gen_chance(pct)) {
640 va_end(ap);
641 return mask & random();
642 }
643 }
644 va_end(ap);
645 return 0;
646 }
647
648 /*
649 generate a bitmask
650 */
651 static uint32_t gen_bits_mask(unsigned int mask)
652 {
653 unsigned int ret = random();
654 return ret & mask;
655 }
656
657 /*
658 generate a bitmask with high probability of the first mask
659 and low of the second
660 */
661 static uint32_t gen_bits_mask2(uint32_t mask1, uint32_t mask2)
662 {
663 if (!options.valid && gen_chance(10)) return gen_bits_mask(mask2);
664 return gen_bits_mask(mask1);
665 }
666
667 /*
668 generate reserved values
669 */
670 static uint64_t gen_reserved8(void)
671 {
672 if (options.valid) return 0;
673 return gen_bits_mask(0xFF);
674 }
675
676 static uint64_t gen_reserved16(void)
677 {
678 if (options.valid) return 0;
679 return gen_bits_mask(0xFFFF);
680 }
681
682 static uint64_t gen_reserved32(void)
683 {
684 if (options.valid) return 0;
685 return gen_bits_mask(0xFFFFFFFF);
686 }
687
688 static uint64_t gen_reserved64(void)
689 {
690 if (options.valid) return 0;
691 return gen_bits_mask(0xFFFFFFFF) | (((uint64_t)gen_bits_mask(0xFFFFFFFF))<<32);
692 }
693
694
695
696 /*
697 generate a boolean
698 */
699 static bool gen_bool(void)
700 {
701 return gen_bits_mask2(0x1, 0xFF);
702 }
703
704 /*
705 generate ntrename flags
706 */
707 static uint16_t gen_rename_flags(void)
708 {
709 if (gen_chance(30)) return RENAME_FLAG_RENAME;
710 if (gen_chance(30)) return RENAME_FLAG_HARD_LINK;
711 if (gen_chance(30)) return RENAME_FLAG_COPY;
712 return gen_bits_mask(0xFFFF);
713 }
714
715 /*
716 generate a pid
717 */
718 static uint16_t gen_pid(void)
719 {
720 if (gen_chance(10)) return gen_bits_mask(0xFFFF);
721 return getpid();
722 }
723
724 /*
725 return a set of lock flags
726 */
727 static uint16_t gen_lock_flags_smb2(void)
728 {
729 if (!options.valid && gen_chance(5)) return gen_bits_mask(0xFFFF);
730 if (gen_chance(20)) return gen_bits_mask(0x1F);
731 if (gen_chance(50)) return SMB2_LOCK_FLAG_UNLOCK;
732 return gen_bits_mask(SMB2_LOCK_FLAG_SHARED |
733 SMB2_LOCK_FLAG_EXCLUSIVE |
734 SMB2_LOCK_FLAG_FAIL_IMMEDIATELY);
735 }
736
737 /*
738 generate a lock count
739 */
740 static off_t gen_lock_count(void)
741 {
742 return gen_int_range(0, 3);
743 }
744
745 /*
746 generate a NT access mask
747 */
748 static uint32_t gen_access_mask(void)
749 {
750 uint32_t ret;
751 if (gen_chance(70)) return SEC_FLAG_MAXIMUM_ALLOWED;
752 if (gen_chance(70)) return SEC_FILE_ALL;
753 ret = gen_bits_mask(0xFFFFFFFF);
754 if (options.valid) ret &= ~SEC_MASK_INVALID;
755 return ret;
756 }
757
758 /*
759 return a lockingx lock mode
760 */
761 static uint16_t gen_lock_mode(void)
762 {
763 if (!options.valid && gen_chance(5)) return gen_bits_mask(0xFFFF);
764 if (gen_chance(20)) return gen_bits_mask(0x1F);
765 return gen_bits_mask(LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES);
766 }
767
768 /*
769 generate a ntcreatex flags field
770 */
771 static uint32_t gen_ntcreatex_flags(void)
772 {
773 if (gen_chance(70)) return NTCREATEX_FLAGS_EXTENDED;
774 return gen_bits_mask2(0x1F, 0xFFFFFFFF);
775 }
776
777 /*
778 generate a ntcreatex create options bitfield
779 */
780 static uint32_t gen_create_options(void)
781 {
782 if (!options.valid && gen_chance(20)) return gen_bits_mask(0xFFFFFFFF);
783 if (gen_chance(50)) return 0;
784 return gen_bits_mask(NTCREATEX_OPTIONS_DELETE_ON_CLOSE | NTCREATEX_OPTIONS_DIRECTORY);
785 }
786
787 /*
788 generate a ntcreatex open disposition
789 */
790 static uint32_t gen_open_disp(void)
791 {
792 if (gen_chance(50)) return NTCREATEX_DISP_OPEN_IF;
793 if (!options.valid && gen_chance(10)) return gen_bits_mask(0xFFFFFFFF);
794 return gen_int_range(0, 5);
795 }
796
797 /*
798 generate an openx open mode
799 */
800 static uint16_t gen_openx_mode(void)
801 {
802 if (!options.valid && gen_chance(20)) return gen_bits_mask(0xFFFF);
803 if (gen_chance(20)) return gen_bits_mask(0xFF);
804 return OPENX_MODE_DENY_NONE | gen_bits_mask(0x3);
805 }
806
807 /*
808 generate an openx flags field
809 */
810 static uint16_t gen_openx_flags(void)
811 {
812 if (!options.valid && gen_chance(20)) return gen_bits_mask(0xFFFF);
813 return gen_bits_mask(0x7);
814 }
815
816 /*
817 generate an openx open function
818 */
819 static uint16_t gen_openx_func(void)
820 {
821 if (!options.valid && gen_chance(20)) return gen_bits_mask(0xFFFF);
822 return gen_bits_mask(0x13);
823 }
824
825 /*
826 generate a file attrib combination
827 */
828 static uint32_t gen_attrib(void)
829 {
830 uint32_t ret;
831 if (gen_chance(20)) {
832 ret = gen_bits_mask(0xFFFFFFFF);
833 if (options.valid) ret &= FILE_ATTRIBUTE_ALL_MASK;
834 return ret;
835 }
836 return gen_bits_mask(FILE_ATTRIBUTE_NORMAL | FILE_ATTRIBUTE_DIRECTORY);
837 }
838
839 /*
840 generate a unix timestamp
841 */
842 static time_t gen_timet(void)
843 {
844 if (gen_chance(30)) return 0;
845 return (time_t)random();
846 }
847
848 /*
849 generate a milliseconds protocol timeout
850 */
851 static uint32_t gen_timeout(void)
852 {
853 if (gen_chance(98)) return 0;
854 return random() % 50;
855 }
856
857 /*
858 generate a timestamp
859 */
860 static NTTIME gen_nttime(void)
861 {
862 NTTIME ret;
863 unix_to_nt_time(&ret, gen_timet());
864 return ret;
865 }
866
867 /*
868 generate a timewarp value
869 */
870 static NTTIME gen_timewarp(void)
871 {
872 NTTIME ret = gen_nttime();
873 if (gen_chance(98)) ret = 0;
874 return ret;
875 }
876
877 /*
878 generate a file allocation size
879 */
880 static unsigned int gen_alloc_size(void)
881 {
882 unsigned int ret;
883
884 if (gen_chance(30)) return 0;
885
886 ret = random() % 4*1024*1024;
887 /* give a high chance of a round number */
888 if (gen_chance(60)) {
889 ret &= ~(1024*1024 - 1);
890 }
891 return ret;
892 }
893
894 /*
895 generate an ea_struct
896 */
897 static struct ea_struct gen_ea_struct(void)
898 {
899 struct ea_struct ea;
900 const char *names[] = {"EAONE",
901 "",
902 "FOO!",
903 " WITH SPACES ",
904 ".",
905 "AVERYLONGATTRIBUTENAME"};
906 const char *values[] = {"VALUE1",
907 "",
908 "NOT MUCH FOO",
909 " LEADING SPACES ",
910 ":",
911 "ASOMEWHATLONGERATTRIBUTEVALUE"};
912 int i;
913
914 ZERO_STRUCT(ea);
915
916 do {
917 i = gen_int_range(0, ARRAY_SIZE(names)-1);
918 } while (ignore_pattern(names[i]));
919
920 ea.name.s = names[i];
921
922 do {
923 i = gen_int_range(0, ARRAY_SIZE(values)-1);
924 } while (ignore_pattern(values[i]));
925
926 ea.value = data_blob(values[i], strlen(values[i]));
927
928 if (gen_chance(10)) ea.flags = gen_bits_mask(0xFF);
929 ea.flags = 0;
930
931 return ea;
932 }
933
934 /*
935 generate an ea_struct
936 */
937 static struct smb_ea_list gen_ea_list(void)
938 {
939 struct smb_ea_list eas;
940 int i;
941 if (options.no_eas) {
942 ZERO_STRUCT(eas);
943 return eas;
944 }
945 eas.num_eas = gen_int_range(0, 3);
946 eas.eas = talloc_array(current_op.mem_ctx, struct ea_struct, eas.num_eas);
947 for (i=0;i<eas.num_eas;i++) {
948 eas.eas[i] = gen_ea_struct();
949 }
950 return eas;
951 }
952
953 /* generate a security descriptor */
954 static struct security_descriptor *gen_sec_desc(void)
955 {
956 struct security_descriptor *sd;
957 if (options.no_acls || gen_chance(90)) return NULL;
958
959 sd = security_descriptor_dacl_create(current_op.mem_ctx,
960 0, NULL, NULL,
961 NULL,
962 SEC_ACE_TYPE_ACCESS_ALLOWED,
963 SEC_FILE_WRITE_DATA | SEC_STD_WRITE_DAC,
964 SEC_ACE_FLAG_OBJECT_INHERIT,
965 SID_WORLD,
966 SEC_ACE_TYPE_ACCESS_ALLOWED,
967 SEC_FILE_ALL | SEC_STD_ALL,
968 0,
969 NULL);
970 return sd;
971 }
972
973
974 static void oplock_handler_close_recv_smb(struct smbcli_request *req)
975 {
976 NTSTATUS status;
977 status = smbcli_request_simple_recv(req);
978 if (!NT_STATUS_IS_OK(status)) {
979 printf("close failed in oplock_handler\n");
980 smb_panic("close failed in oplock_handler");
981 }
982 }
983
984 /*
985 the oplock handler will either ack the break or close the file
986 */
987 static bool oplock_handler_smb(struct smbcli_transport *transport, uint16_t tid, uint16_t fnum, uint8_t level, void *private_data)
988 {
989 union smb_close io;
990 int i, j;
991 bool do_close;
992 struct smbcli_tree *tree = NULL;
993 struct smbcli_request *req;
994
995 srandom(current_op.seed);
996 do_close = gen_chance(50);
997
998 for (i=0;i<NSERVERS;i++) {
999 for (j=0;j<NINSTANCES;j++) {
1000 if (transport == servers[i].smb_tree[j]->session->transport &&
1001 tid == servers[i].smb_tree[j]->tid) {
1002 oplocks[i][j].got_break = true;
1003 oplocks[i][j].smb_handle = fnum;
1004 oplocks[i][j].handle = fnum_to_handle_smb(i, j, fnum);
1005 oplocks[i][j].level = level;
1006 oplocks[i][j].do_close = do_close;
1007 tree = servers[i].smb_tree[j];
1008 }
1009 }
1010 }
1011
1012 if (!tree) {
1013 printf("Oplock break not for one of our trees!?\n");
1014 return false;
1015 }
1016
1017 if (!do_close) {
1018 printf("oplock ack fnum=%d\n", fnum);
1019 return smbcli_oplock_ack(tree, fnum, level);
1020 }
1021
1022 printf("oplock close fnum=%d\n", fnum);
1023
1024 io.close.level = RAW_CLOSE_CLOSE;
1025 io.close.in.file.fnum = fnum;
1026 io.close.in.write_time = 0;
1027 req = smb_raw_close_send(tree, &io);
1028
1029 if (req == NULL) {
1030 printf("WARNING: close failed in oplock_handler_close\n");
1031 return false;
1032 }
1033
1034 req->async.fn = oplock_handler_close_recv_smb;
1035 req->async.private_data = NULL;
1036
1037 return true;
1038 }
1039
1040
1041 /*
1042 the idle function tries to cope with getting an oplock break on a connection, and
1043 an operation on another connection blocking until that break is acked
1044 we check for operations on all transports in the idle function
1045 */
1046 static void idle_func_smb(struct smbcli_transport *transport, void *private_data)
1047 {
1048 int i, j;
1049 for (i=0;i<NSERVERS;i++) {
1050 for (j=0;j<NINSTANCES;j++) {
1051 if (servers[i].smb_tree[j] &&
1052 transport != servers[i].smb_tree[j]->session->transport) {
1053 smbcli_transport_process(servers[i].smb_tree[j]->session->transport);
1054 }
1055 }
1056 }
1057
1058 }
1059
1060 static void oplock_handler_close_recv_smb2(struct smb2_request *req)
1061 {
1062 NTSTATUS status;
1063 struct smb2_close io;
1064 status = smb2_close_recv(req, &io);
1065 if (!NT_STATUS_IS_OK(status)) {
1066 printf("close failed in oplock_handler\n");
1067 smb_panic("close failed in oplock_handler");
1068 }
1069 }
1070
1071 static void oplock_handler_ack_callback_smb2(struct smb2_request *req)
1072 {
1073 NTSTATUS status;
1074 struct smb2_break br;
1075
1076 status = smb2_break_recv(req, &br);
1077 if (!NT_STATUS_IS_OK(status)) {
1078 printf("oplock break ack failed in oplock_handler\n");
1079 smb_panic("oplock break ack failed in oplock_handler");
1080 }
1081 }
1082
1083 static bool send_oplock_ack_smb2(struct smb2_tree *tree, struct smb2_handle handle,
1084 uint8_t level)
1085 {
1086 struct smb2_break br;
1087 struct smb2_request *req;
1088
1089 ZERO_STRUCT(br);
1090 br.in.file.handle = handle;
1091 br.in.oplock_level = level;
1092 br.in.reserved = gen_reserved8();
1093 br.in.reserved2 = gen_reserved32();
1094
1095 req = smb2_break_send(tree, &br);
1096 if (req == NULL) return false;
1097 req->async.fn = oplock_handler_ack_callback_smb2;
1098 req->async.private_data = NULL;
1099 return true;
1100 }
1101
1102 /*
1103 the oplock handler will either ack the break or close the file
1104 */
1105 static bool oplock_handler_smb2(struct smb2_transport *transport, const struct smb2_handle *handle,
1106 uint8_t level, void *private_data)
1107 {
1108 struct smb2_close io;
1109 unsigned i, j;
1110 bool do_close;
1111 struct smb2_tree *tree = NULL;
1112 struct smb2_request *req;
1113
1114 srandom(current_op.seed);
1115 do_close = gen_chance(50);
1116
1117 i = ((uintptr_t)private_data) >> 8;
1118 j = ((uintptr_t)private_data) & 0xFF;
1119
1120 if (i >= NSERVERS || j >= NINSTANCES) {
1121 printf("Bad private_data in oplock_handler\n");
1122 return false;
1123 }
1124
1125 oplocks[i][j].got_break = true;
1126 oplocks[i][j].smb2_handle = *handle;
1127 oplocks[i][j].handle = fnum_to_handle_smb2(i, j, *handle);
1128 oplocks[i][j].level = level;
1129 oplocks[i][j].do_close = do_close;
1130 tree = talloc_get_type(servers[i].smb2_tree[j], struct smb2_tree);
1131
1132 if (!tree) {
1133 printf("Oplock break not for one of our trees!?\n");
1134 return false;
1135 }
1136
1137 if (!do_close) {
1138 printf("oplock ack handle=%d\n", oplocks[i][j].handle);
1139 return send_oplock_ack_smb2(tree, *handle, level);
1140 }
1141
1142 printf("oplock close fnum=%d\n", oplocks[i][j].handle);
1143
1144 ZERO_STRUCT(io);
1145 io.in.file.handle = *handle;
1146 io.in.flags = 0;
1147 req = smb2_close_send(tree, &io);
1148
1149 if (req == NULL) {
1150 printf("WARNING: close failed in oplock_handler_close\n");
1151 return false;
1152 }
1153
1154 req->async.fn = oplock_handler_close_recv_smb2;
1155 req->async.private_data = NULL;
1156
1157 return true;
1158 }
1159
1160
1161 /*
1162 the idle function tries to cope with getting an oplock break on a connection, and
1163 an operation on another connection blocking until that break is acked
1164 we check for operations on all transports in the idle function
1165 */
1166 static void idle_func_smb2(struct smb2_transport *transport, void *private_data)
1167 {
1168 int i, j;
1169 for (i=0;i<NSERVERS;i++) {
1170 for (j=0;j<NINSTANCES;j++) {
1171 if (servers[i].smb2_tree[j] &&
1172 transport != servers[i].smb2_tree[j]->session->transport) {
1173 // smb2_transport_process(servers[i].smb2_tree[j]->session->transport);
1174 }
1175 }
1176 }
1177
1178 }
1179
1180
1181 /*
1182 compare NTSTATUS, using checking ignored patterns
1183 */
1184 static bool compare_status(NTSTATUS status1, NTSTATUS status2)
1185 {
1186 char *s;
1187
1188 if (NT_STATUS_EQUAL(status1, status2)) return true;
1189
1190 /* one code being an error and the other OK is always an error */
1191 if (NT_STATUS_IS_OK(status1) || NT_STATUS_IS_OK(status2)) {
1192 current_op.mismatch = nt_errstr(status1);
1193 return false;
1194 }
1195
1196 /* if we are ignoring one of the status codes then consider this a match */
1197 if (ignore_pattern(nt_errstr(status1)) ||
1198 ignore_pattern(nt_errstr(status2))) {
1199 return true;
1200 }
1201
1202 /* also support ignore patterns of the form NT_STATUS_XX:NT_STATUS_YY
1203 meaning that the first server returns NT_STATUS_XX and the 2nd
1204 returns NT_STATUS_YY */
1205 s = talloc_asprintf(current_op.mem_ctx, "%s:%s",
1206 nt_errstr(status1),
1207 nt_errstr(status2));
1208 if (ignore_pattern(s)) {
1209 return true;
1210 }
1211
1212 current_op.mismatch = nt_errstr(status1);
1213 return false;
1214 }
1215
1216 /*
1217 check for pending packets on all connections
1218 */
1219 static void check_pending(void)
1220 {
1221 int i, j;
1222
1223 smb_msleep(20);
1224
1225 for (j=0;j<NINSTANCES;j++) {
1226 for (i=0;i<NSERVERS;i++) {
1227 // smb2_transport_process(servers[i].smb2_tree[j]->session->transport);
1228 }
1229 }
1230 }
1231
1232 /*
1233 check that the same oplock breaks have been received by all instances
1234 */
1235 static bool check_oplocks(const char *call)
1236 {
1237 int i, j;
1238 int tries = 0;
1239
1240 if (!options.use_oplocks || options.smb2) {
1241 /* no smb2 oplocks in gentest yet */
1242 return true;
1243 }
1244
1245 again:
1246 check_pending();
1247
1248 for (j=0;j<NINSTANCES;j++) {
1249 for (i=1;i<NSERVERS;i++) {
1250 if (oplocks[0][j].got_break != oplocks[i][j].got_break ||
1251 oplocks[0][j].handle != oplocks[i][j].handle ||
1252 oplocks[0][j].level != oplocks[i][j].level) {
1253 if (tries++ < 10) goto again;
1254 printf("oplock break inconsistent - %d/%d/%d vs %d/%d/%d\n",
1255 oplocks[0][j].got_break,
1256 oplocks[0][j].handle,
1257 oplocks[0][j].level,
1258 oplocks[i][j].got_break,
1259 oplocks[i][j].handle,
1260 oplocks[i][j].level);
1261 current_op.mismatch = "oplock break";
1262 return false;
1263 }
1264 }
1265 }
1266
1267 /* if we got a break and closed then remove the handle */
1268 for (j=0;j<NINSTANCES;j++) {
1269 if (oplocks[0][j].got_break &&
1270 oplocks[0][j].do_close) {
1271 uint16_t fnums[NSERVERS];
1272 for (i=0;i<NSERVERS;i++) {
1273 fnums[i] = oplocks[i][j].smb_handle;
1274 }
1275 gen_remove_handle_smb(j, fnums);
1276 break;
1277 }
1278 }
1279 return true;
1280 }
1281
1282
1283 /*
1284 check that the same change notify info has been received by all instances
1285 */
1286 static bool check_notifies(const char *call)
1287 {
1288 int i, j;
1289 int tries = 0;
1290
1291 if (options.smb2) {
1292 /* no smb2 notifies in gentest yet */
1293 return true;
1294 }
1295
1296 again:
1297 check_pending();
1298
1299 for (j=0;j<NINSTANCES;j++) {
1300 for (i=1;i<NSERVERS;i++) {
1301 int n;
1302 union smb_notify not1, not2;
1303
1304 if (notifies[0][j].notify_count != notifies[i][j].notify_count) {
1305 if (tries++ < 10) goto again;
1306 printf("Notify count inconsistent %d %d\n",
1307 notifies[0][j].notify_count,
1308 notifies[i][j].notify_count);
1309 current_op.mismatch = "notify count";
1310 return false;
1311 }
1312
1313 if (notifies[0][j].notify_count == 0) continue;
1314
1315 if (!NT_STATUS_EQUAL(notifies[0][j].status,
1316 notifies[i][j].status)) {
1317 printf("Notify status mismatch - %s - %s\n",
1318 nt_errstr(notifies[0][j].status),
1319 nt_errstr(notifies[i][j].status));
1320 current_op.mismatch = "Notify status";
1321 return false;
1322 }
1323
1324 if (!NT_STATUS_IS_OK(notifies[0][j].status)) {
1325 continue;
1326 }
1327
1328 not1 = notifies[0][j].notify;
1329 not2 = notifies[i][j].notify;
1330
1331 for (n=0;n<not1.nttrans.out.num_changes;n++) {
1332 if (not1.nttrans.out.changes[n].action !=
1333 not2.nttrans.out.changes[n].action) {
1334 printf("Notify action %d inconsistent %d %d\n", n,
1335 not1.nttrans.out.changes[n].action,
1336 not2.nttrans.out.changes[n].action);
1337 current_op.mismatch = "notify action";
1338 return false;
1339 }
1340 if (strcmp(not1.nttrans.out.changes[n].name.s,
1341 not2.nttrans.out.changes[n].name.s)) {
1342 printf("Notify name %d inconsistent %s %s\n", n,
1343 not1.nttrans.out.changes[n].name.s,
1344 not2.nttrans.out.changes[n].name.s);
1345 current_op.mismatch = "notify name";
1346 return false;
1347 }
1348 if (not1.nttrans.out.changes[n].name.private_length !=
1349 not2.nttrans.out.changes[n].name.private_length) {
1350 printf("Notify name length %d inconsistent %d %d\n", n,
1351 not1.nttrans.out.changes[n].name.private_length,
1352 not2.nttrans.out.changes[n].name.private_length);
1353 current_op.mismatch = "notify name length";
1354 return false;
1355 }
1356 }
1357 }
1358 }
1359
1360 ZERO_STRUCT(notifies);
1361
1362 return true;
1363 }
1364
1365 #define GEN_COPY_PARM do { \
1366 int i; \
1367 for (i=1;i<NSERVERS;i++) { \
1368 parm[i] = parm[0]; \
1369 } \
1370 } while (0)
1371
1372 #define GEN_CALL(call, treetype, treefield) do { \
1373 int i; \
1374 ZERO_STRUCT(oplocks); \
1375 ZERO_STRUCT(notifies); \
1376 for (i=0;i<NSERVERS;i++) { \
1377 struct treetype *tree = servers[i].treefield[instance]; \
1378 status[i] = call; \
1379 } \
1380 current_op.status = status[0]; \
1381 for (i=1;i<NSERVERS;i++) { \
1382 if (!compare_status(status[0], status[1])) { \
1383 printf("status different in %s - %s %s\n", #call, \
1384 nt_errstr(status[0]), nt_errstr(status[i])); \
1385 current_op.mismatch = nt_errstr(status[0]); \
1386 return false; \
1387 } \
1388 } \
1389 if (!check_oplocks(#call)) return false; \
1390 if (!check_notifies(#call)) return false; \
1391 if (!NT_STATUS_IS_OK(status[0])) { \
1392 return true; \
1393 } \
1394 } while(0)
1395
1396 #define GEN_CALL_SMB(call) GEN_CALL(call, smbcli_tree, smb_tree)
1397 #define GEN_CALL_SMB2(call) GEN_CALL(call, smb2_tree, smb2_tree)
1398
1399 #define ADD_HANDLE_SMB2(name, field) do { \
1400 struct smb2_handle handles[NSERVERS]; \
1401 int i; \
1402 for (i=0;i<NSERVERS;i++) { \
1403 handles[i] = parm[i].field; \
1404 } \
1405 gen_add_handle_smb2(instance, name, handles); \
1406 } while(0)
1407
1408 #define REMOVE_HANDLE_SMB2(field) do { \
1409 struct smb2_handle handles[NSERVERS]; \
1410 int i; \
1411 for (i=0;i<NSERVERS;i++) { \
1412 handles[i] = parm[i].field; \
1413 } \
1414 gen_remove_handle_smb2(instance, handles); \
1415 } while(0)
1416
1417 #define ADD_HANDLE_SMB(name, field) do { \
1418 uint16_t handles[NSERVERS]; \
1419 int i; \
1420 for (i=0;i<NSERVERS;i++) { \
1421 handles[i] = parm[i].field; \
1422 } \
1423 gen_add_handle_smb(instance, name, handles); \
1424 } while(0)
1425
1426 #define REMOVE_HANDLE_SMB(field) do { \
1427 uint16_t handles[NSERVERS]; \
1428 int i; \
1429 for (i=0;i<NSERVERS;i++) { \
1430 handles[i] = parm[i].field; \
1431 } \
1432 gen_remove_handle_smb(instance, handles); \
1433 } while(0)
1434
1435 #define GEN_SET_FNUM_SMB2(field) do { \
1436 int i; \
1437 for (i=0;i<NSERVERS;i++) { \
1438 parm[i].field = gen_lookup_handle_smb2(i, parm[i].field.data[0]); \
1439 } \
1440 } while(0)
1441
1442 #define GEN_SET_FNUM_SMB(field) do { \
1443 int i; \
1444 for (i=0;i<NSERVERS;i++) { \
1445 parm[i].field = gen_lookup_handle_smb(i, parm[i].field); \
1446 } \
1447 } while(0)
1448
1449 #define CHECK_EQUAL(field) do { \
1450 if (parm[0].field != parm[1].field && !ignore_pattern(#field)) { \
1451 current_op.mismatch = #field; \
1452 printf("Mismatch in %s - 0x%llx 0x%llx\n", #field, \
1453 (unsigned long long)parm[0].field, (unsigned long long)parm[1].field); \
1454 return false; \
1455 } \
1456 } while(0)
1457
1458 #define CHECK_SECDESC(field) do { \
1459 if (!security_acl_equal(parm[0].field->dacl, parm[1].field->dacl) && !ignore_pattern(#field)) { \
1460 current_op.mismatch = #field; \
1461 printf("Mismatch in %s\n", #field); \
1462 return false; \
1463 } \
1464 } while(0)
1465
1466 #define CHECK_ATTRIB(field) do { \
1467 if (!options.mask_indexing) { \
1468 CHECK_EQUAL(field); \
1469 } else if ((~FILE_ATTRIBUTE_NONINDEXED & parm[0].field) != (~FILE_ATTRIBUTE_NONINDEXED & parm[1].field) && !ignore_pattern(#field)) { \
1470 current_op.mismatch = #field; \
1471 printf("Mismatch in %s - 0x%x 0x%x\n", #field, \
1472 (int)parm[0].field, (int)parm[1].field); \
1473 return false; \
1474 } \
1475 } while(0)
1476
1477 #define CHECK_WSTR_EQUAL(field) do { \
1478 if ((!parm[0].field.s && parm[1].field.s) || (parm[0].field.s && !parm[1].field.s)) { \
1479 current_op.mismatch = #field; \
1480 printf("%s is NULL!\n", #field); \
1481 return false; \
1482 } \
1483 if (parm[0].field.s && strcmp(parm[0].field.s, parm[1].field.s) != 0 && !ignore_pattern(#field)) { \
1484 current_op.mismatch = #field; \
1485 printf("Mismatch in %s - %s %s\n", #field, \
1486 parm[0].field.s, parm[1].field.s); \
1487 return false; \
1488 } \
1489 CHECK_EQUAL(field.private_length); \
1490 } while(0)
1491
1492 #define CHECK_BLOB_EQUAL(field) do { \
1493 if (((parm[0].field.data == NULL && parm[1].field.data != NULL) || \
1494 (parm[1].field.data == NULL && parm[0].field.data != NULL) || \
1495 (memcmp(parm[0].field.data, parm[1].field.data, parm[0].field.length) != 0)) && !ignore_pattern(#field)) { \
1496 current_op.mismatch = #field; \
1497 printf("Mismatch in %s\n", #field); \
1498 return false; \
1499 } \
1500 CHECK_EQUAL(field.length); \
1501 } while(0)
1502
1503 #define CHECK_TIMES_EQUAL(field) do { \
1504 if (labs(parm[0].field - parm[1].field) > time_skew() && \
1505 !ignore_pattern(#field)) { \
1506 current_op.mismatch = #field; \
1507 printf("Mismatch in %s - 0x%x 0x%x\n", #field, \
1508 (int)parm[0].field, (int)parm[1].field); \
1509 return false; \
1510 } \
1511 } while(0)
1512
1513 #define CHECK_NTTIMES_EQUAL(field) do { \
1514 if (labs(nt_time_to_unix(parm[0].field) - \
1515 nt_time_to_unix(parm[1].field)) > time_skew() && \
1516 !ignore_pattern(#field)) { \
1517 current_op.mismatch = #field; \
1518 printf("Mismatch in %s - 0x%x 0x%x\n", #field, \
1519 (int)nt_time_to_unix(parm[0].field), \
1520 (int)nt_time_to_unix(parm[1].field)); \
1521 return false; \
1522 } \
1523 } while(0)
1524
1525
1526 /*
1527 compare returned fileinfo structures
1528 */
1529 static bool cmp_fileinfo(int instance,
1530 union smb_fileinfo parm[NSERVERS],
1531 NTSTATUS status[NSERVERS])
1532 {
1533 int i;
1534 enum smb_fileinfo_level level = parm[0].generic.level;
1535
1536 if (level == RAW_FILEINFO_ALL_INFORMATION &&
1537 options.smb2) {
1538 level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
1539 }
1540
1541 switch (level) {
1542 case RAW_FILEINFO_GENERIC:
1543 return false;
1544
1545 case RAW_FILEINFO_GETATTR:
1546 CHECK_ATTRIB(getattr.out.attrib);
1547 CHECK_EQUAL(getattr.out.size);
1548 CHECK_TIMES_EQUAL(getattr.out.write_time);
1549 break;
1550
1551 case RAW_FILEINFO_GETATTRE:
1552 CHECK_TIMES_EQUAL(getattre.out.create_time);
1553 CHECK_TIMES_EQUAL(getattre.out.access_time);
1554 CHECK_TIMES_EQUAL(getattre.out.write_time);
1555 CHECK_EQUAL(getattre.out.size);
1556 CHECK_EQUAL(getattre.out.alloc_size);
1557 CHECK_ATTRIB(getattre.out.attrib);
1558 break;
1559
1560 case RAW_FILEINFO_STANDARD:
1561 CHECK_TIMES_EQUAL(standard.out.create_time);
1562 CHECK_TIMES_EQUAL(standard.out.access_time);
1563 CHECK_TIMES_EQUAL(standard.out.write_time);
1564 CHECK_EQUAL(standard.out.size);
1565 CHECK_EQUAL(standard.out.alloc_size);
1566 CHECK_ATTRIB(standard.out.attrib);
1567 break;
1568
1569 case RAW_FILEINFO_EA_SIZE:
1570 CHECK_TIMES_EQUAL(ea_size.out.create_time);
1571 CHECK_TIMES_EQUAL(ea_size.out.access_time);
1572 CHECK_TIMES_EQUAL(ea_size.out.write_time);
1573 CHECK_EQUAL(ea_size.out.size);
1574 CHECK_EQUAL(ea_size.out.alloc_size);
1575 CHECK_ATTRIB(ea_size.out.attrib);
1576 CHECK_EQUAL(ea_size.out.ea_size);
1577 break;
1578
1579 case RAW_FILEINFO_ALL_EAS:
1580 CHECK_EQUAL(all_eas.out.num_eas);
1581 for (i=0;i<parm[0].all_eas.out.num_eas;i++) {
1582 CHECK_EQUAL(all_eas.out.eas[i].flags);
1583 CHECK_WSTR_EQUAL(all_eas.out.eas[i].name);
1584 CHECK_BLOB_EQUAL(all_eas.out.eas[i].value);
1585 }
1586 break;
1587
1588 case RAW_FILEINFO_IS_NAME_VALID:
1589 break;
1590
1591 case RAW_FILEINFO_BASIC_INFO:
1592 case RAW_FILEINFO_BASIC_INFORMATION:
1593 CHECK_NTTIMES_EQUAL(basic_info.out.create_time);
1594 CHECK_NTTIMES_EQUAL(basic_info.out.access_time);
1595 CHECK_NTTIMES_EQUAL(basic_info.out.write_time);
1596 CHECK_NTTIMES_EQUAL(basic_info.out.change_time);
1597 CHECK_ATTRIB(basic_info.out.attrib);
1598 break;
1599
1600 case RAW_FILEINFO_STANDARD_INFO:
1601 case RAW_FILEINFO_STANDARD_INFORMATION:
1602 CHECK_EQUAL(standard_info.out.alloc_size);
1603 CHECK_EQUAL(standard_info.out.size);
1604 CHECK_EQUAL(standard_info.out.nlink);
1605 CHECK_EQUAL(standard_info.out.delete_pending);
1606 CHECK_EQUAL(standard_info.out.directory);
1607 break;
1608
1609 case RAW_FILEINFO_EA_INFO:
1610 case RAW_FILEINFO_EA_INFORMATION:
1611 CHECK_EQUAL(ea_info.out.ea_size);
1612 break;
1613
1614 case RAW_FILEINFO_NAME_INFO:
1615 case RAW_FILEINFO_NAME_INFORMATION:
1616 CHECK_WSTR_EQUAL(name_info.out.fname);
1617 break;
1618
1619 case RAW_FILEINFO_ALL_INFO:
1620 case RAW_FILEINFO_ALL_INFORMATION:
1621 CHECK_NTTIMES_EQUAL(all_info.out.create_time);
1622 CHECK_NTTIMES_EQUAL(all_info.out.access_time);
1623 CHECK_NTTIMES_EQUAL(all_info.out.write_time);
1624 CHECK_NTTIMES_EQUAL(all_info.out.change_time);
1625 CHECK_ATTRIB(all_info.out.attrib);
1626 CHECK_EQUAL(all_info.out.alloc_size);
1627 CHECK_EQUAL(all_info.out.size);
1628 CHECK_EQUAL(all_info.out.nlink);
1629 CHECK_EQUAL(all_info.out.delete_pending);
1630 CHECK_EQUAL(all_info.out.directory);
1631 CHECK_EQUAL(all_info.out.ea_size);
1632 CHECK_WSTR_EQUAL(all_info.out.fname);
1633 break;
1634
1635 case RAW_FILEINFO_ALT_NAME_INFO:
1636 case RAW_FILEINFO_ALT_NAME_INFORMATION:
1637 CHECK_WSTR_EQUAL(alt_name_info.out.fname);
1638 break;
1639
1640 case RAW_FILEINFO_STREAM_INFO:
1641 case RAW_FILEINFO_STREAM_INFORMATION:
1642 CHECK_EQUAL(stream_info.out.num_streams);
1643 for (i=0;i<parm[0].stream_info.out.num_streams;i++) {
1644 CHECK_EQUAL(stream_info.out.streams[i].size);
1645 CHECK_EQUAL(stream_info.out.streams[i].alloc_size);
1646 CHECK_WSTR_EQUAL(stream_info.out.streams[i].stream_name);
1647 }
1648 break;
1649
1650 case RAW_FILEINFO_COMPRESSION_INFO:
1651 case RAW_FILEINFO_COMPRESSION_INFORMATION:
1652 CHECK_EQUAL(compression_info.out.compressed_size);
1653 CHECK_EQUAL(compression_info.out.format);
1654 CHECK_EQUAL(compression_info.out.unit_shift);
1655 CHECK_EQUAL(compression_info.out.chunk_shift);
1656 CHECK_EQUAL(compression_info.out.cluster_shift);
1657 break;
1658
1659 case RAW_FILEINFO_INTERNAL_INFORMATION:
1660 CHECK_EQUAL(internal_information.out.file_id);
1661 break;
1662
1663 case RAW_FILEINFO_ACCESS_INFORMATION:
1664 CHECK_EQUAL(access_information.out.access_flags);
1665 break;
1666
1667 case RAW_FILEINFO_POSITION_INFORMATION:
1668 CHECK_EQUAL(position_information.out.position);
1669 break;
1670
1671 case RAW_FILEINFO_MODE_INFORMATION:
1672 CHECK_EQUAL(mode_information.out.mode);
1673 break;
1674
1675 case RAW_FILEINFO_ALIGNMENT_INFORMATION:
1676 CHECK_EQUAL(alignment_information.out.alignment_requirement);
1677 break;
1678
1679 case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
1680 CHECK_NTTIMES_EQUAL(network_open_information.out.create_time);
1681 CHECK_NTTIMES_EQUAL(network_open_information.out.access_time);
1682 CHECK_NTTIMES_EQUAL(network_open_information.out.write_time);
1683 CHECK_NTTIMES_EQUAL(network_open_information.out.change_time);
1684 CHECK_EQUAL(network_open_information.out.alloc_size);
1685 CHECK_EQUAL(network_open_information.out.size);
1686 CHECK_ATTRIB(network_open_information.out.attrib);
1687 break;
1688
1689 case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
1690 CHECK_ATTRIB(attribute_tag_information.out.attrib);
1691 CHECK_EQUAL(attribute_tag_information.out.reparse_tag);
1692 break;
1693
1694 case RAW_FILEINFO_SMB2_ALL_INFORMATION:
1695 CHECK_NTTIMES_EQUAL(all_info2.out.create_time);
1696 CHECK_NTTIMES_EQUAL(all_info2.out.access_time);
1697 CHECK_NTTIMES_EQUAL(all_info2.out.write_time);
1698 CHECK_NTTIMES_EQUAL(all_info2.out.change_time);
1699 CHECK_ATTRIB(all_info2.out.attrib);
1700 CHECK_EQUAL(all_info2.out.unknown1);
1701 CHECK_EQUAL(all_info2.out.alloc_size);
1702 CHECK_EQUAL(all_info2.out.size);
1703 CHECK_EQUAL(all_info2.out.nlink);
1704 CHECK_EQUAL(all_info2.out.delete_pending);
1705 CHECK_EQUAL(all_info2.out.directory);
1706 CHECK_EQUAL(all_info2.out.file_id);
1707 CHECK_EQUAL(all_info2.out.ea_size);
1708 CHECK_EQUAL(all_info2.out.access_mask);
1709 CHECK_EQUAL(all_info2.out.position);
1710 CHECK_EQUAL(all_info2.out.mode);
1711 CHECK_EQUAL(all_info2.out.alignment_requirement);
1712 CHECK_WSTR_EQUAL(all_info2.out.fname);
1713 break;
1714
1715 case RAW_FILEINFO_SMB2_ALL_EAS:
1716 CHECK_EQUAL(all_eas.out.num_eas);
1717 for (i=0;i<parm[0].all_eas.out.num_eas;i++) {
1718 CHECK_EQUAL(all_eas.out.eas[i].flags);
1719 CHECK_WSTR_EQUAL(all_eas.out.eas[i].name);
1720 CHECK_BLOB_EQUAL(all_eas.out.eas[i].value);
1721 }
1722 break;
1723
1724 case RAW_FILEINFO_SEC_DESC:
1725 CHECK_SECDESC(query_secdesc.out.sd);
1726 break;
1727
1728 /* Unhandled levels */
1729 case RAW_FILEINFO_EA_LIST:
1730 case RAW_FILEINFO_UNIX_BASIC:
1731 case RAW_FILEINFO_UNIX_LINK:
1732 case RAW_FILEINFO_UNIX_INFO2:
1733 break;
1734 }
1735
1736 return true;
1737 }
1738
1739
1740
1741 /*
1742 generate openx operations
1743 */
1744 static bool handler_smb_openx(int instance)
1745 {
1746 union smb_open parm[NSERVERS];
1747 NTSTATUS status[NSERVERS];
1748
1749 parm[0].openx.level = RAW_OPEN_OPENX;
1750 parm[0].openx.in.flags = gen_openx_flags();
1751 parm[0].openx.in.open_mode = gen_openx_mode();
1752 parm[0].openx.in.search_attrs = gen_attrib();
1753 parm[0].openx.in.file_attrs = gen_attrib();
1754 parm[0].openx.in.write_time = gen_timet();
1755 parm[0].openx.in.open_func = gen_openx_func();
1756 parm[0].openx.in.size = gen_io_count();
1757 parm[0].openx.in.timeout = gen_timeout();
1758 parm[0].openx.in.fname = gen_fname_open(instance);
1759
1760 if (!options.use_oplocks) {
1761 /* mask out oplocks */
1762 parm[0].openx.in.flags &= ~(OPENX_FLAGS_REQUEST_OPLOCK|
1763 OPENX_FLAGS_REQUEST_BATCH_OPLOCK);
1764 }
1765
1766 GEN_COPY_PARM;
1767 GEN_CALL_SMB(smb_raw_open(tree, current_op.mem_ctx, &parm[i]));
1768
1769 CHECK_ATTRIB(openx.out.attrib);
1770 CHECK_EQUAL(openx.out.size);
1771 CHECK_EQUAL(openx.out.access);
1772 CHECK_EQUAL(openx.out.ftype);
1773 CHECK_EQUAL(openx.out.devstate);
1774 CHECK_EQUAL(openx.out.action);
1775 CHECK_EQUAL(openx.out.access_mask);
1776 CHECK_EQUAL(openx.out.unknown);
1777 CHECK_TIMES_EQUAL(openx.out.write_time);
1778
1779 /* open creates a new file handle */
1780 ADD_HANDLE_SMB(parm[0].openx.in.fname, openx.out.file.fnum);
1781
1782 return true;
1783 }
1784
1785
1786 /*
1787 generate open operations
1788 */
1789 static bool handler_smb_open(int instance)
1790 {
1791 union smb_open parm[NSERVERS];
1792 NTSTATUS status[NSERVERS];
1793
1794 parm[0].openold.level = RAW_OPEN_OPEN;
1795 parm[0].openold.in.open_mode = gen_bits_mask2(0xF, 0xFFFF);
1796 parm[0].openold.in.search_attrs = gen_attrib();
1797 parm[0].openold.in.fname = gen_fname_open(instance);
1798
1799 if (!options.use_oplocks) {
1800 /* mask out oplocks */
1801 parm[0].openold.in.open_mode &= ~(OPENX_FLAGS_REQUEST_OPLOCK|
1802 OPENX_FLAGS_REQUEST_BATCH_OPLOCK);
1803 }
1804
1805 GEN_COPY_PARM;
1806 GEN_CALL_SMB(smb_raw_open(tree, current_op.mem_ctx, &parm[i]));
1807
1808 CHECK_ATTRIB(openold.out.attrib);
1809 CHECK_TIMES_EQUAL(openold.out.write_time);
1810 CHECK_EQUAL(openold.out.size);
1811 CHECK_EQUAL(openold.out.rmode);
1812
1813 /* open creates a new file handle */
1814 ADD_HANDLE_SMB(parm[0].openold.in.fname, openold.out.file.fnum);
1815
1816 return true;
1817 }
1818
1819
1820 /*
1821 generate ntcreatex operations
1822 */
1823 static bool handler_smb_ntcreatex(int instance)
1824 {
1825 union smb_open parm[NSERVERS];
1826 NTSTATUS status[NSERVERS];
1827
1828 parm[0].ntcreatex.level = RAW_OPEN_NTCREATEX;
1829 parm[0].ntcreatex.in.flags = gen_ntcreatex_flags();
1830 parm[0].ntcreatex.in.root_fid.fnum = gen_root_fid(instance);
1831 parm[0].ntcreatex.in.access_mask = gen_access_mask();
1832 parm[0].ntcreatex.in.alloc_size = gen_alloc_size();
1833 parm[0].ntcreatex.in.file_attr = gen_attrib();
1834 parm[0].ntcreatex.in.share_access = gen_bits_mask2(0x7, 0xFFFFFFFF);
1835 parm[0].ntcreatex.in.open_disposition = gen_open_disp();
1836 parm[0].ntcreatex.in.create_options = gen_create_options();
1837 parm[0].ntcreatex.in.impersonation = gen_bits_mask2(0, 0xFFFFFFFF);
1838 parm[0].ntcreatex.in.security_flags = gen_bits_mask2(0, 0xFF);
1839 parm[0].ntcreatex.in.fname = gen_fname_open(instance);
1840
1841 if (!options.use_oplocks) {
1842 /* mask out oplocks */
1843 parm[0].ntcreatex.in.flags &= ~(NTCREATEX_FLAGS_REQUEST_OPLOCK|
1844 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK);
1845 }
1846
1847 GEN_COPY_PARM;
1848 if (parm[0].ntcreatex.in.root_fid.fnum != 0) {
1849 GEN_SET_FNUM_SMB(ntcreatex.in.root_fid.fnum);
1850 }
1851 GEN_CALL_SMB(smb_raw_open(tree, current_op.mem_ctx, &parm[i]));
1852
1853 CHECK_EQUAL(ntcreatex.out.oplock_level);
1854 CHECK_EQUAL(ntcreatex.out.create_action);
1855 CHECK_NTTIMES_EQUAL(ntcreatex.out.create_time);
1856 CHECK_NTTIMES_EQUAL(ntcreatex.out.access_time);
1857 CHECK_NTTIMES_EQUAL(ntcreatex.out.write_time);
1858 CHECK_NTTIMES_EQUAL(ntcreatex.out.change_time);
1859 CHECK_ATTRIB(ntcreatex.out.attrib);
1860 CHECK_EQUAL(ntcreatex.out.alloc_size);
1861 CHECK_EQUAL(ntcreatex.out.size);
1862 CHECK_EQUAL(ntcreatex.out.file_type);
1863 CHECK_EQUAL(ntcreatex.out.ipc_state);
1864 CHECK_EQUAL(ntcreatex.out.is_directory);
1865
1866 /* ntcreatex creates a new file handle */
1867 ADD_HANDLE_SMB(parm[0].ntcreatex.in.fname, ntcreatex.out.file.fnum);
1868
1869 return true;
1870 }
1871
1872 /*
1873 generate close operations
1874 */
1875 static bool handler_smb_close(int instance)
1876 {
1877 union smb_close parm[NSERVERS];
1878 NTSTATUS status[NSERVERS];
1879
1880 parm[0].close.level = RAW_CLOSE_CLOSE;
1881 parm[0].close.in.file.fnum = gen_fnum_close(instance);
1882 parm[0].close.in.write_time = gen_timet();
1883
1884 GEN_COPY_PARM;
1885 GEN_SET_FNUM_SMB(close.in.file.fnum);
1886 GEN_CALL_SMB(smb_raw_close(tree, &parm[i]));
1887
1888 REMOVE_HANDLE_SMB(close.in.file.fnum);
1889
1890 return true;
1891 }
1892
1893 /*
1894 generate unlink operations
1895 */
1896 static bool handler_smb_unlink(int instance)
1897 {
1898 union smb_unlink parm[NSERVERS];
1899 NTSTATUS status[NSERVERS];
1900
1901 parm[0].unlink.in.pattern = gen_pattern();
1902 parm[0].unlink.in.attrib = gen_attrib();
1903
1904 GEN_COPY_PARM;
1905 GEN_CALL_SMB(smb_raw_unlink(tree, &parm[i]));
1906
1907 return true;
1908 }
1909
1910 /*
1911 generate chkpath operations
1912 */
1913 static bool handler_smb_chkpath(int instance)
1914 {
1915 union smb_chkpath parm[NSERVERS];
1916 NTSTATUS status[NSERVERS];
1917
1918 parm[0].chkpath.in.path = gen_fname_open(instance);
1919
1920 GEN_COPY_PARM;
1921 GEN_CALL_SMB(smb_raw_chkpath(tree, &parm[i]));
1922
1923 return true;
1924 }
1925
1926 /*
1927 generate mkdir operations
1928 */
1929 static bool handler_smb_mkdir(int instance)
1930 {
1931 union smb_mkdir parm[NSERVERS];
1932 NTSTATUS status[NSERVERS];
1933
1934 parm[0].mkdir.level = RAW_MKDIR_MKDIR;
1935 parm[0].mkdir.in.path = gen_fname_open(instance);
1936
1937 GEN_COPY_PARM;
1938 GEN_CALL_SMB(smb_raw_mkdir(tree, &parm[i]));
1939
1940 return true;
1941 }
1942
1943 /*
1944 generate rmdir operations
1945 */
1946 static bool handler_smb_rmdir(int instance)
1947 {
1948 struct smb_rmdir parm[NSERVERS];
1949 NTSTATUS status[NSERVERS];
1950
1951 parm[0].in.path = gen_fname_open(instance);
1952
1953 GEN_COPY_PARM;
1954 GEN_CALL_SMB(smb_raw_rmdir(tree, &parm[i]));
1955
1956 return true;
1957 }
1958
1959 /*
1960 generate rename operations
1961 */
1962 static bool handler_smb_rename(int instance)
1963 {
1964 union smb_rename parm[NSERVERS];
1965 NTSTATUS status[NSERVERS];
1966
1967 parm[0].generic.level = RAW_RENAME_RENAME;
1968 parm[0].rename.in.pattern1 = gen_pattern();
1969 parm[0].rename.in.pattern2 = gen_pattern();
1970 parm[0].rename.in.attrib = gen_attrib();
1971
1972 GEN_COPY_PARM;
1973 GEN_CALL_SMB(smb_raw_rename(tree, &parm[i]));
1974
1975 return true;
1976 }
1977
1978 /*
1979 generate ntrename operations
1980 */
1981 static bool handler_smb_ntrename(int instance)
1982 {
1983 union smb_rename parm[NSERVERS];
1984 NTSTATUS status[NSERVERS];
1985
1986 parm[0].generic.level = RAW_RENAME_NTRENAME;
1987 parm[0].ntrename.in.old_name = gen_fname();
1988 parm[0].ntrename.in.new_name = gen_fname();
1989 parm[0].ntrename.in.attrib = gen_attrib();
1990 parm[0].ntrename.in.cluster_size = gen_bits_mask2(0, 0xFFFFFFF);
1991 parm[0].ntrename.in.flags = gen_rename_flags();
1992
1993 GEN_COPY_PARM;
1994 GEN_CALL_SMB(smb_raw_rename(tree, &parm[i]));
1995
1996 return true;
1997 }
1998
1999
2000 /*
2001 generate seek operations
2002 */
2003 static bool handler_smb_seek(int instance)
2004 {
2005 union smb_seek parm[NSERVERS];
2006 NTSTATUS status[NSERVERS];
2007
2008 parm[0].lseek.in.file.fnum = gen_fnum(instance);
2009 parm[0].lseek.in.mode = gen_bits_mask2(0x3, 0xFFFF);
2010 parm[0].lseek.in.offset = gen_offset();
2011
2012 GEN_COPY_PARM;
2013 GEN_SET_FNUM_SMB(lseek.in.file.fnum);
2014 GEN_CALL_SMB(smb_raw_seek(tree, &parm[i]));
2015
2016 CHECK_EQUAL(lseek.out.offset);
2017
2018 return true;
2019 }
2020
2021
2022 /*
2023 generate readx operations
2024 */
2025 static bool handler_smb_readx(int instance)
2026 {
2027 union smb_read parm[NSERVERS];
2028 NTSTATUS status[NSERVERS];
2029
2030 parm[0].readx.level = RAW_READ_READX;
2031 parm[0].readx.in.file.fnum = gen_fnum(instance);
2032 parm[0].readx.in.offset = gen_offset();
2033 parm[0].readx.in.mincnt = gen_io_count();
2034 parm[0].readx.in.maxcnt = gen_io_count();
2035 parm[0].readx.in.remaining = gen_io_count();
2036 parm[0].readx.in.read_for_execute = gen_bool();
2037 parm[0].readx.out.data = talloc_array(current_op.mem_ctx, uint8_t,
2038 MAX(parm[0].readx.in.mincnt, parm[0].readx.in.maxcnt));
2039
2040 GEN_COPY_PARM;
2041 GEN_SET_FNUM_SMB(readx.in.file.fnum);
2042 GEN_CALL_SMB(smb_raw_read(tree, &parm[i]));
2043
2044 CHECK_EQUAL(readx.out.remaining);
2045 CHECK_EQUAL(readx.out.compaction_mode);
2046 CHECK_EQUAL(readx.out.nread);
2047
2048 return true;
2049 }
2050
2051 /*
2052 generate writex operations
2053 */
2054 static bool handler_smb_writex(int instance)
2055 {
2056 union smb_write parm[NSERVERS];
2057 NTSTATUS status[NSERVERS];
2058
2059 parm[0].writex.level = RAW_WRITE_WRITEX;
2060 parm[0].writex.in.file.fnum = gen_fnum(instance);
2061 parm[0].writex.in.offset = gen_offset();
2062 parm[0].writex.in.wmode = gen_bits_mask(0xFFFF);
2063 parm[0].writex.in.remaining = gen_io_count();
2064 parm[0].writex.in.count = gen_io_count();
2065 parm[0].writex.in.data = talloc_zero_array(current_op.mem_ctx, uint8_t, parm[0].writex.in.count);
2066
2067 GEN_COPY_PARM;
2068 GEN_SET_FNUM_SMB(writex.in.file.fnum);
2069 GEN_CALL_SMB(smb_raw_write(tree, &parm[i]));
2070
2071 CHECK_EQUAL(writex.out.nwritten);
2072 CHECK_EQUAL(writex.out.remaining);
2073
2074 return true;
2075 }
2076
2077 /*
2078 generate lockingx operations
2079 */
2080 static bool handler_smb_lockingx(int instance)
2081 {
2082 union smb_lock parm[NSERVERS];
2083 NTSTATUS status[NSERVERS];
2084 int n, nlocks;
2085
2086 parm[0].lockx.level = RAW_LOCK_LOCKX;
2087 parm[0].lockx.in.file.fnum = gen_fnum(instance);
2088 parm[0].lockx.in.mode = gen_lock_mode();
2089 parm[0].lockx.in.timeout = gen_timeout();
2090 do {
2091 /* make sure we don't accidentially generate an oplock
2092 break ack - otherwise the server can just block forever */
2093 parm[0].lockx.in.ulock_cnt = gen_lock_count();
2094 parm[0].lockx.in.lock_cnt = gen_lock_count();
2095 nlocks = parm[0].lockx.in.ulock_cnt + parm[0].lockx.in.lock_cnt;
2096 } while (nlocks == 0);
2097
2098 if (nlocks > 0) {
2099 parm[0].lockx.in.locks = talloc_array(current_op.mem_ctx,
2100 struct smb_lock_entry,
2101 nlocks);
2102 for (n=0;n<nlocks;n++) {
2103 parm[0].lockx.in.locks[n].pid = gen_pid();
2104 parm[0].lockx.in.locks[n].offset = gen_offset();
2105 parm[0].lockx.in.locks[n].count = gen_io_count();
2106 }
2107 }
2108
2109 GEN_COPY_PARM;
2110 GEN_SET_FNUM_SMB(lockx.in.file.fnum);
2111 GEN_CALL_SMB(smb_raw_lock(tree, &parm[i]));
2112
2113 return true;
2114 }
2115
2116 #if 0
2117 /*
2118 generate a fileinfo query structure
2119 */
2120 static void gen_setfileinfo(int instance, union smb_setfileinfo *info)
2121 {
2122 int i;
2123 #undef LVL
2124 #define LVL(v) {RAW_SFILEINFO_ ## v, "RAW_SFILEINFO_" #v}
2125 struct {
2126 enum smb_setfileinfo_level level;
2127 const char *name;
2128 } levels[] = {
2129 #if 0
2130 /* disabled until win2003 can handle them ... */
2131 LVL(EA_SET), LVL(BASIC_INFO), LVL(DISPOSITION_INFO),
2132 LVL(STANDARD), LVL(ALLOCATION_INFO), LVL(END_OF_FILE_INFO),
2133 #endif
2134 LVL(SETATTR), LVL(SETATTRE), LVL(BASIC_INFORMATION),
2135 LVL(RENAME_INFORMATION), LVL(DISPOSITION_INFORMATION),
2136 LVL(POSITION_INFORMATION), LVL(MODE_INFORMATION),
2137 LVL(ALLOCATION_INFORMATION), LVL(END_OF_FILE_INFORMATION),
2138 LVL(1023), LVL(1025), LVL(1029), LVL(1032), LVL(1039), LVL(1040)
2139 };
2140 do {
2141 i = gen_int_range(0, ARRAY_SIZE(levels)-1);
2142 } while (ignore_pattern(levels[i].name));
2143
2144 info->generic.level = levels[i].level;
2145
2146 switch (info->generic.level) {
2147 case RAW_SFILEINFO_SETATTR:
2148 info->setattr.in.attrib = gen_attrib();
2149 info->setattr.in.write_time = gen_timet();
2150 break;
2151 case RAW_SFILEINFO_SETATTRE:
2152 info->setattre.in.create_time = gen_timet();
2153 info->setattre.in.access_time = gen_timet();
2154 info->setattre.in.write_time = gen_timet();
2155 break;
2156 case RAW_SFILEINFO_STANDARD:
2157 info->standard.in.create_time = gen_timet();
2158 info->standard.in.access_time = gen_timet();
2159 info->standard.in.write_time = gen_timet();
2160 break;
2161 case RAW_SFILEINFO_EA_SET: {
2162 static struct ea_struct ea;
2163 info->ea_set.in.num_eas = 1;
2164 info->ea_set.in.eas = &ea;
2165 info->ea_set.in.eas[0] = gen_ea_struct();
2166 }
2167 break;
2168 case RAW_SFILEINFO_BASIC_INFO:
2169 case RAW_SFILEINFO_BASIC_INFORMATION:
2170 info->basic_info.in.create_time = gen_nttime();
2171 info->basic_info.in.access_time = gen_nttime();
2172 info->basic_info.in.write_time = gen_nttime();
2173 info->basic_info.in.change_time = gen_nttime();
2174 info->basic_info.in.attrib = gen_attrib();
2175 break;
2176 case RAW_SFILEINFO_DISPOSITION_INFO:
2177 case RAW_SFILEINFO_DISPOSITION_INFORMATION:
2178 info->disposition_info.in.delete_on_close = gen_bool();
2179 break;
2180 case RAW_SFILEINFO_ALLOCATION_INFO:
2181 case RAW_SFILEINFO_ALLOCATION_INFORMATION:
2182 info->allocation_info.in.alloc_size = gen_alloc_size();
2183 break;
2184 case RAW_SFILEINFO_END_OF_FILE_INFO:
2185 case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
2186 info->end_of_file_info.in.size = gen_offset();
2187 break;
2188 case RAW_SFILEINFO_RENAME_INFORMATION:
2189 case RAW_SFILEINFO_RENAME_INFORMATION_SMB2:
2190 info->rename_information.in.overwrite = gen_bool();
2191 info->rename_information.in.root_fid = gen_root_fid(instance);
2192 info->rename_information.in.new_name = gen_fname_open(instance);
2193 break;
2194 case RAW_SFILEINFO_POSITION_INFORMATION:
2195 info->position_information.in.position = gen_offset();
2196 break;
2197 case RAW_SFILEINFO_MODE_INFORMATION:
2198 info->mode_information.in.mode = gen_bits_mask(0xFFFFFFFF);
2199 break;
2200 case RAW_SFILEINFO_FULL_EA_INFORMATION:
2201 info->full_ea_information.in.eas = gen_ea_list();
2202 break;
2203 case RAW_SFILEINFO_GENERIC:
2204 case RAW_SFILEINFO_SEC_DESC:
2205 case RAW_SFILEINFO_UNIX_BASIC:
2206 case RAW_SFILEINFO_UNIX_LINK:
2207 case RAW_SFILEINFO_UNIX_HLINK:
2208 case RAW_SFILEINFO_1023:
2209 case RAW_SFILEINFO_1025:
2210 case RAW_SFILEINFO_1029:
2211 case RAW_SFILEINFO_1032:
2212 case RAW_SFILEINFO_1039:
2213 case RAW_SFILEINFO_1040:
2214 case RAW_SFILEINFO_UNIX_INFO2:
2215 /* Untested */
2216 break;
2217 }
2218 }
2219 #endif
2220
2221 /*
2222 generate a fileinfo query structure
2223 */
2224 static void gen_setfileinfo(int instance, union smb_setfileinfo *info)
2225 {
2226 int i;
2227 #undef LVL
2228 #define LVL(v) {RAW_SFILEINFO_ ## v, "RAW_SFILEINFO_" #v}
2229 struct levels {
2230 enum smb_setfileinfo_level level;
2231 const char *name;
2232 };
2233 struct levels smb_levels[] = {
2234 LVL(EA_SET), LVL(BASIC_INFO), LVL(DISPOSITION_INFO),
2235 LVL(STANDARD), LVL(ALLOCATION_INFO), LVL(END_OF_FILE_INFO),
2236 LVL(SETATTR), LVL(SETATTRE), LVL(BASIC_INFORMATION),
2237 LVL(RENAME_INFORMATION), LVL(DISPOSITION_INFORMATION),
2238 LVL(POSITION_INFORMATION), LVL(FULL_EA_INFORMATION), LVL(MODE_INFORMATION),
2239 LVL(ALLOCATION_INFORMATION), LVL(END_OF_FILE_INFORMATION),
2240 LVL(PIPE_INFORMATION), LVL(VALID_DATA_INFORMATION), LVL(SHORT_NAME_INFORMATION),
2241 LVL(1025), LVL(1027), LVL(1029), LVL(1030), LVL(1031), LVL(1032), LVL(1036),
2242 LVL(1041), LVL(1042), LVL(1043), LVL(1044),
2243 };
2244 struct levels smb2_levels[] = {
2245 LVL(BASIC_INFORMATION),
2246 LVL(RENAME_INFORMATION), LVL(DISPOSITION_INFORMATION),
2247 LVL(POSITION_INFORMATION), LVL(FULL_EA_INFORMATION), LVL(MODE_INFORMATION),
2248 LVL(ALLOCATION_INFORMATION), LVL(END_OF_FILE_INFORMATION),
2249 LVL(PIPE_INFORMATION), LVL(VALID_DATA_INFORMATION), LVL(SHORT_NAME_INFORMATION),
2250 LVL(1025), LVL(1027), LVL(1029), LVL(1030), LVL(1031), LVL(1032), LVL(1036),
2251 LVL(1041), LVL(1042), LVL(1043), LVL(1044),
2252 };
2253 struct levels *levels = options.smb2?smb2_levels:smb_levels;
2254 uint32_t num_levels = options.smb2?ARRAY_SIZE(smb2_levels):ARRAY_SIZE(smb_levels);
2255
2256 do {
2257 i = gen_int_range(0, num_levels-1);
2258 } while (ignore_pattern(levels[i].name));
2259
2260 ZERO_STRUCTP(info);
2261 info->generic.level = levels[i].level;
2262
2263 switch (info->generic.level) {
2264 case RAW_SFILEINFO_SETATTR:
2265 info->setattr.in.attrib = gen_attrib();
2266 info->setattr.in.write_time = gen_timet();
2267 break;
2268 case RAW_SFILEINFO_SETATTRE:
2269 info->setattre.in.create_time = gen_timet();
2270 info->setattre.in.access_time = gen_timet();
2271 info->setattre.in.write_time = gen_timet();
2272 break;
2273 case RAW_SFILEINFO_STANDARD:
2274 info->standard.in.create_time = gen_timet();
2275 info->standard.in.access_time = gen_timet();
2276 info->standard.in.write_time = gen_timet();
2277 break;
2278 case RAW_SFILEINFO_EA_SET: {
2279 static struct ea_struct ea;
2280 info->ea_set.in.num_eas = 1;
2281 info->ea_set.in.eas = &ea;
2282 info->ea_set.in.eas[0] = gen_ea_struct();
2283 break;
2284 }
2285 case RAW_SFILEINFO_BASIC_INFO:
2286 case RAW_SFILEINFO_BASIC_INFORMATION:
2287 info->basic_info.in.create_time = gen_nttime();
2288 info->basic_info.in.access_time = gen_nttime();
2289 info->basic_info.in.write_time = gen_nttime();
2290 info->basic_info.in.change_time = gen_nttime();
2291 info->basic_info.in.attrib = gen_attrib();
2292 break;
2293 case RAW_SFILEINFO_DISPOSITION_INFO:
2294 case RAW_SFILEINFO_DISPOSITION_INFORMATION:
2295 info->disposition_info.in.delete_on_close = gen_bool();
2296 break;
2297 case RAW_SFILEINFO_ALLOCATION_INFO:
2298 case RAW_SFILEINFO_ALLOCATION_INFORMATION:
2299 info->allocation_info.in.alloc_size = gen_alloc_size();
2300 break;
2301 case RAW_SFILEINFO_END_OF_FILE_INFO:
2302 case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
2303 info->end_of_file_info.in.size = gen_offset();
2304 break;
2305 case RAW_SFILEINFO_RENAME_INFORMATION:
2306 case RAW_SFILEINFO_RENAME_INFORMATION_SMB2:
2307 info->rename_information.in.overwrite = gen_bool();
2308 info->rename_information.in.root_fid = gen_root_fid(instance);
2309 info->rename_information.in.new_name = gen_fname_open(instance);
2310 break;
2311 case RAW_SFILEINFO_POSITION_INFORMATION:
2312 info->position_information.in.position = gen_offset();
2313 break;
2314 case RAW_SFILEINFO_MODE_INFORMATION:
2315 info->mode_information.in.mode = gen_bits_mask(0xFFFFFFFF);
2316 break;
2317 case RAW_SFILEINFO_FULL_EA_INFORMATION:
2318 info->full_ea_information.in.eas = gen_ea_list();
2319 break;
2320
2321 case RAW_SFILEINFO_GENERIC:
2322 case RAW_SFILEINFO_SEC_DESC:
2323 case RAW_SFILEINFO_1025:
2324 case RAW_SFILEINFO_1029:
2325 case RAW_SFILEINFO_1032:
2326 case RAW_SFILEINFO_UNIX_BASIC:
2327 case RAW_SFILEINFO_UNIX_INFO2:
2328 case RAW_SFILEINFO_UNIX_LINK:
2329 case RAW_SFILEINFO_UNIX_HLINK:
2330 case RAW_SFILEINFO_LINK_INFORMATION:
2331 case RAW_SFILEINFO_PIPE_INFORMATION:
2332 case RAW_SFILEINFO_VALID_DATA_INFORMATION:
2333 case RAW_SFILEINFO_SHORT_NAME_INFORMATION:
2334 case RAW_SFILEINFO_1027:
2335 case RAW_SFILEINFO_1030:
2336 case RAW_SFILEINFO_1031:
2337 case RAW_SFILEINFO_1036:
2338 case RAW_SFILEINFO_1041:
2339 case RAW_SFILEINFO_1042:
2340 case RAW_SFILEINFO_1043:
2341 case RAW_SFILEINFO_1044:
2342 /* Untested */
2343 break;
2344 }
2345 }
2346
2347
2348
2349 /*
2350 generate a fileinfo query structure
2351 */
2352 static void gen_fileinfo_smb(int instance, union smb_fileinfo *info)
2353 {
2354 int i;
2355 #undef LVL
2356 #define LVL(v) {RAW_FILEINFO_ ## v, "RAW_FILEINFO_" #v}
2357 struct {
2358 enum smb_fileinfo_level level;
2359 const char *name;
2360 } levels[] = {
2361 LVL(GETATTR), LVL(GETATTRE), LVL(STANDARD),
2362 LVL(EA_SIZE), LVL(ALL_EAS), LVL(IS_NAME_VALID),
2363 LVL(BASIC_INFO), LVL(STANDARD_INFO), LVL(EA_INFO),
2364 LVL(NAME_INFO), LVL(ALL_INFO), LVL(ALT_NAME_INFO),
2365 LVL(STREAM_INFO), LVL(COMPRESSION_INFO), LVL(BASIC_INFORMATION),
2366 LVL(STANDARD_INFORMATION), LVL(INTERNAL_INFORMATION), LVL(EA_INFORMATION),
2367 LVL(ACCESS_INFORMATION), LVL(NAME_INFORMATION), LVL(POSITION_INFORMATION),
2368 LVL(MODE_INFORMATION), LVL(ALIGNMENT_INFORMATION), LVL(ALL_INFORMATION),
2369 LVL(ALT_NAME_INFORMATION), LVL(STREAM_INFORMATION), LVL(COMPRESSION_INFORMATION),
2370 LVL(NETWORK_OPEN_INFORMATION), LVL(ATTRIBUTE_TAG_INFORMATION)
2371 };
2372 do {
2373 i = gen_int_range(0, ARRAY_SIZE(levels)-1);
2374 } while (ignore_pattern(levels[i].name));
2375
2376 info->generic.level = levels[i].level;
2377 }
2378
2379 /*
2380 generate qpathinfo operations
2381 */
2382 static bool handler_smb_qpathinfo(int instance)
2383 {
2384 union smb_fileinfo parm[NSERVERS];
2385 NTSTATUS status[NSERVERS];
2386
2387 parm[0].generic.in.file.path = gen_fname_open(instance);
2388
2389 gen_fileinfo_smb(instance, &parm[0]);
2390
2391 GEN_COPY_PARM;
2392 GEN_CALL_SMB(smb_raw_pathinfo(tree, current_op.mem_ctx, &parm[i]));
2393
2394 return cmp_fileinfo(instance, parm, status);
2395 }
2396
2397 /*
2398 generate qfileinfo operations
2399 */
2400 static bool handler_smb_qfileinfo(int instance)
2401 {
2402 union smb_fileinfo parm[NSERVERS];
2403 NTSTATUS status[NSERVERS];
2404
2405 parm[0].generic.in.file.fnum = gen_fnum(instance);
2406
2407 gen_fileinfo_smb(instance, &parm[0]);
2408
2409 GEN_COPY_PARM;
2410 GEN_SET_FNUM_SMB(generic.in.file.fnum);
2411 GEN_CALL_SMB(smb_raw_fileinfo(tree, current_op.mem_ctx, &parm[i]));
2412
2413 return cmp_fileinfo(instance, parm, status);
2414 }
2415
2416
2417 /*
2418 generate setpathinfo operations
2419 */
2420 static bool handler_smb_spathinfo(int instance)
2421 {
2422 union smb_setfileinfo parm[NSERVERS];
2423 NTSTATUS status[NSERVERS];
2424
2425 gen_setfileinfo(instance, &parm[0]);
2426 parm[0].generic.in.file.path = gen_fname_open(instance);
2427
2428 GEN_COPY_PARM;
2429
2430 /* a special case for the fid in a RENAME */
2431 if (parm[0].generic.level == RAW_SFILEINFO_RENAME_INFORMATION &&
2432 parm[0].rename_information.in.root_fid != 0) {
2433 GEN_SET_FNUM_SMB(rename_information.in.root_fid);
2434 }
2435
2436 GEN_CALL_SMB(smb_raw_setpathinfo(tree, &parm[i]));
2437
2438 return true;
2439 }
2440
2441
2442 /*
2443 generate setfileinfo operations
2444 */
2445 static bool handler_smb_sfileinfo(int instance)
2446 {
2447 union smb_setfileinfo parm[NSERVERS];
2448 NTSTATUS status[NSERVERS];
2449
2450 parm[0].generic.in.file.fnum = gen_fnum(instance);
2451
2452 gen_setfileinfo(instance, &parm[0]);
2453
2454 GEN_COPY_PARM;
2455 GEN_SET_FNUM_SMB(generic.in.file.fnum);
2456 GEN_CALL_SMB(smb_raw_setfileinfo(tree, &parm[i]));
2457
2458 return true;
2459 }
2460
2461
2462 /*
2463 this is called when a change notify reply comes in
2464 */
2465 static void async_notify_smb(struct smbcli_request *req)
2466 {
2467 union smb_notify notify;
2468 NTSTATUS status;
2469 int i, j;
2470 uint16_t tid = 0;
2471 struct smbcli_transport *transport = req->transport;
2472
2473 if (req->tree) {
2474 tid = req->tree->tid;
2475 }
2476
2477 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
2478 status = smb_raw_changenotify_recv(req, current_op.mem_ctx, &notify);
2479 if (NT_STATUS_IS_OK(status) && notify.nttrans.out.num_changes > 0) {
2480 printf("notify tid=%d num_changes=%d action=%d name=%s\n",
2481 tid,
2482 notify.nttrans.out.num_changes,
2483 notify.nttrans.out.changes[0].action,
2484 notify.nttrans.out.changes[0].name.s);
2485 }
2486
2487 for (i=0;i<NSERVERS;i++) {
2488 for (j=0;j<NINSTANCES;j++) {
2489 if (transport == servers[i].smb_tree[j]->session->transport &&
2490 tid == servers[i].smb_tree[j]->tid) {
2491 notifies[i][j].notify_count++;
2492 notifies[i][j].status = status;
2493 notifies[i][j].notify = notify;
2494 }
2495 }
2496 }
2497 }
2498
2499 /*
2500 generate change notify operations
2501 */
2502 static bool handler_smb_notify(int instance)
2503 {
2504 union smb_notify parm[NSERVERS];
2505 int n;
2506
2507 ZERO_STRUCT(parm[0]);
2508 parm[0].nttrans.level = RAW_NOTIFY_NTTRANS;
2509 parm[0].nttrans.in.buffer_size = gen_io_count();
2510 parm[0].nttrans.in.completion_filter = gen_bits_mask(0xFF);
2511 parm[0].nttrans.in.file.fnum = gen_fnum(instance);
2512 parm[0].nttrans.in.recursive = gen_bool();
2513
2514 GEN_COPY_PARM;
2515 GEN_SET_FNUM_SMB(nttrans.in.file.fnum);
2516
2517 for (n=0;n<NSERVERS;n++) {
2518 struct smbcli_request *req;
2519 req = smb_raw_changenotify_send(servers[n].smb_tree[instance], &parm[n]);
2520 req->async.fn = async_notify_smb;
2521 }
2522
2523 return true;
2524 }
2525
2526
2527 /*
2528 generate ntcreatex operations
2529 */
2530 static bool handler_smb2_create(int instance)
2531 {
2532 struct smb2_create parm[NSERVERS];
2533 NTSTATUS status[NSERVERS];
2534
2535 ZERO_STRUCT(parm[0]);
2536 parm[0].in.security_flags = gen_bits_levels(3, 90, 0x0, 70, 0x3, 100, 0xFF);
2537 parm[0].in.oplock_level = gen_bits_levels(3, 90, 0x0, 70, 0x9, 100, 0xFF);
2538 parm[0].in.impersonation_level = gen_bits_levels(3, 90, 0x0, 70, 0x3, 100, 0xFFFFFFFF);
2539 parm[0].in.create_flags = gen_reserved64();
2540 parm[0].in.reserved = gen_reserved64();
2541 parm[0].in.desired_access = gen_access_mask();
2542 parm[0].in.file_attributes = gen_attrib();
2543 parm[0].in.share_access = gen_bits_mask2(0x7, 0xFFFFFFFF);
2544 parm[0].in.create_disposition = gen_open_disp();
2545 parm[0].in.create_options = gen_create_options();
2546 parm[0].in.fname = gen_fname_open(instance);
2547 parm[0].in.eas = gen_ea_list();
2548 parm[0].in.alloc_size = gen_alloc_size();
2549 parm[0].in.durable_open = gen_bool();
2550 parm[0].in.query_maximal_access = gen_bool();
2551 parm[0].in.timewarp = gen_timewarp();
2552 parm[0].in.query_on_disk_id = gen_bool();
2553 parm[0].in.sec_desc = gen_sec_desc();
2554
2555 if (!options.use_oplocks) {
2556 /* mask out oplocks */
2557 parm[0].in.oplock_level = 0;
2558 }
2559
2560 if (options.valid) {
2561 parm[0].in.security_flags &= 3;
2562 parm[0].in.oplock_level &= 9;
2563 parm[0].in.impersonation_level &= 3;
2564 }
2565
2566 GEN_COPY_PARM;
2567 GEN_CALL_SMB2(smb2_create(tree, current_op.mem_ctx, &parm[i]));
2568
2569 CHECK_EQUAL(out.oplock_level);
2570 CHECK_EQUAL(out.reserved);
2571 CHECK_EQUAL(out.create_action);
2572 CHECK_NTTIMES_EQUAL(out.create_time);
2573 CHECK_NTTIMES_EQUAL(out.access_time);
2574 CHECK_NTTIMES_EQUAL(out.write_time);
2575 CHECK_NTTIMES_EQUAL(out.change_time);
2576 CHECK_EQUAL(out.alloc_size);
2577 CHECK_EQUAL(out.size);
2578 CHECK_ATTRIB(out.file_attr);
2579 CHECK_EQUAL(out.reserved2);
2580 CHECK_EQUAL(out.maximal_access);
2581
2582 /* ntcreatex creates a new file handle */
2583 ADD_HANDLE_SMB2(parm[0].in.fname, out.file.handle);
2584
2585 return true;
2586 }
2587
2588 /*
2589 generate close operations
2590 */
2591 static bool handler_smb2_close(int instance)
2592 {
2593 struct smb2_close parm[NSERVERS];
2594 NTSTATUS status[NSERVERS];
2595
2596 ZERO_STRUCT(parm[0]);
2597 parm[0].in.file.handle.data[0] = gen_fnum_close(instance);
2598 parm[0].in.flags = gen_bits_mask2(0x1, 0xFFFF);
2599
2600 GEN_COPY_PARM;
2601 GEN_SET_FNUM_SMB2(in.file.handle);
2602 GEN_CALL_SMB2(smb2_close(tree, &parm[i]));
2603
2604 CHECK_EQUAL(out.flags);
2605 CHECK_EQUAL(out._pad);
2606 CHECK_NTTIMES_EQUAL(out.create_time);
2607 CHECK_NTTIMES_EQUAL(out.access_time);
2608 CHECK_NTTIMES_EQUAL(out.write_time);
2609 CHECK_NTTIMES_EQUAL(out.change_time);
2610 CHECK_EQUAL(out.alloc_size);
2611 CHECK_EQUAL(out.size);
2612 CHECK_ATTRIB(out.file_attr);
2613
2614 REMOVE_HANDLE_SMB2(in.file.handle);
2615
2616 return true;
2617 }
2618
2619 /*
2620 generate read operations
2621 */
2622 static bool handler_smb2_read(int instance)
2623 {
2624 struct smb2_read parm[NSERVERS];
2625 NTSTATUS status[NSERVERS];
2626
2627 parm[0].in.file.handle.data[0] = gen_fnum(instance);
2628 parm[0].in.reserved = gen_reserved8();
2629 parm[0].in.length = gen_io_count();
2630 parm[0].in.offset = gen_offset();
2631 parm[0].in.min_count = gen_io_count();
2632 parm[0].in.channel = gen_bits_mask2(0x0, 0xFFFFFFFF);
2633 parm[0].in.remaining = gen_bits_mask2(0x0, 0xFFFFFFFF);
2634 parm[0].in.channel_offset = gen_bits_mask2(0x0, 0xFFFF);
2635 parm[0].in.channel_length = gen_bits_mask2(0x0, 0xFFFF);
2636
2637 GEN_COPY_PARM;
2638 GEN_SET_FNUM_SMB2(in.file.handle);
2639 GEN_CALL_SMB2(smb2_read(tree, current_op.mem_ctx, &parm[i]));
2640
2641 CHECK_EQUAL(out.remaining);
2642 CHECK_EQUAL(out.reserved);
2643 CHECK_EQUAL(out.data.length);
2644
2645 return true;
2646 }
2647
2648 /*
2649 generate write operations
2650 */
2651 static bool handler_smb2_write(int instance)
2652 {
2653 struct smb2_write parm[NSERVERS];
2654 NTSTATUS status[NSERVERS];
2655
2656 parm[0].in.file.handle.data[0] = gen_fnum(instance);
2657 parm[0].in.offset = gen_offset();
2658 parm[0].in.unknown1 = gen_bits_mask2(0, 0xFFFFFFFF);
2659 parm[0].in.unknown2 = gen_bits_mask2(0, 0xFFFFFFFF);
2660 parm[0].in.data = data_blob_talloc(current_op.mem_ctx, NULL,
2661 gen_io_count());
2662
2663 GEN_COPY_PARM;
2664 GEN_SET_FNUM_SMB2(in.file.handle);
2665 GEN_CALL_SMB2(smb2_write(tree, &parm[i]));
2666
2667 CHECK_EQUAL(out._pad);
2668 CHECK_EQUAL(out.nwritten);
2669 CHECK_EQUAL(out.unknown1);
2670
2671 return true;
2672 }
2673
2674 /*
2675 generate lockingx operations
2676 */
2677 static bool handler_smb2_lock(int instance)
2678 {
2679 struct smb2_lock parm[NSERVERS];
2680 NTSTATUS status[NSERVERS];
2681 int n;
2682
2683 parm[0].level = RAW_LOCK_LOCKX;
2684 parm[0].in.file.handle.data[0] = gen_fnum(instance);
2685 parm[0].in.lock_count = gen_lock_count();
2686 parm[0].in.lock_sequence = gen_reserved32();
2687
2688 parm[0].in.locks = talloc_array(current_op.mem_ctx,
2689 struct smb2_lock_element,
2690 parm[0].in.lock_count);
2691 for (n=0;n<parm[0].in.lock_count;n++) {
2692 parm[0].in.locks[n].offset = gen_offset();
2693 parm[0].in.locks[n].length = gen_io_count();
2694 /* don't yet cope with async replies */
2695 parm[0].in.locks[n].flags = gen_lock_flags_smb2() |
2696 SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
2697 parm[0].in.locks[n].reserved = gen_bits_mask2(0x0, 0xFFFFFFFF);
2698 }
2699
2700 GEN_COPY_PARM;
2701 GEN_SET_FNUM_SMB2(in.file.handle);
2702 GEN_CALL_SMB2(smb2_lock(tree, &parm[i]));
2703
2704 return true;
2705 }
2706
2707 /*
2708 generate flush operations
2709 */
2710 static bool handler_smb2_flush(int instance)
2711 {
2712 struct smb2_flush parm[NSERVERS];
2713 NTSTATUS status[NSERVERS];
2714
2715 ZERO_STRUCT(parm[0]);
2716 parm[0].in.file.handle.data[0] = gen_fnum(instance);
2717 parm[0].in.reserved1 = gen_reserved16();
2718 parm[0].in.reserved2 = gen_reserved32();
2719
2720 GEN_COPY_PARM;
2721 GEN_SET_FNUM_SMB2(in.file.handle);
2722 GEN_CALL_SMB2(smb2_flush(tree, &parm[i]));
2723
2724 CHECK_EQUAL(out.reserved);
2725
2726 return true;
2727 }
2728
2729 /*
2730 generate echo operations
2731 */
2732 static bool handler_smb2_echo(int instance)
2733 {
2734 NTSTATUS status[NSERVERS];
2735
2736 GEN_CALL_SMB2(smb2_keepalive(tree->session->transport));
2737
2738 return true;
2739 }
2740
2741
2742
2743 /*
2744 generate a fileinfo query structure
2745 */
2746 static void gen_fileinfo_smb2(int instance, union smb_fileinfo *info)
2747 {
2748 int i;
2749 #define LVL(v) {RAW_FILEINFO_ ## v, "RAW_FILEINFO_" #v}
2750 struct {
2751 enum smb_fileinfo_level level;
2752 const char *name;
2753 } levels[] = {
2754 LVL(BASIC_INFORMATION),
2755 LVL(STANDARD_INFORMATION), LVL(INTERNAL_INFORMATION), LVL(EA_INFORMATION),
2756 LVL(ACCESS_INFORMATION), LVL(NAME_INFORMATION), LVL(POSITION_INFORMATION),
2757 LVL(MODE_INFORMATION), LVL(ALIGNMENT_INFORMATION), LVL(SMB2_ALL_INFORMATION),
2758 LVL(ALT_NAME_INFORMATION), LVL(STREAM_INFORMATION), LVL(COMPRESSION_INFORMATION),
2759 LVL(NETWORK_OPEN_INFORMATION), LVL(ATTRIBUTE_TAG_INFORMATION),
2760 LVL(SMB2_ALL_EAS), LVL(SMB2_ALL_INFORMATION), LVL(SEC_DESC),
2761 };
2762 do {
2763 i = gen_int_range(0, ARRAY_SIZE(levels)-1);
2764 } while (ignore_pattern(levels[i].name));
2765
2766 info->generic.level = levels[i].level;
2767 }
2768
2769 /*
2770 generate qfileinfo operations
2771 */
2772 static bool handler_smb2_qfileinfo(int instance)
2773 {
2774 union smb_fileinfo parm[NSERVERS];
2775 NTSTATUS status[NSERVERS];
2776
2777 parm[0].generic.in.file.handle.data[0] = gen_fnum(instance);
2778
2779 gen_fileinfo_smb2(instance, &parm[0]);
2780
2781 GEN_COPY_PARM;
2782 GEN_SET_FNUM_SMB2(generic.in.file.handle);
2783 GEN_CALL_SMB2(smb2_getinfo_file(tree, current_op.mem_ctx, &parm[i]));
2784
2785 return cmp_fileinfo(instance, parm, status);
2786 }
2787
2788
2789 /*
2790 generate setfileinfo operations
2791 */
2792 static bool handler_smb2_sfileinfo(int instance)
2793 {
2794 union smb_setfileinfo parm[NSERVERS];
2795 NTSTATUS status[NSERVERS];
2796
2797 gen_setfileinfo(instance, &parm[0]);
2798 parm[0].generic.in.file.fnum = gen_fnum(instance);
2799
2800 GEN_COPY_PARM;
2801 GEN_SET_FNUM_SMB2(generic.in.file.handle);
2802 GEN_CALL_SMB2(smb2_setinfo_file(tree, &parm[i]));
2803
2804 return true;
2805 }
2806
2807 /*
2808 wipe any relevant files
2809 */
2810 static void wipe_files(void)
2811 {
2812 int i;
2813 NTSTATUS status;
2814
2815 if (options.skip_cleanup) {
2816 return;
2817 }
2818
2819 for (i=0;i<NSERVERS;i++) {
2820 int n;
2821 if (options.smb2) {
2822 n = smb2_deltree(servers[i].smb2_tree[0], "gentest");
2823 } else {
2824 n = smbcli_deltree(servers[i].smb_tree[0], "gentest");
2825 }
2826 if (n == -1) {
2827 printf("Failed to wipe tree on server %d\n", i);
2828 exit(1);
2829 }
2830 if (options.smb2) {
2831 status = smb2_util_mkdir(servers[i].smb2_tree[0], "gentest");
2832 } else {
2833 status = smbcli_mkdir(servers[i].smb_tree[0], "gentest");
2834 }
2835 if (NT_STATUS_IS_ERR(status)) {
2836 printf("Failed to create gentest on server %d - %s\n", i, nt_errstr(status));
2837 exit(1);
2838 }
2839 if (n > 0) {
2840 printf("Deleted %d files on server %d\n", n, i);
2841 }
2842 }
2843 }
2844
2845 /*
2846 dump the current seeds - useful for continuing a backtrack
2847 */
2848 static void dump_seeds(void)
2849 {
2850 int i;
2851 FILE *f;
2852
2853 if (!options.seeds_file) {
2854 return;
2855 }
2856 f = fopen("seeds.tmp", "w");
2857 if (!f) return;
2858
2859 for (i=0;i<options.numops;i++) {
2860 fprintf(f, "%u\n", op_parms[i].seed);
2861 }
2862 fclose(f);
2863 rename("seeds.tmp", options.seeds_file);
2864 }
2865
2866
2867
2868 /*
2869 the list of top-level operations that we will generate
2870 */
2871 static struct {
2872 const char *name;
2873 bool (*handler)(int instance);
2874 bool smb2;
2875 int count, success_count;
2876 } gen_ops[] = {
2877 {"CREATE", handler_smb2_create, true},
2878 {"CLOSE", handler_smb2_close, true},
2879 {"READ", handler_smb2_read, true},
2880 {"WRITE", handler_smb2_write, true},
2881 {"LOCK", handler_smb2_lock, true},
2882 {"FLUSH", handler_smb2_flush, true},
2883 {"ECHO", handler_smb2_echo, true},
2884 {"QFILEINFO", handler_smb2_qfileinfo, true},
2885 {"SFILEINFO", handler_smb2_sfileinfo, true},
2886
2887 {"OPEN", handler_smb_open, false},
2888 {"OPENX", handler_smb_openx, false},
2889 {"NTCREATEX", handler_smb_ntcreatex, false},
2890 {"CLOSE", handler_smb_close, false},
2891 {"UNLINK", handler_smb_unlink, false},
2892 {"MKDIR", handler_smb_mkdir, false},
2893 {"RMDIR", handler_smb_rmdir, false},
2894 {"RENAME", handler_smb_rename, false},
2895 {"NTRENAME", handler_smb_ntrename, false},
2896 {"READX", handler_smb_readx, false},
2897 {"WRITEX", handler_smb_writex, false},
2898 {"CHKPATH", handler_smb_chkpath, false},
2899 {"SEEK", handler_smb_seek, false},
2900 {"LOCKINGX", handler_smb_lockingx, false},
2901 {"QPATHINFO", handler_smb_qpathinfo, false},
2902 {"QFILEINFO", handler_smb_qfileinfo, false},
2903 {"SPATHINFO", handler_smb_spathinfo, false},
2904 {"SFILEINFO", handler_smb_sfileinfo, false},
2905 {"NOTIFY", handler_smb_notify, false},
2906 {"SEEK", handler_smb_seek, false},
2907 };
2908
2909
2910 /*
2911 run the test with the current set of op_parms parameters
2912 return the number of operations that completed successfully
2913 */
2914 static int run_test(struct tevent_context *ev, struct loadparm_context *lp_ctx)
2915 {
2916 int op, i;
2917
2918 if (!connect_servers(ev, lp_ctx)) {
2919 printf("Failed to connect to servers\n");
2920 exit(1);
2921 }
2922
2923 dump_seeds();
2924
2925 /* wipe any leftover files from old runs */
2926 wipe_files();
2927
2928 /* reset the open handles array */
2929 memset(open_handles, 0, options.max_open_handles * sizeof(open_handles[0]));
2930 num_open_handles = 0;
2931
2932 for (i=0;i<ARRAY_SIZE(gen_ops);i++) {
2933 gen_ops[i].count = 0;
2934 gen_ops[i].success_count = 0;
2935 }
2936
2937 for (op=0; op<options.numops; op++) {
2938 int instance, which_op;
2939 bool ret;
2940
2941 if (op_parms[op].disabled) continue;
2942
2943 srandom(op_parms[op].seed);
2944
2945 instance = gen_int_range(0, NINSTANCES-1);
2946
2947 /* generate a non-ignored operation */
2948 do {
2949 which_op = gen_int_range(0, ARRAY_SIZE(gen_ops)-1);
2950 } while (ignore_pattern(gen_ops[which_op].name) ||
2951 gen_ops[which_op].smb2 != options.smb2);
2952
2953 DEBUG(3,("Generating op %s on instance %d\n",
2954 gen_ops[which_op].name, instance));
2955
2956 current_op.seed = op_parms[op].seed;
2957 current_op.opnum = op;
2958 current_op.name = gen_ops[which_op].name;
2959 current_op.status = NT_STATUS_OK;
2960 talloc_free(current_op.mem_ctx);
2961 current_op.mem_ctx = talloc_named(NULL, 0, "%s", current_op.name);
2962
2963 ret = gen_ops[which_op].handler(instance);
2964
2965 gen_ops[which_op].count++;
2966 if (NT_STATUS_IS_OK(current_op.status)) {
2967 gen_ops[which_op].success_count++;
2968 }
2969
2970 if (!ret) {
2971 printf("Failed at operation %d - %s\n",
2972 op, gen_ops[which_op].name);
2973 return op;
2974 }
2975
2976 if (op % 100 == 0) {
2977 printf("%d\n", op);
2978 }
2979 }
2980
2981 for (i=0;i<ARRAY_SIZE(gen_ops);i++) {
2982 printf("Op %-10s got %d/%d success\n",
2983 gen_ops[i].name,
2984 gen_ops[i].success_count,
2985 gen_ops[i].count);
2986 }
2987
2988 return op;
2989 }
2990
2991 /*
2992 perform a backtracking analysis of the minimal set of operations
2993 to generate an error
2994 */
2995 static void backtrack_analyze(struct tevent_context *ev,
2996 struct loadparm_context *lp_ctx)
2997 {
2998 int chunk, ret;
2999 const char *mismatch = current_op.mismatch;
3000
3001 chunk = options.numops / 2;
3002
3003 do {
3004 int base;
3005 for (base=0;
3006 chunk > 0 && base+chunk < options.numops && options.numops > 1; ) {
3007 int i, max;
3008
3009 chunk = MIN(chunk, options.numops / 2);
3010
3011 /* mark this range as disabled */
3012 max = MIN(options.numops, base+chunk);
3013 for (i=base;i<max; i++) {
3014 op_parms[i].disabled = true;
3015 }
3016 printf("Testing %d ops with %d-%d disabled\n",
3017 options.numops, base, max-1);
3018 ret = run_test(ev, lp_ctx);
3019 printf("Completed %d of %d ops\n", ret, options.numops);
3020 for (i=base;i<max; i++) {
3021 op_parms[i].disabled = false;
3022 }
3023 if (ret == options.numops) {
3024 /* this chunk is needed */
3025 base += chunk;
3026 } else if (mismatch != current_op.mismatch &&
3027 strcmp(mismatch, current_op.mismatch)) {
3028 base += chunk;
3029 printf("Different error in backtracking\n");
3030 } else if (ret < base) {
3031 printf("damn - inconsistent errors! found early error\n");
3032 options.numops = ret+1;
3033 base = 0;
3034 } else {
3035 /* it failed - this chunk isn't needed for a failure */
3036 memmove(&op_parms[base], &op_parms[max],
3037 sizeof(op_parms[0]) * (options.numops - max));
3038 options.numops = (ret+1) - (max - base);
3039 }
3040 }
3041
3042 if (chunk == 2) {
3043 chunk = 1;
3044 } else {
3045 chunk *= 0.4;
3046 }
3047
3048 if (options.analyze_continuous && chunk == 0 && options.numops != 1) {
3049 chunk = 1;
3050 }
3051 } while (chunk > 0);
3052
3053 printf("Reduced to %d ops\n", options.numops);
3054 ret = run_test(ev, lp_ctx);
3055 if (ret != options.numops - 1) {
3056 printf("Inconsistent result? ret=%d numops=%d\n", ret, options.numops);
3057 }
3058 }
3059
3060 /*
3061 start the main gentest process
3062 */
3063 static bool start_gentest(struct tevent_context *ev,
3064 struct loadparm_context *lp_ctx)
3065 {
3066 int op;
3067 int ret;
3068
3069 /* allocate the open_handles array */
3070 open_handles = calloc(options.max_open_handles, sizeof(open_handles[0]));
3071
3072 srandom(options.seed);
3073 op_parms = calloc(options.numops, sizeof(op_parms[0]));
3074
3075 /* generate the seeds - after this everything is deterministic */
3076 if (options.use_preset_seeds) {
3077 int numops;
3078 char **preset = file_lines_load(options.seeds_file, &numops, 0, NULL);
3079 if (!preset) {
3080 printf("Failed to load %s - %s\n", options.seeds_file, strerror(errno));
3081 exit(1);
3082 }
3083 if (numops < options.numops) {
3084 options.numops = numops;
3085 }
3086 for (op=0;op<options.numops;op++) {
3087 if (!preset[op]) {
3088 printf("Not enough seeds in %s\n", options.seeds_file);
3089 exit(1);
3090 }
3091 op_parms[op].seed = atoi(preset[op]);
3092 }
3093 printf("Loaded %d seeds from %s\n", options.numops, options.seeds_file);
3094 } else {
3095 for (op=0; op<options.numops; op++) {
3096 op_parms[op].seed = random();
3097 }
3098 }
3099
3100 ret = run_test(ev, lp_ctx);
3101
3102 if (ret != options.numops && options.analyze) {
3103 options.numops = ret+1;
3104 backtrack_analyze(ev, lp_ctx);
3105 } else if (options.analyze_always) {
3106 backtrack_analyze(ev, lp_ctx);
3107 } else if (options.analyze_continuous) {
3108 while (run_test(ev, lp_ctx) == options.numops) ;
3109 }
3110
3111 return ret == options.numops;
3112 }
3113
3114
3115 static void usage(poptContext pc)
3116 {
3117 printf(
3118 "Usage:\n\
3119 gentest //server1/share1 //server2/share2 [options..]\n\
3120 ");
3121 poptPrintUsage(pc, stdout, 0);
3122 }
3123
3124 /**
3125 split a UNC name into server and share names
3126 */
3127 static bool split_unc_name(const char *unc, char **server, char **share)
3128 {
3129 char *p = strdup(unc);
3130 if (!p) return false;
3131 all_string_sub(p, "\\", "/", 0);
3132 if (strncmp(p, "//", 2) != 0) return false;
3133
3134 (*server) = p+2;
3135 p = strchr(*server, '/');
3136 if (!p) return false;
3137
3138 *p = 0;
3139 (*share) = p+1;
3140
3141 return true;
3142 }
3143
3144
3145
3146 /****************************************************************************
3147 main program
3148 ****************************************************************************/
3149 int main(int argc, char *argv[])
3150 {
3151 int opt;
3152 int i, username_count=0;
3153 bool ret;
3154 char *ignore_file=NULL;
3155 struct tevent_context *ev;
3156 struct loadparm_context *lp_ctx;
3157 poptContext pc;
3158 int argc_new;
3159 char **argv_new;
3160 enum {OPT_UNCLIST=1000};
3161 struct poptOption long_options[] = {
3162 POPT_AUTOHELP
3163 {"smb2", 0, POPT_ARG_NONE, &options.smb2, 0, "use SMB2 protocol", NULL},
3164 {"seed", 0, POPT_ARG_INT, &options.seed, 0, "Seed to use for randomizer", NULL},
3165 {"num-ops", 0, POPT_ARG_INT, &options.numops, 0, "num ops", NULL},
3166 {"oplocks", 0, POPT_ARG_NONE, &options.use_oplocks,0, "use oplocks", NULL},
3167 {"showall", 0, POPT_ARG_NONE, &options.showall, 0, "display all operations", NULL},
3168 {"analyse", 0, POPT_ARG_NONE, &options.analyze, 0, "do backtrack analysis", NULL},
3169 {"analysealways", 0, POPT_ARG_NONE, &options.analyze_always, 0, "analysis always", NULL},
3170 {"analysecontinuous", 0, POPT_ARG_NONE, &options.analyze_continuous, 0, "analysis continuous", NULL},
3171 {"ignore", 0, POPT_ARG_STRING, &ignore_file, 0, "ignore from file", NULL},
3172 {"preset", 0, POPT_ARG_NONE, &options.use_preset_seeds, 0, "use preset seeds", NULL},
3173 {"fast", 0, POPT_ARG_NONE, &options.fast_reconnect, 0, "use fast reconnect", NULL},
3174 {"unclist", 0, POPT_ARG_STRING, NULL, OPT_UNCLIST, "unclist", NULL},
3175 {"seedsfile", 0, POPT_ARG_STRING, &options.seeds_file, 0, "seed file", NULL},
3176 { "user", 'U', POPT_ARG_STRING, NULL, 'U', "Set the network username", "[DOMAIN/]USERNAME[%PASSWORD]" },
3177 {"maskindexing", 0, POPT_ARG_NONE, &options.mask_indexing, 0, "mask out the indexed file attrib", NULL},
3178 {"noeas", 0, POPT_ARG_NONE, &options.no_eas, 0, "don't use extended attributes", NULL},
3179 {"noacls", 0, POPT_ARG_NONE, &options.no_acls, 0, "don't use ACLs", NULL},
3180 {"skip-cleanup", 0, POPT_ARG_NONE, &options.skip_cleanup, 0, "don't delete files at start", NULL},
3181 {"valid", 0, POPT_ARG_NONE, &options.valid, 0, "generate only valid fields", NULL},
3182 POPT_COMMON_SAMBA
3183 POPT_COMMON_CONNECTION
3184 POPT_COMMON_CREDENTIALS
3185 POPT_COMMON_VERSION
3186 { NULL }
3187 };
3188
3189 memset(&bad_smb2_handle, 0xFF, sizeof(bad_smb2_handle));
3190
3191 setlinebuf(stdout);
3192 options.seed = time(NULL);
3193 options.numops = 1000;
3194 options.max_open_handles = 20;
3195 options.seeds_file = "gentest_seeds.dat";
3196
3197 pc = poptGetContext("gentest", argc, (const char **) argv, long_options,
3198 POPT_CONTEXT_KEEP_FIRST);
3199
3200 poptSetOtherOptionHelp(pc, "<unc1> <unc2>");
3201
3202 lp_ctx = cmdline_lp_ctx;
3203 servers[0].credentials = cli_credentials_init(talloc_autofree_context());
3204 servers[1].credentials = cli_credentials_init(talloc_autofree_context());
3205 cli_credentials_guess(servers[0].credentials, lp_ctx);
3206 cli_credentials_guess(servers[1].credentials, lp_ctx);
3207
3208 while((opt = poptGetNextOpt(pc)) != -1) {
3209 switch (opt) {
3210 case OPT_UNCLIST:
3211 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
3212 break;
3213 case 'U':
3214 if (username_count == 2) {
3215 usage(pc);
3216 exit(1);
3217 }
3218 cli_credentials_parse_string(servers[username_count].credentials, poptGetOptArg(pc), CRED_SPECIFIED);
3219 username_count++;
3220 break;
3221 }
3222 }
3223
3224 if (ignore_file) {
3225 options.ignore_patterns = file_lines_load(ignore_file, NULL, 0, NULL);
3226 }
3227
3228 argv_new = discard_const_p(char *, poptGetArgs(pc));
3229 argc_new = argc;
3230 for (i=0; i<argc; i++) {
3231 if (argv_new[i] == NULL) {
3232 argc_new = i;
3233 break;
3234 }
3235 }
3236
3237 if (!(argc_new >= 3)) {
3238 usage(pc);
3239 exit(1);
3240 }
3241
3242 setlinebuf(stdout);
3243
3244 setup_logging("gentest", DEBUG_STDOUT);
3245
3246 if (argc < 3 || argv[1][0] == '-') {
3247 usage(pc);
3248 exit(1);
3249 }
3250
3251 setup_logging(argv[0], DEBUG_STDOUT);
3252
3253 for (i=0;i<NSERVERS;i++) {
3254 const char *share = argv[1+i];
3255 if (!split_unc_name(share, &servers[i].server_name, &servers[i].share_name)) {
3256 printf("Invalid share name '%s'\n", share);
3257 return -1;
3258 }
3259 }
3260
3261 if (username_count == 0) {
3262 usage(pc);
3263 return -1;
3264 }
3265 if (username_count == 1) {
3266 servers[1].credentials = servers[0].credentials;
3267 }
3268
3269 printf("seed=%u\n", options.seed);
3270
3271 ev = s4_event_context_init(talloc_autofree_context());
3272
3273 gensec_init();
3274
3275 ret = start_gentest(ev, lp_ctx);
3276
3277 if (ret) {
3278 printf("gentest completed - no errors\n");
3279 } else {
3280 printf("gentest failed\n");
3281 }
3282
3283 return ret?0:-1;
3284 }