2 Unix SMB/Netbios implementation.
5 Copyright (C) Andrew Tridgell 1997-1998
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 static fstring host, workgroup, share, password, username, myname;
27 static int max_protocol = PROTOCOL_NT1;
28 static char *sockops="TCP_NODELAY";
29 static int nprocs=1, numops=100;
30 static int procnum; /* records process count number when forking */
31 static struct cli_state current_cli;
32 static fstring randomfname;
33 static BOOL use_oplocks;
34 static BOOL use_level_II_oplocks;
35 BOOL torture_showall = False;
37 static double create_procs(BOOL (*fn)(int), BOOL *result);
40 static struct timeval tp1,tp2;
42 static void start_timer(void)
44 gettimeofday(&tp1,NULL);
47 static double end_timer(void)
49 gettimeofday(&tp2,NULL);
50 return((tp2.tv_sec - tp1.tv_sec) +
51 (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
55 /* return a pointer to a anonymous shared memory segment of size "size"
56 which will persist across fork() but will disappear when all processes
59 The memory is not zeroed
61 This function uses system5 shared memory. It takes advantage of a property
62 that the memory is not destroyed if it is attached when the id is removed
64 static void *shm_setup(int size)
69 shmid = shmget(IPC_PRIVATE, size, SHM_R | SHM_W);
71 printf("can't get shared memory\n");
74 ret = (void *)shmat(shmid, 0, 0);
75 if (!ret || ret == (void *)-1) {
76 printf("can't attach to shared memory\n");
79 /* the following releases the ipc, but note that this process
80 and all its children will still have access to the memory, its
81 just that the shmid is no longer valid for other shm calls. This
82 means we don't leave behind lots of shm segments after we exit
84 See Stevens "advanced programming in unix env" for details
86 shmctl(shmid, IPC_RMID, 0);
92 static BOOL open_nbt_connection(struct cli_state *c)
94 struct nmb_name called, calling;
99 make_nmb_name(&calling, myname, 0x0);
100 make_nmb_name(&called , host, 0x20);
104 if (!cli_initialise(c) || !cli_connect(c, host, &ip)) {
105 printf("Failed to connect with %s\n", host);
109 c->timeout = 120000; /* set a really long timeout (2 minutes) */
110 if (use_oplocks) c->use_oplocks = True;
111 if (use_level_II_oplocks) c->use_level_II_oplocks = True;
113 if (!cli_session_request(c, &calling, &called)) {
114 printf("%s rejected the session\n",host);
122 BOOL torture_open_connection(struct cli_state *c)
126 if (!open_nbt_connection(c)) {
130 if (!cli_negprot(c)) {
131 printf("%s rejected the negprot (%s)\n",host, cli_errstr(c));
136 if (!cli_session_setup(c, username,
137 password, strlen(password),
138 password, strlen(password),
140 printf("%s rejected the sessionsetup (%s)\n", host, cli_errstr(c));
145 if (!cli_send_tconX(c, share, "?????",
146 password, strlen(password)+1)) {
147 printf("%s refused tree connect (%s)\n", host, cli_errstr(c));
156 BOOL torture_close_connection(struct cli_state *c)
160 printf("tdis failed (%s)\n", cli_errstr(c));
170 /* check if the server produced the expected error code */
171 static BOOL check_error(int line, struct cli_state *c,
172 uint8 eclass, uint32 ecode, NTSTATUS nterr)
174 if (cli_is_dos_error(c)) {
178 /* Check DOS error */
180 cli_dos_error(c, &class, &num);
182 if (eclass != class || ecode != num) {
183 printf("unexpected error code class=%d code=%d\n",
184 (int)class, (int)num);
185 printf(" expected %d/%d %s (line=%d)\n",
186 (int)eclass, (int)ecode, get_nt_error_msg(nterr), line);
195 status = cli_nt_error(c);
197 if (NT_STATUS_V(nterr) != NT_STATUS_V(status)) {
198 printf("unexpected error code %s\n", get_nt_error_msg(status));
199 printf(" expected %s (line=%d)\n", get_nt_error_msg(nterr), line);
208 static BOOL wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len)
210 while (!cli_lock(c, fnum, offset, len, -1, WRITE_LOCK)) {
211 if (!check_error(__LINE__, c, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
217 static BOOL rw_torture(struct cli_state *c)
219 char *lockfname = "\\torture.lck";
223 pid_t pid2, pid = getpid();
228 fnum2 = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
231 fnum2 = cli_open(c, lockfname, O_RDWR, DENY_NONE);
233 printf("open of %s failed (%s)\n", lockfname, cli_errstr(c));
238 for (i=0;i<numops;i++) {
239 unsigned n = (unsigned)sys_random()%10;
241 printf("%d\r", i); fflush(stdout);
243 slprintf(fname, sizeof(fstring) - 1, "\\torture.%u", n);
245 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
249 fnum = cli_open(c, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL);
251 printf("open failed (%s)\n", cli_errstr(c));
256 if (cli_write(c, fnum, 0, (char *)&pid, 0, sizeof(pid)) != sizeof(pid)) {
257 printf("write failed (%s)\n", cli_errstr(c));
262 if (cli_write(c, fnum, 0, (char *)buf,
263 sizeof(pid)+(j*sizeof(buf)),
264 sizeof(buf)) != sizeof(buf)) {
265 printf("write failed (%s)\n", cli_errstr(c));
272 if (cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid)) != sizeof(pid)) {
273 printf("read failed (%s)\n", cli_errstr(c));
278 printf("data corruption!\n");
282 if (!cli_close(c, fnum)) {
283 printf("close failed (%s)\n", cli_errstr(c));
287 if (!cli_unlink(c, fname)) {
288 printf("unlink failed (%s)\n", cli_errstr(c));
292 if (!cli_unlock(c, fnum2, n*sizeof(int), sizeof(int))) {
293 printf("unlock failed (%s)\n", cli_errstr(c));
299 cli_unlink(c, lockfname);
306 static BOOL run_torture(int dummy)
308 struct cli_state cli;
313 cli_sockopt(&cli, sockops);
315 ret = rw_torture(&cli);
317 if (!torture_close_connection(&cli)) {
324 static BOOL rw_torture3(struct cli_state *c, char *lockfname)
331 unsigned countprev = 0;
336 for (i = 0; i < sizeof(buf); i += sizeof(uint32))
338 SIVAL(buf, i, sys_random());
343 fnum = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
346 printf("first open read/write of %s failed (%s)\n",
347 lockfname, cli_errstr(c));
353 for (i = 0; i < 500 && fnum == -1; i++)
355 fnum = cli_open(c, lockfname, O_RDONLY,
360 printf("second open read-only of %s failed (%s)\n",
361 lockfname, cli_errstr(c));
367 for (count = 0; count < sizeof(buf); count += sent)
369 if (count >= countprev) {
370 printf("%d %8d\r", i, count);
373 countprev += (sizeof(buf) / 20);
378 sent = ((unsigned)sys_random()%(20))+ 1;
379 if (sent > sizeof(buf) - count)
381 sent = sizeof(buf) - count;
384 if (cli_write(c, fnum, 0, buf+count, count, (size_t)sent) != sent) {
385 printf("write failed (%s)\n", cli_errstr(c));
391 sent = cli_read(c, fnum, buf_rd+count, count,
395 printf("read failed offset:%d size:%d (%s)\n",
396 count, sizeof(buf)-count,
403 if (memcmp(buf_rd+count, buf+count, sent) != 0)
405 printf("read/write compare failed\n");
406 printf("offset: %d req %d recvd %d\n",
407 count, sizeof(buf)-count, sent);
416 if (!cli_close(c, fnum)) {
417 printf("close failed (%s)\n", cli_errstr(c));
424 static BOOL rw_torture2(struct cli_state *c1, struct cli_state *c2)
426 char *lockfname = "\\torture2.lck";
431 uchar buf_rd[131072];
435 if (!cli_unlink(c1, lockfname)) {
436 printf("unlink failed (%s) (normal, this file should not exist)\n", cli_errstr(c1));
439 fnum1 = cli_open(c1, lockfname, O_RDWR | O_CREAT | O_EXCL,
442 printf("first open read/write of %s failed (%s)\n",
443 lockfname, cli_errstr(c1));
446 fnum2 = cli_open(c2, lockfname, O_RDONLY,
449 printf("second open read-only of %s failed (%s)\n",
450 lockfname, cli_errstr(c2));
451 cli_close(c1, fnum1);
455 for (i=0;i<numops;i++)
457 size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
459 printf("%d\r", i); fflush(stdout);
462 generate_random_buffer(buf, buf_size, False);
464 if (cli_write(c1, fnum1, 0, buf, 0, buf_size) != buf_size) {
465 printf("write failed (%s)\n", cli_errstr(c1));
469 if ((bytes_read = cli_read(c2, fnum2, buf_rd, 0, buf_size)) != buf_size) {
470 printf("read failed (%s)\n", cli_errstr(c2));
471 printf("read %d, expected %d\n", bytes_read, buf_size);
475 if (memcmp(buf_rd, buf, buf_size) != 0)
477 printf("read/write compare failed\n");
482 if (!cli_close(c2, fnum2)) {
483 printf("close failed (%s)\n", cli_errstr(c2));
486 if (!cli_close(c1, fnum1)) {
487 printf("close failed (%s)\n", cli_errstr(c1));
491 if (!cli_unlink(c1, lockfname)) {
492 printf("unlink failed (%s)\n", cli_errstr(c1));
499 static BOOL run_readwritetest(int dummy)
501 static struct cli_state cli1, cli2;
504 if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
507 cli_sockopt(&cli1, sockops);
508 cli_sockopt(&cli2, sockops);
510 printf("starting readwritetest\n");
512 test1 = rw_torture2(&cli1, &cli2);
513 printf("Passed readwritetest v1: %s\n", BOOLSTR(test1));
515 test2 = rw_torture2(&cli1, &cli1);
516 printf("Passed readwritetest v2: %s\n", BOOLSTR(test2));
518 if (!torture_close_connection(&cli1)) {
522 if (!torture_close_connection(&cli2)) {
526 return (test1 && test2);
529 static BOOL run_readwritemulti(int dummy)
531 static struct cli_state cli;
536 cli_sockopt(&cli, sockops);
538 printf("run_readwritemulti: fname %s\n", randomfname);
539 test = rw_torture3(&cli, randomfname);
541 if (!torture_close_connection(&cli)) {
548 static BOOL run_readwritelarge(int dummy)
550 static struct cli_state cli1;
552 char *lockfname = "\\large.dat";
557 if (!torture_open_connection(&cli1)) {
560 cli_sockopt(&cli1, sockops);
561 memset(buf,'\0',sizeof(buf));
563 cli1.max_xmit = 0x11000;
565 printf("starting readwritelarge\n");
567 cli_unlink(&cli1, lockfname);
569 fnum1 = cli_open(&cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE);
571 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(&cli1));
575 cli_write(&cli1, fnum1, 0, buf, 0, sizeof(buf));
577 if (!cli_close(&cli1, fnum1)) {
578 printf("close failed (%s)\n", cli_errstr(&cli1));
582 if (!cli_qpathinfo(&cli1, lockfname, NULL, NULL, NULL, &fsize, NULL)) {
583 printf("qpathinfo failed (%s)\n", cli_errstr(&cli1));
587 if (fsize == sizeof(buf))
588 printf("readwritelarge test 1 succeeded (size = %x)\n", fsize);
590 printf("readwritelarge test 1 failed (size = %x)\n", fsize);
594 if (!cli_unlink(&cli1, lockfname)) {
595 printf("unlink failed (%s)\n", cli_errstr(&cli1));
599 fnum1 = cli_open(&cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE);
601 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(&cli1));
605 cli_smbwrite(&cli1, fnum1, buf, 0, sizeof(buf));
607 if (!cli_close(&cli1, fnum1)) {
608 printf("close failed (%s)\n", cli_errstr(&cli1));
612 if (!torture_close_connection(&cli1)) {
620 /* run a test that simulates an approximate netbench client load */
621 static BOOL run_netbench(int client)
623 struct cli_state cli;
634 cli_sockopt(&cli, sockops);
638 slprintf(cname,sizeof(fname), "CLIENT%d", client);
640 f = fopen("client.txt", "r");
643 perror("client.txt");
647 while (fgets(line, sizeof(line)-1, f)) {
650 line[strlen(line)-1] = 0;
652 /* printf("[%d] %s\n", line_count, line); */
654 all_string_sub(line,"CLIENT1", cname, sizeof(line));
656 for (i=0;i<20;i++) params[i] = "";
658 /* parse the command parameters */
659 params[0] = strtok(line," ");
661 while (params[i]) params[++i] = strtok(NULL," ");
667 if (strcmp(params[1],"REQUEST") == 0) {
668 if (!strcmp(params[0],"SMBopenX")) {
669 fstrcpy(fname, params[5]);
670 } else if (!strcmp(params[0],"SMBclose")) {
671 nb_close(atoi(params[3]));
672 } else if (!strcmp(params[0],"SMBmkdir")) {
674 } else if (!strcmp(params[0],"CREATE")) {
675 nb_create(params[3], atoi(params[5]));
676 } else if (!strcmp(params[0],"SMBrmdir")) {
678 } else if (!strcmp(params[0],"SMBunlink")) {
679 fstrcpy(fname, params[3]);
680 } else if (!strcmp(params[0],"SMBmv")) {
681 nb_rename(params[3], params[5]);
682 } else if (!strcmp(params[0],"SMBgetatr")) {
683 fstrcpy(fname, params[3]);
684 } else if (!strcmp(params[0],"SMBwrite")) {
685 nb_write(atoi(params[3]),
686 atoi(params[5]), atoi(params[7]));
687 } else if (!strcmp(params[0],"SMBwritebraw")) {
688 nb_write(atoi(params[3]),
689 atoi(params[7]), atoi(params[5]));
690 } else if (!strcmp(params[0],"SMBreadbraw")) {
691 nb_read(atoi(params[3]),
692 atoi(params[7]), atoi(params[5]));
693 } else if (!strcmp(params[0],"SMBread")) {
694 nb_read(atoi(params[3]),
695 atoi(params[5]), atoi(params[7]));
698 if (!strcmp(params[0],"SMBopenX")) {
699 if (!strncmp(params[2], "ERR", 3)) continue;
700 nb_open(fname, atoi(params[3]), atoi(params[5]));
701 } else if (!strcmp(params[0],"SMBgetatr")) {
702 if (!strncmp(params[2], "ERR", 3)) continue;
703 nb_stat(fname, atoi(params[3]));
704 } else if (!strcmp(params[0],"SMBunlink")) {
705 if (!strncmp(params[2], "ERR", 3)) continue;
712 slprintf(fname,sizeof(fname), "CLIENTS/CLIENT%d", client);
718 if (!torture_close_connection(&cli)) {
726 /* run a test that simulates an approximate netbench w9X client load */
727 static BOOL run_nbw95(int dummy)
731 t = create_procs(run_netbench, &correct);
732 /* to produce a netbench result we scale accoding to the
733 netbench measured throughput for the run that produced the
734 sniff that was used to produce client.txt. That run used 2
735 clients and ran for 660 seconds to produce a result of
737 printf("Throughput %g MB/sec (NB=%g MB/sec %g MBit/sec)\n",
738 132*nprocs/t, 0.5*0.5*nprocs*660/t, 2*nprocs*660/t);
742 /* run a test that simulates an approximate netbench wNT client load */
743 static BOOL run_nbwnt(int dummy)
747 t = create_procs(run_netbench, &correct);
748 printf("Throughput %g MB/sec (NB=%g MB/sec %g MBit/sec)\n",
749 132*nprocs/t, 0.5*0.5*nprocs*660/t, 2*nprocs*660/t);
756 This test checks for two things:
758 1) correct support for retaining locks over a close (ie. the server
759 must not use posix semantics)
760 2) support for lock timeouts
762 static BOOL run_locktest1(int dummy)
764 static struct cli_state cli1, cli2;
765 char *fname = "\\lockt1.lck";
766 int fnum1, fnum2, fnum3;
769 if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
772 cli_sockopt(&cli1, sockops);
773 cli_sockopt(&cli2, sockops);
775 printf("starting locktest1\n");
777 cli_unlink(&cli1, fname);
779 fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
781 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1));
784 fnum2 = cli_open(&cli1, fname, O_RDWR, DENY_NONE);
786 printf("open2 of %s failed (%s)\n", fname, cli_errstr(&cli1));
789 fnum3 = cli_open(&cli2, fname, O_RDWR, DENY_NONE);
791 printf("open3 of %s failed (%s)\n", fname, cli_errstr(&cli2));
795 if (!cli_lock(&cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
796 printf("lock1 failed (%s)\n", cli_errstr(&cli1));
801 if (cli_lock(&cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
802 printf("lock2 succeeded! This is a locking bug\n");
805 if (!check_error(__LINE__, &cli2, ERRDOS, ERRlock,
806 NT_STATUS_LOCK_NOT_GRANTED)) return False;
810 printf("Testing lock timeouts\n");
812 if (cli_lock(&cli2, fnum3, 0, 4, 10*1000, WRITE_LOCK)) {
813 printf("lock3 succeeded! This is a locking bug\n");
816 if (!check_error(__LINE__, &cli2, ERRDOS, ERRlock,
817 NT_STATUS_LOCK_NOT_GRANTED)) return False;
822 printf("error: This server appears not to support timed lock requests\n");
825 if (!cli_close(&cli1, fnum2)) {
826 printf("close1 failed (%s)\n", cli_errstr(&cli1));
830 if (cli_lock(&cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
831 printf("lock4 succeeded! This is a locking bug\n");
834 if (!check_error(__LINE__, &cli2, ERRDOS, ERRlock,
835 NT_STATUS_LOCK_NOT_GRANTED)) return False;
838 if (!cli_close(&cli1, fnum1)) {
839 printf("close2 failed (%s)\n", cli_errstr(&cli1));
843 if (!cli_close(&cli2, fnum3)) {
844 printf("close3 failed (%s)\n", cli_errstr(&cli2));
848 if (!cli_unlink(&cli1, fname)) {
849 printf("unlink failed (%s)\n", cli_errstr(&cli1));
854 if (!torture_close_connection(&cli1)) {
858 if (!torture_close_connection(&cli2)) {
862 printf("Passed locktest1\n");
867 checks for correct tconX support
869 static BOOL run_tcon_test(int dummy)
871 static struct cli_state cli1;
872 char *fname = "\\tcontest.tmp";
877 if (!torture_open_connection(&cli1)) {
880 cli_sockopt(&cli1, sockops);
882 printf("starting tcontest\n");
884 cli_unlink(&cli1, fname);
886 fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
889 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1));
895 if (cli_write(&cli1, fnum1, 0, buf, 130, 4) != 4)
897 printf("write failed (%s)", cli_errstr(&cli1));
901 if (!cli_send_tconX(&cli1, share, "?????",
902 password, strlen(password)+1)) {
903 printf("%s refused 2nd tree connect (%s)\n", host,
909 if (cli_write(&cli1, fnum1, 0, buf, 130, 4) == 4)
911 printf("write succeeded (%s)", cli_errstr(&cli1));
915 if (cli_close(&cli1, fnum1)) {
916 printf("close2 succeeded (%s)\n", cli_errstr(&cli1));
920 if (!cli_tdis(&cli1)) {
921 printf("tdis failed (%s)\n", cli_errstr(&cli1));
927 if (!cli_close(&cli1, fnum1)) {
928 printf("close2 failed (%s)\n", cli_errstr(&cli1));
932 if (!torture_close_connection(&cli1)) {
936 printf("Passed tcontest\n");
942 This test checks that
944 1) the server supports multiple locking contexts on the one SMB
945 connection, distinguished by PID.
947 2) the server correctly fails overlapping locks made by the same PID (this
948 goes against POSIX behaviour, which is why it is tricky to implement)
950 3) the server denies unlock requests by an incorrect client PID
952 static BOOL run_locktest2(int dummy)
954 static struct cli_state cli;
955 char *fname = "\\lockt2.lck";
956 int fnum1, fnum2, fnum3;
959 if (!torture_open_connection(&cli)) {
963 cli_sockopt(&cli, sockops);
965 printf("starting locktest2\n");
967 cli_unlink(&cli, fname);
971 fnum1 = cli_open(&cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
973 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli));
977 fnum2 = cli_open(&cli, fname, O_RDWR, DENY_NONE);
979 printf("open2 of %s failed (%s)\n", fname, cli_errstr(&cli));
985 fnum3 = cli_open(&cli, fname, O_RDWR, DENY_NONE);
987 printf("open3 of %s failed (%s)\n", fname, cli_errstr(&cli));
993 if (!cli_lock(&cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
994 printf("lock1 failed (%s)\n", cli_errstr(&cli));
998 if (cli_lock(&cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
999 printf("WRITE lock1 succeeded! This is a locking bug\n");
1002 if (!check_error(__LINE__, &cli, ERRDOS, ERRlock,
1003 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1006 if (cli_lock(&cli, fnum2, 0, 4, 0, WRITE_LOCK)) {
1007 printf("WRITE lock2 succeeded! This is a locking bug\n");
1010 if (!check_error(__LINE__, &cli, ERRDOS, ERRlock,
1011 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1014 if (cli_lock(&cli, fnum2, 0, 4, 0, READ_LOCK)) {
1015 printf("READ lock2 succeeded! This is a locking bug\n");
1018 if (!check_error(__LINE__, &cli, ERRDOS, ERRlock,
1019 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1022 if (!cli_lock(&cli, fnum1, 100, 4, 0, WRITE_LOCK)) {
1023 printf("lock at 100 failed (%s)\n", cli_errstr(&cli));
1025 cli_setpid(&cli, 2);
1026 if (cli_unlock(&cli, fnum1, 100, 4)) {
1027 printf("unlock at 100 succeeded! This is a locking bug\n");
1031 if (cli_unlock(&cli, fnum1, 0, 4)) {
1032 printf("unlock1 succeeded! This is a locking bug\n");
1035 if (!check_error(__LINE__, &cli,
1037 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1040 if (cli_unlock(&cli, fnum1, 0, 8)) {
1041 printf("unlock2 succeeded! This is a locking bug\n");
1044 if (!check_error(__LINE__, &cli,
1046 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1049 if (cli_lock(&cli, fnum3, 0, 4, 0, WRITE_LOCK)) {
1050 printf("lock3 succeeded! This is a locking bug\n");
1053 if (!check_error(__LINE__, &cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
1056 cli_setpid(&cli, 1);
1058 if (!cli_close(&cli, fnum1)) {
1059 printf("close1 failed (%s)\n", cli_errstr(&cli));
1063 if (!cli_close(&cli, fnum2)) {
1064 printf("close2 failed (%s)\n", cli_errstr(&cli));
1068 if (!cli_close(&cli, fnum3)) {
1069 printf("close3 failed (%s)\n", cli_errstr(&cli));
1073 if (!torture_close_connection(&cli)) {
1077 printf("locktest2 finished\n");
1084 This test checks that
1086 1) the server supports the full offset range in lock requests
1088 static BOOL run_locktest3(int dummy)
1090 static struct cli_state cli1, cli2;
1091 char *fname = "\\lockt3.lck";
1092 int fnum1, fnum2, i;
1094 BOOL correct = True;
1096 #define NEXT_OFFSET offset += (~(uint32)0) / numops
1098 if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
1101 cli_sockopt(&cli1, sockops);
1102 cli_sockopt(&cli2, sockops);
1104 printf("starting locktest3\n");
1106 cli_unlink(&cli1, fname);
1108 fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1110 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1));
1113 fnum2 = cli_open(&cli2, fname, O_RDWR, DENY_NONE);
1115 printf("open2 of %s failed (%s)\n", fname, cli_errstr(&cli2));
1119 for (offset=i=0;i<numops;i++) {
1121 if (!cli_lock(&cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1122 printf("lock1 %d failed (%s)\n",
1128 if (!cli_lock(&cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1129 printf("lock2 %d failed (%s)\n",
1136 for (offset=i=0;i<numops;i++) {
1139 if (cli_lock(&cli1, fnum1, offset-2, 1, 0, WRITE_LOCK)) {
1140 printf("error: lock1 %d succeeded!\n", i);
1144 if (cli_lock(&cli2, fnum2, offset-1, 1, 0, WRITE_LOCK)) {
1145 printf("error: lock2 %d succeeded!\n", i);
1149 if (cli_lock(&cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1150 printf("error: lock3 %d succeeded!\n", i);
1154 if (cli_lock(&cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1155 printf("error: lock4 %d succeeded!\n", i);
1160 for (offset=i=0;i<numops;i++) {
1163 if (!cli_unlock(&cli1, fnum1, offset-1, 1)) {
1164 printf("unlock1 %d failed (%s)\n",
1170 if (!cli_unlock(&cli2, fnum2, offset-2, 1)) {
1171 printf("unlock2 %d failed (%s)\n",
1178 if (!cli_close(&cli1, fnum1)) {
1179 printf("close1 failed (%s)\n", cli_errstr(&cli1));
1183 if (!cli_close(&cli2, fnum2)) {
1184 printf("close2 failed (%s)\n", cli_errstr(&cli2));
1188 if (!cli_unlink(&cli1, fname)) {
1189 printf("unlink failed (%s)\n", cli_errstr(&cli1));
1193 if (!torture_close_connection(&cli1)) {
1197 if (!torture_close_connection(&cli2)) {
1201 printf("finished locktest3\n");
1206 #define EXPECTED(ret, v) if ((ret) != (v)) { \
1207 printf("** "); correct = False; \
1211 looks at overlapping locks
1213 static BOOL run_locktest4(int dummy)
1215 static struct cli_state cli1, cli2;
1216 char *fname = "\\lockt4.lck";
1217 int fnum1, fnum2, f;
1220 BOOL correct = True;
1222 if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
1226 cli_sockopt(&cli1, sockops);
1227 cli_sockopt(&cli2, sockops);
1229 printf("starting locktest4\n");
1231 cli_unlink(&cli1, fname);
1233 fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1234 fnum2 = cli_open(&cli2, fname, O_RDWR, DENY_NONE);
1236 memset(buf, 0, sizeof(buf));
1238 if (cli_write(&cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1239 printf("Failed to create file\n");
1244 ret = cli_lock(&cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1245 cli_lock(&cli1, fnum1, 2, 4, 0, WRITE_LOCK);
1246 EXPECTED(ret, False);
1247 printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
1249 ret = cli_lock(&cli1, fnum1, 10, 4, 0, READ_LOCK) &&
1250 cli_lock(&cli1, fnum1, 12, 4, 0, READ_LOCK);
1251 EXPECTED(ret, True);
1252 printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
1254 ret = cli_lock(&cli1, fnum1, 20, 4, 0, WRITE_LOCK) &&
1255 cli_lock(&cli2, fnum2, 22, 4, 0, WRITE_LOCK);
1256 EXPECTED(ret, False);
1257 printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
1259 ret = cli_lock(&cli1, fnum1, 30, 4, 0, READ_LOCK) &&
1260 cli_lock(&cli2, fnum2, 32, 4, 0, READ_LOCK);
1261 EXPECTED(ret, True);
1262 printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
1264 ret = (cli_setpid(&cli1, 1), cli_lock(&cli1, fnum1, 40, 4, 0, WRITE_LOCK)) &&
1265 (cli_setpid(&cli1, 2), cli_lock(&cli1, fnum1, 42, 4, 0, WRITE_LOCK));
1266 EXPECTED(ret, False);
1267 printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
1269 ret = (cli_setpid(&cli1, 1), cli_lock(&cli1, fnum1, 50, 4, 0, READ_LOCK)) &&
1270 (cli_setpid(&cli1, 2), cli_lock(&cli1, fnum1, 52, 4, 0, READ_LOCK));
1271 EXPECTED(ret, True);
1272 printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
1274 ret = cli_lock(&cli1, fnum1, 60, 4, 0, READ_LOCK) &&
1275 cli_lock(&cli1, fnum1, 60, 4, 0, READ_LOCK);
1276 EXPECTED(ret, True);
1277 printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
1279 ret = cli_lock(&cli1, fnum1, 70, 4, 0, WRITE_LOCK) &&
1280 cli_lock(&cli1, fnum1, 70, 4, 0, WRITE_LOCK);
1281 EXPECTED(ret, False);
1282 printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
1284 ret = cli_lock(&cli1, fnum1, 80, 4, 0, READ_LOCK) &&
1285 cli_lock(&cli1, fnum1, 80, 4, 0, WRITE_LOCK);
1286 EXPECTED(ret, False);
1287 printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
1289 ret = cli_lock(&cli1, fnum1, 90, 4, 0, WRITE_LOCK) &&
1290 cli_lock(&cli1, fnum1, 90, 4, 0, READ_LOCK);
1291 EXPECTED(ret, True);
1292 printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1294 ret = (cli_setpid(&cli1, 1), cli_lock(&cli1, fnum1, 100, 4, 0, WRITE_LOCK)) &&
1295 (cli_setpid(&cli1, 2), cli_lock(&cli1, fnum1, 100, 4, 0, READ_LOCK));
1296 EXPECTED(ret, False);
1297 printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1299 ret = cli_lock(&cli1, fnum1, 110, 4, 0, READ_LOCK) &&
1300 cli_lock(&cli1, fnum1, 112, 4, 0, READ_LOCK) &&
1301 cli_unlock(&cli1, fnum1, 110, 6);
1302 EXPECTED(ret, False);
1303 printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
1306 ret = cli_lock(&cli1, fnum1, 120, 4, 0, WRITE_LOCK) &&
1307 (cli_read(&cli2, fnum2, buf, 120, 4) == 4);
1308 EXPECTED(ret, False);
1309 printf("this server %s strict write locking\n", ret?"doesn't do":"does");
1311 ret = cli_lock(&cli1, fnum1, 130, 4, 0, READ_LOCK) &&
1312 (cli_write(&cli2, fnum2, 0, buf, 130, 4) == 4);
1313 EXPECTED(ret, False);
1314 printf("this server %s strict read locking\n", ret?"doesn't do":"does");
1317 ret = cli_lock(&cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1318 cli_lock(&cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1319 cli_unlock(&cli1, fnum1, 140, 4) &&
1320 cli_unlock(&cli1, fnum1, 140, 4);
1321 EXPECTED(ret, True);
1322 printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
1325 ret = cli_lock(&cli1, fnum1, 150, 4, 0, WRITE_LOCK) &&
1326 cli_lock(&cli1, fnum1, 150, 4, 0, READ_LOCK) &&
1327 cli_unlock(&cli1, fnum1, 150, 4) &&
1328 (cli_read(&cli2, fnum2, buf, 150, 4) == 4) &&
1329 !(cli_write(&cli2, fnum2, 0, buf, 150, 4) == 4) &&
1330 cli_unlock(&cli1, fnum1, 150, 4);
1331 EXPECTED(ret, True);
1332 printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
1334 ret = cli_lock(&cli1, fnum1, 160, 4, 0, READ_LOCK) &&
1335 cli_unlock(&cli1, fnum1, 160, 4) &&
1336 (cli_write(&cli2, fnum2, 0, buf, 160, 4) == 4) &&
1337 (cli_read(&cli2, fnum2, buf, 160, 4) == 4);
1338 EXPECTED(ret, True);
1339 printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
1341 ret = cli_lock(&cli1, fnum1, 170, 4, 0, WRITE_LOCK) &&
1342 cli_unlock(&cli1, fnum1, 170, 4) &&
1343 (cli_write(&cli2, fnum2, 0, buf, 170, 4) == 4) &&
1344 (cli_read(&cli2, fnum2, buf, 170, 4) == 4);
1345 EXPECTED(ret, True);
1346 printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
1348 ret = cli_lock(&cli1, fnum1, 190, 4, 0, WRITE_LOCK) &&
1349 cli_lock(&cli1, fnum1, 190, 4, 0, READ_LOCK) &&
1350 cli_unlock(&cli1, fnum1, 190, 4) &&
1351 !(cli_write(&cli2, fnum2, 0, buf, 190, 4) == 4) &&
1352 (cli_read(&cli2, fnum2, buf, 190, 4) == 4);
1353 EXPECTED(ret, True);
1354 printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
1356 cli_close(&cli1, fnum1);
1357 cli_close(&cli2, fnum2);
1358 fnum1 = cli_open(&cli1, fname, O_RDWR, DENY_NONE);
1359 f = cli_open(&cli1, fname, O_RDWR, DENY_NONE);
1360 ret = cli_lock(&cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1361 cli_lock(&cli1, f, 0, 1, 0, READ_LOCK) &&
1362 cli_close(&cli1, fnum1) &&
1363 ((fnum1 = cli_open(&cli1, fname, O_RDWR, DENY_NONE)) != -1) &&
1364 cli_lock(&cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1365 cli_close(&cli1, f);
1366 EXPECTED(ret, True);
1367 printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
1370 cli_close(&cli1, fnum1);
1371 cli_close(&cli2, fnum2);
1372 cli_unlink(&cli1, fname);
1373 torture_close_connection(&cli1);
1374 torture_close_connection(&cli2);
1376 printf("finished locktest4\n");
1381 looks at lock upgrade/downgrade.
1383 static BOOL run_locktest5(int dummy)
1385 static struct cli_state cli1, cli2;
1386 char *fname = "\\lockt5.lck";
1387 int fnum1, fnum2, fnum3;
1390 BOOL correct = True;
1392 if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
1396 cli_sockopt(&cli1, sockops);
1397 cli_sockopt(&cli2, sockops);
1399 printf("starting locktest5\n");
1401 cli_unlink(&cli1, fname);
1403 fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1404 fnum2 = cli_open(&cli2, fname, O_RDWR, DENY_NONE);
1405 fnum3 = cli_open(&cli1, fname, O_RDWR, DENY_NONE);
1407 memset(buf, 0, sizeof(buf));
1409 if (cli_write(&cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1410 printf("Failed to create file\n");
1415 /* Check for NT bug... */
1416 ret = cli_lock(&cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1417 cli_lock(&cli1, fnum3, 0, 1, 0, READ_LOCK);
1418 cli_close(&cli1, fnum1);
1419 fnum1 = cli_open(&cli1, fname, O_RDWR, DENY_NONE);
1420 ret = cli_lock(&cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1421 EXPECTED(ret, True);
1422 printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
1423 cli_close(&cli1, fnum1);
1424 fnum1 = cli_open(&cli1, fname, O_RDWR, DENY_NONE);
1425 cli_unlock(&cli1, fnum3, 0, 1);
1427 ret = cli_lock(&cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1428 cli_lock(&cli1, fnum1, 1, 1, 0, READ_LOCK);
1429 EXPECTED(ret, True);
1430 printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
1432 ret = cli_lock(&cli2, fnum2, 0, 4, 0, READ_LOCK);
1433 EXPECTED(ret, False);
1435 printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
1437 /* Unlock the process 2 lock. */
1438 cli_unlock(&cli2, fnum2, 0, 4);
1440 ret = cli_lock(&cli1, fnum3, 0, 4, 0, READ_LOCK);
1441 EXPECTED(ret, False);
1443 printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
1445 /* Unlock the process 1 fnum3 lock. */
1446 cli_unlock(&cli1, fnum3, 0, 4);
1448 /* Stack 2 more locks here. */
1449 ret = cli_lock(&cli1, fnum1, 0, 4, 0, READ_LOCK) &&
1450 cli_lock(&cli1, fnum1, 0, 4, 0, READ_LOCK);
1452 EXPECTED(ret, True);
1453 printf("the same process %s stack read locks\n", ret?"can":"cannot");
1455 /* Unlock the first process lock, then check this was the WRITE lock that was
1458 ret = cli_unlock(&cli1, fnum1, 0, 4) &&
1459 cli_lock(&cli2, fnum2, 0, 4, 0, READ_LOCK);
1461 EXPECTED(ret, True);
1462 printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
1464 /* Unlock the process 2 lock. */
1465 cli_unlock(&cli2, fnum2, 0, 4);
1467 /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
1469 ret = cli_unlock(&cli1, fnum1, 1, 1) &&
1470 cli_unlock(&cli1, fnum1, 0, 4) &&
1471 cli_unlock(&cli1, fnum1, 0, 4);
1473 EXPECTED(ret, True);
1474 printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
1476 /* Ensure the next unlock fails. */
1477 ret = cli_unlock(&cli1, fnum1, 0, 4);
1478 EXPECTED(ret, False);
1479 printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
1481 /* Ensure connection 2 can get a write lock. */
1482 ret = cli_lock(&cli2, fnum2, 0, 4, 0, WRITE_LOCK);
1483 EXPECTED(ret, True);
1485 printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
1489 cli_close(&cli1, fnum1);
1490 cli_close(&cli2, fnum2);
1491 cli_unlink(&cli1, fname);
1492 if (!torture_close_connection(&cli1)) {
1495 if (!torture_close_connection(&cli2)) {
1499 printf("finished locktest5\n");
1505 test whether fnums and tids open on one VC are available on another (a major
1508 static BOOL run_fdpasstest(int dummy)
1510 static struct cli_state cli1, cli2, cli3;
1511 char *fname = "\\fdpass.tst";
1515 if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
1518 cli_sockopt(&cli1, sockops);
1519 cli_sockopt(&cli2, sockops);
1521 printf("starting fdpasstest\n");
1523 cli_unlink(&cli1, fname);
1525 fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1527 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1));
1531 if (cli_write(&cli1, fnum1, 0, "hello world\n", 0, 13) != 13) {
1532 printf("write failed (%s)\n", cli_errstr(&cli1));
1537 cli3.vuid = cli1.vuid;
1538 cli3.cnum = cli1.cnum;
1539 cli3.pid = cli1.pid;
1541 if (cli_read(&cli3, fnum1, buf, 0, 13) == 13) {
1542 printf("read succeeded! nasty security hole [%s]\n",
1547 cli_close(&cli1, fnum1);
1548 cli_unlink(&cli1, fname);
1550 torture_close_connection(&cli1);
1551 torture_close_connection(&cli2);
1553 printf("finished fdpasstest\n");
1559 This test checks that
1561 1) the server does not allow an unlink on a file that is open
1563 static BOOL run_unlinktest(int dummy)
1565 static struct cli_state cli;
1566 char *fname = "\\unlink.tst";
1568 BOOL correct = True;
1570 if (!torture_open_connection(&cli)) {
1574 cli_sockopt(&cli, sockops);
1576 printf("starting unlink test\n");
1578 cli_unlink(&cli, fname);
1580 cli_setpid(&cli, 1);
1582 fnum = cli_open(&cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1584 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli));
1588 if (cli_unlink(&cli, fname)) {
1589 printf("error: server allowed unlink on an open file\n");
1592 correct = check_error(__LINE__, &cli, ERRDOS, ERRbadshare,
1593 NT_STATUS_SHARING_VIOLATION);
1596 cli_close(&cli, fnum);
1597 cli_unlink(&cli, fname);
1599 if (!torture_close_connection(&cli)) {
1603 printf("unlink test finished\n");
1610 test how many open files this server supports on the one socket
1612 static BOOL run_maxfidtest(int dummy)
1614 static struct cli_state cli;
1615 char *template = "\\maxfid.%d.%d";
1617 int fnums[0x11000], i;
1619 BOOL correct = True;
1624 printf("failed to connect\n");
1628 cli_sockopt(&cli, sockops);
1630 for (i=0; i<0x11000; i++) {
1631 slprintf(fname,sizeof(fname)-1,template, i,(int)getpid());
1632 if ((fnums[i] = cli_open(&cli, fname,
1633 O_RDWR|O_CREAT|O_TRUNC, DENY_NONE)) ==
1635 printf("open of %s failed (%s)\n",
1636 fname, cli_errstr(&cli));
1637 printf("maximum fnum is %d\n", i);
1645 printf("cleaning up\n");
1647 slprintf(fname,sizeof(fname)-1,template, i,(int)getpid());
1648 cli_close(&cli, fnums[i]);
1649 if (!cli_unlink(&cli, fname)) {
1650 printf("unlink of %s failed (%s)\n",
1651 fname, cli_errstr(&cli));
1658 printf("maxfid test finished\n");
1659 if (!torture_close_connection(&cli)) {
1665 /* generate a random buffer */
1666 static void rand_buf(char *buf, int len)
1669 *buf = (char)sys_random();
1674 /* send smb negprot commands, not reading the response */
1675 static BOOL run_negprot_nowait(int dummy)
1678 static struct cli_state cli;
1679 BOOL correct = True;
1681 printf("starting negprot nowait test\n");
1683 if (!open_nbt_connection(&cli)) {
1687 for (i=0;i<50000;i++) {
1688 cli_negprot_send(&cli);
1691 if (!torture_close_connection(&cli)) {
1695 printf("finished negprot nowait test\n");
1701 /* send random IPC commands */
1702 static BOOL run_randomipc(int dummy)
1704 char *rparam = NULL;
1708 int api, param_len, i;
1709 static struct cli_state cli;
1710 BOOL correct = True;
1713 printf("starting random ipc test\n");
1715 if (!torture_open_connection(&cli)) {
1719 for (i=0;i<count;i++) {
1720 api = sys_random() % 500;
1721 param_len = (sys_random() % 64);
1723 rand_buf(param, param_len);
1728 param, param_len, 8,
1729 NULL, 0, BUFFER_SIZE,
1733 printf("%d/%d\r", i,count);
1736 printf("%d/%d\n", i, count);
1738 if (!torture_close_connection(&cli)) {
1742 printf("finished random ipc test\n");
1749 static void browse_callback(const char *sname, uint32 stype,
1750 const char *comment, void *state)
1752 printf("\t%20.20s %08x %s\n", sname, stype, comment);
1758 This test checks the browse list code
1761 static BOOL run_browsetest(int dummy)
1763 static struct cli_state cli;
1764 BOOL correct = True;
1766 printf("starting browse test\n");
1768 if (!torture_open_connection(&cli)) {
1772 printf("domain list:\n");
1773 cli_NetServerEnum(&cli, cli.server_domain,
1774 SV_TYPE_DOMAIN_ENUM,
1775 browse_callback, NULL);
1777 printf("machine list:\n");
1778 cli_NetServerEnum(&cli, cli.server_domain,
1780 browse_callback, NULL);
1782 if (!torture_close_connection(&cli)) {
1786 printf("browse test finished\n");
1794 This checks how the getatr calls works
1796 static BOOL run_attrtest(int dummy)
1798 static struct cli_state cli;
1801 char *fname = "\\attrib.tst";
1802 BOOL correct = True;
1804 printf("starting attrib test\n");
1806 if (!torture_open_connection(&cli)) {
1810 cli_unlink(&cli, fname);
1811 fnum = cli_open(&cli, fname,
1812 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
1813 cli_close(&cli, fnum);
1814 if (!cli_getatr(&cli, fname, NULL, NULL, &t)) {
1815 printf("getatr failed (%s)\n", cli_errstr(&cli));
1819 if (abs(t - time(NULL)) > 2) {
1820 printf("ERROR: SMBgetatr bug. time is %s",
1826 t2 = t-60*60*24; /* 1 day ago */
1828 if (!cli_setatr(&cli, fname, 0, t2)) {
1829 printf("setatr failed (%s)\n", cli_errstr(&cli));
1833 if (!cli_getatr(&cli, fname, NULL, NULL, &t)) {
1834 printf("getatr failed (%s)\n", cli_errstr(&cli));
1839 printf("ERROR: getatr/setatr bug. times are\n%s",
1841 printf("%s", ctime(&t2));
1845 cli_unlink(&cli, fname);
1847 if (!torture_close_connection(&cli)) {
1851 printf("attrib test finished\n");
1858 This checks a couple of trans2 calls
1860 static BOOL run_trans2test(int dummy)
1862 static struct cli_state cli;
1865 time_t c_time, a_time, m_time, w_time, m_time2;
1866 char *fname = "\\trans2.tst";
1867 char *dname = "\\trans2";
1868 char *fname2 = "\\trans2\\trans2.tst";
1869 BOOL correct = True;
1871 printf("starting trans2 test\n");
1873 if (!torture_open_connection(&cli)) {
1877 cli_unlink(&cli, fname);
1878 fnum = cli_open(&cli, fname,
1879 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
1880 if (!cli_qfileinfo(&cli, fnum, NULL, &size, &c_time, &a_time, &m_time,
1882 printf("ERROR: qfileinfo failed (%s)\n", cli_errstr(&cli));
1885 cli_close(&cli, fnum);
1889 cli_unlink(&cli, fname);
1890 fnum = cli_open(&cli, fname,
1891 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
1893 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli));
1896 cli_close(&cli, fnum);
1898 if (!cli_qpathinfo(&cli, fname, &c_time, &a_time, &m_time, &size, NULL)) {
1899 printf("ERROR: qpathinfo failed (%s)\n", cli_errstr(&cli));
1902 if (c_time != m_time) {
1903 printf("create time=%s", ctime(&c_time));
1904 printf("modify time=%s", ctime(&m_time));
1905 printf("This system appears to have sticky create times\n");
1908 if (a_time % (60*60) == 0) {
1909 printf("access time=%s", ctime(&a_time));
1910 printf("This system appears to set a midnight access time\n");
1914 if (abs(m_time - time(NULL)) > 60*60*24*7) {
1915 printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
1921 cli_unlink(&cli, fname);
1922 fnum = cli_open(&cli, fname,
1923 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
1924 cli_close(&cli, fnum);
1925 if (!cli_qpathinfo2(&cli, fname, &c_time, &a_time, &m_time,
1926 &w_time, &size, NULL, NULL)) {
1927 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(&cli));
1930 if (w_time < 60*60*24*2) {
1931 printf("write time=%s", ctime(&w_time));
1932 printf("This system appears to set a initial 0 write time\n");
1937 cli_unlink(&cli, fname);
1940 /* check if the server updates the directory modification time
1941 when creating a new file */
1942 if (!cli_mkdir(&cli, dname)) {
1943 printf("ERROR: mkdir failed (%s)\n", cli_errstr(&cli));
1947 if (!cli_qpathinfo2(&cli, "\\trans2\\", &c_time, &a_time, &m_time,
1948 &w_time, &size, NULL, NULL)) {
1949 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(&cli));
1953 fnum = cli_open(&cli, fname2,
1954 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
1955 cli_write(&cli, fnum, 0, (char *)&fnum, 0, sizeof(fnum));
1956 cli_close(&cli, fnum);
1957 if (!cli_qpathinfo2(&cli, "\\trans2\\", &c_time, &a_time, &m_time2,
1958 &w_time, &size, NULL, NULL)) {
1959 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(&cli));
1962 if (m_time2 == m_time) {
1963 printf("This system does not update directory modification times\n");
1967 cli_unlink(&cli, fname2);
1968 cli_rmdir(&cli, dname);
1970 if (!torture_close_connection(&cli)) {
1974 printf("trans2 test finished\n");
1980 This checks new W2K calls.
1983 static BOOL new_trans(struct cli_state *pcli, int fnum, int level)
1986 BOOL correct = True;
1988 memset(buf, 0xff, sizeof(buf));
1990 if (!cli_qfileinfo_test(pcli, fnum, level, buf)) {
1991 printf("ERROR: qfileinfo (%d) failed (%s)\n", level, cli_errstr(pcli));
1994 printf("qfileinfo: level %d\n", level);
1995 dump_data(0, buf, 256);
2001 static BOOL run_w2ktest(int dummy)
2003 static struct cli_state cli;
2005 char *fname = "\\w2ktest\\w2k.tst";
2007 BOOL correct = True;
2009 printf("starting w2k test\n");
2011 if (!torture_open_connection(&cli)) {
2015 fnum = cli_open(&cli, fname,
2016 O_RDWR | O_CREAT , DENY_NONE);
2018 for (level = 1004; level < 1040; level++) {
2019 new_trans(&cli, fnum, level);
2022 cli_close(&cli, fnum);
2024 if (!torture_close_connection(&cli)) {
2028 printf("w2k test finished\n");
2035 this is a harness for some oplock tests
2037 static BOOL run_oplock1(int dummy)
2039 static struct cli_state cli1;
2040 char *fname = "\\lockt1.lck";
2042 BOOL correct = True;
2044 printf("starting oplock test 1\n");
2046 if (!torture_open_connection(&cli1)) {
2050 cli_unlink(&cli1, fname);
2052 cli_sockopt(&cli1, sockops);
2054 cli1.use_oplocks = True;
2056 fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2058 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2062 cli1.use_oplocks = False;
2064 cli_unlink(&cli1, fname);
2065 cli_unlink(&cli1, fname);
2067 if (!cli_close(&cli1, fnum1)) {
2068 printf("close2 failed (%s)\n", cli_errstr(&cli1));
2072 if (!cli_unlink(&cli1, fname)) {
2073 printf("unlink failed (%s)\n", cli_errstr(&cli1));
2077 if (!torture_close_connection(&cli1)) {
2081 printf("finished oplock test 1\n");
2086 static BOOL run_oplock2(int dummy)
2088 static struct cli_state cli1, cli2;
2089 char *fname = "\\lockt2.lck";
2091 int saved_use_oplocks = use_oplocks;
2093 BOOL correct = True;
2094 volatile BOOL *shared_correct;
2096 shared_correct = (volatile BOOL *)shm_setup(sizeof(BOOL));
2097 *shared_correct = True;
2099 use_level_II_oplocks = True;
2102 printf("starting oplock test 2\n");
2104 if (!torture_open_connection(&cli1)) {
2105 use_level_II_oplocks = False;
2106 use_oplocks = saved_use_oplocks;
2110 cli1.use_oplocks = True;
2111 cli1.use_level_II_oplocks = True;
2113 if (!torture_open_connection(&cli2)) {
2114 use_level_II_oplocks = False;
2115 use_oplocks = saved_use_oplocks;
2119 cli2.use_oplocks = True;
2120 cli2.use_level_II_oplocks = True;
2122 cli_unlink(&cli1, fname);
2124 cli_sockopt(&cli1, sockops);
2125 cli_sockopt(&cli2, sockops);
2127 fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2129 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2133 /* Don't need the globals any more. */
2134 use_level_II_oplocks = False;
2135 use_oplocks = saved_use_oplocks;
2139 fnum2 = cli_open(&cli2, fname, O_RDWR, DENY_NONE);
2141 printf("second open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2142 *shared_correct = False;
2148 if (!cli_close(&cli2, fnum2)) {
2149 printf("close2 failed (%s)\n", cli_errstr(&cli1));
2150 *shared_correct = False;
2158 /* Ensure cli1 processes the break. */
2160 if (cli_read(&cli1, fnum1, buf, 0, 4) != 4) {
2161 printf("read on fnum1 failed (%s)\n", cli_errstr(&cli1));
2165 /* Should now be at level II. */
2166 /* Test if sending a write locks causes a break to none. */
2168 if (!cli_lock(&cli1, fnum1, 0, 4, 0, READ_LOCK)) {
2169 printf("lock failed (%s)\n", cli_errstr(&cli1));
2173 cli_unlock(&cli1, fnum1, 0, 4);
2177 if (!cli_lock(&cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
2178 printf("lock failed (%s)\n", cli_errstr(&cli1));
2182 cli_unlock(&cli1, fnum1, 0, 4);
2186 cli_read(&cli1, fnum1, buf, 0, 4);
2189 if (cli_write(&cli1, fnum1, 0, buf, 0, 4) != 4) {
2190 printf("write on fnum1 failed (%s)\n", cli_errstr(&cli1));
2195 if (!cli_close(&cli1, fnum1)) {
2196 printf("close1 failed (%s)\n", cli_errstr(&cli1));
2202 if (!cli_unlink(&cli1, fname)) {
2203 printf("unlink failed (%s)\n", cli_errstr(&cli1));
2207 if (!torture_close_connection(&cli1)) {
2211 if (!*shared_correct) {
2215 printf("finished oplock test 2\n");
2220 /* handler for oplock 3 tests */
2221 static BOOL oplock3_handler(struct cli_state *cli, int fnum, unsigned char level)
2223 printf("got oplock break fnum=%d level=%d\n",
2225 return cli_oplock_ack(cli, fnum, level);
2228 static BOOL run_oplock3(int dummy)
2230 static struct cli_state cli;
2231 char *fname = "\\oplockt3.dat";
2233 char buf[4] = "abcd";
2234 BOOL correct = True;
2235 volatile BOOL *shared_correct;
2237 shared_correct = (volatile BOOL *)shm_setup(sizeof(BOOL));
2238 *shared_correct = True;
2240 printf("starting oplock test 3\n");
2245 use_level_II_oplocks = True;
2246 if (!torture_open_connection(&cli)) {
2247 *shared_correct = False;
2251 /* try to trigger a oplock break in parent */
2252 fnum = cli_open(&cli, fname, O_RDWR, DENY_NONE);
2253 cli_write(&cli, fnum, 0, buf, 0, 4);
2259 use_level_II_oplocks = True;
2260 if (!torture_open_connection(&cli)) {
2263 cli_oplock_handler(&cli, oplock3_handler);
2264 fnum = cli_open(&cli, fname, O_RDWR|O_CREAT, DENY_NONE);
2265 cli_write(&cli, fnum, 0, buf, 0, 4);
2266 cli_close(&cli, fnum);
2267 fnum = cli_open(&cli, fname, O_RDWR, DENY_NONE);
2268 cli.timeout = 20000;
2269 cli_receive_smb(&cli);
2270 printf("finished oplock test 3\n");
2272 return (correct && *shared_correct);
2274 /* What are we looking for here? What's sucess and what's FAILURE? */
2280 Test delete on close semantics.
2282 static BOOL run_deletetest(int dummy)
2284 static struct cli_state cli1;
2285 static struct cli_state cli2;
2286 char *fname = "\\delete.file";
2288 BOOL correct = True;
2290 printf("starting delete test\n");
2292 if (!torture_open_connection(&cli1)) {
2296 cli_sockopt(&cli1, sockops);
2298 /* Test 1 - this should *NOT* delete the file on close. */
2300 cli_setatr(&cli1, fname, 0, 0);
2301 cli_unlink(&cli1, fname);
2303 fnum1 = cli_nt_create_full(&cli1, fname, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
2304 FILE_SHARE_DELETE, FILE_OVERWRITE_IF,
2305 DELETE_ON_CLOSE_FLAG);
2308 printf("[1] open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2312 if (!cli_close(&cli1, fnum1)) {
2313 printf("[1] close failed (%s)\n", cli_errstr(&cli1));
2317 fnum1 = cli_open(&cli1, fname, O_RDWR, DENY_NONE);
2319 printf("[1] open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2323 if (!cli_close(&cli1, fnum1)) {
2324 printf("[1] close failed (%s)\n", cli_errstr(&cli1));
2328 printf("first delete on close test succeeded.\n");
2330 /* Test 2 - this should delete the file on close. */
2332 cli_setatr(&cli1, fname, 0, 0);
2333 cli_unlink(&cli1, fname);
2335 fnum1 = cli_nt_create_full(&cli1, fname, GENERIC_ALL_ACCESS,
2336 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
2337 FILE_OVERWRITE_IF, 0);
2340 printf("[2] open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2344 if (!cli_nt_delete_on_close(&cli1, fnum1, True)) {
2345 printf("[2] setting delete_on_close failed (%s)\n", cli_errstr(&cli1));
2349 if (!cli_close(&cli1, fnum1)) {
2350 printf("[2] close failed (%s)\n", cli_errstr(&cli1));
2354 fnum1 = cli_open(&cli1, fname, O_RDONLY, DENY_NONE);
2356 printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
2357 if (!cli_close(&cli1, fnum1)) {
2358 printf("[2] close failed (%s)\n", cli_errstr(&cli1));
2361 cli_unlink(&cli1, fname);
2363 printf("second delete on close test succeeded.\n");
2366 cli_setatr(&cli1, fname, 0, 0);
2367 cli_unlink(&cli1, fname);
2369 fnum1 = cli_nt_create_full(&cli1, fname, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
2370 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0);
2373 printf("[3] open - 1 of %s failed (%s)\n", fname, cli_errstr(&cli1));
2377 /* This should fail with a sharing violation - open for delete is only compatible
2378 with SHARE_DELETE. */
2380 fnum2 = cli_nt_create_full(&cli1, fname, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
2381 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0);
2384 printf("[3] open - 2 of %s succeeded - should have failed.\n", fname);
2388 /* This should succeed. */
2390 fnum2 = cli_nt_create_full(&cli1, fname, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
2391 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0);
2394 printf("[3] open - 2 of %s failed (%s)\n", fname, cli_errstr(&cli1));
2398 if (!cli_nt_delete_on_close(&cli1, fnum1, True)) {
2399 printf("[3] setting delete_on_close failed (%s)\n", cli_errstr(&cli1));
2403 if (!cli_close(&cli1, fnum1)) {
2404 printf("[3] close 1 failed (%s)\n", cli_errstr(&cli1));
2408 if (!cli_close(&cli1, fnum2)) {
2409 printf("[3] close 2 failed (%s)\n", cli_errstr(&cli1));
2413 /* This should fail - file should no longer be there. */
2415 fnum1 = cli_open(&cli1, fname, O_RDONLY, DENY_NONE);
2417 printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
2418 if (!cli_close(&cli1, fnum1)) {
2419 printf("[3] close failed (%s)\n", cli_errstr(&cli1));
2421 cli_unlink(&cli1, fname);
2424 printf("third delete on close test succeeded.\n");
2427 cli_setatr(&cli1, fname, 0, 0);
2428 cli_unlink(&cli1, fname);
2430 fnum1 = cli_nt_create_full(&cli1, fname, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
2431 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0);
2434 printf("[4] open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2438 /* This should succeed. */
2439 fnum2 = cli_nt_create_full(&cli1, fname, GENERIC_READ_ACCESS,
2440 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0);
2442 printf("[4] open - 2 of %s failed (%s)\n", fname, cli_errstr(&cli1));
2446 if (!cli_close(&cli1, fnum2)) {
2447 printf("[4] close - 1 failed (%s)\n", cli_errstr(&cli1));
2451 if (!cli_nt_delete_on_close(&cli1, fnum1, True)) {
2452 printf("[4] setting delete_on_close failed (%s)\n", cli_errstr(&cli1));
2456 /* This should fail - no more opens once delete on close set. */
2457 fnum2 = cli_nt_create_full(&cli1, fname, GENERIC_READ_ACCESS,
2458 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0);
2460 printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname );
2463 printf("fourth delete on close test succeeded.\n");
2465 if (!cli_close(&cli1, fnum1)) {
2466 printf("[4] close - 2 failed (%s)\n", cli_errstr(&cli1));
2471 cli_setatr(&cli1, fname, 0, 0);
2472 cli_unlink(&cli1, fname);
2474 fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT, DENY_NONE);
2476 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2480 /* This should fail - only allowed on NT opens with DELETE access. */
2482 if (cli_nt_delete_on_close(&cli1, fnum1, True)) {
2483 printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
2487 if (!cli_close(&cli1, fnum1)) {
2488 printf("[5] close - 2 failed (%s)\n", cli_errstr(&cli1));
2492 printf("fifth delete on close test succeeded.\n");
2495 cli_setatr(&cli1, fname, 0, 0);
2496 cli_unlink(&cli1, fname);
2498 fnum1 = cli_nt_create_full(&cli1, fname, FILE_READ_DATA|FILE_WRITE_DATA,
2499 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
2500 FILE_OVERWRITE_IF, 0);
2503 printf("[6] open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2507 /* This should fail - only allowed on NT opens with DELETE access. */
2509 if (cli_nt_delete_on_close(&cli1, fnum1, True)) {
2510 printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
2514 if (!cli_close(&cli1, fnum1)) {
2515 printf("[6] close - 2 failed (%s)\n", cli_errstr(&cli1));
2519 printf("sixth delete on close test succeeded.\n");
2522 cli_setatr(&cli1, fname, 0, 0);
2523 cli_unlink(&cli1, fname);
2525 fnum1 = cli_nt_create_full(&cli1, fname, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
2526 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0);
2529 printf("[7] open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2533 if (!cli_nt_delete_on_close(&cli1, fnum1, True)) {
2534 printf("[7] setting delete_on_close on file failed !\n");
2538 if (!cli_nt_delete_on_close(&cli1, fnum1, False)) {
2539 printf("[7] unsetting delete_on_close on file failed !\n");
2543 if (!cli_close(&cli1, fnum1)) {
2544 printf("[7] close - 2 failed (%s)\n", cli_errstr(&cli1));
2548 /* This next open should succeed - we reset the flag. */
2550 fnum1 = cli_open(&cli1, fname, O_RDONLY, DENY_NONE);
2552 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2556 if (!cli_close(&cli1, fnum1)) {
2557 printf("[7] close - 2 failed (%s)\n", cli_errstr(&cli1));
2561 printf("seventh delete on close test succeeded.\n");
2564 cli_setatr(&cli1, fname, 0, 0);
2565 cli_unlink(&cli1, fname);
2567 if (!torture_open_connection(&cli2)) {
2568 printf("[8] failed to open second connection.\n");
2572 cli_sockopt(&cli1, sockops);
2574 fnum1 = cli_nt_create_full(&cli1, fname, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
2575 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0);
2578 printf("[8] open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2582 fnum2 = cli_nt_create_full(&cli2, fname, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
2583 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0);
2586 printf("[8] open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2590 if (!cli_nt_delete_on_close(&cli1, fnum1, True)) {
2591 printf("[8] setting delete_on_close on file failed !\n");
2595 if (!cli_close(&cli1, fnum1)) {
2596 printf("[8] close - 1 failed (%s)\n", cli_errstr(&cli1));
2600 if (!cli_close(&cli2, fnum2)) {
2601 printf("[8] close - 2 failed (%s)\n", cli_errstr(&cli2));
2605 /* This should fail.. */
2606 fnum1 = cli_open(&cli1, fname, O_RDONLY, DENY_NONE);
2608 printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
2609 if (!cli_close(&cli1, fnum1)) {
2610 printf("[8] close failed (%s)\n", cli_errstr(&cli1));
2612 cli_unlink(&cli1, fname);
2615 printf("eighth delete on close test succeeded.\n");
2617 printf("finished delete test\n");
2619 cli_setatr(&cli1, fname, 0, 0);
2620 cli_unlink(&cli1, fname);
2622 if (!torture_close_connection(&cli1)) {
2625 if (!torture_close_connection(&cli2)) {
2632 Test open mode returns on read-only files.
2634 static BOOL run_opentest(int dummy)
2636 static struct cli_state cli1;
2637 char *fname = "\\readonly.file";
2641 BOOL correct = True;
2644 printf("starting open test\n");
2646 if (!torture_open_connection(&cli1)) {
2650 cli_setatr(&cli1, fname, 0, 0);
2651 cli_unlink(&cli1, fname);
2653 cli_sockopt(&cli1, sockops);
2655 fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2657 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2661 if (!cli_close(&cli1, fnum1)) {
2662 printf("close2 failed (%s)\n", cli_errstr(&cli1));
2666 if (!cli_setatr(&cli1, fname, aRONLY, 0)) {
2667 printf("cli_setatr failed (%s)\n", cli_errstr(&cli1));
2671 fnum1 = cli_open(&cli1, fname, O_RDONLY, DENY_WRITE);
2673 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2677 /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
2678 fnum2 = cli_open(&cli1, fname, O_RDWR, DENY_ALL);
2680 if (check_error(__LINE__, &cli1, ERRDOS, ERRnoaccess,
2681 NT_STATUS_ACCESS_DENIED)) {
2682 printf("correct error code ERRDOS/ERRnoaccess returned\n");
2685 printf("finished open test 1\n");
2687 cli_close(&cli1, fnum1);
2689 /* Now try not readonly and ensure ERRbadshare is returned. */
2691 cli_setatr(&cli1, fname, 0, 0);
2693 fnum1 = cli_open(&cli1, fname, O_RDONLY, DENY_WRITE);
2695 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1));
2699 /* This will fail - but the error should be ERRshare. */
2700 fnum2 = cli_open(&cli1, fname, O_RDWR, DENY_ALL);
2702 if (check_error(__LINE__, &cli1, ERRDOS, ERRbadshare,
2703 NT_STATUS_SHARING_VIOLATION)) {
2704 printf("correct error code ERRDOS/ERRbadshare returned\n");
2707 if (!cli_close(&cli1, fnum1)) {
2708 printf("close2 failed (%s)\n", cli_errstr(&cli1));
2712 cli_unlink(&cli1, fname);
2714 printf("finished open test 2\n");
2716 /* Test truncate open disposition on file opened for read. */
2718 fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2720 printf("(3) open (1) of %s failed (%s)\n", fname, cli_errstr(&cli1));
2724 /* write 20 bytes. */
2726 memset(buf, '\0', 20);
2728 if (cli_write(&cli1, fnum1, 0, buf, 0, 20) != 20) {
2729 printf("write failed (%s)\n", cli_errstr(&cli1));
2733 if (!cli_close(&cli1, fnum1)) {
2734 printf("(3) close1 failed (%s)\n", cli_errstr(&cli1));
2738 /* Ensure size == 20. */
2739 if (!cli_getatr(&cli1, fname, NULL, &fsize, NULL)) {
2740 printf("(3) getatr failed (%s)\n", cli_errstr(&cli1));
2745 printf("(3) file size != 20\n");
2749 /* Now test if we can truncate a file opened for readonly. */
2751 fnum1 = cli_open(&cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE);
2753 printf("(3) open (2) of %s failed (%s)\n", fname, cli_errstr(&cli1));
2757 if (!cli_close(&cli1, fnum1)) {
2758 printf("close2 failed (%s)\n", cli_errstr(&cli1));
2762 /* Ensure size == 0. */
2763 if (!cli_getatr(&cli1, fname, NULL, &fsize, NULL)) {
2764 printf("(3) getatr failed (%s)\n", cli_errstr(&cli1));
2769 printf("(3) file size != 0\n");
2772 printf("finished open test 3\n");
2774 cli_unlink(&cli1, fname);
2777 printf("testing ctemp\n");
2778 fnum1 = cli_ctemp(&cli1, "\\", &tmp_path);
2780 printf("ctemp failed (%s)\n", cli_errstr(&cli1));
2783 printf("ctemp gave path %s\n", tmp_path);
2784 if (!cli_close(&cli1, fnum1)) {
2785 printf("close of temp failed (%s)\n", cli_errstr(&cli1));
2787 if (!cli_unlink(&cli1, tmp_path)) {
2788 printf("unlink of temp failed (%s)\n", cli_errstr(&cli1));
2791 if (!torture_close_connection(&cli1)) {
2798 static void list_fn(file_info *finfo, const char *name, void *state)
2804 test directory listing speed
2806 static BOOL run_dirtest(int dummy)
2809 static struct cli_state cli;
2812 BOOL correct = True;
2814 printf("starting directory test\n");
2816 if (!torture_open_connection(&cli)) {
2820 cli_sockopt(&cli, sockops);
2823 for (i=0;i<numops;i++) {
2825 slprintf(fname, sizeof(fname), "%x", (int)random());
2826 fnum = cli_open(&cli, fname, O_RDWR|O_CREAT, DENY_NONE);
2828 fprintf(stderr,"Failed to open %s\n", fname);
2831 cli_close(&cli, fnum);
2836 printf("Matched %d\n", cli_list(&cli, "a*.*", 0, list_fn, NULL));
2837 printf("Matched %d\n", cli_list(&cli, "b*.*", 0, list_fn, NULL));
2838 printf("Matched %d\n", cli_list(&cli, "xyzabc", 0, list_fn, NULL));
2840 printf("dirtest core %g seconds\n", end_timer() - t1);
2843 for (i=0;i<numops;i++) {
2845 slprintf(fname, sizeof(fname), "%x", (int)random());
2846 cli_unlink(&cli, fname);
2849 if (!torture_close_connection(&cli)) {
2853 printf("finished dirtest\n");
2858 static BOOL run_error_map_extract(int dummy) {
2860 static struct cli_state c_dos;
2861 static struct cli_state c_nt;
2865 uint32 flgs2, errnum;
2872 /* NT-Error connection */
2874 if (!open_nbt_connection(&c_nt)) {
2878 c_nt.use_spnego = False;
2880 if (!cli_negprot(&c_nt)) {
2881 printf("%s rejected the NT-error negprot (%s)\n",host, cli_errstr(&c_nt));
2882 cli_shutdown(&c_nt);
2886 if (!cli_session_setup(&c_nt, "", "", 0, "", 0,
2888 printf("%s rejected the NT-error initial session setup (%s)\n",host, cli_errstr(&c_nt));
2892 /* DOS-Error connection */
2894 if (!open_nbt_connection(&c_dos)) {
2898 c_dos.use_spnego = False;
2899 c_dos.force_dos_errors = True;
2901 if (!cli_negprot(&c_dos)) {
2902 printf("%s rejected the DOS-error negprot (%s)\n",host, cli_errstr(&c_dos));
2903 cli_shutdown(&c_dos);
2907 if (!cli_session_setup(&c_dos, "", "", 0, "", 0,
2909 printf("%s rejected the DOS-error initial session setup (%s)\n",host, cli_errstr(&c_dos));
2913 for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) {
2914 snprintf(user, sizeof(user), "%X", error);
2916 if (!cli_session_setup(&c_nt, user,
2917 password, strlen(password),
2918 password, strlen(password),
2920 flgs2 = SVAL(c_nt.inbuf,smb_flg2);
2922 /* Case #1: 32-bit NT errors */
2923 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
2924 nt_status = NT_STATUS(IVAL(c_nt.inbuf,smb_rcls));
2926 printf("** Dos error on NT connection! (%s)\n", cli_errstr(&c_nt));
2927 nt_status = NT_STATUS(0xc0000000);
2930 printf("** Session setup succeeded. This shouldn't happen...\n");
2933 if (!cli_session_setup(&c_dos, user,
2934 password, strlen(password),
2935 password, strlen(password),
2937 flgs2 = SVAL(c_dos.inbuf,smb_flg2), errnum;
2939 /* Case #1: 32-bit NT errors */
2940 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
2941 printf("** NT error on DOS connection! (%s)\n", cli_errstr(&c_nt));
2942 errnum = errclass = 0;
2944 cli_dos_error(&c_dos, &errclass, &errnum);
2947 printf("** Session setup succeeded. This shouldn't happen...\n");
2949 if (NT_STATUS_V(nt_status) == error) {
2950 printf("\t{%s,\t%s,\t%s},\n", smb_dos_err_class(errclass), smb_dos_err_name(errclass, errnum), get_nt_error_c_code(nt_status));
2952 printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n", get_nt_error_c_code(NT_STATUS(error)), get_nt_error_c_code(nt_status));
2958 static double create_procs(BOOL (*fn)(int), BOOL *result)
2961 volatile pid_t *child_status;
2962 volatile BOOL *child_status_out;
2968 child_status = (volatile pid_t *)shm_setup(sizeof(pid_t)*nprocs);
2969 if (!child_status) {
2970 printf("Failed to setup shared memory\n");
2974 child_status_out = (volatile BOOL *)shm_setup(sizeof(BOOL)*nprocs);
2975 if (!child_status_out) {
2976 printf("Failed to setup result status shared memory\n");
2980 memset((void *)child_status, 0, sizeof(pid_t)*nprocs);
2981 memset((void *)child_status_out, True, sizeof(BOOL)*nprocs);
2985 for (i=0;i<nprocs;i++) {
2988 pid_t mypid = getpid();
2989 sys_srandom(((int)mypid) ^ ((int)time(NULL)));
2991 slprintf(myname,sizeof(myname),"CLIENT%d", i);
2994 memset(¤t_cli, 0, sizeof(current_cli));
2995 if (torture_open_connection(¤t_cli)) break;
2997 printf("pid %d failed to start\n", (int)getpid());
3003 child_status[i] = getpid();
3005 while (child_status[i]) msleep(2);
3007 child_status_out[i] = fn(i);
3014 for (i=0;i<nprocs;i++) {
3015 if (child_status[i]) synccount++;
3017 if (synccount == nprocs) break;
3019 } while (end_timer() < 30);
3021 if (synccount != nprocs) {
3022 printf("FAILED TO START %d CLIENTS (started %d)\n", nprocs, synccount);
3027 /* start the client load */
3030 for (i=0;i<nprocs;i++) {
3031 child_status[i] = 0;
3034 printf("%d clients started\n", nprocs);
3036 for (i=0;i<nprocs;i++) {
3037 waitpid(0, &status, 0);
3043 for (i=0;i<nprocs;i++) {
3044 if (!child_status_out[i]) {
3052 #define FLAG_MULTIPROC 1
3059 {"FDPASS", run_fdpasstest, 0},
3060 {"LOCK1", run_locktest1, 0},
3061 {"LOCK2", run_locktest2, 0},
3062 {"LOCK3", run_locktest3, 0},
3063 {"LOCK4", run_locktest4, 0},
3064 {"LOCK5", run_locktest5, 0},
3065 {"UNLINK", run_unlinktest, 0},
3066 {"BROWSE", run_browsetest, 0},
3067 {"ATTR", run_attrtest, 0},
3068 {"TRANS2", run_trans2test, 0},
3069 {"MAXFID", run_maxfidtest, FLAG_MULTIPROC},
3070 {"TORTURE",run_torture, FLAG_MULTIPROC},
3071 {"RANDOMIPC", run_randomipc, 0},
3072 {"NEGNOWAIT", run_negprot_nowait, 0},
3073 {"NBW95", run_nbw95, 0},
3074 {"NBWNT", run_nbwnt, 0},
3075 {"OPLOCK1", run_oplock1, 0},
3076 {"OPLOCK2", run_oplock2, 0},
3077 {"OPLOCK3", run_oplock3, 0},
3078 {"DIR", run_dirtest, 0},
3079 {"DENY1", torture_denytest1, 0},
3080 {"DENY2", torture_denytest2, 0},
3081 {"TCON", run_tcon_test, 0},
3082 {"RW1", run_readwritetest, 0},
3083 {"RW2", run_readwritemulti, FLAG_MULTIPROC},
3084 {"RW3", run_readwritelarge, 0},
3085 {"OPEN", run_opentest, 0},
3086 {"DELETE", run_deletetest, 0},
3087 {"W2K", run_w2ktest, 0},
3088 {"TRANS2SCAN", torture_trans2_scan, 0},
3089 {"NTTRANSSCAN", torture_nttrans_scan, 0},
3090 {"UTABLE", torture_utable, 0},
3091 {"CASETABLE", torture_casetable, 0},
3092 {"ERRMAPEXTRACT", run_error_map_extract, 0},
3097 /****************************************************************************
3098 run a specified test or "ALL"
3099 ****************************************************************************/
3100 static BOOL run_test(char *name)
3106 if (strequal(name,"ALL")) {
3107 for (i=0;torture_ops[i].name;i++) {
3108 run_test(torture_ops[i].name);
3112 for (i=0;torture_ops[i].name;i++) {
3113 snprintf(randomfname, sizeof(randomfname), "\\XX%x",
3114 (unsigned)random());
3116 if (strequal(name, torture_ops[i].name)) {
3117 printf("Running %s\n", name);
3118 if (torture_ops[i].flags & FLAG_MULTIPROC) {
3119 t = create_procs(torture_ops[i].fn, &result);
3122 printf("TEST %s FAILED!\n", name);
3127 if (!torture_ops[i].fn(0)) {
3129 printf("TEST %s FAILED!\n", name);
3133 printf("%s took %g secs\n\n", name, t);
3140 static void usage(void)
3144 printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
3146 printf("\t-d debuglevel\n");
3147 printf("\t-U user%%pass\n");
3148 printf("\t-N numprocs\n");
3149 printf("\t-n my_netbios_name\n");
3150 printf("\t-W workgroup\n");
3151 printf("\t-o num_operations\n");
3152 printf("\t-O socket_options\n");
3153 printf("\t-m maximum protocol\n");
3154 printf("\t-L use oplocks\n");
3155 printf("\t-A showall\n");
3158 printf("tests are:");
3159 for (i=0;torture_ops[i].name;i++) {
3160 printf(" %s", torture_ops[i].name);
3164 printf("default test is ALL\n");
3173 /****************************************************************************
3175 ****************************************************************************/
3176 int main(int argc,char *argv[])
3181 extern char *optarg;
3183 BOOL correct = True;
3187 #ifdef HAVE_SETBUFFER
3188 setbuffer(stdout, NULL, 0);
3191 lp_load(dyn_CONFIGFILE,True,False,False);
3198 for(p = argv[1]; *p; p++)
3202 if (strncmp(argv[1], "//", 2)) {
3206 fstrcpy(host, &argv[1][2]);
3207 p = strchr_m(&host[2],'/');
3212 fstrcpy(share, p+1);
3216 if (*username == 0 && getenv("LOGNAME")) {
3217 pstrcpy(username,getenv("LOGNAME"));
3224 fstrcpy(workgroup, lp_workgroup());
3226 while ((opt = getopt(argc, argv, "hW:U:n:N:O:o:m:Ld:A")) != EOF) {
3229 fstrcpy(workgroup,optarg);
3232 max_protocol = interpret_protocol(optarg, max_protocol);
3235 nprocs = atoi(optarg);
3238 numops = atoi(optarg);
3241 DEBUGLEVEL = atoi(optarg);
3250 torture_showall = True;
3253 fstrcpy(myname, optarg);
3256 pstrcpy(username,optarg);
3257 p = strchr_m(username,'%');
3260 pstrcpy(password, p+1);
3265 printf("Unknown option %c (%d)\n", (char)opt, opt);
3272 p = getpass("Password:");
3274 pstrcpy(password, p);
3279 printf("host=%s share=%s user=%s myname=%s\n",
3280 host, share, username, myname);
3283 correct = run_test("ALL");
3285 for (i=1;i<argc;i++) {
3286 if (!run_test(argv[i])) {