?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix all other modules to use ldb_module.h instead of ldb_private.h
[Samba.git] / source3 / torture / torture.c
blob1210a36a392714774e5ccaa1c3d0431afa42a25d
1 /*
2 Unix SMB/CIFS implementation.
3 SMB torture tester
4 Copyright (C) Andrew Tridgell 1997-1998
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21
22 extern char *optarg;
23 extern int optind;
24
25 static fstring host, workgroup, share, password, username, myname;
26 static int max_protocol = PROTOCOL_NT1;
27 static const char *sockops="TCP_NODELAY";
28 static int nprocs=1;
29 static int port_to_use=0;
30 int torture_numops=100;
31 int torture_blocksize=1024*1024;
32 static int procnum; /* records process count number when forking */
33 static struct cli_state *current_cli;
34 static fstring randomfname;
35 static bool use_oplocks;
36 static bool use_level_II_oplocks;
37 static const char *client_txt = "client_oplocks.txt";
38 static bool use_kerberos;
39 static fstring multishare_conn_fname;
40 static bool use_multishare_conn = False;
41 static bool do_encrypt;
42
43 bool torture_showall = False;
44
45 static double create_procs(bool (*fn)(int), bool *result);
46
47
48 static struct timeval tp1,tp2;
49
50
51 void start_timer(void)
52 {
53 GetTimeOfDay(&tp1);
54 }
55
56 double end_timer(void)
57 {
58 GetTimeOfDay(&tp2);
59 return((tp2.tv_sec - tp1.tv_sec) +
60 (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
61 }
62
63
64 /* return a pointer to a anonymous shared memory segment of size "size"
65 which will persist across fork() but will disappear when all processes
66 exit
67
68 The memory is not zeroed
69
70 This function uses system5 shared memory. It takes advantage of a property
71 that the memory is not destroyed if it is attached when the id is removed
72 */
73 void *shm_setup(int size)
74 {
75 int shmid;
76 void *ret;
77
78 shmid = shmget(IPC_PRIVATE, size, S_IRUSR | S_IWUSR);
79 if (shmid == -1) {
80 printf("can't get shared memory\n");
81 exit(1);
82 }
83 ret = (void *)shmat(shmid, 0, 0);
84 if (!ret || ret == (void *)-1) {
85 printf("can't attach to shared memory\n");
86 return NULL;
87 }
88 /* the following releases the ipc, but note that this process
89 and all its children will still have access to the memory, its
90 just that the shmid is no longer valid for other shm calls. This
91 means we don't leave behind lots of shm segments after we exit
92
93 See Stevens "advanced programming in unix env" for details
94 */
95 shmctl(shmid, IPC_RMID, 0);
96
97 return ret;
98 }
99
100 /********************************************************************
101 Ensure a connection is encrypted.
102 ********************************************************************/
103
104 static bool force_cli_encryption(struct cli_state *c,
105 const char *sharename)
106 {
107 uint16 major, minor;
108 uint32 caplow, caphigh;
109 NTSTATUS status;
110
111 if (!SERVER_HAS_UNIX_CIFS(c)) {
112 d_printf("Encryption required and "
113 "server that doesn't support "
114 "UNIX extensions - failing connect\n");
115 return false;
116 }
117
118 if (!cli_unix_extensions_version(c, &major, &minor, &caplow, &caphigh)) {
119 d_printf("Encryption required and "
120 "can't get UNIX CIFS extensions "
121 "version from server.\n");
122 return false;
123 }
124
125 if (!(caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)) {
126 d_printf("Encryption required and "
127 "share %s doesn't support "
128 "encryption.\n", sharename);
129 return false;
130 }
131
132 if (c->use_kerberos) {
133 status = cli_gss_smb_encryption_start(c);
134 } else {
135 status = cli_raw_ntlm_smb_encryption_start(c,
136 username,
137 password,
138 workgroup);
139 }
140
141 if (!NT_STATUS_IS_OK(status)) {
142 d_printf("Encryption required and "
143 "setup failed with error %s.\n",
144 nt_errstr(status));
145 return false;
146 }
147
148 return true;
149 }
150
151
152 static struct cli_state *open_nbt_connection(void)
153 {
154 struct nmb_name called, calling;
155 struct sockaddr_storage ss;
156 struct cli_state *c;
157 NTSTATUS status;
158
159 make_nmb_name(&calling, myname, 0x0);
160 make_nmb_name(&called , host, 0x20);
161
162 zero_sockaddr(&ss);
163
164 if (!(c = cli_initialise())) {
165 printf("Failed initialize cli_struct to connect with %s\n", host);
166 return NULL;
167 }
168
169 c->port = port_to_use;
170
171 status = cli_connect(c, host, &ss);
172 if (!NT_STATUS_IS_OK(status)) {
173 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
174 return NULL;
175 }
176
177 c->use_kerberos = use_kerberos;
178
179 c->timeout = 120000; /* set a really long timeout (2 minutes) */
180 if (use_oplocks) c->use_oplocks = True;
181 if (use_level_II_oplocks) c->use_level_II_oplocks = True;
182
183 if (!cli_session_request(c, &calling, &called)) {
184 /*
185 * Well, that failed, try *SMBSERVER ...
186 * However, we must reconnect as well ...
187 */
188 status = cli_connect(c, host, &ss);
189 if (!NT_STATUS_IS_OK(status)) {
190 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
191 return NULL;
192 }
193
194 make_nmb_name(&called, "*SMBSERVER", 0x20);
195 if (!cli_session_request(c, &calling, &called)) {
196 printf("%s rejected the session\n",host);
197 printf("We tried with a called name of %s & %s\n",
198 host, "*SMBSERVER");
199 cli_shutdown(c);
200 return NULL;
201 }
202 }
203
204 return c;
205 }
206
207 /* Insert a NULL at the first separator of the given path and return a pointer
208 * to the remainder of the string.
209 */
210 static char *
211 terminate_path_at_separator(char * path)
212 {
213 char * p;
214
215 if (!path) {
216 return NULL;
217 }
218
219 if ((p = strchr_m(path, '/'))) {
220 *p = '\0';
221 return p + 1;
222 }
223
224 if ((p = strchr_m(path, '\\'))) {
225 *p = '\0';
226 return p + 1;
227 }
228
229 /* No separator. */
230 return NULL;
231 }
232
233 /*
234 parse a //server/share type UNC name
235 */
236 bool smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
237 char **hostname, char **sharename)
238 {
239 char *p;
240
241 *hostname = *sharename = NULL;
242
243 if (strncmp(unc_name, "\\\\", 2) &&
244 strncmp(unc_name, "//", 2)) {
245 return False;
246 }
247
248 *hostname = talloc_strdup(mem_ctx, &unc_name[2]);
249 p = terminate_path_at_separator(*hostname);
250
251 if (p && *p) {
252 *sharename = talloc_strdup(mem_ctx, p);
253 terminate_path_at_separator(*sharename);
254 }
255
256 if (*hostname && *sharename) {
257 return True;
258 }
259
260 TALLOC_FREE(*hostname);
261 TALLOC_FREE(*sharename);
262 return False;
263 }
264
265 static bool torture_open_connection_share(struct cli_state **c,
266 const char *hostname,
267 const char *sharename)
268 {
269 bool retry;
270 int flags = 0;
271 NTSTATUS status;
272
273 if (use_kerberos)
274 flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
275
276 status = cli_full_connection(c, myname,
277 hostname, NULL, port_to_use,
278 sharename, "?????",
279 username, workgroup,
280 password, flags, Undefined, &retry);
281 if (!NT_STATUS_IS_OK(status)) {
282 printf("failed to open share connection: //%s/%s port:%d - %s\n",
283 hostname, sharename, port_to_use, nt_errstr(status));
284 return False;
285 }
286
287 if (use_oplocks) (*c)->use_oplocks = True;
288 if (use_level_II_oplocks) (*c)->use_level_II_oplocks = True;
289 (*c)->timeout = 120000; /* set a really long timeout (2 minutes) */
290
291 if (do_encrypt) {
292 return force_cli_encryption(*c,
293 sharename);
294 }
295 return True;
296 }
297
298 bool torture_open_connection(struct cli_state **c, int conn_index)
299 {
300 char **unc_list = NULL;
301 int num_unc_names = 0;
302 bool result;
303
304 if (use_multishare_conn==True) {
305 char *h, *s;
306 unc_list = file_lines_load(multishare_conn_fname, &num_unc_names, 0, NULL);
307 if (!unc_list || num_unc_names <= 0) {
308 printf("Failed to load unc names list from '%s'\n", multishare_conn_fname);
309 exit(1);
310 }
311
312 if (!smbcli_parse_unc(unc_list[conn_index % num_unc_names],
313 NULL, &h, &s)) {
314 printf("Failed to parse UNC name %s\n",
315 unc_list[conn_index % num_unc_names]);
316 TALLOC_FREE(unc_list);
317 exit(1);
318 }
319
320 result = torture_open_connection_share(c, h, s);
321
322 /* h, s were copied earlier */
323 TALLOC_FREE(unc_list);
324 return result;
325 }
326
327 return torture_open_connection_share(c, host, share);
328 }
329
330 bool torture_cli_session_setup2(struct cli_state *cli, uint16 *new_vuid)
331 {
332 uint16 old_vuid = cli->vuid;
333 fstring old_user_name;
334 size_t passlen = strlen(password);
335 bool ret;
336
337 fstrcpy(old_user_name, cli->user_name);
338 cli->vuid = 0;
339 ret = NT_STATUS_IS_OK(cli_session_setup(cli, username,
340 password, passlen,
341 password, passlen,
342 workgroup));
343 *new_vuid = cli->vuid;
344 cli->vuid = old_vuid;
345 fstrcpy(cli->user_name, old_user_name);
346 return ret;
347 }
348
349
350 bool torture_close_connection(struct cli_state *c)
351 {
352 bool ret = True;
353 if (!cli_tdis(c)) {
354 printf("tdis failed (%s)\n", cli_errstr(c));
355 ret = False;
356 }
357
358 cli_shutdown(c);
359
360 return ret;
361 }
362
363
364 /* check if the server produced the expected error code */
365 static bool check_error(int line, struct cli_state *c,
366 uint8 eclass, uint32 ecode, NTSTATUS nterr)
367 {
368 if (cli_is_dos_error(c)) {
369 uint8 cclass;
370 uint32 num;
371
372 /* Check DOS error */
373
374 cli_dos_error(c, &cclass, &num);
375
376 if (eclass != cclass || ecode != num) {
377 printf("unexpected error code class=%d code=%d\n",
378 (int)cclass, (int)num);
379 printf(" expected %d/%d %s (line=%d)\n",
380 (int)eclass, (int)ecode, nt_errstr(nterr), line);
381 return False;
382 }
383
384 } else {
385 NTSTATUS status;
386
387 /* Check NT error */
388
389 status = cli_nt_error(c);
390
391 if (NT_STATUS_V(nterr) != NT_STATUS_V(status)) {
392 printf("unexpected error code %s\n", nt_errstr(status));
393 printf(" expected %s (line=%d)\n", nt_errstr(nterr), line);
394 return False;
395 }
396 }
397
398 return True;
399 }
400
401
402 static bool wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len)
403 {
404 while (!cli_lock(c, fnum, offset, len, -1, WRITE_LOCK)) {
405 if (!check_error(__LINE__, c, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
406 }
407 return True;
408 }
409
410
411 static bool rw_torture(struct cli_state *c)
412 {
413 const char *lockfname = "\\torture.lck";
414 fstring fname;
415 int fnum;
416 int fnum2;
417 pid_t pid2, pid = getpid();
418 int i, j;
419 char buf[1024];
420 bool correct = True;
421
422 memset(buf, '\0', sizeof(buf));
423
424 fnum2 = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
425 DENY_NONE);
426 if (fnum2 == -1)
427 fnum2 = cli_open(c, lockfname, O_RDWR, DENY_NONE);
428 if (fnum2 == -1) {
429 printf("open of %s failed (%s)\n", lockfname, cli_errstr(c));
430 return False;
431 }
432
433
434 for (i=0;i<torture_numops;i++) {
435 unsigned n = (unsigned)sys_random()%10;
436 if (i % 10 == 0) {
437 printf("%d\r", i); fflush(stdout);
438 }
439 slprintf(fname, sizeof(fstring) - 1, "\\torture.%u", n);
440
441 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
442 return False;
443 }
444
445 fnum = cli_open(c, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL);
446 if (fnum == -1) {
447 printf("open failed (%s)\n", cli_errstr(c));
448 correct = False;
449 break;
450 }
451
452 if (cli_write(c, fnum, 0, (char *)&pid, 0, sizeof(pid)) != sizeof(pid)) {
453 printf("write failed (%s)\n", cli_errstr(c));
454 correct = False;
455 }
456
457 for (j=0;j<50;j++) {
458 if (cli_write(c, fnum, 0, (char *)buf,
459 sizeof(pid)+(j*sizeof(buf)),
460 sizeof(buf)) != sizeof(buf)) {
461 printf("write failed (%s)\n", cli_errstr(c));
462 correct = False;
463 }
464 }
465
466 pid2 = 0;
467
468 if (cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid)) != sizeof(pid)) {
469 printf("read failed (%s)\n", cli_errstr(c));
470 correct = False;
471 }
472
473 if (pid2 != pid) {
474 printf("data corruption!\n");
475 correct = False;
476 }
477
478 if (!cli_close(c, fnum)) {
479 printf("close failed (%s)\n", cli_errstr(c));
480 correct = False;
481 }
482
483 if (!cli_unlink(c, fname)) {
484 printf("unlink failed (%s)\n", cli_errstr(c));
485 correct = False;
486 }
487
488 if (!cli_unlock(c, fnum2, n*sizeof(int), sizeof(int))) {
489 printf("unlock failed (%s)\n", cli_errstr(c));
490 correct = False;
491 }
492 }
493
494 cli_close(c, fnum2);
495 cli_unlink(c, lockfname);
496
497 printf("%d\n", i);
498
499 return correct;
500 }
501
502 static bool run_torture(int dummy)
503 {
504 struct cli_state *cli;
505 bool ret;
506
507 cli = current_cli;
508
509 cli_sockopt(cli, sockops);
510
511 ret = rw_torture(cli);
512
513 if (!torture_close_connection(cli)) {
514 ret = False;
515 }
516
517 return ret;
518 }
519
520 static bool rw_torture3(struct cli_state *c, char *lockfname)
521 {
522 int fnum = -1;
523 unsigned int i = 0;
524 char buf[131072];
525 char buf_rd[131072];
526 unsigned count;
527 unsigned countprev = 0;
528 ssize_t sent = 0;
529 bool correct = True;
530
531 srandom(1);
532 for (i = 0; i < sizeof(buf); i += sizeof(uint32))
533 {
534 SIVAL(buf, i, sys_random());
535 }
536
537 if (procnum == 0)
538 {
539 fnum = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
540 DENY_NONE);
541 if (fnum == -1) {
542 printf("first open read/write of %s failed (%s)\n",
543 lockfname, cli_errstr(c));
544 return False;
545 }
546 }
547 else
548 {
549 for (i = 0; i < 500 && fnum == -1; i++)
550 {
551 fnum = cli_open(c, lockfname, O_RDONLY,
552 DENY_NONE);
553 smb_msleep(10);
554 }
555 if (fnum == -1) {
556 printf("second open read-only of %s failed (%s)\n",
557 lockfname, cli_errstr(c));
558 return False;
559 }
560 }
561
562 i = 0;
563 for (count = 0; count < sizeof(buf); count += sent)
564 {
565 if (count >= countprev) {
566 printf("%d %8d\r", i, count);
567 fflush(stdout);
568 i++;
569 countprev += (sizeof(buf) / 20);
570 }
571
572 if (procnum == 0)
573 {
574 sent = ((unsigned)sys_random()%(20))+ 1;
575 if (sent > sizeof(buf) - count)
576 {
577 sent = sizeof(buf) - count;
578 }
579
580 if (cli_write(c, fnum, 0, buf+count, count, (size_t)sent) != sent) {
581 printf("write failed (%s)\n", cli_errstr(c));
582 correct = False;
583 }
584 }
585 else
586 {
587 sent = cli_read(c, fnum, buf_rd+count, count,
588 sizeof(buf)-count);
589 if (sent < 0)
590 {
591 printf("read failed offset:%d size:%ld (%s)\n",
592 count, (unsigned long)sizeof(buf)-count,
593 cli_errstr(c));
594 correct = False;
595 sent = 0;
596 }
597 if (sent > 0)
598 {
599 if (memcmp(buf_rd+count, buf+count, sent) != 0)
600 {
601 printf("read/write compare failed\n");
602 printf("offset: %d req %ld recvd %ld\n", count, (unsigned long)sizeof(buf)-count, (unsigned long)sent);
603 correct = False;
604 break;
605 }
606 }
607 }
608
609 }
610
611 if (!cli_close(c, fnum)) {
612 printf("close failed (%s)\n", cli_errstr(c));
613 correct = False;
614 }
615
616 return correct;
617 }
618
619 static bool rw_torture2(struct cli_state *c1, struct cli_state *c2)
620 {
621 const char *lockfname = "\\torture2.lck";
622 int fnum1;
623 int fnum2;
624 int i;
625 char buf[131072];
626 char buf_rd[131072];
627 bool correct = True;
628 ssize_t bytes_read;
629
630 if (!cli_unlink(c1, lockfname)) {
631 printf("unlink failed (%s) (normal, this file should not exist)\n", cli_errstr(c1));
632 }
633
634 fnum1 = cli_open(c1, lockfname, O_RDWR | O_CREAT | O_EXCL,
635 DENY_NONE);
636 if (fnum1 == -1) {
637 printf("first open read/write of %s failed (%s)\n",
638 lockfname, cli_errstr(c1));
639 return False;
640 }
641 fnum2 = cli_open(c2, lockfname, O_RDONLY,
642 DENY_NONE);
643 if (fnum2 == -1) {
644 printf("second open read-only of %s failed (%s)\n",
645 lockfname, cli_errstr(c2));
646 cli_close(c1, fnum1);
647 return False;
648 }
649
650 for (i=0;i<torture_numops;i++)
651 {
652 size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
653 if (i % 10 == 0) {
654 printf("%d\r", i); fflush(stdout);
655 }
656
657 generate_random_buffer((unsigned char *)buf, buf_size);
658
659 if (cli_write(c1, fnum1, 0, buf, 0, buf_size) != buf_size) {
660 printf("write failed (%s)\n", cli_errstr(c1));
661 correct = False;
662 break;
663 }
664
665 if ((bytes_read = cli_read(c2, fnum2, buf_rd, 0, buf_size)) != buf_size) {
666 printf("read failed (%s)\n", cli_errstr(c2));
667 printf("read %d, expected %ld\n", (int)bytes_read,
668 (unsigned long)buf_size);
669 correct = False;
670 break;
671 }
672
673 if (memcmp(buf_rd, buf, buf_size) != 0)
674 {
675 printf("read/write compare failed\n");
676 correct = False;
677 break;
678 }
679 }
680
681 if (!cli_close(c2, fnum2)) {
682 printf("close failed (%s)\n", cli_errstr(c2));
683 correct = False;
684 }
685 if (!cli_close(c1, fnum1)) {
686 printf("close failed (%s)\n", cli_errstr(c1));
687 correct = False;
688 }
689
690 if (!cli_unlink(c1, lockfname)) {
691 printf("unlink failed (%s)\n", cli_errstr(c1));
692 correct = False;
693 }
694
695 return correct;
696 }
697
698 static bool run_readwritetest(int dummy)
699 {
700 static struct cli_state *cli1, *cli2;
701 bool test1, test2 = False;
702
703 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
704 return False;
705 }
706 cli_sockopt(cli1, sockops);
707 cli_sockopt(cli2, sockops);
708
709 printf("starting readwritetest\n");
710
711 test1 = rw_torture2(cli1, cli2);
712 printf("Passed readwritetest v1: %s\n", BOOLSTR(test1));
713
714 if (test1) {
715 test2 = rw_torture2(cli1, cli1);
716 printf("Passed readwritetest v2: %s\n", BOOLSTR(test2));
717 }
718
719 if (!torture_close_connection(cli1)) {
720 test1 = False;
721 }
722
723 if (!torture_close_connection(cli2)) {
724 test2 = False;
725 }
726
727 return (test1 && test2);
728 }
729
730 static bool run_readwritemulti(int dummy)
731 {
732 struct cli_state *cli;
733 bool test;
734
735 cli = current_cli;
736
737 cli_sockopt(cli, sockops);
738
739 printf("run_readwritemulti: fname %s\n", randomfname);
740 test = rw_torture3(cli, randomfname);
741
742 if (!torture_close_connection(cli)) {
743 test = False;
744 }
745
746 return test;
747 }
748
749 static bool run_readwritelarge(int dummy)
750 {
751 static struct cli_state *cli1;
752 int fnum1;
753 const char *lockfname = "\\large.dat";
754 SMB_OFF_T fsize;
755 char buf[126*1024];
756 bool correct = True;
757
758 if (!torture_open_connection(&cli1, 0)) {
759 return False;
760 }
761 cli_sockopt(cli1, sockops);
762 memset(buf,'\0',sizeof(buf));
763
764 cli1->max_xmit = 128*1024;
765
766 printf("starting readwritelarge\n");
767
768 cli_unlink(cli1, lockfname);
769
770 fnum1 = cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE);
771 if (fnum1 == -1) {
772 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
773 return False;
774 }
775
776 cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf));
777
778 if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
779 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
780 correct = False;
781 }
782
783 if (fsize == sizeof(buf))
784 printf("readwritelarge test 1 succeeded (size = %lx)\n",
785 (unsigned long)fsize);
786 else {
787 printf("readwritelarge test 1 failed (size = %lx)\n",
788 (unsigned long)fsize);
789 correct = False;
790 }
791
792 if (!cli_close(cli1, fnum1)) {
793 printf("close failed (%s)\n", cli_errstr(cli1));
794 correct = False;
795 }
796
797 if (!cli_unlink(cli1, lockfname)) {
798 printf("unlink failed (%s)\n", cli_errstr(cli1));
799 correct = False;
800 }
801
802 fnum1 = cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE);
803 if (fnum1 == -1) {
804 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
805 return False;
806 }
807
808 cli1->max_xmit = 4*1024;
809
810 cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf));
811
812 if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
813 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
814 correct = False;
815 }
816
817 if (fsize == sizeof(buf))
818 printf("readwritelarge test 2 succeeded (size = %lx)\n",
819 (unsigned long)fsize);
820 else {
821 printf("readwritelarge test 2 failed (size = %lx)\n",
822 (unsigned long)fsize);
823 correct = False;
824 }
825
826 #if 0
827 /* ToDo - set allocation. JRA */
828 if(!cli_set_allocation_size(cli1, fnum1, 0)) {
829 printf("set allocation size to zero failed (%s)\n", cli_errstr(&cli1));
830 return False;
831 }
832 if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
833 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
834 correct = False;
835 }
836 if (fsize != 0)
837 printf("readwritelarge test 3 (truncate test) succeeded (size = %x)\n", fsize);
838 #endif
839
840 if (!cli_close(cli1, fnum1)) {
841 printf("close failed (%s)\n", cli_errstr(cli1));
842 correct = False;
843 }
844
845 if (!torture_close_connection(cli1)) {
846 correct = False;
847 }
848 return correct;
849 }
850
851 int line_count = 0;
852 int nbio_id;
853
854 #define ival(s) strtol(s, NULL, 0)
855
856 /* run a test that simulates an approximate netbench client load */
857 static bool run_netbench(int client)
858 {
859 struct cli_state *cli;
860 int i;
861 char line[1024];
862 char cname[20];
863 FILE *f;
864 const char *params[20];
865 bool correct = True;
866
867 cli = current_cli;
868
869 nbio_id = client;
870
871 cli_sockopt(cli, sockops);
872
873 nb_setup(cli);
874
875 slprintf(cname,sizeof(cname)-1, "client%d", client);
876
877 f = fopen(client_txt, "r");
878
879 if (!f) {
880 perror(client_txt);
881 return False;
882 }
883
884 while (fgets(line, sizeof(line)-1, f)) {
885 char *saveptr;
886 line_count++;
887
888 line[strlen(line)-1] = 0;
889
890 /* printf("[%d] %s\n", line_count, line); */
891
892 all_string_sub(line,"client1", cname, sizeof(line));
893
894 /* parse the command parameters */
895 params[0] = strtok_r(line, " ", &saveptr);
896 i = 0;
897 while (params[i]) params[++i] = strtok_r(NULL, " ", &saveptr);
898
899 params[i] = "";
900
901 if (i < 2) continue;
902
903 if (!strncmp(params[0],"SMB", 3)) {
904 printf("ERROR: You are using a dbench 1 load file\n");
905 exit(1);
906 }
907
908 if (!strcmp(params[0],"NTCreateX")) {
909 nb_createx(params[1], ival(params[2]), ival(params[3]),
910 ival(params[4]));
911 } else if (!strcmp(params[0],"Close")) {
912 nb_close(ival(params[1]));
913 } else if (!strcmp(params[0],"Rename")) {
914 nb_rename(params[1], params[2]);
915 } else if (!strcmp(params[0],"Unlink")) {
916 nb_unlink(params[1]);
917 } else if (!strcmp(params[0],"Deltree")) {
918 nb_deltree(params[1]);
919 } else if (!strcmp(params[0],"Rmdir")) {
920 nb_rmdir(params[1]);
921 } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
922 nb_qpathinfo(params[1]);
923 } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
924 nb_qfileinfo(ival(params[1]));
925 } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
926 nb_qfsinfo(ival(params[1]));
927 } else if (!strcmp(params[0],"FIND_FIRST")) {
928 nb_findfirst(params[1]);
929 } else if (!strcmp(params[0],"WriteX")) {
930 nb_writex(ival(params[1]),
931 ival(params[2]), ival(params[3]), ival(params[4]));
932 } else if (!strcmp(params[0],"ReadX")) {
933 nb_readx(ival(params[1]),
934 ival(params[2]), ival(params[3]), ival(params[4]));
935 } else if (!strcmp(params[0],"Flush")) {
936 nb_flush(ival(params[1]));
937 } else {
938 printf("Unknown operation %s\n", params[0]);
939 exit(1);
940 }
941 }
942 fclose(f);
943
944 nb_cleanup();
945
946 if (!torture_close_connection(cli)) {
947 correct = False;
948 }
949
950 return correct;
951 }
952
953
954 /* run a test that simulates an approximate netbench client load */
955 static bool run_nbench(int dummy)
956 {
957 double t;
958 bool correct = True;
959
960 nbio_shmem(nprocs);
961
962 nbio_id = -1;
963
964 signal(SIGALRM, nb_alarm);
965 alarm(1);
966 t = create_procs(run_netbench, &correct);
967 alarm(0);
968
969 printf("\nThroughput %g MB/sec\n",
970 1.0e-6 * nbio_total() / t);
971 return correct;
972 }
973
974
975 /*
976 This test checks for two things:
977
978 1) correct support for retaining locks over a close (ie. the server
979 must not use posix semantics)
980 2) support for lock timeouts
981 */
982 static bool run_locktest1(int dummy)
983 {
984 struct cli_state *cli1, *cli2;
985 const char *fname = "\\lockt1.lck";
986 int fnum1, fnum2, fnum3;
987 time_t t1, t2;
988 unsigned lock_timeout;
989
990 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
991 return False;
992 }
993 cli_sockopt(cli1, sockops);
994 cli_sockopt(cli2, sockops);
995
996 printf("starting locktest1\n");
997
998 cli_unlink(cli1, fname);
999
1000 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1001 if (fnum1 == -1) {
1002 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1003 return False;
1004 }
1005 fnum2 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1006 if (fnum2 == -1) {
1007 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli1));
1008 return False;
1009 }
1010 fnum3 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1011 if (fnum3 == -1) {
1012 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli2));
1013 return False;
1014 }
1015
1016 if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
1017 printf("lock1 failed (%s)\n", cli_errstr(cli1));
1018 return False;
1019 }
1020
1021
1022 if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
1023 printf("lock2 succeeded! This is a locking bug\n");
1024 return False;
1025 } else {
1026 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1027 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1028 }
1029
1030
1031 lock_timeout = (1 + (random() % 20));
1032 printf("Testing lock timeout with timeout=%u\n", lock_timeout);
1033 t1 = time(NULL);
1034 if (cli_lock(cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK)) {
1035 printf("lock3 succeeded! This is a locking bug\n");
1036 return False;
1037 } else {
1038 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1039 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1040 }
1041 t2 = time(NULL);
1042
1043 if (ABS(t2 - t1) < lock_timeout-1) {
1044 printf("error: This server appears not to support timed lock requests\n");
1045 }
1046
1047 printf("server slept for %u seconds for a %u second timeout\n",
1048 (unsigned int)(t2-t1), lock_timeout);
1049
1050 if (!cli_close(cli1, fnum2)) {
1051 printf("close1 failed (%s)\n", cli_errstr(cli1));
1052 return False;
1053 }
1054
1055 if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
1056 printf("lock4 succeeded! This is a locking bug\n");
1057 return False;
1058 } else {
1059 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1060 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1061 }
1062
1063 if (!cli_close(cli1, fnum1)) {
1064 printf("close2 failed (%s)\n", cli_errstr(cli1));
1065 return False;
1066 }
1067
1068 if (!cli_close(cli2, fnum3)) {
1069 printf("close3 failed (%s)\n", cli_errstr(cli2));
1070 return False;
1071 }
1072
1073 if (!cli_unlink(cli1, fname)) {
1074 printf("unlink failed (%s)\n", cli_errstr(cli1));
1075 return False;
1076 }
1077
1078
1079 if (!torture_close_connection(cli1)) {
1080 return False;
1081 }
1082
1083 if (!torture_close_connection(cli2)) {
1084 return False;
1085 }
1086
1087 printf("Passed locktest1\n");
1088 return True;
1089 }
1090
1091 /*
1092 this checks to see if a secondary tconx can use open files from an
1093 earlier tconx
1094 */
1095 static bool run_tcon_test(int dummy)
1096 {
1097 static struct cli_state *cli;
1098 const char *fname = "\\tcontest.tmp";
1099 int fnum1;
1100 uint16 cnum1, cnum2, cnum3;
1101 uint16 vuid1, vuid2;
1102 char buf[4];
1103 bool ret = True;
1104 NTSTATUS status;
1105
1106 memset(buf, '\0', sizeof(buf));
1107
1108 if (!torture_open_connection(&cli, 0)) {
1109 return False;
1110 }
1111 cli_sockopt(cli, sockops);
1112
1113 printf("starting tcontest\n");
1114
1115 cli_unlink(cli, fname);
1116
1117 fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1118 if (fnum1 == -1) {
1119 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1120 return False;
1121 }
1122
1123 cnum1 = cli->cnum;
1124 vuid1 = cli->vuid;
1125
1126 if (cli_write(cli, fnum1, 0, buf, 130, 4) != 4) {
1127 printf("initial write failed (%s)", cli_errstr(cli));
1128 return False;
1129 }
1130
1131 status = cli_tcon_andx(cli, share, "?????",
1132 password, strlen(password)+1);
1133 if (!NT_STATUS_IS_OK(status)) {
1134 printf("%s refused 2nd tree connect (%s)\n", host,
1135 nt_errstr(status));
1136 cli_shutdown(cli);
1137 return False;
1138 }
1139
1140 cnum2 = cli->cnum;
1141 cnum3 = MAX(cnum1, cnum2) + 1; /* any invalid number */
1142 vuid2 = cli->vuid + 1;
1143
1144 /* try a write with the wrong tid */
1145 cli->cnum = cnum2;
1146
1147 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1148 printf("* server allows write with wrong TID\n");
1149 ret = False;
1150 } else {
1151 printf("server fails write with wrong TID : %s\n", cli_errstr(cli));
1152 }
1153
1154
1155 /* try a write with an invalid tid */
1156 cli->cnum = cnum3;
1157
1158 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1159 printf("* server allows write with invalid TID\n");
1160 ret = False;
1161 } else {
1162 printf("server fails write with invalid TID : %s\n", cli_errstr(cli));
1163 }
1164
1165 /* try a write with an invalid vuid */
1166 cli->vuid = vuid2;
1167 cli->cnum = cnum1;
1168
1169 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1170 printf("* server allows write with invalid VUID\n");
1171 ret = False;
1172 } else {
1173 printf("server fails write with invalid VUID : %s\n", cli_errstr(cli));
1174 }
1175
1176 cli->cnum = cnum1;
1177 cli->vuid = vuid1;
1178
1179 if (!cli_close(cli, fnum1)) {
1180 printf("close failed (%s)\n", cli_errstr(cli));
1181 return False;
1182 }
1183
1184 cli->cnum = cnum2;
1185
1186 if (!cli_tdis(cli)) {
1187 printf("secondary tdis failed (%s)\n", cli_errstr(cli));
1188 return False;
1189 }
1190
1191 cli->cnum = cnum1;
1192
1193 if (!torture_close_connection(cli)) {
1194 return False;
1195 }
1196
1197 return ret;
1198 }
1199
1200
1201 /*
1202 checks for old style tcon support
1203 */
1204 static bool run_tcon2_test(int dummy)
1205 {
1206 static struct cli_state *cli;
1207 uint16 cnum, max_xmit;
1208 char *service;
1209 NTSTATUS status;
1210
1211 if (!torture_open_connection(&cli, 0)) {
1212 return False;
1213 }
1214 cli_sockopt(cli, sockops);
1215
1216 printf("starting tcon2 test\n");
1217
1218 if (asprintf(&service, "\\\\%s\\%s", host, share) == -1) {
1219 return false;
1220 }
1221
1222 status = cli_raw_tcon(cli, service, password, "?????", &max_xmit, &cnum);
1223
1224 if (!NT_STATUS_IS_OK(status)) {
1225 printf("tcon2 failed : %s\n", cli_errstr(cli));
1226 } else {
1227 printf("tcon OK : max_xmit=%d cnum=%d tid=%d\n",
1228 (int)max_xmit, (int)cnum, SVAL(cli->inbuf, smb_tid));
1229 }
1230
1231 if (!torture_close_connection(cli)) {
1232 return False;
1233 }
1234
1235 printf("Passed tcon2 test\n");
1236 return True;
1237 }
1238
1239 static bool tcon_devtest(struct cli_state *cli,
1240 const char *myshare, const char *devtype,
1241 const char *return_devtype,
1242 NTSTATUS expected_error)
1243 {
1244 NTSTATUS status;
1245 bool ret;
1246
1247 status = cli_tcon_andx(cli, myshare, devtype,
1248 password, strlen(password)+1);
1249
1250 if (NT_STATUS_IS_OK(expected_error)) {
1251 if (NT_STATUS_IS_OK(status)) {
1252 if (strcmp(cli->dev, return_devtype) == 0) {
1253 ret = True;
1254 } else {
1255 printf("tconX to share %s with type %s "
1256 "succeeded but returned the wrong "
1257 "device type (got [%s] but should have got [%s])\n",
1258 myshare, devtype, cli->dev, return_devtype);
1259 ret = False;
1260 }
1261 } else {
1262 printf("tconX to share %s with type %s "
1263 "should have succeeded but failed\n",
1264 myshare, devtype);
1265 ret = False;
1266 }
1267 cli_tdis(cli);
1268 } else {
1269 if (NT_STATUS_IS_OK(status)) {
1270 printf("tconx to share %s with type %s "
1271 "should have failed but succeeded\n",
1272 myshare, devtype);
1273 ret = False;
1274 } else {
1275 if (NT_STATUS_EQUAL(cli_nt_error(cli),
1276 expected_error)) {
1277 ret = True;
1278 } else {
1279 printf("Returned unexpected error\n");
1280 ret = False;
1281 }
1282 }
1283 }
1284 return ret;
1285 }
1286
1287 /*
1288 checks for correct tconX support
1289 */
1290 static bool run_tcon_devtype_test(int dummy)
1291 {
1292 static struct cli_state *cli1 = NULL;
1293 bool retry;
1294 int flags = 0;
1295 NTSTATUS status;
1296 bool ret = True;
1297
1298 status = cli_full_connection(&cli1, myname,
1299 host, NULL, port_to_use,
1300 NULL, NULL,
1301 username, workgroup,
1302 password, flags, Undefined, &retry);
1303
1304 if (!NT_STATUS_IS_OK(status)) {
1305 printf("could not open connection\n");
1306 return False;
1307 }
1308
1309 if (!tcon_devtest(cli1, "IPC$", "A:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1310 ret = False;
1311
1312 if (!tcon_devtest(cli1, "IPC$", "?????", "IPC", NT_STATUS_OK))
1313 ret = False;
1314
1315 if (!tcon_devtest(cli1, "IPC$", "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1316 ret = False;
1317
1318 if (!tcon_devtest(cli1, "IPC$", "IPC", "IPC", NT_STATUS_OK))
1319 ret = False;
1320
1321 if (!tcon_devtest(cli1, "IPC$", "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1322 ret = False;
1323
1324 if (!tcon_devtest(cli1, share, "A:", "A:", NT_STATUS_OK))
1325 ret = False;
1326
1327 if (!tcon_devtest(cli1, share, "?????", "A:", NT_STATUS_OK))
1328 ret = False;
1329
1330 if (!tcon_devtest(cli1, share, "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1331 ret = False;
1332
1333 if (!tcon_devtest(cli1, share, "IPC", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1334 ret = False;
1335
1336 if (!tcon_devtest(cli1, share, "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1337 ret = False;
1338
1339 cli_shutdown(cli1);
1340
1341 if (ret)
1342 printf("Passed tcondevtest\n");
1343
1344 return ret;
1345 }
1346
1347
1348 /*
1349 This test checks that
1350
1351 1) the server supports multiple locking contexts on the one SMB
1352 connection, distinguished by PID.
1353
1354 2) the server correctly fails overlapping locks made by the same PID (this
1355 goes against POSIX behaviour, which is why it is tricky to implement)
1356
1357 3) the server denies unlock requests by an incorrect client PID
1358 */
1359 static bool run_locktest2(int dummy)
1360 {
1361 static struct cli_state *cli;
1362 const char *fname = "\\lockt2.lck";
1363 int fnum1, fnum2, fnum3;
1364 bool correct = True;
1365
1366 if (!torture_open_connection(&cli, 0)) {
1367 return False;
1368 }
1369
1370 cli_sockopt(cli, sockops);
1371
1372 printf("starting locktest2\n");
1373
1374 cli_unlink(cli, fname);
1375
1376 cli_setpid(cli, 1);
1377
1378 fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1379 if (fnum1 == -1) {
1380 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1381 return False;
1382 }
1383
1384 fnum2 = cli_open(cli, fname, O_RDWR, DENY_NONE);
1385 if (fnum2 == -1) {
1386 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli));
1387 return False;
1388 }
1389
1390 cli_setpid(cli, 2);
1391
1392 fnum3 = cli_open(cli, fname, O_RDWR, DENY_NONE);
1393 if (fnum3 == -1) {
1394 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli));
1395 return False;
1396 }
1397
1398 cli_setpid(cli, 1);
1399
1400 if (!cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1401 printf("lock1 failed (%s)\n", cli_errstr(cli));
1402 return False;
1403 }
1404
1405 if (cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1406 printf("WRITE lock1 succeeded! This is a locking bug\n");
1407 correct = False;
1408 } else {
1409 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1410 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1411 }
1412
1413 if (cli_lock(cli, fnum2, 0, 4, 0, WRITE_LOCK)) {
1414 printf("WRITE lock2 succeeded! This is a locking bug\n");
1415 correct = False;
1416 } else {
1417 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1418 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1419 }
1420
1421 if (cli_lock(cli, fnum2, 0, 4, 0, READ_LOCK)) {
1422 printf("READ lock2 succeeded! This is a locking bug\n");
1423 correct = False;
1424 } else {
1425 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1426 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1427 }
1428
1429 if (!cli_lock(cli, fnum1, 100, 4, 0, WRITE_LOCK)) {
1430 printf("lock at 100 failed (%s)\n", cli_errstr(cli));
1431 }
1432 cli_setpid(cli, 2);
1433 if (cli_unlock(cli, fnum1, 100, 4)) {
1434 printf("unlock at 100 succeeded! This is a locking bug\n");
1435 correct = False;
1436 }
1437
1438 if (cli_unlock(cli, fnum1, 0, 4)) {
1439 printf("unlock1 succeeded! This is a locking bug\n");
1440 correct = False;
1441 } else {
1442 if (!check_error(__LINE__, cli,
1443 ERRDOS, ERRlock,
1444 NT_STATUS_RANGE_NOT_LOCKED)) return False;
1445 }
1446
1447 if (cli_unlock(cli, fnum1, 0, 8)) {
1448 printf("unlock2 succeeded! This is a locking bug\n");
1449 correct = False;
1450 } else {
1451 if (!check_error(__LINE__, cli,
1452 ERRDOS, ERRlock,
1453 NT_STATUS_RANGE_NOT_LOCKED)) return False;
1454 }
1455
1456 if (cli_lock(cli, fnum3, 0, 4, 0, WRITE_LOCK)) {
1457 printf("lock3 succeeded! This is a locking bug\n");
1458 correct = False;
1459 } else {
1460 if (!check_error(__LINE__, cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
1461 }
1462
1463 cli_setpid(cli, 1);
1464
1465 if (!cli_close(cli, fnum1)) {
1466 printf("close1 failed (%s)\n", cli_errstr(cli));
1467 return False;
1468 }
1469
1470 if (!cli_close(cli, fnum2)) {
1471 printf("close2 failed (%s)\n", cli_errstr(cli));
1472 return False;
1473 }
1474
1475 if (!cli_close(cli, fnum3)) {
1476 printf("close3 failed (%s)\n", cli_errstr(cli));
1477 return False;
1478 }
1479
1480 if (!torture_close_connection(cli)) {
1481 correct = False;
1482 }
1483
1484 printf("locktest2 finished\n");
1485
1486 return correct;
1487 }
1488
1489
1490 /*
1491 This test checks that
1492
1493 1) the server supports the full offset range in lock requests
1494 */
1495 static bool run_locktest3(int dummy)
1496 {
1497 static struct cli_state *cli1, *cli2;
1498 const char *fname = "\\lockt3.lck";
1499 int fnum1, fnum2, i;
1500 uint32 offset;
1501 bool correct = True;
1502
1503 #define NEXT_OFFSET offset += (~(uint32)0) / torture_numops
1504
1505 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1506 return False;
1507 }
1508 cli_sockopt(cli1, sockops);
1509 cli_sockopt(cli2, sockops);
1510
1511 printf("starting locktest3\n");
1512
1513 cli_unlink(cli1, fname);
1514
1515 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1516 if (fnum1 == -1) {
1517 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1518 return False;
1519 }
1520 fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1521 if (fnum2 == -1) {
1522 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli2));
1523 return False;
1524 }
1525
1526 for (offset=i=0;i<torture_numops;i++) {
1527 NEXT_OFFSET;
1528 if (!cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1529 printf("lock1 %d failed (%s)\n",
1530 i,
1531 cli_errstr(cli1));
1532 return False;
1533 }
1534
1535 if (!cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1536 printf("lock2 %d failed (%s)\n",
1537 i,
1538 cli_errstr(cli1));
1539 return False;
1540 }
1541 }
1542
1543 for (offset=i=0;i<torture_numops;i++) {
1544 NEXT_OFFSET;
1545
1546 if (cli_lock(cli1, fnum1, offset-2, 1, 0, WRITE_LOCK)) {
1547 printf("error: lock1 %d succeeded!\n", i);
1548 return False;
1549 }
1550
1551 if (cli_lock(cli2, fnum2, offset-1, 1, 0, WRITE_LOCK)) {
1552 printf("error: lock2 %d succeeded!\n", i);
1553 return False;
1554 }
1555
1556 if (cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1557 printf("error: lock3 %d succeeded!\n", i);
1558 return False;
1559 }
1560
1561 if (cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1562 printf("error: lock4 %d succeeded!\n", i);
1563 return False;
1564 }
1565 }
1566
1567 for (offset=i=0;i<torture_numops;i++) {
1568 NEXT_OFFSET;
1569
1570 if (!cli_unlock(cli1, fnum1, offset-1, 1)) {
1571 printf("unlock1 %d failed (%s)\n",
1572 i,
1573 cli_errstr(cli1));
1574 return False;
1575 }
1576
1577 if (!cli_unlock(cli2, fnum2, offset-2, 1)) {
1578 printf("unlock2 %d failed (%s)\n",
1579 i,
1580 cli_errstr(cli1));
1581 return False;
1582 }
1583 }
1584
1585 if (!cli_close(cli1, fnum1)) {
1586 printf("close1 failed (%s)\n", cli_errstr(cli1));
1587 return False;
1588 }
1589
1590 if (!cli_close(cli2, fnum2)) {
1591 printf("close2 failed (%s)\n", cli_errstr(cli2));
1592 return False;
1593 }
1594
1595 if (!cli_unlink(cli1, fname)) {
1596 printf("unlink failed (%s)\n", cli_errstr(cli1));
1597 return False;
1598 }
1599
1600 if (!torture_close_connection(cli1)) {
1601 correct = False;
1602 }
1603
1604 if (!torture_close_connection(cli2)) {
1605 correct = False;
1606 }
1607
1608 printf("finished locktest3\n");
1609
1610 return correct;
1611 }
1612
1613 #define EXPECTED(ret, v) if ((ret) != (v)) { \
1614 printf("** "); correct = False; \
1615 }
1616
1617 /*
1618 looks at overlapping locks
1619 */
1620 static bool run_locktest4(int dummy)
1621 {
1622 static struct cli_state *cli1, *cli2;
1623 const char *fname = "\\lockt4.lck";
1624 int fnum1, fnum2, f;
1625 bool ret;
1626 char buf[1000];
1627 bool correct = True;
1628
1629 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1630 return False;
1631 }
1632
1633 cli_sockopt(cli1, sockops);
1634 cli_sockopt(cli2, sockops);
1635
1636 printf("starting locktest4\n");
1637
1638 cli_unlink(cli1, fname);
1639
1640 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1641 fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1642
1643 memset(buf, 0, sizeof(buf));
1644
1645 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1646 printf("Failed to create file\n");
1647 correct = False;
1648 goto fail;
1649 }
1650
1651 ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1652 cli_lock(cli1, fnum1, 2, 4, 0, WRITE_LOCK);
1653 EXPECTED(ret, False);
1654 printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
1655
1656 ret = cli_lock(cli1, fnum1, 10, 4, 0, READ_LOCK) &&
1657 cli_lock(cli1, fnum1, 12, 4, 0, READ_LOCK);
1658 EXPECTED(ret, True);
1659 printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
1660
1661 ret = cli_lock(cli1, fnum1, 20, 4, 0, WRITE_LOCK) &&
1662 cli_lock(cli2, fnum2, 22, 4, 0, WRITE_LOCK);
1663 EXPECTED(ret, False);
1664 printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
1665
1666 ret = cli_lock(cli1, fnum1, 30, 4, 0, READ_LOCK) &&
1667 cli_lock(cli2, fnum2, 32, 4, 0, READ_LOCK);
1668 EXPECTED(ret, True);
1669 printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
1670
1671 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 40, 4, 0, WRITE_LOCK)) &&
1672 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 42, 4, 0, WRITE_LOCK));
1673 EXPECTED(ret, False);
1674 printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
1675
1676 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 50, 4, 0, READ_LOCK)) &&
1677 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 52, 4, 0, READ_LOCK));
1678 EXPECTED(ret, True);
1679 printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
1680
1681 ret = cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK) &&
1682 cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK);
1683 EXPECTED(ret, True);
1684 printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
1685
1686 ret = cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK) &&
1687 cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK);
1688 EXPECTED(ret, False);
1689 printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
1690
1691 ret = cli_lock(cli1, fnum1, 80, 4, 0, READ_LOCK) &&
1692 cli_lock(cli1, fnum1, 80, 4, 0, WRITE_LOCK);
1693 EXPECTED(ret, False);
1694 printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
1695
1696 ret = cli_lock(cli1, fnum1, 90, 4, 0, WRITE_LOCK) &&
1697 cli_lock(cli1, fnum1, 90, 4, 0, READ_LOCK);
1698 EXPECTED(ret, True);
1699 printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1700
1701 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 100, 4, 0, WRITE_LOCK)) &&
1702 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 100, 4, 0, READ_LOCK));
1703 EXPECTED(ret, False);
1704 printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1705
1706 ret = cli_lock(cli1, fnum1, 110, 4, 0, READ_LOCK) &&
1707 cli_lock(cli1, fnum1, 112, 4, 0, READ_LOCK) &&
1708 cli_unlock(cli1, fnum1, 110, 6);
1709 EXPECTED(ret, False);
1710 printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
1711
1712
1713 ret = cli_lock(cli1, fnum1, 120, 4, 0, WRITE_LOCK) &&
1714 (cli_read(cli2, fnum2, buf, 120, 4) == 4);
1715 EXPECTED(ret, False);
1716 printf("this server %s strict write locking\n", ret?"doesn't do":"does");
1717
1718 ret = cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK) &&
1719 (cli_write(cli2, fnum2, 0, buf, 130, 4) == 4);
1720 EXPECTED(ret, False);
1721 printf("this server %s strict read locking\n", ret?"doesn't do":"does");
1722
1723
1724 ret = cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1725 cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1726 cli_unlock(cli1, fnum1, 140, 4) &&
1727 cli_unlock(cli1, fnum1, 140, 4);
1728 EXPECTED(ret, True);
1729 printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
1730
1731
1732 ret = cli_lock(cli1, fnum1, 150, 4, 0, WRITE_LOCK) &&
1733 cli_lock(cli1, fnum1, 150, 4, 0, READ_LOCK) &&
1734 cli_unlock(cli1, fnum1, 150, 4) &&
1735 (cli_read(cli2, fnum2, buf, 150, 4) == 4) &&
1736 !(cli_write(cli2, fnum2, 0, buf, 150, 4) == 4) &&
1737 cli_unlock(cli1, fnum1, 150, 4);
1738 EXPECTED(ret, True);
1739 printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
1740
1741 ret = cli_lock(cli1, fnum1, 160, 4, 0, READ_LOCK) &&
1742 cli_unlock(cli1, fnum1, 160, 4) &&
1743 (cli_write(cli2, fnum2, 0, buf, 160, 4) == 4) &&
1744 (cli_read(cli2, fnum2, buf, 160, 4) == 4);
1745 EXPECTED(ret, True);
1746 printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
1747
1748 ret = cli_lock(cli1, fnum1, 170, 4, 0, WRITE_LOCK) &&
1749 cli_unlock(cli1, fnum1, 170, 4) &&
1750 (cli_write(cli2, fnum2, 0, buf, 170, 4) == 4) &&
1751 (cli_read(cli2, fnum2, buf, 170, 4) == 4);
1752 EXPECTED(ret, True);
1753 printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
1754
1755 ret = cli_lock(cli1, fnum1, 190, 4, 0, WRITE_LOCK) &&
1756 cli_lock(cli1, fnum1, 190, 4, 0, READ_LOCK) &&
1757 cli_unlock(cli1, fnum1, 190, 4) &&
1758 !(cli_write(cli2, fnum2, 0, buf, 190, 4) == 4) &&
1759 (cli_read(cli2, fnum2, buf, 190, 4) == 4);
1760 EXPECTED(ret, True);
1761 printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
1762
1763 cli_close(cli1, fnum1);
1764 cli_close(cli2, fnum2);
1765 fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1766 f = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1767 ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1768 cli_lock(cli1, f, 0, 1, 0, READ_LOCK) &&
1769 cli_close(cli1, fnum1) &&
1770 ((fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE)) != -1) &&
1771 cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1772 cli_close(cli1, f);
1773 cli_close(cli1, fnum1);
1774 EXPECTED(ret, True);
1775 printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
1776
1777 fail:
1778 cli_close(cli1, fnum1);
1779 cli_close(cli2, fnum2);
1780 cli_unlink(cli1, fname);
1781 torture_close_connection(cli1);
1782 torture_close_connection(cli2);
1783
1784 printf("finished locktest4\n");
1785 return correct;
1786 }
1787
1788 /*
1789 looks at lock upgrade/downgrade.
1790 */
1791 static bool run_locktest5(int dummy)
1792 {
1793 static struct cli_state *cli1, *cli2;
1794 const char *fname = "\\lockt5.lck";
1795 int fnum1, fnum2, fnum3;
1796 bool ret;
1797 char buf[1000];
1798 bool correct = True;
1799
1800 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1801 return False;
1802 }
1803
1804 cli_sockopt(cli1, sockops);
1805 cli_sockopt(cli2, sockops);
1806
1807 printf("starting locktest5\n");
1808
1809 cli_unlink(cli1, fname);
1810
1811 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1812 fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1813 fnum3 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1814
1815 memset(buf, 0, sizeof(buf));
1816
1817 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1818 printf("Failed to create file\n");
1819 correct = False;
1820 goto fail;
1821 }
1822
1823 /* Check for NT bug... */
1824 ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1825 cli_lock(cli1, fnum3, 0, 1, 0, READ_LOCK);
1826 cli_close(cli1, fnum1);
1827 fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1828 ret = cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1829 EXPECTED(ret, True);
1830 printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
1831 cli_close(cli1, fnum1);
1832 fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1833 cli_unlock(cli1, fnum3, 0, 1);
1834
1835 ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1836 cli_lock(cli1, fnum1, 1, 1, 0, READ_LOCK);
1837 EXPECTED(ret, True);
1838 printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
1839
1840 ret = cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1841 EXPECTED(ret, False);
1842
1843 printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
1844
1845 /* Unlock the process 2 lock. */
1846 cli_unlock(cli2, fnum2, 0, 4);
1847
1848 ret = cli_lock(cli1, fnum3, 0, 4, 0, READ_LOCK);
1849 EXPECTED(ret, False);
1850
1851 printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
1852
1853 /* Unlock the process 1 fnum3 lock. */
1854 cli_unlock(cli1, fnum3, 0, 4);
1855
1856 /* Stack 2 more locks here. */
1857 ret = cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK) &&
1858 cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK);
1859
1860 EXPECTED(ret, True);
1861 printf("the same process %s stack read locks\n", ret?"can":"cannot");
1862
1863 /* Unlock the first process lock, then check this was the WRITE lock that was
1864 removed. */
1865
1866 ret = cli_unlock(cli1, fnum1, 0, 4) &&
1867 cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1868
1869 EXPECTED(ret, True);
1870 printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
1871
1872 /* Unlock the process 2 lock. */
1873 cli_unlock(cli2, fnum2, 0, 4);
1874
1875 /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
1876
1877 ret = cli_unlock(cli1, fnum1, 1, 1) &&
1878 cli_unlock(cli1, fnum1, 0, 4) &&
1879 cli_unlock(cli1, fnum1, 0, 4);
1880
1881 EXPECTED(ret, True);
1882 printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
1883
1884 /* Ensure the next unlock fails. */
1885 ret = cli_unlock(cli1, fnum1, 0, 4);
1886 EXPECTED(ret, False);
1887 printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
1888
1889 /* Ensure connection 2 can get a write lock. */
1890 ret = cli_lock(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
1891 EXPECTED(ret, True);
1892
1893 printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
1894
1895
1896 fail:
1897 cli_close(cli1, fnum1);
1898 cli_close(cli2, fnum2);
1899 cli_unlink(cli1, fname);
1900 if (!torture_close_connection(cli1)) {
1901 correct = False;
1902 }
1903 if (!torture_close_connection(cli2)) {
1904 correct = False;
1905 }
1906
1907 printf("finished locktest5\n");
1908
1909 return correct;
1910 }
1911
1912 /*
1913 tries the unusual lockingX locktype bits
1914 */
1915 static bool run_locktest6(int dummy)
1916 {
1917 static struct cli_state *cli;
1918 const char *fname[1] = { "\\lock6.txt" };
1919 int i;
1920 int fnum;
1921 NTSTATUS status;
1922
1923 if (!torture_open_connection(&cli, 0)) {
1924 return False;
1925 }
1926
1927 cli_sockopt(cli, sockops);
1928
1929 printf("starting locktest6\n");
1930
1931 for (i=0;i<1;i++) {
1932 printf("Testing %s\n", fname[i]);
1933
1934 cli_unlink(cli, fname[i]);
1935
1936 fnum = cli_open(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1937 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
1938 cli_close(cli, fnum);
1939 printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
1940
1941 fnum = cli_open(cli, fname[i], O_RDWR, DENY_NONE);
1942 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
1943 cli_close(cli, fnum);
1944 printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
1945
1946 cli_unlink(cli, fname[i]);
1947 }
1948
1949 torture_close_connection(cli);
1950
1951 printf("finished locktest6\n");
1952 return True;
1953 }
1954
1955 static bool run_locktest7(int dummy)
1956 {
1957 struct cli_state *cli1;
1958 const char *fname = "\\lockt7.lck";
1959 int fnum1;
1960 char buf[200];
1961 bool correct = False;
1962
1963 if (!torture_open_connection(&cli1, 0)) {
1964 return False;
1965 }
1966
1967 cli_sockopt(cli1, sockops);
1968
1969 printf("starting locktest7\n");
1970
1971 cli_unlink(cli1, fname);
1972
1973 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1974
1975 memset(buf, 0, sizeof(buf));
1976
1977 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1978 printf("Failed to create file\n");
1979 goto fail;
1980 }
1981
1982 cli_setpid(cli1, 1);
1983
1984 if (!cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK)) {
1985 printf("Unable to apply read lock on range 130:4, error was %s\n", cli_errstr(cli1));
1986 goto fail;
1987 } else {
1988 printf("pid1 successfully locked range 130:4 for READ\n");
1989 }
1990
1991 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
1992 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
1993 goto fail;
1994 } else {
1995 printf("pid1 successfully read the range 130:4\n");
1996 }
1997
1998 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
1999 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2000 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2001 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2002 goto fail;
2003 }
2004 } else {
2005 printf("pid1 successfully wrote to the range 130:4 (should be denied)\n");
2006 goto fail;
2007 }
2008
2009 cli_setpid(cli1, 2);
2010
2011 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2012 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2013 } else {
2014 printf("pid2 successfully read the range 130:4\n");
2015 }
2016
2017 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2018 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2019 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2020 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2021 goto fail;
2022 }
2023 } else {
2024 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2025 goto fail;
2026 }
2027
2028 cli_setpid(cli1, 1);
2029 cli_unlock(cli1, fnum1, 130, 4);
2030
2031 if (!cli_lock(cli1, fnum1, 130, 4, 0, WRITE_LOCK)) {
2032 printf("Unable to apply write lock on range 130:4, error was %s\n", cli_errstr(cli1));
2033 goto fail;
2034 } else {
2035 printf("pid1 successfully locked range 130:4 for WRITE\n");
2036 }
2037
2038 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2039 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2040 goto fail;
2041 } else {
2042 printf("pid1 successfully read the range 130:4\n");
2043 }
2044
2045 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2046 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2047 goto fail;
2048 } else {
2049 printf("pid1 successfully wrote to the range 130:4\n");
2050 }
2051
2052 cli_setpid(cli1, 2);
2053
2054 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2055 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2056 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2057 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2058 goto fail;
2059 }
2060 } else {
2061 printf("pid2 successfully read the range 130:4 (should be denied)\n");
2062 goto fail;
2063 }
2064
2065 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2066 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2067 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2068 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2069 goto fail;
2070 }
2071 } else {
2072 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2073 goto fail;
2074 }
2075
2076 cli_unlock(cli1, fnum1, 130, 0);
2077 correct = True;
2078
2079 fail:
2080 cli_close(cli1, fnum1);
2081 cli_unlink(cli1, fname);
2082 torture_close_connection(cli1);
2083
2084 printf("finished locktest7\n");
2085 return correct;
2086 }
2087
2088 /*
2089 test whether fnums and tids open on one VC are available on another (a major
2090 security hole)
2091 */
2092 static bool run_fdpasstest(int dummy)
2093 {
2094 struct cli_state *cli1, *cli2;
2095 const char *fname = "\\fdpass.tst";
2096 int fnum1;
2097 char buf[1024];
2098
2099 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2100 return False;
2101 }
2102 cli_sockopt(cli1, sockops);
2103 cli_sockopt(cli2, sockops);
2104
2105 printf("starting fdpasstest\n");
2106
2107 cli_unlink(cli1, fname);
2108
2109 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2110 if (fnum1 == -1) {
2111 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2112 return False;
2113 }
2114
2115 if (cli_write(cli1, fnum1, 0, "hello world\n", 0, 13) != 13) {
2116 printf("write failed (%s)\n", cli_errstr(cli1));
2117 return False;
2118 }
2119
2120 cli2->vuid = cli1->vuid;
2121 cli2->cnum = cli1->cnum;
2122 cli2->pid = cli1->pid;
2123
2124 if (cli_read(cli2, fnum1, buf, 0, 13) == 13) {
2125 printf("read succeeded! nasty security hole [%s]\n",
2126 buf);
2127 return False;
2128 }
2129
2130 cli_close(cli1, fnum1);
2131 cli_unlink(cli1, fname);
2132
2133 torture_close_connection(cli1);
2134 torture_close_connection(cli2);
2135
2136 printf("finished fdpasstest\n");
2137 return True;
2138 }
2139
2140 static bool run_fdsesstest(int dummy)
2141 {
2142 struct cli_state *cli;
2143 uint16 new_vuid;
2144 uint16 saved_vuid;
2145 uint16 new_cnum;
2146 uint16 saved_cnum;
2147 const char *fname = "\\fdsess.tst";
2148 const char *fname1 = "\\fdsess1.tst";
2149 int fnum1;
2150 int fnum2;
2151 char buf[1024];
2152 bool ret = True;
2153
2154 if (!torture_open_connection(&cli, 0))
2155 return False;
2156 cli_sockopt(cli, sockops);
2157
2158 if (!torture_cli_session_setup2(cli, &new_vuid))
2159 return False;
2160
2161 saved_cnum = cli->cnum;
2162 if (!NT_STATUS_IS_OK(cli_tcon_andx(cli, share, "?????", "", 1)))
2163 return False;
2164 new_cnum = cli->cnum;
2165 cli->cnum = saved_cnum;
2166
2167 printf("starting fdsesstest\n");
2168
2169 cli_unlink(cli, fname);
2170 cli_unlink(cli, fname1);
2171
2172 fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2173 if (fnum1 == -1) {
2174 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2175 return False;
2176 }
2177
2178 if (cli_write(cli, fnum1, 0, "hello world\n", 0, 13) != 13) {
2179 printf("write failed (%s)\n", cli_errstr(cli));
2180 return False;
2181 }
2182
2183 saved_vuid = cli->vuid;
2184 cli->vuid = new_vuid;
2185
2186 if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2187 printf("read succeeded with different vuid! nasty security hole [%s]\n",
2188 buf);
2189 ret = False;
2190 }
2191 /* Try to open a file with different vuid, samba cnum. */
2192 fnum2 = cli_open(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2193 if (fnum2 != -1) {
2194 printf("create with different vuid, same cnum succeeded.\n");
2195 cli_close(cli, fnum2);
2196 cli_unlink(cli, fname1);
2197 } else {
2198 printf("create with different vuid, same cnum failed.\n");
2199 printf("This will cause problems with service clients.\n");
2200 ret = False;
2201 }
2202
2203 cli->vuid = saved_vuid;
2204
2205 /* Try with same vuid, different cnum. */
2206 cli->cnum = new_cnum;
2207
2208 if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2209 printf("read succeeded with different cnum![%s]\n",
2210 buf);
2211 ret = False;
2212 }
2213
2214 cli->cnum = saved_cnum;
2215 cli_close(cli, fnum1);
2216 cli_unlink(cli, fname);
2217
2218 torture_close_connection(cli);
2219
2220 printf("finished fdsesstest\n");
2221 return ret;
2222 }
2223
2224 /*
2225 This test checks that
2226
2227 1) the server does not allow an unlink on a file that is open
2228 */
2229 static bool run_unlinktest(int dummy)
2230 {
2231 struct cli_state *cli;
2232 const char *fname = "\\unlink.tst";
2233 int fnum;
2234 bool correct = True;
2235
2236 if (!torture_open_connection(&cli, 0)) {
2237 return False;
2238 }
2239
2240 cli_sockopt(cli, sockops);
2241
2242 printf("starting unlink test\n");
2243
2244 cli_unlink(cli, fname);
2245
2246 cli_setpid(cli, 1);
2247
2248 fnum = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2249 if (fnum == -1) {
2250 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2251 return False;
2252 }
2253
2254 if (cli_unlink(cli, fname)) {
2255 printf("error: server allowed unlink on an open file\n");
2256 correct = False;
2257 } else {
2258 correct = check_error(__LINE__, cli, ERRDOS, ERRbadshare,
2259 NT_STATUS_SHARING_VIOLATION);
2260 }
2261
2262 cli_close(cli, fnum);
2263 cli_unlink(cli, fname);
2264
2265 if (!torture_close_connection(cli)) {
2266 correct = False;
2267 }
2268
2269 printf("unlink test finished\n");
2270
2271 return correct;
2272 }
2273
2274
2275 /*
2276 test how many open files this server supports on the one socket
2277 */
2278 static bool run_maxfidtest(int dummy)
2279 {
2280 struct cli_state *cli;
2281 const char *ftemplate = "\\maxfid.%d.%d";
2282 fstring fname;
2283 int fnums[0x11000], i;
2284 int retries=4;
2285 bool correct = True;
2286
2287 cli = current_cli;
2288
2289 if (retries <= 0) {
2290 printf("failed to connect\n");
2291 return False;
2292 }
2293
2294 cli_sockopt(cli, sockops);
2295
2296 for (i=0; i<0x11000; i++) {
2297 slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2298 if ((fnums[i] = cli_open(cli, fname,
2299 O_RDWR|O_CREAT|O_TRUNC, DENY_NONE)) ==
2300 -1) {
2301 printf("open of %s failed (%s)\n",
2302 fname, cli_errstr(cli));
2303 printf("maximum fnum is %d\n", i);
2304 break;
2305 }
2306 printf("%6d\r", i);
2307 }
2308 printf("%6d\n", i);
2309 i--;
2310
2311 printf("cleaning up\n");
2312 for (;i>=0;i--) {
2313 slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2314 cli_close(cli, fnums[i]);
2315 if (!cli_unlink(cli, fname)) {
2316 printf("unlink of %s failed (%s)\n",
2317 fname, cli_errstr(cli));
2318 correct = False;
2319 }
2320 printf("%6d\r", i);
2321 }
2322 printf("%6d\n", 0);
2323
2324 printf("maxfid test finished\n");
2325 if (!torture_close_connection(cli)) {
2326 correct = False;
2327 }
2328 return correct;
2329 }
2330
2331 /* generate a random buffer */
2332 static void rand_buf(char *buf, int len)
2333 {
2334 while (len--) {
2335 *buf = (char)sys_random();
2336 buf++;
2337 }
2338 }
2339
2340 /* send smb negprot commands, not reading the response */
2341 static bool run_negprot_nowait(int dummy)
2342 {
2343 int i;
2344 static struct cli_state *cli;
2345 bool correct = True;
2346
2347 printf("starting negprot nowait test\n");
2348
2349 if (!(cli = open_nbt_connection())) {
2350 return False;
2351 }
2352
2353 for (i=0;i<50000;i++) {
2354 cli_negprot_sendsync(cli);
2355 }
2356
2357 if (!torture_close_connection(cli)) {
2358 correct = False;
2359 }
2360
2361 printf("finished negprot nowait test\n");
2362
2363 return correct;
2364 }
2365
2366
2367 /* send random IPC commands */
2368 static bool run_randomipc(int dummy)
2369 {
2370 char *rparam = NULL;
2371 char *rdata = NULL;
2372 unsigned int rdrcnt,rprcnt;
2373 char param[1024];
2374 int api, param_len, i;
2375 struct cli_state *cli;
2376 bool correct = True;
2377 int count = 50000;
2378
2379 printf("starting random ipc test\n");
2380
2381 if (!torture_open_connection(&cli, 0)) {
2382 return False;
2383 }
2384
2385 for (i=0;i<count;i++) {
2386 api = sys_random() % 500;
2387 param_len = (sys_random() % 64);
2388
2389 rand_buf(param, param_len);
2390
2391 SSVAL(param,0,api);
2392
2393 cli_api(cli,
2394 param, param_len, 8,
2395 NULL, 0, BUFFER_SIZE,
2396 &rparam, &rprcnt,
2397 &rdata, &rdrcnt);
2398 if (i % 100 == 0) {
2399 printf("%d/%d\r", i,count);
2400 }
2401 }
2402 printf("%d/%d\n", i, count);
2403
2404 if (!torture_close_connection(cli)) {
2405 correct = False;
2406 }
2407
2408 printf("finished random ipc test\n");
2409
2410 return correct;
2411 }
2412
2413
2414
2415 static void browse_callback(const char *sname, uint32 stype,
2416 const char *comment, void *state)
2417 {
2418 printf("\t%20.20s %08x %s\n", sname, stype, comment);
2419 }
2420
2421
2422
2423 /*
2424 This test checks the browse list code
2425
2426 */
2427 static bool run_browsetest(int dummy)
2428 {
2429 static struct cli_state *cli;
2430 bool correct = True;
2431
2432 printf("starting browse test\n");
2433
2434 if (!torture_open_connection(&cli, 0)) {
2435 return False;
2436 }
2437
2438 printf("domain list:\n");
2439 cli_NetServerEnum(cli, cli->server_domain,
2440 SV_TYPE_DOMAIN_ENUM,
2441 browse_callback, NULL);
2442
2443 printf("machine list:\n");
2444 cli_NetServerEnum(cli, cli->server_domain,
2445 SV_TYPE_ALL,
2446 browse_callback, NULL);
2447
2448 if (!torture_close_connection(cli)) {
2449 correct = False;
2450 }
2451
2452 printf("browse test finished\n");
2453
2454 return correct;
2455
2456 }
2457
2458
2459 /*
2460 This checks how the getatr calls works
2461 */
2462 static bool run_attrtest(int dummy)
2463 {
2464 struct cli_state *cli;
2465 int fnum;
2466 time_t t, t2;
2467 const char *fname = "\\attrib123456789.tst";
2468 bool correct = True;
2469
2470 printf("starting attrib test\n");
2471
2472 if (!torture_open_connection(&cli, 0)) {
2473 return False;
2474 }
2475
2476 cli_unlink(cli, fname);
2477 fnum = cli_open(cli, fname,
2478 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2479 cli_close(cli, fnum);
2480 if (!cli_getatr(cli, fname, NULL, NULL, &t)) {
2481 printf("getatr failed (%s)\n", cli_errstr(cli));
2482 correct = False;
2483 }
2484
2485 if (abs(t - time(NULL)) > 60*60*24*10) {
2486 printf("ERROR: SMBgetatr bug. time is %s",
2487 ctime(&t));
2488 t = time(NULL);
2489 correct = True;
2490 }
2491
2492 t2 = t-60*60*24; /* 1 day ago */
2493
2494 if (!cli_setatr(cli, fname, 0, t2)) {
2495 printf("setatr failed (%s)\n", cli_errstr(cli));
2496 correct = True;
2497 }
2498
2499 if (!cli_getatr(cli, fname, NULL, NULL, &t)) {
2500 printf("getatr failed (%s)\n", cli_errstr(cli));
2501 correct = True;
2502 }
2503
2504 if (t != t2) {
2505 printf("ERROR: getatr/setatr bug. times are\n%s",
2506 ctime(&t));
2507 printf("%s", ctime(&t2));
2508 correct = True;
2509 }
2510
2511 cli_unlink(cli, fname);
2512
2513 if (!torture_close_connection(cli)) {
2514 correct = False;
2515 }
2516
2517 printf("attrib test finished\n");
2518
2519 return correct;
2520 }
2521
2522
2523 /*
2524 This checks a couple of trans2 calls
2525 */
2526 static bool run_trans2test(int dummy)
2527 {
2528 struct cli_state *cli;
2529 int fnum;
2530 SMB_OFF_T size;
2531 time_t c_time, a_time, m_time;
2532 struct timespec c_time_ts, a_time_ts, m_time_ts, w_time_ts, m_time2_ts;
2533 const char *fname = "\\trans2.tst";
2534 const char *dname = "\\trans2";
2535 const char *fname2 = "\\trans2\\trans2.tst";
2536 char pname[1024];
2537 bool correct = True;
2538
2539 printf("starting trans2 test\n");
2540
2541 if (!torture_open_connection(&cli, 0)) {
2542 return False;
2543 }
2544
2545 cli_unlink(cli, fname);
2546 fnum = cli_open(cli, fname,
2547 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2548 if (!cli_qfileinfo(cli, fnum, NULL, &size, &c_time_ts, &a_time_ts, &w_time_ts,
2549 &m_time_ts, NULL)) {
2550 printf("ERROR: qfileinfo failed (%s)\n", cli_errstr(cli));
2551 correct = False;
2552 }
2553
2554 if (!cli_qfilename(cli, fnum, pname, sizeof(pname))) {
2555 printf("ERROR: qfilename failed (%s)\n", cli_errstr(cli));
2556 correct = False;
2557 }
2558
2559 if (strcmp(pname, fname)) {
2560 printf("qfilename gave different name? [%s] [%s]\n",
2561 fname, pname);
2562 correct = False;
2563 }
2564
2565 cli_close(cli, fnum);
2566
2567 sleep(2);
2568
2569 cli_unlink(cli, fname);
2570 fnum = cli_open(cli, fname,
2571 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2572 if (fnum == -1) {
2573 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2574 return False;
2575 }
2576 cli_close(cli, fnum);
2577
2578 if (!cli_qpathinfo(cli, fname, &c_time, &a_time, &m_time, &size, NULL)) {
2579 printf("ERROR: qpathinfo failed (%s)\n", cli_errstr(cli));
2580 correct = False;
2581 } else {
2582 if (c_time != m_time) {
2583 printf("create time=%s", ctime(&c_time));
2584 printf("modify time=%s", ctime(&m_time));
2585 printf("This system appears to have sticky create times\n");
2586 }
2587 if (a_time % (60*60) == 0) {
2588 printf("access time=%s", ctime(&a_time));
2589 printf("This system appears to set a midnight access time\n");
2590 correct = False;
2591 }
2592
2593 if (abs(m_time - time(NULL)) > 60*60*24*7) {
2594 printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
2595 correct = False;
2596 }
2597 }
2598
2599
2600 cli_unlink(cli, fname);
2601 fnum = cli_open(cli, fname,
2602 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2603 cli_close(cli, fnum);
2604 if (!cli_qpathinfo2(cli, fname, &c_time_ts, &a_time_ts, &w_time_ts,
2605 &m_time_ts, &size, NULL, NULL)) {
2606 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2607 correct = False;
2608 } else {
2609 if (w_time_ts.tv_sec < 60*60*24*2) {
2610 printf("write time=%s", ctime(&w_time_ts.tv_sec));
2611 printf("This system appears to set a initial 0 write time\n");
2612 correct = False;
2613 }
2614 }
2615
2616 cli_unlink(cli, fname);
2617
2618
2619 /* check if the server updates the directory modification time
2620 when creating a new file */
2621 if (!cli_mkdir(cli, dname)) {
2622 printf("ERROR: mkdir failed (%s)\n", cli_errstr(cli));
2623 correct = False;
2624 }
2625 sleep(3);
2626 if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts, &w_time_ts,
2627 &m_time_ts, &size, NULL, NULL)) {
2628 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2629 correct = False;
2630 }
2631
2632 fnum = cli_open(cli, fname2,
2633 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2634 cli_write(cli, fnum, 0, (char *)&fnum, 0, sizeof(fnum));
2635 cli_close(cli, fnum);
2636 if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts, &w_time_ts,
2637 &m_time2_ts, &size, NULL, NULL)) {
2638 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2639 correct = False;
2640 } else {
2641 if (memcmp(&m_time_ts, &m_time2_ts, sizeof(struct timespec))
2642 == 0) {
2643 printf("This system does not update directory modification times\n");
2644 correct = False;
2645 }
2646 }
2647 cli_unlink(cli, fname2);
2648 cli_rmdir(cli, dname);
2649
2650 if (!torture_close_connection(cli)) {
2651 correct = False;
2652 }
2653
2654 printf("trans2 test finished\n");
2655
2656 return correct;
2657 }
2658
2659 /*
2660 This checks new W2K calls.
2661 */
2662
2663 static bool new_trans(struct cli_state *pcli, int fnum, int level)
2664 {
2665 char *buf = NULL;
2666 uint32 len;
2667 bool correct = True;
2668
2669 if (!cli_qfileinfo_test(pcli, fnum, level, &buf, &len)) {
2670 printf("ERROR: qfileinfo (%d) failed (%s)\n", level, cli_errstr(pcli));
2671 correct = False;
2672 } else {
2673 printf("qfileinfo: level %d, len = %u\n", level, len);
2674 dump_data(0, (uint8 *)buf, len);
2675 printf("\n");
2676 }
2677 SAFE_FREE(buf);
2678 return correct;
2679 }
2680
2681 static bool run_w2ktest(int dummy)
2682 {
2683 struct cli_state *cli;
2684 int fnum;
2685 const char *fname = "\\w2ktest\\w2k.tst";
2686 int level;
2687 bool correct = True;
2688
2689 printf("starting w2k test\n");
2690
2691 if (!torture_open_connection(&cli, 0)) {
2692 return False;
2693 }
2694
2695 fnum = cli_open(cli, fname,
2696 O_RDWR | O_CREAT , DENY_NONE);
2697
2698 for (level = 1004; level < 1040; level++) {
2699 new_trans(cli, fnum, level);
2700 }
2701
2702 cli_close(cli, fnum);
2703
2704 if (!torture_close_connection(cli)) {
2705 correct = False;
2706 }
2707
2708 printf("w2k test finished\n");
2709
2710 return correct;
2711 }
2712
2713
2714 /*
2715 this is a harness for some oplock tests
2716 */
2717 static bool run_oplock1(int dummy)
2718 {
2719 struct cli_state *cli1;
2720 const char *fname = "\\lockt1.lck";
2721 int fnum1;
2722 bool correct = True;
2723
2724 printf("starting oplock test 1\n");
2725
2726 if (!torture_open_connection(&cli1, 0)) {
2727 return False;
2728 }
2729
2730 cli_unlink(cli1, fname);
2731
2732 cli_sockopt(cli1, sockops);
2733
2734 cli1->use_oplocks = True;
2735
2736 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2737 if (fnum1 == -1) {
2738 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2739 return False;
2740 }
2741
2742 cli1->use_oplocks = False;
2743
2744 cli_unlink(cli1, fname);
2745 cli_unlink(cli1, fname);
2746
2747 if (!cli_close(cli1, fnum1)) {
2748 printf("close2 failed (%s)\n", cli_errstr(cli1));
2749 return False;
2750 }
2751
2752 if (!cli_unlink(cli1, fname)) {
2753 printf("unlink failed (%s)\n", cli_errstr(cli1));
2754 return False;
2755 }
2756
2757 if (!torture_close_connection(cli1)) {
2758 correct = False;
2759 }
2760
2761 printf("finished oplock test 1\n");
2762
2763 return correct;
2764 }
2765
2766 static bool run_oplock2(int dummy)
2767 {
2768 struct cli_state *cli1, *cli2;
2769 const char *fname = "\\lockt2.lck";
2770 int fnum1, fnum2;
2771 int saved_use_oplocks = use_oplocks;
2772 char buf[4];
2773 bool correct = True;
2774 volatile bool *shared_correct;
2775
2776 shared_correct = (volatile bool *)shm_setup(sizeof(bool));
2777 *shared_correct = True;
2778
2779 use_level_II_oplocks = True;
2780 use_oplocks = True;
2781
2782 printf("starting oplock test 2\n");
2783
2784 if (!torture_open_connection(&cli1, 0)) {
2785 use_level_II_oplocks = False;
2786 use_oplocks = saved_use_oplocks;
2787 return False;
2788 }
2789
2790 cli1->use_oplocks = True;
2791 cli1->use_level_II_oplocks = True;
2792
2793 if (!torture_open_connection(&cli2, 1)) {
2794 use_level_II_oplocks = False;
2795 use_oplocks = saved_use_oplocks;
2796 return False;
2797 }
2798
2799 cli2->use_oplocks = True;
2800 cli2->use_level_II_oplocks = True;
2801
2802 cli_unlink(cli1, fname);
2803
2804 cli_sockopt(cli1, sockops);
2805 cli_sockopt(cli2, sockops);
2806
2807 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2808 if (fnum1 == -1) {
2809 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2810 return False;
2811 }
2812
2813 /* Don't need the globals any more. */
2814 use_level_II_oplocks = False;
2815 use_oplocks = saved_use_oplocks;
2816
2817 if (fork() == 0) {
2818 /* Child code */
2819 fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
2820 if (fnum2 == -1) {
2821 printf("second open of %s failed (%s)\n", fname, cli_errstr(cli1));
2822 *shared_correct = False;
2823 exit(0);
2824 }
2825
2826 sleep(2);
2827
2828 if (!cli_close(cli2, fnum2)) {
2829 printf("close2 failed (%s)\n", cli_errstr(cli1));
2830 *shared_correct = False;
2831 }
2832
2833 exit(0);
2834 }
2835
2836 sleep(2);
2837
2838 /* Ensure cli1 processes the break. Empty file should always return 0
2839 * bytes. */
2840
2841 if (cli_read(cli1, fnum1, buf, 0, 4) != 0) {
2842 printf("read on fnum1 failed (%s)\n", cli_errstr(cli1));
2843 correct = False;
2844 }
2845
2846 /* Should now be at level II. */
2847 /* Test if sending a write locks causes a break to none. */
2848
2849 if (!cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK)) {
2850 printf("lock failed (%s)\n", cli_errstr(cli1));
2851 correct = False;
2852 }
2853
2854 cli_unlock(cli1, fnum1, 0, 4);
2855
2856 sleep(2);
2857
2858 if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
2859 printf("lock failed (%s)\n", cli_errstr(cli1));
2860 correct = False;
2861 }
2862
2863 cli_unlock(cli1, fnum1, 0, 4);
2864
2865 sleep(2);
2866
2867 cli_read(cli1, fnum1, buf, 0, 4);
2868
2869 #if 0
2870 if (cli_write(cli1, fnum1, 0, buf, 0, 4) != 4) {
2871 printf("write on fnum1 failed (%s)\n", cli_errstr(cli1));
2872 correct = False;
2873 }
2874 #endif
2875
2876 if (!cli_close(cli1, fnum1)) {
2877 printf("close1 failed (%s)\n", cli_errstr(cli1));
2878 correct = False;
2879 }
2880
2881 sleep(4);
2882
2883 if (!cli_unlink(cli1, fname)) {
2884 printf("unlink failed (%s)\n", cli_errstr(cli1));
2885 correct = False;
2886 }
2887
2888 if (!torture_close_connection(cli1)) {
2889 correct = False;
2890 }
2891
2892 if (!*shared_correct) {
2893 correct = False;
2894 }
2895
2896 printf("finished oplock test 2\n");
2897
2898 return correct;
2899 }
2900
2901 /* handler for oplock 3 tests */
2902 static bool oplock3_handler(struct cli_state *cli, int fnum, unsigned char level)
2903 {
2904 printf("got oplock break fnum=%d level=%d\n",
2905 fnum, level);
2906 return cli_oplock_ack(cli, fnum, level);
2907 }
2908
2909 static bool run_oplock3(int dummy)
2910 {
2911 struct cli_state *cli;
2912 const char *fname = "\\oplockt3.dat";
2913 int fnum;
2914 char buf[4] = "abcd";
2915 bool correct = True;
2916 volatile bool *shared_correct;
2917
2918 shared_correct = (volatile bool *)shm_setup(sizeof(bool));
2919 *shared_correct = True;
2920
2921 printf("starting oplock test 3\n");
2922
2923 if (fork() == 0) {
2924 /* Child code */
2925 use_oplocks = True;
2926 use_level_II_oplocks = True;
2927 if (!torture_open_connection(&cli, 0)) {
2928 *shared_correct = False;
2929 exit(0);
2930 }
2931 sleep(2);
2932 /* try to trigger a oplock break in parent */
2933 fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
2934 cli_write(cli, fnum, 0, buf, 0, 4);
2935 exit(0);
2936 }
2937
2938 /* parent code */
2939 use_oplocks = True;
2940 use_level_II_oplocks = True;
2941 if (!torture_open_connection(&cli, 1)) { /* other is forked */
2942 return False;
2943 }
2944 cli_oplock_handler(cli, oplock3_handler);
2945 fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
2946 cli_write(cli, fnum, 0, buf, 0, 4);
2947 cli_close(cli, fnum);
2948 fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
2949 cli->timeout = 20000;
2950 cli_receive_smb(cli);
2951 printf("finished oplock test 3\n");
2952
2953 return (correct && *shared_correct);
2954
2955 /* What are we looking for here? What's sucess and what's FAILURE? */
2956 }
2957
2958
2959
2960 /*
2961 Test delete on close semantics.
2962 */
2963 static bool run_deletetest(int dummy)
2964 {
2965 struct cli_state *cli1 = NULL;
2966 struct cli_state *cli2 = NULL;
2967 const char *fname = "\\delete.file";
2968 int fnum1 = -1;
2969 int fnum2 = -1;
2970 bool correct = True;
2971
2972 printf("starting delete test\n");
2973
2974 if (!torture_open_connection(&cli1, 0)) {
2975 return False;
2976 }
2977
2978 cli_sockopt(cli1, sockops);
2979
2980 /* Test 1 - this should delete the file on close. */
2981
2982 cli_setatr(cli1, fname, 0, 0);
2983 cli_unlink(cli1, fname);
2984
2985 fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
2986 0, FILE_OVERWRITE_IF,
2987 FILE_DELETE_ON_CLOSE, 0);
2988
2989 if (fnum1 == -1) {
2990 printf("[1] open of %s failed (%s)\n", fname, cli_errstr(cli1));
2991 correct = False;
2992 goto fail;
2993 }
2994
2995 #if 0 /* JRATEST */
2996 {
2997 uint32 *accinfo = NULL;
2998 uint32 len;
2999 cli_qfileinfo_test(cli1, fnum1, SMB_FILE_ACCESS_INFORMATION, (char **)&accinfo, &len);
3000 if (accinfo)
3001 printf("access mode = 0x%lx\n", *accinfo);
3002 SAFE_FREE(accinfo);
3003 }
3004 #endif
3005
3006 if (!cli_close(cli1, fnum1)) {
3007 printf("[1] close failed (%s)\n", cli_errstr(cli1));
3008 correct = False;
3009 goto fail;
3010 }
3011
3012 fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
3013 if (fnum1 != -1) {
3014 printf("[1] open of %s succeeded (should fail)\n", fname);
3015 correct = False;
3016 goto fail;
3017 }
3018
3019 printf("first delete on close test succeeded.\n");
3020
3021 /* Test 2 - this should delete the file on close. */
3022
3023 cli_setatr(cli1, fname, 0, 0);
3024 cli_unlink(cli1, fname);
3025
3026 fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_ALL_ACCESS,
3027 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
3028 FILE_OVERWRITE_IF, 0, 0);
3029
3030 if (fnum1 == -1) {
3031 printf("[2] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3032 correct = False;
3033 goto fail;
3034 }
3035
3036 if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3037 printf("[2] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3038 correct = False;
3039 goto fail;
3040 }
3041
3042 if (!cli_close(cli1, fnum1)) {
3043 printf("[2] close failed (%s)\n", cli_errstr(cli1));
3044 correct = False;
3045 goto fail;
3046 }
3047
3048 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3049 if (fnum1 != -1) {
3050 printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
3051 if (!cli_close(cli1, fnum1)) {
3052 printf("[2] close failed (%s)\n", cli_errstr(cli1));
3053 correct = False;
3054 goto fail;
3055 }
3056 cli_unlink(cli1, fname);
3057 } else
3058 printf("second delete on close test succeeded.\n");
3059
3060 /* Test 3 - ... */
3061 cli_setatr(cli1, fname, 0, 0);
3062 cli_unlink(cli1, fname);
3063
3064 fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
3065 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
3066
3067 if (fnum1 == -1) {
3068 printf("[3] open - 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3069 correct = False;
3070 goto fail;
3071 }
3072
3073 /* This should fail with a sharing violation - open for delete is only compatible
3074 with SHARE_DELETE. */
3075
3076 fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3077 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0, 0);
3078
3079 if (fnum2 != -1) {
3080 printf("[3] open - 2 of %s succeeded - should have failed.\n", fname);
3081 correct = False;
3082 goto fail;
3083 }
3084
3085 /* This should succeed. */
3086
3087 fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3088 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0);
3089
3090 if (fnum2 == -1) {
3091 printf("[3] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3092 correct = False;
3093 goto fail;
3094 }
3095
3096 if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3097 printf("[3] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3098 correct = False;
3099 goto fail;
3100 }
3101
3102 if (!cli_close(cli1, fnum1)) {
3103 printf("[3] close 1 failed (%s)\n", cli_errstr(cli1));
3104 correct = False;
3105 goto fail;
3106 }
3107
3108 if (!cli_close(cli1, fnum2)) {
3109 printf("[3] close 2 failed (%s)\n", cli_errstr(cli1));
3110 correct = False;
3111 goto fail;
3112 }
3113
3114 /* This should fail - file should no longer be there. */
3115
3116 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3117 if (fnum1 != -1) {
3118 printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
3119 if (!cli_close(cli1, fnum1)) {
3120 printf("[3] close failed (%s)\n", cli_errstr(cli1));
3121 }
3122 cli_unlink(cli1, fname);
3123 correct = False;
3124 goto fail;
3125 } else
3126 printf("third delete on close test succeeded.\n");
3127
3128 /* Test 4 ... */
3129 cli_setatr(cli1, fname, 0, 0);
3130 cli_unlink(cli1, fname);
3131
3132 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3133 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
3134
3135 if (fnum1 == -1) {
3136 printf("[4] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3137 correct = False;
3138 goto fail;
3139 }
3140
3141 /* This should succeed. */
3142 fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS,
3143 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0);
3144 if (fnum2 == -1) {
3145 printf("[4] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3146 correct = False;
3147 goto fail;
3148 }
3149
3150 if (!cli_close(cli1, fnum2)) {
3151 printf("[4] close - 1 failed (%s)\n", cli_errstr(cli1));
3152 correct = False;
3153 goto fail;
3154 }
3155
3156 if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3157 printf("[4] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3158 correct = False;
3159 goto fail;
3160 }
3161
3162 /* This should fail - no more opens once delete on close set. */
3163 fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS,
3164 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3165 FILE_OPEN, 0, 0);
3166 if (fnum2 != -1) {
3167 printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname );
3168 correct = False;
3169 goto fail;
3170 } else
3171 printf("fourth delete on close test succeeded.\n");
3172
3173 if (!cli_close(cli1, fnum1)) {
3174 printf("[4] close - 2 failed (%s)\n", cli_errstr(cli1));
3175 correct = False;
3176 goto fail;
3177 }
3178
3179 /* Test 5 ... */
3180 cli_setatr(cli1, fname, 0, 0);
3181 cli_unlink(cli1, fname);
3182
3183 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT, DENY_NONE);
3184 if (fnum1 == -1) {
3185 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3186 correct = False;
3187 goto fail;
3188 }
3189
3190 /* This should fail - only allowed on NT opens with DELETE access. */
3191
3192 if (cli_nt_delete_on_close(cli1, fnum1, True)) {
3193 printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
3194 correct = False;
3195 goto fail;
3196 }
3197
3198 if (!cli_close(cli1, fnum1)) {
3199 printf("[5] close - 2 failed (%s)\n", cli_errstr(cli1));
3200 correct = False;
3201 goto fail;
3202 }
3203
3204 printf("fifth delete on close test succeeded.\n");
3205
3206 /* Test 6 ... */
3207 cli_setatr(cli1, fname, 0, 0);
3208 cli_unlink(cli1, fname);
3209
3210 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
3211 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3212 FILE_OVERWRITE_IF, 0, 0);
3213
3214 if (fnum1 == -1) {
3215 printf("[6] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3216 correct = False;
3217 goto fail;
3218 }
3219
3220 /* This should fail - only allowed on NT opens with DELETE access. */
3221
3222 if (cli_nt_delete_on_close(cli1, fnum1, True)) {
3223 printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
3224 correct = False;
3225 goto fail;
3226 }
3227
3228 if (!cli_close(cli1, fnum1)) {
3229 printf("[6] close - 2 failed (%s)\n", cli_errstr(cli1));
3230 correct = False;
3231 goto fail;
3232 }
3233
3234 printf("sixth delete on close test succeeded.\n");
3235
3236 /* Test 7 ... */
3237 cli_setatr(cli1, fname, 0, 0);
3238 cli_unlink(cli1, fname);
3239
3240 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3241 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0);
3242
3243 if (fnum1 == -1) {
3244 printf("[7] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3245 correct = False;
3246 goto fail;
3247 }
3248
3249 if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3250 printf("[7] setting delete_on_close on file failed !\n");
3251 correct = False;
3252 goto fail;
3253 }
3254
3255 if (!cli_nt_delete_on_close(cli1, fnum1, False)) {
3256 printf("[7] unsetting delete_on_close on file failed !\n");
3257 correct = False;
3258 goto fail;
3259 }
3260
3261 if (!cli_close(cli1, fnum1)) {
3262 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3263 correct = False;
3264 goto fail;
3265 }
3266
3267 /* This next open should succeed - we reset the flag. */
3268
3269 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3270 if (fnum1 == -1) {
3271 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3272 correct = False;
3273 goto fail;
3274 }
3275
3276 if (!cli_close(cli1, fnum1)) {
3277 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3278 correct = False;
3279 goto fail;
3280 }
3281
3282 printf("seventh delete on close test succeeded.\n");
3283
3284 /* Test 7 ... */
3285 cli_setatr(cli1, fname, 0, 0);
3286 cli_unlink(cli1, fname);
3287
3288 if (!torture_open_connection(&cli2, 1)) {
3289 printf("[8] failed to open second connection.\n");
3290 correct = False;
3291 goto fail;
3292 }
3293
3294 cli_sockopt(cli1, sockops);
3295
3296 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3297 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3298 FILE_OVERWRITE_IF, 0, 0);
3299
3300 if (fnum1 == -1) {
3301 printf("[8] open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3302 correct = False;
3303 goto fail;
3304 }
3305
3306 fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3307 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3308 FILE_OPEN, 0, 0);
3309
3310 if (fnum2 == -1) {
3311 printf("[8] open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3312 correct = False;
3313 goto fail;
3314 }
3315
3316 if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3317 printf("[8] setting delete_on_close on file failed !\n");
3318 correct = False;
3319 goto fail;
3320 }
3321
3322 if (!cli_close(cli1, fnum1)) {
3323 printf("[8] close - 1 failed (%s)\n", cli_errstr(cli1));
3324 correct = False;
3325 goto fail;
3326 }
3327
3328 if (!cli_close(cli2, fnum2)) {
3329 printf("[8] close - 2 failed (%s)\n", cli_errstr(cli2));
3330 correct = False;
3331 goto fail;
3332 }
3333
3334 /* This should fail.. */
3335 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3336 if (fnum1 != -1) {
3337 printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
3338 goto fail;
3339 correct = False;
3340 } else
3341 printf("eighth delete on close test succeeded.\n");
3342
3343 /* This should fail - we need to set DELETE_ACCESS. */
3344 fnum1 = cli_nt_create_full(cli1, fname, 0,FILE_READ_DATA|FILE_WRITE_DATA,
3345 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0);
3346
3347 if (fnum1 != -1) {
3348 printf("[9] open of %s succeeded should have failed!\n", fname);
3349 correct = False;
3350 goto fail;
3351 }
3352
3353 printf("ninth delete on close test succeeded.\n");
3354
3355 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3356 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0);
3357 if (fnum1 == -1) {
3358 printf("[10] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3359 correct = False;
3360 goto fail;
3361 }
3362
3363 /* This should delete the file. */
3364 if (!cli_close(cli1, fnum1)) {
3365 printf("[10] close failed (%s)\n", cli_errstr(cli1));
3366 correct = False;
3367 goto fail;
3368 }
3369
3370 /* This should fail.. */
3371 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3372 if (fnum1 != -1) {
3373 printf("[10] open of %s succeeded should have been deleted on close !\n", fname);
3374 goto fail;
3375 correct = False;
3376 } else
3377 printf("tenth delete on close test succeeded.\n");
3378
3379 cli_setatr(cli1, fname, 0, 0);
3380 cli_unlink(cli1, fname);
3381
3382 /* What error do we get when attempting to open a read-only file with
3383 delete access ? */
3384
3385 /* Create a readonly file. */
3386 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
3387 FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3388 if (fnum1 == -1) {
3389 printf("[11] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3390 correct = False;
3391 goto fail;
3392 }
3393
3394 if (!cli_close(cli1, fnum1)) {
3395 printf("[11] close failed (%s)\n", cli_errstr(cli1));
3396 correct = False;
3397 goto fail;
3398 }
3399
3400 /* Now try open for delete access. */
3401 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_ATTRIBUTES|DELETE_ACCESS,
3402 0, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3403 FILE_OVERWRITE_IF, 0, 0);
3404
3405 if (fnum1 != -1) {
3406 printf("[11] open of %s succeeded should have been denied with ACCESS_DENIED!\n", fname);
3407 cli_close(cli1, fnum1);
3408 goto fail;
3409 correct = False;
3410 } else {
3411 NTSTATUS nterr = cli_nt_error(cli1);
3412 if (!NT_STATUS_EQUAL(nterr,NT_STATUS_ACCESS_DENIED)) {
3413 printf("[11] open of %s should have been denied with ACCESS_DENIED! Got error %s\n", fname, nt_errstr(nterr));
3414 goto fail;
3415 correct = False;
3416 } else {
3417 printf("eleventh delete on close test succeeded.\n");
3418 }
3419 }
3420
3421 printf("finished delete test\n");
3422
3423 fail:
3424 /* FIXME: This will crash if we aborted before cli2 got
3425 * intialized, because these functions don't handle
3426 * uninitialized connections. */
3427
3428 if (fnum1 != -1) cli_close(cli1, fnum1);
3429 if (fnum2 != -1) cli_close(cli1, fnum2);
3430 cli_setatr(cli1, fname, 0, 0);
3431 cli_unlink(cli1, fname);
3432
3433 if (cli1 && !torture_close_connection(cli1)) {
3434 correct = False;
3435 }
3436 if (cli2 && !torture_close_connection(cli2)) {
3437 correct = False;
3438 }
3439 return correct;
3440 }
3441
3442
3443 /*
3444 print out server properties
3445 */
3446 static bool run_properties(int dummy)
3447 {
3448 static struct cli_state *cli;
3449 bool correct = True;
3450
3451 printf("starting properties test\n");
3452
3453 ZERO_STRUCT(cli);
3454
3455 if (!torture_open_connection(&cli, 0)) {
3456 return False;
3457 }
3458
3459 cli_sockopt(cli, sockops);
3460
3461 d_printf("Capabilities 0x%08x\n", cli->capabilities);
3462
3463 if (!torture_close_connection(cli)) {
3464 correct = False;
3465 }
3466
3467 return correct;
3468 }
3469
3470
3471
3472 /* FIRST_DESIRED_ACCESS 0xf019f */
3473 #define FIRST_DESIRED_ACCESS FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\
3474 FILE_READ_EA| /* 0xf */ \
3475 FILE_WRITE_EA|FILE_READ_ATTRIBUTES| /* 0x90 */ \
3476 FILE_WRITE_ATTRIBUTES| /* 0x100 */ \
3477 DELETE_ACCESS|READ_CONTROL_ACCESS|\
3478 WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS /* 0xf0000 */
3479 /* SECOND_DESIRED_ACCESS 0xe0080 */
3480 #define SECOND_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
3481 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
3482 WRITE_OWNER_ACCESS /* 0xe0000 */
3483
3484 #if 0
3485 #define THIRD_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
3486 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
3487 FILE_READ_DATA|\
3488 WRITE_OWNER_ACCESS /* */
3489 #endif
3490
3491 /*
3492 Test ntcreate calls made by xcopy
3493 */
3494 static bool run_xcopy(int dummy)
3495 {
3496 static struct cli_state *cli1;
3497 const char *fname = "\\test.txt";
3498 bool correct = True;
3499 int fnum1, fnum2;
3500
3501 printf("starting xcopy test\n");
3502
3503 if (!torture_open_connection(&cli1, 0)) {
3504 return False;
3505 }
3506
3507 fnum1 = cli_nt_create_full(cli1, fname, 0,
3508 FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
3509 FILE_SHARE_NONE, FILE_OVERWRITE_IF,
3510 0x4044, 0);
3511
3512 if (fnum1 == -1) {
3513 printf("First open failed - %s\n", cli_errstr(cli1));
3514 return False;
3515 }
3516
3517 fnum2 = cli_nt_create_full(cli1, fname, 0,
3518 SECOND_DESIRED_ACCESS, 0,
3519 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN,
3520 0x200000, 0);
3521 if (fnum2 == -1) {
3522 printf("second open failed - %s\n", cli_errstr(cli1));
3523 return False;
3524 }
3525
3526 if (!torture_close_connection(cli1)) {
3527 correct = False;
3528 }
3529
3530 return correct;
3531 }
3532
3533 /*
3534 Test rename on files open with share delete and no share delete.
3535 */
3536 static bool run_rename(int dummy)
3537 {
3538 static struct cli_state *cli1;
3539 const char *fname = "\\test.txt";
3540 const char *fname1 = "\\test1.txt";
3541 bool correct = True;
3542 int fnum1;
3543
3544 printf("starting rename test\n");
3545
3546 if (!torture_open_connection(&cli1, 0)) {
3547 return False;
3548 }
3549
3550 cli_unlink(cli1, fname);
3551 cli_unlink(cli1, fname1);
3552 fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3553 FILE_SHARE_READ, FILE_OVERWRITE_IF, 0, 0);
3554
3555 if (fnum1 == -1) {
3556 printf("First open failed - %s\n", cli_errstr(cli1));
3557 return False;
3558 }
3559
3560 if (!cli_rename(cli1, fname, fname1)) {
3561 printf("First rename failed (SHARE_READ) (this is correct) - %s\n", cli_errstr(cli1));
3562 } else {
3563 printf("First rename succeeded (SHARE_READ) - this should have failed !\n");
3564 correct = False;
3565 }
3566
3567 if (!cli_close(cli1, fnum1)) {
3568 printf("close - 1 failed (%s)\n", cli_errstr(cli1));
3569 return False;
3570 }
3571
3572 cli_unlink(cli1, fname);
3573 cli_unlink(cli1, fname1);
3574 fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3575 #if 0
3576 FILE_SHARE_DELETE|FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3577 #else
3578 FILE_SHARE_DELETE|FILE_SHARE_READ, FILE_OVERWRITE_IF, 0, 0);
3579 #endif
3580
3581 if (fnum1 == -1) {
3582 printf("Second open failed - %s\n", cli_errstr(cli1));
3583 return False;
3584 }
3585
3586 if (!cli_rename(cli1, fname, fname1)) {
3587 printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", cli_errstr(cli1));
3588 correct = False;
3589 } else {
3590 printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n");
3591 }
3592
3593 if (!cli_close(cli1, fnum1)) {
3594 printf("close - 2 failed (%s)\n", cli_errstr(cli1));
3595 return False;
3596 }
3597
3598 cli_unlink(cli1, fname);
3599 cli_unlink(cli1, fname1);
3600
3601 fnum1 = cli_nt_create_full(cli1, fname, 0, READ_CONTROL_ACCESS, FILE_ATTRIBUTE_NORMAL,
3602 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3603
3604 if (fnum1 == -1) {
3605 printf("Third open failed - %s\n", cli_errstr(cli1));
3606 return False;
3607 }
3608
3609
3610 #if 0
3611 {
3612 int fnum2;
3613
3614 fnum2 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
3615 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3616
3617 if (fnum2 == -1) {
3618 printf("Fourth open failed - %s\n", cli_errstr(cli1));
3619 return False;
3620 }
3621 if (!cli_nt_delete_on_close(cli1, fnum2, True)) {
3622 printf("[8] setting delete_on_close on file failed !\n");
3623 return False;
3624 }
3625
3626 if (!cli_close(cli1, fnum2)) {
3627 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
3628 return False;
3629 }
3630 }
3631 #endif
3632
3633 if (!cli_rename(cli1, fname, fname1)) {
3634 printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", cli_errstr(cli1));
3635 correct = False;
3636 } else {
3637 printf("Third rename succeeded (SHARE_NONE)\n");
3638 }
3639
3640 if (!cli_close(cli1, fnum1)) {
3641 printf("close - 3 failed (%s)\n", cli_errstr(cli1));
3642 return False;
3643 }
3644
3645 cli_unlink(cli1, fname);
3646 cli_unlink(cli1, fname1);
3647
3648 /*----*/
3649
3650 fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3651 FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
3652
3653 if (fnum1 == -1) {
3654 printf("Fourth open failed - %s\n", cli_errstr(cli1));
3655 return False;
3656 }
3657
3658 if (!cli_rename(cli1, fname, fname1)) {
3659 printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", cli_errstr(cli1));
3660 } else {
3661 printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n");
3662 correct = False;
3663 }
3664
3665 if (!cli_close(cli1, fnum1)) {
3666 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
3667 return False;
3668 }
3669
3670 cli_unlink(cli1, fname);
3671 cli_unlink(cli1, fname1);
3672
3673 /*--*/
3674
3675 fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3676 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0);
3677
3678 if (fnum1 == -1) {
3679 printf("Fifth open failed - %s\n", cli_errstr(cli1));
3680 return False;
3681 }
3682
3683 if (!cli_rename(cli1, fname, fname1)) {
3684 printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n",
3685 cli_errstr(cli1));
3686 correct = False;
3687 } else {
3688 printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", cli_errstr(cli1));
3689 }
3690
3691 /*
3692 * Now check if the first name still exists ...
3693 */
3694
3695 /*fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3696 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0);
3697
3698 if (fnum2 == -1) {
3699 printf("Opening original file after rename of open file fails: %s\n",
3700 cli_errstr(cli1));
3701 }
3702 else {
3703 printf("Opening original file after rename of open file works ...\n");
3704 (void)cli_close(cli1, fnum2);
3705 } */
3706
3707 /*--*/
3708
3709
3710 if (!cli_close(cli1, fnum1)) {
3711 printf("close - 5 failed (%s)\n", cli_errstr(cli1));
3712 return False;
3713 }
3714
3715 cli_unlink(cli1, fname);
3716 cli_unlink(cli1, fname1);
3717
3718 if (!torture_close_connection(cli1)) {
3719 correct = False;
3720 }
3721
3722 return correct;
3723 }
3724
3725 static bool run_pipe_number(int dummy)
3726 {
3727 struct cli_state *cli1;
3728 const char *pipe_name = "\\SPOOLSS";
3729 int fnum;
3730 int num_pipes = 0;
3731
3732 printf("starting pipenumber test\n");
3733 if (!torture_open_connection(&cli1, 0)) {
3734 return False;
3735 }
3736
3737 cli_sockopt(cli1, sockops);
3738 while(1) {
3739 fnum = cli_nt_create_full(cli1, pipe_name, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
3740 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF, 0, 0);
3741
3742 if (fnum == -1) {
3743 printf("Open of pipe %s failed with error (%s)\n", pipe_name, cli_errstr(cli1));
3744 break;
3745 }
3746 num_pipes++;
3747 printf("\r%6d", num_pipes);
3748 }
3749
3750 printf("pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
3751 torture_close_connection(cli1);
3752 return True;
3753 }
3754
3755 /*
3756 Test open mode returns on read-only files.
3757 */
3758 static bool run_opentest(int dummy)
3759 {
3760 static struct cli_state *cli1;
3761 static struct cli_state *cli2;
3762 const char *fname = "\\readonly.file";
3763 int fnum1, fnum2;
3764 char buf[20];
3765 SMB_OFF_T fsize;
3766 bool correct = True;
3767 char *tmp_path;
3768
3769 printf("starting open test\n");
3770
3771 if (!torture_open_connection(&cli1, 0)) {
3772 return False;
3773 }
3774
3775 cli_setatr(cli1, fname, 0, 0);
3776 cli_unlink(cli1, fname);
3777
3778 cli_sockopt(cli1, sockops);
3779
3780 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
3781 if (fnum1 == -1) {
3782 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3783 return False;
3784 }
3785
3786 if (!cli_close(cli1, fnum1)) {
3787 printf("close2 failed (%s)\n", cli_errstr(cli1));
3788 return False;
3789 }
3790
3791 if (!cli_setatr(cli1, fname, aRONLY, 0)) {
3792 printf("cli_setatr failed (%s)\n", cli_errstr(cli1));
3793 return False;
3794 }
3795
3796 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_WRITE);
3797 if (fnum1 == -1) {
3798 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3799 return False;
3800 }
3801
3802 /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
3803 fnum2 = cli_open(cli1, fname, O_RDWR, DENY_ALL);
3804
3805 if (check_error(__LINE__, cli1, ERRDOS, ERRnoaccess,
3806 NT_STATUS_ACCESS_DENIED)) {
3807 printf("correct error code ERRDOS/ERRnoaccess returned\n");
3808 }
3809
3810 printf("finished open test 1\n");
3811
3812 cli_close(cli1, fnum1);
3813
3814 /* Now try not readonly and ensure ERRbadshare is returned. */
3815
3816 cli_setatr(cli1, fname, 0, 0);
3817
3818 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_WRITE);
3819 if (fnum1 == -1) {
3820 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3821 return False;
3822 }
3823
3824 /* This will fail - but the error should be ERRshare. */
3825 fnum2 = cli_open(cli1, fname, O_RDWR, DENY_ALL);
3826
3827 if (check_error(__LINE__, cli1, ERRDOS, ERRbadshare,
3828 NT_STATUS_SHARING_VIOLATION)) {
3829 printf("correct error code ERRDOS/ERRbadshare returned\n");
3830 }
3831
3832 if (!cli_close(cli1, fnum1)) {
3833 printf("close2 failed (%s)\n", cli_errstr(cli1));
3834 return False;
3835 }
3836
3837 cli_unlink(cli1, fname);
3838
3839 printf("finished open test 2\n");
3840
3841 /* Test truncate open disposition on file opened for read. */
3842
3843 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
3844 if (fnum1 == -1) {
3845 printf("(3) open (1) of %s failed (%s)\n", fname, cli_errstr(cli1));
3846 return False;
3847 }
3848
3849 /* write 20 bytes. */
3850
3851 memset(buf, '\0', 20);
3852
3853 if (cli_write(cli1, fnum1, 0, buf, 0, 20) != 20) {
3854 printf("write failed (%s)\n", cli_errstr(cli1));
3855 correct = False;
3856 }
3857
3858 if (!cli_close(cli1, fnum1)) {
3859 printf("(3) close1 failed (%s)\n", cli_errstr(cli1));
3860 return False;
3861 }
3862
3863 /* Ensure size == 20. */
3864 if (!cli_getatr(cli1, fname, NULL, &fsize, NULL)) {
3865 printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
3866 return False;
3867 }
3868
3869 if (fsize != 20) {
3870 printf("(3) file size != 20\n");
3871 return False;
3872 }
3873
3874 /* Now test if we can truncate a file opened for readonly. */
3875
3876 fnum1 = cli_open(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE);
3877 if (fnum1 == -1) {
3878 printf("(3) open (2) of %s failed (%s)\n", fname, cli_errstr(cli1));
3879 return False;
3880 }
3881
3882 if (!cli_close(cli1, fnum1)) {
3883 printf("close2 failed (%s)\n", cli_errstr(cli1));
3884 return False;
3885 }
3886
3887 /* Ensure size == 0. */
3888 if (!cli_getatr(cli1, fname, NULL, &fsize, NULL)) {
3889 printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
3890 return False;
3891 }
3892
3893 if (fsize != 0) {
3894 printf("(3) file size != 0\n");
3895 return False;
3896 }
3897 printf("finished open test 3\n");
3898
3899 cli_unlink(cli1, fname);
3900
3901
3902 printf("testing ctemp\n");
3903 fnum1 = cli_ctemp(cli1, "\\", &tmp_path);
3904 if (fnum1 == -1) {
3905 printf("ctemp failed (%s)\n", cli_errstr(cli1));
3906 return False;
3907 }
3908 printf("ctemp gave path %s\n", tmp_path);
3909 if (!cli_close(cli1, fnum1)) {
3910 printf("close of temp failed (%s)\n", cli_errstr(cli1));
3911 }
3912 if (!cli_unlink(cli1, tmp_path)) {
3913 printf("unlink of temp failed (%s)\n", cli_errstr(cli1));
3914 }
3915
3916 /* Test the non-io opens... */
3917
3918 if (!torture_open_connection(&cli2, 1)) {
3919 return False;
3920 }
3921
3922 cli_setatr(cli2, fname, 0, 0);
3923 cli_unlink(cli2, fname);
3924
3925 cli_sockopt(cli2, sockops);
3926
3927 printf("TEST #1 testing 2 non-io opens (no delete)\n");
3928
3929 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3930 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3931
3932 if (fnum1 == -1) {
3933 printf("test 1 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3934 return False;
3935 }
3936
3937 fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3938 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
3939
3940 if (fnum2 == -1) {
3941 printf("test 1 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3942 return False;
3943 }
3944
3945 if (!cli_close(cli1, fnum1)) {
3946 printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3947 return False;
3948 }
3949 if (!cli_close(cli2, fnum2)) {
3950 printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3951 return False;
3952 }
3953
3954 printf("non-io open test #1 passed.\n");
3955
3956 cli_unlink(cli1, fname);
3957
3958 printf("TEST #2 testing 2 non-io opens (first with delete)\n");
3959
3960 fnum1 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3961 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3962
3963 if (fnum1 == -1) {
3964 printf("test 2 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3965 return False;
3966 }
3967
3968 fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3969 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
3970
3971 if (fnum2 == -1) {
3972 printf("test 2 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3973 return False;
3974 }
3975
3976 if (!cli_close(cli1, fnum1)) {
3977 printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3978 return False;
3979 }
3980 if (!cli_close(cli2, fnum2)) {
3981 printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3982 return False;
3983 }
3984
3985 printf("non-io open test #2 passed.\n");
3986
3987 cli_unlink(cli1, fname);
3988
3989 printf("TEST #3 testing 2 non-io opens (second with delete)\n");
3990
3991 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3992 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3993
3994 if (fnum1 == -1) {
3995 printf("test 3 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3996 return False;
3997 }
3998
3999 fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4000 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
4001
4002 if (fnum2 == -1) {
4003 printf("test 3 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4004 return False;
4005 }
4006
4007 if (!cli_close(cli1, fnum1)) {
4008 printf("test 3 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4009 return False;
4010 }
4011 if (!cli_close(cli2, fnum2)) {
4012 printf("test 3 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4013 return False;
4014 }
4015
4016 printf("non-io open test #3 passed.\n");
4017
4018 cli_unlink(cli1, fname);
4019
4020 printf("TEST #4 testing 2 non-io opens (both with delete)\n");
4021
4022 fnum1 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4023 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
4024
4025 if (fnum1 == -1) {
4026 printf("test 4 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4027 return False;
4028 }
4029
4030 fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4031 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
4032
4033 if (fnum2 != -1) {
4034 printf("test 4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
4035 return False;
4036 }
4037
4038 printf("test 3 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
4039
4040 if (!cli_close(cli1, fnum1)) {
4041 printf("test 4 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4042 return False;
4043 }
4044
4045 printf("non-io open test #4 passed.\n");
4046
4047 cli_unlink(cli1, fname);
4048
4049 printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
4050
4051 fnum1 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4052 FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0);
4053
4054 if (fnum1 == -1) {
4055 printf("test 5 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4056 return False;
4057 }
4058
4059 fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4060 FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0);
4061
4062 if (fnum2 == -1) {
4063 printf("test 5 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4064 return False;
4065 }
4066
4067 if (!cli_close(cli1, fnum1)) {
4068 printf("test 5 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4069 return False;
4070 }
4071
4072 if (!cli_close(cli2, fnum2)) {
4073 printf("test 5 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4074 return False;
4075 }
4076
4077 printf("non-io open test #5 passed.\n");
4078
4079 printf("TEST #6 testing 1 non-io open, one io open\n");
4080
4081 cli_unlink(cli1, fname);
4082
4083 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
4084 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
4085
4086 if (fnum1 == -1) {
4087 printf("test 6 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4088 return False;
4089 }
4090
4091 fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4092 FILE_SHARE_READ, FILE_OPEN_IF, 0, 0);
4093
4094 if (fnum2 == -1) {
4095 printf("test 6 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4096 return False;
4097 }
4098
4099 if (!cli_close(cli1, fnum1)) {
4100 printf("test 6 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4101 return False;
4102 }
4103
4104 if (!cli_close(cli2, fnum2)) {
4105 printf("test 6 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4106 return False;
4107 }
4108
4109 printf("non-io open test #6 passed.\n");
4110
4111 printf("TEST #7 testing 1 non-io open, one io open with delete\n");
4112
4113 cli_unlink(cli1, fname);
4114
4115 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
4116 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
4117
4118 if (fnum1 == -1) {
4119 printf("test 7 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4120 return False;
4121 }
4122
4123 fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4124 FILE_SHARE_READ|FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0);
4125
4126 if (fnum2 != -1) {
4127 printf("test 7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
4128 return False;
4129 }
4130
4131 printf("test 7 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
4132
4133 if (!cli_close(cli1, fnum1)) {
4134 printf("test 7 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4135 return False;
4136 }
4137
4138 printf("non-io open test #7 passed.\n");
4139
4140 cli_unlink(cli1, fname);
4141
4142 if (!torture_close_connection(cli1)) {
4143 correct = False;
4144 }
4145 if (!torture_close_connection(cli2)) {
4146 correct = False;
4147 }
4148
4149 return correct;
4150 }
4151
4152 static uint32 open_attrs_table[] = {
4153 FILE_ATTRIBUTE_NORMAL,
4154 FILE_ATTRIBUTE_ARCHIVE,
4155 FILE_ATTRIBUTE_READONLY,
4156 FILE_ATTRIBUTE_HIDDEN,
4157 FILE_ATTRIBUTE_SYSTEM,
4158
4159 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY,
4160 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN,
4161 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,
4162 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
4163 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
4164 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
4165
4166 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
4167 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
4168 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
4169 FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM,
4170 };
4171
4172 struct trunc_open_results {
4173 unsigned int num;
4174 uint32 init_attr;
4175 uint32 trunc_attr;
4176 uint32 result_attr;
4177 };
4178
4179 static struct trunc_open_results attr_results[] = {
4180 { 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
4181 { 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
4182 { 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
4183 { 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
4184 { 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
4185 { 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
4186 { 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4187 { 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4188 { 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
4189 { 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4190 { 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4191 { 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
4192 { 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4193 { 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4194 { 104, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
4195 { 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4196 { 119, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4197 { 121, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
4198 { 170, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN },
4199 { 173, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM },
4200 { 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4201 { 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4202 { 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
4203 { 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4204 { 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4205 { 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
4206 };
4207
4208 static bool run_openattrtest(int dummy)
4209 {
4210 static struct cli_state *cli1;
4211 const char *fname = "\\openattr.file";
4212 int fnum1;
4213 bool correct = True;
4214 uint16 attr;
4215 unsigned int i, j, k, l;
4216
4217 printf("starting open attr test\n");
4218
4219 if (!torture_open_connection(&cli1, 0)) {
4220 return False;
4221 }
4222
4223 cli_sockopt(cli1, sockops);
4224
4225 for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32); i++) {
4226 cli_setatr(cli1, fname, 0, 0);
4227 cli_unlink(cli1, fname);
4228 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_WRITE_DATA, open_attrs_table[i],
4229 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
4230
4231 if (fnum1 == -1) {
4232 printf("open %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
4233 return False;
4234 }
4235
4236 if (!cli_close(cli1, fnum1)) {
4237 printf("close %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
4238 return False;
4239 }
4240
4241 for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32); j++) {
4242 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA, open_attrs_table[j],
4243 FILE_SHARE_NONE, FILE_OVERWRITE, 0, 0);
4244
4245 if (fnum1 == -1) {
4246 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
4247 if (attr_results[l].num == k) {
4248 printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
4249 k, open_attrs_table[i],
4250 open_attrs_table[j],
4251 fname, NT_STATUS_V(cli_nt_error(cli1)), cli_errstr(cli1));
4252 correct = False;
4253 }
4254 }
4255 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_ACCESS_DENIED)) {
4256 printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n",
4257 k, open_attrs_table[i], open_attrs_table[j],
4258 cli_errstr(cli1));
4259 correct = False;
4260 }
4261 #if 0
4262 printf("[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]);
4263 #endif
4264 k++;
4265 continue;
4266 }
4267
4268 if (!cli_close(cli1, fnum1)) {
4269 printf("close %d (2) of %s failed (%s)\n", j, fname, cli_errstr(cli1));
4270 return False;
4271 }
4272
4273 if (!cli_getatr(cli1, fname, &attr, NULL, NULL)) {
4274 printf("getatr(2) failed (%s)\n", cli_errstr(cli1));
4275 return False;
4276 }
4277
4278 #if 0
4279 printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
4280 k, open_attrs_table[i], open_attrs_table[j], attr );
4281 #endif
4282
4283 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
4284 if (attr_results[l].num == k) {
4285 if (attr != attr_results[l].result_attr ||
4286 open_attrs_table[i] != attr_results[l].init_attr ||
4287 open_attrs_table[j] != attr_results[l].trunc_attr) {
4288 printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
4289 open_attrs_table[i],
4290 open_attrs_table[j],
4291 (unsigned int)attr,
4292 attr_results[l].result_attr);
4293 correct = False;
4294 }
4295 break;
4296 }
4297 }
4298 k++;
4299 }
4300 }
4301
4302 cli_setatr(cli1, fname, 0, 0);
4303 cli_unlink(cli1, fname);
4304
4305 printf("open attr test %s.\n", correct ? "passed" : "failed");
4306
4307 if (!torture_close_connection(cli1)) {
4308 correct = False;
4309 }
4310 return correct;
4311 }
4312
4313 static void list_fn(const char *mnt, file_info *finfo, const char *name, void *state)
4314 {
4315
4316 }
4317
4318 /*
4319 test directory listing speed
4320 */
4321 static bool run_dirtest(int dummy)
4322 {
4323 int i;
4324 static struct cli_state *cli;
4325 int fnum;
4326 double t1;
4327 bool correct = True;
4328
4329 printf("starting directory test\n");
4330
4331 if (!torture_open_connection(&cli, 0)) {
4332 return False;
4333 }
4334
4335 cli_sockopt(cli, sockops);
4336
4337 srandom(0);
4338 for (i=0;i<torture_numops;i++) {
4339 fstring fname;
4340 slprintf(fname, sizeof(fname), "\\%x", (int)random());
4341 fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
4342 if (fnum == -1) {
4343 fprintf(stderr,"Failed to open %s\n", fname);
4344 return False;
4345 }
4346 cli_close(cli, fnum);
4347 }
4348
4349 t1 = end_timer();
4350
4351 printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
4352 printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
4353 printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
4354
4355 printf("dirtest core %g seconds\n", end_timer() - t1);
4356
4357 srandom(0);
4358 for (i=0;i<torture_numops;i++) {
4359 fstring fname;
4360 slprintf(fname, sizeof(fname), "\\%x", (int)random());
4361 cli_unlink(cli, fname);
4362 }
4363
4364 if (!torture_close_connection(cli)) {
4365 correct = False;
4366 }
4367
4368 printf("finished dirtest\n");
4369
4370 return correct;
4371 }
4372
4373 static void del_fn(const char *mnt, file_info *finfo, const char *mask, void *state)
4374 {
4375 struct cli_state *pcli = (struct cli_state *)state;
4376 fstring fname;
4377 slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name);
4378
4379 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
4380 return;
4381
4382 if (finfo->mode & aDIR) {
4383 if (!cli_rmdir(pcli, fname))
4384 printf("del_fn: failed to rmdir %s\n,", fname );
4385 } else {
4386 if (!cli_unlink(pcli, fname))
4387 printf("del_fn: failed to unlink %s\n,", fname );
4388 }
4389 }
4390
4391
4392 /*
4393 sees what IOCTLs are supported
4394 */
4395 bool torture_ioctl_test(int dummy)
4396 {
4397 static struct cli_state *cli;
4398 uint16 device, function;
4399 int fnum;
4400 const char *fname = "\\ioctl.dat";
4401 DATA_BLOB blob;
4402 NTSTATUS status;
4403
4404 if (!torture_open_connection(&cli, 0)) {
4405 return False;
4406 }
4407
4408 printf("starting ioctl test\n");
4409
4410 cli_unlink(cli, fname);
4411
4412 fnum = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
4413 if (fnum == -1) {
4414 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
4415 return False;
4416 }
4417
4418 status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob);
4419 printf("ioctl device info: %s\n", cli_errstr(cli));
4420
4421 status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob);
4422 printf("ioctl job info: %s\n", cli_errstr(cli));
4423
4424 for (device=0;device<0x100;device++) {
4425 printf("testing device=0x%x\n", device);
4426 for (function=0;function<0x100;function++) {
4427 uint32 code = (device<<16) | function;
4428
4429 status = cli_raw_ioctl(cli, fnum, code, &blob);
4430
4431 if (NT_STATUS_IS_OK(status)) {
4432 printf("ioctl 0x%x OK : %d bytes\n", (int)code,
4433 (int)blob.length);
4434 data_blob_free(&blob);
4435 }
4436 }
4437 }
4438
4439 if (!torture_close_connection(cli)) {
4440 return False;
4441 }
4442
4443 return True;
4444 }
4445
4446
4447 /*
4448 tries varients of chkpath
4449 */
4450 bool torture_chkpath_test(int dummy)
4451 {
4452 static struct cli_state *cli;
4453 int fnum;
4454 bool ret;
4455
4456 if (!torture_open_connection(&cli, 0)) {
4457 return False;
4458 }
4459
4460 printf("starting chkpath test\n");
4461
4462 /* cleanup from an old run */
4463 cli_rmdir(cli, "\\chkpath.dir\\dir2");
4464 cli_unlink(cli, "\\chkpath.dir\\*");
4465 cli_rmdir(cli, "\\chkpath.dir");
4466
4467 if (!cli_mkdir(cli, "\\chkpath.dir")) {
4468 printf("mkdir1 failed : %s\n", cli_errstr(cli));
4469 return False;
4470 }
4471
4472 if (!cli_mkdir(cli, "\\chkpath.dir\\dir2")) {
4473 printf("mkdir2 failed : %s\n", cli_errstr(cli));
4474 return False;
4475 }
4476
4477 fnum = cli_open(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
4478 if (fnum == -1) {
4479 printf("open1 failed (%s)\n", cli_errstr(cli));
4480 return False;
4481 }
4482 cli_close(cli, fnum);
4483
4484 if (!cli_chkpath(cli, "\\chkpath.dir")) {
4485 printf("chkpath1 failed: %s\n", cli_errstr(cli));
4486 ret = False;
4487 }
4488
4489 if (!cli_chkpath(cli, "\\chkpath.dir\\dir2")) {
4490 printf("chkpath2 failed: %s\n", cli_errstr(cli));
4491 ret = False;
4492 }
4493
4494 if (!cli_chkpath(cli, "\\chkpath.dir\\foo.txt")) {
4495 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
4496 NT_STATUS_NOT_A_DIRECTORY);
4497 } else {
4498 printf("* chkpath on a file should fail\n");
4499 ret = False;
4500 }
4501
4502 if (!cli_chkpath(cli, "\\chkpath.dir\\bar.txt")) {
4503 ret = check_error(__LINE__, cli, ERRDOS, ERRbadfile,
4504 NT_STATUS_OBJECT_NAME_NOT_FOUND);
4505 } else {
4506 printf("* chkpath on a non existant file should fail\n");
4507 ret = False;
4508 }
4509
4510 if (!cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt")) {
4511 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
4512 NT_STATUS_OBJECT_PATH_NOT_FOUND);
4513 } else {
4514 printf("* chkpath on a non existent component should fail\n");
4515 ret = False;
4516 }
4517
4518 cli_rmdir(cli, "\\chkpath.dir\\dir2");
4519 cli_unlink(cli, "\\chkpath.dir\\*");
4520 cli_rmdir(cli, "\\chkpath.dir");
4521
4522 if (!torture_close_connection(cli)) {
4523 return False;
4524 }
4525
4526 return ret;
4527 }
4528
4529 static bool run_eatest(int dummy)
4530 {
4531 static struct cli_state *cli;
4532 const char *fname = "\\eatest.txt";
4533 bool correct = True;
4534 int fnum, i;
4535 size_t num_eas;
4536 struct ea_struct *ea_list = NULL;
4537 TALLOC_CTX *mem_ctx = talloc_init("eatest");
4538
4539 printf("starting eatest\n");
4540
4541 if (!torture_open_connection(&cli, 0)) {
4542 talloc_destroy(mem_ctx);
4543 return False;
4544 }
4545
4546 cli_unlink(cli, fname);
4547 fnum = cli_nt_create_full(cli, fname, 0,
4548 FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
4549 FILE_SHARE_NONE, FILE_OVERWRITE_IF,
4550 0x4044, 0);
4551
4552 if (fnum == -1) {
4553 printf("open failed - %s\n", cli_errstr(cli));
4554 talloc_destroy(mem_ctx);
4555 return False;
4556 }
4557
4558 for (i = 0; i < 10; i++) {
4559 fstring ea_name, ea_val;
4560
4561 slprintf(ea_name, sizeof(ea_name), "EA_%d", i);
4562 memset(ea_val, (char)i+1, i+1);
4563 if (!cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1)) {
4564 printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
4565 talloc_destroy(mem_ctx);
4566 return False;
4567 }
4568 }
4569
4570 cli_close(cli, fnum);
4571 for (i = 0; i < 10; i++) {
4572 fstring ea_name, ea_val;
4573
4574 slprintf(ea_name, sizeof(ea_name), "EA_%d", i+10);
4575 memset(ea_val, (char)i+1, i+1);
4576 if (!cli_set_ea_path(cli, fname, ea_name, ea_val, i+1)) {
4577 printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
4578 talloc_destroy(mem_ctx);
4579 return False;
4580 }
4581 }
4582
4583 if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list)) {
4584 printf("ea_get list failed - %s\n", cli_errstr(cli));
4585 correct = False;
4586 }
4587
4588 printf("num_eas = %d\n", (int)num_eas);
4589
4590 if (num_eas != 20) {
4591 printf("Should be 20 EA's stored... failing.\n");
4592 correct = False;
4593 }
4594
4595 for (i = 0; i < num_eas; i++) {
4596 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
4597 dump_data(0, ea_list[i].value.data,
4598 ea_list[i].value.length);
4599 }
4600
4601 /* Setting EA's to zero length deletes them. Test this */
4602 printf("Now deleting all EA's - case indepenent....\n");
4603
4604 #if 1
4605 cli_set_ea_path(cli, fname, "", "", 0);
4606 #else
4607 for (i = 0; i < 20; i++) {
4608 fstring ea_name;
4609 slprintf(ea_name, sizeof(ea_name), "ea_%d", i);
4610 if (!cli_set_ea_path(cli, fname, ea_name, "", 0)) {
4611 printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
4612 talloc_destroy(mem_ctx);
4613 return False;
4614 }
4615 }
4616 #endif
4617
4618 if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list)) {
4619 printf("ea_get list failed - %s\n", cli_errstr(cli));
4620 correct = False;
4621 }
4622
4623 printf("num_eas = %d\n", (int)num_eas);
4624 for (i = 0; i < num_eas; i++) {
4625 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
4626 dump_data(0, ea_list[i].value.data,
4627 ea_list[i].value.length);
4628 }
4629
4630 if (num_eas != 0) {
4631 printf("deleting EA's failed.\n");
4632 correct = False;
4633 }
4634
4635 /* Try and delete a non existant EA. */
4636 if (!cli_set_ea_path(cli, fname, "foo", "", 0)) {
4637 printf("deleting non-existant EA 'foo' should succeed. %s\n", cli_errstr(cli));
4638 correct = False;
4639 }
4640
4641 talloc_destroy(mem_ctx);
4642 if (!torture_close_connection(cli)) {
4643 correct = False;
4644 }
4645
4646 return correct;
4647 }
4648
4649 static bool run_dirtest1(int dummy)
4650 {
4651 int i;
4652 static struct cli_state *cli;
4653 int fnum, num_seen;
4654 bool correct = True;
4655
4656 printf("starting directory test\n");
4657
4658 if (!torture_open_connection(&cli, 0)) {
4659 return False;
4660 }
4661
4662 cli_sockopt(cli, sockops);
4663
4664 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
4665 cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
4666 cli_rmdir(cli, "\\LISTDIR");
4667 cli_mkdir(cli, "\\LISTDIR");
4668
4669 /* Create 1000 files and 1000 directories. */
4670 for (i=0;i<1000;i++) {
4671 fstring fname;
4672 slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i);
4673 fnum = cli_nt_create_full(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
4674 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
4675 if (fnum == -1) {
4676 fprintf(stderr,"Failed to open %s\n", fname);
4677 return False;
4678 }
4679 cli_close(cli, fnum);
4680 }
4681 for (i=0;i<1000;i++) {
4682 fstring fname;
4683 slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i);
4684 if (!cli_mkdir(cli, fname)) {
4685 fprintf(stderr,"Failed to open %s\n", fname);
4686 return False;
4687 }
4688 }
4689
4690 /* Now ensure that doing an old list sees both files and directories. */
4691 num_seen = cli_list_old(cli, "\\LISTDIR\\*", aDIR, list_fn, NULL);
4692 printf("num_seen = %d\n", num_seen );
4693 /* We should see 100 files + 1000 directories + . and .. */
4694 if (num_seen != 2002)
4695 correct = False;
4696
4697 /* Ensure if we have the "must have" bits we only see the
4698 * relevent entries.
4699 */
4700 num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aDIR<<8)|aDIR, list_fn, NULL);
4701 printf("num_seen = %d\n", num_seen );
4702 if (num_seen != 1002)
4703 correct = False;
4704
4705 num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aARCH<<8)|aDIR, list_fn, NULL);
4706 printf("num_seen = %d\n", num_seen );
4707 if (num_seen != 1000)
4708 correct = False;
4709
4710 /* Delete everything. */
4711 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
4712 cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
4713 cli_rmdir(cli, "\\LISTDIR");
4714
4715 #if 0
4716 printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
4717 printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
4718 printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
4719 #endif
4720
4721 if (!torture_close_connection(cli)) {
4722 correct = False;
4723 }
4724
4725 printf("finished dirtest1\n");
4726
4727 return correct;
4728 }
4729
4730 static bool run_error_map_extract(int dummy) {
4731
4732 static struct cli_state *c_dos;
4733 static struct cli_state *c_nt;
4734 NTSTATUS status;
4735
4736 uint32 error;
4737
4738 uint32 flgs2, errnum;
4739 uint8 errclass;
4740
4741 NTSTATUS nt_status;
4742
4743 fstring user;
4744
4745 /* NT-Error connection */
4746
4747 if (!(c_nt = open_nbt_connection())) {
4748 return False;
4749 }
4750
4751 c_nt->use_spnego = False;
4752
4753 status = cli_negprot(c_nt);
4754
4755 if (!NT_STATUS_IS_OK(status)) {
4756 printf("%s rejected the NT-error negprot (%s)\n", host,
4757 nt_errstr(status));
4758 cli_shutdown(c_nt);
4759 return False;
4760 }
4761
4762 if (!NT_STATUS_IS_OK(cli_session_setup(c_nt, "", "", 0, "", 0,
4763 workgroup))) {
4764 printf("%s rejected the NT-error initial session setup (%s)\n",host, cli_errstr(c_nt));
4765 return False;
4766 }
4767
4768 /* DOS-Error connection */
4769
4770 if (!(c_dos = open_nbt_connection())) {
4771 return False;
4772 }
4773
4774 c_dos->use_spnego = False;
4775 c_dos->force_dos_errors = True;
4776
4777 status = cli_negprot(c_dos);
4778 if (!NT_STATUS_IS_OK(status)) {
4779 printf("%s rejected the DOS-error negprot (%s)\n", host,
4780 nt_errstr(status));
4781 cli_shutdown(c_dos);
4782 return False;
4783 }
4784
4785 if (!NT_STATUS_IS_OK(cli_session_setup(c_dos, "", "", 0, "", 0,
4786 workgroup))) {
4787 printf("%s rejected the DOS-error initial session setup (%s)\n",host, cli_errstr(c_dos));
4788 return False;
4789 }
4790
4791 for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) {
4792 fstr_sprintf(user, "%X", error);
4793
4794 if (NT_STATUS_IS_OK(cli_session_setup(c_nt, user,
4795 password, strlen(password),
4796 password, strlen(password),
4797 workgroup))) {
4798 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
4799 }
4800
4801 flgs2 = SVAL(c_nt->inbuf,smb_flg2);
4802
4803 /* Case #1: 32-bit NT errors */
4804 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
4805 nt_status = NT_STATUS(IVAL(c_nt->inbuf,smb_rcls));
4806 } else {
4807 printf("/** Dos error on NT connection! (%s) */\n",
4808 cli_errstr(c_nt));
4809 nt_status = NT_STATUS(0xc0000000);
4810 }
4811
4812 if (NT_STATUS_IS_OK(cli_session_setup(c_dos, user,
4813 password, strlen(password),
4814 password, strlen(password),
4815 workgroup))) {
4816 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
4817 }
4818 flgs2 = SVAL(c_dos->inbuf,smb_flg2), errnum;
4819
4820 /* Case #1: 32-bit NT errors */
4821 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
4822 printf("/** NT error on DOS connection! (%s) */\n",
4823 cli_errstr(c_nt));
4824 errnum = errclass = 0;
4825 } else {
4826 cli_dos_error(c_dos, &errclass, &errnum);
4827 }
4828
4829 if (NT_STATUS_V(nt_status) != error) {
4830 printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n",
4831 get_nt_error_c_code(NT_STATUS(error)),
4832 get_nt_error_c_code(nt_status));
4833 }
4834
4835 printf("\t{%s,\t%s,\t%s},\n",
4836 smb_dos_err_class(errclass),
4837 smb_dos_err_name(errclass, errnum),
4838 get_nt_error_c_code(NT_STATUS(error)));
4839 }
4840 return True;
4841 }
4842
4843 static bool run_sesssetup_bench(int dummy)
4844 {
4845 static struct cli_state *c;
4846 const char *fname = "\\file.dat";
4847 int fnum;
4848 NTSTATUS status;
4849 int i;
4850
4851 if (!torture_open_connection(&c, 0)) {
4852 return false;
4853 }
4854
4855 fnum = cli_nt_create_full(
4856 c, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
4857 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
4858 FILE_DELETE_ON_CLOSE, 0);
4859 if (fnum == -1) {
4860 d_printf("open %s failed: %s\n", fname, cli_errstr(c));
4861 return false;
4862 }
4863
4864 for (i=0; i<torture_numops; i++) {
4865 status = cli_session_setup(
4866 c, username,
4867 password, strlen(password),
4868 password, strlen(password),
4869 workgroup);
4870 if (!NT_STATUS_IS_OK(status)) {
4871 d_printf("(%s) cli_session_setup failed: %s\n",
4872 __location__, nt_errstr(status));
4873 return false;
4874 }
4875
4876 d_printf("\r%d ", (int)c->vuid);
4877
4878 if (!cli_ulogoff(c)) {
4879 d_printf("(%s) cli_ulogoff failed: %s\n",
4880 __location__, cli_errstr(c));
4881 return false;
4882 }
4883 c->vuid = 0;
4884 }
4885
4886 return true;
4887 }
4888
4889 static bool subst_test(const char *str, const char *user, const char *domain,
4890 uid_t uid, gid_t gid, const char *expected)
4891 {
4892 char *subst;
4893 bool result = true;
4894
4895 subst = talloc_sub_specified(talloc_tos(), str, user, domain, uid, gid);
4896
4897 if (strcmp(subst, expected) != 0) {
4898 printf("sub_specified(%s, %s, %s, %d, %d) returned [%s], expected "
4899 "[%s]\n", str, user, domain, (int)uid, (int)gid, subst,
4900 expected);
4901 result = false;
4902 }
4903
4904 TALLOC_FREE(subst);
4905 return result;
4906 }
4907
4908 static void chain1_open_completion(struct async_req *req)
4909 {
4910 int fnum;
4911 NTSTATUS status;
4912
4913 status = cli_open_recv(req, &fnum);
4914 TALLOC_FREE(req);
4915
4916 d_printf("cli_open_recv returned %s: %d\n",
4917 nt_errstr(status),
4918 NT_STATUS_IS_OK(status) ? fnum : -1);
4919 }
4920
4921 static void chain1_read_completion(struct async_req *req)
4922 {
4923 NTSTATUS status;
4924 ssize_t received;
4925 uint8_t *rcvbuf;
4926
4927 status = cli_read_andx_recv(req, &received, &rcvbuf);
4928 if (!NT_STATUS_IS_OK(status)) {
4929 TALLOC_FREE(req);
4930 d_printf("cli_read_andx_recv returned %s\n",
4931 nt_errstr(status));
4932 return;
4933 }
4934
4935 d_printf("got %d bytes: %.*s\n", (int)received, (int)received,
4936 (char *)rcvbuf);
4937 TALLOC_FREE(req);
4938 }
4939
4940 static void chain1_write_completion(struct async_req *req)
4941 {
4942 NTSTATUS status;
4943 size_t written;
4944
4945 status = cli_write_andx_recv(req, &written);
4946 if (!NT_STATUS_IS_OK(status)) {
4947 TALLOC_FREE(req);
4948 d_printf("cli_write_andx_recv returned %s\n",
4949 nt_errstr(status));
4950 return;
4951 }
4952
4953 d_printf("wrote %d bytes\n", (int)written);
4954 TALLOC_FREE(req);
4955 }
4956
4957 static void chain1_close_completion(struct async_req *req)
4958 {
4959 NTSTATUS status;
4960
4961 status = cli_close_recv(req);
4962 *((bool *)(req->async.priv)) = true;
4963
4964 TALLOC_FREE(req);
4965
4966 d_printf("cli_close returned %s\n", nt_errstr(status));
4967 }
4968
4969 static bool run_chain1(int dummy)
4970 {
4971 struct cli_state *cli1;
4972 struct event_context *evt = event_context_init(NULL);
4973 struct async_req *reqs[4];
4974 bool done = false;
4975 const char *text = "hallo";
4976
4977 printf("starting chain1 test\n");
4978 if (!torture_open_connection(&cli1, 0)) {
4979 return False;
4980 }
4981
4982 cli_sockopt(cli1, sockops);
4983
4984 cli_chain_cork(cli1, evt, 0);
4985 reqs[0] = cli_open_send(talloc_tos(), evt, cli1, "\\test",
4986 O_CREAT|O_RDWR, 0);
4987 reqs[0]->async.fn = chain1_open_completion;
4988 reqs[1] = cli_write_andx_send(talloc_tos(), evt, cli1, 0, 0,
4989 (uint8_t *)text, 0, strlen(text));
4990 reqs[1]->async.fn = chain1_write_completion;
4991 reqs[2] = cli_read_andx_send(talloc_tos(), evt, cli1, 0, 1, 10);
4992 reqs[2]->async.fn = chain1_read_completion;
4993 reqs[3] = cli_close_send(talloc_tos(), evt, cli1, 0);
4994 reqs[3]->async.fn = chain1_close_completion;
4995 reqs[3]->async.priv = (void *)&done;
4996 cli_chain_uncork(cli1);
4997
4998 while (!done) {
4999 event_loop_once(evt);
5000 }
5001
5002 torture_close_connection(cli1);
5003 return True;
5004 }
5005
5006 static size_t null_source(uint8_t *buf, size_t n, void *priv)
5007 {
5008 size_t *to_pull = (size_t *)priv;
5009 size_t thistime = *to_pull;
5010
5011 thistime = MIN(thistime, n);
5012 if (thistime == 0) {
5013 return 0;
5014 }
5015
5016 memset(buf, 0, thistime);
5017 *to_pull -= thistime;
5018 return thistime;
5019 }
5020
5021 static bool run_windows_write(int dummy)
5022 {
5023 struct cli_state *cli1;
5024 int fnum;
5025 int i;
5026 bool ret = false;
5027 const char *fname = "\\writetest.txt";
5028 double seconds;
5029 double kbytes;
5030
5031 printf("starting windows_write test\n");
5032 if (!torture_open_connection(&cli1, 0)) {
5033 return False;
5034 }
5035
5036 fnum = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
5037 if (fnum == -1) {
5038 printf("open failed (%s)\n", cli_errstr(cli1));
5039 return False;
5040 }
5041
5042 cli_sockopt(cli1, sockops);
5043
5044 start_timer();
5045
5046 for (i=0; i<torture_numops; i++) {
5047 char c = 0;
5048 off_t start = i * torture_blocksize;
5049 NTSTATUS status;
5050 size_t to_pull = torture_blocksize - 1;
5051
5052 if (cli_write(cli1, fnum, 0, &c,
5053 start + torture_blocksize - 1, 1) != 1) {
5054 printf("cli_write failed: %s\n", cli_errstr(cli1));
5055 goto fail;
5056 }
5057
5058 status = cli_push(cli1, fnum, 0, i * torture_blocksize, torture_blocksize,
5059 null_source, &to_pull);
5060 if (!NT_STATUS_IS_OK(status)) {
5061 printf("cli_push returned: %s\n", nt_errstr(status));
5062 goto fail;
5063 }
5064 }
5065
5066 seconds = end_timer();
5067 kbytes = (double)torture_blocksize * torture_numops;
5068 kbytes /= 1024;
5069
5070 printf("Wrote %d kbytes in %.2f seconds: %d kb/sec\n", (int)kbytes,
5071 (double)seconds, (int)(kbytes/seconds));
5072
5073 ret = true;
5074 fail:
5075 cli_close(cli1, fnum);
5076 cli_unlink(cli1, fname);
5077 torture_close_connection(cli1);
5078 return ret;
5079 }
5080
5081 static bool run_cli_echo(int dummy)
5082 {
5083 struct cli_state *cli;
5084 struct event_context *ev = event_context_init(NULL);
5085 struct async_req *req;
5086 NTSTATUS status;
5087
5088 printf("starting chain1 test\n");
5089 if (!torture_open_connection(&cli, 0)) {
5090 return false;
5091 }
5092 cli_sockopt(cli, sockops);
5093
5094 req = cli_echo_send(ev, ev, cli, 5, data_blob_const("hello", 5));
5095 if (req == NULL) {
5096 d_printf("cli_echo_send failed\n");
5097 return false;
5098 }
5099
5100 while (req->state < ASYNC_REQ_DONE) {
5101 event_loop_once(ev);
5102 }
5103
5104 status = cli_echo_recv(req);
5105 d_printf("cli_echo returned %s\n", nt_errstr(status));
5106
5107 TALLOC_FREE(req);
5108
5109 torture_close_connection(cli);
5110 return NT_STATUS_IS_OK(status);
5111 }
5112
5113 static bool run_local_substitute(int dummy)
5114 {
5115 bool ok = true;
5116
5117 ok &= subst_test("%U", "bla", "", -1, -1, "bla");
5118 ok &= subst_test("%u%U", "bla", "", -1, -1, "blabla");
5119 ok &= subst_test("%g", "", "", -1, -1, "NO_GROUP");
5120 ok &= subst_test("%G", "", "", -1, -1, "NO_GROUP");
5121 ok &= subst_test("%g", "", "", -1, 0, gidtoname(0));
5122 ok &= subst_test("%G", "", "", -1, 0, gidtoname(0));
5123 ok &= subst_test("%D%u", "u", "dom", -1, 0, "domu");
5124 ok &= subst_test("%i %I", "", "", -1, -1, "0.0.0.0 0.0.0.0");
5125
5126 /* Different captialization rules in sub_basic... */
5127
5128 ok &= (strcmp(talloc_sub_basic(talloc_tos(), "BLA", "dom", "%U%D"),
5129 "blaDOM") == 0);
5130
5131 return ok;
5132 }
5133
5134 static bool run_local_gencache(int dummy)
5135 {
5136 char *val;
5137 time_t tm;
5138 DATA_BLOB blob;
5139
5140 if (!gencache_init()) {
5141 d_printf("%s: gencache_init() failed\n", __location__);
5142 return False;
5143 }
5144
5145 if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
5146 d_printf("%s: gencache_set() failed\n", __location__);
5147 return False;
5148 }
5149
5150 if (!gencache_get("foo", &val, &tm)) {
5151 d_printf("%s: gencache_get() failed\n", __location__);
5152 return False;
5153 }
5154
5155 if (strcmp(val, "bar") != 0) {
5156 d_printf("%s: gencache_get() returned %s, expected %s\n",
5157 __location__, val, "bar");
5158 SAFE_FREE(val);
5159 return False;
5160 }
5161
5162 SAFE_FREE(val);
5163
5164 if (!gencache_del("foo")) {
5165 d_printf("%s: gencache_del() failed\n", __location__);
5166 return False;
5167 }
5168 if (gencache_del("foo")) {
5169 d_printf("%s: second gencache_del() succeeded\n",
5170 __location__);
5171 return False;
5172 }
5173
5174 if (gencache_get("foo", &val, &tm)) {
5175 d_printf("%s: gencache_get() on deleted entry "
5176 "succeeded\n", __location__);
5177 return False;
5178 }
5179
5180 blob = data_blob_string_const_null("bar");
5181 tm = time(NULL);
5182
5183 if (!gencache_set_data_blob("foo", &blob, tm)) {
5184 d_printf("%s: gencache_set_data_blob() failed\n", __location__);
5185 return False;
5186 }
5187
5188 data_blob_free(&blob);
5189
5190 if (!gencache_get_data_blob("foo", &blob, NULL)) {
5191 d_printf("%s: gencache_get_data_blob() failed\n", __location__);
5192 return False;
5193 }
5194
5195 if (strcmp((const char *)blob.data, "bar") != 0) {
5196 d_printf("%s: gencache_get_data_blob() returned %s, expected %s\n",
5197 __location__, (const char *)blob.data, "bar");
5198 data_blob_free(&blob);
5199 return False;
5200 }
5201
5202 data_blob_free(&blob);
5203
5204 if (!gencache_del("foo")) {
5205 d_printf("%s: gencache_del() failed\n", __location__);
5206 return False;
5207 }
5208 if (gencache_del("foo")) {
5209 d_printf("%s: second gencache_del() succeeded\n",
5210 __location__);
5211 return False;
5212 }
5213
5214 if (gencache_get_data_blob("foo", &blob, NULL)) {
5215 d_printf("%s: gencache_get_data_blob() on deleted entry "
5216 "succeeded\n", __location__);
5217 return False;
5218 }
5219
5220 if (!gencache_shutdown()) {
5221 d_printf("%s: gencache_shutdown() failed\n", __location__);
5222 return False;
5223 }
5224
5225 if (gencache_shutdown()) {
5226 d_printf("%s: second gencache_shutdown() succeeded\n",
5227 __location__);
5228 return False;
5229 }
5230
5231 return True;
5232 }
5233
5234 static bool rbt_testval(struct db_context *db, const char *key,
5235 const char *value)
5236 {
5237 struct db_record *rec;
5238 TDB_DATA data = string_tdb_data(value);
5239 bool ret = false;
5240 NTSTATUS status;
5241
5242 rec = db->fetch_locked(db, db, string_tdb_data(key));
5243 if (rec == NULL) {
5244 d_fprintf(stderr, "fetch_locked failed\n");
5245 goto done;
5246 }
5247 status = rec->store(rec, data, 0);
5248 if (!NT_STATUS_IS_OK(status)) {
5249 d_fprintf(stderr, "store failed: %s\n", nt_errstr(status));
5250 goto done;
5251 }
5252 TALLOC_FREE(rec);
5253
5254 rec = db->fetch_locked(db, db, string_tdb_data(key));
5255 if (rec == NULL) {
5256 d_fprintf(stderr, "second fetch_locked failed\n");
5257 goto done;
5258 }
5259 if ((rec->value.dsize != data.dsize)
5260 || (memcmp(rec->value.dptr, data.dptr, data.dsize) != 0)) {
5261 d_fprintf(stderr, "Got wrong data back\n");
5262 goto done;
5263 }
5264
5265 ret = true;
5266 done:
5267 TALLOC_FREE(rec);
5268 return ret;
5269 }
5270
5271 static bool run_local_rbtree(int dummy)
5272 {
5273 struct db_context *db;
5274 bool ret = false;
5275 int i;
5276
5277 db = db_open_rbt(NULL);
5278
5279 if (db == NULL) {
5280 d_fprintf(stderr, "db_open_rbt failed\n");
5281 return false;
5282 }
5283
5284 for (i=0; i<1000; i++) {
5285 char *key, *value;
5286
5287 if (asprintf(&key, "key%ld", random()) == -1) {
5288 goto done;
5289 }
5290 if (asprintf(&value, "value%ld", random()) == -1) {
5291 SAFE_FREE(key);
5292 goto done;
5293 }
5294
5295 if (!rbt_testval(db, key, value)) {
5296 SAFE_FREE(key);
5297 SAFE_FREE(value);
5298 goto done;
5299 }
5300
5301 SAFE_FREE(value);
5302 if (asprintf(&value, "value%ld", random()) == -1) {
5303 SAFE_FREE(key);
5304 goto done;
5305 }
5306
5307 if (!rbt_testval(db, key, value)) {
5308 SAFE_FREE(key);
5309 SAFE_FREE(value);
5310 goto done;
5311 }
5312
5313 SAFE_FREE(key);
5314 SAFE_FREE(value);
5315 }
5316
5317 ret = true;
5318
5319 done:
5320 TALLOC_FREE(db);
5321 return ret;
5322 }
5323
5324 static bool test_stream_name(const char *fname, const char *expected_base,
5325 const char *expected_stream,
5326 NTSTATUS expected_status)
5327 {
5328 NTSTATUS status;
5329 char *base = NULL;
5330 char *stream = NULL;
5331
5332 status = split_ntfs_stream_name(talloc_tos(), fname, &base, &stream);
5333 if (!NT_STATUS_EQUAL(status, expected_status)) {
5334 goto error;
5335 }
5336
5337 if (!NT_STATUS_IS_OK(status)) {
5338 return true;
5339 }
5340
5341 if (base == NULL) goto error;
5342
5343 if (strcmp(expected_base, base) != 0) goto error;
5344
5345 if ((expected_stream != NULL) && (stream == NULL)) goto error;
5346 if ((expected_stream == NULL) && (stream != NULL)) goto error;
5347
5348 if ((stream != NULL) && (strcmp(expected_stream, stream) != 0))
5349 goto error;
5350
5351 TALLOC_FREE(base);
5352 TALLOC_FREE(stream);
5353 return true;
5354
5355 error:
5356 d_fprintf(stderr, "test_stream(%s, %s, %s, %s)\n",
5357 fname, expected_base ? expected_base : "<NULL>",
5358 expected_stream ? expected_stream : "<NULL>",
5359 nt_errstr(expected_status));
5360 d_fprintf(stderr, "-> base=%s, stream=%s, status=%s\n",
5361 base ? base : "<NULL>", stream ? stream : "<NULL>",
5362 nt_errstr(status));
5363 TALLOC_FREE(base);
5364 TALLOC_FREE(stream);
5365 return false;
5366 }
5367
5368 static bool run_local_stream_name(int dummy)
5369 {
5370 bool ret = true;
5371
5372 ret &= test_stream_name(
5373 "bla", "bla", NULL, NT_STATUS_OK);
5374 ret &= test_stream_name(
5375 "bla::$DATA", "bla", NULL, NT_STATUS_OK);
5376 ret &= test_stream_name(
5377 "bla:blub:", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
5378 ret &= test_stream_name(
5379 "bla::", NULL, NULL, NT_STATUS_OBJECT_NAME_INVALID);
5380 ret &= test_stream_name(
5381 "bla::123", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
5382 ret &= test_stream_name(
5383 "bla:$DATA", "bla", "$DATA:$DATA", NT_STATUS_OK);
5384 ret &= test_stream_name(
5385 "bla:x:$DATA", "bla", "x:$DATA", NT_STATUS_OK);
5386 ret &= test_stream_name(
5387 "bla:x", "bla", "x:$DATA", NT_STATUS_OK);
5388
5389 return ret;
5390 }
5391
5392 static bool data_blob_equal(DATA_BLOB a, DATA_BLOB b)
5393 {
5394 if (a.length != b.length) {
5395 printf("a.length=%d != b.length=%d\n",
5396 (int)a.length, (int)b.length);
5397 return false;
5398 }
5399 if (memcmp(a.data, b.data, a.length) != 0) {
5400 printf("a.data and b.data differ\n");
5401 return false;
5402 }
5403 return true;
5404 }
5405
5406 static bool run_local_memcache(int dummy)
5407 {
5408 struct memcache *cache;
5409 DATA_BLOB k1, k2;
5410 DATA_BLOB d1, d2, d3;
5411 DATA_BLOB v1, v2, v3;
5412
5413 TALLOC_CTX *mem_ctx;
5414 char *str1, *str2;
5415 size_t size1, size2;
5416 bool ret = false;
5417
5418 cache = memcache_init(NULL, 100);
5419
5420 if (cache == NULL) {
5421 printf("memcache_init failed\n");
5422 return false;
5423 }
5424
5425 d1 = data_blob_const("d1", 2);
5426 d2 = data_blob_const("d2", 2);
5427 d3 = data_blob_const("d3", 2);
5428
5429 k1 = data_blob_const("d1", 2);
5430 k2 = data_blob_const("d2", 2);
5431
5432 memcache_add(cache, STAT_CACHE, k1, d1);
5433 memcache_add(cache, GETWD_CACHE, k2, d2);
5434
5435 if (!memcache_lookup(cache, STAT_CACHE, k1, &v1)) {
5436 printf("could not find k1\n");
5437 return false;
5438 }
5439 if (!data_blob_equal(d1, v1)) {
5440 return false;
5441 }
5442
5443 if (!memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
5444 printf("could not find k2\n");
5445 return false;
5446 }
5447 if (!data_blob_equal(d2, v2)) {
5448 return false;
5449 }
5450
5451 memcache_add(cache, STAT_CACHE, k1, d3);
5452
5453 if (!memcache_lookup(cache, STAT_CACHE, k1, &v3)) {
5454 printf("could not find replaced k1\n");
5455 return false;
5456 }
5457 if (!data_blob_equal(d3, v3)) {
5458 return false;
5459 }
5460
5461 memcache_add(cache, GETWD_CACHE, k1, d1);
5462
5463 if (memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
5464 printf("Did find k2, should have been purged\n");
5465 return false;
5466 }
5467
5468 TALLOC_FREE(cache);
5469
5470 cache = memcache_init(NULL, 0);
5471
5472 mem_ctx = talloc_init("foo");
5473
5474 str1 = talloc_strdup(mem_ctx, "string1");
5475 str2 = talloc_strdup(mem_ctx, "string2");
5476
5477 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
5478 data_blob_string_const("torture"), &str1);
5479 size1 = talloc_total_size(cache);
5480
5481 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
5482 data_blob_string_const("torture"), &str2);
5483 size2 = talloc_total_size(cache);
5484
5485 printf("size1=%d, size2=%d\n", (int)size1, (int)size2);
5486
5487 if (size2 > size1) {
5488 printf("memcache leaks memory!\n");
5489 goto fail;
5490 }
5491
5492 ret = true;
5493 fail:
5494 TALLOC_FREE(cache);
5495 return ret;
5496 }
5497
5498 static void wbclient_done(struct async_req *req)
5499 {
5500 NTSTATUS status;
5501 struct winbindd_response *wb_resp;
5502 int *i = (int *)req->async.priv;
5503
5504 status = wb_trans_recv(req, req, &wb_resp);
5505 TALLOC_FREE(req);
5506 *i += 1;
5507 d_printf("wb_trans_recv %d returned %s\n", *i, nt_errstr(status));
5508 }
5509
5510 static bool run_local_wbclient(int dummy)
5511 {
5512 struct event_context *ev;
5513 struct wb_context **wb_ctx;
5514 struct winbindd_request wb_req;
5515 bool result = false;
5516 int i, j;
5517
5518 BlockSignals(True, SIGPIPE);
5519
5520 ev = event_context_init(talloc_tos());
5521 if (ev == NULL) {
5522 goto fail;
5523 }
5524
5525 wb_ctx = TALLOC_ARRAY(ev, struct wb_context *, torture_numops);
5526 if (wb_ctx == NULL) {
5527 goto fail;
5528 }
5529
5530 ZERO_STRUCT(wb_req);
5531 wb_req.cmd = WINBINDD_PING;
5532
5533 for (i=0; i<torture_numops; i++) {
5534 wb_ctx[i] = wb_context_init(ev);
5535 if (wb_ctx[i] == NULL) {
5536 goto fail;
5537 }
5538 for (j=0; j<5; j++) {
5539 struct async_req *req;
5540 req = wb_trans_send(ev, ev, wb_ctx[i],
5541 (j % 2) == 0, &wb_req);
5542 if (req == NULL) {
5543 goto fail;
5544 }
5545 req->async.fn = wbclient_done;
5546 req->async.priv = &i;
5547 }
5548 }
5549
5550 i = 0;
5551
5552 while (i < 5 * torture_numops) {
5553 event_loop_once(ev);
5554 }
5555
5556 result = true;
5557 fail:
5558 TALLOC_FREE(ev);
5559 return result;
5560 }
5561
5562 static double create_procs(bool (*fn)(int), bool *result)
5563 {
5564 int i, status;
5565 volatile pid_t *child_status;
5566 volatile bool *child_status_out;
5567 int synccount;
5568 int tries = 8;
5569
5570 synccount = 0;
5571
5572 child_status = (volatile pid_t *)shm_setup(sizeof(pid_t)*nprocs);
5573 if (!child_status) {
5574 printf("Failed to setup shared memory\n");
5575 return -1;
5576 }
5577
5578 child_status_out = (volatile bool *)shm_setup(sizeof(bool)*nprocs);
5579 if (!child_status_out) {
5580 printf("Failed to setup result status shared memory\n");
5581 return -1;
5582 }
5583
5584 for (i = 0; i < nprocs; i++) {
5585 child_status[i] = 0;
5586 child_status_out[i] = True;
5587 }
5588
5589 start_timer();
5590
5591 for (i=0;i<nprocs;i++) {
5592 procnum = i;
5593 if (fork() == 0) {
5594 pid_t mypid = getpid();
5595 sys_srandom(((int)mypid) ^ ((int)time(NULL)));
5596
5597 slprintf(myname,sizeof(myname),"CLIENT%d", i);
5598
5599 while (1) {
5600 if (torture_open_connection(&current_cli, i)) break;
5601 if (tries-- == 0) {
5602 printf("pid %d failed to start\n", (int)getpid());
5603 _exit(1);
5604 }
5605 smb_msleep(10);
5606 }
5607
5608 child_status[i] = getpid();
5609
5610 while (child_status[i] && end_timer() < 5) smb_msleep(2);
5611
5612 child_status_out[i] = fn(i);
5613 _exit(0);
5614 }
5615 }
5616
5617 do {
5618 synccount = 0;
5619 for (i=0;i<nprocs;i++) {
5620 if (child_status[i]) synccount++;
5621 }
5622 if (synccount == nprocs) break;
5623 smb_msleep(10);
5624 } while (end_timer() < 30);
5625
5626 if (synccount != nprocs) {
5627 printf("FAILED TO START %d CLIENTS (started %d)\n", nprocs, synccount);
5628 *result = False;
5629 return end_timer();
5630 }
5631
5632 /* start the client load */
5633 start_timer();
5634
5635 for (i=0;i<nprocs;i++) {
5636 child_status[i] = 0;
5637 }
5638
5639 printf("%d clients started\n", nprocs);
5640
5641 for (i=0;i<nprocs;i++) {
5642 while (waitpid(0, &status, 0) == -1 && errno == EINTR) /* noop */ ;
5643 }
5644
5645 printf("\n");
5646
5647 for (i=0;i<nprocs;i++) {
5648 if (!child_status_out[i]) {
5649 *result = False;
5650 }
5651 }
5652 return end_timer();
5653 }
5654
5655 #define FLAG_MULTIPROC 1
5656
5657 static struct {
5658 const char *name;
5659 bool (*fn)(int);
5660 unsigned flags;
5661 } torture_ops[] = {
5662 {"FDPASS", run_fdpasstest, 0},
5663 {"LOCK1", run_locktest1, 0},
5664 {"LOCK2", run_locktest2, 0},
5665 {"LOCK3", run_locktest3, 0},
5666 {"LOCK4", run_locktest4, 0},
5667 {"LOCK5", run_locktest5, 0},
5668 {"LOCK6", run_locktest6, 0},
5669 {"LOCK7", run_locktest7, 0},
5670 {"UNLINK", run_unlinktest, 0},
5671 {"BROWSE", run_browsetest, 0},
5672 {"ATTR", run_attrtest, 0},
5673 {"TRANS2", run_trans2test, 0},
5674 {"MAXFID", run_maxfidtest, FLAG_MULTIPROC},
5675 {"TORTURE",run_torture, FLAG_MULTIPROC},
5676 {"RANDOMIPC", run_randomipc, 0},
5677 {"NEGNOWAIT", run_negprot_nowait, 0},
5678 {"NBENCH", run_nbench, 0},
5679 {"OPLOCK1", run_oplock1, 0},
5680 {"OPLOCK2", run_oplock2, 0},
5681 {"OPLOCK3", run_oplock3, 0},
5682 {"DIR", run_dirtest, 0},
5683 {"DIR1", run_dirtest1, 0},
5684 {"DENY1", torture_denytest1, 0},
5685 {"DENY2", torture_denytest2, 0},
5686 {"TCON", run_tcon_test, 0},
5687 {"TCONDEV", run_tcon_devtype_test, 0},
5688 {"RW1", run_readwritetest, 0},
5689 {"RW2", run_readwritemulti, FLAG_MULTIPROC},
5690 {"RW3", run_readwritelarge, 0},
5691 {"OPEN", run_opentest, 0},
5692 #if 1
5693 {"OPENATTR", run_openattrtest, 0},
5694 #endif
5695 {"XCOPY", run_xcopy, 0},
5696 {"RENAME", run_rename, 0},
5697 {"DELETE", run_deletetest, 0},
5698 {"PROPERTIES", run_properties, 0},
5699 {"MANGLE", torture_mangle, 0},
5700 {"W2K", run_w2ktest, 0},
5701 {"TRANS2SCAN", torture_trans2_scan, 0},
5702 {"NTTRANSSCAN", torture_nttrans_scan, 0},
5703 {"UTABLE", torture_utable, 0},
5704 {"CASETABLE", torture_casetable, 0},
5705 {"ERRMAPEXTRACT", run_error_map_extract, 0},
5706 {"PIPE_NUMBER", run_pipe_number, 0},
5707 {"TCON2", run_tcon2_test, 0},
5708 {"IOCTL", torture_ioctl_test, 0},
5709 {"CHKPATH", torture_chkpath_test, 0},
5710 {"FDSESS", run_fdsesstest, 0},
5711 { "EATEST", run_eatest, 0},
5712 { "SESSSETUP_BENCH", run_sesssetup_bench, 0},
5713 { "CHAIN1", run_chain1, 0},
5714 { "WINDOWS-WRITE", run_windows_write, 0},
5715 { "CLI_ECHO", run_cli_echo, 0},
5716 { "LOCAL-SUBSTITUTE", run_local_substitute, 0},
5717 { "LOCAL-GENCACHE", run_local_gencache, 0},
5718 { "LOCAL-RBTREE", run_local_rbtree, 0},
5719 { "LOCAL-MEMCACHE", run_local_memcache, 0},
5720 { "LOCAL-STREAM-NAME", run_local_stream_name, 0},
5721 { "LOCAL-WBCLIENT", run_local_wbclient, 0},
5722 {NULL, NULL, 0}};
5723
5724
5725
5726 /****************************************************************************
5727 run a specified test or "ALL"
5728 ****************************************************************************/
5729 static bool run_test(const char *name)
5730 {
5731 bool ret = True;
5732 bool result = True;
5733 bool found = False;
5734 int i;
5735 double t;
5736 if (strequal(name,"ALL")) {
5737 for (i=0;torture_ops[i].name;i++) {
5738 run_test(torture_ops[i].name);
5739 }
5740 found = True;
5741 }
5742
5743 for (i=0;torture_ops[i].name;i++) {
5744 fstr_sprintf(randomfname, "\\XX%x",
5745 (unsigned)random());
5746
5747 if (strequal(name, torture_ops[i].name)) {
5748 found = True;
5749 printf("Running %s\n", name);
5750 if (torture_ops[i].flags & FLAG_MULTIPROC) {
5751 t = create_procs(torture_ops[i].fn, &result);
5752 if (!result) {
5753 ret = False;
5754 printf("TEST %s FAILED!\n", name);
5755 }
5756
5757 } else {
5758 start_timer();
5759 if (!torture_ops[i].fn(0)) {
5760 ret = False;
5761 printf("TEST %s FAILED!\n", name);
5762 }
5763 t = end_timer();
5764 }
5765 printf("%s took %g secs\n\n", name, t);
5766 }
5767 }
5768
5769 if (!found) {
5770 printf("Did not find a test named %s\n", name);
5771 ret = False;
5772 }
5773
5774 return ret;
5775 }
5776
5777
5778 static void usage(void)
5779 {
5780 int i;
5781
5782 printf("WARNING samba4 test suite is much more complete nowadays.\n");
5783 printf("Please use samba4 torture.\n\n");
5784
5785 printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
5786
5787 printf("\t-d debuglevel\n");
5788 printf("\t-U user%%pass\n");
5789 printf("\t-k use kerberos\n");
5790 printf("\t-N numprocs\n");
5791 printf("\t-n my_netbios_name\n");
5792 printf("\t-W workgroup\n");
5793 printf("\t-o num_operations\n");
5794 printf("\t-O socket_options\n");
5795 printf("\t-m maximum protocol\n");
5796 printf("\t-L use oplocks\n");
5797 printf("\t-c CLIENT.TXT specify client load file for NBENCH\n");
5798 printf("\t-A showall\n");
5799 printf("\t-p port\n");
5800 printf("\t-s seed\n");
5801 printf("\t-b unclist_filename specify multiple shares for multiple connections\n");
5802 printf("\n\n");
5803
5804 printf("tests are:");
5805 for (i=0;torture_ops[i].name;i++) {
5806 printf(" %s", torture_ops[i].name);
5807 }
5808 printf("\n");
5809
5810 printf("default test is ALL\n");
5811
5812 exit(1);
5813 }
5814
5815 /****************************************************************************
5816 main program
5817 ****************************************************************************/
5818 int main(int argc,char *argv[])
5819 {
5820 int opt, i;
5821 char *p;
5822 int gotuser = 0;
5823 int gotpass = 0;
5824 bool correct = True;
5825 TALLOC_CTX *frame = talloc_stackframe();
5826 int seed = time(NULL);
5827
5828 dbf = x_stdout;
5829
5830 #ifdef HAVE_SETBUFFER
5831 setbuffer(stdout, NULL, 0);
5832 #endif
5833
5834 load_case_tables();
5835
5836 if (is_default_dyn_CONFIGFILE()) {
5837 if(getenv("SMB_CONF_PATH")) {
5838 set_dyn_CONFIGFILE(getenv("SMB_CONF_PATH"));
5839 }
5840 }
5841 lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
5842 load_interfaces();
5843
5844 if (argc < 2) {
5845 usage();
5846 }
5847
5848 for(p = argv[1]; *p; p++)
5849 if(*p == '\\')
5850 *p = '/';
5851
5852 if (strncmp(argv[1], "//", 2)) {
5853 usage();
5854 }
5855
5856 fstrcpy(host, &argv[1][2]);
5857 p = strchr_m(&host[2],'/');
5858 if (!p) {
5859 usage();
5860 }
5861 *p = 0;
5862 fstrcpy(share, p+1);
5863
5864 fstrcpy(myname, talloc_get_myname(talloc_tos()));
5865 if (!*myname) {
5866 fprintf(stderr, "Failed to get my hostname.\n");
5867 return 1;
5868 }
5869
5870 if (*username == 0 && getenv("LOGNAME")) {
5871 fstrcpy(username,getenv("LOGNAME"));
5872 }
5873
5874 argc--;
5875 argv++;
5876
5877 fstrcpy(workgroup, lp_workgroup());
5878
5879 while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ld:Aec:ks:b:B:")) != EOF) {
5880 switch (opt) {
5881 case 'p':
5882 port_to_use = atoi(optarg);
5883 break;
5884 case 's':
5885 seed = atoi(optarg);
5886 break;
5887 case 'W':
5888 fstrcpy(workgroup,optarg);
5889 break;
5890 case 'm':
5891 max_protocol = interpret_protocol(optarg, max_protocol);
5892 break;
5893 case 'N':
5894 nprocs = atoi(optarg);
5895 break;
5896 case 'o':
5897 torture_numops = atoi(optarg);
5898 break;
5899 case 'd':
5900 DEBUGLEVEL = atoi(optarg);
5901 break;
5902 case 'O':
5903 sockops = optarg;
5904 break;
5905 case 'L':
5906 use_oplocks = True;
5907 break;
5908 case 'A':
5909 torture_showall = True;
5910 break;
5911 case 'n':
5912 fstrcpy(myname, optarg);
5913 break;
5914 case 'c':
5915 client_txt = optarg;
5916 break;
5917 case 'e':
5918 do_encrypt = true;
5919 break;
5920 case 'k':
5921 #ifdef HAVE_KRB5
5922 use_kerberos = True;
5923 #else
5924 d_printf("No kerberos support compiled in\n");
5925 exit(1);
5926 #endif
5927 break;
5928 case 'U':
5929 gotuser = 1;
5930 fstrcpy(username,optarg);
5931 p = strchr_m(username,'%');
5932 if (p) {
5933 *p = 0;
5934 fstrcpy(password, p+1);
5935 gotpass = 1;
5936 }
5937 break;
5938 case 'b':
5939 fstrcpy(multishare_conn_fname, optarg);
5940 use_multishare_conn = True;
5941 break;
5942 case 'B':
5943 torture_blocksize = atoi(optarg);
5944 break;
5945 default:
5946 printf("Unknown option %c (%d)\n", (char)opt, opt);
5947 usage();
5948 }
5949 }
5950
5951 d_printf("using seed %d\n", seed);
5952
5953 srandom(seed);
5954
5955 if(use_kerberos && !gotuser) gotpass = True;
5956
5957 while (!gotpass) {
5958 p = getpass("Password:");
5959 if (p) {
5960 fstrcpy(password, p);
5961 gotpass = 1;
5962 }
5963 }
5964
5965 printf("host=%s share=%s user=%s myname=%s\n",
5966 host, share, username, myname);
5967
5968 if (argc == optind) {
5969 correct = run_test("ALL");
5970 } else {
5971 for (i=optind;i<argc;i++) {
5972 if (!run_test(argv[i])) {
5973 correct = False;
5974 }
5975 }
5976 }
5977
5978 TALLOC_FREE(frame);
5979
5980 if (correct) {
5981 return(0);
5982 } else {
5983 return(1);
5984 }
5985 }
Samba GIT mirror