Make memcache_add_talloc NULL out the source pointer
[Samba.git] / source / torture / torture.c
blob0bacc07fedceee6576a0e203c9e64b0b85eb635c
1 /*
2 Unix SMB/CIFS implementation.
3 SMB torture tester
4 Copyright (C) Andrew Tridgell 1997-1998
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.
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.
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/>.
20 #include "includes.h"
22 extern char *optarg;
23 extern int optind;
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 static int procnum; /* records process count number when forking */
32 static struct cli_state *current_cli;
33 static fstring randomfname;
34 static bool use_oplocks;
35 static bool use_level_II_oplocks;
36 static const char *client_txt = "client_oplocks.txt";
37 static bool use_kerberos;
38 static fstring multishare_conn_fname;
39 static bool use_multishare_conn = False;
40 static bool do_encrypt;
42 bool torture_showall = False;
44 static double create_procs(bool (*fn)(int), bool *result);
47 static struct timeval tp1,tp2;
50 void start_timer(void)
52 GetTimeOfDay(&tp1);
55 double end_timer(void)
57 GetTimeOfDay(&tp2);
58 return((tp2.tv_sec - tp1.tv_sec) +
59 (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
63 /* return a pointer to a anonymous shared memory segment of size "size"
64 which will persist across fork() but will disappear when all processes
65 exit
67 The memory is not zeroed
69 This function uses system5 shared memory. It takes advantage of a property
70 that the memory is not destroyed if it is attached when the id is removed
72 void *shm_setup(int size)
74 int shmid;
75 void *ret;
77 shmid = shmget(IPC_PRIVATE, size, S_IRUSR | S_IWUSR);
78 if (shmid == -1) {
79 printf("can't get shared memory\n");
80 exit(1);
82 ret = (void *)shmat(shmid, 0, 0);
83 if (!ret || ret == (void *)-1) {
84 printf("can't attach to shared memory\n");
85 return NULL;
87 /* the following releases the ipc, but note that this process
88 and all its children will still have access to the memory, its
89 just that the shmid is no longer valid for other shm calls. This
90 means we don't leave behind lots of shm segments after we exit
92 See Stevens "advanced programming in unix env" for details
94 shmctl(shmid, IPC_RMID, 0);
96 return ret;
99 /********************************************************************
100 Ensure a connection is encrypted.
101 ********************************************************************/
103 static bool force_cli_encryption(struct cli_state *c,
104 const char *sharename)
106 uint16 major, minor;
107 uint32 caplow, caphigh;
108 NTSTATUS status;
110 if (!SERVER_HAS_UNIX_CIFS(c)) {
111 d_printf("Encryption required and "
112 "server that doesn't support "
113 "UNIX extensions - failing connect\n");
114 return false;
117 if (!cli_unix_extensions_version(c, &major, &minor, &caplow, &caphigh)) {
118 d_printf("Encryption required and "
119 "can't get UNIX CIFS extensions "
120 "version from server.\n");
121 return false;
124 if (!(caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)) {
125 d_printf("Encryption required and "
126 "share %s doesn't support "
127 "encryption.\n", sharename);
128 return false;
131 if (c->use_kerberos) {
132 status = cli_gss_smb_encryption_start(c);
133 } else {
134 status = cli_raw_ntlm_smb_encryption_start(c,
135 username,
136 password,
137 workgroup);
140 if (!NT_STATUS_IS_OK(status)) {
141 d_printf("Encryption required and "
142 "setup failed with error %s.\n",
143 nt_errstr(status));
144 return false;
147 return true;
151 static struct cli_state *open_nbt_connection(void)
153 struct nmb_name called, calling;
154 struct sockaddr_storage ss;
155 struct cli_state *c;
156 NTSTATUS status;
158 make_nmb_name(&calling, myname, 0x0);
159 make_nmb_name(&called , host, 0x20);
161 zero_addr(&ss);
163 if (!(c = cli_initialise())) {
164 printf("Failed initialize cli_struct to connect with %s\n", host);
165 return NULL;
168 c->port = port_to_use;
170 status = cli_connect(c, host, &ss);
171 if (!NT_STATUS_IS_OK(status)) {
172 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
173 return NULL;
176 c->use_kerberos = use_kerberos;
178 c->timeout = 120000; /* set a really long timeout (2 minutes) */
179 if (use_oplocks) c->use_oplocks = True;
180 if (use_level_II_oplocks) c->use_level_II_oplocks = True;
182 if (!cli_session_request(c, &calling, &called)) {
184 * Well, that failed, try *SMBSERVER ...
185 * However, we must reconnect as well ...
187 status = cli_connect(c, host, &ss);
188 if (!NT_STATUS_IS_OK(status)) {
189 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
190 return NULL;
193 make_nmb_name(&called, "*SMBSERVER", 0x20);
194 if (!cli_session_request(c, &calling, &called)) {
195 printf("%s rejected the session\n",host);
196 printf("We tried with a called name of %s & %s\n",
197 host, "*SMBSERVER");
198 cli_shutdown(c);
199 return NULL;
203 return c;
206 /* Insert a NULL at the first separator of the given path and return a pointer
207 * to the remainder of the string.
209 static char *
210 terminate_path_at_separator(char * path)
212 char * p;
214 if (!path) {
215 return NULL;
218 if ((p = strchr_m(path, '/'))) {
219 *p = '\0';
220 return p + 1;
223 if ((p = strchr_m(path, '\\'))) {
224 *p = '\0';
225 return p + 1;
228 /* No separator. */
229 return NULL;
233 parse a //server/share type UNC name
235 bool smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
236 char **hostname, char **sharename)
238 char *p;
240 *hostname = *sharename = NULL;
242 if (strncmp(unc_name, "\\\\", 2) &&
243 strncmp(unc_name, "//", 2)) {
244 return False;
247 *hostname = talloc_strdup(mem_ctx, &unc_name[2]);
248 p = terminate_path_at_separator(*hostname);
250 if (p && *p) {
251 *sharename = talloc_strdup(mem_ctx, p);
252 terminate_path_at_separator(*sharename);
255 if (*hostname && *sharename) {
256 return True;
259 TALLOC_FREE(*hostname);
260 TALLOC_FREE(*sharename);
261 return False;
264 static bool torture_open_connection_share(struct cli_state **c,
265 const char *hostname,
266 const char *sharename)
268 bool retry;
269 int flags = 0;
270 NTSTATUS status;
272 if (use_kerberos)
273 flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
275 status = cli_full_connection(c, myname,
276 hostname, NULL, port_to_use,
277 sharename, "?????",
278 username, workgroup,
279 password, flags, Undefined, &retry);
280 if (!NT_STATUS_IS_OK(status)) {
281 printf("failed to open share connection: //%s/%s port:%d - %s\n",
282 hostname, sharename, port_to_use, nt_errstr(status));
283 return False;
286 if (use_oplocks) (*c)->use_oplocks = True;
287 if (use_level_II_oplocks) (*c)->use_level_II_oplocks = True;
288 (*c)->timeout = 120000; /* set a really long timeout (2 minutes) */
290 if (do_encrypt) {
291 return force_cli_encryption(*c,
292 sharename);
294 return True;
297 void torture_open_connection_free_unclist(char **unc_list)
299 if (unc_list!=NULL)
301 SAFE_FREE(unc_list[0]);
302 SAFE_FREE(unc_list);
306 bool torture_open_connection(struct cli_state **c, int conn_index)
308 char **unc_list = NULL;
309 int num_unc_names = 0;
310 bool result;
312 if (use_multishare_conn==True) {
313 char *h, *s;
314 unc_list = file_lines_load(multishare_conn_fname, &num_unc_names, 0);
315 if (!unc_list || num_unc_names <= 0) {
316 printf("Failed to load unc names list from '%s'\n", multishare_conn_fname);
317 exit(1);
320 if (!smbcli_parse_unc(unc_list[conn_index % num_unc_names],
321 NULL, &h, &s)) {
322 printf("Failed to parse UNC name %s\n",
323 unc_list[conn_index % num_unc_names]);
324 torture_open_connection_free_unclist(unc_list);
325 exit(1);
328 result = torture_open_connection_share(c, h, s);
330 /* h, s were copied earlier */
331 torture_open_connection_free_unclist(unc_list);
332 return result;
335 return torture_open_connection_share(c, host, share);
338 bool torture_cli_session_setup2(struct cli_state *cli, uint16 *new_vuid)
340 uint16 old_vuid = cli->vuid;
341 fstring old_user_name;
342 size_t passlen = strlen(password);
343 bool ret;
345 fstrcpy(old_user_name, cli->user_name);
346 cli->vuid = 0;
347 ret = NT_STATUS_IS_OK(cli_session_setup(cli, username,
348 password, passlen,
349 password, passlen,
350 workgroup));
351 *new_vuid = cli->vuid;
352 cli->vuid = old_vuid;
353 fstrcpy(cli->user_name, old_user_name);
354 return ret;
358 bool torture_close_connection(struct cli_state *c)
360 bool ret = True;
361 if (!cli_tdis(c)) {
362 printf("tdis failed (%s)\n", cli_errstr(c));
363 ret = False;
366 cli_shutdown(c);
368 return ret;
372 /* check if the server produced the expected error code */
373 static bool check_error(int line, struct cli_state *c,
374 uint8 eclass, uint32 ecode, NTSTATUS nterr)
376 if (cli_is_dos_error(c)) {
377 uint8 cclass;
378 uint32 num;
380 /* Check DOS error */
382 cli_dos_error(c, &cclass, &num);
384 if (eclass != cclass || ecode != num) {
385 printf("unexpected error code class=%d code=%d\n",
386 (int)cclass, (int)num);
387 printf(" expected %d/%d %s (line=%d)\n",
388 (int)eclass, (int)ecode, nt_errstr(nterr), line);
389 return False;
392 } else {
393 NTSTATUS status;
395 /* Check NT error */
397 status = cli_nt_error(c);
399 if (NT_STATUS_V(nterr) != NT_STATUS_V(status)) {
400 printf("unexpected error code %s\n", nt_errstr(status));
401 printf(" expected %s (line=%d)\n", nt_errstr(nterr), line);
402 return False;
406 return True;
410 static bool wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len)
412 while (!cli_lock(c, fnum, offset, len, -1, WRITE_LOCK)) {
413 if (!check_error(__LINE__, c, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
415 return True;
419 static bool rw_torture(struct cli_state *c)
421 const char *lockfname = "\\torture.lck";
422 fstring fname;
423 int fnum;
424 int fnum2;
425 pid_t pid2, pid = getpid();
426 int i, j;
427 char buf[1024];
428 bool correct = True;
430 memset(buf, '\0', sizeof(buf));
432 fnum2 = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
433 DENY_NONE);
434 if (fnum2 == -1)
435 fnum2 = cli_open(c, lockfname, O_RDWR, DENY_NONE);
436 if (fnum2 == -1) {
437 printf("open of %s failed (%s)\n", lockfname, cli_errstr(c));
438 return False;
442 for (i=0;i<torture_numops;i++) {
443 unsigned n = (unsigned)sys_random()%10;
444 if (i % 10 == 0) {
445 printf("%d\r", i); fflush(stdout);
447 slprintf(fname, sizeof(fstring) - 1, "\\torture.%u", n);
449 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
450 return False;
453 fnum = cli_open(c, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL);
454 if (fnum == -1) {
455 printf("open failed (%s)\n", cli_errstr(c));
456 correct = False;
457 break;
460 if (cli_write(c, fnum, 0, (char *)&pid, 0, sizeof(pid)) != sizeof(pid)) {
461 printf("write failed (%s)\n", cli_errstr(c));
462 correct = False;
465 for (j=0;j<50;j++) {
466 if (cli_write(c, fnum, 0, (char *)buf,
467 sizeof(pid)+(j*sizeof(buf)),
468 sizeof(buf)) != sizeof(buf)) {
469 printf("write failed (%s)\n", cli_errstr(c));
470 correct = False;
474 pid2 = 0;
476 if (cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid)) != sizeof(pid)) {
477 printf("read failed (%s)\n", cli_errstr(c));
478 correct = False;
481 if (pid2 != pid) {
482 printf("data corruption!\n");
483 correct = False;
486 if (!cli_close(c, fnum)) {
487 printf("close failed (%s)\n", cli_errstr(c));
488 correct = False;
491 if (!cli_unlink(c, fname)) {
492 printf("unlink failed (%s)\n", cli_errstr(c));
493 correct = False;
496 if (!cli_unlock(c, fnum2, n*sizeof(int), sizeof(int))) {
497 printf("unlock failed (%s)\n", cli_errstr(c));
498 correct = False;
502 cli_close(c, fnum2);
503 cli_unlink(c, lockfname);
505 printf("%d\n", i);
507 return correct;
510 static bool run_torture(int dummy)
512 struct cli_state *cli;
513 bool ret;
515 cli = current_cli;
517 cli_sockopt(cli, sockops);
519 ret = rw_torture(cli);
521 if (!torture_close_connection(cli)) {
522 ret = False;
525 return ret;
528 static bool rw_torture3(struct cli_state *c, char *lockfname)
530 int fnum = -1;
531 unsigned int i = 0;
532 char buf[131072];
533 char buf_rd[131072];
534 unsigned count;
535 unsigned countprev = 0;
536 ssize_t sent = 0;
537 bool correct = True;
539 srandom(1);
540 for (i = 0; i < sizeof(buf); i += sizeof(uint32))
542 SIVAL(buf, i, sys_random());
545 if (procnum == 0)
547 fnum = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
548 DENY_NONE);
549 if (fnum == -1) {
550 printf("first open read/write of %s failed (%s)\n",
551 lockfname, cli_errstr(c));
552 return False;
555 else
557 for (i = 0; i < 500 && fnum == -1; i++)
559 fnum = cli_open(c, lockfname, O_RDONLY,
560 DENY_NONE);
561 smb_msleep(10);
563 if (fnum == -1) {
564 printf("second open read-only of %s failed (%s)\n",
565 lockfname, cli_errstr(c));
566 return False;
570 i = 0;
571 for (count = 0; count < sizeof(buf); count += sent)
573 if (count >= countprev) {
574 printf("%d %8d\r", i, count);
575 fflush(stdout);
576 i++;
577 countprev += (sizeof(buf) / 20);
580 if (procnum == 0)
582 sent = ((unsigned)sys_random()%(20))+ 1;
583 if (sent > sizeof(buf) - count)
585 sent = sizeof(buf) - count;
588 if (cli_write(c, fnum, 0, buf+count, count, (size_t)sent) != sent) {
589 printf("write failed (%s)\n", cli_errstr(c));
590 correct = False;
593 else
595 sent = cli_read(c, fnum, buf_rd+count, count,
596 sizeof(buf)-count);
597 if (sent < 0)
599 printf("read failed offset:%d size:%ld (%s)\n",
600 count, (unsigned long)sizeof(buf)-count,
601 cli_errstr(c));
602 correct = False;
603 sent = 0;
605 if (sent > 0)
607 if (memcmp(buf_rd+count, buf+count, sent) != 0)
609 printf("read/write compare failed\n");
610 printf("offset: %d req %ld recvd %ld\n", count, (unsigned long)sizeof(buf)-count, (unsigned long)sent);
611 correct = False;
612 break;
619 if (!cli_close(c, fnum)) {
620 printf("close failed (%s)\n", cli_errstr(c));
621 correct = False;
624 return correct;
627 static bool rw_torture2(struct cli_state *c1, struct cli_state *c2)
629 const char *lockfname = "\\torture2.lck";
630 int fnum1;
631 int fnum2;
632 int i;
633 char buf[131072];
634 char buf_rd[131072];
635 bool correct = True;
636 ssize_t bytes_read;
638 if (!cli_unlink(c1, lockfname)) {
639 printf("unlink failed (%s) (normal, this file should not exist)\n", cli_errstr(c1));
642 fnum1 = cli_open(c1, lockfname, O_RDWR | O_CREAT | O_EXCL,
643 DENY_NONE);
644 if (fnum1 == -1) {
645 printf("first open read/write of %s failed (%s)\n",
646 lockfname, cli_errstr(c1));
647 return False;
649 fnum2 = cli_open(c2, lockfname, O_RDONLY,
650 DENY_NONE);
651 if (fnum2 == -1) {
652 printf("second open read-only of %s failed (%s)\n",
653 lockfname, cli_errstr(c2));
654 cli_close(c1, fnum1);
655 return False;
658 for (i=0;i<torture_numops;i++)
660 size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
661 if (i % 10 == 0) {
662 printf("%d\r", i); fflush(stdout);
665 generate_random_buffer((unsigned char *)buf, buf_size);
667 if (cli_write(c1, fnum1, 0, buf, 0, buf_size) != buf_size) {
668 printf("write failed (%s)\n", cli_errstr(c1));
669 correct = False;
670 break;
673 if ((bytes_read = cli_read(c2, fnum2, buf_rd, 0, buf_size)) != buf_size) {
674 printf("read failed (%s)\n", cli_errstr(c2));
675 printf("read %d, expected %ld\n", (int)bytes_read,
676 (unsigned long)buf_size);
677 correct = False;
678 break;
681 if (memcmp(buf_rd, buf, buf_size) != 0)
683 printf("read/write compare failed\n");
684 correct = False;
685 break;
689 if (!cli_close(c2, fnum2)) {
690 printf("close failed (%s)\n", cli_errstr(c2));
691 correct = False;
693 if (!cli_close(c1, fnum1)) {
694 printf("close failed (%s)\n", cli_errstr(c1));
695 correct = False;
698 if (!cli_unlink(c1, lockfname)) {
699 printf("unlink failed (%s)\n", cli_errstr(c1));
700 correct = False;
703 return correct;
706 static bool run_readwritetest(int dummy)
708 static struct cli_state *cli1, *cli2;
709 bool test1, test2 = False;
711 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
712 return False;
714 cli_sockopt(cli1, sockops);
715 cli_sockopt(cli2, sockops);
717 printf("starting readwritetest\n");
719 test1 = rw_torture2(cli1, cli2);
720 printf("Passed readwritetest v1: %s\n", BOOLSTR(test1));
722 if (test1) {
723 test2 = rw_torture2(cli1, cli1);
724 printf("Passed readwritetest v2: %s\n", BOOLSTR(test2));
727 if (!torture_close_connection(cli1)) {
728 test1 = False;
731 if (!torture_close_connection(cli2)) {
732 test2 = False;
735 return (test1 && test2);
738 static bool run_readwritemulti(int dummy)
740 struct cli_state *cli;
741 bool test;
743 cli = current_cli;
745 cli_sockopt(cli, sockops);
747 printf("run_readwritemulti: fname %s\n", randomfname);
748 test = rw_torture3(cli, randomfname);
750 if (!torture_close_connection(cli)) {
751 test = False;
754 return test;
757 static bool run_readwritelarge(int dummy)
759 static struct cli_state *cli1;
760 int fnum1;
761 const char *lockfname = "\\large.dat";
762 SMB_OFF_T fsize;
763 char buf[126*1024];
764 bool correct = True;
766 if (!torture_open_connection(&cli1, 0)) {
767 return False;
769 cli_sockopt(cli1, sockops);
770 memset(buf,'\0',sizeof(buf));
772 cli1->max_xmit = 128*1024;
774 printf("starting readwritelarge\n");
776 cli_unlink(cli1, lockfname);
778 fnum1 = cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE);
779 if (fnum1 == -1) {
780 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
781 return False;
784 cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf));
786 if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
787 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
788 correct = False;
791 if (fsize == sizeof(buf))
792 printf("readwritelarge test 1 succeeded (size = %lx)\n",
793 (unsigned long)fsize);
794 else {
795 printf("readwritelarge test 1 failed (size = %lx)\n",
796 (unsigned long)fsize);
797 correct = False;
800 if (!cli_close(cli1, fnum1)) {
801 printf("close failed (%s)\n", cli_errstr(cli1));
802 correct = False;
805 if (!cli_unlink(cli1, lockfname)) {
806 printf("unlink failed (%s)\n", cli_errstr(cli1));
807 correct = False;
810 fnum1 = cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE);
811 if (fnum1 == -1) {
812 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
813 return False;
816 cli1->max_xmit = 4*1024;
818 cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf));
820 if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
821 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
822 correct = False;
825 if (fsize == sizeof(buf))
826 printf("readwritelarge test 2 succeeded (size = %lx)\n",
827 (unsigned long)fsize);
828 else {
829 printf("readwritelarge test 2 failed (size = %lx)\n",
830 (unsigned long)fsize);
831 correct = False;
834 #if 0
835 /* ToDo - set allocation. JRA */
836 if(!cli_set_allocation_size(cli1, fnum1, 0)) {
837 printf("set allocation size to zero failed (%s)\n", cli_errstr(&cli1));
838 return False;
840 if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
841 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
842 correct = False;
844 if (fsize != 0)
845 printf("readwritelarge test 3 (truncate test) succeeded (size = %x)\n", fsize);
846 #endif
848 if (!cli_close(cli1, fnum1)) {
849 printf("close failed (%s)\n", cli_errstr(cli1));
850 correct = False;
853 if (!torture_close_connection(cli1)) {
854 correct = False;
856 return correct;
859 int line_count = 0;
860 int nbio_id;
862 #define ival(s) strtol(s, NULL, 0)
864 /* run a test that simulates an approximate netbench client load */
865 static bool run_netbench(int client)
867 struct cli_state *cli;
868 int i;
869 char line[1024];
870 char cname[20];
871 FILE *f;
872 const char *params[20];
873 bool correct = True;
875 cli = current_cli;
877 nbio_id = client;
879 cli_sockopt(cli, sockops);
881 nb_setup(cli);
883 slprintf(cname,sizeof(cname)-1, "client%d", client);
885 f = fopen(client_txt, "r");
887 if (!f) {
888 perror(client_txt);
889 return False;
892 while (fgets(line, sizeof(line)-1, f)) {
893 char *saveptr;
894 line_count++;
896 line[strlen(line)-1] = 0;
898 /* printf("[%d] %s\n", line_count, line); */
900 all_string_sub(line,"client1", cname, sizeof(line));
902 /* parse the command parameters */
903 params[0] = strtok_r(line, " ", &saveptr);
904 i = 0;
905 while (params[i]) params[++i] = strtok_r(NULL, " ", &saveptr);
907 params[i] = "";
909 if (i < 2) continue;
911 if (!strncmp(params[0],"SMB", 3)) {
912 printf("ERROR: You are using a dbench 1 load file\n");
913 exit(1);
916 if (!strcmp(params[0],"NTCreateX")) {
917 nb_createx(params[1], ival(params[2]), ival(params[3]),
918 ival(params[4]));
919 } else if (!strcmp(params[0],"Close")) {
920 nb_close(ival(params[1]));
921 } else if (!strcmp(params[0],"Rename")) {
922 nb_rename(params[1], params[2]);
923 } else if (!strcmp(params[0],"Unlink")) {
924 nb_unlink(params[1]);
925 } else if (!strcmp(params[0],"Deltree")) {
926 nb_deltree(params[1]);
927 } else if (!strcmp(params[0],"Rmdir")) {
928 nb_rmdir(params[1]);
929 } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
930 nb_qpathinfo(params[1]);
931 } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
932 nb_qfileinfo(ival(params[1]));
933 } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
934 nb_qfsinfo(ival(params[1]));
935 } else if (!strcmp(params[0],"FIND_FIRST")) {
936 nb_findfirst(params[1]);
937 } else if (!strcmp(params[0],"WriteX")) {
938 nb_writex(ival(params[1]),
939 ival(params[2]), ival(params[3]), ival(params[4]));
940 } else if (!strcmp(params[0],"ReadX")) {
941 nb_readx(ival(params[1]),
942 ival(params[2]), ival(params[3]), ival(params[4]));
943 } else if (!strcmp(params[0],"Flush")) {
944 nb_flush(ival(params[1]));
945 } else {
946 printf("Unknown operation %s\n", params[0]);
947 exit(1);
950 fclose(f);
952 nb_cleanup();
954 if (!torture_close_connection(cli)) {
955 correct = False;
958 return correct;
962 /* run a test that simulates an approximate netbench client load */
963 static bool run_nbench(int dummy)
965 double t;
966 bool correct = True;
968 nbio_shmem(nprocs);
970 nbio_id = -1;
972 signal(SIGALRM, nb_alarm);
973 alarm(1);
974 t = create_procs(run_netbench, &correct);
975 alarm(0);
977 printf("\nThroughput %g MB/sec\n",
978 1.0e-6 * nbio_total() / t);
979 return correct;
984 This test checks for two things:
986 1) correct support for retaining locks over a close (ie. the server
987 must not use posix semantics)
988 2) support for lock timeouts
990 static bool run_locktest1(int dummy)
992 struct cli_state *cli1, *cli2;
993 const char *fname = "\\lockt1.lck";
994 int fnum1, fnum2, fnum3;
995 time_t t1, t2;
996 unsigned lock_timeout;
998 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
999 return False;
1001 cli_sockopt(cli1, sockops);
1002 cli_sockopt(cli2, sockops);
1004 printf("starting locktest1\n");
1006 cli_unlink(cli1, fname);
1008 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1009 if (fnum1 == -1) {
1010 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1011 return False;
1013 fnum2 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1014 if (fnum2 == -1) {
1015 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli1));
1016 return False;
1018 fnum3 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1019 if (fnum3 == -1) {
1020 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli2));
1021 return False;
1024 if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
1025 printf("lock1 failed (%s)\n", cli_errstr(cli1));
1026 return False;
1030 if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
1031 printf("lock2 succeeded! This is a locking bug\n");
1032 return False;
1033 } else {
1034 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1035 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1039 lock_timeout = (1 + (random() % 20));
1040 printf("Testing lock timeout with timeout=%u\n", lock_timeout);
1041 t1 = time(NULL);
1042 if (cli_lock(cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK)) {
1043 printf("lock3 succeeded! This is a locking bug\n");
1044 return False;
1045 } else {
1046 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1047 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1049 t2 = time(NULL);
1051 if (ABS(t2 - t1) < lock_timeout-1) {
1052 printf("error: This server appears not to support timed lock requests\n");
1055 printf("server slept for %u seconds for a %u second timeout\n",
1056 (unsigned int)(t2-t1), lock_timeout);
1058 if (!cli_close(cli1, fnum2)) {
1059 printf("close1 failed (%s)\n", cli_errstr(cli1));
1060 return False;
1063 if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
1064 printf("lock4 succeeded! This is a locking bug\n");
1065 return False;
1066 } else {
1067 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1068 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1071 if (!cli_close(cli1, fnum1)) {
1072 printf("close2 failed (%s)\n", cli_errstr(cli1));
1073 return False;
1076 if (!cli_close(cli2, fnum3)) {
1077 printf("close3 failed (%s)\n", cli_errstr(cli2));
1078 return False;
1081 if (!cli_unlink(cli1, fname)) {
1082 printf("unlink failed (%s)\n", cli_errstr(cli1));
1083 return False;
1087 if (!torture_close_connection(cli1)) {
1088 return False;
1091 if (!torture_close_connection(cli2)) {
1092 return False;
1095 printf("Passed locktest1\n");
1096 return True;
1100 this checks to see if a secondary tconx can use open files from an
1101 earlier tconx
1103 static bool run_tcon_test(int dummy)
1105 static struct cli_state *cli;
1106 const char *fname = "\\tcontest.tmp";
1107 int fnum1;
1108 uint16 cnum1, cnum2, cnum3;
1109 uint16 vuid1, vuid2;
1110 char buf[4];
1111 bool ret = True;
1113 memset(buf, '\0', sizeof(buf));
1115 if (!torture_open_connection(&cli, 0)) {
1116 return False;
1118 cli_sockopt(cli, sockops);
1120 printf("starting tcontest\n");
1122 cli_unlink(cli, fname);
1124 fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1125 if (fnum1 == -1) {
1126 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1127 return False;
1130 cnum1 = cli->cnum;
1131 vuid1 = cli->vuid;
1133 if (cli_write(cli, fnum1, 0, buf, 130, 4) != 4) {
1134 printf("initial write failed (%s)", cli_errstr(cli));
1135 return False;
1138 if (!cli_send_tconX(cli, share, "?????",
1139 password, strlen(password)+1)) {
1140 printf("%s refused 2nd tree connect (%s)\n", host,
1141 cli_errstr(cli));
1142 cli_shutdown(cli);
1143 return False;
1146 cnum2 = cli->cnum;
1147 cnum3 = MAX(cnum1, cnum2) + 1; /* any invalid number */
1148 vuid2 = cli->vuid + 1;
1150 /* try a write with the wrong tid */
1151 cli->cnum = cnum2;
1153 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1154 printf("* server allows write with wrong TID\n");
1155 ret = False;
1156 } else {
1157 printf("server fails write with wrong TID : %s\n", cli_errstr(cli));
1161 /* try a write with an invalid tid */
1162 cli->cnum = cnum3;
1164 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1165 printf("* server allows write with invalid TID\n");
1166 ret = False;
1167 } else {
1168 printf("server fails write with invalid TID : %s\n", cli_errstr(cli));
1171 /* try a write with an invalid vuid */
1172 cli->vuid = vuid2;
1173 cli->cnum = cnum1;
1175 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1176 printf("* server allows write with invalid VUID\n");
1177 ret = False;
1178 } else {
1179 printf("server fails write with invalid VUID : %s\n", cli_errstr(cli));
1182 cli->cnum = cnum1;
1183 cli->vuid = vuid1;
1185 if (!cli_close(cli, fnum1)) {
1186 printf("close failed (%s)\n", cli_errstr(cli));
1187 return False;
1190 cli->cnum = cnum2;
1192 if (!cli_tdis(cli)) {
1193 printf("secondary tdis failed (%s)\n", cli_errstr(cli));
1194 return False;
1197 cli->cnum = cnum1;
1199 if (!torture_close_connection(cli)) {
1200 return False;
1203 return ret;
1208 checks for old style tcon support
1210 static bool run_tcon2_test(int dummy)
1212 static struct cli_state *cli;
1213 uint16 cnum, max_xmit;
1214 char *service;
1215 NTSTATUS status;
1217 if (!torture_open_connection(&cli, 0)) {
1218 return False;
1220 cli_sockopt(cli, sockops);
1222 printf("starting tcon2 test\n");
1224 asprintf(&service, "\\\\%s\\%s", host, share);
1226 status = cli_raw_tcon(cli, service, password, "?????", &max_xmit, &cnum);
1228 if (!NT_STATUS_IS_OK(status)) {
1229 printf("tcon2 failed : %s\n", cli_errstr(cli));
1230 } else {
1231 printf("tcon OK : max_xmit=%d cnum=%d tid=%d\n",
1232 (int)max_xmit, (int)cnum, SVAL(cli->inbuf, smb_tid));
1235 if (!torture_close_connection(cli)) {
1236 return False;
1239 printf("Passed tcon2 test\n");
1240 return True;
1243 static bool tcon_devtest(struct cli_state *cli,
1244 const char *myshare, const char *devtype,
1245 const char *return_devtype,
1246 NTSTATUS expected_error)
1248 bool status;
1249 bool ret;
1251 status = cli_send_tconX(cli, myshare, devtype,
1252 password, strlen(password)+1);
1254 if (NT_STATUS_IS_OK(expected_error)) {
1255 if (status) {
1256 if (strcmp(cli->dev, return_devtype) == 0) {
1257 ret = True;
1258 } else {
1259 printf("tconX to share %s with type %s "
1260 "succeeded but returned the wrong "
1261 "device type (got [%s] but should have got [%s])\n",
1262 myshare, devtype, cli->dev, return_devtype);
1263 ret = False;
1265 } else {
1266 printf("tconX to share %s with type %s "
1267 "should have succeeded but failed\n",
1268 myshare, devtype);
1269 ret = False;
1271 cli_tdis(cli);
1272 } else {
1273 if (status) {
1274 printf("tconx to share %s with type %s "
1275 "should have failed but succeeded\n",
1276 myshare, devtype);
1277 ret = False;
1278 } else {
1279 if (NT_STATUS_EQUAL(cli_nt_error(cli),
1280 expected_error)) {
1281 ret = True;
1282 } else {
1283 printf("Returned unexpected error\n");
1284 ret = False;
1288 return ret;
1292 checks for correct tconX support
1294 static bool run_tcon_devtype_test(int dummy)
1296 static struct cli_state *cli1 = NULL;
1297 bool retry;
1298 int flags = 0;
1299 NTSTATUS status;
1300 bool ret = True;
1302 status = cli_full_connection(&cli1, myname,
1303 host, NULL, port_to_use,
1304 NULL, NULL,
1305 username, workgroup,
1306 password, flags, Undefined, &retry);
1308 if (!NT_STATUS_IS_OK(status)) {
1309 printf("could not open connection\n");
1310 return False;
1313 if (!tcon_devtest(cli1, "IPC$", "A:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1314 ret = False;
1316 if (!tcon_devtest(cli1, "IPC$", "?????", "IPC", NT_STATUS_OK))
1317 ret = False;
1319 if (!tcon_devtest(cli1, "IPC$", "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1320 ret = False;
1322 if (!tcon_devtest(cli1, "IPC$", "IPC", "IPC", NT_STATUS_OK))
1323 ret = False;
1325 if (!tcon_devtest(cli1, "IPC$", "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1326 ret = False;
1328 if (!tcon_devtest(cli1, share, "A:", "A:", NT_STATUS_OK))
1329 ret = False;
1331 if (!tcon_devtest(cli1, share, "?????", "A:", NT_STATUS_OK))
1332 ret = False;
1334 if (!tcon_devtest(cli1, share, "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1335 ret = False;
1337 if (!tcon_devtest(cli1, share, "IPC", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1338 ret = False;
1340 if (!tcon_devtest(cli1, share, "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1341 ret = False;
1343 cli_shutdown(cli1);
1345 if (ret)
1346 printf("Passed tcondevtest\n");
1348 return ret;
1353 This test checks that
1355 1) the server supports multiple locking contexts on the one SMB
1356 connection, distinguished by PID.
1358 2) the server correctly fails overlapping locks made by the same PID (this
1359 goes against POSIX behaviour, which is why it is tricky to implement)
1361 3) the server denies unlock requests by an incorrect client PID
1363 static bool run_locktest2(int dummy)
1365 static struct cli_state *cli;
1366 const char *fname = "\\lockt2.lck";
1367 int fnum1, fnum2, fnum3;
1368 bool correct = True;
1370 if (!torture_open_connection(&cli, 0)) {
1371 return False;
1374 cli_sockopt(cli, sockops);
1376 printf("starting locktest2\n");
1378 cli_unlink(cli, fname);
1380 cli_setpid(cli, 1);
1382 fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1383 if (fnum1 == -1) {
1384 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1385 return False;
1388 fnum2 = cli_open(cli, fname, O_RDWR, DENY_NONE);
1389 if (fnum2 == -1) {
1390 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli));
1391 return False;
1394 cli_setpid(cli, 2);
1396 fnum3 = cli_open(cli, fname, O_RDWR, DENY_NONE);
1397 if (fnum3 == -1) {
1398 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli));
1399 return False;
1402 cli_setpid(cli, 1);
1404 if (!cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1405 printf("lock1 failed (%s)\n", cli_errstr(cli));
1406 return False;
1409 if (cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1410 printf("WRITE lock1 succeeded! This is a locking bug\n");
1411 correct = False;
1412 } else {
1413 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1414 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1417 if (cli_lock(cli, fnum2, 0, 4, 0, WRITE_LOCK)) {
1418 printf("WRITE lock2 succeeded! This is a locking bug\n");
1419 correct = False;
1420 } else {
1421 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1422 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1425 if (cli_lock(cli, fnum2, 0, 4, 0, READ_LOCK)) {
1426 printf("READ lock2 succeeded! This is a locking bug\n");
1427 correct = False;
1428 } else {
1429 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1430 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1433 if (!cli_lock(cli, fnum1, 100, 4, 0, WRITE_LOCK)) {
1434 printf("lock at 100 failed (%s)\n", cli_errstr(cli));
1436 cli_setpid(cli, 2);
1437 if (cli_unlock(cli, fnum1, 100, 4)) {
1438 printf("unlock at 100 succeeded! This is a locking bug\n");
1439 correct = False;
1442 if (cli_unlock(cli, fnum1, 0, 4)) {
1443 printf("unlock1 succeeded! This is a locking bug\n");
1444 correct = False;
1445 } else {
1446 if (!check_error(__LINE__, cli,
1447 ERRDOS, ERRlock,
1448 NT_STATUS_RANGE_NOT_LOCKED)) return False;
1451 if (cli_unlock(cli, fnum1, 0, 8)) {
1452 printf("unlock2 succeeded! This is a locking bug\n");
1453 correct = False;
1454 } else {
1455 if (!check_error(__LINE__, cli,
1456 ERRDOS, ERRlock,
1457 NT_STATUS_RANGE_NOT_LOCKED)) return False;
1460 if (cli_lock(cli, fnum3, 0, 4, 0, WRITE_LOCK)) {
1461 printf("lock3 succeeded! This is a locking bug\n");
1462 correct = False;
1463 } else {
1464 if (!check_error(__LINE__, cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
1467 cli_setpid(cli, 1);
1469 if (!cli_close(cli, fnum1)) {
1470 printf("close1 failed (%s)\n", cli_errstr(cli));
1471 return False;
1474 if (!cli_close(cli, fnum2)) {
1475 printf("close2 failed (%s)\n", cli_errstr(cli));
1476 return False;
1479 if (!cli_close(cli, fnum3)) {
1480 printf("close3 failed (%s)\n", cli_errstr(cli));
1481 return False;
1484 if (!torture_close_connection(cli)) {
1485 correct = False;
1488 printf("locktest2 finished\n");
1490 return correct;
1495 This test checks that
1497 1) the server supports the full offset range in lock requests
1499 static bool run_locktest3(int dummy)
1501 static struct cli_state *cli1, *cli2;
1502 const char *fname = "\\lockt3.lck";
1503 int fnum1, fnum2, i;
1504 uint32 offset;
1505 bool correct = True;
1507 #define NEXT_OFFSET offset += (~(uint32)0) / torture_numops
1509 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1510 return False;
1512 cli_sockopt(cli1, sockops);
1513 cli_sockopt(cli2, sockops);
1515 printf("starting locktest3\n");
1517 cli_unlink(cli1, fname);
1519 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1520 if (fnum1 == -1) {
1521 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1522 return False;
1524 fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1525 if (fnum2 == -1) {
1526 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli2));
1527 return False;
1530 for (offset=i=0;i<torture_numops;i++) {
1531 NEXT_OFFSET;
1532 if (!cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1533 printf("lock1 %d failed (%s)\n",
1535 cli_errstr(cli1));
1536 return False;
1539 if (!cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1540 printf("lock2 %d failed (%s)\n",
1542 cli_errstr(cli1));
1543 return False;
1547 for (offset=i=0;i<torture_numops;i++) {
1548 NEXT_OFFSET;
1550 if (cli_lock(cli1, fnum1, offset-2, 1, 0, WRITE_LOCK)) {
1551 printf("error: lock1 %d succeeded!\n", i);
1552 return False;
1555 if (cli_lock(cli2, fnum2, offset-1, 1, 0, WRITE_LOCK)) {
1556 printf("error: lock2 %d succeeded!\n", i);
1557 return False;
1560 if (cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1561 printf("error: lock3 %d succeeded!\n", i);
1562 return False;
1565 if (cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1566 printf("error: lock4 %d succeeded!\n", i);
1567 return False;
1571 for (offset=i=0;i<torture_numops;i++) {
1572 NEXT_OFFSET;
1574 if (!cli_unlock(cli1, fnum1, offset-1, 1)) {
1575 printf("unlock1 %d failed (%s)\n",
1577 cli_errstr(cli1));
1578 return False;
1581 if (!cli_unlock(cli2, fnum2, offset-2, 1)) {
1582 printf("unlock2 %d failed (%s)\n",
1584 cli_errstr(cli1));
1585 return False;
1589 if (!cli_close(cli1, fnum1)) {
1590 printf("close1 failed (%s)\n", cli_errstr(cli1));
1591 return False;
1594 if (!cli_close(cli2, fnum2)) {
1595 printf("close2 failed (%s)\n", cli_errstr(cli2));
1596 return False;
1599 if (!cli_unlink(cli1, fname)) {
1600 printf("unlink failed (%s)\n", cli_errstr(cli1));
1601 return False;
1604 if (!torture_close_connection(cli1)) {
1605 correct = False;
1608 if (!torture_close_connection(cli2)) {
1609 correct = False;
1612 printf("finished locktest3\n");
1614 return correct;
1617 #define EXPECTED(ret, v) if ((ret) != (v)) { \
1618 printf("** "); correct = False; \
1622 looks at overlapping locks
1624 static bool run_locktest4(int dummy)
1626 static struct cli_state *cli1, *cli2;
1627 const char *fname = "\\lockt4.lck";
1628 int fnum1, fnum2, f;
1629 bool ret;
1630 char buf[1000];
1631 bool correct = True;
1633 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1634 return False;
1637 cli_sockopt(cli1, sockops);
1638 cli_sockopt(cli2, sockops);
1640 printf("starting locktest4\n");
1642 cli_unlink(cli1, fname);
1644 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1645 fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1647 memset(buf, 0, sizeof(buf));
1649 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1650 printf("Failed to create file\n");
1651 correct = False;
1652 goto fail;
1655 ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1656 cli_lock(cli1, fnum1, 2, 4, 0, WRITE_LOCK);
1657 EXPECTED(ret, False);
1658 printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
1660 ret = cli_lock(cli1, fnum1, 10, 4, 0, READ_LOCK) &&
1661 cli_lock(cli1, fnum1, 12, 4, 0, READ_LOCK);
1662 EXPECTED(ret, True);
1663 printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
1665 ret = cli_lock(cli1, fnum1, 20, 4, 0, WRITE_LOCK) &&
1666 cli_lock(cli2, fnum2, 22, 4, 0, WRITE_LOCK);
1667 EXPECTED(ret, False);
1668 printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
1670 ret = cli_lock(cli1, fnum1, 30, 4, 0, READ_LOCK) &&
1671 cli_lock(cli2, fnum2, 32, 4, 0, READ_LOCK);
1672 EXPECTED(ret, True);
1673 printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
1675 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 40, 4, 0, WRITE_LOCK)) &&
1676 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 42, 4, 0, WRITE_LOCK));
1677 EXPECTED(ret, False);
1678 printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
1680 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 50, 4, 0, READ_LOCK)) &&
1681 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 52, 4, 0, READ_LOCK));
1682 EXPECTED(ret, True);
1683 printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
1685 ret = cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK) &&
1686 cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK);
1687 EXPECTED(ret, True);
1688 printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
1690 ret = cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK) &&
1691 cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK);
1692 EXPECTED(ret, False);
1693 printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
1695 ret = cli_lock(cli1, fnum1, 80, 4, 0, READ_LOCK) &&
1696 cli_lock(cli1, fnum1, 80, 4, 0, WRITE_LOCK);
1697 EXPECTED(ret, False);
1698 printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
1700 ret = cli_lock(cli1, fnum1, 90, 4, 0, WRITE_LOCK) &&
1701 cli_lock(cli1, fnum1, 90, 4, 0, READ_LOCK);
1702 EXPECTED(ret, True);
1703 printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1705 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 100, 4, 0, WRITE_LOCK)) &&
1706 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 100, 4, 0, READ_LOCK));
1707 EXPECTED(ret, False);
1708 printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1710 ret = cli_lock(cli1, fnum1, 110, 4, 0, READ_LOCK) &&
1711 cli_lock(cli1, fnum1, 112, 4, 0, READ_LOCK) &&
1712 cli_unlock(cli1, fnum1, 110, 6);
1713 EXPECTED(ret, False);
1714 printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
1717 ret = cli_lock(cli1, fnum1, 120, 4, 0, WRITE_LOCK) &&
1718 (cli_read(cli2, fnum2, buf, 120, 4) == 4);
1719 EXPECTED(ret, False);
1720 printf("this server %s strict write locking\n", ret?"doesn't do":"does");
1722 ret = cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK) &&
1723 (cli_write(cli2, fnum2, 0, buf, 130, 4) == 4);
1724 EXPECTED(ret, False);
1725 printf("this server %s strict read locking\n", ret?"doesn't do":"does");
1728 ret = cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1729 cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1730 cli_unlock(cli1, fnum1, 140, 4) &&
1731 cli_unlock(cli1, fnum1, 140, 4);
1732 EXPECTED(ret, True);
1733 printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
1736 ret = cli_lock(cli1, fnum1, 150, 4, 0, WRITE_LOCK) &&
1737 cli_lock(cli1, fnum1, 150, 4, 0, READ_LOCK) &&
1738 cli_unlock(cli1, fnum1, 150, 4) &&
1739 (cli_read(cli2, fnum2, buf, 150, 4) == 4) &&
1740 !(cli_write(cli2, fnum2, 0, buf, 150, 4) == 4) &&
1741 cli_unlock(cli1, fnum1, 150, 4);
1742 EXPECTED(ret, True);
1743 printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
1745 ret = cli_lock(cli1, fnum1, 160, 4, 0, READ_LOCK) &&
1746 cli_unlock(cli1, fnum1, 160, 4) &&
1747 (cli_write(cli2, fnum2, 0, buf, 160, 4) == 4) &&
1748 (cli_read(cli2, fnum2, buf, 160, 4) == 4);
1749 EXPECTED(ret, True);
1750 printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
1752 ret = cli_lock(cli1, fnum1, 170, 4, 0, WRITE_LOCK) &&
1753 cli_unlock(cli1, fnum1, 170, 4) &&
1754 (cli_write(cli2, fnum2, 0, buf, 170, 4) == 4) &&
1755 (cli_read(cli2, fnum2, buf, 170, 4) == 4);
1756 EXPECTED(ret, True);
1757 printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
1759 ret = cli_lock(cli1, fnum1, 190, 4, 0, WRITE_LOCK) &&
1760 cli_lock(cli1, fnum1, 190, 4, 0, READ_LOCK) &&
1761 cli_unlock(cli1, fnum1, 190, 4) &&
1762 !(cli_write(cli2, fnum2, 0, buf, 190, 4) == 4) &&
1763 (cli_read(cli2, fnum2, buf, 190, 4) == 4);
1764 EXPECTED(ret, True);
1765 printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
1767 cli_close(cli1, fnum1);
1768 cli_close(cli2, fnum2);
1769 fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1770 f = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1771 ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1772 cli_lock(cli1, f, 0, 1, 0, READ_LOCK) &&
1773 cli_close(cli1, fnum1) &&
1774 ((fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE)) != -1) &&
1775 cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1776 cli_close(cli1, f);
1777 cli_close(cli1, fnum1);
1778 EXPECTED(ret, True);
1779 printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
1781 fail:
1782 cli_close(cli1, fnum1);
1783 cli_close(cli2, fnum2);
1784 cli_unlink(cli1, fname);
1785 torture_close_connection(cli1);
1786 torture_close_connection(cli2);
1788 printf("finished locktest4\n");
1789 return correct;
1793 looks at lock upgrade/downgrade.
1795 static bool run_locktest5(int dummy)
1797 static struct cli_state *cli1, *cli2;
1798 const char *fname = "\\lockt5.lck";
1799 int fnum1, fnum2, fnum3;
1800 bool ret;
1801 char buf[1000];
1802 bool correct = True;
1804 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1805 return False;
1808 cli_sockopt(cli1, sockops);
1809 cli_sockopt(cli2, sockops);
1811 printf("starting locktest5\n");
1813 cli_unlink(cli1, fname);
1815 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1816 fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1817 fnum3 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1819 memset(buf, 0, sizeof(buf));
1821 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1822 printf("Failed to create file\n");
1823 correct = False;
1824 goto fail;
1827 /* Check for NT bug... */
1828 ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1829 cli_lock(cli1, fnum3, 0, 1, 0, READ_LOCK);
1830 cli_close(cli1, fnum1);
1831 fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1832 ret = cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1833 EXPECTED(ret, True);
1834 printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
1835 cli_close(cli1, fnum1);
1836 fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1837 cli_unlock(cli1, fnum3, 0, 1);
1839 ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1840 cli_lock(cli1, fnum1, 1, 1, 0, READ_LOCK);
1841 EXPECTED(ret, True);
1842 printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
1844 ret = cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1845 EXPECTED(ret, False);
1847 printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
1849 /* Unlock the process 2 lock. */
1850 cli_unlock(cli2, fnum2, 0, 4);
1852 ret = cli_lock(cli1, fnum3, 0, 4, 0, READ_LOCK);
1853 EXPECTED(ret, False);
1855 printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
1857 /* Unlock the process 1 fnum3 lock. */
1858 cli_unlock(cli1, fnum3, 0, 4);
1860 /* Stack 2 more locks here. */
1861 ret = cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK) &&
1862 cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK);
1864 EXPECTED(ret, True);
1865 printf("the same process %s stack read locks\n", ret?"can":"cannot");
1867 /* Unlock the first process lock, then check this was the WRITE lock that was
1868 removed. */
1870 ret = cli_unlock(cli1, fnum1, 0, 4) &&
1871 cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1873 EXPECTED(ret, True);
1874 printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
1876 /* Unlock the process 2 lock. */
1877 cli_unlock(cli2, fnum2, 0, 4);
1879 /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
1881 ret = cli_unlock(cli1, fnum1, 1, 1) &&
1882 cli_unlock(cli1, fnum1, 0, 4) &&
1883 cli_unlock(cli1, fnum1, 0, 4);
1885 EXPECTED(ret, True);
1886 printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
1888 /* Ensure the next unlock fails. */
1889 ret = cli_unlock(cli1, fnum1, 0, 4);
1890 EXPECTED(ret, False);
1891 printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
1893 /* Ensure connection 2 can get a write lock. */
1894 ret = cli_lock(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
1895 EXPECTED(ret, True);
1897 printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
1900 fail:
1901 cli_close(cli1, fnum1);
1902 cli_close(cli2, fnum2);
1903 cli_unlink(cli1, fname);
1904 if (!torture_close_connection(cli1)) {
1905 correct = False;
1907 if (!torture_close_connection(cli2)) {
1908 correct = False;
1911 printf("finished locktest5\n");
1913 return correct;
1917 tries the unusual lockingX locktype bits
1919 static bool run_locktest6(int dummy)
1921 static struct cli_state *cli;
1922 const char *fname[1] = { "\\lock6.txt" };
1923 int i;
1924 int fnum;
1925 NTSTATUS status;
1927 if (!torture_open_connection(&cli, 0)) {
1928 return False;
1931 cli_sockopt(cli, sockops);
1933 printf("starting locktest6\n");
1935 for (i=0;i<1;i++) {
1936 printf("Testing %s\n", fname[i]);
1938 cli_unlink(cli, fname[i]);
1940 fnum = cli_open(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1941 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
1942 cli_close(cli, fnum);
1943 printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
1945 fnum = cli_open(cli, fname[i], O_RDWR, DENY_NONE);
1946 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
1947 cli_close(cli, fnum);
1948 printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
1950 cli_unlink(cli, fname[i]);
1953 torture_close_connection(cli);
1955 printf("finished locktest6\n");
1956 return True;
1959 static bool run_locktest7(int dummy)
1961 struct cli_state *cli1;
1962 const char *fname = "\\lockt7.lck";
1963 int fnum1;
1964 char buf[200];
1965 bool correct = False;
1967 if (!torture_open_connection(&cli1, 0)) {
1968 return False;
1971 cli_sockopt(cli1, sockops);
1973 printf("starting locktest7\n");
1975 cli_unlink(cli1, fname);
1977 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1979 memset(buf, 0, sizeof(buf));
1981 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1982 printf("Failed to create file\n");
1983 goto fail;
1986 cli_setpid(cli1, 1);
1988 if (!cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK)) {
1989 printf("Unable to apply read lock on range 130:4, error was %s\n", cli_errstr(cli1));
1990 goto fail;
1991 } else {
1992 printf("pid1 successfully locked range 130:4 for READ\n");
1995 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
1996 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
1997 goto fail;
1998 } else {
1999 printf("pid1 successfully read the range 130:4\n");
2002 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2003 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2004 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2005 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2006 goto fail;
2008 } else {
2009 printf("pid1 successfully wrote to the range 130:4 (should be denied)\n");
2010 goto fail;
2013 cli_setpid(cli1, 2);
2015 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2016 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2017 } else {
2018 printf("pid2 successfully read the range 130:4\n");
2021 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2022 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2023 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2024 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2025 goto fail;
2027 } else {
2028 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2029 goto fail;
2032 cli_setpid(cli1, 1);
2033 cli_unlock(cli1, fnum1, 130, 4);
2035 if (!cli_lock(cli1, fnum1, 130, 4, 0, WRITE_LOCK)) {
2036 printf("Unable to apply write lock on range 130:4, error was %s\n", cli_errstr(cli1));
2037 goto fail;
2038 } else {
2039 printf("pid1 successfully locked range 130:4 for WRITE\n");
2042 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2043 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2044 goto fail;
2045 } else {
2046 printf("pid1 successfully read the range 130:4\n");
2049 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2050 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2051 goto fail;
2052 } else {
2053 printf("pid1 successfully wrote to the range 130:4\n");
2056 cli_setpid(cli1, 2);
2058 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2059 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2060 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2061 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2062 goto fail;
2064 } else {
2065 printf("pid2 successfully read the range 130:4 (should be denied)\n");
2066 goto fail;
2069 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2070 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2071 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2072 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2073 goto fail;
2075 } else {
2076 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2077 goto fail;
2080 cli_unlock(cli1, fnum1, 130, 0);
2081 correct = True;
2083 fail:
2084 cli_close(cli1, fnum1);
2085 cli_unlink(cli1, fname);
2086 torture_close_connection(cli1);
2088 printf("finished locktest7\n");
2089 return correct;
2093 test whether fnums and tids open on one VC are available on another (a major
2094 security hole)
2096 static bool run_fdpasstest(int dummy)
2098 struct cli_state *cli1, *cli2;
2099 const char *fname = "\\fdpass.tst";
2100 int fnum1;
2101 char buf[1024];
2103 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2104 return False;
2106 cli_sockopt(cli1, sockops);
2107 cli_sockopt(cli2, sockops);
2109 printf("starting fdpasstest\n");
2111 cli_unlink(cli1, fname);
2113 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2114 if (fnum1 == -1) {
2115 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2116 return False;
2119 if (cli_write(cli1, fnum1, 0, "hello world\n", 0, 13) != 13) {
2120 printf("write failed (%s)\n", cli_errstr(cli1));
2121 return False;
2124 cli2->vuid = cli1->vuid;
2125 cli2->cnum = cli1->cnum;
2126 cli2->pid = cli1->pid;
2128 if (cli_read(cli2, fnum1, buf, 0, 13) == 13) {
2129 printf("read succeeded! nasty security hole [%s]\n",
2130 buf);
2131 return False;
2134 cli_close(cli1, fnum1);
2135 cli_unlink(cli1, fname);
2137 torture_close_connection(cli1);
2138 torture_close_connection(cli2);
2140 printf("finished fdpasstest\n");
2141 return True;
2144 static bool run_fdsesstest(int dummy)
2146 struct cli_state *cli;
2147 uint16 new_vuid;
2148 uint16 saved_vuid;
2149 uint16 new_cnum;
2150 uint16 saved_cnum;
2151 const char *fname = "\\fdsess.tst";
2152 const char *fname1 = "\\fdsess1.tst";
2153 int fnum1;
2154 int fnum2;
2155 char buf[1024];
2156 bool ret = True;
2158 if (!torture_open_connection(&cli, 0))
2159 return False;
2160 cli_sockopt(cli, sockops);
2162 if (!torture_cli_session_setup2(cli, &new_vuid))
2163 return False;
2165 saved_cnum = cli->cnum;
2166 if (!cli_send_tconX(cli, share, "?????", "", 1))
2167 return False;
2168 new_cnum = cli->cnum;
2169 cli->cnum = saved_cnum;
2171 printf("starting fdsesstest\n");
2173 cli_unlink(cli, fname);
2174 cli_unlink(cli, fname1);
2176 fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2177 if (fnum1 == -1) {
2178 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2179 return False;
2182 if (cli_write(cli, fnum1, 0, "hello world\n", 0, 13) != 13) {
2183 printf("write failed (%s)\n", cli_errstr(cli));
2184 return False;
2187 saved_vuid = cli->vuid;
2188 cli->vuid = new_vuid;
2190 if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2191 printf("read succeeded with different vuid! nasty security hole [%s]\n",
2192 buf);
2193 ret = False;
2195 /* Try to open a file with different vuid, samba cnum. */
2196 fnum2 = cli_open(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2197 if (fnum2 != -1) {
2198 printf("create with different vuid, same cnum succeeded.\n");
2199 cli_close(cli, fnum2);
2200 cli_unlink(cli, fname1);
2201 } else {
2202 printf("create with different vuid, same cnum failed.\n");
2203 printf("This will cause problems with service clients.\n");
2204 ret = False;
2207 cli->vuid = saved_vuid;
2209 /* Try with same vuid, different cnum. */
2210 cli->cnum = new_cnum;
2212 if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2213 printf("read succeeded with different cnum![%s]\n",
2214 buf);
2215 ret = False;
2218 cli->cnum = saved_cnum;
2219 cli_close(cli, fnum1);
2220 cli_unlink(cli, fname);
2222 torture_close_connection(cli);
2224 printf("finished fdsesstest\n");
2225 return ret;
2229 This test checks that
2231 1) the server does not allow an unlink on a file that is open
2233 static bool run_unlinktest(int dummy)
2235 struct cli_state *cli;
2236 const char *fname = "\\unlink.tst";
2237 int fnum;
2238 bool correct = True;
2240 if (!torture_open_connection(&cli, 0)) {
2241 return False;
2244 cli_sockopt(cli, sockops);
2246 printf("starting unlink test\n");
2248 cli_unlink(cli, fname);
2250 cli_setpid(cli, 1);
2252 fnum = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2253 if (fnum == -1) {
2254 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2255 return False;
2258 if (cli_unlink(cli, fname)) {
2259 printf("error: server allowed unlink on an open file\n");
2260 correct = False;
2261 } else {
2262 correct = check_error(__LINE__, cli, ERRDOS, ERRbadshare,
2263 NT_STATUS_SHARING_VIOLATION);
2266 cli_close(cli, fnum);
2267 cli_unlink(cli, fname);
2269 if (!torture_close_connection(cli)) {
2270 correct = False;
2273 printf("unlink test finished\n");
2275 return correct;
2280 test how many open files this server supports on the one socket
2282 static bool run_maxfidtest(int dummy)
2284 struct cli_state *cli;
2285 const char *ftemplate = "\\maxfid.%d.%d";
2286 fstring fname;
2287 int fnums[0x11000], i;
2288 int retries=4;
2289 bool correct = True;
2291 cli = current_cli;
2293 if (retries <= 0) {
2294 printf("failed to connect\n");
2295 return False;
2298 cli_sockopt(cli, sockops);
2300 for (i=0; i<0x11000; i++) {
2301 slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2302 if ((fnums[i] = cli_open(cli, fname,
2303 O_RDWR|O_CREAT|O_TRUNC, DENY_NONE)) ==
2304 -1) {
2305 printf("open of %s failed (%s)\n",
2306 fname, cli_errstr(cli));
2307 printf("maximum fnum is %d\n", i);
2308 break;
2310 printf("%6d\r", i);
2312 printf("%6d\n", i);
2313 i--;
2315 printf("cleaning up\n");
2316 for (;i>=0;i--) {
2317 slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2318 cli_close(cli, fnums[i]);
2319 if (!cli_unlink(cli, fname)) {
2320 printf("unlink of %s failed (%s)\n",
2321 fname, cli_errstr(cli));
2322 correct = False;
2324 printf("%6d\r", i);
2326 printf("%6d\n", 0);
2328 printf("maxfid test finished\n");
2329 if (!torture_close_connection(cli)) {
2330 correct = False;
2332 return correct;
2335 /* generate a random buffer */
2336 static void rand_buf(char *buf, int len)
2338 while (len--) {
2339 *buf = (char)sys_random();
2340 buf++;
2344 /* send smb negprot commands, not reading the response */
2345 static bool run_negprot_nowait(int dummy)
2347 int i;
2348 static struct cli_state *cli;
2349 bool correct = True;
2351 printf("starting negprot nowait test\n");
2353 if (!(cli = open_nbt_connection())) {
2354 return False;
2357 for (i=0;i<50000;i++) {
2358 cli_negprot_send(cli);
2361 if (!torture_close_connection(cli)) {
2362 correct = False;
2365 printf("finished negprot nowait test\n");
2367 return correct;
2371 /* send random IPC commands */
2372 static bool run_randomipc(int dummy)
2374 char *rparam = NULL;
2375 char *rdata = NULL;
2376 unsigned int rdrcnt,rprcnt;
2377 char param[1024];
2378 int api, param_len, i;
2379 struct cli_state *cli;
2380 bool correct = True;
2381 int count = 50000;
2383 printf("starting random ipc test\n");
2385 if (!torture_open_connection(&cli, 0)) {
2386 return False;
2389 for (i=0;i<count;i++) {
2390 api = sys_random() % 500;
2391 param_len = (sys_random() % 64);
2393 rand_buf(param, param_len);
2395 SSVAL(param,0,api);
2397 cli_api(cli,
2398 param, param_len, 8,
2399 NULL, 0, BUFFER_SIZE,
2400 &rparam, &rprcnt,
2401 &rdata, &rdrcnt);
2402 if (i % 100 == 0) {
2403 printf("%d/%d\r", i,count);
2406 printf("%d/%d\n", i, count);
2408 if (!torture_close_connection(cli)) {
2409 correct = False;
2412 printf("finished random ipc test\n");
2414 return correct;
2419 static void browse_callback(const char *sname, uint32 stype,
2420 const char *comment, void *state)
2422 printf("\t%20.20s %08x %s\n", sname, stype, comment);
2428 This test checks the browse list code
2431 static bool run_browsetest(int dummy)
2433 static struct cli_state *cli;
2434 bool correct = True;
2436 printf("starting browse test\n");
2438 if (!torture_open_connection(&cli, 0)) {
2439 return False;
2442 printf("domain list:\n");
2443 cli_NetServerEnum(cli, cli->server_domain,
2444 SV_TYPE_DOMAIN_ENUM,
2445 browse_callback, NULL);
2447 printf("machine list:\n");
2448 cli_NetServerEnum(cli, cli->server_domain,
2449 SV_TYPE_ALL,
2450 browse_callback, NULL);
2452 if (!torture_close_connection(cli)) {
2453 correct = False;
2456 printf("browse test finished\n");
2458 return correct;
2464 This checks how the getatr calls works
2466 static bool run_attrtest(int dummy)
2468 struct cli_state *cli;
2469 int fnum;
2470 time_t t, t2;
2471 const char *fname = "\\attrib123456789.tst";
2472 bool correct = True;
2474 printf("starting attrib test\n");
2476 if (!torture_open_connection(&cli, 0)) {
2477 return False;
2480 cli_unlink(cli, fname);
2481 fnum = cli_open(cli, fname,
2482 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2483 cli_close(cli, fnum);
2484 if (!cli_getatr(cli, fname, NULL, NULL, &t)) {
2485 printf("getatr failed (%s)\n", cli_errstr(cli));
2486 correct = False;
2489 if (abs(t - time(NULL)) > 60*60*24*10) {
2490 printf("ERROR: SMBgetatr bug. time is %s",
2491 ctime(&t));
2492 t = time(NULL);
2493 correct = True;
2496 t2 = t-60*60*24; /* 1 day ago */
2498 if (!cli_setatr(cli, fname, 0, t2)) {
2499 printf("setatr failed (%s)\n", cli_errstr(cli));
2500 correct = True;
2503 if (!cli_getatr(cli, fname, NULL, NULL, &t)) {
2504 printf("getatr failed (%s)\n", cli_errstr(cli));
2505 correct = True;
2508 if (t != t2) {
2509 printf("ERROR: getatr/setatr bug. times are\n%s",
2510 ctime(&t));
2511 printf("%s", ctime(&t2));
2512 correct = True;
2515 cli_unlink(cli, fname);
2517 if (!torture_close_connection(cli)) {
2518 correct = False;
2521 printf("attrib test finished\n");
2523 return correct;
2528 This checks a couple of trans2 calls
2530 static bool run_trans2test(int dummy)
2532 struct cli_state *cli;
2533 int fnum;
2534 SMB_OFF_T size;
2535 time_t c_time, a_time, m_time;
2536 struct timespec c_time_ts, a_time_ts, m_time_ts, w_time_ts, m_time2_ts;
2537 const char *fname = "\\trans2.tst";
2538 const char *dname = "\\trans2";
2539 const char *fname2 = "\\trans2\\trans2.tst";
2540 char pname[1024];
2541 bool correct = True;
2543 printf("starting trans2 test\n");
2545 if (!torture_open_connection(&cli, 0)) {
2546 return False;
2549 cli_unlink(cli, fname);
2550 fnum = cli_open(cli, fname,
2551 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2552 if (!cli_qfileinfo(cli, fnum, NULL, &size, &c_time_ts, &a_time_ts, &w_time_ts,
2553 &m_time_ts, NULL)) {
2554 printf("ERROR: qfileinfo failed (%s)\n", cli_errstr(cli));
2555 correct = False;
2558 if (!cli_qfilename(cli, fnum, pname, sizeof(pname))) {
2559 printf("ERROR: qfilename failed (%s)\n", cli_errstr(cli));
2560 correct = False;
2563 if (strcmp(pname, fname)) {
2564 printf("qfilename gave different name? [%s] [%s]\n",
2565 fname, pname);
2566 correct = False;
2569 cli_close(cli, fnum);
2571 sleep(2);
2573 cli_unlink(cli, fname);
2574 fnum = cli_open(cli, fname,
2575 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2576 if (fnum == -1) {
2577 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2578 return False;
2580 cli_close(cli, fnum);
2582 if (!cli_qpathinfo(cli, fname, &c_time, &a_time, &m_time, &size, NULL)) {
2583 printf("ERROR: qpathinfo failed (%s)\n", cli_errstr(cli));
2584 correct = False;
2585 } else {
2586 if (c_time != m_time) {
2587 printf("create time=%s", ctime(&c_time));
2588 printf("modify time=%s", ctime(&m_time));
2589 printf("This system appears to have sticky create times\n");
2591 if (a_time % (60*60) == 0) {
2592 printf("access time=%s", ctime(&a_time));
2593 printf("This system appears to set a midnight access time\n");
2594 correct = False;
2597 if (abs(m_time - time(NULL)) > 60*60*24*7) {
2598 printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
2599 correct = False;
2604 cli_unlink(cli, fname);
2605 fnum = cli_open(cli, fname,
2606 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2607 cli_close(cli, fnum);
2608 if (!cli_qpathinfo2(cli, fname, &c_time_ts, &a_time_ts, &w_time_ts,
2609 &m_time_ts, &size, NULL, NULL)) {
2610 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2611 correct = False;
2612 } else {
2613 if (w_time_ts.tv_sec < 60*60*24*2) {
2614 printf("write time=%s", ctime(&w_time_ts.tv_sec));
2615 printf("This system appears to set a initial 0 write time\n");
2616 correct = False;
2620 cli_unlink(cli, fname);
2623 /* check if the server updates the directory modification time
2624 when creating a new file */
2625 if (!cli_mkdir(cli, dname)) {
2626 printf("ERROR: mkdir failed (%s)\n", cli_errstr(cli));
2627 correct = False;
2629 sleep(3);
2630 if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts, &w_time_ts,
2631 &m_time_ts, &size, NULL, NULL)) {
2632 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2633 correct = False;
2636 fnum = cli_open(cli, fname2,
2637 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2638 cli_write(cli, fnum, 0, (char *)&fnum, 0, sizeof(fnum));
2639 cli_close(cli, fnum);
2640 if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts, &w_time_ts,
2641 &m_time2_ts, &size, NULL, NULL)) {
2642 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2643 correct = False;
2644 } else {
2645 if (memcmp(&m_time_ts, &m_time2_ts, sizeof(struct timespec))
2646 == 0) {
2647 printf("This system does not update directory modification times\n");
2648 correct = False;
2651 cli_unlink(cli, fname2);
2652 cli_rmdir(cli, dname);
2654 if (!torture_close_connection(cli)) {
2655 correct = False;
2658 printf("trans2 test finished\n");
2660 return correct;
2664 This checks new W2K calls.
2667 static bool new_trans(struct cli_state *pcli, int fnum, int level)
2669 char *buf = NULL;
2670 uint32 len;
2671 bool correct = True;
2673 if (!cli_qfileinfo_test(pcli, fnum, level, &buf, &len)) {
2674 printf("ERROR: qfileinfo (%d) failed (%s)\n", level, cli_errstr(pcli));
2675 correct = False;
2676 } else {
2677 printf("qfileinfo: level %d, len = %u\n", level, len);
2678 dump_data(0, (uint8 *)buf, len);
2679 printf("\n");
2681 SAFE_FREE(buf);
2682 return correct;
2685 static bool run_w2ktest(int dummy)
2687 struct cli_state *cli;
2688 int fnum;
2689 const char *fname = "\\w2ktest\\w2k.tst";
2690 int level;
2691 bool correct = True;
2693 printf("starting w2k test\n");
2695 if (!torture_open_connection(&cli, 0)) {
2696 return False;
2699 fnum = cli_open(cli, fname,
2700 O_RDWR | O_CREAT , DENY_NONE);
2702 for (level = 1004; level < 1040; level++) {
2703 new_trans(cli, fnum, level);
2706 cli_close(cli, fnum);
2708 if (!torture_close_connection(cli)) {
2709 correct = False;
2712 printf("w2k test finished\n");
2714 return correct;
2719 this is a harness for some oplock tests
2721 static bool run_oplock1(int dummy)
2723 struct cli_state *cli1;
2724 const char *fname = "\\lockt1.lck";
2725 int fnum1;
2726 bool correct = True;
2728 printf("starting oplock test 1\n");
2730 if (!torture_open_connection(&cli1, 0)) {
2731 return False;
2734 cli_unlink(cli1, fname);
2736 cli_sockopt(cli1, sockops);
2738 cli1->use_oplocks = True;
2740 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2741 if (fnum1 == -1) {
2742 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2743 return False;
2746 cli1->use_oplocks = False;
2748 cli_unlink(cli1, fname);
2749 cli_unlink(cli1, fname);
2751 if (!cli_close(cli1, fnum1)) {
2752 printf("close2 failed (%s)\n", cli_errstr(cli1));
2753 return False;
2756 if (!cli_unlink(cli1, fname)) {
2757 printf("unlink failed (%s)\n", cli_errstr(cli1));
2758 return False;
2761 if (!torture_close_connection(cli1)) {
2762 correct = False;
2765 printf("finished oplock test 1\n");
2767 return correct;
2770 static bool run_oplock2(int dummy)
2772 struct cli_state *cli1, *cli2;
2773 const char *fname = "\\lockt2.lck";
2774 int fnum1, fnum2;
2775 int saved_use_oplocks = use_oplocks;
2776 char buf[4];
2777 bool correct = True;
2778 volatile bool *shared_correct;
2780 shared_correct = (volatile bool *)shm_setup(sizeof(bool));
2781 *shared_correct = True;
2783 use_level_II_oplocks = True;
2784 use_oplocks = True;
2786 printf("starting oplock test 2\n");
2788 if (!torture_open_connection(&cli1, 0)) {
2789 use_level_II_oplocks = False;
2790 use_oplocks = saved_use_oplocks;
2791 return False;
2794 cli1->use_oplocks = True;
2795 cli1->use_level_II_oplocks = True;
2797 if (!torture_open_connection(&cli2, 1)) {
2798 use_level_II_oplocks = False;
2799 use_oplocks = saved_use_oplocks;
2800 return False;
2803 cli2->use_oplocks = True;
2804 cli2->use_level_II_oplocks = True;
2806 cli_unlink(cli1, fname);
2808 cli_sockopt(cli1, sockops);
2809 cli_sockopt(cli2, sockops);
2811 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2812 if (fnum1 == -1) {
2813 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2814 return False;
2817 /* Don't need the globals any more. */
2818 use_level_II_oplocks = False;
2819 use_oplocks = saved_use_oplocks;
2821 if (fork() == 0) {
2822 /* Child code */
2823 fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
2824 if (fnum2 == -1) {
2825 printf("second open of %s failed (%s)\n", fname, cli_errstr(cli1));
2826 *shared_correct = False;
2827 exit(0);
2830 sleep(2);
2832 if (!cli_close(cli2, fnum2)) {
2833 printf("close2 failed (%s)\n", cli_errstr(cli1));
2834 *shared_correct = False;
2837 exit(0);
2840 sleep(2);
2842 /* Ensure cli1 processes the break. Empty file should always return 0
2843 * bytes. */
2845 if (cli_read(cli1, fnum1, buf, 0, 4) != 0) {
2846 printf("read on fnum1 failed (%s)\n", cli_errstr(cli1));
2847 correct = False;
2850 /* Should now be at level II. */
2851 /* Test if sending a write locks causes a break to none. */
2853 if (!cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK)) {
2854 printf("lock failed (%s)\n", cli_errstr(cli1));
2855 correct = False;
2858 cli_unlock(cli1, fnum1, 0, 4);
2860 sleep(2);
2862 if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
2863 printf("lock failed (%s)\n", cli_errstr(cli1));
2864 correct = False;
2867 cli_unlock(cli1, fnum1, 0, 4);
2869 sleep(2);
2871 cli_read(cli1, fnum1, buf, 0, 4);
2873 #if 0
2874 if (cli_write(cli1, fnum1, 0, buf, 0, 4) != 4) {
2875 printf("write on fnum1 failed (%s)\n", cli_errstr(cli1));
2876 correct = False;
2878 #endif
2880 if (!cli_close(cli1, fnum1)) {
2881 printf("close1 failed (%s)\n", cli_errstr(cli1));
2882 correct = False;
2885 sleep(4);
2887 if (!cli_unlink(cli1, fname)) {
2888 printf("unlink failed (%s)\n", cli_errstr(cli1));
2889 correct = False;
2892 if (!torture_close_connection(cli1)) {
2893 correct = False;
2896 if (!*shared_correct) {
2897 correct = False;
2900 printf("finished oplock test 2\n");
2902 return correct;
2905 /* handler for oplock 3 tests */
2906 static bool oplock3_handler(struct cli_state *cli, int fnum, unsigned char level)
2908 printf("got oplock break fnum=%d level=%d\n",
2909 fnum, level);
2910 return cli_oplock_ack(cli, fnum, level);
2913 static bool run_oplock3(int dummy)
2915 struct cli_state *cli;
2916 const char *fname = "\\oplockt3.dat";
2917 int fnum;
2918 char buf[4] = "abcd";
2919 bool correct = True;
2920 volatile bool *shared_correct;
2922 shared_correct = (volatile bool *)shm_setup(sizeof(bool));
2923 *shared_correct = True;
2925 printf("starting oplock test 3\n");
2927 if (fork() == 0) {
2928 /* Child code */
2929 use_oplocks = True;
2930 use_level_II_oplocks = True;
2931 if (!torture_open_connection(&cli, 0)) {
2932 *shared_correct = False;
2933 exit(0);
2935 sleep(2);
2936 /* try to trigger a oplock break in parent */
2937 fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
2938 cli_write(cli, fnum, 0, buf, 0, 4);
2939 exit(0);
2942 /* parent code */
2943 use_oplocks = True;
2944 use_level_II_oplocks = True;
2945 if (!torture_open_connection(&cli, 1)) { /* other is forked */
2946 return False;
2948 cli_oplock_handler(cli, oplock3_handler);
2949 fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
2950 cli_write(cli, fnum, 0, buf, 0, 4);
2951 cli_close(cli, fnum);
2952 fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
2953 cli->timeout = 20000;
2954 cli_receive_smb(cli);
2955 printf("finished oplock test 3\n");
2957 return (correct && *shared_correct);
2959 /* What are we looking for here? What's sucess and what's FAILURE? */
2965 Test delete on close semantics.
2967 static bool run_deletetest(int dummy)
2969 struct cli_state *cli1 = NULL;
2970 struct cli_state *cli2 = NULL;
2971 const char *fname = "\\delete.file";
2972 int fnum1 = -1;
2973 int fnum2 = -1;
2974 bool correct = True;
2976 printf("starting delete test\n");
2978 if (!torture_open_connection(&cli1, 0)) {
2979 return False;
2982 cli_sockopt(cli1, sockops);
2984 /* Test 1 - this should delete the file on close. */
2986 cli_setatr(cli1, fname, 0, 0);
2987 cli_unlink(cli1, fname);
2989 fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
2990 0, FILE_OVERWRITE_IF,
2991 FILE_DELETE_ON_CLOSE, 0);
2993 if (fnum1 == -1) {
2994 printf("[1] open of %s failed (%s)\n", fname, cli_errstr(cli1));
2995 correct = False;
2996 goto fail;
2999 #if 0 /* JRATEST */
3001 uint32 *accinfo = NULL;
3002 uint32 len;
3003 cli_qfileinfo_test(cli1, fnum1, SMB_FILE_ACCESS_INFORMATION, (char **)&accinfo, &len);
3004 if (accinfo)
3005 printf("access mode = 0x%lx\n", *accinfo);
3006 SAFE_FREE(accinfo);
3008 #endif
3010 if (!cli_close(cli1, fnum1)) {
3011 printf("[1] close failed (%s)\n", cli_errstr(cli1));
3012 correct = False;
3013 goto fail;
3016 fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
3017 if (fnum1 != -1) {
3018 printf("[1] open of %s succeeded (should fail)\n", fname);
3019 correct = False;
3020 goto fail;
3023 printf("first delete on close test succeeded.\n");
3025 /* Test 2 - this should delete the file on close. */
3027 cli_setatr(cli1, fname, 0, 0);
3028 cli_unlink(cli1, fname);
3030 fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_ALL_ACCESS,
3031 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
3032 FILE_OVERWRITE_IF, 0, 0);
3034 if (fnum1 == -1) {
3035 printf("[2] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3036 correct = False;
3037 goto fail;
3040 if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3041 printf("[2] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3042 correct = False;
3043 goto fail;
3046 if (!cli_close(cli1, fnum1)) {
3047 printf("[2] close failed (%s)\n", cli_errstr(cli1));
3048 correct = False;
3049 goto fail;
3052 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3053 if (fnum1 != -1) {
3054 printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
3055 if (!cli_close(cli1, fnum1)) {
3056 printf("[2] close failed (%s)\n", cli_errstr(cli1));
3057 correct = False;
3058 goto fail;
3060 cli_unlink(cli1, fname);
3061 } else
3062 printf("second delete on close test succeeded.\n");
3064 /* Test 3 - ... */
3065 cli_setatr(cli1, fname, 0, 0);
3066 cli_unlink(cli1, fname);
3068 fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
3069 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
3071 if (fnum1 == -1) {
3072 printf("[3] open - 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3073 correct = False;
3074 goto fail;
3077 /* This should fail with a sharing violation - open for delete is only compatible
3078 with SHARE_DELETE. */
3080 fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3081 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0, 0);
3083 if (fnum2 != -1) {
3084 printf("[3] open - 2 of %s succeeded - should have failed.\n", fname);
3085 correct = False;
3086 goto fail;
3089 /* This should succeed. */
3091 fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3092 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0);
3094 if (fnum2 == -1) {
3095 printf("[3] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3096 correct = False;
3097 goto fail;
3100 if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3101 printf("[3] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3102 correct = False;
3103 goto fail;
3106 if (!cli_close(cli1, fnum1)) {
3107 printf("[3] close 1 failed (%s)\n", cli_errstr(cli1));
3108 correct = False;
3109 goto fail;
3112 if (!cli_close(cli1, fnum2)) {
3113 printf("[3] close 2 failed (%s)\n", cli_errstr(cli1));
3114 correct = False;
3115 goto fail;
3118 /* This should fail - file should no longer be there. */
3120 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3121 if (fnum1 != -1) {
3122 printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
3123 if (!cli_close(cli1, fnum1)) {
3124 printf("[3] close failed (%s)\n", cli_errstr(cli1));
3126 cli_unlink(cli1, fname);
3127 correct = False;
3128 goto fail;
3129 } else
3130 printf("third delete on close test succeeded.\n");
3132 /* Test 4 ... */
3133 cli_setatr(cli1, fname, 0, 0);
3134 cli_unlink(cli1, fname);
3136 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3137 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
3139 if (fnum1 == -1) {
3140 printf("[4] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3141 correct = False;
3142 goto fail;
3145 /* This should succeed. */
3146 fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS,
3147 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0);
3148 if (fnum2 == -1) {
3149 printf("[4] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3150 correct = False;
3151 goto fail;
3154 if (!cli_close(cli1, fnum2)) {
3155 printf("[4] close - 1 failed (%s)\n", cli_errstr(cli1));
3156 correct = False;
3157 goto fail;
3160 if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3161 printf("[4] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3162 correct = False;
3163 goto fail;
3166 /* This should fail - no more opens once delete on close set. */
3167 fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS,
3168 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3169 FILE_OPEN, 0, 0);
3170 if (fnum2 != -1) {
3171 printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname );
3172 correct = False;
3173 goto fail;
3174 } else
3175 printf("fourth delete on close test succeeded.\n");
3177 if (!cli_close(cli1, fnum1)) {
3178 printf("[4] close - 2 failed (%s)\n", cli_errstr(cli1));
3179 correct = False;
3180 goto fail;
3183 /* Test 5 ... */
3184 cli_setatr(cli1, fname, 0, 0);
3185 cli_unlink(cli1, fname);
3187 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT, DENY_NONE);
3188 if (fnum1 == -1) {
3189 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3190 correct = False;
3191 goto fail;
3194 /* This should fail - only allowed on NT opens with DELETE access. */
3196 if (cli_nt_delete_on_close(cli1, fnum1, True)) {
3197 printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
3198 correct = False;
3199 goto fail;
3202 if (!cli_close(cli1, fnum1)) {
3203 printf("[5] close - 2 failed (%s)\n", cli_errstr(cli1));
3204 correct = False;
3205 goto fail;
3208 printf("fifth delete on close test succeeded.\n");
3210 /* Test 6 ... */
3211 cli_setatr(cli1, fname, 0, 0);
3212 cli_unlink(cli1, fname);
3214 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
3215 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3216 FILE_OVERWRITE_IF, 0, 0);
3218 if (fnum1 == -1) {
3219 printf("[6] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3220 correct = False;
3221 goto fail;
3224 /* This should fail - only allowed on NT opens with DELETE access. */
3226 if (cli_nt_delete_on_close(cli1, fnum1, True)) {
3227 printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
3228 correct = False;
3229 goto fail;
3232 if (!cli_close(cli1, fnum1)) {
3233 printf("[6] close - 2 failed (%s)\n", cli_errstr(cli1));
3234 correct = False;
3235 goto fail;
3238 printf("sixth delete on close test succeeded.\n");
3240 /* Test 7 ... */
3241 cli_setatr(cli1, fname, 0, 0);
3242 cli_unlink(cli1, fname);
3244 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3245 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0);
3247 if (fnum1 == -1) {
3248 printf("[7] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3249 correct = False;
3250 goto fail;
3253 if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3254 printf("[7] setting delete_on_close on file failed !\n");
3255 correct = False;
3256 goto fail;
3259 if (!cli_nt_delete_on_close(cli1, fnum1, False)) {
3260 printf("[7] unsetting delete_on_close on file failed !\n");
3261 correct = False;
3262 goto fail;
3265 if (!cli_close(cli1, fnum1)) {
3266 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3267 correct = False;
3268 goto fail;
3271 /* This next open should succeed - we reset the flag. */
3273 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3274 if (fnum1 == -1) {
3275 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3276 correct = False;
3277 goto fail;
3280 if (!cli_close(cli1, fnum1)) {
3281 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3282 correct = False;
3283 goto fail;
3286 printf("seventh delete on close test succeeded.\n");
3288 /* Test 7 ... */
3289 cli_setatr(cli1, fname, 0, 0);
3290 cli_unlink(cli1, fname);
3292 if (!torture_open_connection(&cli2, 1)) {
3293 printf("[8] failed to open second connection.\n");
3294 correct = False;
3295 goto fail;
3298 cli_sockopt(cli1, sockops);
3300 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3301 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3302 FILE_OVERWRITE_IF, 0, 0);
3304 if (fnum1 == -1) {
3305 printf("[8] open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3306 correct = False;
3307 goto fail;
3310 fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3311 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3312 FILE_OPEN, 0, 0);
3314 if (fnum2 == -1) {
3315 printf("[8] open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3316 correct = False;
3317 goto fail;
3320 if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3321 printf("[8] setting delete_on_close on file failed !\n");
3322 correct = False;
3323 goto fail;
3326 if (!cli_close(cli1, fnum1)) {
3327 printf("[8] close - 1 failed (%s)\n", cli_errstr(cli1));
3328 correct = False;
3329 goto fail;
3332 if (!cli_close(cli2, fnum2)) {
3333 printf("[8] close - 2 failed (%s)\n", cli_errstr(cli2));
3334 correct = False;
3335 goto fail;
3338 /* This should fail.. */
3339 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3340 if (fnum1 != -1) {
3341 printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
3342 goto fail;
3343 correct = False;
3344 } else
3345 printf("eighth delete on close test succeeded.\n");
3347 /* This should fail - we need to set DELETE_ACCESS. */
3348 fnum1 = cli_nt_create_full(cli1, fname, 0,FILE_READ_DATA|FILE_WRITE_DATA,
3349 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0);
3351 if (fnum1 != -1) {
3352 printf("[9] open of %s succeeded should have failed!\n", fname);
3353 correct = False;
3354 goto fail;
3357 printf("ninth delete on close test succeeded.\n");
3359 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3360 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0);
3361 if (fnum1 == -1) {
3362 printf("[10] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3363 correct = False;
3364 goto fail;
3367 /* This should delete the file. */
3368 if (!cli_close(cli1, fnum1)) {
3369 printf("[10] close failed (%s)\n", cli_errstr(cli1));
3370 correct = False;
3371 goto fail;
3374 /* This should fail.. */
3375 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3376 if (fnum1 != -1) {
3377 printf("[10] open of %s succeeded should have been deleted on close !\n", fname);
3378 goto fail;
3379 correct = False;
3380 } else
3381 printf("tenth delete on close test succeeded.\n");
3383 cli_setatr(cli1, fname, 0, 0);
3384 cli_unlink(cli1, fname);
3386 /* What error do we get when attempting to open a read-only file with
3387 delete access ? */
3389 /* Create a readonly file. */
3390 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
3391 FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3392 if (fnum1 == -1) {
3393 printf("[11] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3394 correct = False;
3395 goto fail;
3398 if (!cli_close(cli1, fnum1)) {
3399 printf("[11] close failed (%s)\n", cli_errstr(cli1));
3400 correct = False;
3401 goto fail;
3404 /* Now try open for delete access. */
3405 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_ATTRIBUTES|DELETE_ACCESS,
3406 0, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3407 FILE_OVERWRITE_IF, 0, 0);
3409 if (fnum1 != -1) {
3410 printf("[11] open of %s succeeded should have been denied with ACCESS_DENIED!\n", fname);
3411 cli_close(cli1, fnum1);
3412 goto fail;
3413 correct = False;
3414 } else {
3415 NTSTATUS nterr = cli_nt_error(cli1);
3416 if (!NT_STATUS_EQUAL(nterr,NT_STATUS_ACCESS_DENIED)) {
3417 printf("[11] open of %s should have been denied with ACCESS_DENIED! Got error %s\n", fname, nt_errstr(nterr));
3418 goto fail;
3419 correct = False;
3420 } else {
3421 printf("eleventh delete on close test succeeded.\n");
3425 printf("finished delete test\n");
3427 fail:
3428 /* FIXME: This will crash if we aborted before cli2 got
3429 * intialized, because these functions don't handle
3430 * uninitialized connections. */
3432 if (fnum1 != -1) cli_close(cli1, fnum1);
3433 if (fnum2 != -1) cli_close(cli1, fnum2);
3434 cli_setatr(cli1, fname, 0, 0);
3435 cli_unlink(cli1, fname);
3437 if (cli1 && !torture_close_connection(cli1)) {
3438 correct = False;
3440 if (cli2 && !torture_close_connection(cli2)) {
3441 correct = False;
3443 return correct;
3448 print out server properties
3450 static bool run_properties(int dummy)
3452 static struct cli_state *cli;
3453 bool correct = True;
3455 printf("starting properties test\n");
3457 ZERO_STRUCT(cli);
3459 if (!torture_open_connection(&cli, 0)) {
3460 return False;
3463 cli_sockopt(cli, sockops);
3465 d_printf("Capabilities 0x%08x\n", cli->capabilities);
3467 if (!torture_close_connection(cli)) {
3468 correct = False;
3471 return correct;
3476 /* FIRST_DESIRED_ACCESS 0xf019f */
3477 #define FIRST_DESIRED_ACCESS FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\
3478 FILE_READ_EA| /* 0xf */ \
3479 FILE_WRITE_EA|FILE_READ_ATTRIBUTES| /* 0x90 */ \
3480 FILE_WRITE_ATTRIBUTES| /* 0x100 */ \
3481 DELETE_ACCESS|READ_CONTROL_ACCESS|\
3482 WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS /* 0xf0000 */
3483 /* SECOND_DESIRED_ACCESS 0xe0080 */
3484 #define SECOND_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
3485 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
3486 WRITE_OWNER_ACCESS /* 0xe0000 */
3488 #if 0
3489 #define THIRD_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
3490 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
3491 FILE_READ_DATA|\
3492 WRITE_OWNER_ACCESS /* */
3493 #endif
3496 Test ntcreate calls made by xcopy
3498 static bool run_xcopy(int dummy)
3500 static struct cli_state *cli1;
3501 const char *fname = "\\test.txt";
3502 bool correct = True;
3503 int fnum1, fnum2;
3505 printf("starting xcopy test\n");
3507 if (!torture_open_connection(&cli1, 0)) {
3508 return False;
3511 fnum1 = cli_nt_create_full(cli1, fname, 0,
3512 FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
3513 FILE_SHARE_NONE, FILE_OVERWRITE_IF,
3514 0x4044, 0);
3516 if (fnum1 == -1) {
3517 printf("First open failed - %s\n", cli_errstr(cli1));
3518 return False;
3521 fnum2 = cli_nt_create_full(cli1, fname, 0,
3522 SECOND_DESIRED_ACCESS, 0,
3523 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN,
3524 0x200000, 0);
3525 if (fnum2 == -1) {
3526 printf("second open failed - %s\n", cli_errstr(cli1));
3527 return False;
3530 if (!torture_close_connection(cli1)) {
3531 correct = False;
3534 return correct;
3538 Test rename on files open with share delete and no share delete.
3540 static bool run_rename(int dummy)
3542 static struct cli_state *cli1;
3543 const char *fname = "\\test.txt";
3544 const char *fname1 = "\\test1.txt";
3545 bool correct = True;
3546 int fnum1;
3548 printf("starting rename test\n");
3550 if (!torture_open_connection(&cli1, 0)) {
3551 return False;
3554 cli_unlink(cli1, fname);
3555 cli_unlink(cli1, fname1);
3556 fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3557 FILE_SHARE_READ, FILE_OVERWRITE_IF, 0, 0);
3559 if (fnum1 == -1) {
3560 printf("First open failed - %s\n", cli_errstr(cli1));
3561 return False;
3564 if (!cli_rename(cli1, fname, fname1)) {
3565 printf("First rename failed (SHARE_READ) (this is correct) - %s\n", cli_errstr(cli1));
3566 } else {
3567 printf("First rename succeeded (SHARE_READ) - this should have failed !\n");
3568 correct = False;
3571 if (!cli_close(cli1, fnum1)) {
3572 printf("close - 1 failed (%s)\n", cli_errstr(cli1));
3573 return False;
3576 cli_unlink(cli1, fname);
3577 cli_unlink(cli1, fname1);
3578 fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3579 #if 0
3580 FILE_SHARE_DELETE|FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3581 #else
3582 FILE_SHARE_DELETE|FILE_SHARE_READ, FILE_OVERWRITE_IF, 0, 0);
3583 #endif
3585 if (fnum1 == -1) {
3586 printf("Second open failed - %s\n", cli_errstr(cli1));
3587 return False;
3590 if (!cli_rename(cli1, fname, fname1)) {
3591 printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", cli_errstr(cli1));
3592 correct = False;
3593 } else {
3594 printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n");
3597 if (!cli_close(cli1, fnum1)) {
3598 printf("close - 2 failed (%s)\n", cli_errstr(cli1));
3599 return False;
3602 cli_unlink(cli1, fname);
3603 cli_unlink(cli1, fname1);
3605 fnum1 = cli_nt_create_full(cli1, fname, 0, READ_CONTROL_ACCESS, FILE_ATTRIBUTE_NORMAL,
3606 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3608 if (fnum1 == -1) {
3609 printf("Third open failed - %s\n", cli_errstr(cli1));
3610 return False;
3614 #if 0
3616 int fnum2;
3618 fnum2 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
3619 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3621 if (fnum2 == -1) {
3622 printf("Fourth open failed - %s\n", cli_errstr(cli1));
3623 return False;
3625 if (!cli_nt_delete_on_close(cli1, fnum2, True)) {
3626 printf("[8] setting delete_on_close on file failed !\n");
3627 return False;
3630 if (!cli_close(cli1, fnum2)) {
3631 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
3632 return False;
3635 #endif
3637 if (!cli_rename(cli1, fname, fname1)) {
3638 printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", cli_errstr(cli1));
3639 correct = False;
3640 } else {
3641 printf("Third rename succeeded (SHARE_NONE)\n");
3644 if (!cli_close(cli1, fnum1)) {
3645 printf("close - 3 failed (%s)\n", cli_errstr(cli1));
3646 return False;
3649 cli_unlink(cli1, fname);
3650 cli_unlink(cli1, fname1);
3652 /*----*/
3654 fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3655 FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
3657 if (fnum1 == -1) {
3658 printf("Fourth open failed - %s\n", cli_errstr(cli1));
3659 return False;
3662 if (!cli_rename(cli1, fname, fname1)) {
3663 printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", cli_errstr(cli1));
3664 } else {
3665 printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n");
3666 correct = False;
3669 if (!cli_close(cli1, fnum1)) {
3670 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
3671 return False;
3674 cli_unlink(cli1, fname);
3675 cli_unlink(cli1, fname1);
3677 /*--*/
3679 fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3680 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0);
3682 if (fnum1 == -1) {
3683 printf("Fifth open failed - %s\n", cli_errstr(cli1));
3684 return False;
3687 if (!cli_rename(cli1, fname, fname1)) {
3688 printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s\n", cli_errstr(cli1));
3689 correct = False;
3690 } else {
3691 printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", cli_errstr(cli1));
3695 * Now check if the first name still exists ...
3698 /*fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3699 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0);
3701 if (fnum2 == -1) {
3702 printf("Opening original file after rename of open file fails: %s\n",
3703 cli_errstr(cli1));
3705 else {
3706 printf("Opening original file after rename of open file works ...\n");
3707 (void)cli_close(cli1, fnum2);
3708 } */
3710 /*--*/
3713 if (!cli_close(cli1, fnum1)) {
3714 printf("close - 5 failed (%s)\n", cli_errstr(cli1));
3715 return False;
3718 cli_unlink(cli1, fname);
3719 cli_unlink(cli1, fname1);
3721 if (!torture_close_connection(cli1)) {
3722 correct = False;
3725 return correct;
3728 static bool run_pipe_number(int dummy)
3730 struct cli_state *cli1;
3731 const char *pipe_name = "\\SPOOLSS";
3732 int fnum;
3733 int num_pipes = 0;
3735 printf("starting pipenumber test\n");
3736 if (!torture_open_connection(&cli1, 0)) {
3737 return False;
3740 cli_sockopt(cli1, sockops);
3741 while(1) {
3742 fnum = cli_nt_create_full(cli1, pipe_name, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
3743 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF, 0, 0);
3745 if (fnum == -1) {
3746 printf("Open of pipe %s failed with error (%s)\n", pipe_name, cli_errstr(cli1));
3747 break;
3749 num_pipes++;
3750 printf("\r%6d", num_pipes);
3753 printf("pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
3754 torture_close_connection(cli1);
3755 return True;
3759 Test open mode returns on read-only files.
3761 static bool run_opentest(int dummy)
3763 static struct cli_state *cli1;
3764 static struct cli_state *cli2;
3765 const char *fname = "\\readonly.file";
3766 int fnum1, fnum2;
3767 char buf[20];
3768 SMB_OFF_T fsize;
3769 bool correct = True;
3770 char *tmp_path;
3772 printf("starting open test\n");
3774 if (!torture_open_connection(&cli1, 0)) {
3775 return False;
3778 cli_setatr(cli1, fname, 0, 0);
3779 cli_unlink(cli1, fname);
3781 cli_sockopt(cli1, sockops);
3783 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
3784 if (fnum1 == -1) {
3785 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3786 return False;
3789 if (!cli_close(cli1, fnum1)) {
3790 printf("close2 failed (%s)\n", cli_errstr(cli1));
3791 return False;
3794 if (!cli_setatr(cli1, fname, aRONLY, 0)) {
3795 printf("cli_setatr failed (%s)\n", cli_errstr(cli1));
3796 return False;
3799 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_WRITE);
3800 if (fnum1 == -1) {
3801 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3802 return False;
3805 /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
3806 fnum2 = cli_open(cli1, fname, O_RDWR, DENY_ALL);
3808 if (check_error(__LINE__, cli1, ERRDOS, ERRnoaccess,
3809 NT_STATUS_ACCESS_DENIED)) {
3810 printf("correct error code ERRDOS/ERRnoaccess returned\n");
3813 printf("finished open test 1\n");
3815 cli_close(cli1, fnum1);
3817 /* Now try not readonly and ensure ERRbadshare is returned. */
3819 cli_setatr(cli1, fname, 0, 0);
3821 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_WRITE);
3822 if (fnum1 == -1) {
3823 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3824 return False;
3827 /* This will fail - but the error should be ERRshare. */
3828 fnum2 = cli_open(cli1, fname, O_RDWR, DENY_ALL);
3830 if (check_error(__LINE__, cli1, ERRDOS, ERRbadshare,
3831 NT_STATUS_SHARING_VIOLATION)) {
3832 printf("correct error code ERRDOS/ERRbadshare returned\n");
3835 if (!cli_close(cli1, fnum1)) {
3836 printf("close2 failed (%s)\n", cli_errstr(cli1));
3837 return False;
3840 cli_unlink(cli1, fname);
3842 printf("finished open test 2\n");
3844 /* Test truncate open disposition on file opened for read. */
3846 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
3847 if (fnum1 == -1) {
3848 printf("(3) open (1) of %s failed (%s)\n", fname, cli_errstr(cli1));
3849 return False;
3852 /* write 20 bytes. */
3854 memset(buf, '\0', 20);
3856 if (cli_write(cli1, fnum1, 0, buf, 0, 20) != 20) {
3857 printf("write failed (%s)\n", cli_errstr(cli1));
3858 correct = False;
3861 if (!cli_close(cli1, fnum1)) {
3862 printf("(3) close1 failed (%s)\n", cli_errstr(cli1));
3863 return False;
3866 /* Ensure size == 20. */
3867 if (!cli_getatr(cli1, fname, NULL, &fsize, NULL)) {
3868 printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
3869 return False;
3872 if (fsize != 20) {
3873 printf("(3) file size != 20\n");
3874 return False;
3877 /* Now test if we can truncate a file opened for readonly. */
3879 fnum1 = cli_open(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE);
3880 if (fnum1 == -1) {
3881 printf("(3) open (2) of %s failed (%s)\n", fname, cli_errstr(cli1));
3882 return False;
3885 if (!cli_close(cli1, fnum1)) {
3886 printf("close2 failed (%s)\n", cli_errstr(cli1));
3887 return False;
3890 /* Ensure size == 0. */
3891 if (!cli_getatr(cli1, fname, NULL, &fsize, NULL)) {
3892 printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
3893 return False;
3896 if (fsize != 0) {
3897 printf("(3) file size != 0\n");
3898 return False;
3900 printf("finished open test 3\n");
3902 cli_unlink(cli1, fname);
3905 printf("testing ctemp\n");
3906 fnum1 = cli_ctemp(cli1, "\\", &tmp_path);
3907 if (fnum1 == -1) {
3908 printf("ctemp failed (%s)\n", cli_errstr(cli1));
3909 return False;
3911 printf("ctemp gave path %s\n", tmp_path);
3912 if (!cli_close(cli1, fnum1)) {
3913 printf("close of temp failed (%s)\n", cli_errstr(cli1));
3915 if (!cli_unlink(cli1, tmp_path)) {
3916 printf("unlink of temp failed (%s)\n", cli_errstr(cli1));
3919 /* Test the non-io opens... */
3921 if (!torture_open_connection(&cli2, 1)) {
3922 return False;
3925 cli_setatr(cli2, fname, 0, 0);
3926 cli_unlink(cli2, fname);
3928 cli_sockopt(cli2, sockops);
3930 printf("TEST #1 testing 2 non-io opens (no delete)\n");
3932 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3933 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3935 if (fnum1 == -1) {
3936 printf("test 1 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3937 return False;
3940 fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3941 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
3943 if (fnum2 == -1) {
3944 printf("test 1 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3945 return False;
3948 if (!cli_close(cli1, fnum1)) {
3949 printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3950 return False;
3952 if (!cli_close(cli2, fnum2)) {
3953 printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3954 return False;
3957 printf("non-io open test #1 passed.\n");
3959 cli_unlink(cli1, fname);
3961 printf("TEST #2 testing 2 non-io opens (first with delete)\n");
3963 fnum1 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3964 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3966 if (fnum1 == -1) {
3967 printf("test 2 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3968 return False;
3971 fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3972 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
3974 if (fnum2 == -1) {
3975 printf("test 2 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3976 return False;
3979 if (!cli_close(cli1, fnum1)) {
3980 printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3981 return False;
3983 if (!cli_close(cli2, fnum2)) {
3984 printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3985 return False;
3988 printf("non-io open test #2 passed.\n");
3990 cli_unlink(cli1, fname);
3992 printf("TEST #3 testing 2 non-io opens (second with delete)\n");
3994 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3995 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3997 if (fnum1 == -1) {
3998 printf("test 3 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3999 return False;
4002 fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4003 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
4005 if (fnum2 == -1) {
4006 printf("test 3 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4007 return False;
4010 if (!cli_close(cli1, fnum1)) {
4011 printf("test 3 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4012 return False;
4014 if (!cli_close(cli2, fnum2)) {
4015 printf("test 3 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4016 return False;
4019 printf("non-io open test #3 passed.\n");
4021 cli_unlink(cli1, fname);
4023 printf("TEST #4 testing 2 non-io opens (both with delete)\n");
4025 fnum1 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4026 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
4028 if (fnum1 == -1) {
4029 printf("test 4 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4030 return False;
4033 fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4034 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
4036 if (fnum2 != -1) {
4037 printf("test 4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
4038 return False;
4041 printf("test 3 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
4043 if (!cli_close(cli1, fnum1)) {
4044 printf("test 4 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4045 return False;
4048 printf("non-io open test #4 passed.\n");
4050 cli_unlink(cli1, fname);
4052 printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
4054 fnum1 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4055 FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0);
4057 if (fnum1 == -1) {
4058 printf("test 5 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4059 return False;
4062 fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4063 FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0);
4065 if (fnum2 == -1) {
4066 printf("test 5 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4067 return False;
4070 if (!cli_close(cli1, fnum1)) {
4071 printf("test 5 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4072 return False;
4075 if (!cli_close(cli2, fnum2)) {
4076 printf("test 5 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4077 return False;
4080 printf("non-io open test #5 passed.\n");
4082 printf("TEST #6 testing 1 non-io open, one io open\n");
4084 cli_unlink(cli1, fname);
4086 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
4087 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
4089 if (fnum1 == -1) {
4090 printf("test 6 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4091 return False;
4094 fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4095 FILE_SHARE_READ, FILE_OPEN_IF, 0, 0);
4097 if (fnum2 == -1) {
4098 printf("test 6 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4099 return False;
4102 if (!cli_close(cli1, fnum1)) {
4103 printf("test 6 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4104 return False;
4107 if (!cli_close(cli2, fnum2)) {
4108 printf("test 6 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4109 return False;
4112 printf("non-io open test #6 passed.\n");
4114 printf("TEST #7 testing 1 non-io open, one io open with delete\n");
4116 cli_unlink(cli1, fname);
4118 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
4119 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
4121 if (fnum1 == -1) {
4122 printf("test 7 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4123 return False;
4126 fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4127 FILE_SHARE_READ|FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0);
4129 if (fnum2 != -1) {
4130 printf("test 7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
4131 return False;
4134 printf("test 7 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
4136 if (!cli_close(cli1, fnum1)) {
4137 printf("test 7 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4138 return False;
4141 printf("non-io open test #7 passed.\n");
4143 cli_unlink(cli1, fname);
4145 if (!torture_close_connection(cli1)) {
4146 correct = False;
4148 if (!torture_close_connection(cli2)) {
4149 correct = False;
4152 return correct;
4155 static uint32 open_attrs_table[] = {
4156 FILE_ATTRIBUTE_NORMAL,
4157 FILE_ATTRIBUTE_ARCHIVE,
4158 FILE_ATTRIBUTE_READONLY,
4159 FILE_ATTRIBUTE_HIDDEN,
4160 FILE_ATTRIBUTE_SYSTEM,
4162 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY,
4163 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN,
4164 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,
4165 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
4166 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
4167 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
4169 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
4170 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
4171 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
4172 FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM,
4175 struct trunc_open_results {
4176 unsigned int num;
4177 uint32 init_attr;
4178 uint32 trunc_attr;
4179 uint32 result_attr;
4182 static struct trunc_open_results attr_results[] = {
4183 { 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
4184 { 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
4185 { 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
4186 { 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
4187 { 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
4188 { 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
4189 { 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4190 { 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4191 { 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
4192 { 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4193 { 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4194 { 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
4195 { 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4196 { 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4197 { 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 },
4198 { 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4199 { 119, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4200 { 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 },
4201 { 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 },
4202 { 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 },
4203 { 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4204 { 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4205 { 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
4206 { 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4207 { 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4208 { 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
4211 static bool run_openattrtest(int dummy)
4213 static struct cli_state *cli1;
4214 const char *fname = "\\openattr.file";
4215 int fnum1;
4216 bool correct = True;
4217 uint16 attr;
4218 unsigned int i, j, k, l;
4220 printf("starting open attr test\n");
4222 if (!torture_open_connection(&cli1, 0)) {
4223 return False;
4226 cli_sockopt(cli1, sockops);
4228 for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32); i++) {
4229 cli_setatr(cli1, fname, 0, 0);
4230 cli_unlink(cli1, fname);
4231 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_WRITE_DATA, open_attrs_table[i],
4232 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
4234 if (fnum1 == -1) {
4235 printf("open %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
4236 return False;
4239 if (!cli_close(cli1, fnum1)) {
4240 printf("close %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
4241 return False;
4244 for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32); j++) {
4245 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA, open_attrs_table[j],
4246 FILE_SHARE_NONE, FILE_OVERWRITE, 0, 0);
4248 if (fnum1 == -1) {
4249 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
4250 if (attr_results[l].num == k) {
4251 printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
4252 k, open_attrs_table[i],
4253 open_attrs_table[j],
4254 fname, NT_STATUS_V(cli_nt_error(cli1)), cli_errstr(cli1));
4255 correct = False;
4258 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_ACCESS_DENIED)) {
4259 printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n",
4260 k, open_attrs_table[i], open_attrs_table[j],
4261 cli_errstr(cli1));
4262 correct = False;
4264 #if 0
4265 printf("[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]);
4266 #endif
4267 k++;
4268 continue;
4271 if (!cli_close(cli1, fnum1)) {
4272 printf("close %d (2) of %s failed (%s)\n", j, fname, cli_errstr(cli1));
4273 return False;
4276 if (!cli_getatr(cli1, fname, &attr, NULL, NULL)) {
4277 printf("getatr(2) failed (%s)\n", cli_errstr(cli1));
4278 return False;
4281 #if 0
4282 printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
4283 k, open_attrs_table[i], open_attrs_table[j], attr );
4284 #endif
4286 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
4287 if (attr_results[l].num == k) {
4288 if (attr != attr_results[l].result_attr ||
4289 open_attrs_table[i] != attr_results[l].init_attr ||
4290 open_attrs_table[j] != attr_results[l].trunc_attr) {
4291 printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
4292 open_attrs_table[i],
4293 open_attrs_table[j],
4294 (unsigned int)attr,
4295 attr_results[l].result_attr);
4296 correct = False;
4298 break;
4301 k++;
4305 cli_setatr(cli1, fname, 0, 0);
4306 cli_unlink(cli1, fname);
4308 printf("open attr test %s.\n", correct ? "passed" : "failed");
4310 if (!torture_close_connection(cli1)) {
4311 correct = False;
4313 return correct;
4316 static void list_fn(const char *mnt, file_info *finfo, const char *name, void *state)
4322 test directory listing speed
4324 static bool run_dirtest(int dummy)
4326 int i;
4327 static struct cli_state *cli;
4328 int fnum;
4329 double t1;
4330 bool correct = True;
4332 printf("starting directory test\n");
4334 if (!torture_open_connection(&cli, 0)) {
4335 return False;
4338 cli_sockopt(cli, sockops);
4340 srandom(0);
4341 for (i=0;i<torture_numops;i++) {
4342 fstring fname;
4343 slprintf(fname, sizeof(fname), "\\%x", (int)random());
4344 fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
4345 if (fnum == -1) {
4346 fprintf(stderr,"Failed to open %s\n", fname);
4347 return False;
4349 cli_close(cli, fnum);
4352 t1 = end_timer();
4354 printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
4355 printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
4356 printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
4358 printf("dirtest core %g seconds\n", end_timer() - t1);
4360 srandom(0);
4361 for (i=0;i<torture_numops;i++) {
4362 fstring fname;
4363 slprintf(fname, sizeof(fname), "\\%x", (int)random());
4364 cli_unlink(cli, fname);
4367 if (!torture_close_connection(cli)) {
4368 correct = False;
4371 printf("finished dirtest\n");
4373 return correct;
4376 static void del_fn(const char *mnt, file_info *finfo, const char *mask, void *state)
4378 struct cli_state *pcli = (struct cli_state *)state;
4379 fstring fname;
4380 slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name);
4382 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
4383 return;
4385 if (finfo->mode & aDIR) {
4386 if (!cli_rmdir(pcli, fname))
4387 printf("del_fn: failed to rmdir %s\n,", fname );
4388 } else {
4389 if (!cli_unlink(pcli, fname))
4390 printf("del_fn: failed to unlink %s\n,", fname );
4396 sees what IOCTLs are supported
4398 bool torture_ioctl_test(int dummy)
4400 static struct cli_state *cli;
4401 uint16 device, function;
4402 int fnum;
4403 const char *fname = "\\ioctl.dat";
4404 DATA_BLOB blob;
4405 NTSTATUS status;
4407 if (!torture_open_connection(&cli, 0)) {
4408 return False;
4411 printf("starting ioctl test\n");
4413 cli_unlink(cli, fname);
4415 fnum = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
4416 if (fnum == -1) {
4417 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
4418 return False;
4421 status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob);
4422 printf("ioctl device info: %s\n", cli_errstr(cli));
4424 status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob);
4425 printf("ioctl job info: %s\n", cli_errstr(cli));
4427 for (device=0;device<0x100;device++) {
4428 printf("testing device=0x%x\n", device);
4429 for (function=0;function<0x100;function++) {
4430 uint32 code = (device<<16) | function;
4432 status = cli_raw_ioctl(cli, fnum, code, &blob);
4434 if (NT_STATUS_IS_OK(status)) {
4435 printf("ioctl 0x%x OK : %d bytes\n", (int)code,
4436 (int)blob.length);
4437 data_blob_free(&blob);
4442 if (!torture_close_connection(cli)) {
4443 return False;
4446 return True;
4451 tries varients of chkpath
4453 bool torture_chkpath_test(int dummy)
4455 static struct cli_state *cli;
4456 int fnum;
4457 bool ret;
4459 if (!torture_open_connection(&cli, 0)) {
4460 return False;
4463 printf("starting chkpath test\n");
4465 /* cleanup from an old run */
4466 cli_rmdir(cli, "\\chkpath.dir\\dir2");
4467 cli_unlink(cli, "\\chkpath.dir\\*");
4468 cli_rmdir(cli, "\\chkpath.dir");
4470 if (!cli_mkdir(cli, "\\chkpath.dir")) {
4471 printf("mkdir1 failed : %s\n", cli_errstr(cli));
4472 return False;
4475 if (!cli_mkdir(cli, "\\chkpath.dir\\dir2")) {
4476 printf("mkdir2 failed : %s\n", cli_errstr(cli));
4477 return False;
4480 fnum = cli_open(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
4481 if (fnum == -1) {
4482 printf("open1 failed (%s)\n", cli_errstr(cli));
4483 return False;
4485 cli_close(cli, fnum);
4487 if (!cli_chkpath(cli, "\\chkpath.dir")) {
4488 printf("chkpath1 failed: %s\n", cli_errstr(cli));
4489 ret = False;
4492 if (!cli_chkpath(cli, "\\chkpath.dir\\dir2")) {
4493 printf("chkpath2 failed: %s\n", cli_errstr(cli));
4494 ret = False;
4497 if (!cli_chkpath(cli, "\\chkpath.dir\\foo.txt")) {
4498 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
4499 NT_STATUS_NOT_A_DIRECTORY);
4500 } else {
4501 printf("* chkpath on a file should fail\n");
4502 ret = False;
4505 if (!cli_chkpath(cli, "\\chkpath.dir\\bar.txt")) {
4506 ret = check_error(__LINE__, cli, ERRDOS, ERRbadfile,
4507 NT_STATUS_OBJECT_NAME_NOT_FOUND);
4508 } else {
4509 printf("* chkpath on a non existant file should fail\n");
4510 ret = False;
4513 if (!cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt")) {
4514 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
4515 NT_STATUS_OBJECT_PATH_NOT_FOUND);
4516 } else {
4517 printf("* chkpath on a non existent component should fail\n");
4518 ret = False;
4521 cli_rmdir(cli, "\\chkpath.dir\\dir2");
4522 cli_unlink(cli, "\\chkpath.dir\\*");
4523 cli_rmdir(cli, "\\chkpath.dir");
4525 if (!torture_close_connection(cli)) {
4526 return False;
4529 return ret;
4532 static bool run_eatest(int dummy)
4534 static struct cli_state *cli;
4535 const char *fname = "\\eatest.txt";
4536 bool correct = True;
4537 int fnum, i;
4538 size_t num_eas;
4539 struct ea_struct *ea_list = NULL;
4540 TALLOC_CTX *mem_ctx = talloc_init("eatest");
4542 printf("starting eatest\n");
4544 if (!torture_open_connection(&cli, 0)) {
4545 talloc_destroy(mem_ctx);
4546 return False;
4549 cli_unlink(cli, fname);
4550 fnum = cli_nt_create_full(cli, fname, 0,
4551 FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
4552 FILE_SHARE_NONE, FILE_OVERWRITE_IF,
4553 0x4044, 0);
4555 if (fnum == -1) {
4556 printf("open failed - %s\n", cli_errstr(cli));
4557 talloc_destroy(mem_ctx);
4558 return False;
4561 for (i = 0; i < 10; i++) {
4562 fstring ea_name, ea_val;
4564 slprintf(ea_name, sizeof(ea_name), "EA_%d", i);
4565 memset(ea_val, (char)i+1, i+1);
4566 if (!cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1)) {
4567 printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
4568 talloc_destroy(mem_ctx);
4569 return False;
4573 cli_close(cli, fnum);
4574 for (i = 0; i < 10; i++) {
4575 fstring ea_name, ea_val;
4577 slprintf(ea_name, sizeof(ea_name), "EA_%d", i+10);
4578 memset(ea_val, (char)i+1, i+1);
4579 if (!cli_set_ea_path(cli, fname, ea_name, ea_val, i+1)) {
4580 printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
4581 talloc_destroy(mem_ctx);
4582 return False;
4586 if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list)) {
4587 printf("ea_get list failed - %s\n", cli_errstr(cli));
4588 correct = False;
4591 printf("num_eas = %d\n", (int)num_eas);
4593 if (num_eas != 20) {
4594 printf("Should be 20 EA's stored... failing.\n");
4595 correct = False;
4598 for (i = 0; i < num_eas; i++) {
4599 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
4600 dump_data(0, ea_list[i].value.data,
4601 ea_list[i].value.length);
4604 /* Setting EA's to zero length deletes them. Test this */
4605 printf("Now deleting all EA's - case indepenent....\n");
4607 #if 1
4608 cli_set_ea_path(cli, fname, "", "", 0);
4609 #else
4610 for (i = 0; i < 20; i++) {
4611 fstring ea_name;
4612 slprintf(ea_name, sizeof(ea_name), "ea_%d", i);
4613 if (!cli_set_ea_path(cli, fname, ea_name, "", 0)) {
4614 printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
4615 talloc_destroy(mem_ctx);
4616 return False;
4619 #endif
4621 if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list)) {
4622 printf("ea_get list failed - %s\n", cli_errstr(cli));
4623 correct = False;
4626 printf("num_eas = %d\n", (int)num_eas);
4627 for (i = 0; i < num_eas; i++) {
4628 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
4629 dump_data(0, ea_list[i].value.data,
4630 ea_list[i].value.length);
4633 if (num_eas != 0) {
4634 printf("deleting EA's failed.\n");
4635 correct = False;
4638 /* Try and delete a non existant EA. */
4639 if (!cli_set_ea_path(cli, fname, "foo", "", 0)) {
4640 printf("deleting non-existant EA 'foo' should succeed. %s\n", cli_errstr(cli));
4641 correct = False;
4644 talloc_destroy(mem_ctx);
4645 if (!torture_close_connection(cli)) {
4646 correct = False;
4649 return correct;
4652 static bool run_dirtest1(int dummy)
4654 int i;
4655 static struct cli_state *cli;
4656 int fnum, num_seen;
4657 bool correct = True;
4659 printf("starting directory test\n");
4661 if (!torture_open_connection(&cli, 0)) {
4662 return False;
4665 cli_sockopt(cli, sockops);
4667 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
4668 cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
4669 cli_rmdir(cli, "\\LISTDIR");
4670 cli_mkdir(cli, "\\LISTDIR");
4672 /* Create 1000 files and 1000 directories. */
4673 for (i=0;i<1000;i++) {
4674 fstring fname;
4675 slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i);
4676 fnum = cli_nt_create_full(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
4677 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
4678 if (fnum == -1) {
4679 fprintf(stderr,"Failed to open %s\n", fname);
4680 return False;
4682 cli_close(cli, fnum);
4684 for (i=0;i<1000;i++) {
4685 fstring fname;
4686 slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i);
4687 if (!cli_mkdir(cli, fname)) {
4688 fprintf(stderr,"Failed to open %s\n", fname);
4689 return False;
4693 /* Now ensure that doing an old list sees both files and directories. */
4694 num_seen = cli_list_old(cli, "\\LISTDIR\\*", aDIR, list_fn, NULL);
4695 printf("num_seen = %d\n", num_seen );
4696 /* We should see 100 files + 1000 directories + . and .. */
4697 if (num_seen != 2002)
4698 correct = False;
4700 /* Ensure if we have the "must have" bits we only see the
4701 * relevent entries.
4703 num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aDIR<<8)|aDIR, list_fn, NULL);
4704 printf("num_seen = %d\n", num_seen );
4705 if (num_seen != 1002)
4706 correct = False;
4708 num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aARCH<<8)|aDIR, list_fn, NULL);
4709 printf("num_seen = %d\n", num_seen );
4710 if (num_seen != 1000)
4711 correct = False;
4713 /* Delete everything. */
4714 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
4715 cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
4716 cli_rmdir(cli, "\\LISTDIR");
4718 #if 0
4719 printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
4720 printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
4721 printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
4722 #endif
4724 if (!torture_close_connection(cli)) {
4725 correct = False;
4728 printf("finished dirtest1\n");
4730 return correct;
4733 static bool run_error_map_extract(int dummy) {
4735 static struct cli_state *c_dos;
4736 static struct cli_state *c_nt;
4738 uint32 error;
4740 uint32 flgs2, errnum;
4741 uint8 errclass;
4743 NTSTATUS nt_status;
4745 fstring user;
4747 /* NT-Error connection */
4749 if (!(c_nt = open_nbt_connection())) {
4750 return False;
4753 c_nt->use_spnego = False;
4755 if (!cli_negprot(c_nt)) {
4756 printf("%s rejected the NT-error negprot (%s)\n",host, cli_errstr(c_nt));
4757 cli_shutdown(c_nt);
4758 return False;
4761 if (!NT_STATUS_IS_OK(cli_session_setup(c_nt, "", "", 0, "", 0,
4762 workgroup))) {
4763 printf("%s rejected the NT-error initial session setup (%s)\n",host, cli_errstr(c_nt));
4764 return False;
4767 /* DOS-Error connection */
4769 if (!(c_dos = open_nbt_connection())) {
4770 return False;
4773 c_dos->use_spnego = False;
4774 c_dos->force_dos_errors = True;
4776 if (!cli_negprot(c_dos)) {
4777 printf("%s rejected the DOS-error negprot (%s)\n",host, cli_errstr(c_dos));
4778 cli_shutdown(c_dos);
4779 return False;
4782 if (!NT_STATUS_IS_OK(cli_session_setup(c_dos, "", "", 0, "", 0,
4783 workgroup))) {
4784 printf("%s rejected the DOS-error initial session setup (%s)\n",host, cli_errstr(c_dos));
4785 return False;
4788 for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) {
4789 fstr_sprintf(user, "%X", error);
4791 if (NT_STATUS_IS_OK(cli_session_setup(c_nt, user,
4792 password, strlen(password),
4793 password, strlen(password),
4794 workgroup))) {
4795 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
4798 flgs2 = SVAL(c_nt->inbuf,smb_flg2);
4800 /* Case #1: 32-bit NT errors */
4801 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
4802 nt_status = NT_STATUS(IVAL(c_nt->inbuf,smb_rcls));
4803 } else {
4804 printf("/** Dos error on NT connection! (%s) */\n",
4805 cli_errstr(c_nt));
4806 nt_status = NT_STATUS(0xc0000000);
4809 if (NT_STATUS_IS_OK(cli_session_setup(c_dos, user,
4810 password, strlen(password),
4811 password, strlen(password),
4812 workgroup))) {
4813 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
4815 flgs2 = SVAL(c_dos->inbuf,smb_flg2), errnum;
4817 /* Case #1: 32-bit NT errors */
4818 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
4819 printf("/** NT error on DOS connection! (%s) */\n",
4820 cli_errstr(c_nt));
4821 errnum = errclass = 0;
4822 } else {
4823 cli_dos_error(c_dos, &errclass, &errnum);
4826 if (NT_STATUS_V(nt_status) != error) {
4827 printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n",
4828 get_nt_error_c_code(NT_STATUS(error)),
4829 get_nt_error_c_code(nt_status));
4832 printf("\t{%s,\t%s,\t%s},\n",
4833 smb_dos_err_class(errclass),
4834 smb_dos_err_name(errclass, errnum),
4835 get_nt_error_c_code(NT_STATUS(error)));
4837 return True;
4840 static bool run_sesssetup_bench(int dummy)
4842 static struct cli_state *c;
4843 NTSTATUS status;
4844 int i;
4846 if (!(c = open_nbt_connection())) {
4847 return false;
4850 if (!cli_negprot(c)) {
4851 printf("%s rejected the NT-error negprot (%s)\n", host,
4852 cli_errstr(c));
4853 cli_shutdown(c);
4854 return false;
4857 for (i=0; i<torture_numops; i++) {
4858 status = cli_session_setup(
4859 c, username,
4860 password, strlen(password),
4861 password, strlen(password),
4862 workgroup);
4863 if (!NT_STATUS_IS_OK(status)) {
4864 d_printf("(%s) cli_session_setup failed: %s\n",
4865 __location__, nt_errstr(status));
4866 return false;
4869 if (!cli_ulogoff(c)) {
4870 d_printf("(%s) cli_ulogoff failed: %s\n",
4871 __location__, cli_errstr(c));
4872 return false;
4874 c->vuid = 0;
4877 return true;
4880 static bool subst_test(const char *str, const char *user, const char *domain,
4881 uid_t uid, gid_t gid, const char *expected)
4883 char *subst;
4884 bool result = true;
4886 subst = talloc_sub_specified(talloc_tos(), str, user, domain, uid, gid);
4888 if (strcmp(subst, expected) != 0) {
4889 printf("sub_specified(%s, %s, %s, %d, %d) returned [%s], expected "
4890 "[%s]\n", str, user, domain, (int)uid, (int)gid, subst,
4891 expected);
4892 result = false;
4895 TALLOC_FREE(subst);
4896 return result;
4899 static bool run_local_substitute(int dummy)
4901 bool ok = true;
4903 ok &= subst_test("%U", "bla", "", -1, -1, "bla");
4904 ok &= subst_test("%u%U", "bla", "", -1, -1, "blabla");
4905 ok &= subst_test("%g", "", "", -1, -1, "NO_GROUP");
4906 ok &= subst_test("%G", "", "", -1, -1, "NO_GROUP");
4907 ok &= subst_test("%g", "", "", -1, 0, gidtoname(0));
4908 ok &= subst_test("%G", "", "", -1, 0, gidtoname(0));
4909 ok &= subst_test("%D%u", "u", "dom", -1, 0, "domu");
4910 ok &= subst_test("%i %I", "", "", -1, -1, "0.0.0.0 0.0.0.0");
4912 /* Different captialization rules in sub_basic... */
4914 ok &= (strcmp(talloc_sub_basic(talloc_tos(), "BLA", "dom", "%U%D"),
4915 "blaDOM") == 0);
4917 return ok;
4920 static bool run_local_gencache(int dummy)
4922 char *val;
4923 time_t tm;
4924 DATA_BLOB blob;
4926 if (!gencache_init()) {
4927 d_printf("%s: gencache_init() failed\n", __location__);
4928 return False;
4931 if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
4932 d_printf("%s: gencache_set() failed\n", __location__);
4933 return False;
4936 if (!gencache_get("foo", &val, &tm)) {
4937 d_printf("%s: gencache_get() failed\n", __location__);
4938 return False;
4941 if (strcmp(val, "bar") != 0) {
4942 d_printf("%s: gencache_get() returned %s, expected %s\n",
4943 __location__, val, "bar");
4944 SAFE_FREE(val);
4945 return False;
4948 SAFE_FREE(val);
4950 if (!gencache_del("foo")) {
4951 d_printf("%s: gencache_del() failed\n", __location__);
4952 return False;
4954 if (gencache_del("foo")) {
4955 d_printf("%s: second gencache_del() succeeded\n",
4956 __location__);
4957 return False;
4960 if (gencache_get("foo", &val, &tm)) {
4961 d_printf("%s: gencache_get() on deleted entry "
4962 "succeeded\n", __location__);
4963 return False;
4966 blob = data_blob_string_const("bar");
4967 tm = time(NULL);
4969 if (!gencache_set_data_blob("foo", &blob, tm)) {
4970 d_printf("%s: gencache_set_data_blob() failed\n", __location__);
4971 return False;
4974 data_blob_free(&blob);
4976 if (!gencache_get_data_blob("foo", &blob, NULL)) {
4977 d_printf("%s: gencache_get_data_blob() failed\n", __location__);
4978 return False;
4981 if (strcmp((const char *)blob.data, "bar") != 0) {
4982 d_printf("%s: gencache_get_data_blob() returned %s, expected %s\n",
4983 __location__, (const char *)blob.data, "bar");
4984 data_blob_free(&blob);
4985 return False;
4988 data_blob_free(&blob);
4990 if (!gencache_del("foo")) {
4991 d_printf("%s: gencache_del() failed\n", __location__);
4992 return False;
4994 if (gencache_del("foo")) {
4995 d_printf("%s: second gencache_del() succeeded\n",
4996 __location__);
4997 return False;
5000 if (gencache_get_data_blob("foo", &blob, NULL)) {
5001 d_printf("%s: gencache_get_data_blob() on deleted entry "
5002 "succeeded\n", __location__);
5003 return False;
5006 if (!gencache_shutdown()) {
5007 d_printf("%s: gencache_shutdown() failed\n", __location__);
5008 return False;
5011 if (gencache_shutdown()) {
5012 d_printf("%s: second gencache_shutdown() succeeded\n",
5013 __location__);
5014 return False;
5017 return True;
5020 static bool rbt_testval(struct db_context *db, const char *key,
5021 const char *value)
5023 struct db_record *rec;
5024 TDB_DATA data = string_tdb_data(value);
5025 bool ret = false;
5026 NTSTATUS status;
5028 rec = db->fetch_locked(db, db, string_tdb_data(key));
5029 if (rec == NULL) {
5030 d_fprintf(stderr, "fetch_locked failed\n");
5031 goto done;
5033 status = rec->store(rec, data, 0);
5034 if (!NT_STATUS_IS_OK(status)) {
5035 d_fprintf(stderr, "store failed: %s\n", nt_errstr(status));
5036 goto done;
5038 TALLOC_FREE(rec);
5040 rec = db->fetch_locked(db, db, string_tdb_data(key));
5041 if (rec == NULL) {
5042 d_fprintf(stderr, "second fetch_locked failed\n");
5043 goto done;
5045 if ((rec->value.dsize != data.dsize)
5046 || (memcmp(rec->value.dptr, data.dptr, data.dsize) != 0)) {
5047 d_fprintf(stderr, "Got wrong data back\n");
5048 goto done;
5051 ret = true;
5052 done:
5053 TALLOC_FREE(rec);
5054 return ret;
5057 static bool run_local_rbtree(int dummy)
5059 struct db_context *db;
5060 bool ret = false;
5061 int i;
5063 db = db_open_rbt(NULL);
5065 if (db == NULL) {
5066 d_fprintf(stderr, "db_open_rbt failed\n");
5067 return false;
5070 for (i=0; i<1000; i++) {
5071 char *key, *value;
5073 asprintf(&key, "key%ld", random());
5074 asprintf(&value, "value%ld", random());
5076 if (!rbt_testval(db, key, value)) {
5077 SAFE_FREE(key);
5078 SAFE_FREE(value);
5079 goto done;
5082 SAFE_FREE(value);
5083 asprintf(&value, "value%ld", random());
5085 if (!rbt_testval(db, key, value)) {
5086 SAFE_FREE(key);
5087 SAFE_FREE(value);
5088 goto done;
5091 SAFE_FREE(key);
5092 SAFE_FREE(value);
5095 ret = true;
5097 done:
5098 TALLOC_FREE(db);
5099 return ret;
5102 static bool test_stream_name(const char *fname, const char *expected_base,
5103 const char *expected_stream,
5104 NTSTATUS expected_status)
5106 NTSTATUS status;
5107 char *base = NULL;
5108 char *stream = NULL;
5110 status = split_ntfs_stream_name(talloc_tos(), fname, &base, &stream);
5111 if (!NT_STATUS_EQUAL(status, expected_status)) {
5112 goto error;
5115 if (!NT_STATUS_IS_OK(status)) {
5116 return true;
5119 if (base == NULL) goto error;
5121 if (strcmp(expected_base, base) != 0) goto error;
5123 if ((expected_stream != NULL) && (stream == NULL)) goto error;
5124 if ((expected_stream == NULL) && (stream != NULL)) goto error;
5126 if ((stream != NULL) && (strcmp(expected_stream, stream) != 0))
5127 goto error;
5129 TALLOC_FREE(base);
5130 TALLOC_FREE(stream);
5131 return true;
5133 error:
5134 d_fprintf(stderr, "test_stream(%s, %s, %s, %s)\n",
5135 fname, expected_base ? expected_base : "<NULL>",
5136 expected_stream ? expected_stream : "<NULL>",
5137 nt_errstr(expected_status));
5138 d_fprintf(stderr, "-> base=%s, stream=%s, status=%s\n",
5139 base ? base : "<NULL>", stream ? stream : "<NULL>",
5140 nt_errstr(status));
5141 TALLOC_FREE(base);
5142 TALLOC_FREE(stream);
5143 return false;
5146 static bool run_local_stream_name(int dummy)
5148 bool ret = true;
5150 ret &= test_stream_name(
5151 "bla", "bla", NULL, NT_STATUS_OK);
5152 ret &= test_stream_name(
5153 "bla::$DATA", "bla", NULL, NT_STATUS_OK);
5154 ret &= test_stream_name(
5155 "bla:blub:", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
5156 ret &= test_stream_name(
5157 "bla::", NULL, NULL, NT_STATUS_OBJECT_NAME_INVALID);
5158 ret &= test_stream_name(
5159 "bla::123", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
5160 ret &= test_stream_name(
5161 "bla:$DATA", "bla", "$DATA:$DATA", NT_STATUS_OK);
5162 ret &= test_stream_name(
5163 "bla:x:$DATA", "bla", "x:$DATA", NT_STATUS_OK);
5164 ret &= test_stream_name(
5165 "bla:x", "bla", "x:$DATA", NT_STATUS_OK);
5167 return ret;
5170 static bool data_blob_equal(DATA_BLOB a, DATA_BLOB b)
5172 if (a.length != b.length) {
5173 printf("a.length=%d != b.length=%d\n",
5174 (int)a.length, (int)b.length);
5175 return false;
5177 if (memcmp(a.data, b.data, a.length) != 0) {
5178 printf("a.data and b.data differ\n");
5179 return false;
5181 return true;
5184 static bool run_local_memcache(int dummy)
5186 struct memcache *cache;
5187 DATA_BLOB k1, k2;
5188 DATA_BLOB d1, d2, d3;
5189 DATA_BLOB v1, v2, v3;
5191 TALLOC_CTX *mem_ctx;
5192 char *str1, *str2;
5193 size_t size1, size2;
5194 bool ret = false;
5196 cache = memcache_init(NULL, 100);
5198 if (cache == NULL) {
5199 printf("memcache_init failed\n");
5200 return false;
5203 d1 = data_blob_const("d1", 2);
5204 d2 = data_blob_const("d2", 2);
5205 d3 = data_blob_const("d3", 2);
5207 k1 = data_blob_const("d1", 2);
5208 k2 = data_blob_const("d2", 2);
5210 memcache_add(cache, STAT_CACHE, k1, d1);
5211 memcache_add(cache, GETWD_CACHE, k2, d2);
5213 if (!memcache_lookup(cache, STAT_CACHE, k1, &v1)) {
5214 printf("could not find k1\n");
5215 return false;
5217 if (!data_blob_equal(d1, v1)) {
5218 return false;
5221 if (!memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
5222 printf("could not find k2\n");
5223 return false;
5225 if (!data_blob_equal(d2, v2)) {
5226 return false;
5229 memcache_add(cache, STAT_CACHE, k1, d3);
5231 if (!memcache_lookup(cache, STAT_CACHE, k1, &v3)) {
5232 printf("could not find replaced k1\n");
5233 return false;
5235 if (!data_blob_equal(d3, v3)) {
5236 return false;
5239 memcache_add(cache, GETWD_CACHE, k1, d1);
5241 if (memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
5242 printf("Did find k2, should have been purged\n");
5243 return false;
5246 TALLOC_FREE(cache);
5248 cache = memcache_init(NULL, 0);
5250 mem_ctx = talloc_init("foo");
5252 str1 = talloc_strdup(mem_ctx, "string1");
5253 str2 = talloc_strdup(mem_ctx, "string2");
5255 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
5256 data_blob_string_const("torture"), &str1);
5257 size1 = talloc_total_size(cache);
5259 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
5260 data_blob_string_const("torture"), &str2);
5261 size2 = talloc_total_size(cache);
5263 printf("size1=%d, size2=%d\n", (int)size1, (int)size2);
5265 if (size2 > size1) {
5266 printf("memcache leaks memory!\n");
5267 goto fail;
5270 ret = true;
5271 fail:
5272 TALLOC_FREE(cache);
5273 return ret;
5276 static double create_procs(bool (*fn)(int), bool *result)
5278 int i, status;
5279 volatile pid_t *child_status;
5280 volatile bool *child_status_out;
5281 int synccount;
5282 int tries = 8;
5284 synccount = 0;
5286 child_status = (volatile pid_t *)shm_setup(sizeof(pid_t)*nprocs);
5287 if (!child_status) {
5288 printf("Failed to setup shared memory\n");
5289 return -1;
5292 child_status_out = (volatile bool *)shm_setup(sizeof(bool)*nprocs);
5293 if (!child_status_out) {
5294 printf("Failed to setup result status shared memory\n");
5295 return -1;
5298 for (i = 0; i < nprocs; i++) {
5299 child_status[i] = 0;
5300 child_status_out[i] = True;
5303 start_timer();
5305 for (i=0;i<nprocs;i++) {
5306 procnum = i;
5307 if (fork() == 0) {
5308 pid_t mypid = getpid();
5309 sys_srandom(((int)mypid) ^ ((int)time(NULL)));
5311 slprintf(myname,sizeof(myname),"CLIENT%d", i);
5313 while (1) {
5314 if (torture_open_connection(&current_cli, i)) break;
5315 if (tries-- == 0) {
5316 printf("pid %d failed to start\n", (int)getpid());
5317 _exit(1);
5319 smb_msleep(10);
5322 child_status[i] = getpid();
5324 while (child_status[i] && end_timer() < 5) smb_msleep(2);
5326 child_status_out[i] = fn(i);
5327 _exit(0);
5331 do {
5332 synccount = 0;
5333 for (i=0;i<nprocs;i++) {
5334 if (child_status[i]) synccount++;
5336 if (synccount == nprocs) break;
5337 smb_msleep(10);
5338 } while (end_timer() < 30);
5340 if (synccount != nprocs) {
5341 printf("FAILED TO START %d CLIENTS (started %d)\n", nprocs, synccount);
5342 *result = False;
5343 return end_timer();
5346 /* start the client load */
5347 start_timer();
5349 for (i=0;i<nprocs;i++) {
5350 child_status[i] = 0;
5353 printf("%d clients started\n", nprocs);
5355 for (i=0;i<nprocs;i++) {
5356 while (waitpid(0, &status, 0) == -1 && errno == EINTR) /* noop */ ;
5359 printf("\n");
5361 for (i=0;i<nprocs;i++) {
5362 if (!child_status_out[i]) {
5363 *result = False;
5366 return end_timer();
5369 #define FLAG_MULTIPROC 1
5371 static struct {
5372 const char *name;
5373 bool (*fn)(int);
5374 unsigned flags;
5375 } torture_ops[] = {
5376 {"FDPASS", run_fdpasstest, 0},
5377 {"LOCK1", run_locktest1, 0},
5378 {"LOCK2", run_locktest2, 0},
5379 {"LOCK3", run_locktest3, 0},
5380 {"LOCK4", run_locktest4, 0},
5381 {"LOCK5", run_locktest5, 0},
5382 {"LOCK6", run_locktest6, 0},
5383 {"LOCK7", run_locktest7, 0},
5384 {"UNLINK", run_unlinktest, 0},
5385 {"BROWSE", run_browsetest, 0},
5386 {"ATTR", run_attrtest, 0},
5387 {"TRANS2", run_trans2test, 0},
5388 {"MAXFID", run_maxfidtest, FLAG_MULTIPROC},
5389 {"TORTURE",run_torture, FLAG_MULTIPROC},
5390 {"RANDOMIPC", run_randomipc, 0},
5391 {"NEGNOWAIT", run_negprot_nowait, 0},
5392 {"NBENCH", run_nbench, 0},
5393 {"OPLOCK1", run_oplock1, 0},
5394 {"OPLOCK2", run_oplock2, 0},
5395 {"OPLOCK3", run_oplock3, 0},
5396 {"DIR", run_dirtest, 0},
5397 {"DIR1", run_dirtest1, 0},
5398 {"DENY1", torture_denytest1, 0},
5399 {"DENY2", torture_denytest2, 0},
5400 {"TCON", run_tcon_test, 0},
5401 {"TCONDEV", run_tcon_devtype_test, 0},
5402 {"RW1", run_readwritetest, 0},
5403 {"RW2", run_readwritemulti, FLAG_MULTIPROC},
5404 {"RW3", run_readwritelarge, 0},
5405 {"OPEN", run_opentest, 0},
5406 #if 1
5407 {"OPENATTR", run_openattrtest, 0},
5408 #endif
5409 {"XCOPY", run_xcopy, 0},
5410 {"RENAME", run_rename, 0},
5411 {"DELETE", run_deletetest, 0},
5412 {"PROPERTIES", run_properties, 0},
5413 {"MANGLE", torture_mangle, 0},
5414 {"W2K", run_w2ktest, 0},
5415 {"TRANS2SCAN", torture_trans2_scan, 0},
5416 {"NTTRANSSCAN", torture_nttrans_scan, 0},
5417 {"UTABLE", torture_utable, 0},
5418 {"CASETABLE", torture_casetable, 0},
5419 {"ERRMAPEXTRACT", run_error_map_extract, 0},
5420 {"PIPE_NUMBER", run_pipe_number, 0},
5421 {"TCON2", run_tcon2_test, 0},
5422 {"IOCTL", torture_ioctl_test, 0},
5423 {"CHKPATH", torture_chkpath_test, 0},
5424 {"FDSESS", run_fdsesstest, 0},
5425 { "EATEST", run_eatest, 0},
5426 { "SESSSETUP_BENCH", run_sesssetup_bench, 0},
5427 { "LOCAL-SUBSTITUTE", run_local_substitute, 0},
5428 { "LOCAL-GENCACHE", run_local_gencache, 0},
5429 { "LOCAL-RBTREE", run_local_rbtree, 0},
5430 { "LOCAL-MEMCACHE", run_local_memcache, 0},
5431 { "LOCAL-STREAM-NAME", run_local_stream_name, 0},
5432 {NULL, NULL, 0}};
5436 /****************************************************************************
5437 run a specified test or "ALL"
5438 ****************************************************************************/
5439 static bool run_test(const char *name)
5441 bool ret = True;
5442 bool result = True;
5443 bool found = False;
5444 int i;
5445 double t;
5446 if (strequal(name,"ALL")) {
5447 for (i=0;torture_ops[i].name;i++) {
5448 run_test(torture_ops[i].name);
5450 found = True;
5453 for (i=0;torture_ops[i].name;i++) {
5454 fstr_sprintf(randomfname, "\\XX%x",
5455 (unsigned)random());
5457 if (strequal(name, torture_ops[i].name)) {
5458 found = True;
5459 printf("Running %s\n", name);
5460 if (torture_ops[i].flags & FLAG_MULTIPROC) {
5461 t = create_procs(torture_ops[i].fn, &result);
5462 if (!result) {
5463 ret = False;
5464 printf("TEST %s FAILED!\n", name);
5467 } else {
5468 start_timer();
5469 if (!torture_ops[i].fn(0)) {
5470 ret = False;
5471 printf("TEST %s FAILED!\n", name);
5473 t = end_timer();
5475 printf("%s took %g secs\n\n", name, t);
5479 if (!found) {
5480 printf("Did not find a test named %s\n", name);
5481 ret = False;
5484 return ret;
5488 static void usage(void)
5490 int i;
5492 printf("WARNING samba4 test suite is much more complete nowadays.\n");
5493 printf("Please use samba4 torture.\n\n");
5495 printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
5497 printf("\t-d debuglevel\n");
5498 printf("\t-U user%%pass\n");
5499 printf("\t-k use kerberos\n");
5500 printf("\t-N numprocs\n");
5501 printf("\t-n my_netbios_name\n");
5502 printf("\t-W workgroup\n");
5503 printf("\t-o num_operations\n");
5504 printf("\t-O socket_options\n");
5505 printf("\t-m maximum protocol\n");
5506 printf("\t-L use oplocks\n");
5507 printf("\t-c CLIENT.TXT specify client load file for NBENCH\n");
5508 printf("\t-A showall\n");
5509 printf("\t-p port\n");
5510 printf("\t-s seed\n");
5511 printf("\t-b unclist_filename specify multiple shares for multiple connections\n");
5512 printf("\n\n");
5514 printf("tests are:");
5515 for (i=0;torture_ops[i].name;i++) {
5516 printf(" %s", torture_ops[i].name);
5518 printf("\n");
5520 printf("default test is ALL\n");
5522 exit(1);
5525 /****************************************************************************
5526 main program
5527 ****************************************************************************/
5528 int main(int argc,char *argv[])
5530 int opt, i;
5531 char *p;
5532 int gotuser = 0;
5533 int gotpass = 0;
5534 bool correct = True;
5535 TALLOC_CTX *frame = talloc_stackframe();
5536 int seed = time(NULL);
5538 dbf = x_stdout;
5540 #ifdef HAVE_SETBUFFER
5541 setbuffer(stdout, NULL, 0);
5542 #endif
5544 load_case_tables();
5546 lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
5547 load_interfaces();
5549 if (argc < 2) {
5550 usage();
5553 for(p = argv[1]; *p; p++)
5554 if(*p == '\\')
5555 *p = '/';
5557 if (strncmp(argv[1], "//", 2)) {
5558 usage();
5561 fstrcpy(host, &argv[1][2]);
5562 p = strchr_m(&host[2],'/');
5563 if (!p) {
5564 usage();
5566 *p = 0;
5567 fstrcpy(share, p+1);
5569 fstrcpy(myname, get_myname(talloc_tos()));
5570 if (!*myname) {
5571 fprintf(stderr, "Failed to get my hostname.\n");
5572 return 1;
5575 if (*username == 0 && getenv("LOGNAME")) {
5576 fstrcpy(username,getenv("LOGNAME"));
5579 argc--;
5580 argv++;
5582 fstrcpy(workgroup, lp_workgroup());
5584 while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ld:Aec:ks:b:")) != EOF) {
5585 switch (opt) {
5586 case 'p':
5587 port_to_use = atoi(optarg);
5588 break;
5589 case 's':
5590 seed = atoi(optarg);
5591 break;
5592 case 'W':
5593 fstrcpy(workgroup,optarg);
5594 break;
5595 case 'm':
5596 max_protocol = interpret_protocol(optarg, max_protocol);
5597 break;
5598 case 'N':
5599 nprocs = atoi(optarg);
5600 break;
5601 case 'o':
5602 torture_numops = atoi(optarg);
5603 break;
5604 case 'd':
5605 DEBUGLEVEL = atoi(optarg);
5606 break;
5607 case 'O':
5608 sockops = optarg;
5609 break;
5610 case 'L':
5611 use_oplocks = True;
5612 break;
5613 case 'A':
5614 torture_showall = True;
5615 break;
5616 case 'n':
5617 fstrcpy(myname, optarg);
5618 break;
5619 case 'c':
5620 client_txt = optarg;
5621 break;
5622 case 'e':
5623 do_encrypt = true;
5624 break;
5625 case 'k':
5626 #ifdef HAVE_KRB5
5627 use_kerberos = True;
5628 #else
5629 d_printf("No kerberos support compiled in\n");
5630 exit(1);
5631 #endif
5632 break;
5633 case 'U':
5634 gotuser = 1;
5635 fstrcpy(username,optarg);
5636 p = strchr_m(username,'%');
5637 if (p) {
5638 *p = 0;
5639 fstrcpy(password, p+1);
5640 gotpass = 1;
5642 break;
5643 case 'b':
5644 fstrcpy(multishare_conn_fname, optarg);
5645 use_multishare_conn = True;
5646 break;
5647 default:
5648 printf("Unknown option %c (%d)\n", (char)opt, opt);
5649 usage();
5653 d_printf("using seed %d\n", seed);
5655 srandom(seed);
5657 if(use_kerberos && !gotuser) gotpass = True;
5659 while (!gotpass) {
5660 p = getpass("Password:");
5661 if (p) {
5662 fstrcpy(password, p);
5663 gotpass = 1;
5667 printf("host=%s share=%s user=%s myname=%s\n",
5668 host, share, username, myname);
5670 if (argc == optind) {
5671 correct = run_test("ALL");
5672 } else {
5673 for (i=optind;i<argc;i++) {
5674 if (!run_test(argv[i])) {
5675 correct = False;
5680 TALLOC_FREE(frame);
5682 if (correct) {
5683 return(0);
5684 } else {
5685 return(1);