2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1997-1998
5 Copyright (C) Jeremy Allison 2009
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
22 #include "nsswitch/libwbclient/wbc_async.h"
27 static fstring host, workgroup, share, password, username, myname;
28 static int max_protocol = PROTOCOL_NT1;
29 static const char *sockops="TCP_NODELAY";
31 static int port_to_use=0;
32 int torture_numops=100;
33 int torture_blocksize=1024*1024;
34 static int procnum; /* records process count number when forking */
35 static struct cli_state *current_cli;
36 static fstring randomfname;
37 static bool use_oplocks;
38 static bool use_level_II_oplocks;
39 static const char *client_txt = "client_oplocks.txt";
40 static bool use_kerberos;
41 static fstring multishare_conn_fname;
42 static bool use_multishare_conn = False;
43 static bool do_encrypt;
44 static const char *local_path = NULL;
46 bool torture_showall = False;
48 static double create_procs(bool (*fn)(int), bool *result);
51 static struct timeval tp1,tp2;
54 void start_timer(void)
59 double end_timer(void)
62 return((tp2.tv_sec - tp1.tv_sec) +
63 (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
67 /* return a pointer to a anonymous shared memory segment of size "size"
68 which will persist across fork() but will disappear when all processes
71 The memory is not zeroed
73 This function uses system5 shared memory. It takes advantage of a property
74 that the memory is not destroyed if it is attached when the id is removed
76 void *shm_setup(int size)
82 shmid = shm_open("private", O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
84 printf("can't get shared memory\n");
87 shm_unlink("private");
88 if (ftruncate(shmid, size) == -1) {
89 printf("can't set shared memory size\n");
92 ret = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, shmid, 0);
93 if (ret == MAP_FAILED) {
94 printf("can't map shared memory\n");
98 shmid = shmget(IPC_PRIVATE, size, S_IRUSR | S_IWUSR);
100 printf("can't get shared memory\n");
103 ret = (void *)shmat(shmid, 0, 0);
104 if (!ret || ret == (void *)-1) {
105 printf("can't attach to shared memory\n");
108 /* the following releases the ipc, but note that this process
109 and all its children will still have access to the memory, its
110 just that the shmid is no longer valid for other shm calls. This
111 means we don't leave behind lots of shm segments after we exit
113 See Stevens "advanced programming in unix env" for details
115 shmctl(shmid, IPC_RMID, 0);
121 /********************************************************************
122 Ensure a connection is encrypted.
123 ********************************************************************/
125 static bool force_cli_encryption(struct cli_state *c,
126 const char *sharename)
129 uint32 caplow, caphigh;
132 if (!SERVER_HAS_UNIX_CIFS(c)) {
133 d_printf("Encryption required and "
134 "server that doesn't support "
135 "UNIX extensions - failing connect\n");
139 status = cli_unix_extensions_version(c, &major, &minor, &caplow,
141 if (!NT_STATUS_IS_OK(status)) {
142 d_printf("Encryption required and "
143 "can't get UNIX CIFS extensions "
144 "version from server: %s\n", nt_errstr(status));
148 if (!(caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)) {
149 d_printf("Encryption required and "
150 "share %s doesn't support "
151 "encryption.\n", sharename);
155 if (c->use_kerberos) {
156 status = cli_gss_smb_encryption_start(c);
158 status = cli_raw_ntlm_smb_encryption_start(c,
164 if (!NT_STATUS_IS_OK(status)) {
165 d_printf("Encryption required and "
166 "setup failed with error %s.\n",
175 static struct cli_state *open_nbt_connection(void)
177 struct nmb_name called, calling;
178 struct sockaddr_storage ss;
182 make_nmb_name(&calling, myname, 0x0);
183 make_nmb_name(&called , host, 0x20);
187 if (!(c = cli_initialise())) {
188 printf("Failed initialize cli_struct to connect with %s\n", host);
192 c->port = port_to_use;
194 status = cli_connect(c, host, &ss);
195 if (!NT_STATUS_IS_OK(status)) {
196 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
200 c->use_kerberos = use_kerberos;
202 c->timeout = 120000; /* set a really long timeout (2 minutes) */
203 if (use_oplocks) c->use_oplocks = True;
204 if (use_level_II_oplocks) c->use_level_II_oplocks = True;
206 if (!cli_session_request(c, &calling, &called)) {
208 * Well, that failed, try *SMBSERVER ...
209 * However, we must reconnect as well ...
211 status = cli_connect(c, host, &ss);
212 if (!NT_STATUS_IS_OK(status)) {
213 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
217 make_nmb_name(&called, "*SMBSERVER", 0x20);
218 if (!cli_session_request(c, &calling, &called)) {
219 printf("%s rejected the session\n",host);
220 printf("We tried with a called name of %s & %s\n",
230 /* Insert a NULL at the first separator of the given path and return a pointer
231 * to the remainder of the string.
234 terminate_path_at_separator(char * path)
242 if ((p = strchr_m(path, '/'))) {
247 if ((p = strchr_m(path, '\\'))) {
257 parse a //server/share type UNC name
259 bool smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
260 char **hostname, char **sharename)
264 *hostname = *sharename = NULL;
266 if (strncmp(unc_name, "\\\\", 2) &&
267 strncmp(unc_name, "//", 2)) {
271 *hostname = talloc_strdup(mem_ctx, &unc_name[2]);
272 p = terminate_path_at_separator(*hostname);
275 *sharename = talloc_strdup(mem_ctx, p);
276 terminate_path_at_separator(*sharename);
279 if (*hostname && *sharename) {
283 TALLOC_FREE(*hostname);
284 TALLOC_FREE(*sharename);
288 static bool torture_open_connection_share(struct cli_state **c,
289 const char *hostname,
290 const char *sharename)
297 flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
299 flags |= CLI_FULL_CONNECTION_OPLOCKS;
300 if (use_level_II_oplocks)
301 flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS;
303 status = cli_full_connection(c, myname,
304 hostname, NULL, port_to_use,
307 password, flags, Undefined, &retry);
308 if (!NT_STATUS_IS_OK(status)) {
309 printf("failed to open share connection: //%s/%s port:%d - %s\n",
310 hostname, sharename, port_to_use, nt_errstr(status));
314 (*c)->timeout = 120000; /* set a really long timeout (2 minutes) */
317 return force_cli_encryption(*c,
323 bool torture_open_connection(struct cli_state **c, int conn_index)
325 char **unc_list = NULL;
326 int num_unc_names = 0;
329 if (use_multishare_conn==True) {
331 unc_list = file_lines_load(multishare_conn_fname, &num_unc_names, 0, NULL);
332 if (!unc_list || num_unc_names <= 0) {
333 printf("Failed to load unc names list from '%s'\n", multishare_conn_fname);
337 if (!smbcli_parse_unc(unc_list[conn_index % num_unc_names],
339 printf("Failed to parse UNC name %s\n",
340 unc_list[conn_index % num_unc_names]);
341 TALLOC_FREE(unc_list);
345 result = torture_open_connection_share(c, h, s);
347 /* h, s were copied earlier */
348 TALLOC_FREE(unc_list);
352 return torture_open_connection_share(c, host, share);
355 bool torture_cli_session_setup2(struct cli_state *cli, uint16 *new_vuid)
357 uint16 old_vuid = cli->vuid;
358 fstring old_user_name;
359 size_t passlen = strlen(password);
363 fstrcpy(old_user_name, cli->user_name);
365 ret = NT_STATUS_IS_OK(cli_session_setup(cli, username,
369 *new_vuid = cli->vuid;
370 cli->vuid = old_vuid;
371 status = cli_set_username(cli, old_user_name);
372 if (!NT_STATUS_IS_OK(status)) {
379 bool torture_close_connection(struct cli_state *c)
383 printf("tdis failed (%s)\n", cli_errstr(c));
393 /* check if the server produced the expected error code */
394 static bool check_error(int line, struct cli_state *c,
395 uint8 eclass, uint32 ecode, NTSTATUS nterr)
397 if (cli_is_dos_error(c)) {
401 /* Check DOS error */
403 cli_dos_error(c, &cclass, &num);
405 if (eclass != cclass || ecode != num) {
406 printf("unexpected error code class=%d code=%d\n",
407 (int)cclass, (int)num);
408 printf(" expected %d/%d %s (line=%d)\n",
409 (int)eclass, (int)ecode, nt_errstr(nterr), line);
418 status = cli_nt_error(c);
420 if (NT_STATUS_V(nterr) != NT_STATUS_V(status)) {
421 printf("unexpected error code %s\n", nt_errstr(status));
422 printf(" expected %s (line=%d)\n", nt_errstr(nterr), line);
431 static bool wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len)
433 while (!cli_lock(c, fnum, offset, len, -1, WRITE_LOCK)) {
434 if (!check_error(__LINE__, c, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
440 static bool rw_torture(struct cli_state *c)
442 const char *lockfname = "\\torture.lck";
446 pid_t pid2, pid = getpid();
452 memset(buf, '\0', sizeof(buf));
454 status = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
456 if (!NT_STATUS_IS_OK(status)) {
457 status = cli_open(c, lockfname, O_RDWR, DENY_NONE, &fnum2);
459 if (!NT_STATUS_IS_OK(status)) {
460 printf("open of %s failed (%s)\n", lockfname, cli_errstr(c));
464 for (i=0;i<torture_numops;i++) {
465 unsigned n = (unsigned)sys_random()%10;
467 printf("%d\r", i); fflush(stdout);
469 slprintf(fname, sizeof(fstring) - 1, "\\torture.%u", n);
471 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
475 if (!NT_STATUS_IS_OK(cli_open(c, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL, &fnum))) {
476 printf("open failed (%s)\n", cli_errstr(c));
481 if (cli_write(c, fnum, 0, (char *)&pid, 0, sizeof(pid)) != sizeof(pid)) {
482 printf("write failed (%s)\n", cli_errstr(c));
487 if (cli_write(c, fnum, 0, (char *)buf,
488 sizeof(pid)+(j*sizeof(buf)),
489 sizeof(buf)) != sizeof(buf)) {
490 printf("write failed (%s)\n", cli_errstr(c));
497 if (cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid)) != sizeof(pid)) {
498 printf("read failed (%s)\n", cli_errstr(c));
503 printf("data corruption!\n");
507 if (!NT_STATUS_IS_OK(cli_close(c, fnum))) {
508 printf("close failed (%s)\n", cli_errstr(c));
512 if (!NT_STATUS_IS_OK(cli_unlink(c, fname, aSYSTEM | aHIDDEN))) {
513 printf("unlink failed (%s)\n", cli_errstr(c));
517 if (!NT_STATUS_IS_OK(cli_unlock(c, fnum2, n*sizeof(int), sizeof(int)))) {
518 printf("unlock failed (%s)\n", cli_errstr(c));
524 cli_unlink(c, lockfname, aSYSTEM | aHIDDEN);
531 static bool run_torture(int dummy)
533 struct cli_state *cli;
538 cli_sockopt(cli, sockops);
540 ret = rw_torture(cli);
542 if (!torture_close_connection(cli)) {
549 static bool rw_torture3(struct cli_state *c, char *lockfname)
551 uint16_t fnum = (uint16_t)-1;
556 unsigned countprev = 0;
562 for (i = 0; i < sizeof(buf); i += sizeof(uint32))
564 SIVAL(buf, i, sys_random());
569 if (!NT_STATUS_IS_OK(cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
570 DENY_NONE, &fnum))) {
571 printf("first open read/write of %s failed (%s)\n",
572 lockfname, cli_errstr(c));
578 for (i = 0; i < 500 && fnum == (uint16_t)-1; i++)
580 status = cli_open(c, lockfname, O_RDONLY,
582 if (!NT_STATUS_IS_OK(status)) {
587 if (!NT_STATUS_IS_OK(status)) {
588 printf("second open read-only of %s failed (%s)\n",
589 lockfname, cli_errstr(c));
595 for (count = 0; count < sizeof(buf); count += sent)
597 if (count >= countprev) {
598 printf("%d %8d\r", i, count);
601 countprev += (sizeof(buf) / 20);
606 sent = ((unsigned)sys_random()%(20))+ 1;
607 if (sent > sizeof(buf) - count)
609 sent = sizeof(buf) - count;
612 if (cli_write(c, fnum, 0, buf+count, count, (size_t)sent) != sent) {
613 printf("write failed (%s)\n", cli_errstr(c));
619 sent = cli_read(c, fnum, buf_rd+count, count,
623 printf("read failed offset:%d size:%ld (%s)\n",
624 count, (unsigned long)sizeof(buf)-count,
631 if (memcmp(buf_rd+count, buf+count, sent) != 0)
633 printf("read/write compare failed\n");
634 printf("offset: %d req %ld recvd %ld\n", count, (unsigned long)sizeof(buf)-count, (unsigned long)sent);
643 if (!NT_STATUS_IS_OK(cli_close(c, fnum))) {
644 printf("close failed (%s)\n", cli_errstr(c));
651 static bool rw_torture2(struct cli_state *c1, struct cli_state *c2)
653 const char *lockfname = "\\torture2.lck";
662 if (!NT_STATUS_IS_OK(cli_unlink(c1, lockfname, aSYSTEM | aHIDDEN))) {
663 printf("unlink failed (%s) (normal, this file should not exist)\n", cli_errstr(c1));
666 if (!NT_STATUS_IS_OK(cli_open(c1, lockfname, O_RDWR | O_CREAT | O_EXCL,
667 DENY_NONE, &fnum1))) {
668 printf("first open read/write of %s failed (%s)\n",
669 lockfname, cli_errstr(c1));
672 if (!NT_STATUS_IS_OK(cli_open(c2, lockfname, O_RDONLY,
673 DENY_NONE, &fnum2))) {
674 printf("second open read-only of %s failed (%s)\n",
675 lockfname, cli_errstr(c2));
676 cli_close(c1, fnum1);
680 for (i=0;i<torture_numops;i++)
682 size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
684 printf("%d\r", i); fflush(stdout);
687 generate_random_buffer((unsigned char *)buf, buf_size);
689 if (cli_write(c1, fnum1, 0, buf, 0, buf_size) != buf_size) {
690 printf("write failed (%s)\n", cli_errstr(c1));
695 if ((bytes_read = cli_read(c2, fnum2, buf_rd, 0, buf_size)) != buf_size) {
696 printf("read failed (%s)\n", cli_errstr(c2));
697 printf("read %d, expected %ld\n", (int)bytes_read,
698 (unsigned long)buf_size);
703 if (memcmp(buf_rd, buf, buf_size) != 0)
705 printf("read/write compare failed\n");
711 if (!NT_STATUS_IS_OK(cli_close(c2, fnum2))) {
712 printf("close failed (%s)\n", cli_errstr(c2));
715 if (!NT_STATUS_IS_OK(cli_close(c1, fnum1))) {
716 printf("close failed (%s)\n", cli_errstr(c1));
720 if (!NT_STATUS_IS_OK(cli_unlink(c1, lockfname, aSYSTEM | aHIDDEN))) {
721 printf("unlink failed (%s)\n", cli_errstr(c1));
728 static bool run_readwritetest(int dummy)
730 struct cli_state *cli1, *cli2;
731 bool test1, test2 = False;
733 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
736 cli_sockopt(cli1, sockops);
737 cli_sockopt(cli2, sockops);
739 printf("starting readwritetest\n");
741 test1 = rw_torture2(cli1, cli2);
742 printf("Passed readwritetest v1: %s\n", BOOLSTR(test1));
745 test2 = rw_torture2(cli1, cli1);
746 printf("Passed readwritetest v2: %s\n", BOOLSTR(test2));
749 if (!torture_close_connection(cli1)) {
753 if (!torture_close_connection(cli2)) {
757 return (test1 && test2);
760 static bool run_readwritemulti(int dummy)
762 struct cli_state *cli;
767 cli_sockopt(cli, sockops);
769 printf("run_readwritemulti: fname %s\n", randomfname);
770 test = rw_torture3(cli, randomfname);
772 if (!torture_close_connection(cli)) {
779 static bool run_readwritelarge(int dummy)
781 static struct cli_state *cli1;
783 const char *lockfname = "\\large.dat";
788 if (!torture_open_connection(&cli1, 0)) {
791 cli_sockopt(cli1, sockops);
792 memset(buf,'\0',sizeof(buf));
794 cli1->max_xmit = 128*1024;
796 printf("starting readwritelarge\n");
798 cli_unlink(cli1, lockfname, aSYSTEM | aHIDDEN);
800 if (!NT_STATUS_IS_OK(cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE, &fnum1))) {
801 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
805 cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf));
807 if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
808 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
812 if (fsize == sizeof(buf))
813 printf("readwritelarge test 1 succeeded (size = %lx)\n",
814 (unsigned long)fsize);
816 printf("readwritelarge test 1 failed (size = %lx)\n",
817 (unsigned long)fsize);
821 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
822 printf("close failed (%s)\n", cli_errstr(cli1));
826 if (!NT_STATUS_IS_OK(cli_unlink(cli1, lockfname, aSYSTEM | aHIDDEN))) {
827 printf("unlink failed (%s)\n", cli_errstr(cli1));
831 if (!NT_STATUS_IS_OK(cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE, &fnum1))) {
832 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
836 cli1->max_xmit = 4*1024;
838 cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf));
840 if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
841 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
845 if (fsize == sizeof(buf))
846 printf("readwritelarge test 2 succeeded (size = %lx)\n",
847 (unsigned long)fsize);
849 printf("readwritelarge test 2 failed (size = %lx)\n",
850 (unsigned long)fsize);
855 /* ToDo - set allocation. JRA */
856 if(!cli_set_allocation_size(cli1, fnum1, 0)) {
857 printf("set allocation size to zero failed (%s)\n", cli_errstr(&cli1));
860 if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
861 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
865 printf("readwritelarge test 3 (truncate test) succeeded (size = %x)\n", fsize);
868 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
869 printf("close failed (%s)\n", cli_errstr(cli1));
873 if (!torture_close_connection(cli1)) {
882 #define ival(s) strtol(s, NULL, 0)
884 /* run a test that simulates an approximate netbench client load */
885 static bool run_netbench(int client)
887 struct cli_state *cli;
892 const char *params[20];
899 cli_sockopt(cli, sockops);
903 slprintf(cname,sizeof(cname)-1, "client%d", client);
905 f = fopen(client_txt, "r");
912 while (fgets(line, sizeof(line)-1, f)) {
916 line[strlen(line)-1] = 0;
918 /* printf("[%d] %s\n", line_count, line); */
920 all_string_sub(line,"client1", cname, sizeof(line));
922 /* parse the command parameters */
923 params[0] = strtok_r(line, " ", &saveptr);
925 while (params[i]) params[++i] = strtok_r(NULL, " ", &saveptr);
931 if (!strncmp(params[0],"SMB", 3)) {
932 printf("ERROR: You are using a dbench 1 load file\n");
936 if (!strcmp(params[0],"NTCreateX")) {
937 nb_createx(params[1], ival(params[2]), ival(params[3]),
939 } else if (!strcmp(params[0],"Close")) {
940 nb_close(ival(params[1]));
941 } else if (!strcmp(params[0],"Rename")) {
942 nb_rename(params[1], params[2]);
943 } else if (!strcmp(params[0],"Unlink")) {
944 nb_unlink(params[1]);
945 } else if (!strcmp(params[0],"Deltree")) {
946 nb_deltree(params[1]);
947 } else if (!strcmp(params[0],"Rmdir")) {
949 } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
950 nb_qpathinfo(params[1]);
951 } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
952 nb_qfileinfo(ival(params[1]));
953 } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
954 nb_qfsinfo(ival(params[1]));
955 } else if (!strcmp(params[0],"FIND_FIRST")) {
956 nb_findfirst(params[1]);
957 } else if (!strcmp(params[0],"WriteX")) {
958 nb_writex(ival(params[1]),
959 ival(params[2]), ival(params[3]), ival(params[4]));
960 } else if (!strcmp(params[0],"ReadX")) {
961 nb_readx(ival(params[1]),
962 ival(params[2]), ival(params[3]), ival(params[4]));
963 } else if (!strcmp(params[0],"Flush")) {
964 nb_flush(ival(params[1]));
966 printf("Unknown operation %s\n", params[0]);
974 if (!torture_close_connection(cli)) {
982 /* run a test that simulates an approximate netbench client load */
983 static bool run_nbench(int dummy)
992 signal(SIGALRM, nb_alarm);
994 t = create_procs(run_netbench, &correct);
997 printf("\nThroughput %g MB/sec\n",
998 1.0e-6 * nbio_total() / t);
1004 This test checks for two things:
1006 1) correct support for retaining locks over a close (ie. the server
1007 must not use posix semantics)
1008 2) support for lock timeouts
1010 static bool run_locktest1(int dummy)
1012 struct cli_state *cli1, *cli2;
1013 const char *fname = "\\lockt1.lck";
1014 uint16_t fnum1, fnum2, fnum3;
1016 unsigned lock_timeout;
1018 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1021 cli_sockopt(cli1, sockops);
1022 cli_sockopt(cli2, sockops);
1024 printf("starting locktest1\n");
1026 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1028 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1029 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1032 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum2))) {
1033 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli1));
1036 if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum3))) {
1037 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli2));
1041 if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
1042 printf("lock1 failed (%s)\n", cli_errstr(cli1));
1047 if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
1048 printf("lock2 succeeded! This is a locking bug\n");
1051 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1052 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1056 lock_timeout = (1 + (random() % 20));
1057 printf("Testing lock timeout with timeout=%u\n", lock_timeout);
1059 if (cli_lock(cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK)) {
1060 printf("lock3 succeeded! This is a locking bug\n");
1063 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1064 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1068 if (ABS(t2 - t1) < lock_timeout-1) {
1069 printf("error: This server appears not to support timed lock requests\n");
1072 printf("server slept for %u seconds for a %u second timeout\n",
1073 (unsigned int)(t2-t1), lock_timeout);
1075 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
1076 printf("close1 failed (%s)\n", cli_errstr(cli1));
1080 if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
1081 printf("lock4 succeeded! This is a locking bug\n");
1084 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1085 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1088 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
1089 printf("close2 failed (%s)\n", cli_errstr(cli1));
1093 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum3))) {
1094 printf("close3 failed (%s)\n", cli_errstr(cli2));
1098 if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
1099 printf("unlink failed (%s)\n", cli_errstr(cli1));
1104 if (!torture_close_connection(cli1)) {
1108 if (!torture_close_connection(cli2)) {
1112 printf("Passed locktest1\n");
1117 this checks to see if a secondary tconx can use open files from an
1120 static bool run_tcon_test(int dummy)
1122 static struct cli_state *cli;
1123 const char *fname = "\\tcontest.tmp";
1125 uint16 cnum1, cnum2, cnum3;
1126 uint16 vuid1, vuid2;
1131 memset(buf, '\0', sizeof(buf));
1133 if (!torture_open_connection(&cli, 0)) {
1136 cli_sockopt(cli, sockops);
1138 printf("starting tcontest\n");
1140 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
1142 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1143 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1150 if (cli_write(cli, fnum1, 0, buf, 130, 4) != 4) {
1151 printf("initial write failed (%s)", cli_errstr(cli));
1155 status = cli_tcon_andx(cli, share, "?????",
1156 password, strlen(password)+1);
1157 if (!NT_STATUS_IS_OK(status)) {
1158 printf("%s refused 2nd tree connect (%s)\n", host,
1165 cnum3 = MAX(cnum1, cnum2) + 1; /* any invalid number */
1166 vuid2 = cli->vuid + 1;
1168 /* try a write with the wrong tid */
1171 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1172 printf("* server allows write with wrong TID\n");
1175 printf("server fails write with wrong TID : %s\n", cli_errstr(cli));
1179 /* try a write with an invalid tid */
1182 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1183 printf("* server allows write with invalid TID\n");
1186 printf("server fails write with invalid TID : %s\n", cli_errstr(cli));
1189 /* try a write with an invalid vuid */
1193 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1194 printf("* server allows write with invalid VUID\n");
1197 printf("server fails write with invalid VUID : %s\n", cli_errstr(cli));
1203 if (!NT_STATUS_IS_OK(cli_close(cli, fnum1))) {
1204 printf("close failed (%s)\n", cli_errstr(cli));
1210 if (!cli_tdis(cli)) {
1211 printf("secondary tdis failed (%s)\n", cli_errstr(cli));
1217 if (!torture_close_connection(cli)) {
1226 checks for old style tcon support
1228 static bool run_tcon2_test(int dummy)
1230 static struct cli_state *cli;
1231 uint16 cnum, max_xmit;
1235 if (!torture_open_connection(&cli, 0)) {
1238 cli_sockopt(cli, sockops);
1240 printf("starting tcon2 test\n");
1242 if (asprintf(&service, "\\\\%s\\%s", host, share) == -1) {
1246 status = cli_raw_tcon(cli, service, password, "?????", &max_xmit, &cnum);
1248 if (!NT_STATUS_IS_OK(status)) {
1249 printf("tcon2 failed : %s\n", cli_errstr(cli));
1251 printf("tcon OK : max_xmit=%d cnum=%d tid=%d\n",
1252 (int)max_xmit, (int)cnum, SVAL(cli->inbuf, smb_tid));
1255 if (!torture_close_connection(cli)) {
1259 printf("Passed tcon2 test\n");
1263 static bool tcon_devtest(struct cli_state *cli,
1264 const char *myshare, const char *devtype,
1265 const char *return_devtype,
1266 NTSTATUS expected_error)
1271 status = cli_tcon_andx(cli, myshare, devtype,
1272 password, strlen(password)+1);
1274 if (NT_STATUS_IS_OK(expected_error)) {
1275 if (NT_STATUS_IS_OK(status)) {
1276 if (strcmp(cli->dev, return_devtype) == 0) {
1279 printf("tconX to share %s with type %s "
1280 "succeeded but returned the wrong "
1281 "device type (got [%s] but should have got [%s])\n",
1282 myshare, devtype, cli->dev, return_devtype);
1286 printf("tconX to share %s with type %s "
1287 "should have succeeded but failed\n",
1293 if (NT_STATUS_IS_OK(status)) {
1294 printf("tconx to share %s with type %s "
1295 "should have failed but succeeded\n",
1299 if (NT_STATUS_EQUAL(cli_nt_error(cli),
1303 printf("Returned unexpected error\n");
1312 checks for correct tconX support
1314 static bool run_tcon_devtype_test(int dummy)
1316 static struct cli_state *cli1 = NULL;
1322 status = cli_full_connection(&cli1, myname,
1323 host, NULL, port_to_use,
1325 username, workgroup,
1326 password, flags, Undefined, &retry);
1328 if (!NT_STATUS_IS_OK(status)) {
1329 printf("could not open connection\n");
1333 if (!tcon_devtest(cli1, "IPC$", "A:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1336 if (!tcon_devtest(cli1, "IPC$", "?????", "IPC", NT_STATUS_OK))
1339 if (!tcon_devtest(cli1, "IPC$", "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1342 if (!tcon_devtest(cli1, "IPC$", "IPC", "IPC", NT_STATUS_OK))
1345 if (!tcon_devtest(cli1, "IPC$", "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1348 if (!tcon_devtest(cli1, share, "A:", "A:", NT_STATUS_OK))
1351 if (!tcon_devtest(cli1, share, "?????", "A:", NT_STATUS_OK))
1354 if (!tcon_devtest(cli1, share, "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1357 if (!tcon_devtest(cli1, share, "IPC", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1360 if (!tcon_devtest(cli1, share, "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1366 printf("Passed tcondevtest\n");
1373 This test checks that
1375 1) the server supports multiple locking contexts on the one SMB
1376 connection, distinguished by PID.
1378 2) the server correctly fails overlapping locks made by the same PID (this
1379 goes against POSIX behaviour, which is why it is tricky to implement)
1381 3) the server denies unlock requests by an incorrect client PID
1383 static bool run_locktest2(int dummy)
1385 static struct cli_state *cli;
1386 const char *fname = "\\lockt2.lck";
1387 uint16_t fnum1, fnum2, fnum3;
1388 bool correct = True;
1390 if (!torture_open_connection(&cli, 0)) {
1394 cli_sockopt(cli, sockops);
1396 printf("starting locktest2\n");
1398 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
1402 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1403 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1407 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum2))) {
1408 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli));
1414 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum3))) {
1415 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli));
1421 if (!cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1422 printf("lock1 failed (%s)\n", cli_errstr(cli));
1426 if (cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1427 printf("WRITE lock1 succeeded! This is a locking bug\n");
1430 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1431 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1434 if (cli_lock(cli, fnum2, 0, 4, 0, WRITE_LOCK)) {
1435 printf("WRITE lock2 succeeded! This is a locking bug\n");
1438 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1439 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1442 if (cli_lock(cli, fnum2, 0, 4, 0, READ_LOCK)) {
1443 printf("READ lock2 succeeded! This is a locking bug\n");
1446 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1447 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1450 if (!cli_lock(cli, fnum1, 100, 4, 0, WRITE_LOCK)) {
1451 printf("lock at 100 failed (%s)\n", cli_errstr(cli));
1454 if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 100, 4))) {
1455 printf("unlock at 100 succeeded! This is a locking bug\n");
1459 if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 0, 4))) {
1460 printf("unlock1 succeeded! This is a locking bug\n");
1463 if (!check_error(__LINE__, cli,
1465 NT_STATUS_RANGE_NOT_LOCKED)) return False;
1468 if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 0, 8))) {
1469 printf("unlock2 succeeded! This is a locking bug\n");
1472 if (!check_error(__LINE__, cli,
1474 NT_STATUS_RANGE_NOT_LOCKED)) return False;
1477 if (cli_lock(cli, fnum3, 0, 4, 0, WRITE_LOCK)) {
1478 printf("lock3 succeeded! This is a locking bug\n");
1481 if (!check_error(__LINE__, cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
1486 if (!NT_STATUS_IS_OK(cli_close(cli, fnum1))) {
1487 printf("close1 failed (%s)\n", cli_errstr(cli));
1491 if (!NT_STATUS_IS_OK(cli_close(cli, fnum2))) {
1492 printf("close2 failed (%s)\n", cli_errstr(cli));
1496 if (!NT_STATUS_IS_OK(cli_close(cli, fnum3))) {
1497 printf("close3 failed (%s)\n", cli_errstr(cli));
1501 if (!torture_close_connection(cli)) {
1505 printf("locktest2 finished\n");
1512 This test checks that
1514 1) the server supports the full offset range in lock requests
1516 static bool run_locktest3(int dummy)
1518 static struct cli_state *cli1, *cli2;
1519 const char *fname = "\\lockt3.lck";
1520 uint16_t fnum1, fnum2;
1523 bool correct = True;
1525 #define NEXT_OFFSET offset += (~(uint32)0) / torture_numops
1527 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1530 cli_sockopt(cli1, sockops);
1531 cli_sockopt(cli2, sockops);
1533 printf("starting locktest3\n");
1535 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1537 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1538 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1541 if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2))) {
1542 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli2));
1546 for (offset=i=0;i<torture_numops;i++) {
1548 if (!cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1549 printf("lock1 %d failed (%s)\n",
1555 if (!cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1556 printf("lock2 %d failed (%s)\n",
1563 for (offset=i=0;i<torture_numops;i++) {
1566 if (cli_lock(cli1, fnum1, offset-2, 1, 0, WRITE_LOCK)) {
1567 printf("error: lock1 %d succeeded!\n", i);
1571 if (cli_lock(cli2, fnum2, offset-1, 1, 0, WRITE_LOCK)) {
1572 printf("error: lock2 %d succeeded!\n", i);
1576 if (cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1577 printf("error: lock3 %d succeeded!\n", i);
1581 if (cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1582 printf("error: lock4 %d succeeded!\n", i);
1587 for (offset=i=0;i<torture_numops;i++) {
1590 if (!NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, offset-1, 1))) {
1591 printf("unlock1 %d failed (%s)\n",
1597 if (!NT_STATUS_IS_OK(cli_unlock(cli2, fnum2, offset-2, 1))) {
1598 printf("unlock2 %d failed (%s)\n",
1605 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
1606 printf("close1 failed (%s)\n", cli_errstr(cli1));
1610 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
1611 printf("close2 failed (%s)\n", cli_errstr(cli2));
1615 if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
1616 printf("unlink failed (%s)\n", cli_errstr(cli1));
1620 if (!torture_close_connection(cli1)) {
1624 if (!torture_close_connection(cli2)) {
1628 printf("finished locktest3\n");
1633 #define EXPECTED(ret, v) if ((ret) != (v)) { \
1634 printf("** "); correct = False; \
1638 looks at overlapping locks
1640 static bool run_locktest4(int dummy)
1642 static struct cli_state *cli1, *cli2;
1643 const char *fname = "\\lockt4.lck";
1644 uint16_t fnum1, fnum2, f;
1647 bool correct = True;
1649 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1653 cli_sockopt(cli1, sockops);
1654 cli_sockopt(cli2, sockops);
1656 printf("starting locktest4\n");
1658 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1660 cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1661 cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1663 memset(buf, 0, sizeof(buf));
1665 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1666 printf("Failed to create file\n");
1671 ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1672 cli_lock(cli1, fnum1, 2, 4, 0, WRITE_LOCK);
1673 EXPECTED(ret, False);
1674 printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
1676 ret = cli_lock(cli1, fnum1, 10, 4, 0, READ_LOCK) &&
1677 cli_lock(cli1, fnum1, 12, 4, 0, READ_LOCK);
1678 EXPECTED(ret, True);
1679 printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
1681 ret = cli_lock(cli1, fnum1, 20, 4, 0, WRITE_LOCK) &&
1682 cli_lock(cli2, fnum2, 22, 4, 0, WRITE_LOCK);
1683 EXPECTED(ret, False);
1684 printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
1686 ret = cli_lock(cli1, fnum1, 30, 4, 0, READ_LOCK) &&
1687 cli_lock(cli2, fnum2, 32, 4, 0, READ_LOCK);
1688 EXPECTED(ret, True);
1689 printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
1691 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 40, 4, 0, WRITE_LOCK)) &&
1692 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 42, 4, 0, WRITE_LOCK));
1693 EXPECTED(ret, False);
1694 printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
1696 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 50, 4, 0, READ_LOCK)) &&
1697 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 52, 4, 0, READ_LOCK));
1698 EXPECTED(ret, True);
1699 printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
1701 ret = cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK) &&
1702 cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK);
1703 EXPECTED(ret, True);
1704 printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
1706 ret = cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK) &&
1707 cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK);
1708 EXPECTED(ret, False);
1709 printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
1711 ret = cli_lock(cli1, fnum1, 80, 4, 0, READ_LOCK) &&
1712 cli_lock(cli1, fnum1, 80, 4, 0, WRITE_LOCK);
1713 EXPECTED(ret, False);
1714 printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
1716 ret = cli_lock(cli1, fnum1, 90, 4, 0, WRITE_LOCK) &&
1717 cli_lock(cli1, fnum1, 90, 4, 0, READ_LOCK);
1718 EXPECTED(ret, True);
1719 printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1721 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 100, 4, 0, WRITE_LOCK)) &&
1722 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 100, 4, 0, READ_LOCK));
1723 EXPECTED(ret, False);
1724 printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1726 ret = cli_lock(cli1, fnum1, 110, 4, 0, READ_LOCK) &&
1727 cli_lock(cli1, fnum1, 112, 4, 0, READ_LOCK) &&
1728 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 110, 6));
1729 EXPECTED(ret, False);
1730 printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
1733 ret = cli_lock(cli1, fnum1, 120, 4, 0, WRITE_LOCK) &&
1734 (cli_read(cli2, fnum2, buf, 120, 4) == 4);
1735 EXPECTED(ret, False);
1736 printf("this server %s strict write locking\n", ret?"doesn't do":"does");
1738 ret = cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK) &&
1739 (cli_write(cli2, fnum2, 0, buf, 130, 4) == 4);
1740 EXPECTED(ret, False);
1741 printf("this server %s strict read locking\n", ret?"doesn't do":"does");
1744 ret = cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1745 cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1746 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4)) &&
1747 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4));
1748 EXPECTED(ret, True);
1749 printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
1752 ret = cli_lock(cli1, fnum1, 150, 4, 0, WRITE_LOCK) &&
1753 cli_lock(cli1, fnum1, 150, 4, 0, READ_LOCK) &&
1754 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4)) &&
1755 (cli_read(cli2, fnum2, buf, 150, 4) == 4) &&
1756 !(cli_write(cli2, fnum2, 0, buf, 150, 4) == 4) &&
1757 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4));
1758 EXPECTED(ret, True);
1759 printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
1761 ret = cli_lock(cli1, fnum1, 160, 4, 0, READ_LOCK) &&
1762 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 160, 4)) &&
1763 (cli_write(cli2, fnum2, 0, buf, 160, 4) == 4) &&
1764 (cli_read(cli2, fnum2, buf, 160, 4) == 4);
1765 EXPECTED(ret, True);
1766 printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
1768 ret = cli_lock(cli1, fnum1, 170, 4, 0, WRITE_LOCK) &&
1769 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 170, 4)) &&
1770 (cli_write(cli2, fnum2, 0, buf, 170, 4) == 4) &&
1771 (cli_read(cli2, fnum2, buf, 170, 4) == 4);
1772 EXPECTED(ret, True);
1773 printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
1775 ret = cli_lock(cli1, fnum1, 190, 4, 0, WRITE_LOCK) &&
1776 cli_lock(cli1, fnum1, 190, 4, 0, READ_LOCK) &&
1777 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 190, 4)) &&
1778 !(cli_write(cli2, fnum2, 0, buf, 190, 4) == 4) &&
1779 (cli_read(cli2, fnum2, buf, 190, 4) == 4);
1780 EXPECTED(ret, True);
1781 printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
1783 cli_close(cli1, fnum1);
1784 cli_close(cli2, fnum2);
1785 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
1786 cli_open(cli1, fname, O_RDWR, DENY_NONE, &f);
1787 ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1788 cli_lock(cli1, f, 0, 1, 0, READ_LOCK) &&
1789 NT_STATUS_IS_OK(cli_close(cli1, fnum1)) &&
1790 NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1)) &&
1791 cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1793 cli_close(cli1, fnum1);
1794 EXPECTED(ret, True);
1795 printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
1798 cli_close(cli1, fnum1);
1799 cli_close(cli2, fnum2);
1800 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1801 torture_close_connection(cli1);
1802 torture_close_connection(cli2);
1804 printf("finished locktest4\n");
1809 looks at lock upgrade/downgrade.
1811 static bool run_locktest5(int dummy)
1813 static struct cli_state *cli1, *cli2;
1814 const char *fname = "\\lockt5.lck";
1815 uint16_t fnum1, fnum2, fnum3;
1818 bool correct = True;
1820 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1824 cli_sockopt(cli1, sockops);
1825 cli_sockopt(cli2, sockops);
1827 printf("starting locktest5\n");
1829 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1831 cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1832 cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1833 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum3);
1835 memset(buf, 0, sizeof(buf));
1837 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1838 printf("Failed to create file\n");
1843 /* Check for NT bug... */
1844 ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1845 cli_lock(cli1, fnum3, 0, 1, 0, READ_LOCK);
1846 cli_close(cli1, fnum1);
1847 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
1848 ret = cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1849 EXPECTED(ret, True);
1850 printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
1851 cli_close(cli1, fnum1);
1852 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
1853 cli_unlock(cli1, fnum3, 0, 1);
1855 ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1856 cli_lock(cli1, fnum1, 1, 1, 0, READ_LOCK);
1857 EXPECTED(ret, True);
1858 printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
1860 ret = cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1861 EXPECTED(ret, False);
1863 printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
1865 /* Unlock the process 2 lock. */
1866 cli_unlock(cli2, fnum2, 0, 4);
1868 ret = cli_lock(cli1, fnum3, 0, 4, 0, READ_LOCK);
1869 EXPECTED(ret, False);
1871 printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
1873 /* Unlock the process 1 fnum3 lock. */
1874 cli_unlock(cli1, fnum3, 0, 4);
1876 /* Stack 2 more locks here. */
1877 ret = cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK) &&
1878 cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK);
1880 EXPECTED(ret, True);
1881 printf("the same process %s stack read locks\n", ret?"can":"cannot");
1883 /* Unlock the first process lock, then check this was the WRITE lock that was
1886 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
1887 cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1889 EXPECTED(ret, True);
1890 printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
1892 /* Unlock the process 2 lock. */
1893 cli_unlock(cli2, fnum2, 0, 4);
1895 /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
1897 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 1, 1)) &&
1898 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
1899 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
1901 EXPECTED(ret, True);
1902 printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
1904 /* Ensure the next unlock fails. */
1905 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
1906 EXPECTED(ret, False);
1907 printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
1909 /* Ensure connection 2 can get a write lock. */
1910 ret = cli_lock(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
1911 EXPECTED(ret, True);
1913 printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
1917 cli_close(cli1, fnum1);
1918 cli_close(cli2, fnum2);
1919 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1920 if (!torture_close_connection(cli1)) {
1923 if (!torture_close_connection(cli2)) {
1927 printf("finished locktest5\n");
1933 tries the unusual lockingX locktype bits
1935 static bool run_locktest6(int dummy)
1937 static struct cli_state *cli;
1938 const char *fname[1] = { "\\lock6.txt" };
1943 if (!torture_open_connection(&cli, 0)) {
1947 cli_sockopt(cli, sockops);
1949 printf("starting locktest6\n");
1952 printf("Testing %s\n", fname[i]);
1954 cli_unlink(cli, fname[i], aSYSTEM | aHIDDEN);
1956 cli_open(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
1957 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
1958 cli_close(cli, fnum);
1959 printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
1961 cli_open(cli, fname[i], O_RDWR, DENY_NONE, &fnum);
1962 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
1963 cli_close(cli, fnum);
1964 printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
1966 cli_unlink(cli, fname[i], aSYSTEM | aHIDDEN);
1969 torture_close_connection(cli);
1971 printf("finished locktest6\n");
1975 static bool run_locktest7(int dummy)
1977 struct cli_state *cli1;
1978 const char *fname = "\\lockt7.lck";
1981 bool correct = False;
1983 if (!torture_open_connection(&cli1, 0)) {
1987 cli_sockopt(cli1, sockops);
1989 printf("starting locktest7\n");
1991 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1993 cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1995 memset(buf, 0, sizeof(buf));
1997 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1998 printf("Failed to create file\n");
2002 cli_setpid(cli1, 1);
2004 if (!cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK)) {
2005 printf("Unable to apply read lock on range 130:4, error was %s\n", cli_errstr(cli1));
2008 printf("pid1 successfully locked range 130:4 for READ\n");
2011 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2012 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2015 printf("pid1 successfully read the range 130:4\n");
2018 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2019 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2020 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2021 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2025 printf("pid1 successfully wrote to the range 130:4 (should be denied)\n");
2029 cli_setpid(cli1, 2);
2031 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2032 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2034 printf("pid2 successfully read the range 130:4\n");
2037 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2038 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2039 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2040 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2044 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2048 cli_setpid(cli1, 1);
2049 cli_unlock(cli1, fnum1, 130, 4);
2051 if (!cli_lock(cli1, fnum1, 130, 4, 0, WRITE_LOCK)) {
2052 printf("Unable to apply write lock on range 130:4, error was %s\n", cli_errstr(cli1));
2055 printf("pid1 successfully locked range 130:4 for WRITE\n");
2058 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2059 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2062 printf("pid1 successfully read the range 130:4\n");
2065 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2066 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2069 printf("pid1 successfully wrote to the range 130:4\n");
2072 cli_setpid(cli1, 2);
2074 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2075 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2076 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2077 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2081 printf("pid2 successfully read the range 130:4 (should be denied)\n");
2085 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2086 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2087 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2088 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2092 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2096 cli_unlock(cli1, fnum1, 130, 0);
2100 cli_close(cli1, fnum1);
2101 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2102 torture_close_connection(cli1);
2104 printf("finished locktest7\n");
2109 * This demonstrates a problem with our use of GPFS share modes: A file
2110 * descriptor sitting in the pending close queue holding a GPFS share mode
2111 * blocks opening a file another time. Happens with Word 2007 temp files.
2112 * With "posix locking = yes" and "gpfs:sharemodes = yes" enabled, the third
2113 * open is denied with NT_STATUS_SHARING_VIOLATION.
2116 static bool run_locktest8(int dummy)
2118 struct cli_state *cli1;
2119 const char *fname = "\\lockt8.lck";
2120 uint16_t fnum1, fnum2;
2122 bool correct = False;
2125 if (!torture_open_connection(&cli1, 0)) {
2129 cli_sockopt(cli1, sockops);
2131 printf("starting locktest8\n");
2133 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2135 status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_WRITE,
2137 if (!NT_STATUS_IS_OK(status)) {
2138 d_fprintf(stderr, "cli_open returned %s\n", cli_errstr(cli1));
2142 memset(buf, 0, sizeof(buf));
2144 status = cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum2);
2145 if (!NT_STATUS_IS_OK(status)) {
2146 d_fprintf(stderr, "cli_open second time returned %s\n",
2151 if (!cli_lock(cli1, fnum2, 1, 1, 0, READ_LOCK)) {
2152 printf("Unable to apply read lock on range 1:1, error was "
2153 "%s\n", cli_errstr(cli1));
2157 status = cli_close(cli1, fnum1);
2158 if (!NT_STATUS_IS_OK(status)) {
2159 d_fprintf(stderr, "cli_close(fnum1) %s\n", cli_errstr(cli1));
2163 status = cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2164 if (!NT_STATUS_IS_OK(status)) {
2165 d_fprintf(stderr, "cli_open third time returned %s\n",
2173 cli_close(cli1, fnum1);
2174 cli_close(cli1, fnum2);
2175 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2176 torture_close_connection(cli1);
2178 printf("finished locktest8\n");
2183 * This test is designed to be run in conjunction with
2184 * external NFS or POSIX locks taken in the filesystem.
2185 * It checks that the smbd server will block until the
2186 * lock is released and then acquire it. JRA.
2189 static bool got_alarm;
2190 static int alarm_fd;
2192 static void alarm_handler(int dummy)
2197 static void alarm_handler_parent(int dummy)
2202 static void do_local_lock(int read_fd, int write_fd)
2207 const char *local_pathname = NULL;
2210 local_pathname = talloc_asprintf(talloc_tos(),
2211 "%s/lockt9.lck", local_path);
2212 if (!local_pathname) {
2213 printf("child: alloc fail\n");
2217 unlink(local_pathname);
2218 fd = open(local_pathname, O_RDWR|O_CREAT, 0666);
2220 printf("child: open of %s failed %s.\n",
2221 local_pathname, strerror(errno));
2225 /* Now take a fcntl lock. */
2226 lock.l_type = F_WRLCK;
2227 lock.l_whence = SEEK_SET;
2230 lock.l_pid = getpid();
2232 ret = fcntl(fd,F_SETLK,&lock);
2234 printf("child: failed to get lock 0:4 on file %s. Error %s\n",
2235 local_pathname, strerror(errno));
2238 printf("child: got lock 0:4 on file %s.\n",
2243 CatchSignal(SIGALRM, alarm_handler);
2245 /* Signal the parent. */
2246 if (write(write_fd, &c, 1) != 1) {
2247 printf("child: start signal fail %s.\n",
2254 /* Wait for the parent to be ready. */
2255 if (read(read_fd, &c, 1) != 1) {
2256 printf("child: reply signal fail %s.\n",
2264 printf("child: released lock 0:4 on file %s.\n",
2270 static bool run_locktest9(int dummy)
2272 struct cli_state *cli1;
2273 const char *fname = "\\lockt9.lck";
2275 bool correct = False;
2276 int pipe_in[2], pipe_out[2];
2283 printf("starting locktest9\n");
2285 if (local_path == NULL) {
2286 d_fprintf(stderr, "locktest9 must be given a local path via -l <localpath>\n");
2290 if (pipe(pipe_in) == -1 || pipe(pipe_out) == -1) {
2295 if (child_pid == -1) {
2299 if (child_pid == 0) {
2301 do_local_lock(pipe_out[0], pipe_in[1]);
2311 ret = read(pipe_in[0], &c, 1);
2313 d_fprintf(stderr, "failed to read start signal from child. %s\n",
2318 if (!torture_open_connection(&cli1, 0)) {
2322 cli_sockopt(cli1, sockops);
2324 status = cli_open(cli1, fname, O_RDWR, DENY_NONE,
2326 if (!NT_STATUS_IS_OK(status)) {
2327 d_fprintf(stderr, "cli_open returned %s\n", cli_errstr(cli1));
2331 /* Ensure the child has the lock. */
2332 if (cli_lock(cli1, fnum, 0, 4, 0, WRITE_LOCK)) {
2333 d_fprintf(stderr, "Got the lock on range 0:4 - this should not happen !\n");
2336 d_printf("Child has the lock.\n");
2339 /* Tell the child to wait 5 seconds then exit. */
2340 ret = write(pipe_out[1], &c, 1);
2342 d_fprintf(stderr, "failed to send exit signal to child. %s\n",
2347 /* Wait 20 seconds for the lock. */
2348 alarm_fd = cli1->fd;
2349 CatchSignal(SIGALRM, alarm_handler_parent);
2354 if (!cli_lock(cli1, fnum, 0, 4, -1, WRITE_LOCK)) {
2355 d_fprintf(stderr, "Unable to apply write lock on range 0:4, error was "
2356 "%s\n", cli_errstr(cli1));
2361 seconds = end_timer();
2363 printf("Parent got the lock after %.2f seconds.\n",
2366 status = cli_close(cli1, fnum);
2367 if (!NT_STATUS_IS_OK(status)) {
2368 d_fprintf(stderr, "cli_close(fnum1) %s\n", cli_errstr(cli1));
2375 cli_close(cli1, fnum);
2376 torture_close_connection(cli1);
2380 printf("finished locktest9\n");
2385 test whether fnums and tids open on one VC are available on another (a major
2388 static bool run_fdpasstest(int dummy)
2390 struct cli_state *cli1, *cli2;
2391 const char *fname = "\\fdpass.tst";
2395 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2398 cli_sockopt(cli1, sockops);
2399 cli_sockopt(cli2, sockops);
2401 printf("starting fdpasstest\n");
2403 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2405 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
2406 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2410 if (cli_write(cli1, fnum1, 0, "hello world\n", 0, 13) != 13) {
2411 printf("write failed (%s)\n", cli_errstr(cli1));
2415 cli2->vuid = cli1->vuid;
2416 cli2->cnum = cli1->cnum;
2417 cli2->pid = cli1->pid;
2419 if (cli_read(cli2, fnum1, buf, 0, 13) == 13) {
2420 printf("read succeeded! nasty security hole [%s]\n",
2425 cli_close(cli1, fnum1);
2426 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2428 torture_close_connection(cli1);
2429 torture_close_connection(cli2);
2431 printf("finished fdpasstest\n");
2435 static bool run_fdsesstest(int dummy)
2437 struct cli_state *cli;
2442 const char *fname = "\\fdsess.tst";
2443 const char *fname1 = "\\fdsess1.tst";
2449 if (!torture_open_connection(&cli, 0))
2451 cli_sockopt(cli, sockops);
2453 if (!torture_cli_session_setup2(cli, &new_vuid))
2456 saved_cnum = cli->cnum;
2457 if (!NT_STATUS_IS_OK(cli_tcon_andx(cli, share, "?????", "", 1)))
2459 new_cnum = cli->cnum;
2460 cli->cnum = saved_cnum;
2462 printf("starting fdsesstest\n");
2464 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2465 cli_unlink(cli, fname1, aSYSTEM | aHIDDEN);
2467 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
2468 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2472 if (cli_write(cli, fnum1, 0, "hello world\n", 0, 13) != 13) {
2473 printf("write failed (%s)\n", cli_errstr(cli));
2477 saved_vuid = cli->vuid;
2478 cli->vuid = new_vuid;
2480 if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2481 printf("read succeeded with different vuid! nasty security hole [%s]\n",
2485 /* Try to open a file with different vuid, samba cnum. */
2486 if (NT_STATUS_IS_OK(cli_open(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum2))) {
2487 printf("create with different vuid, same cnum succeeded.\n");
2488 cli_close(cli, fnum2);
2489 cli_unlink(cli, fname1, aSYSTEM | aHIDDEN);
2491 printf("create with different vuid, same cnum failed.\n");
2492 printf("This will cause problems with service clients.\n");
2496 cli->vuid = saved_vuid;
2498 /* Try with same vuid, different cnum. */
2499 cli->cnum = new_cnum;
2501 if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2502 printf("read succeeded with different cnum![%s]\n",
2507 cli->cnum = saved_cnum;
2508 cli_close(cli, fnum1);
2509 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2511 torture_close_connection(cli);
2513 printf("finished fdsesstest\n");
2518 This test checks that
2520 1) the server does not allow an unlink on a file that is open
2522 static bool run_unlinktest(int dummy)
2524 struct cli_state *cli;
2525 const char *fname = "\\unlink.tst";
2527 bool correct = True;
2529 if (!torture_open_connection(&cli, 0)) {
2533 cli_sockopt(cli, sockops);
2535 printf("starting unlink test\n");
2537 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2541 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
2542 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2546 if (NT_STATUS_IS_OK(cli_unlink(cli, fname, aSYSTEM | aHIDDEN))) {
2547 printf("error: server allowed unlink on an open file\n");
2550 correct = check_error(__LINE__, cli, ERRDOS, ERRbadshare,
2551 NT_STATUS_SHARING_VIOLATION);
2554 cli_close(cli, fnum);
2555 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2557 if (!torture_close_connection(cli)) {
2561 printf("unlink test finished\n");
2568 test how many open files this server supports on the one socket
2570 static bool run_maxfidtest(int dummy)
2572 struct cli_state *cli;
2573 const char *ftemplate = "\\maxfid.%d.%d";
2575 uint16_t fnums[0x11000];
2578 bool correct = True;
2583 printf("failed to connect\n");
2587 cli_sockopt(cli, sockops);
2589 for (i=0; i<0x11000; i++) {
2590 slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2591 if (!NT_STATUS_IS_OK(cli_open(cli, fname,
2592 O_RDWR|O_CREAT|O_TRUNC, DENY_NONE, &fnums[i]))) {
2593 printf("open of %s failed (%s)\n",
2594 fname, cli_errstr(cli));
2595 printf("maximum fnum is %d\n", i);
2603 printf("cleaning up\n");
2605 slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2606 cli_close(cli, fnums[i]);
2607 if (!NT_STATUS_IS_OK(cli_unlink(cli, fname, aSYSTEM | aHIDDEN))) {
2608 printf("unlink of %s failed (%s)\n",
2609 fname, cli_errstr(cli));
2616 printf("maxfid test finished\n");
2617 if (!torture_close_connection(cli)) {
2623 /* generate a random buffer */
2624 static void rand_buf(char *buf, int len)
2627 *buf = (char)sys_random();
2632 /* send smb negprot commands, not reading the response */
2633 static bool run_negprot_nowait(int dummy)
2636 static struct cli_state *cli;
2637 bool correct = True;
2639 printf("starting negprot nowait test\n");
2641 if (!(cli = open_nbt_connection())) {
2645 for (i=0;i<50000;i++) {
2646 cli_negprot_sendsync(cli);
2649 if (!torture_close_connection(cli)) {
2653 printf("finished negprot nowait test\n");
2659 /* send random IPC commands */
2660 static bool run_randomipc(int dummy)
2662 char *rparam = NULL;
2664 unsigned int rdrcnt,rprcnt;
2666 int api, param_len, i;
2667 struct cli_state *cli;
2668 bool correct = True;
2671 printf("starting random ipc test\n");
2673 if (!torture_open_connection(&cli, 0)) {
2677 for (i=0;i<count;i++) {
2678 api = sys_random() % 500;
2679 param_len = (sys_random() % 64);
2681 rand_buf(param, param_len);
2686 param, param_len, 8,
2687 NULL, 0, BUFFER_SIZE,
2691 printf("%d/%d\r", i,count);
2694 printf("%d/%d\n", i, count);
2696 if (!torture_close_connection(cli)) {
2700 printf("finished random ipc test\n");
2707 static void browse_callback(const char *sname, uint32 stype,
2708 const char *comment, void *state)
2710 printf("\t%20.20s %08x %s\n", sname, stype, comment);
2716 This test checks the browse list code
2719 static bool run_browsetest(int dummy)
2721 static struct cli_state *cli;
2722 bool correct = True;
2724 printf("starting browse test\n");
2726 if (!torture_open_connection(&cli, 0)) {
2730 printf("domain list:\n");
2731 cli_NetServerEnum(cli, cli->server_domain,
2732 SV_TYPE_DOMAIN_ENUM,
2733 browse_callback, NULL);
2735 printf("machine list:\n");
2736 cli_NetServerEnum(cli, cli->server_domain,
2738 browse_callback, NULL);
2740 if (!torture_close_connection(cli)) {
2744 printf("browse test finished\n");
2752 This checks how the getatr calls works
2754 static bool run_attrtest(int dummy)
2756 struct cli_state *cli;
2759 const char *fname = "\\attrib123456789.tst";
2760 bool correct = True;
2762 printf("starting attrib test\n");
2764 if (!torture_open_connection(&cli, 0)) {
2768 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2769 cli_open(cli, fname,
2770 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
2771 cli_close(cli, fnum);
2772 if (!NT_STATUS_IS_OK(cli_getatr(cli, fname, NULL, NULL, &t))) {
2773 printf("getatr failed (%s)\n", cli_errstr(cli));
2777 if (abs(t - time(NULL)) > 60*60*24*10) {
2778 printf("ERROR: SMBgetatr bug. time is %s",
2784 t2 = t-60*60*24; /* 1 day ago */
2786 if (!NT_STATUS_IS_OK(cli_setatr(cli, fname, 0, t2))) {
2787 printf("setatr failed (%s)\n", cli_errstr(cli));
2791 if (!NT_STATUS_IS_OK(cli_getatr(cli, fname, NULL, NULL, &t))) {
2792 printf("getatr failed (%s)\n", cli_errstr(cli));
2797 printf("ERROR: getatr/setatr bug. times are\n%s",
2799 printf("%s", ctime(&t2));
2803 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2805 if (!torture_close_connection(cli)) {
2809 printf("attrib test finished\n");
2816 This checks a couple of trans2 calls
2818 static bool run_trans2test(int dummy)
2820 struct cli_state *cli;
2823 time_t c_time, a_time, m_time;
2824 struct timespec c_time_ts, a_time_ts, m_time_ts, w_time_ts, m_time2_ts;
2825 const char *fname = "\\trans2.tst";
2826 const char *dname = "\\trans2";
2827 const char *fname2 = "\\trans2\\trans2.tst";
2829 bool correct = True;
2831 printf("starting trans2 test\n");
2833 if (!torture_open_connection(&cli, 0)) {
2837 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2838 cli_open(cli, fname,
2839 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
2840 if (!cli_qfileinfo(cli, fnum, NULL, &size, &c_time_ts, &a_time_ts, &w_time_ts,
2841 &m_time_ts, NULL)) {
2842 printf("ERROR: qfileinfo failed (%s)\n", cli_errstr(cli));
2846 if (!cli_qfilename(cli, fnum, pname, sizeof(pname))) {
2847 printf("ERROR: qfilename failed (%s)\n", cli_errstr(cli));
2851 if (strcmp(pname, fname)) {
2852 printf("qfilename gave different name? [%s] [%s]\n",
2857 cli_close(cli, fnum);
2861 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2862 if (!NT_STATUS_IS_OK(cli_open(cli, fname,
2863 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum))) {
2864 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2867 cli_close(cli, fnum);
2869 if (!cli_qpathinfo(cli, fname, &c_time, &a_time, &m_time, &size, NULL)) {
2870 printf("ERROR: qpathinfo failed (%s)\n", cli_errstr(cli));
2873 if (c_time != m_time) {
2874 printf("create time=%s", ctime(&c_time));
2875 printf("modify time=%s", ctime(&m_time));
2876 printf("This system appears to have sticky create times\n");
2878 if (a_time % (60*60) == 0) {
2879 printf("access time=%s", ctime(&a_time));
2880 printf("This system appears to set a midnight access time\n");
2884 if (abs(m_time - time(NULL)) > 60*60*24*7) {
2885 printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
2891 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2892 cli_open(cli, fname,
2893 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
2894 cli_close(cli, fnum);
2895 if (!cli_qpathinfo2(cli, fname, &c_time_ts, &a_time_ts, &w_time_ts,
2896 &m_time_ts, &size, NULL, NULL)) {
2897 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2900 if (w_time_ts.tv_sec < 60*60*24*2) {
2901 printf("write time=%s", ctime(&w_time_ts.tv_sec));
2902 printf("This system appears to set a initial 0 write time\n");
2907 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2910 /* check if the server updates the directory modification time
2911 when creating a new file */
2912 if (!NT_STATUS_IS_OK(cli_mkdir(cli, dname))) {
2913 printf("ERROR: mkdir failed (%s)\n", cli_errstr(cli));
2917 if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts, &w_time_ts,
2918 &m_time_ts, &size, NULL, NULL)) {
2919 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2923 cli_open(cli, fname2,
2924 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
2925 cli_write(cli, fnum, 0, (char *)&fnum, 0, sizeof(fnum));
2926 cli_close(cli, fnum);
2927 if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts, &w_time_ts,
2928 &m_time2_ts, &size, NULL, NULL)) {
2929 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2932 if (memcmp(&m_time_ts, &m_time2_ts, sizeof(struct timespec))
2934 printf("This system does not update directory modification times\n");
2938 cli_unlink(cli, fname2, aSYSTEM | aHIDDEN);
2939 cli_rmdir(cli, dname);
2941 if (!torture_close_connection(cli)) {
2945 printf("trans2 test finished\n");
2951 This checks new W2K calls.
2954 static bool new_trans(struct cli_state *pcli, int fnum, int level)
2958 bool correct = True;
2960 if (!cli_qfileinfo_test(pcli, fnum, level, &buf, &len)) {
2961 printf("ERROR: qfileinfo (%d) failed (%s)\n", level, cli_errstr(pcli));
2964 printf("qfileinfo: level %d, len = %u\n", level, len);
2965 dump_data(0, (uint8 *)buf, len);
2972 static bool run_w2ktest(int dummy)
2974 struct cli_state *cli;
2976 const char *fname = "\\w2ktest\\w2k.tst";
2978 bool correct = True;
2980 printf("starting w2k test\n");
2982 if (!torture_open_connection(&cli, 0)) {
2986 cli_open(cli, fname,
2987 O_RDWR | O_CREAT , DENY_NONE, &fnum);
2989 for (level = 1004; level < 1040; level++) {
2990 new_trans(cli, fnum, level);
2993 cli_close(cli, fnum);
2995 if (!torture_close_connection(cli)) {
2999 printf("w2k test finished\n");
3006 this is a harness for some oplock tests
3008 static bool run_oplock1(int dummy)
3010 struct cli_state *cli1;
3011 const char *fname = "\\lockt1.lck";
3013 bool correct = True;
3015 printf("starting oplock test 1\n");
3017 if (!torture_open_connection(&cli1, 0)) {
3021 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3023 cli_sockopt(cli1, sockops);
3025 cli1->use_oplocks = True;
3027 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
3028 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3032 cli1->use_oplocks = False;
3034 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3035 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3037 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3038 printf("close2 failed (%s)\n", cli_errstr(cli1));
3042 if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
3043 printf("unlink failed (%s)\n", cli_errstr(cli1));
3047 if (!torture_close_connection(cli1)) {
3051 printf("finished oplock test 1\n");
3056 static bool run_oplock2(int dummy)
3058 struct cli_state *cli1, *cli2;
3059 const char *fname = "\\lockt2.lck";
3060 uint16_t fnum1, fnum2;
3061 int saved_use_oplocks = use_oplocks;
3063 bool correct = True;
3064 volatile bool *shared_correct;
3066 shared_correct = (volatile bool *)shm_setup(sizeof(bool));
3067 *shared_correct = True;
3069 use_level_II_oplocks = True;
3072 printf("starting oplock test 2\n");
3074 if (!torture_open_connection(&cli1, 0)) {
3075 use_level_II_oplocks = False;
3076 use_oplocks = saved_use_oplocks;
3080 cli1->use_oplocks = True;
3081 cli1->use_level_II_oplocks = True;
3083 if (!torture_open_connection(&cli2, 1)) {
3084 use_level_II_oplocks = False;
3085 use_oplocks = saved_use_oplocks;
3089 cli2->use_oplocks = True;
3090 cli2->use_level_II_oplocks = True;
3092 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3094 cli_sockopt(cli1, sockops);
3095 cli_sockopt(cli2, sockops);
3097 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
3098 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3102 /* Don't need the globals any more. */
3103 use_level_II_oplocks = False;
3104 use_oplocks = saved_use_oplocks;
3108 if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2))) {
3109 printf("second open of %s failed (%s)\n", fname, cli_errstr(cli1));
3110 *shared_correct = False;
3116 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
3117 printf("close2 failed (%s)\n", cli_errstr(cli1));
3118 *shared_correct = False;
3126 /* Ensure cli1 processes the break. Empty file should always return 0
3129 if (cli_read(cli1, fnum1, buf, 0, 4) != 0) {
3130 printf("read on fnum1 failed (%s)\n", cli_errstr(cli1));
3134 /* Should now be at level II. */
3135 /* Test if sending a write locks causes a break to none. */
3137 if (!cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK)) {
3138 printf("lock failed (%s)\n", cli_errstr(cli1));
3142 cli_unlock(cli1, fnum1, 0, 4);
3146 if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
3147 printf("lock failed (%s)\n", cli_errstr(cli1));
3151 cli_unlock(cli1, fnum1, 0, 4);
3155 cli_read(cli1, fnum1, buf, 0, 4);
3158 if (cli_write(cli1, fnum1, 0, buf, 0, 4) != 4) {
3159 printf("write on fnum1 failed (%s)\n", cli_errstr(cli1));
3164 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3165 printf("close1 failed (%s)\n", cli_errstr(cli1));
3171 if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
3172 printf("unlink failed (%s)\n", cli_errstr(cli1));
3176 if (!torture_close_connection(cli1)) {
3180 if (!*shared_correct) {
3184 printf("finished oplock test 2\n");
3189 /* handler for oplock 3 tests */
3190 static NTSTATUS oplock3_handler(struct cli_state *cli, uint16_t fnum, unsigned char level)
3192 printf("got oplock break fnum=%d level=%d\n",
3194 return cli_oplock_ack(cli, fnum, level);
3197 static bool run_oplock3(int dummy)
3199 struct cli_state *cli;
3200 const char *fname = "\\oplockt3.dat";
3202 char buf[4] = "abcd";
3203 bool correct = True;
3204 volatile bool *shared_correct;
3206 shared_correct = (volatile bool *)shm_setup(sizeof(bool));
3207 *shared_correct = True;
3209 printf("starting oplock test 3\n");
3214 use_level_II_oplocks = True;
3215 if (!torture_open_connection(&cli, 0)) {
3216 *shared_correct = False;
3220 /* try to trigger a oplock break in parent */
3221 cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum);
3222 cli_write(cli, fnum, 0, buf, 0, 4);
3228 use_level_II_oplocks = True;
3229 if (!torture_open_connection(&cli, 1)) { /* other is forked */
3232 cli_oplock_handler(cli, oplock3_handler);
3233 cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum);
3234 cli_write(cli, fnum, 0, buf, 0, 4);
3235 cli_close(cli, fnum);
3236 cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum);
3237 cli->timeout = 20000;
3238 cli_receive_smb(cli);
3239 printf("finished oplock test 3\n");
3241 return (correct && *shared_correct);
3243 /* What are we looking for here? What's sucess and what's FAILURE? */
3249 Test delete on close semantics.
3251 static bool run_deletetest(int dummy)
3253 struct cli_state *cli1 = NULL;
3254 struct cli_state *cli2 = NULL;
3255 const char *fname = "\\delete.file";
3256 uint16_t fnum1 = (uint16_t)-1;
3257 uint16_t fnum2 = (uint16_t)-1;
3258 bool correct = True;
3260 printf("starting delete test\n");
3262 if (!torture_open_connection(&cli1, 0)) {
3266 cli_sockopt(cli1, sockops);
3268 /* Test 1 - this should delete the file on close. */
3270 cli_setatr(cli1, fname, 0, 0);
3271 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3273 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
3274 0, FILE_OVERWRITE_IF,
3275 FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
3276 printf("[1] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3283 uint32 *accinfo = NULL;
3285 cli_qfileinfo_test(cli1, fnum1, SMB_FILE_ACCESS_INFORMATION, (char **)&accinfo, &len);
3287 printf("access mode = 0x%lx\n", *accinfo);
3292 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3293 printf("[1] close failed (%s)\n", cli_errstr(cli1));
3298 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1))) {
3299 printf("[1] open of %s succeeded (should fail)\n", fname);
3304 printf("first delete on close test succeeded.\n");
3306 /* Test 2 - this should delete the file on close. */
3308 cli_setatr(cli1, fname, 0, 0);
3309 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3311 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
3312 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
3313 FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3314 printf("[2] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3319 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3320 printf("[2] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3325 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3326 printf("[2] close failed (%s)\n", cli_errstr(cli1));
3331 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3332 printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
3333 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3334 printf("[2] close failed (%s)\n", cli_errstr(cli1));
3338 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3340 printf("second delete on close test succeeded.\n");
3343 cli_setatr(cli1, fname, 0, 0);
3344 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3346 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
3347 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3348 printf("[3] open - 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3353 /* This should fail with a sharing violation - open for delete is only compatible
3354 with SHARE_DELETE. */
3356 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3357 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0, 0, &fnum2))) {
3358 printf("[3] open - 2 of %s succeeded - should have failed.\n", fname);
3363 /* This should succeed. */
3365 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3366 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0, &fnum2))) {
3367 printf("[3] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3372 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3373 printf("[3] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3378 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3379 printf("[3] close 1 failed (%s)\n", cli_errstr(cli1));
3384 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
3385 printf("[3] close 2 failed (%s)\n", cli_errstr(cli1));
3390 /* This should fail - file should no longer be there. */
3392 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3393 printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
3394 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3395 printf("[3] close failed (%s)\n", cli_errstr(cli1));
3397 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3401 printf("third delete on close test succeeded.\n");
3404 cli_setatr(cli1, fname, 0, 0);
3405 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3407 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3408 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3409 printf("[4] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3414 /* This should succeed. */
3415 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
3416 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0, &fnum2))) {
3417 printf("[4] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3422 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
3423 printf("[4] close - 1 failed (%s)\n", cli_errstr(cli1));
3428 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3429 printf("[4] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3434 /* This should fail - no more opens once delete on close set. */
3435 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
3436 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3437 FILE_OPEN, 0, 0, &fnum2))) {
3438 printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname );
3442 printf("fourth delete on close test succeeded.\n");
3444 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3445 printf("[4] close - 2 failed (%s)\n", cli_errstr(cli1));
3451 cli_setatr(cli1, fname, 0, 0);
3452 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3454 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum1))) {
3455 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3460 /* This should fail - only allowed on NT opens with DELETE access. */
3462 if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3463 printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
3468 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3469 printf("[5] close - 2 failed (%s)\n", cli_errstr(cli1));
3474 printf("fifth delete on close test succeeded.\n");
3477 cli_setatr(cli1, fname, 0, 0);
3478 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3480 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
3481 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3482 FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3483 printf("[6] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3488 /* This should fail - only allowed on NT opens with DELETE access. */
3490 if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3491 printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
3496 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3497 printf("[6] close - 2 failed (%s)\n", cli_errstr(cli1));
3502 printf("sixth delete on close test succeeded.\n");
3505 cli_setatr(cli1, fname, 0, 0);
3506 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3508 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3509 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3510 printf("[7] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3515 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3516 printf("[7] setting delete_on_close on file failed !\n");
3521 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, false))) {
3522 printf("[7] unsetting delete_on_close on file failed !\n");
3527 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3528 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3533 /* This next open should succeed - we reset the flag. */
3535 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3536 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3541 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3542 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3547 printf("seventh delete on close test succeeded.\n");
3550 cli_setatr(cli1, fname, 0, 0);
3551 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3553 if (!torture_open_connection(&cli2, 1)) {
3554 printf("[8] failed to open second connection.\n");
3559 cli_sockopt(cli1, sockops);
3561 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3562 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3563 FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3564 printf("[8] open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3569 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3570 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3571 FILE_OPEN, 0, 0, &fnum2))) {
3572 printf("[8] open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3577 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3578 printf("[8] setting delete_on_close on file failed !\n");
3583 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3584 printf("[8] close - 1 failed (%s)\n", cli_errstr(cli1));
3589 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
3590 printf("[8] close - 2 failed (%s)\n", cli_errstr(cli2));
3595 /* This should fail.. */
3596 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3597 printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
3601 printf("eighth delete on close test succeeded.\n");
3603 /* This should fail - we need to set DELETE_ACCESS. */
3604 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,FILE_READ_DATA|FILE_WRITE_DATA,
3605 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
3606 printf("[9] open of %s succeeded should have failed!\n", fname);
3611 printf("ninth delete on close test succeeded.\n");
3613 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3614 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
3615 printf("[10] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3620 /* This should delete the file. */
3621 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3622 printf("[10] close failed (%s)\n", cli_errstr(cli1));
3627 /* This should fail.. */
3628 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3629 printf("[10] open of %s succeeded should have been deleted on close !\n", fname);
3633 printf("tenth delete on close test succeeded.\n");
3635 cli_setatr(cli1, fname, 0, 0);
3636 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3638 /* What error do we get when attempting to open a read-only file with
3641 /* Create a readonly file. */
3642 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
3643 FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3644 printf("[11] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3649 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3650 printf("[11] close failed (%s)\n", cli_errstr(cli1));
3655 /* Now try open for delete access. */
3656 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES|DELETE_ACCESS,
3657 0, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3658 FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3659 printf("[11] open of %s succeeded should have been denied with ACCESS_DENIED!\n", fname);
3660 cli_close(cli1, fnum1);
3664 NTSTATUS nterr = cli_nt_error(cli1);
3665 if (!NT_STATUS_EQUAL(nterr,NT_STATUS_ACCESS_DENIED)) {
3666 printf("[11] open of %s should have been denied with ACCESS_DENIED! Got error %s\n", fname, nt_errstr(nterr));
3670 printf("eleventh delete on close test succeeded.\n");
3674 printf("finished delete test\n");
3677 /* FIXME: This will crash if we aborted before cli2 got
3678 * intialized, because these functions don't handle
3679 * uninitialized connections. */
3681 if (fnum1 != (uint16_t)-1) cli_close(cli1, fnum1);
3682 if (fnum2 != (uint16_t)-1) cli_close(cli1, fnum2);
3683 cli_setatr(cli1, fname, 0, 0);
3684 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3686 if (cli1 && !torture_close_connection(cli1)) {
3689 if (cli2 && !torture_close_connection(cli2)) {
3697 print out server properties
3699 static bool run_properties(int dummy)
3701 struct cli_state *cli;
3702 bool correct = True;
3704 printf("starting properties test\n");
3708 if (!torture_open_connection(&cli, 0)) {
3712 cli_sockopt(cli, sockops);
3714 d_printf("Capabilities 0x%08x\n", cli->capabilities);
3716 if (!torture_close_connection(cli)) {
3725 /* FIRST_DESIRED_ACCESS 0xf019f */
3726 #define FIRST_DESIRED_ACCESS FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\
3727 FILE_READ_EA| /* 0xf */ \
3728 FILE_WRITE_EA|FILE_READ_ATTRIBUTES| /* 0x90 */ \
3729 FILE_WRITE_ATTRIBUTES| /* 0x100 */ \
3730 DELETE_ACCESS|READ_CONTROL_ACCESS|\
3731 WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS /* 0xf0000 */
3732 /* SECOND_DESIRED_ACCESS 0xe0080 */
3733 #define SECOND_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
3734 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
3735 WRITE_OWNER_ACCESS /* 0xe0000 */
3738 #define THIRD_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
3739 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
3741 WRITE_OWNER_ACCESS /* */
3745 Test ntcreate calls made by xcopy
3747 static bool run_xcopy(int dummy)
3749 static struct cli_state *cli1;
3750 const char *fname = "\\test.txt";
3751 bool correct = True;
3752 uint16_t fnum1, fnum2;
3754 printf("starting xcopy test\n");
3756 if (!torture_open_connection(&cli1, 0)) {
3760 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,
3761 FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
3762 FILE_SHARE_NONE, FILE_OVERWRITE_IF,
3763 0x4044, 0, &fnum1))) {
3764 printf("First open failed - %s\n", cli_errstr(cli1));
3768 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,
3769 SECOND_DESIRED_ACCESS, 0,
3770 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN,
3771 0x200000, 0, &fnum2))) {
3772 printf("second open failed - %s\n", cli_errstr(cli1));
3776 if (!torture_close_connection(cli1)) {
3784 Test rename on files open with share delete and no share delete.
3786 static bool run_rename(int dummy)
3788 static struct cli_state *cli1;
3789 const char *fname = "\\test.txt";
3790 const char *fname1 = "\\test1.txt";
3791 bool correct = True;
3795 printf("starting rename test\n");
3797 if (!torture_open_connection(&cli1, 0)) {
3801 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3802 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
3803 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3804 FILE_SHARE_READ, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3805 printf("First open failed - %s\n", cli_errstr(cli1));
3809 if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
3810 printf("First rename failed (SHARE_READ) (this is correct) - %s\n", cli_errstr(cli1));
3812 printf("First rename succeeded (SHARE_READ) - this should have failed !\n");
3816 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3817 printf("close - 1 failed (%s)\n", cli_errstr(cli1));
3821 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3822 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
3823 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3825 FILE_SHARE_DELETE|FILE_SHARE_NONE,
3827 FILE_SHARE_DELETE|FILE_SHARE_READ,
3829 FILE_OVERWRITE_IF, 0, 0, &fnum1);
3830 if (!NT_STATUS_IS_OK(status)) {
3831 printf("Second open failed - %s\n", cli_errstr(cli1));
3835 if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
3836 printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", cli_errstr(cli1));
3839 printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n");
3842 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3843 printf("close - 2 failed (%s)\n", cli_errstr(cli1));
3847 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3848 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
3850 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, READ_CONTROL_ACCESS, FILE_ATTRIBUTE_NORMAL,
3851 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3852 printf("Third open failed - %s\n", cli_errstr(cli1));
3861 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
3862 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
3863 printf("Fourth open failed - %s\n", cli_errstr(cli1));
3866 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum2, true))) {
3867 printf("[8] setting delete_on_close on file failed !\n");
3871 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
3872 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
3878 if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
3879 printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", cli_errstr(cli1));
3882 printf("Third rename succeeded (SHARE_NONE)\n");
3885 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3886 printf("close - 3 failed (%s)\n", cli_errstr(cli1));
3890 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3891 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
3895 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3896 FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3897 printf("Fourth open failed - %s\n", cli_errstr(cli1));
3901 if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
3902 printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", cli_errstr(cli1));
3904 printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n");
3908 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3909 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
3913 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3914 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
3918 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3919 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3920 printf("Fifth open failed - %s\n", cli_errstr(cli1));
3924 if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
3925 printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n",
3929 printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", cli_errstr(cli1));
3933 * Now check if the first name still exists ...
3936 /* if (!NT_STATUS_OP(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3937 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
3938 printf("Opening original file after rename of open file fails: %s\n",
3942 printf("Opening original file after rename of open file works ...\n");
3943 (void)cli_close(cli1, fnum2);
3949 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3950 printf("close - 5 failed (%s)\n", cli_errstr(cli1));
3954 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3955 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
3957 if (!torture_close_connection(cli1)) {
3964 static bool run_pipe_number(int dummy)
3966 struct cli_state *cli1;
3967 const char *pipe_name = "\\SPOOLSS";
3971 printf("starting pipenumber test\n");
3972 if (!torture_open_connection(&cli1, 0)) {
3976 cli_sockopt(cli1, sockops);
3978 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, pipe_name, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
3979 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF, 0, 0, &fnum))) {
3980 printf("Open of pipe %s failed with error (%s)\n", pipe_name, cli_errstr(cli1));
3984 printf("\r%6d", num_pipes);
3987 printf("pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
3988 torture_close_connection(cli1);
3993 Test open mode returns on read-only files.
3995 static bool run_opentest(int dummy)
3997 static struct cli_state *cli1;
3998 static struct cli_state *cli2;
3999 const char *fname = "\\readonly.file";
4000 uint16_t fnum1, fnum2;
4003 bool correct = True;
4006 printf("starting open test\n");
4008 if (!torture_open_connection(&cli1, 0)) {
4012 cli_setatr(cli1, fname, 0, 0);
4013 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4015 cli_sockopt(cli1, sockops);
4017 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
4018 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
4022 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4023 printf("close2 failed (%s)\n", cli_errstr(cli1));
4027 if (!NT_STATUS_IS_OK(cli_setatr(cli1, fname, aRONLY, 0))) {
4028 printf("cli_setatr failed (%s)\n", cli_errstr(cli1));
4032 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1))) {
4033 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
4037 /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
4038 cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
4040 if (check_error(__LINE__, cli1, ERRDOS, ERRnoaccess,
4041 NT_STATUS_ACCESS_DENIED)) {
4042 printf("correct error code ERRDOS/ERRnoaccess returned\n");
4045 printf("finished open test 1\n");
4047 cli_close(cli1, fnum1);
4049 /* Now try not readonly and ensure ERRbadshare is returned. */
4051 cli_setatr(cli1, fname, 0, 0);
4053 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1))) {
4054 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
4058 /* This will fail - but the error should be ERRshare. */
4059 cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
4061 if (check_error(__LINE__, cli1, ERRDOS, ERRbadshare,
4062 NT_STATUS_SHARING_VIOLATION)) {
4063 printf("correct error code ERRDOS/ERRbadshare returned\n");
4066 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4067 printf("close2 failed (%s)\n", cli_errstr(cli1));
4071 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4073 printf("finished open test 2\n");
4075 /* Test truncate open disposition on file opened for read. */
4077 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
4078 printf("(3) open (1) of %s failed (%s)\n", fname, cli_errstr(cli1));
4082 /* write 20 bytes. */
4084 memset(buf, '\0', 20);
4086 if (cli_write(cli1, fnum1, 0, buf, 0, 20) != 20) {
4087 printf("write failed (%s)\n", cli_errstr(cli1));
4091 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4092 printf("(3) close1 failed (%s)\n", cli_errstr(cli1));
4096 /* Ensure size == 20. */
4097 if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname, NULL, &fsize, NULL))) {
4098 printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
4103 printf("(3) file size != 20\n");
4107 /* Now test if we can truncate a file opened for readonly. */
4109 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE, &fnum1))) {
4110 printf("(3) open (2) of %s failed (%s)\n", fname, cli_errstr(cli1));
4114 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4115 printf("close2 failed (%s)\n", cli_errstr(cli1));
4119 /* Ensure size == 0. */
4120 if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname, NULL, &fsize, NULL))) {
4121 printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
4126 printf("(3) file size != 0\n");
4129 printf("finished open test 3\n");
4131 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4134 printf("testing ctemp\n");
4135 if (!NT_STATUS_IS_OK(cli_ctemp(cli1, talloc_tos(), "\\", &fnum1, &tmp_path))) {
4136 printf("ctemp failed (%s)\n", cli_errstr(cli1));
4139 printf("ctemp gave path %s\n", tmp_path);
4140 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4141 printf("close of temp failed (%s)\n", cli_errstr(cli1));
4143 if (!NT_STATUS_IS_OK(cli_unlink(cli1, tmp_path, aSYSTEM | aHIDDEN))) {
4144 printf("unlink of temp failed (%s)\n", cli_errstr(cli1));
4147 /* Test the non-io opens... */
4149 if (!torture_open_connection(&cli2, 1)) {
4153 cli_setatr(cli2, fname, 0, 0);
4154 cli_unlink(cli2, fname, aSYSTEM | aHIDDEN);
4156 cli_sockopt(cli2, sockops);
4158 printf("TEST #1 testing 2 non-io opens (no delete)\n");
4160 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4161 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4162 printf("test 1 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4166 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4167 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4168 printf("test 1 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4172 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4173 printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4176 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
4177 printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4181 printf("non-io open test #1 passed.\n");
4183 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4185 printf("TEST #2 testing 2 non-io opens (first with delete)\n");
4187 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4188 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4189 printf("test 2 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4193 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4194 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4195 printf("test 2 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4199 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4200 printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4203 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
4204 printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
4208 printf("non-io open test #2 passed.\n");
4210 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4212 printf("TEST #3 testing 2 non-io opens (second with delete)\n");
4214 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4215 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4216 printf("test 3 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4220 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4221 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4222 printf("test 3 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4226 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4227 printf("test 3 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4230 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
4231 printf("test 3 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4235 printf("non-io open test #3 passed.\n");
4237 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4239 printf("TEST #4 testing 2 non-io opens (both with delete)\n");
4241 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4242 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4243 printf("test 4 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4247 if (NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4248 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4249 printf("test 4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
4253 printf("test 3 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
4255 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4256 printf("test 4 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4260 printf("non-io open test #4 passed.\n");
4262 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4264 printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
4266 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4267 FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4268 printf("test 5 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4272 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4273 FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4274 printf("test 5 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4278 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4279 printf("test 5 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4283 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
4284 printf("test 5 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4288 printf("non-io open test #5 passed.\n");
4290 printf("TEST #6 testing 1 non-io open, one io open\n");
4292 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4294 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
4295 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4296 printf("test 6 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4300 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4301 FILE_SHARE_READ, FILE_OPEN_IF, 0, 0, &fnum2))) {
4302 printf("test 6 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4306 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4307 printf("test 6 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4311 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
4312 printf("test 6 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4316 printf("non-io open test #6 passed.\n");
4318 printf("TEST #7 testing 1 non-io open, one io open with delete\n");
4320 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4322 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
4323 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4324 printf("test 7 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4328 if (NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4329 FILE_SHARE_READ|FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4330 printf("test 7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
4334 printf("test 7 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
4336 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4337 printf("test 7 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4341 printf("non-io open test #7 passed.\n");
4343 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4345 if (!torture_close_connection(cli1)) {
4348 if (!torture_close_connection(cli2)) {
4356 Test POSIX open /mkdir calls.
4358 static bool run_simple_posix_open_test(int dummy)
4360 static struct cli_state *cli1;
4361 const char *fname = "posix:file";
4362 const char *hname = "posix:hlink";
4363 const char *sname = "posix:symlink";
4364 const char *dname = "posix:dir";
4367 uint16 major, minor;
4368 uint32 caplow, caphigh;
4369 uint16_t fnum1 = (uint16_t)-1;
4370 SMB_STRUCT_STAT sbuf;
4371 bool correct = false;
4374 printf("Starting simple POSIX open test\n");
4376 if (!torture_open_connection(&cli1, 0)) {
4380 cli_sockopt(cli1, sockops);
4382 if (!SERVER_HAS_UNIX_CIFS(cli1)) {
4383 printf("Server doesn't support UNIX CIFS extensions.\n");
4387 status = cli_unix_extensions_version(cli1, &major, &minor, &caplow,
4389 if (!NT_STATUS_IS_OK(status)) {
4390 printf("Server didn't return UNIX CIFS extensions: %s\n",
4395 status = cli_set_unix_extensions_capabilities(cli1, major, minor,
4397 if (!NT_STATUS_IS_OK(status)) {
4398 printf("Server doesn't support setting UNIX CIFS extensions: "
4399 "%s.\n", nt_errstr(status));
4403 cli_setatr(cli1, fname, 0, 0);
4404 cli_posix_unlink(cli1, fname);
4405 cli_setatr(cli1, dname, 0, 0);
4406 cli_posix_rmdir(cli1, dname);
4407 cli_setatr(cli1, hname, 0, 0);
4408 cli_posix_unlink(cli1, hname);
4409 cli_setatr(cli1, sname, 0, 0);
4410 cli_posix_unlink(cli1, sname);
4412 /* Create a directory. */
4413 if (!NT_STATUS_IS_OK(cli_posix_mkdir(cli1, dname, 0777))) {
4414 printf("POSIX mkdir of %s failed (%s)\n", dname, cli_errstr(cli1));
4418 if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1))) {
4419 printf("POSIX create of %s failed (%s)\n", fname, cli_errstr(cli1));
4423 /* Test ftruncate - set file size. */
4424 if (!NT_STATUS_IS_OK(cli_ftruncate(cli1, fnum1, 1000))) {
4425 printf("ftruncate failed (%s)\n", cli_errstr(cli1));
4429 /* Ensure st_size == 1000 */
4430 if (!NT_STATUS_IS_OK(cli_posix_stat(cli1, fname, &sbuf))) {
4431 printf("stat failed (%s)\n", cli_errstr(cli1));
4435 if (sbuf.st_ex_size != 1000) {
4436 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
4440 /* Test ftruncate - set file size back to zero. */
4441 if (!NT_STATUS_IS_OK(cli_ftruncate(cli1, fnum1, 0))) {
4442 printf("ftruncate failed (%s)\n", cli_errstr(cli1));
4446 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4447 printf("close failed (%s)\n", cli_errstr(cli1));
4451 /* Now open the file again for read only. */
4452 if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1))) {
4453 printf("POSIX open of %s failed (%s)\n", fname, cli_errstr(cli1));
4457 /* Now unlink while open. */
4458 if (!NT_STATUS_IS_OK(cli_posix_unlink(cli1, fname))) {
4459 printf("POSIX unlink of %s failed (%s)\n", fname, cli_errstr(cli1));
4463 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4464 printf("close(2) failed (%s)\n", cli_errstr(cli1));
4468 /* Ensure the file has gone. */
4469 if (NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1))) {
4470 printf("POSIX open of %s succeeded, should have been deleted.\n", fname);
4474 /* What happens when we try and POSIX open a directory ? */
4475 if (NT_STATUS_IS_OK(cli_posix_open(cli1, dname, O_RDONLY, 0, &fnum1))) {
4476 printf("POSIX open of directory %s succeeded, should have failed.\n", fname);
4479 if (!check_error(__LINE__, cli1, ERRDOS, EISDIR,
4480 NT_STATUS_FILE_IS_A_DIRECTORY)) {
4485 /* Create the file. */
4486 if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1))) {
4487 printf("POSIX create of %s failed (%s)\n", fname, cli_errstr(cli1));
4491 /* Write some data into it. */
4492 if (cli_write(cli1, fnum1, 0, "TEST DATA\n", 0, 10) != 10) {
4493 printf("cli_write failed: %s\n", cli_errstr(cli1));
4497 cli_close(cli1, fnum1);
4499 /* Now create a hardlink. */
4500 if (!NT_STATUS_IS_OK(cli_posix_hardlink(cli1, fname, hname))) {
4501 printf("POSIX hardlink of %s failed (%s)\n", hname, cli_errstr(cli1));
4505 /* Now create a symlink. */
4506 if (!NT_STATUS_IS_OK(cli_posix_symlink(cli1, fname, sname))) {
4507 printf("POSIX symlink of %s failed (%s)\n", sname, cli_errstr(cli1));
4511 /* Open the hardlink for read. */
4512 if (!NT_STATUS_IS_OK(cli_posix_open(cli1, hname, O_RDONLY, 0, &fnum1))) {
4513 printf("POSIX open of %s failed (%s)\n", hname, cli_errstr(cli1));
4517 if (cli_read(cli1, fnum1, buf, 0, 10) != 10) {
4518 printf("POSIX read of %s failed (%s)\n", hname, cli_errstr(cli1));
4522 if (memcmp(buf, "TEST DATA\n", 10)) {
4523 printf("invalid data read from hardlink\n");
4527 /* Do a POSIX lock/unlock. */
4528 if (!NT_STATUS_IS_OK(cli_posix_lock(cli1, fnum1, 0, 100, true, READ_LOCK))) {
4529 printf("POSIX lock failed %s\n", cli_errstr(cli1));
4533 /* Punch a hole in the locked area. */
4534 if (!NT_STATUS_IS_OK(cli_posix_unlock(cli1, fnum1, 10, 80))) {
4535 printf("POSIX unlock failed %s\n", cli_errstr(cli1));
4539 cli_close(cli1, fnum1);
4541 /* Open the symlink for read - this should fail. A POSIX
4542 client should not be doing opens on a symlink. */
4543 if (NT_STATUS_IS_OK(cli_posix_open(cli1, sname, O_RDONLY, 0, &fnum1))) {
4544 printf("POSIX open of %s succeeded (should have failed)\n", sname);
4547 if (!check_error(__LINE__, cli1, ERRDOS, ERRbadpath,
4548 NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
4549 printf("POSIX open of %s should have failed "
4550 "with NT_STATUS_OBJECT_PATH_NOT_FOUND, "
4551 "failed with %s instead.\n",
4552 sname, cli_errstr(cli1));
4557 if (!NT_STATUS_IS_OK(cli_posix_readlink(cli1, sname, namebuf, sizeof(namebuf)))) {
4558 printf("POSIX readlink on %s failed (%s)\n", sname, cli_errstr(cli1));
4562 if (strcmp(namebuf, fname) != 0) {
4563 printf("POSIX readlink on %s failed to match name %s (read %s)\n",
4564 sname, fname, namebuf);
4568 if (!NT_STATUS_IS_OK(cli_posix_rmdir(cli1, dname))) {
4569 printf("POSIX rmdir failed (%s)\n", cli_errstr(cli1));
4573 printf("Simple POSIX open test passed\n");
4578 if (fnum1 != (uint16_t)-1) {
4579 cli_close(cli1, fnum1);
4580 fnum1 = (uint16_t)-1;
4583 cli_setatr(cli1, sname, 0, 0);
4584 cli_posix_unlink(cli1, sname);
4585 cli_setatr(cli1, hname, 0, 0);
4586 cli_posix_unlink(cli1, hname);
4587 cli_setatr(cli1, fname, 0, 0);
4588 cli_posix_unlink(cli1, fname);
4589 cli_setatr(cli1, dname, 0, 0);
4590 cli_posix_rmdir(cli1, dname);
4592 if (!torture_close_connection(cli1)) {
4600 static uint32 open_attrs_table[] = {
4601 FILE_ATTRIBUTE_NORMAL,
4602 FILE_ATTRIBUTE_ARCHIVE,
4603 FILE_ATTRIBUTE_READONLY,
4604 FILE_ATTRIBUTE_HIDDEN,
4605 FILE_ATTRIBUTE_SYSTEM,
4607 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY,
4608 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN,
4609 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,
4610 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
4611 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
4612 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
4614 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
4615 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
4616 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
4617 FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM,
4620 struct trunc_open_results {
4627 static struct trunc_open_results attr_results[] = {
4628 { 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
4629 { 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
4630 { 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
4631 { 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
4632 { 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
4633 { 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
4634 { 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4635 { 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4636 { 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
4637 { 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4638 { 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4639 { 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
4640 { 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4641 { 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4642 { 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 },
4643 { 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4644 { 119, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4645 { 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 },
4646 { 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 },
4647 { 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 },
4648 { 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4649 { 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4650 { 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
4651 { 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4652 { 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4653 { 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
4656 static bool run_openattrtest(int dummy)
4658 static struct cli_state *cli1;
4659 const char *fname = "\\openattr.file";
4661 bool correct = True;
4663 unsigned int i, j, k, l;
4665 printf("starting open attr test\n");
4667 if (!torture_open_connection(&cli1, 0)) {
4671 cli_sockopt(cli1, sockops);
4673 for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32); i++) {
4674 cli_setatr(cli1, fname, 0, 0);
4675 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4676 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA, open_attrs_table[i],
4677 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4678 printf("open %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
4682 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4683 printf("close %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
4687 for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32); j++) {
4688 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA, open_attrs_table[j],
4689 FILE_SHARE_NONE, FILE_OVERWRITE, 0, 0, &fnum1))) {
4690 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
4691 if (attr_results[l].num == k) {
4692 printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
4693 k, open_attrs_table[i],
4694 open_attrs_table[j],
4695 fname, NT_STATUS_V(cli_nt_error(cli1)), cli_errstr(cli1));
4699 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_ACCESS_DENIED)) {
4700 printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n",
4701 k, open_attrs_table[i], open_attrs_table[j],
4706 printf("[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]);
4712 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4713 printf("close %d (2) of %s failed (%s)\n", j, fname, cli_errstr(cli1));
4717 if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname, &attr, NULL, NULL))) {
4718 printf("getatr(2) failed (%s)\n", cli_errstr(cli1));
4723 printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
4724 k, open_attrs_table[i], open_attrs_table[j], attr );
4727 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
4728 if (attr_results[l].num == k) {
4729 if (attr != attr_results[l].result_attr ||
4730 open_attrs_table[i] != attr_results[l].init_attr ||
4731 open_attrs_table[j] != attr_results[l].trunc_attr) {
4732 printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
4733 open_attrs_table[i],
4734 open_attrs_table[j],
4736 attr_results[l].result_attr);
4746 cli_setatr(cli1, fname, 0, 0);
4747 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4749 printf("open attr test %s.\n", correct ? "passed" : "failed");
4751 if (!torture_close_connection(cli1)) {
4757 static void list_fn(const char *mnt, file_info *finfo, const char *name, void *state)
4763 test directory listing speed
4765 static bool run_dirtest(int dummy)
4768 static struct cli_state *cli;
4771 bool correct = True;
4773 printf("starting directory test\n");
4775 if (!torture_open_connection(&cli, 0)) {
4779 cli_sockopt(cli, sockops);
4782 for (i=0;i<torture_numops;i++) {
4784 slprintf(fname, sizeof(fname), "\\%x", (int)random());
4785 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum))) {
4786 fprintf(stderr,"Failed to open %s\n", fname);
4789 cli_close(cli, fnum);
4794 printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
4795 printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
4796 printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
4798 printf("dirtest core %g seconds\n", end_timer() - t1);
4801 for (i=0;i<torture_numops;i++) {
4803 slprintf(fname, sizeof(fname), "\\%x", (int)random());
4804 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
4807 if (!torture_close_connection(cli)) {
4811 printf("finished dirtest\n");
4816 static void del_fn(const char *mnt, file_info *finfo, const char *mask, void *state)
4818 struct cli_state *pcli = (struct cli_state *)state;
4820 slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name);
4822 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
4825 if (finfo->mode & aDIR) {
4826 if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname)))
4827 printf("del_fn: failed to rmdir %s\n,", fname );
4829 if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, aSYSTEM | aHIDDEN)))
4830 printf("del_fn: failed to unlink %s\n,", fname );
4836 sees what IOCTLs are supported
4838 bool torture_ioctl_test(int dummy)
4840 static struct cli_state *cli;
4841 uint16_t device, function;
4843 const char *fname = "\\ioctl.dat";
4847 if (!torture_open_connection(&cli, 0)) {
4851 printf("starting ioctl test\n");
4853 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
4855 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
4856 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
4860 status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob);
4861 printf("ioctl device info: %s\n", cli_errstr(cli));
4863 status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob);
4864 printf("ioctl job info: %s\n", cli_errstr(cli));
4866 for (device=0;device<0x100;device++) {
4867 printf("testing device=0x%x\n", device);
4868 for (function=0;function<0x100;function++) {
4869 uint32 code = (device<<16) | function;
4871 status = cli_raw_ioctl(cli, fnum, code, &blob);
4873 if (NT_STATUS_IS_OK(status)) {
4874 printf("ioctl 0x%x OK : %d bytes\n", (int)code,
4876 data_blob_free(&blob);
4881 if (!torture_close_connection(cli)) {
4890 tries varients of chkpath
4892 bool torture_chkpath_test(int dummy)
4894 static struct cli_state *cli;
4898 if (!torture_open_connection(&cli, 0)) {
4902 printf("starting chkpath test\n");
4904 /* cleanup from an old run */
4905 cli_rmdir(cli, "\\chkpath.dir\\dir2");
4906 cli_unlink(cli, "\\chkpath.dir\\*", aSYSTEM | aHIDDEN);
4907 cli_rmdir(cli, "\\chkpath.dir");
4909 if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\chkpath.dir"))) {
4910 printf("mkdir1 failed : %s\n", cli_errstr(cli));
4914 if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\chkpath.dir\\dir2"))) {
4915 printf("mkdir2 failed : %s\n", cli_errstr(cli));
4919 if (!NT_STATUS_IS_OK(cli_open(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
4920 printf("open1 failed (%s)\n", cli_errstr(cli));
4923 cli_close(cli, fnum);
4925 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir"))) {
4926 printf("chkpath1 failed: %s\n", cli_errstr(cli));
4930 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\dir2"))) {
4931 printf("chkpath2 failed: %s\n", cli_errstr(cli));
4935 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\foo.txt"))) {
4936 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
4937 NT_STATUS_NOT_A_DIRECTORY);
4939 printf("* chkpath on a file should fail\n");
4943 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\bar.txt"))) {
4944 ret = check_error(__LINE__, cli, ERRDOS, ERRbadfile,
4945 NT_STATUS_OBJECT_NAME_NOT_FOUND);
4947 printf("* chkpath on a non existant file should fail\n");
4951 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt"))) {
4952 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
4953 NT_STATUS_OBJECT_PATH_NOT_FOUND);
4955 printf("* chkpath on a non existent component should fail\n");
4959 cli_rmdir(cli, "\\chkpath.dir\\dir2");
4960 cli_unlink(cli, "\\chkpath.dir\\*", aSYSTEM | aHIDDEN);
4961 cli_rmdir(cli, "\\chkpath.dir");
4963 if (!torture_close_connection(cli)) {
4970 static bool run_eatest(int dummy)
4972 static struct cli_state *cli;
4973 const char *fname = "\\eatest.txt";
4974 bool correct = True;
4978 struct ea_struct *ea_list = NULL;
4979 TALLOC_CTX *mem_ctx = talloc_init("eatest");
4981 printf("starting eatest\n");
4983 if (!torture_open_connection(&cli, 0)) {
4984 talloc_destroy(mem_ctx);
4988 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
4989 if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0,
4990 FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
4991 FILE_SHARE_NONE, FILE_OVERWRITE_IF,
4992 0x4044, 0, &fnum))) {
4993 printf("open failed - %s\n", cli_errstr(cli));
4994 talloc_destroy(mem_ctx);
4998 for (i = 0; i < 10; i++) {
4999 fstring ea_name, ea_val;
5001 slprintf(ea_name, sizeof(ea_name), "EA_%d", i);
5002 memset(ea_val, (char)i+1, i+1);
5003 if (!cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1)) {
5004 printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
5005 talloc_destroy(mem_ctx);
5010 cli_close(cli, fnum);
5011 for (i = 0; i < 10; i++) {
5012 fstring ea_name, ea_val;
5014 slprintf(ea_name, sizeof(ea_name), "EA_%d", i+10);
5015 memset(ea_val, (char)i+1, i+1);
5016 if (!cli_set_ea_path(cli, fname, ea_name, ea_val, i+1)) {
5017 printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
5018 talloc_destroy(mem_ctx);
5023 if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list)) {
5024 printf("ea_get list failed - %s\n", cli_errstr(cli));
5028 printf("num_eas = %d\n", (int)num_eas);
5030 if (num_eas != 20) {
5031 printf("Should be 20 EA's stored... failing.\n");
5035 for (i = 0; i < num_eas; i++) {
5036 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
5037 dump_data(0, ea_list[i].value.data,
5038 ea_list[i].value.length);
5041 /* Setting EA's to zero length deletes them. Test this */
5042 printf("Now deleting all EA's - case indepenent....\n");
5045 cli_set_ea_path(cli, fname, "", "", 0);
5047 for (i = 0; i < 20; i++) {
5049 slprintf(ea_name, sizeof(ea_name), "ea_%d", i);
5050 if (!cli_set_ea_path(cli, fname, ea_name, "", 0)) {
5051 printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
5052 talloc_destroy(mem_ctx);
5058 if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list)) {
5059 printf("ea_get list failed - %s\n", cli_errstr(cli));
5063 printf("num_eas = %d\n", (int)num_eas);
5064 for (i = 0; i < num_eas; i++) {
5065 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
5066 dump_data(0, ea_list[i].value.data,
5067 ea_list[i].value.length);
5071 printf("deleting EA's failed.\n");
5075 /* Try and delete a non existant EA. */
5076 if (!cli_set_ea_path(cli, fname, "foo", "", 0)) {
5077 printf("deleting non-existant EA 'foo' should succeed. %s\n", cli_errstr(cli));
5081 talloc_destroy(mem_ctx);
5082 if (!torture_close_connection(cli)) {
5089 static bool run_dirtest1(int dummy)
5092 static struct cli_state *cli;
5095 bool correct = True;
5097 printf("starting directory test\n");
5099 if (!torture_open_connection(&cli, 0)) {
5103 cli_sockopt(cli, sockops);
5105 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
5106 cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
5107 cli_rmdir(cli, "\\LISTDIR");
5108 cli_mkdir(cli, "\\LISTDIR");
5110 /* Create 1000 files and 1000 directories. */
5111 for (i=0;i<1000;i++) {
5113 slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i);
5114 if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
5115 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum))) {
5116 fprintf(stderr,"Failed to open %s\n", fname);
5119 cli_close(cli, fnum);
5121 for (i=0;i<1000;i++) {
5123 slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i);
5124 if (!NT_STATUS_IS_OK(cli_mkdir(cli, fname))) {
5125 fprintf(stderr,"Failed to open %s\n", fname);
5130 /* Now ensure that doing an old list sees both files and directories. */
5131 num_seen = cli_list_old(cli, "\\LISTDIR\\*", aDIR, list_fn, NULL);
5132 printf("num_seen = %d\n", num_seen );
5133 /* We should see 100 files + 1000 directories + . and .. */
5134 if (num_seen != 2002)
5137 /* Ensure if we have the "must have" bits we only see the
5140 num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aDIR<<8)|aDIR, list_fn, NULL);
5141 printf("num_seen = %d\n", num_seen );
5142 if (num_seen != 1002)
5145 num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aARCH<<8)|aDIR, list_fn, NULL);
5146 printf("num_seen = %d\n", num_seen );
5147 if (num_seen != 1000)
5150 /* Delete everything. */
5151 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
5152 cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
5153 cli_rmdir(cli, "\\LISTDIR");
5156 printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
5157 printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
5158 printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
5161 if (!torture_close_connection(cli)) {
5165 printf("finished dirtest1\n");
5170 static bool run_error_map_extract(int dummy) {
5172 static struct cli_state *c_dos;
5173 static struct cli_state *c_nt;
5178 uint32 flgs2, errnum;
5185 /* NT-Error connection */
5187 if (!(c_nt = open_nbt_connection())) {
5191 c_nt->use_spnego = False;
5193 status = cli_negprot(c_nt);
5195 if (!NT_STATUS_IS_OK(status)) {
5196 printf("%s rejected the NT-error negprot (%s)\n", host,
5202 if (!NT_STATUS_IS_OK(cli_session_setup(c_nt, "", "", 0, "", 0,
5204 printf("%s rejected the NT-error initial session setup (%s)\n",host, cli_errstr(c_nt));
5208 /* DOS-Error connection */
5210 if (!(c_dos = open_nbt_connection())) {
5214 c_dos->use_spnego = False;
5215 c_dos->force_dos_errors = True;
5217 status = cli_negprot(c_dos);
5218 if (!NT_STATUS_IS_OK(status)) {
5219 printf("%s rejected the DOS-error negprot (%s)\n", host,
5221 cli_shutdown(c_dos);
5225 if (!NT_STATUS_IS_OK(cli_session_setup(c_dos, "", "", 0, "", 0,
5227 printf("%s rejected the DOS-error initial session setup (%s)\n",host, cli_errstr(c_dos));
5231 for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) {
5232 fstr_sprintf(user, "%X", error);
5234 if (NT_STATUS_IS_OK(cli_session_setup(c_nt, user,
5235 password, strlen(password),
5236 password, strlen(password),
5238 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
5241 flgs2 = SVAL(c_nt->inbuf,smb_flg2);
5243 /* Case #1: 32-bit NT errors */
5244 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
5245 nt_status = NT_STATUS(IVAL(c_nt->inbuf,smb_rcls));
5247 printf("/** Dos error on NT connection! (%s) */\n",
5249 nt_status = NT_STATUS(0xc0000000);
5252 if (NT_STATUS_IS_OK(cli_session_setup(c_dos, user,
5253 password, strlen(password),
5254 password, strlen(password),
5256 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
5258 flgs2 = SVAL(c_dos->inbuf,smb_flg2), errnum;
5260 /* Case #1: 32-bit NT errors */
5261 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
5262 printf("/** NT error on DOS connection! (%s) */\n",
5264 errnum = errclass = 0;
5266 cli_dos_error(c_dos, &errclass, &errnum);
5269 if (NT_STATUS_V(nt_status) != error) {
5270 printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n",
5271 get_nt_error_c_code(NT_STATUS(error)),
5272 get_nt_error_c_code(nt_status));
5275 printf("\t{%s,\t%s,\t%s},\n",
5276 smb_dos_err_class(errclass),
5277 smb_dos_err_name(errclass, errnum),
5278 get_nt_error_c_code(NT_STATUS(error)));
5283 static bool run_sesssetup_bench(int dummy)
5285 static struct cli_state *c;
5286 const char *fname = "\\file.dat";
5291 if (!torture_open_connection(&c, 0)) {
5295 if (!NT_STATUS_IS_OK(cli_ntcreate(
5296 c, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
5297 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
5298 FILE_DELETE_ON_CLOSE, 0, &fnum))) {
5299 d_printf("open %s failed: %s\n", fname, cli_errstr(c));
5303 for (i=0; i<torture_numops; i++) {
5304 status = cli_session_setup(
5306 password, strlen(password),
5307 password, strlen(password),
5309 if (!NT_STATUS_IS_OK(status)) {
5310 d_printf("(%s) cli_session_setup failed: %s\n",
5311 __location__, nt_errstr(status));
5315 d_printf("\r%d ", (int)c->vuid);
5317 if (!cli_ulogoff(c)) {
5318 d_printf("(%s) cli_ulogoff failed: %s\n",
5319 __location__, cli_errstr(c));
5328 static bool subst_test(const char *str, const char *user, const char *domain,
5329 uid_t uid, gid_t gid, const char *expected)
5334 subst = talloc_sub_specified(talloc_tos(), str, user, domain, uid, gid);
5336 if (strcmp(subst, expected) != 0) {
5337 printf("sub_specified(%s, %s, %s, %d, %d) returned [%s], expected "
5338 "[%s]\n", str, user, domain, (int)uid, (int)gid, subst,
5347 static void chain1_open_completion(struct tevent_req *req)
5351 status = cli_open_recv(req, &fnum);
5354 d_printf("cli_open_recv returned %s: %d\n",
5356 NT_STATUS_IS_OK(status) ? fnum : -1);
5359 static void chain1_write_completion(struct tevent_req *req)
5363 status = cli_write_andx_recv(req, &written);
5366 d_printf("cli_write_andx_recv returned %s: %d\n",
5368 NT_STATUS_IS_OK(status) ? (int)written : -1);
5371 static void chain1_close_completion(struct tevent_req *req)
5374 bool *done = (bool *)tevent_req_callback_data_void(req);
5376 status = cli_close_recv(req);
5381 d_printf("cli_close returned %s\n", nt_errstr(status));
5384 static bool run_chain1(int dummy)
5386 struct cli_state *cli1;
5387 struct event_context *evt = event_context_init(NULL);
5388 struct tevent_req *reqs[3], *smbreqs[3];
5390 const char *str = "foobar";
5393 printf("starting chain1 test\n");
5394 if (!torture_open_connection(&cli1, 0)) {
5398 cli_sockopt(cli1, sockops);
5400 reqs[0] = cli_open_create(talloc_tos(), evt, cli1, "\\test",
5401 O_CREAT|O_RDWR, 0, &smbreqs[0]);
5402 if (reqs[0] == NULL) return false;
5403 tevent_req_set_callback(reqs[0], chain1_open_completion, NULL);
5406 reqs[1] = cli_write_andx_create(talloc_tos(), evt, cli1, 0, 0,
5407 (uint8_t *)str, 0, strlen(str)+1,
5408 smbreqs, 1, &smbreqs[1]);
5409 if (reqs[1] == NULL) return false;
5410 tevent_req_set_callback(reqs[1], chain1_write_completion, NULL);
5412 reqs[2] = cli_close_create(talloc_tos(), evt, cli1, 0, &smbreqs[2]);
5413 if (reqs[2] == NULL) return false;
5414 tevent_req_set_callback(reqs[2], chain1_close_completion, &done);
5416 status = cli_smb_chain_send(smbreqs, ARRAY_SIZE(smbreqs));
5417 if (!NT_STATUS_IS_OK(status)) {
5422 event_loop_once(evt);
5425 torture_close_connection(cli1);
5429 static void chain2_sesssetup_completion(struct tevent_req *req)
5432 status = cli_session_setup_guest_recv(req);
5433 d_printf("sesssetup returned %s\n", nt_errstr(status));
5436 static void chain2_tcon_completion(struct tevent_req *req)
5438 bool *done = (bool *)tevent_req_callback_data_void(req);
5440 status = cli_tcon_andx_recv(req);
5441 d_printf("tcon_and_x returned %s\n", nt_errstr(status));
5445 static bool run_chain2(int dummy)
5447 struct cli_state *cli1;
5448 struct event_context *evt = event_context_init(NULL);
5449 struct tevent_req *reqs[2], *smbreqs[2];
5453 printf("starting chain2 test\n");
5454 status = cli_start_connection(&cli1, global_myname(), host, NULL,
5455 port_to_use, Undefined, 0, NULL);
5456 if (!NT_STATUS_IS_OK(status)) {
5460 cli_sockopt(cli1, sockops);
5462 reqs[0] = cli_session_setup_guest_create(talloc_tos(), evt, cli1,
5464 if (reqs[0] == NULL) return false;
5465 tevent_req_set_callback(reqs[0], chain2_sesssetup_completion, NULL);
5467 reqs[1] = cli_tcon_andx_create(talloc_tos(), evt, cli1, "IPC$",
5468 "?????", NULL, 0, &smbreqs[1]);
5469 if (reqs[1] == NULL) return false;
5470 tevent_req_set_callback(reqs[1], chain2_tcon_completion, &done);
5472 status = cli_smb_chain_send(smbreqs, ARRAY_SIZE(smbreqs));
5473 if (!NT_STATUS_IS_OK(status)) {
5478 event_loop_once(evt);
5481 torture_close_connection(cli1);
5486 struct torture_createdel_state {
5487 struct tevent_context *ev;
5488 struct cli_state *cli;
5491 static void torture_createdel_created(struct tevent_req *subreq);
5492 static void torture_createdel_closed(struct tevent_req *subreq);
5494 static struct tevent_req *torture_createdel_send(TALLOC_CTX *mem_ctx,
5495 struct tevent_context *ev,
5496 struct cli_state *cli,
5499 struct tevent_req *req, *subreq;
5500 struct torture_createdel_state *state;
5502 req = tevent_req_create(mem_ctx, &state,
5503 struct torture_createdel_state);
5510 subreq = cli_ntcreate_send(
5511 state, ev, cli, name, 0,
5512 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
5513 FILE_ATTRIBUTE_NORMAL,
5514 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5515 FILE_OPEN_IF, FILE_DELETE_ON_CLOSE, 0);
5517 if (tevent_req_nomem(subreq, req)) {
5518 return tevent_req_post(req, ev);
5520 tevent_req_set_callback(subreq, torture_createdel_created, req);
5524 static void torture_createdel_created(struct tevent_req *subreq)
5526 struct tevent_req *req = tevent_req_callback_data(
5527 subreq, struct tevent_req);
5528 struct torture_createdel_state *state = tevent_req_data(
5529 req, struct torture_createdel_state);
5533 status = cli_ntcreate_recv(subreq, &fnum);
5534 TALLOC_FREE(subreq);
5535 if (!NT_STATUS_IS_OK(status)) {
5536 DEBUG(10, ("cli_ntcreate_recv returned %s\n",
5537 nt_errstr(status)));
5538 tevent_req_nterror(req, status);
5542 subreq = cli_close_send(state, state->ev, state->cli, fnum);
5543 if (tevent_req_nomem(subreq, req)) {
5546 tevent_req_set_callback(subreq, torture_createdel_closed, req);
5549 static void torture_createdel_closed(struct tevent_req *subreq)
5551 struct tevent_req *req = tevent_req_callback_data(
5552 subreq, struct tevent_req);
5555 status = cli_close_recv(subreq);
5556 if (!NT_STATUS_IS_OK(status)) {
5557 DEBUG(10, ("cli_close_recv returned %s\n", nt_errstr(status)));
5558 tevent_req_nterror(req, status);
5561 tevent_req_done(req);
5564 static NTSTATUS torture_createdel_recv(struct tevent_req *req)
5566 return tevent_req_simple_recv_ntstatus(req);
5569 struct torture_createdels_state {
5570 struct tevent_context *ev;
5571 struct cli_state *cli;
5572 const char *base_name;
5576 struct tevent_req **reqs;
5579 static void torture_createdels_done(struct tevent_req *subreq);
5581 static struct tevent_req *torture_createdels_send(TALLOC_CTX *mem_ctx,
5582 struct tevent_context *ev,
5583 struct cli_state *cli,
5584 const char *base_name,
5588 struct tevent_req *req;
5589 struct torture_createdels_state *state;
5592 req = tevent_req_create(mem_ctx, &state,
5593 struct torture_createdels_state);
5599 state->base_name = talloc_strdup(state, base_name);
5600 if (tevent_req_nomem(state->base_name, req)) {
5601 return tevent_req_post(req, ev);
5603 state->num_files = MAX(num_parallel, num_files);
5605 state->received = 0;
5607 state->reqs = talloc_array(state, struct tevent_req *, num_parallel);
5608 if (tevent_req_nomem(state->reqs, req)) {
5609 return tevent_req_post(req, ev);
5612 for (i=0; i<num_parallel; i++) {
5615 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
5617 if (tevent_req_nomem(name, req)) {
5618 return tevent_req_post(req, ev);
5620 state->reqs[i] = torture_createdel_send(
5621 state->reqs, state->ev, state->cli, name);
5622 if (tevent_req_nomem(state->reqs[i], req)) {
5623 return tevent_req_post(req, ev);
5625 name = talloc_move(state->reqs[i], &name);
5626 tevent_req_set_callback(state->reqs[i],
5627 torture_createdels_done, req);
5633 static void torture_createdels_done(struct tevent_req *subreq)
5635 struct tevent_req *req = tevent_req_callback_data(
5636 subreq, struct tevent_req);
5637 struct torture_createdels_state *state = tevent_req_data(
5638 req, struct torture_createdels_state);
5639 size_t num_parallel = talloc_array_length(state->reqs);
5644 status = torture_createdel_recv(subreq);
5645 if (!NT_STATUS_IS_OK(status)){
5646 DEBUG(10, ("torture_createdel_recv returned %s\n",
5647 nt_errstr(status)));
5648 TALLOC_FREE(subreq);
5649 tevent_req_nterror(req, status);
5653 for (i=0; i<num_parallel; i++) {
5654 if (subreq == state->reqs[i]) {
5658 if (i == num_parallel) {
5659 DEBUG(10, ("received something we did not send\n"));
5660 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
5663 TALLOC_FREE(state->reqs[i]);
5665 if (state->sent >= state->num_files) {
5666 tevent_req_done(req);
5670 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
5672 if (tevent_req_nomem(name, req)) {
5675 state->reqs[i] = torture_createdel_send(state->reqs, state->ev,
5677 if (tevent_req_nomem(state->reqs[i], req)) {
5680 name = talloc_move(state->reqs[i], &name);
5681 tevent_req_set_callback(state->reqs[i], torture_createdels_done, req);
5685 static NTSTATUS torture_createdels_recv(struct tevent_req *req)
5687 return tevent_req_simple_recv_ntstatus(req);
5690 struct swallow_notify_state {
5691 struct tevent_context *ev;
5692 struct cli_state *cli;
5694 uint32_t completion_filter;
5696 bool (*fn)(uint32_t action, const char *name, void *priv);
5700 static void swallow_notify_done(struct tevent_req *subreq);
5702 static struct tevent_req *swallow_notify_send(TALLOC_CTX *mem_ctx,
5703 struct tevent_context *ev,
5704 struct cli_state *cli,
5706 uint32_t completion_filter,
5708 bool (*fn)(uint32_t action,
5713 struct tevent_req *req, *subreq;
5714 struct swallow_notify_state *state;
5716 req = tevent_req_create(mem_ctx, &state,
5717 struct swallow_notify_state);
5724 state->completion_filter = completion_filter;
5725 state->recursive = recursive;
5729 subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
5730 0xffff, state->completion_filter,
5732 if (tevent_req_nomem(subreq, req)) {
5733 return tevent_req_post(req, ev);
5735 tevent_req_set_callback(subreq, swallow_notify_done, req);
5739 static void swallow_notify_done(struct tevent_req *subreq)
5741 struct tevent_req *req = tevent_req_callback_data(
5742 subreq, struct tevent_req);
5743 struct swallow_notify_state *state = tevent_req_data(
5744 req, struct swallow_notify_state);
5746 uint32_t i, num_changes;
5747 struct notify_change *changes;
5749 status = cli_notify_recv(subreq, state, &num_changes, &changes);
5750 TALLOC_FREE(subreq);
5751 if (!NT_STATUS_IS_OK(status)) {
5752 DEBUG(10, ("cli_notify_recv returned %s\n",
5753 nt_errstr(status)));
5754 tevent_req_nterror(req, status);
5758 for (i=0; i<num_changes; i++) {
5759 state->fn(changes[i].action, changes[i].name, state->priv);
5761 TALLOC_FREE(changes);
5763 subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
5764 0xffff, state->completion_filter,
5766 if (tevent_req_nomem(subreq, req)) {
5769 tevent_req_set_callback(subreq, swallow_notify_done, req);
5772 static bool print_notifies(uint32_t action, const char *name, void *priv)
5774 if (DEBUGLEVEL > 5) {
5775 d_printf("%d %s\n", (int)action, name);
5780 static void notify_bench_done(struct tevent_req *req)
5782 int *num_finished = (int *)tevent_req_callback_data_void(req);
5786 static bool run_notify_bench(int dummy)
5788 const char *dname = "\\notify-bench";
5789 struct tevent_context *ev;
5792 struct tevent_req *req1, *req2;
5793 int i, num_unc_names;
5794 int num_finished = 0;
5796 printf("starting notify-bench test\n");
5798 if (use_multishare_conn) {
5800 unc_list = file_lines_load(multishare_conn_fname,
5801 &num_unc_names, 0, NULL);
5802 if (!unc_list || num_unc_names <= 0) {
5803 d_printf("Failed to load unc names list from '%s'\n",
5804 multishare_conn_fname);
5807 TALLOC_FREE(unc_list);
5812 ev = tevent_context_init(talloc_tos());
5814 d_printf("tevent_context_init failed\n");
5818 for (i=0; i<num_unc_names; i++) {
5819 struct cli_state *cli;
5822 base_fname = talloc_asprintf(talloc_tos(), "%s\\file%3.3d.",
5824 if (base_fname == NULL) {
5828 if (!torture_open_connection(&cli, i)) {
5832 status = cli_ntcreate(cli, dname, 0,
5833 MAXIMUM_ALLOWED_ACCESS,
5834 0, FILE_SHARE_READ|FILE_SHARE_WRITE|
5836 FILE_OPEN_IF, FILE_DIRECTORY_FILE, 0,
5839 if (!NT_STATUS_IS_OK(status)) {
5840 d_printf("Could not create %s: %s\n", dname,
5845 req1 = swallow_notify_send(talloc_tos(), ev, cli, dnum,
5846 FILE_NOTIFY_CHANGE_FILE_NAME |
5847 FILE_NOTIFY_CHANGE_DIR_NAME |
5848 FILE_NOTIFY_CHANGE_ATTRIBUTES |
5849 FILE_NOTIFY_CHANGE_LAST_WRITE,
5850 false, print_notifies, NULL);
5852 d_printf("Could not create notify request\n");
5856 req2 = torture_createdels_send(talloc_tos(), ev, cli,
5857 base_fname, 10, torture_numops);
5859 d_printf("Could not create createdels request\n");
5862 TALLOC_FREE(base_fname);
5864 tevent_req_set_callback(req2, notify_bench_done,
5868 while (num_finished < num_unc_names) {
5870 ret = tevent_loop_once(ev);
5872 d_printf("tevent_loop_once failed\n");
5877 if (!tevent_req_poll(req2, ev)) {
5878 d_printf("tevent_req_poll failed\n");
5881 status = torture_createdels_recv(req2);
5882 d_printf("torture_createdels_recv returned %s\n", nt_errstr(status));
5887 static bool run_mangle1(int dummy)
5889 struct cli_state *cli;
5890 const char *fname = "this_is_a_long_fname_to_be_mangled.txt";
5894 time_t change_time, access_time, write_time;
5898 printf("starting mangle1 test\n");
5899 if (!torture_open_connection(&cli, 0)) {
5903 cli_sockopt(cli, sockops);
5905 if (!NT_STATUS_IS_OK(cli_ntcreate(
5906 cli, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
5907 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0, &fnum))) {
5908 d_printf("open %s failed: %s\n", fname, cli_errstr(cli));
5911 cli_close(cli, fnum);
5913 status = cli_qpathinfo_alt_name(cli, fname, alt_name);
5914 if (!NT_STATUS_IS_OK(status)) {
5915 d_printf("cli_qpathinfo_alt_name failed: %s\n",
5919 d_printf("alt_name: %s\n", alt_name);
5921 if (!NT_STATUS_IS_OK(cli_open(cli, alt_name, O_RDONLY, DENY_NONE, &fnum))) {
5922 d_printf("cli_open(%s) failed: %s\n", alt_name,
5926 cli_close(cli, fnum);
5928 if (!cli_qpathinfo(cli, alt_name, &change_time, &access_time,
5929 &write_time, &size, &mode)) {
5930 d_printf("cli_qpathinfo(%s) failed: %s\n", alt_name,
5938 static size_t null_source(uint8_t *buf, size_t n, void *priv)
5940 size_t *to_pull = (size_t *)priv;
5941 size_t thistime = *to_pull;
5943 thistime = MIN(thistime, n);
5944 if (thistime == 0) {
5948 memset(buf, 0, thistime);
5949 *to_pull -= thistime;
5953 static bool run_windows_write(int dummy)
5955 struct cli_state *cli1;
5959 const char *fname = "\\writetest.txt";
5963 printf("starting windows_write test\n");
5964 if (!torture_open_connection(&cli1, 0)) {
5968 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
5969 printf("open failed (%s)\n", cli_errstr(cli1));
5973 cli_sockopt(cli1, sockops);
5977 for (i=0; i<torture_numops; i++) {
5979 off_t start = i * torture_blocksize;
5981 size_t to_pull = torture_blocksize - 1;
5983 if (cli_write(cli1, fnum, 0, &c,
5984 start + torture_blocksize - 1, 1) != 1) {
5985 printf("cli_write failed: %s\n", cli_errstr(cli1));
5989 status = cli_push(cli1, fnum, 0, i * torture_blocksize, torture_blocksize,
5990 null_source, &to_pull);
5991 if (!NT_STATUS_IS_OK(status)) {
5992 printf("cli_push returned: %s\n", nt_errstr(status));
5997 seconds = end_timer();
5998 kbytes = (double)torture_blocksize * torture_numops;
6001 printf("Wrote %d kbytes in %.2f seconds: %d kb/sec\n", (int)kbytes,
6002 (double)seconds, (int)(kbytes/seconds));
6006 cli_close(cli1, fnum);
6007 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
6008 torture_close_connection(cli1);
6012 static bool run_cli_echo(int dummy)
6014 struct cli_state *cli;
6017 printf("starting cli_echo test\n");
6018 if (!torture_open_connection(&cli, 0)) {
6021 cli_sockopt(cli, sockops);
6023 status = cli_echo(cli, 5, data_blob_const("hello", 5));
6025 d_printf("cli_echo returned %s\n", nt_errstr(status));
6027 torture_close_connection(cli);
6028 return NT_STATUS_IS_OK(status);
6031 static bool run_uid_regression_test(int dummy)
6033 static struct cli_state *cli;
6036 bool correct = True;
6038 printf("starting uid regression test\n");
6040 if (!torture_open_connection(&cli, 0)) {
6044 cli_sockopt(cli, sockops);
6046 /* Ok - now save then logoff our current user. */
6047 old_vuid = cli->vuid;
6049 if (!cli_ulogoff(cli)) {
6050 d_printf("(%s) cli_ulogoff failed: %s\n",
6051 __location__, cli_errstr(cli));
6056 cli->vuid = old_vuid;
6058 /* Try an operation. */
6059 if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\uid_reg_test"))) {
6060 /* We expect bad uid. */
6061 if (!check_error(__LINE__, cli, ERRSRV, ERRbaduid,
6062 NT_STATUS_NO_SUCH_USER)) {
6067 old_cnum = cli->cnum;
6069 /* Now try a SMBtdis with the invald vuid set to zero. */
6072 /* This should succeed. */
6073 if (cli_tdis(cli)) {
6074 printf("First tdis with invalid vuid should succeed.\n");
6076 printf("First tdis failed (%s)\n", cli_errstr(cli));
6079 cli->vuid = old_vuid;
6080 cli->cnum = old_cnum;
6082 /* This should fail. */
6083 if (cli_tdis(cli)) {
6084 printf("Second tdis with invalid vuid should fail - succeeded instead !.\n");
6086 /* Should be bad tid. */
6087 if (!check_error(__LINE__, cli, ERRSRV, ERRinvnid,
6088 NT_STATUS_NETWORK_NAME_DELETED)) {
6093 cli_rmdir(cli, "\\uid_reg_test");
6102 static const char *illegal_chars = "*\\/?<>|\":";
6103 static char force_shortname_chars[] = " +,.[];=\177";
6105 static void shortname_del_fn(const char *mnt, file_info *finfo, const char *mask, void *state)
6107 struct cli_state *pcli = (struct cli_state *)state;
6109 slprintf(fname, sizeof(fname), "\\shortname\\%s", finfo->name);
6111 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
6114 if (finfo->mode & aDIR) {
6115 if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname)))
6116 printf("del_fn: failed to rmdir %s\n,", fname );
6118 if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, aSYSTEM | aHIDDEN)))
6119 printf("del_fn: failed to unlink %s\n,", fname );
6128 static void shortname_list_fn(const char *mnt, file_info *finfo, const char *name, void *state)
6130 struct sn_state *s = (struct sn_state *)state;
6134 printf("shortname list: i = %d, name = |%s|, shortname = |%s|\n",
6135 i, finfo->name, finfo->short_name);
6138 if (strchr(force_shortname_chars, i)) {
6139 if (!finfo->short_name[0]) {
6140 /* Shortname not created when it should be. */
6141 d_printf("(%s) ERROR: Shortname was not created for file %s containing %d\n",
6142 __location__, finfo->name, i);
6145 } else if (finfo->short_name[0]){
6146 /* Shortname created when it should not be. */
6147 d_printf("(%s) ERROR: Shortname %s was created for file %s\n",
6148 __location__, finfo->short_name, finfo->name);
6153 static bool run_shortname_test(int dummy)
6155 static struct cli_state *cli;
6156 bool correct = True;
6161 printf("starting shortname test\n");
6163 if (!torture_open_connection(&cli, 0)) {
6167 cli_sockopt(cli, sockops);
6169 cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
6170 cli_list(cli, "\\shortname\\*", aDIR, shortname_del_fn, cli);
6171 cli_rmdir(cli, "\\shortname");
6173 if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\shortname"))) {
6174 d_printf("(%s) cli_mkdir of \\shortname failed: %s\n",
6175 __location__, cli_errstr(cli));
6180 strlcpy(fname, "\\shortname\\", sizeof(fname));
6181 strlcat(fname, "test .txt", sizeof(fname));
6185 for (i = 32; i < 128; i++) {
6187 uint16_t fnum = (uint16_t)-1;
6191 if (strchr(illegal_chars, i)) {
6196 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
6197 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum);
6198 if (!NT_STATUS_IS_OK(status)) {
6199 d_printf("(%s) cli_nt_create of %s failed: %s\n",
6200 __location__, fname, cli_errstr(cli));
6204 cli_close(cli, fnum);
6205 if (cli_list(cli, "\\shortname\\test*.*", 0, shortname_list_fn, &s) != 1) {
6206 d_printf("(%s) failed to list %s: %s\n",
6207 __location__, fname, cli_errstr(cli));
6211 if (!NT_STATUS_IS_OK(cli_unlink(cli, fname, aSYSTEM | aHIDDEN))) {
6212 d_printf("(%s) failed to delete %s: %s\n",
6213 __location__, fname, cli_errstr(cli));
6226 cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
6227 cli_list(cli, "\\shortname\\*", aDIR, shortname_del_fn, cli);
6228 cli_rmdir(cli, "\\shortname");
6229 torture_close_connection(cli);
6233 static void pagedsearch_cb(struct tevent_req *req)
6236 struct tldap_message *msg;
6239 rc = tldap_search_paged_recv(req, talloc_tos(), &msg);
6240 if (rc != TLDAP_SUCCESS) {
6241 d_printf("tldap_search_paged_recv failed: %s\n",
6242 tldap_err2string(rc));
6245 if (tldap_msg_type(msg) != TLDAP_RES_SEARCH_ENTRY) {
6249 if (!tldap_entry_dn(msg, &dn)) {
6250 d_printf("tldap_entry_dn failed\n");
6253 d_printf("%s\n", dn);
6257 static bool run_tldap(int dummy)
6259 struct tldap_context *ld;
6262 struct sockaddr_storage addr;
6263 struct tevent_context *ev;
6264 struct tevent_req *req;
6267 if (!resolve_name(host, &addr, 0, false)) {
6268 d_printf("could not find host %s\n", host);
6271 status = open_socket_out(&addr, 389, 9999, &fd);
6272 if (!NT_STATUS_IS_OK(status)) {
6273 d_printf("open_socket_out failed: %s\n", nt_errstr(status));
6277 ld = tldap_context_create(talloc_tos(), fd);
6280 d_printf("tldap_context_create failed\n");
6284 rc = tldap_fetch_rootdse(ld);
6285 if (rc != TLDAP_SUCCESS) {
6286 d_printf("tldap_fetch_rootdse failed: %s\n",
6287 tldap_errstr(talloc_tos(), ld, rc));
6291 basedn = tldap_talloc_single_attribute(
6292 tldap_rootdse(ld), "defaultNamingContext", talloc_tos());
6293 if (basedn == NULL) {
6294 d_printf("no defaultNamingContext\n");
6297 d_printf("defaultNamingContext: %s\n", basedn);
6299 ev = tevent_context_init(talloc_tos());
6301 d_printf("tevent_context_init failed\n");
6305 req = tldap_search_paged_send(talloc_tos(), ev, ld, basedn,
6306 TLDAP_SCOPE_SUB, "(objectclass=*)",
6308 NULL, 0, NULL, 0, 0, 0, 0, 5);
6310 d_printf("tldap_search_paged_send failed\n");
6313 tevent_req_set_callback(req, pagedsearch_cb, NULL);
6315 tevent_req_poll(req, ev);
6323 static bool run_streamerror(int dummy)
6325 struct cli_state *cli;
6326 const char *dname = "\\testdir";
6327 const char *streamname =
6328 "testdir:{4c8cc155-6c1e-11d1-8e41-00c04fb9386d}:$DATA";
6330 time_t change_time, access_time, write_time;
6332 uint16_t mode, fnum;
6335 if (!torture_open_connection(&cli, 0)) {
6339 cli_rmdir(cli, dname);
6341 status = cli_mkdir(cli, dname);
6342 if (!NT_STATUS_IS_OK(status)) {
6343 printf("mkdir failed: %s\n", nt_errstr(status));
6347 cli_qpathinfo(cli, streamname, &change_time, &access_time, &write_time,
6349 status = cli_nt_error(cli);
6351 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
6352 printf("pathinfo returned %s, expected "
6353 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
6358 status = cli_ntcreate(cli, streamname, 0x16,
6359 FILE_READ_DATA|FILE_READ_EA|
6360 FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS,
6361 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
6362 FILE_OPEN, 0, 0, &fnum);
6364 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
6365 printf("ntcreate returned %s, expected "
6366 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
6372 cli_rmdir(cli, dname);
6376 static bool run_local_substitute(int dummy)
6380 ok &= subst_test("%U", "bla", "", -1, -1, "bla");
6381 ok &= subst_test("%u%U", "bla", "", -1, -1, "blabla");
6382 ok &= subst_test("%g", "", "", -1, -1, "NO_GROUP");
6383 ok &= subst_test("%G", "", "", -1, -1, "NO_GROUP");
6384 ok &= subst_test("%g", "", "", -1, 0, gidtoname(0));
6385 ok &= subst_test("%G", "", "", -1, 0, gidtoname(0));
6386 ok &= subst_test("%D%u", "u", "dom", -1, 0, "domu");
6387 ok &= subst_test("%i %I", "", "", -1, -1, "0.0.0.0 0.0.0.0");
6389 /* Different captialization rules in sub_basic... */
6391 ok &= (strcmp(talloc_sub_basic(talloc_tos(), "BLA", "dom", "%U%D"),
6397 static bool run_local_base64(int dummy)
6402 for (i=1; i<2000; i++) {
6403 DATA_BLOB blob1, blob2;
6406 blob1.data = talloc_array(talloc_tos(), uint8_t, i);
6408 generate_random_buffer(blob1.data, blob1.length);
6410 b64 = base64_encode_data_blob(talloc_tos(), blob1);
6412 d_fprintf(stderr, "base64_encode_data_blob failed "
6413 "for %d bytes\n", i);
6416 blob2 = base64_decode_data_blob(b64);
6419 if (data_blob_cmp(&blob1, &blob2)) {
6420 d_fprintf(stderr, "data_blob_cmp failed for %d "
6424 TALLOC_FREE(blob1.data);
6425 data_blob_free(&blob2);
6430 static bool run_local_gencache(int dummy)
6436 if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
6437 d_printf("%s: gencache_set() failed\n", __location__);
6441 if (!gencache_get("foo", NULL, NULL)) {
6442 d_printf("%s: gencache_get() failed\n", __location__);
6446 if (!gencache_get("foo", &val, &tm)) {
6447 d_printf("%s: gencache_get() failed\n", __location__);
6451 if (strcmp(val, "bar") != 0) {
6452 d_printf("%s: gencache_get() returned %s, expected %s\n",
6453 __location__, val, "bar");
6460 if (!gencache_del("foo")) {
6461 d_printf("%s: gencache_del() failed\n", __location__);
6464 if (gencache_del("foo")) {
6465 d_printf("%s: second gencache_del() succeeded\n",
6470 if (gencache_get("foo", &val, &tm)) {
6471 d_printf("%s: gencache_get() on deleted entry "
6472 "succeeded\n", __location__);
6476 blob = data_blob_string_const_null("bar");
6477 tm = time(NULL) + 60;
6479 if (!gencache_set_data_blob("foo", &blob, tm)) {
6480 d_printf("%s: gencache_set_data_blob() failed\n", __location__);
6484 if (!gencache_get_data_blob("foo", &blob, NULL, NULL)) {
6485 d_printf("%s: gencache_get_data_blob() failed\n", __location__);
6489 if (strcmp((const char *)blob.data, "bar") != 0) {
6490 d_printf("%s: gencache_get_data_blob() returned %s, expected %s\n",
6491 __location__, (const char *)blob.data, "bar");
6492 data_blob_free(&blob);
6496 data_blob_free(&blob);
6498 if (!gencache_del("foo")) {
6499 d_printf("%s: gencache_del() failed\n", __location__);
6502 if (gencache_del("foo")) {
6503 d_printf("%s: second gencache_del() succeeded\n",
6508 if (gencache_get_data_blob("foo", &blob, NULL, NULL)) {
6509 d_printf("%s: gencache_get_data_blob() on deleted entry "
6510 "succeeded\n", __location__);
6517 static bool rbt_testval(struct db_context *db, const char *key,
6520 struct db_record *rec;
6521 TDB_DATA data = string_tdb_data(value);
6525 rec = db->fetch_locked(db, db, string_tdb_data(key));
6527 d_fprintf(stderr, "fetch_locked failed\n");
6530 status = rec->store(rec, data, 0);
6531 if (!NT_STATUS_IS_OK(status)) {
6532 d_fprintf(stderr, "store failed: %s\n", nt_errstr(status));
6537 rec = db->fetch_locked(db, db, string_tdb_data(key));
6539 d_fprintf(stderr, "second fetch_locked failed\n");
6542 if ((rec->value.dsize != data.dsize)
6543 || (memcmp(rec->value.dptr, data.dptr, data.dsize) != 0)) {
6544 d_fprintf(stderr, "Got wrong data back\n");
6554 static bool run_local_rbtree(int dummy)
6556 struct db_context *db;
6560 db = db_open_rbt(NULL);
6563 d_fprintf(stderr, "db_open_rbt failed\n");
6567 for (i=0; i<1000; i++) {
6570 if (asprintf(&key, "key%ld", random()) == -1) {
6573 if (asprintf(&value, "value%ld", random()) == -1) {
6578 if (!rbt_testval(db, key, value)) {
6585 if (asprintf(&value, "value%ld", random()) == -1) {
6590 if (!rbt_testval(db, key, value)) {
6607 struct talloc_dict_test {
6611 static int talloc_dict_traverse_fn(DATA_BLOB key, void *data, void *priv)
6613 int *count = (int *)priv;
6618 static bool run_local_talloc_dict(int dummy)
6620 struct talloc_dict *dict;
6621 struct talloc_dict_test *t;
6624 dict = talloc_dict_init(talloc_tos());
6629 t = talloc(talloc_tos(), struct talloc_dict_test);
6636 if (!talloc_dict_set(dict, data_blob_const(&key, sizeof(key)), t)) {
6641 if (talloc_dict_traverse(dict, talloc_dict_traverse_fn, &count) != 0) {
6654 /* Split a path name into filename and stream name components. Canonicalise
6655 * such that an implicit $DATA token is always explicit.
6657 * The "specification" of this function can be found in the
6658 * run_local_stream_name() function in torture.c, I've tried those
6659 * combinations against a W2k3 server.
6662 static NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
6663 char **pbase, char **pstream)
6666 char *stream = NULL;
6667 char *sname; /* stream name */
6668 const char *stype; /* stream type */
6670 DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
6672 sname = strchr_m(fname, ':');
6674 if (lp_posix_pathnames() || (sname == NULL)) {
6675 if (pbase != NULL) {
6676 base = talloc_strdup(mem_ctx, fname);
6677 NT_STATUS_HAVE_NO_MEMORY(base);
6682 if (pbase != NULL) {
6683 base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
6684 NT_STATUS_HAVE_NO_MEMORY(base);
6689 stype = strchr_m(sname, ':');
6691 if (stype == NULL) {
6692 sname = talloc_strdup(mem_ctx, sname);
6696 if (StrCaseCmp(stype, ":$DATA") != 0) {
6698 * If there is an explicit stream type, so far we only
6699 * allow $DATA. Is there anything else allowed? -- vl
6701 DEBUG(10, ("[%s] is an invalid stream type\n", stype));
6703 return NT_STATUS_OBJECT_NAME_INVALID;
6705 sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
6709 if (sname == NULL) {
6711 return NT_STATUS_NO_MEMORY;
6714 if (sname[0] == '\0') {
6716 * no stream name, so no stream
6721 if (pstream != NULL) {
6722 stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
6723 if (stream == NULL) {
6726 return NT_STATUS_NO_MEMORY;
6729 * upper-case the type field
6731 strupper_m(strchr_m(stream, ':')+1);
6735 if (pbase != NULL) {
6738 if (pstream != NULL) {
6741 return NT_STATUS_OK;
6744 static bool test_stream_name(const char *fname, const char *expected_base,
6745 const char *expected_stream,
6746 NTSTATUS expected_status)
6750 char *stream = NULL;
6752 status = split_ntfs_stream_name(talloc_tos(), fname, &base, &stream);
6753 if (!NT_STATUS_EQUAL(status, expected_status)) {
6757 if (!NT_STATUS_IS_OK(status)) {
6761 if (base == NULL) goto error;
6763 if (strcmp(expected_base, base) != 0) goto error;
6765 if ((expected_stream != NULL) && (stream == NULL)) goto error;
6766 if ((expected_stream == NULL) && (stream != NULL)) goto error;
6768 if ((stream != NULL) && (strcmp(expected_stream, stream) != 0))
6772 TALLOC_FREE(stream);
6776 d_fprintf(stderr, "test_stream(%s, %s, %s, %s)\n",
6777 fname, expected_base ? expected_base : "<NULL>",
6778 expected_stream ? expected_stream : "<NULL>",
6779 nt_errstr(expected_status));
6780 d_fprintf(stderr, "-> base=%s, stream=%s, status=%s\n",
6781 base ? base : "<NULL>", stream ? stream : "<NULL>",
6784 TALLOC_FREE(stream);
6788 static bool run_local_stream_name(int dummy)
6792 ret &= test_stream_name(
6793 "bla", "bla", NULL, NT_STATUS_OK);
6794 ret &= test_stream_name(
6795 "bla::$DATA", "bla", NULL, NT_STATUS_OK);
6796 ret &= test_stream_name(
6797 "bla:blub:", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
6798 ret &= test_stream_name(
6799 "bla::", NULL, NULL, NT_STATUS_OBJECT_NAME_INVALID);
6800 ret &= test_stream_name(
6801 "bla::123", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
6802 ret &= test_stream_name(
6803 "bla:$DATA", "bla", "$DATA:$DATA", NT_STATUS_OK);
6804 ret &= test_stream_name(
6805 "bla:x:$DATA", "bla", "x:$DATA", NT_STATUS_OK);
6806 ret &= test_stream_name(
6807 "bla:x", "bla", "x:$DATA", NT_STATUS_OK);
6812 static bool data_blob_equal(DATA_BLOB a, DATA_BLOB b)
6814 if (a.length != b.length) {
6815 printf("a.length=%d != b.length=%d\n",
6816 (int)a.length, (int)b.length);
6819 if (memcmp(a.data, b.data, a.length) != 0) {
6820 printf("a.data and b.data differ\n");
6826 static bool run_local_memcache(int dummy)
6828 struct memcache *cache;
6830 DATA_BLOB d1, d2, d3;
6831 DATA_BLOB v1, v2, v3;
6833 TALLOC_CTX *mem_ctx;
6835 size_t size1, size2;
6838 cache = memcache_init(NULL, 100);
6840 if (cache == NULL) {
6841 printf("memcache_init failed\n");
6845 d1 = data_blob_const("d1", 2);
6846 d2 = data_blob_const("d2", 2);
6847 d3 = data_blob_const("d3", 2);
6849 k1 = data_blob_const("d1", 2);
6850 k2 = data_blob_const("d2", 2);
6852 memcache_add(cache, STAT_CACHE, k1, d1);
6853 memcache_add(cache, GETWD_CACHE, k2, d2);
6855 if (!memcache_lookup(cache, STAT_CACHE, k1, &v1)) {
6856 printf("could not find k1\n");
6859 if (!data_blob_equal(d1, v1)) {
6863 if (!memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
6864 printf("could not find k2\n");
6867 if (!data_blob_equal(d2, v2)) {
6871 memcache_add(cache, STAT_CACHE, k1, d3);
6873 if (!memcache_lookup(cache, STAT_CACHE, k1, &v3)) {
6874 printf("could not find replaced k1\n");
6877 if (!data_blob_equal(d3, v3)) {
6881 memcache_add(cache, GETWD_CACHE, k1, d1);
6883 if (memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
6884 printf("Did find k2, should have been purged\n");
6890 cache = memcache_init(NULL, 0);
6892 mem_ctx = talloc_init("foo");
6894 str1 = talloc_strdup(mem_ctx, "string1");
6895 str2 = talloc_strdup(mem_ctx, "string2");
6897 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
6898 data_blob_string_const("torture"), &str1);
6899 size1 = talloc_total_size(cache);
6901 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
6902 data_blob_string_const("torture"), &str2);
6903 size2 = talloc_total_size(cache);
6905 printf("size1=%d, size2=%d\n", (int)size1, (int)size2);
6907 if (size2 > size1) {
6908 printf("memcache leaks memory!\n");
6918 static void wbclient_done(struct tevent_req *req)
6921 struct winbindd_response *wb_resp;
6922 int *i = (int *)tevent_req_callback_data_void(req);
6924 wbc_err = wb_trans_recv(req, req, &wb_resp);
6927 d_printf("wb_trans_recv %d returned %s\n", *i, wbcErrorString(wbc_err));
6930 static bool run_local_wbclient(int dummy)
6932 struct event_context *ev;
6933 struct wb_context **wb_ctx;
6934 struct winbindd_request wb_req;
6935 bool result = false;
6938 BlockSignals(True, SIGPIPE);
6940 ev = tevent_context_init_byname(talloc_tos(), "epoll");
6945 wb_ctx = TALLOC_ARRAY(ev, struct wb_context *, nprocs);
6946 if (wb_ctx == NULL) {
6950 ZERO_STRUCT(wb_req);
6951 wb_req.cmd = WINBINDD_PING;
6953 d_printf("nprocs=%d, numops=%d\n", (int)nprocs, (int)torture_numops);
6955 for (i=0; i<nprocs; i++) {
6956 wb_ctx[i] = wb_context_init(ev, NULL);
6957 if (wb_ctx[i] == NULL) {
6960 for (j=0; j<torture_numops; j++) {
6961 struct tevent_req *req;
6962 req = wb_trans_send(ev, ev, wb_ctx[i],
6963 (j % 2) == 0, &wb_req);
6967 tevent_req_set_callback(req, wbclient_done, &i);
6973 while (i < nprocs * torture_numops) {
6974 event_loop_once(ev);
6983 static void getaddrinfo_finished(struct tevent_req *req)
6985 char *name = (char *)tevent_req_callback_data_void(req);
6986 struct addrinfo *ainfo;
6989 res = getaddrinfo_recv(req, &ainfo);
6991 d_printf("gai(%s) returned %s\n", name, gai_strerror(res));
6994 d_printf("gai(%s) succeeded\n", name);
6995 freeaddrinfo(ainfo);
6998 static bool run_getaddrinfo_send(int dummy)
7000 TALLOC_CTX *frame = talloc_stackframe();
7001 struct fncall_context *ctx;
7002 struct tevent_context *ev;
7003 bool result = false;
7004 const char *names[4] = { "www.samba.org", "notfound.samba.org",
7005 "www.slashdot.org", "heise.de" };
7006 struct tevent_req *reqs[4];
7009 ev = event_context_init(frame);
7014 ctx = fncall_context_init(frame, 4);
7016 for (i=0; i<ARRAY_SIZE(names); i++) {
7017 reqs[i] = getaddrinfo_send(frame, ev, ctx, names[i], NULL,
7019 if (reqs[i] == NULL) {
7022 tevent_req_set_callback(reqs[i], getaddrinfo_finished,
7026 for (i=0; i<ARRAY_SIZE(reqs); i++) {
7027 tevent_loop_once(ev);
7037 static double create_procs(bool (*fn)(int), bool *result)
7040 volatile pid_t *child_status;
7041 volatile bool *child_status_out;
7047 child_status = (volatile pid_t *)shm_setup(sizeof(pid_t)*nprocs);
7048 if (!child_status) {
7049 printf("Failed to setup shared memory\n");
7053 child_status_out = (volatile bool *)shm_setup(sizeof(bool)*nprocs);
7054 if (!child_status_out) {
7055 printf("Failed to setup result status shared memory\n");
7059 for (i = 0; i < nprocs; i++) {
7060 child_status[i] = 0;
7061 child_status_out[i] = True;
7066 for (i=0;i<nprocs;i++) {
7069 pid_t mypid = getpid();
7070 sys_srandom(((int)mypid) ^ ((int)time(NULL)));
7072 slprintf(myname,sizeof(myname),"CLIENT%d", i);
7075 if (torture_open_connection(¤t_cli, i)) break;
7077 printf("pid %d failed to start\n", (int)getpid());
7083 child_status[i] = getpid();
7085 while (child_status[i] && end_timer() < 5) smb_msleep(2);
7087 child_status_out[i] = fn(i);
7094 for (i=0;i<nprocs;i++) {
7095 if (child_status[i]) synccount++;
7097 if (synccount == nprocs) break;
7099 } while (end_timer() < 30);
7101 if (synccount != nprocs) {
7102 printf("FAILED TO START %d CLIENTS (started %d)\n", nprocs, synccount);
7107 /* start the client load */
7110 for (i=0;i<nprocs;i++) {
7111 child_status[i] = 0;
7114 printf("%d clients started\n", nprocs);
7116 for (i=0;i<nprocs;i++) {
7117 while (waitpid(0, &status, 0) == -1 && errno == EINTR) /* noop */ ;
7122 for (i=0;i<nprocs;i++) {
7123 if (!child_status_out[i]) {
7130 #define FLAG_MULTIPROC 1
7137 {"FDPASS", run_fdpasstest, 0},
7138 {"LOCK1", run_locktest1, 0},
7139 {"LOCK2", run_locktest2, 0},
7140 {"LOCK3", run_locktest3, 0},
7141 {"LOCK4", run_locktest4, 0},
7142 {"LOCK5", run_locktest5, 0},
7143 {"LOCK6", run_locktest6, 0},
7144 {"LOCK7", run_locktest7, 0},
7145 {"LOCK8", run_locktest8, 0},
7146 {"LOCK9", run_locktest9, 0},
7147 {"UNLINK", run_unlinktest, 0},
7148 {"BROWSE", run_browsetest, 0},
7149 {"ATTR", run_attrtest, 0},
7150 {"TRANS2", run_trans2test, 0},
7151 {"MAXFID", run_maxfidtest, FLAG_MULTIPROC},
7152 {"TORTURE",run_torture, FLAG_MULTIPROC},
7153 {"RANDOMIPC", run_randomipc, 0},
7154 {"NEGNOWAIT", run_negprot_nowait, 0},
7155 {"NBENCH", run_nbench, 0},
7156 {"OPLOCK1", run_oplock1, 0},
7157 {"OPLOCK2", run_oplock2, 0},
7158 {"OPLOCK3", run_oplock3, 0},
7159 {"DIR", run_dirtest, 0},
7160 {"DIR1", run_dirtest1, 0},
7161 {"DENY1", torture_denytest1, 0},
7162 {"DENY2", torture_denytest2, 0},
7163 {"TCON", run_tcon_test, 0},
7164 {"TCONDEV", run_tcon_devtype_test, 0},
7165 {"RW1", run_readwritetest, 0},
7166 {"RW2", run_readwritemulti, FLAG_MULTIPROC},
7167 {"RW3", run_readwritelarge, 0},
7168 {"OPEN", run_opentest, 0},
7169 {"POSIX", run_simple_posix_open_test, 0},
7170 { "UID-REGRESSION-TEST", run_uid_regression_test, 0},
7171 { "SHORTNAME-TEST", run_shortname_test, 0},
7173 {"OPENATTR", run_openattrtest, 0},
7175 {"XCOPY", run_xcopy, 0},
7176 {"RENAME", run_rename, 0},
7177 {"DELETE", run_deletetest, 0},
7178 {"PROPERTIES", run_properties, 0},
7179 {"MANGLE", torture_mangle, 0},
7180 {"MANGLE1", run_mangle1, 0},
7181 {"W2K", run_w2ktest, 0},
7182 {"TRANS2SCAN", torture_trans2_scan, 0},
7183 {"NTTRANSSCAN", torture_nttrans_scan, 0},
7184 {"UTABLE", torture_utable, 0},
7185 {"CASETABLE", torture_casetable, 0},
7186 {"ERRMAPEXTRACT", run_error_map_extract, 0},
7187 {"PIPE_NUMBER", run_pipe_number, 0},
7188 {"TCON2", run_tcon2_test, 0},
7189 {"IOCTL", torture_ioctl_test, 0},
7190 {"CHKPATH", torture_chkpath_test, 0},
7191 {"FDSESS", run_fdsesstest, 0},
7192 { "EATEST", run_eatest, 0},
7193 { "SESSSETUP_BENCH", run_sesssetup_bench, 0},
7194 { "CHAIN1", run_chain1, 0},
7195 { "CHAIN2", run_chain2, 0},
7196 { "WINDOWS-WRITE", run_windows_write, 0},
7197 { "CLI_ECHO", run_cli_echo, 0},
7198 { "GETADDRINFO", run_getaddrinfo_send, 0},
7199 { "TLDAP", run_tldap },
7200 { "STREAMERROR", run_streamerror },
7201 { "NOTIFY-BENCH", run_notify_bench },
7202 { "LOCAL-SUBSTITUTE", run_local_substitute, 0},
7203 { "LOCAL-GENCACHE", run_local_gencache, 0},
7204 { "LOCAL-TALLOC-DICT", run_local_talloc_dict, 0},
7205 { "LOCAL-BASE64", run_local_base64, 0},
7206 { "LOCAL-RBTREE", run_local_rbtree, 0},
7207 { "LOCAL-MEMCACHE", run_local_memcache, 0},
7208 { "LOCAL-STREAM-NAME", run_local_stream_name, 0},
7209 { "LOCAL-WBCLIENT", run_local_wbclient, 0},
7214 /****************************************************************************
7215 run a specified test or "ALL"
7216 ****************************************************************************/
7217 static bool run_test(const char *name)
7224 if (strequal(name,"ALL")) {
7225 for (i=0;torture_ops[i].name;i++) {
7226 run_test(torture_ops[i].name);
7231 for (i=0;torture_ops[i].name;i++) {
7232 fstr_sprintf(randomfname, "\\XX%x",
7233 (unsigned)random());
7235 if (strequal(name, torture_ops[i].name)) {
7237 printf("Running %s\n", name);
7238 if (torture_ops[i].flags & FLAG_MULTIPROC) {
7239 t = create_procs(torture_ops[i].fn, &result);
7242 printf("TEST %s FAILED!\n", name);
7246 if (!torture_ops[i].fn(0)) {
7248 printf("TEST %s FAILED!\n", name);
7252 printf("%s took %g secs\n\n", name, t);
7257 printf("Did not find a test named %s\n", name);
7265 static void usage(void)
7269 printf("WARNING samba4 test suite is much more complete nowadays.\n");
7270 printf("Please use samba4 torture.\n\n");
7272 printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
7274 printf("\t-d debuglevel\n");
7275 printf("\t-U user%%pass\n");
7276 printf("\t-k use kerberos\n");
7277 printf("\t-N numprocs\n");
7278 printf("\t-n my_netbios_name\n");
7279 printf("\t-W workgroup\n");
7280 printf("\t-o num_operations\n");
7281 printf("\t-O socket_options\n");
7282 printf("\t-m maximum protocol\n");
7283 printf("\t-L use oplocks\n");
7284 printf("\t-c CLIENT.TXT specify client load file for NBENCH\n");
7285 printf("\t-A showall\n");
7286 printf("\t-p port\n");
7287 printf("\t-s seed\n");
7288 printf("\t-b unclist_filename specify multiple shares for multiple connections\n");
7291 printf("tests are:");
7292 for (i=0;torture_ops[i].name;i++) {
7293 printf(" %s", torture_ops[i].name);
7297 printf("default test is ALL\n");
7302 /****************************************************************************
7304 ****************************************************************************/
7305 int main(int argc,char *argv[])
7311 bool correct = True;
7312 TALLOC_CTX *frame = talloc_stackframe();
7313 int seed = time(NULL);
7317 #ifdef HAVE_SETBUFFER
7318 setbuffer(stdout, NULL, 0);
7323 if (is_default_dyn_CONFIGFILE()) {
7324 if(getenv("SMB_CONF_PATH")) {
7325 set_dyn_CONFIGFILE(getenv("SMB_CONF_PATH"));
7328 lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
7335 for(p = argv[1]; *p; p++)
7339 if (strncmp(argv[1], "//", 2)) {
7343 fstrcpy(host, &argv[1][2]);
7344 p = strchr_m(&host[2],'/');
7349 fstrcpy(share, p+1);
7351 fstrcpy(myname, get_myname(talloc_tos()));
7353 fprintf(stderr, "Failed to get my hostname.\n");
7357 if (*username == 0 && getenv("LOGNAME")) {
7358 fstrcpy(username,getenv("LOGNAME"));
7364 fstrcpy(workgroup, lp_workgroup());
7366 while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ll:d:Aec:ks:b:B:")) != EOF) {
7369 port_to_use = atoi(optarg);
7372 seed = atoi(optarg);
7375 fstrcpy(workgroup,optarg);
7378 max_protocol = interpret_protocol(optarg, max_protocol);
7381 nprocs = atoi(optarg);
7384 torture_numops = atoi(optarg);
7387 DEBUGLEVEL = atoi(optarg);
7396 local_path = optarg;
7399 torture_showall = True;
7402 fstrcpy(myname, optarg);
7405 client_txt = optarg;
7412 use_kerberos = True;
7414 d_printf("No kerberos support compiled in\n");
7420 fstrcpy(username,optarg);
7421 p = strchr_m(username,'%');
7424 fstrcpy(password, p+1);
7429 fstrcpy(multishare_conn_fname, optarg);
7430 use_multishare_conn = True;
7433 torture_blocksize = atoi(optarg);
7436 printf("Unknown option %c (%d)\n", (char)opt, opt);
7441 d_printf("using seed %d\n", seed);
7445 if(use_kerberos && !gotuser) gotpass = True;
7448 p = getpass("Password:");
7450 fstrcpy(password, p);
7455 printf("host=%s share=%s user=%s myname=%s\n",
7456 host, share, username, myname);
7458 if (argc == optind) {
7459 correct = run_test("ALL");
7461 for (i=optind;i<argc;i++) {
7462 if (!run_test(argv[i])) {