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 "wbc_async.h"
23 #include "torture/proto.h"
24 #include "libcli/security/security.h"
26 #include "tldap_util.h"
27 #include "../librpc/gen_ndr/svcctl.h"
29 #include "nsswitch/winbind_client.h"
31 #include "talloc_dict.h"
32 #include "async_smb.h"
33 #include "libsmb/clirap.h"
38 static fstring host, workgroup, share, password, username, myname;
39 static int max_protocol = PROTOCOL_NT1;
40 static const char *sockops="TCP_NODELAY";
42 static int port_to_use=0;
43 int torture_numops=100;
44 int torture_blocksize=1024*1024;
45 static int procnum; /* records process count number when forking */
46 static struct cli_state *current_cli;
47 static fstring randomfname;
48 static bool use_oplocks;
49 static bool use_level_II_oplocks;
50 static const char *client_txt = "client_oplocks.txt";
51 static bool use_kerberos;
52 static fstring multishare_conn_fname;
53 static bool use_multishare_conn = False;
54 static bool do_encrypt;
55 static const char *local_path = NULL;
56 static int signing_state = Undefined;
58 bool torture_showall = False;
60 static double create_procs(bool (*fn)(int), bool *result);
63 /* return a pointer to a anonymous shared memory segment of size "size"
64 which will persist across fork() but will disappear when all processes
67 The memory is not zeroed
69 This function uses system5 shared memory. It takes advantage of a property
70 that the memory is not destroyed if it is attached when the id is removed
72 void *shm_setup(int size)
78 shmid = shm_open("private", O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
80 printf("can't get shared memory\n");
83 shm_unlink("private");
84 if (ftruncate(shmid, size) == -1) {
85 printf("can't set shared memory size\n");
88 ret = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, shmid, 0);
89 if (ret == MAP_FAILED) {
90 printf("can't map shared memory\n");
94 shmid = shmget(IPC_PRIVATE, size, S_IRUSR | S_IWUSR);
96 printf("can't get shared memory\n");
99 ret = (void *)shmat(shmid, 0, 0);
100 if (!ret || ret == (void *)-1) {
101 printf("can't attach to shared memory\n");
104 /* the following releases the ipc, but note that this process
105 and all its children will still have access to the memory, its
106 just that the shmid is no longer valid for other shm calls. This
107 means we don't leave behind lots of shm segments after we exit
109 See Stevens "advanced programming in unix env" for details
111 shmctl(shmid, IPC_RMID, 0);
117 /********************************************************************
118 Ensure a connection is encrypted.
119 ********************************************************************/
121 static bool force_cli_encryption(struct cli_state *c,
122 const char *sharename)
125 uint32 caplow, caphigh;
128 if (!SERVER_HAS_UNIX_CIFS(c)) {
129 d_printf("Encryption required and "
130 "server that doesn't support "
131 "UNIX extensions - failing connect\n");
135 status = cli_unix_extensions_version(c, &major, &minor, &caplow,
137 if (!NT_STATUS_IS_OK(status)) {
138 d_printf("Encryption required and "
139 "can't get UNIX CIFS extensions "
140 "version from server: %s\n", nt_errstr(status));
144 if (!(caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)) {
145 d_printf("Encryption required and "
146 "share %s doesn't support "
147 "encryption.\n", sharename);
151 if (c->use_kerberos) {
152 status = cli_gss_smb_encryption_start(c);
154 status = cli_raw_ntlm_smb_encryption_start(c,
160 if (!NT_STATUS_IS_OK(status)) {
161 d_printf("Encryption required and "
162 "setup failed with error %s.\n",
171 static struct cli_state *open_nbt_connection(void)
173 struct nmb_name called, calling;
174 struct sockaddr_storage ss;
178 make_nmb_name(&calling, myname, 0x0);
179 make_nmb_name(&called , host, 0x20);
183 if (!(c = cli_initialise_ex(signing_state))) {
184 printf("Failed initialize cli_struct to connect with %s\n", host);
188 c->port = port_to_use;
190 status = cli_connect(c, host, &ss);
191 if (!NT_STATUS_IS_OK(status)) {
192 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
196 c->use_kerberos = use_kerberos;
198 c->timeout = 120000; /* set a really long timeout (2 minutes) */
199 if (use_oplocks) c->use_oplocks = True;
200 if (use_level_II_oplocks) c->use_level_II_oplocks = True;
202 if (!cli_session_request(c, &calling, &called)) {
204 * Well, that failed, try *SMBSERVER ...
205 * However, we must reconnect as well ...
207 status = cli_connect(c, host, &ss);
208 if (!NT_STATUS_IS_OK(status)) {
209 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
213 make_nmb_name(&called, "*SMBSERVER", 0x20);
214 if (!cli_session_request(c, &calling, &called)) {
215 printf("%s rejected the session\n",host);
216 printf("We tried with a called name of %s & %s\n",
226 /****************************************************************************
227 Send a corrupt session request. See rfc1002.txt 4.3 and 4.3.2.
228 ****************************************************************************/
230 static bool cli_bad_session_request(struct cli_state *cli,
231 struct nmb_name *calling, struct nmb_name *called)
238 memcpy(&(cli->calling), calling, sizeof(*calling));
239 memcpy(&(cli->called ), called , sizeof(*called ));
241 /* put in the destination name */
243 tmp = name_mangle(talloc_tos(), cli->called.name,
244 cli->called.name_type);
250 namelen = name_len((unsigned char *)tmp, talloc_get_size(tmp));
252 memcpy(p, tmp, namelen);
257 /* Deliberately corrupt the name len (first byte) */
262 tmp = name_mangle(talloc_tos(), cli->calling.name,
263 cli->calling.name_type);
269 namelen = name_len((unsigned char *)tmp, talloc_get_size(tmp));
271 memcpy(p, tmp, namelen);
275 /* Deliberately corrupt the name len (first byte) */
278 /* send a session request (RFC 1002) */
279 /* setup the packet length
280 * Remove four bytes from the length count, since the length
281 * field in the NBT Session Service header counts the number
282 * of bytes which follow. The cli_send_smb() function knows
283 * about this and accounts for those four bytes.
287 _smb_setlen(cli->outbuf,len);
288 SCVAL(cli->outbuf,0,0x81);
291 DEBUG(5,("Sent session request\n"));
293 if (!cli_receive_smb(cli))
296 if (CVAL(cli->inbuf,0) != 0x82) {
297 /* This is the wrong place to put the error... JRA. */
298 cli->rap_error = CVAL(cli->inbuf,4);
304 static struct cli_state *open_bad_nbt_connection(void)
306 struct nmb_name called, calling;
307 struct sockaddr_storage ss;
311 make_nmb_name(&calling, myname, 0x0);
312 make_nmb_name(&called , host, 0x20);
316 if (!(c = cli_initialise_ex(signing_state))) {
317 printf("Failed initialize cli_struct to connect with %s\n", host);
323 status = cli_connect(c, host, &ss);
324 if (!NT_STATUS_IS_OK(status)) {
325 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
329 c->timeout = 4000; /* set a short timeout (4 seconds) */
331 if (!cli_bad_session_request(c, &calling, &called)) {
332 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
340 /* Insert a NULL at the first separator of the given path and return a pointer
341 * to the remainder of the string.
344 terminate_path_at_separator(char * path)
352 if ((p = strchr_m(path, '/'))) {
357 if ((p = strchr_m(path, '\\'))) {
367 parse a //server/share type UNC name
369 bool smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
370 char **hostname, char **sharename)
374 *hostname = *sharename = NULL;
376 if (strncmp(unc_name, "\\\\", 2) &&
377 strncmp(unc_name, "//", 2)) {
381 *hostname = talloc_strdup(mem_ctx, &unc_name[2]);
382 p = terminate_path_at_separator(*hostname);
385 *sharename = talloc_strdup(mem_ctx, p);
386 terminate_path_at_separator(*sharename);
389 if (*hostname && *sharename) {
393 TALLOC_FREE(*hostname);
394 TALLOC_FREE(*sharename);
398 static bool torture_open_connection_share(struct cli_state **c,
399 const char *hostname,
400 const char *sharename)
406 flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
408 flags |= CLI_FULL_CONNECTION_OPLOCKS;
409 if (use_level_II_oplocks)
410 flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS;
412 status = cli_full_connection(c, myname,
413 hostname, NULL, port_to_use,
416 password, flags, signing_state);
417 if (!NT_STATUS_IS_OK(status)) {
418 printf("failed to open share connection: //%s/%s port:%d - %s\n",
419 hostname, sharename, port_to_use, nt_errstr(status));
423 (*c)->timeout = 120000; /* set a really long timeout (2 minutes) */
426 return force_cli_encryption(*c,
432 bool torture_open_connection(struct cli_state **c, int conn_index)
434 char **unc_list = NULL;
435 int num_unc_names = 0;
438 if (use_multishare_conn==True) {
440 unc_list = file_lines_load(multishare_conn_fname, &num_unc_names, 0, NULL);
441 if (!unc_list || num_unc_names <= 0) {
442 printf("Failed to load unc names list from '%s'\n", multishare_conn_fname);
446 if (!smbcli_parse_unc(unc_list[conn_index % num_unc_names],
448 printf("Failed to parse UNC name %s\n",
449 unc_list[conn_index % num_unc_names]);
450 TALLOC_FREE(unc_list);
454 result = torture_open_connection_share(c, h, s);
456 /* h, s were copied earlier */
457 TALLOC_FREE(unc_list);
461 return torture_open_connection_share(c, host, share);
464 bool torture_cli_session_setup2(struct cli_state *cli, uint16 *new_vuid)
466 uint16 old_vuid = cli->vuid;
467 fstring old_user_name;
468 size_t passlen = strlen(password);
472 fstrcpy(old_user_name, cli->user_name);
474 ret = NT_STATUS_IS_OK(cli_session_setup(cli, username,
478 *new_vuid = cli->vuid;
479 cli->vuid = old_vuid;
480 status = cli_set_username(cli, old_user_name);
481 if (!NT_STATUS_IS_OK(status)) {
488 bool torture_close_connection(struct cli_state *c)
493 status = cli_tdis(c);
494 if (!NT_STATUS_IS_OK(status)) {
495 printf("tdis failed (%s)\n", nt_errstr(status));
505 /* check if the server produced the expected error code */
506 static bool check_error(int line, struct cli_state *c,
507 uint8 eclass, uint32 ecode, NTSTATUS nterr)
509 if (cli_is_dos_error(c)) {
513 /* Check DOS error */
515 cli_dos_error(c, &cclass, &num);
517 if (eclass != cclass || ecode != num) {
518 printf("unexpected error code class=%d code=%d\n",
519 (int)cclass, (int)num);
520 printf(" expected %d/%d %s (line=%d)\n",
521 (int)eclass, (int)ecode, nt_errstr(nterr), line);
530 status = cli_nt_error(c);
532 if (NT_STATUS_V(nterr) != NT_STATUS_V(status)) {
533 printf("unexpected error code %s\n", nt_errstr(status));
534 printf(" expected %s (line=%d)\n", nt_errstr(nterr), line);
543 static bool wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len)
545 while (!cli_lock(c, fnum, offset, len, -1, WRITE_LOCK)) {
546 if (!check_error(__LINE__, c, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
552 static bool rw_torture(struct cli_state *c)
554 const char *lockfname = "\\torture.lck";
558 pid_t pid2, pid = getpid();
564 memset(buf, '\0', sizeof(buf));
566 status = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
568 if (!NT_STATUS_IS_OK(status)) {
569 status = cli_open(c, lockfname, O_RDWR, DENY_NONE, &fnum2);
571 if (!NT_STATUS_IS_OK(status)) {
572 printf("open of %s failed (%s)\n", lockfname, cli_errstr(c));
576 for (i=0;i<torture_numops;i++) {
577 unsigned n = (unsigned)sys_random()%10;
579 printf("%d\r", i); fflush(stdout);
581 slprintf(fname, sizeof(fstring) - 1, "\\torture.%u", n);
583 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
587 if (!NT_STATUS_IS_OK(cli_open(c, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL, &fnum))) {
588 printf("open failed (%s)\n", cli_errstr(c));
593 if (cli_write(c, fnum, 0, (char *)&pid, 0, sizeof(pid)) != sizeof(pid)) {
594 printf("write failed (%s)\n", cli_errstr(c));
599 if (cli_write(c, fnum, 0, (char *)buf,
600 sizeof(pid)+(j*sizeof(buf)),
601 sizeof(buf)) != sizeof(buf)) {
602 printf("write failed (%s)\n", cli_errstr(c));
609 if (cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid)) != sizeof(pid)) {
610 printf("read failed (%s)\n", cli_errstr(c));
615 printf("data corruption!\n");
619 if (!NT_STATUS_IS_OK(cli_close(c, fnum))) {
620 printf("close failed (%s)\n", cli_errstr(c));
624 if (!NT_STATUS_IS_OK(cli_unlink(c, fname, aSYSTEM | aHIDDEN))) {
625 printf("unlink failed (%s)\n", cli_errstr(c));
629 if (!NT_STATUS_IS_OK(cli_unlock(c, fnum2, n*sizeof(int), sizeof(int)))) {
630 printf("unlock failed (%s)\n", cli_errstr(c));
636 cli_unlink(c, lockfname, aSYSTEM | aHIDDEN);
643 static bool run_torture(int dummy)
645 struct cli_state *cli;
650 cli_sockopt(cli, sockops);
652 ret = rw_torture(cli);
654 if (!torture_close_connection(cli)) {
661 static bool rw_torture3(struct cli_state *c, char *lockfname)
663 uint16_t fnum = (uint16_t)-1;
668 unsigned countprev = 0;
671 NTSTATUS status = NT_STATUS_OK;
674 for (i = 0; i < sizeof(buf); i += sizeof(uint32))
676 SIVAL(buf, i, sys_random());
681 if (!NT_STATUS_IS_OK(cli_unlink(c, lockfname, aSYSTEM | aHIDDEN))) {
682 printf("unlink failed (%s) (normal, this file should not exist)\n", cli_errstr(c));
685 if (!NT_STATUS_IS_OK(cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
686 DENY_NONE, &fnum))) {
687 printf("first open read/write of %s failed (%s)\n",
688 lockfname, cli_errstr(c));
694 for (i = 0; i < 500 && fnum == (uint16_t)-1; i++)
696 status = cli_open(c, lockfname, O_RDONLY,
698 if (!NT_STATUS_IS_OK(status)) {
703 if (!NT_STATUS_IS_OK(status)) {
704 printf("second open read-only of %s failed (%s)\n",
705 lockfname, cli_errstr(c));
711 for (count = 0; count < sizeof(buf); count += sent)
713 if (count >= countprev) {
714 printf("%d %8d\r", i, count);
717 countprev += (sizeof(buf) / 20);
722 sent = ((unsigned)sys_random()%(20))+ 1;
723 if (sent > sizeof(buf) - count)
725 sent = sizeof(buf) - count;
728 if (cli_write(c, fnum, 0, buf+count, count, (size_t)sent) != sent) {
729 printf("write failed (%s)\n", cli_errstr(c));
735 sent = cli_read(c, fnum, buf_rd+count, count,
739 printf("read failed offset:%d size:%ld (%s)\n",
740 count, (unsigned long)sizeof(buf)-count,
747 if (memcmp(buf_rd+count, buf+count, sent) != 0)
749 printf("read/write compare failed\n");
750 printf("offset: %d req %ld recvd %ld\n", count, (unsigned long)sizeof(buf)-count, (unsigned long)sent);
759 if (!NT_STATUS_IS_OK(cli_close(c, fnum))) {
760 printf("close failed (%s)\n", cli_errstr(c));
767 static bool rw_torture2(struct cli_state *c1, struct cli_state *c2)
769 const char *lockfname = "\\torture2.lck";
778 if (!NT_STATUS_IS_OK(cli_unlink(c1, lockfname, aSYSTEM | aHIDDEN))) {
779 printf("unlink failed (%s) (normal, this file should not exist)\n", cli_errstr(c1));
782 if (!NT_STATUS_IS_OK(cli_open(c1, lockfname, O_RDWR | O_CREAT | O_EXCL,
783 DENY_NONE, &fnum1))) {
784 printf("first open read/write of %s failed (%s)\n",
785 lockfname, cli_errstr(c1));
788 if (!NT_STATUS_IS_OK(cli_open(c2, lockfname, O_RDONLY,
789 DENY_NONE, &fnum2))) {
790 printf("second open read-only of %s failed (%s)\n",
791 lockfname, cli_errstr(c2));
792 cli_close(c1, fnum1);
796 for (i=0;i<torture_numops;i++)
798 size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
800 printf("%d\r", i); fflush(stdout);
803 generate_random_buffer((unsigned char *)buf, buf_size);
805 if (cli_write(c1, fnum1, 0, buf, 0, buf_size) != buf_size) {
806 printf("write failed (%s)\n", cli_errstr(c1));
811 if ((bytes_read = cli_read(c2, fnum2, buf_rd, 0, buf_size)) != buf_size) {
812 printf("read failed (%s)\n", cli_errstr(c2));
813 printf("read %d, expected %ld\n", (int)bytes_read,
814 (unsigned long)buf_size);
819 if (memcmp(buf_rd, buf, buf_size) != 0)
821 printf("read/write compare failed\n");
827 if (!NT_STATUS_IS_OK(cli_close(c2, fnum2))) {
828 printf("close failed (%s)\n", cli_errstr(c2));
831 if (!NT_STATUS_IS_OK(cli_close(c1, fnum1))) {
832 printf("close failed (%s)\n", cli_errstr(c1));
836 if (!NT_STATUS_IS_OK(cli_unlink(c1, lockfname, aSYSTEM | aHIDDEN))) {
837 printf("unlink failed (%s)\n", cli_errstr(c1));
844 static bool run_readwritetest(int dummy)
846 struct cli_state *cli1, *cli2;
847 bool test1, test2 = False;
849 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
852 cli_sockopt(cli1, sockops);
853 cli_sockopt(cli2, sockops);
855 printf("starting readwritetest\n");
857 test1 = rw_torture2(cli1, cli2);
858 printf("Passed readwritetest v1: %s\n", BOOLSTR(test1));
861 test2 = rw_torture2(cli1, cli1);
862 printf("Passed readwritetest v2: %s\n", BOOLSTR(test2));
865 if (!torture_close_connection(cli1)) {
869 if (!torture_close_connection(cli2)) {
873 return (test1 && test2);
876 static bool run_readwritemulti(int dummy)
878 struct cli_state *cli;
883 cli_sockopt(cli, sockops);
885 printf("run_readwritemulti: fname %s\n", randomfname);
886 test = rw_torture3(cli, randomfname);
888 if (!torture_close_connection(cli)) {
895 static bool run_readwritelarge_internal(int max_xmit_k)
897 static struct cli_state *cli1;
899 const char *lockfname = "\\large.dat";
904 if (!torture_open_connection(&cli1, 0)) {
907 cli_sockopt(cli1, sockops);
908 memset(buf,'\0',sizeof(buf));
910 cli1->max_xmit = max_xmit_k*1024;
912 if (signing_state == Required) {
913 /* Horrible cheat to force
914 multiple signed outstanding
915 packets against a Samba server.
917 cli1->is_samba = false;
920 printf("starting readwritelarge_internal\n");
922 cli_unlink(cli1, lockfname, aSYSTEM | aHIDDEN);
924 if (!NT_STATUS_IS_OK(cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE, &fnum1))) {
925 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
929 cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf));
931 if (!NT_STATUS_IS_OK(cli_qfileinfo_basic(
932 cli1, fnum1, NULL, &fsize, NULL, NULL,
933 NULL, NULL, NULL))) {
934 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
938 if (fsize == sizeof(buf))
939 printf("readwritelarge_internal test 1 succeeded (size = %lx)\n",
940 (unsigned long)fsize);
942 printf("readwritelarge_internal test 1 failed (size = %lx)\n",
943 (unsigned long)fsize);
947 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
948 printf("close failed (%s)\n", cli_errstr(cli1));
952 if (!NT_STATUS_IS_OK(cli_unlink(cli1, lockfname, aSYSTEM | aHIDDEN))) {
953 printf("unlink failed (%s)\n", cli_errstr(cli1));
957 if (!NT_STATUS_IS_OK(cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE, &fnum1))) {
958 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
962 cli1->max_xmit = 4*1024;
964 cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf), NULL);
966 if (!NT_STATUS_IS_OK(cli_qfileinfo_basic(
967 cli1, fnum1, NULL, &fsize, NULL, NULL,
968 NULL, NULL, NULL))) {
969 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
973 if (fsize == sizeof(buf))
974 printf("readwritelarge_internal test 2 succeeded (size = %lx)\n",
975 (unsigned long)fsize);
977 printf("readwritelarge_internal test 2 failed (size = %lx)\n",
978 (unsigned long)fsize);
983 /* ToDo - set allocation. JRA */
984 if(!cli_set_allocation_size(cli1, fnum1, 0)) {
985 printf("set allocation size to zero failed (%s)\n", cli_errstr(&cli1));
988 if (!cli_qfileinfo_basic(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL,
990 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
994 printf("readwritelarge test 3 (truncate test) succeeded (size = %x)\n", fsize);
997 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
998 printf("close failed (%s)\n", cli_errstr(cli1));
1002 if (!torture_close_connection(cli1)) {
1008 static bool run_readwritelarge(int dummy)
1010 return run_readwritelarge_internal(128);
1013 static bool run_readwritelarge_signtest(int dummy)
1016 signing_state = Required;
1017 ret = run_readwritelarge_internal(2);
1018 signing_state = Undefined;
1025 #define ival(s) strtol(s, NULL, 0)
1027 /* run a test that simulates an approximate netbench client load */
1028 static bool run_netbench(int client)
1030 struct cli_state *cli;
1035 const char *params[20];
1036 bool correct = True;
1042 cli_sockopt(cli, sockops);
1046 slprintf(cname,sizeof(cname)-1, "client%d", client);
1048 f = fopen(client_txt, "r");
1055 while (fgets(line, sizeof(line)-1, f)) {
1059 line[strlen(line)-1] = 0;
1061 /* printf("[%d] %s\n", line_count, line); */
1063 all_string_sub(line,"client1", cname, sizeof(line));
1065 /* parse the command parameters */
1066 params[0] = strtok_r(line, " ", &saveptr);
1068 while (params[i]) params[++i] = strtok_r(NULL, " ", &saveptr);
1072 if (i < 2) continue;
1074 if (!strncmp(params[0],"SMB", 3)) {
1075 printf("ERROR: You are using a dbench 1 load file\n");
1079 if (!strcmp(params[0],"NTCreateX")) {
1080 nb_createx(params[1], ival(params[2]), ival(params[3]),
1082 } else if (!strcmp(params[0],"Close")) {
1083 nb_close(ival(params[1]));
1084 } else if (!strcmp(params[0],"Rename")) {
1085 nb_rename(params[1], params[2]);
1086 } else if (!strcmp(params[0],"Unlink")) {
1087 nb_unlink(params[1]);
1088 } else if (!strcmp(params[0],"Deltree")) {
1089 nb_deltree(params[1]);
1090 } else if (!strcmp(params[0],"Rmdir")) {
1091 nb_rmdir(params[1]);
1092 } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
1093 nb_qpathinfo(params[1]);
1094 } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
1095 nb_qfileinfo(ival(params[1]));
1096 } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
1097 nb_qfsinfo(ival(params[1]));
1098 } else if (!strcmp(params[0],"FIND_FIRST")) {
1099 nb_findfirst(params[1]);
1100 } else if (!strcmp(params[0],"WriteX")) {
1101 nb_writex(ival(params[1]),
1102 ival(params[2]), ival(params[3]), ival(params[4]));
1103 } else if (!strcmp(params[0],"ReadX")) {
1104 nb_readx(ival(params[1]),
1105 ival(params[2]), ival(params[3]), ival(params[4]));
1106 } else if (!strcmp(params[0],"Flush")) {
1107 nb_flush(ival(params[1]));
1109 printf("Unknown operation %s\n", params[0]);
1117 if (!torture_close_connection(cli)) {
1125 /* run a test that simulates an approximate netbench client load */
1126 static bool run_nbench(int dummy)
1129 bool correct = True;
1135 signal(SIGALRM, nb_alarm);
1137 t = create_procs(run_netbench, &correct);
1140 printf("\nThroughput %g MB/sec\n",
1141 1.0e-6 * nbio_total() / t);
1147 This test checks for two things:
1149 1) correct support for retaining locks over a close (ie. the server
1150 must not use posix semantics)
1151 2) support for lock timeouts
1153 static bool run_locktest1(int dummy)
1155 struct cli_state *cli1, *cli2;
1156 const char *fname = "\\lockt1.lck";
1157 uint16_t fnum1, fnum2, fnum3;
1159 unsigned lock_timeout;
1161 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1164 cli_sockopt(cli1, sockops);
1165 cli_sockopt(cli2, sockops);
1167 printf("starting locktest1\n");
1169 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1171 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1172 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1175 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum2))) {
1176 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli1));
1179 if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum3))) {
1180 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli2));
1184 if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
1185 printf("lock1 failed (%s)\n", cli_errstr(cli1));
1190 if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
1191 printf("lock2 succeeded! This is a locking bug\n");
1194 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1195 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1199 lock_timeout = (1 + (random() % 20));
1200 printf("Testing lock timeout with timeout=%u\n", lock_timeout);
1202 if (cli_lock(cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK)) {
1203 printf("lock3 succeeded! This is a locking bug\n");
1206 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1207 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1211 if (ABS(t2 - t1) < lock_timeout-1) {
1212 printf("error: This server appears not to support timed lock requests\n");
1215 printf("server slept for %u seconds for a %u second timeout\n",
1216 (unsigned int)(t2-t1), lock_timeout);
1218 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
1219 printf("close1 failed (%s)\n", cli_errstr(cli1));
1223 if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
1224 printf("lock4 succeeded! This is a locking bug\n");
1227 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1228 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1231 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
1232 printf("close2 failed (%s)\n", cli_errstr(cli1));
1236 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum3))) {
1237 printf("close3 failed (%s)\n", cli_errstr(cli2));
1241 if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
1242 printf("unlink failed (%s)\n", cli_errstr(cli1));
1247 if (!torture_close_connection(cli1)) {
1251 if (!torture_close_connection(cli2)) {
1255 printf("Passed locktest1\n");
1260 this checks to see if a secondary tconx can use open files from an
1263 static bool run_tcon_test(int dummy)
1265 static struct cli_state *cli;
1266 const char *fname = "\\tcontest.tmp";
1268 uint16 cnum1, cnum2, cnum3;
1269 uint16 vuid1, vuid2;
1274 memset(buf, '\0', sizeof(buf));
1276 if (!torture_open_connection(&cli, 0)) {
1279 cli_sockopt(cli, sockops);
1281 printf("starting tcontest\n");
1283 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
1285 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1286 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1293 if (cli_write(cli, fnum1, 0, buf, 130, 4) != 4) {
1294 printf("initial write failed (%s)", cli_errstr(cli));
1298 status = cli_tcon_andx(cli, share, "?????",
1299 password, strlen(password)+1);
1300 if (!NT_STATUS_IS_OK(status)) {
1301 printf("%s refused 2nd tree connect (%s)\n", host,
1308 cnum3 = MAX(cnum1, cnum2) + 1; /* any invalid number */
1309 vuid2 = cli->vuid + 1;
1311 /* try a write with the wrong tid */
1314 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1315 printf("* server allows write with wrong TID\n");
1318 printf("server fails write with wrong TID : %s\n", cli_errstr(cli));
1322 /* try a write with an invalid tid */
1325 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1326 printf("* server allows write with invalid TID\n");
1329 printf("server fails write with invalid TID : %s\n", cli_errstr(cli));
1332 /* try a write with an invalid vuid */
1336 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1337 printf("* server allows write with invalid VUID\n");
1340 printf("server fails write with invalid VUID : %s\n", cli_errstr(cli));
1346 if (!NT_STATUS_IS_OK(cli_close(cli, fnum1))) {
1347 printf("close failed (%s)\n", cli_errstr(cli));
1353 status = cli_tdis(cli);
1354 if (!NT_STATUS_IS_OK(status)) {
1355 printf("secondary tdis failed (%s)\n", nt_errstr(status));
1361 if (!torture_close_connection(cli)) {
1370 checks for old style tcon support
1372 static bool run_tcon2_test(int dummy)
1374 static struct cli_state *cli;
1375 uint16 cnum, max_xmit;
1379 if (!torture_open_connection(&cli, 0)) {
1382 cli_sockopt(cli, sockops);
1384 printf("starting tcon2 test\n");
1386 if (asprintf(&service, "\\\\%s\\%s", host, share) == -1) {
1390 status = cli_raw_tcon(cli, service, password, "?????", &max_xmit, &cnum);
1394 if (!NT_STATUS_IS_OK(status)) {
1395 printf("tcon2 failed : %s\n", nt_errstr(status));
1397 printf("tcon OK : max_xmit=%d cnum=%d tid=%d\n",
1398 (int)max_xmit, (int)cnum, SVAL(cli->inbuf, smb_tid));
1401 if (!torture_close_connection(cli)) {
1405 printf("Passed tcon2 test\n");
1409 static bool tcon_devtest(struct cli_state *cli,
1410 const char *myshare, const char *devtype,
1411 const char *return_devtype,
1412 NTSTATUS expected_error)
1417 status = cli_tcon_andx(cli, myshare, devtype,
1418 password, strlen(password)+1);
1420 if (NT_STATUS_IS_OK(expected_error)) {
1421 if (NT_STATUS_IS_OK(status)) {
1422 if (strcmp(cli->dev, return_devtype) == 0) {
1425 printf("tconX to share %s with type %s "
1426 "succeeded but returned the wrong "
1427 "device type (got [%s] but should have got [%s])\n",
1428 myshare, devtype, cli->dev, return_devtype);
1432 printf("tconX to share %s with type %s "
1433 "should have succeeded but failed\n",
1439 if (NT_STATUS_IS_OK(status)) {
1440 printf("tconx to share %s with type %s "
1441 "should have failed but succeeded\n",
1445 if (NT_STATUS_EQUAL(cli_nt_error(cli),
1449 printf("Returned unexpected error\n");
1458 checks for correct tconX support
1460 static bool run_tcon_devtype_test(int dummy)
1462 static struct cli_state *cli1 = NULL;
1467 status = cli_full_connection(&cli1, myname,
1468 host, NULL, port_to_use,
1470 username, workgroup,
1471 password, flags, signing_state);
1473 if (!NT_STATUS_IS_OK(status)) {
1474 printf("could not open connection\n");
1478 if (!tcon_devtest(cli1, "IPC$", "A:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1481 if (!tcon_devtest(cli1, "IPC$", "?????", "IPC", NT_STATUS_OK))
1484 if (!tcon_devtest(cli1, "IPC$", "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1487 if (!tcon_devtest(cli1, "IPC$", "IPC", "IPC", NT_STATUS_OK))
1490 if (!tcon_devtest(cli1, "IPC$", "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1493 if (!tcon_devtest(cli1, share, "A:", "A:", NT_STATUS_OK))
1496 if (!tcon_devtest(cli1, share, "?????", "A:", NT_STATUS_OK))
1499 if (!tcon_devtest(cli1, share, "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1502 if (!tcon_devtest(cli1, share, "IPC", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1505 if (!tcon_devtest(cli1, share, "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1511 printf("Passed tcondevtest\n");
1518 This test checks that
1520 1) the server supports multiple locking contexts on the one SMB
1521 connection, distinguished by PID.
1523 2) the server correctly fails overlapping locks made by the same PID (this
1524 goes against POSIX behaviour, which is why it is tricky to implement)
1526 3) the server denies unlock requests by an incorrect client PID
1528 static bool run_locktest2(int dummy)
1530 static struct cli_state *cli;
1531 const char *fname = "\\lockt2.lck";
1532 uint16_t fnum1, fnum2, fnum3;
1533 bool correct = True;
1535 if (!torture_open_connection(&cli, 0)) {
1539 cli_sockopt(cli, sockops);
1541 printf("starting locktest2\n");
1543 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
1547 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1548 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1552 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum2))) {
1553 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli));
1559 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum3))) {
1560 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli));
1566 if (!cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1567 printf("lock1 failed (%s)\n", cli_errstr(cli));
1571 if (cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1572 printf("WRITE lock1 succeeded! This is a locking bug\n");
1575 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1576 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1579 if (cli_lock(cli, fnum2, 0, 4, 0, WRITE_LOCK)) {
1580 printf("WRITE lock2 succeeded! This is a locking bug\n");
1583 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1584 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1587 if (cli_lock(cli, fnum2, 0, 4, 0, READ_LOCK)) {
1588 printf("READ lock2 succeeded! This is a locking bug\n");
1591 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1592 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1595 if (!cli_lock(cli, fnum1, 100, 4, 0, WRITE_LOCK)) {
1596 printf("lock at 100 failed (%s)\n", cli_errstr(cli));
1599 if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 100, 4))) {
1600 printf("unlock at 100 succeeded! This is a locking bug\n");
1604 if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 0, 4))) {
1605 printf("unlock1 succeeded! This is a locking bug\n");
1608 if (!check_error(__LINE__, cli,
1610 NT_STATUS_RANGE_NOT_LOCKED)) return False;
1613 if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 0, 8))) {
1614 printf("unlock2 succeeded! This is a locking bug\n");
1617 if (!check_error(__LINE__, cli,
1619 NT_STATUS_RANGE_NOT_LOCKED)) return False;
1622 if (cli_lock(cli, fnum3, 0, 4, 0, WRITE_LOCK)) {
1623 printf("lock3 succeeded! This is a locking bug\n");
1626 if (!check_error(__LINE__, cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
1631 if (!NT_STATUS_IS_OK(cli_close(cli, fnum1))) {
1632 printf("close1 failed (%s)\n", cli_errstr(cli));
1636 if (!NT_STATUS_IS_OK(cli_close(cli, fnum2))) {
1637 printf("close2 failed (%s)\n", cli_errstr(cli));
1641 if (!NT_STATUS_IS_OK(cli_close(cli, fnum3))) {
1642 printf("close3 failed (%s)\n", cli_errstr(cli));
1646 if (!torture_close_connection(cli)) {
1650 printf("locktest2 finished\n");
1657 This test checks that
1659 1) the server supports the full offset range in lock requests
1661 static bool run_locktest3(int dummy)
1663 static struct cli_state *cli1, *cli2;
1664 const char *fname = "\\lockt3.lck";
1665 uint16_t fnum1, fnum2;
1668 bool correct = True;
1670 #define NEXT_OFFSET offset += (~(uint32)0) / torture_numops
1672 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1675 cli_sockopt(cli1, sockops);
1676 cli_sockopt(cli2, sockops);
1678 printf("starting locktest3\n");
1680 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1682 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1683 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1686 if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2))) {
1687 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli2));
1691 for (offset=i=0;i<torture_numops;i++) {
1693 if (!cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1694 printf("lock1 %d failed (%s)\n",
1700 if (!cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1701 printf("lock2 %d failed (%s)\n",
1708 for (offset=i=0;i<torture_numops;i++) {
1711 if (cli_lock(cli1, fnum1, offset-2, 1, 0, WRITE_LOCK)) {
1712 printf("error: lock1 %d succeeded!\n", i);
1716 if (cli_lock(cli2, fnum2, offset-1, 1, 0, WRITE_LOCK)) {
1717 printf("error: lock2 %d succeeded!\n", i);
1721 if (cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1722 printf("error: lock3 %d succeeded!\n", i);
1726 if (cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1727 printf("error: lock4 %d succeeded!\n", i);
1732 for (offset=i=0;i<torture_numops;i++) {
1735 if (!NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, offset-1, 1))) {
1736 printf("unlock1 %d failed (%s)\n",
1742 if (!NT_STATUS_IS_OK(cli_unlock(cli2, fnum2, offset-2, 1))) {
1743 printf("unlock2 %d failed (%s)\n",
1750 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
1751 printf("close1 failed (%s)\n", cli_errstr(cli1));
1755 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
1756 printf("close2 failed (%s)\n", cli_errstr(cli2));
1760 if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
1761 printf("unlink failed (%s)\n", cli_errstr(cli1));
1765 if (!torture_close_connection(cli1)) {
1769 if (!torture_close_connection(cli2)) {
1773 printf("finished locktest3\n");
1778 #define EXPECTED(ret, v) if ((ret) != (v)) { \
1779 printf("** "); correct = False; \
1783 looks at overlapping locks
1785 static bool run_locktest4(int dummy)
1787 static struct cli_state *cli1, *cli2;
1788 const char *fname = "\\lockt4.lck";
1789 uint16_t fnum1, fnum2, f;
1792 bool correct = True;
1794 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1798 cli_sockopt(cli1, sockops);
1799 cli_sockopt(cli2, sockops);
1801 printf("starting locktest4\n");
1803 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1805 cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1806 cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1808 memset(buf, 0, sizeof(buf));
1810 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1811 printf("Failed to create file\n");
1816 ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1817 cli_lock(cli1, fnum1, 2, 4, 0, WRITE_LOCK);
1818 EXPECTED(ret, False);
1819 printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
1821 ret = cli_lock(cli1, fnum1, 10, 4, 0, READ_LOCK) &&
1822 cli_lock(cli1, fnum1, 12, 4, 0, READ_LOCK);
1823 EXPECTED(ret, True);
1824 printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
1826 ret = cli_lock(cli1, fnum1, 20, 4, 0, WRITE_LOCK) &&
1827 cli_lock(cli2, fnum2, 22, 4, 0, WRITE_LOCK);
1828 EXPECTED(ret, False);
1829 printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
1831 ret = cli_lock(cli1, fnum1, 30, 4, 0, READ_LOCK) &&
1832 cli_lock(cli2, fnum2, 32, 4, 0, READ_LOCK);
1833 EXPECTED(ret, True);
1834 printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
1836 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 40, 4, 0, WRITE_LOCK)) &&
1837 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 42, 4, 0, WRITE_LOCK));
1838 EXPECTED(ret, False);
1839 printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
1841 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 50, 4, 0, READ_LOCK)) &&
1842 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 52, 4, 0, READ_LOCK));
1843 EXPECTED(ret, True);
1844 printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
1846 ret = cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK) &&
1847 cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK);
1848 EXPECTED(ret, True);
1849 printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
1851 ret = cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK) &&
1852 cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK);
1853 EXPECTED(ret, False);
1854 printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
1856 ret = cli_lock(cli1, fnum1, 80, 4, 0, READ_LOCK) &&
1857 cli_lock(cli1, fnum1, 80, 4, 0, WRITE_LOCK);
1858 EXPECTED(ret, False);
1859 printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
1861 ret = cli_lock(cli1, fnum1, 90, 4, 0, WRITE_LOCK) &&
1862 cli_lock(cli1, fnum1, 90, 4, 0, READ_LOCK);
1863 EXPECTED(ret, True);
1864 printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1866 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 100, 4, 0, WRITE_LOCK)) &&
1867 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 100, 4, 0, READ_LOCK));
1868 EXPECTED(ret, False);
1869 printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1871 ret = cli_lock(cli1, fnum1, 110, 4, 0, READ_LOCK) &&
1872 cli_lock(cli1, fnum1, 112, 4, 0, READ_LOCK) &&
1873 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 110, 6));
1874 EXPECTED(ret, False);
1875 printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
1878 ret = cli_lock(cli1, fnum1, 120, 4, 0, WRITE_LOCK) &&
1879 (cli_read(cli2, fnum2, buf, 120, 4) == 4);
1880 EXPECTED(ret, False);
1881 printf("this server %s strict write locking\n", ret?"doesn't do":"does");
1883 ret = cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK) &&
1884 (cli_write(cli2, fnum2, 0, buf, 130, 4) == 4);
1885 EXPECTED(ret, False);
1886 printf("this server %s strict read locking\n", ret?"doesn't do":"does");
1889 ret = cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1890 cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1891 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4)) &&
1892 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4));
1893 EXPECTED(ret, True);
1894 printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
1897 ret = cli_lock(cli1, fnum1, 150, 4, 0, WRITE_LOCK) &&
1898 cli_lock(cli1, fnum1, 150, 4, 0, READ_LOCK) &&
1899 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4)) &&
1900 (cli_read(cli2, fnum2, buf, 150, 4) == 4) &&
1901 !(cli_write(cli2, fnum2, 0, buf, 150, 4) == 4) &&
1902 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4));
1903 EXPECTED(ret, True);
1904 printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
1906 ret = cli_lock(cli1, fnum1, 160, 4, 0, READ_LOCK) &&
1907 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 160, 4)) &&
1908 (cli_write(cli2, fnum2, 0, buf, 160, 4) == 4) &&
1909 (cli_read(cli2, fnum2, buf, 160, 4) == 4);
1910 EXPECTED(ret, True);
1911 printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
1913 ret = cli_lock(cli1, fnum1, 170, 4, 0, WRITE_LOCK) &&
1914 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 170, 4)) &&
1915 (cli_write(cli2, fnum2, 0, buf, 170, 4) == 4) &&
1916 (cli_read(cli2, fnum2, buf, 170, 4) == 4);
1917 EXPECTED(ret, True);
1918 printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
1920 ret = cli_lock(cli1, fnum1, 190, 4, 0, WRITE_LOCK) &&
1921 cli_lock(cli1, fnum1, 190, 4, 0, READ_LOCK) &&
1922 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 190, 4)) &&
1923 !(cli_write(cli2, fnum2, 0, buf, 190, 4) == 4) &&
1924 (cli_read(cli2, fnum2, buf, 190, 4) == 4);
1925 EXPECTED(ret, True);
1926 printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
1928 cli_close(cli1, fnum1);
1929 cli_close(cli2, fnum2);
1930 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
1931 cli_open(cli1, fname, O_RDWR, DENY_NONE, &f);
1932 ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1933 cli_lock(cli1, f, 0, 1, 0, READ_LOCK) &&
1934 NT_STATUS_IS_OK(cli_close(cli1, fnum1)) &&
1935 NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1)) &&
1936 cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1938 cli_close(cli1, fnum1);
1939 EXPECTED(ret, True);
1940 printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
1943 cli_close(cli1, fnum1);
1944 cli_close(cli2, fnum2);
1945 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1946 torture_close_connection(cli1);
1947 torture_close_connection(cli2);
1949 printf("finished locktest4\n");
1954 looks at lock upgrade/downgrade.
1956 static bool run_locktest5(int dummy)
1958 static struct cli_state *cli1, *cli2;
1959 const char *fname = "\\lockt5.lck";
1960 uint16_t fnum1, fnum2, fnum3;
1963 bool correct = True;
1965 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1969 cli_sockopt(cli1, sockops);
1970 cli_sockopt(cli2, sockops);
1972 printf("starting locktest5\n");
1974 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1976 cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1977 cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1978 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum3);
1980 memset(buf, 0, sizeof(buf));
1982 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1983 printf("Failed to create file\n");
1988 /* Check for NT bug... */
1989 ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1990 cli_lock(cli1, fnum3, 0, 1, 0, READ_LOCK);
1991 cli_close(cli1, fnum1);
1992 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
1993 ret = cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1994 EXPECTED(ret, True);
1995 printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
1996 cli_close(cli1, fnum1);
1997 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
1998 cli_unlock(cli1, fnum3, 0, 1);
2000 ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
2001 cli_lock(cli1, fnum1, 1, 1, 0, READ_LOCK);
2002 EXPECTED(ret, True);
2003 printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
2005 ret = cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
2006 EXPECTED(ret, False);
2008 printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
2010 /* Unlock the process 2 lock. */
2011 cli_unlock(cli2, fnum2, 0, 4);
2013 ret = cli_lock(cli1, fnum3, 0, 4, 0, READ_LOCK);
2014 EXPECTED(ret, False);
2016 printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
2018 /* Unlock the process 1 fnum3 lock. */
2019 cli_unlock(cli1, fnum3, 0, 4);
2021 /* Stack 2 more locks here. */
2022 ret = cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK) &&
2023 cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK);
2025 EXPECTED(ret, True);
2026 printf("the same process %s stack read locks\n", ret?"can":"cannot");
2028 /* Unlock the first process lock, then check this was the WRITE lock that was
2031 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
2032 cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
2034 EXPECTED(ret, True);
2035 printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
2037 /* Unlock the process 2 lock. */
2038 cli_unlock(cli2, fnum2, 0, 4);
2040 /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
2042 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 1, 1)) &&
2043 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
2044 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
2046 EXPECTED(ret, True);
2047 printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
2049 /* Ensure the next unlock fails. */
2050 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
2051 EXPECTED(ret, False);
2052 printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
2054 /* Ensure connection 2 can get a write lock. */
2055 ret = cli_lock(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
2056 EXPECTED(ret, True);
2058 printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
2062 cli_close(cli1, fnum1);
2063 cli_close(cli2, fnum2);
2064 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2065 if (!torture_close_connection(cli1)) {
2068 if (!torture_close_connection(cli2)) {
2072 printf("finished locktest5\n");
2078 tries the unusual lockingX locktype bits
2080 static bool run_locktest6(int dummy)
2082 static struct cli_state *cli;
2083 const char *fname[1] = { "\\lock6.txt" };
2088 if (!torture_open_connection(&cli, 0)) {
2092 cli_sockopt(cli, sockops);
2094 printf("starting locktest6\n");
2097 printf("Testing %s\n", fname[i]);
2099 cli_unlink(cli, fname[i], aSYSTEM | aHIDDEN);
2101 cli_open(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
2102 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
2103 cli_close(cli, fnum);
2104 printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
2106 cli_open(cli, fname[i], O_RDWR, DENY_NONE, &fnum);
2107 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
2108 cli_close(cli, fnum);
2109 printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
2111 cli_unlink(cli, fname[i], aSYSTEM | aHIDDEN);
2114 torture_close_connection(cli);
2116 printf("finished locktest6\n");
2120 static bool run_locktest7(int dummy)
2122 struct cli_state *cli1;
2123 const char *fname = "\\lockt7.lck";
2126 bool correct = False;
2128 if (!torture_open_connection(&cli1, 0)) {
2132 cli_sockopt(cli1, sockops);
2134 printf("starting locktest7\n");
2136 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2138 cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2140 memset(buf, 0, sizeof(buf));
2142 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
2143 printf("Failed to create file\n");
2147 cli_setpid(cli1, 1);
2149 if (!cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK)) {
2150 printf("Unable to apply read lock on range 130:4, error was %s\n", cli_errstr(cli1));
2153 printf("pid1 successfully locked range 130:4 for READ\n");
2156 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2157 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2160 printf("pid1 successfully read the range 130:4\n");
2163 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2164 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2165 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2166 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2170 printf("pid1 successfully wrote to the range 130:4 (should be denied)\n");
2174 cli_setpid(cli1, 2);
2176 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2177 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2179 printf("pid2 successfully read the range 130:4\n");
2182 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2183 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2184 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2185 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2189 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2193 cli_setpid(cli1, 1);
2194 cli_unlock(cli1, fnum1, 130, 4);
2196 if (!cli_lock(cli1, fnum1, 130, 4, 0, WRITE_LOCK)) {
2197 printf("Unable to apply write lock on range 130:4, error was %s\n", cli_errstr(cli1));
2200 printf("pid1 successfully locked range 130:4 for WRITE\n");
2203 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2204 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2207 printf("pid1 successfully read the range 130:4\n");
2210 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2211 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2214 printf("pid1 successfully wrote to the range 130:4\n");
2217 cli_setpid(cli1, 2);
2219 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2220 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2221 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2222 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2226 printf("pid2 successfully read the range 130:4 (should be denied)\n");
2230 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2231 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2232 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2233 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2237 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2241 cli_unlock(cli1, fnum1, 130, 0);
2245 cli_close(cli1, fnum1);
2246 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2247 torture_close_connection(cli1);
2249 printf("finished locktest7\n");
2254 * This demonstrates a problem with our use of GPFS share modes: A file
2255 * descriptor sitting in the pending close queue holding a GPFS share mode
2256 * blocks opening a file another time. Happens with Word 2007 temp files.
2257 * With "posix locking = yes" and "gpfs:sharemodes = yes" enabled, the third
2258 * open is denied with NT_STATUS_SHARING_VIOLATION.
2261 static bool run_locktest8(int dummy)
2263 struct cli_state *cli1;
2264 const char *fname = "\\lockt8.lck";
2265 uint16_t fnum1, fnum2;
2267 bool correct = False;
2270 if (!torture_open_connection(&cli1, 0)) {
2274 cli_sockopt(cli1, sockops);
2276 printf("starting locktest8\n");
2278 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2280 status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_WRITE,
2282 if (!NT_STATUS_IS_OK(status)) {
2283 d_fprintf(stderr, "cli_open returned %s\n", cli_errstr(cli1));
2287 memset(buf, 0, sizeof(buf));
2289 status = cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum2);
2290 if (!NT_STATUS_IS_OK(status)) {
2291 d_fprintf(stderr, "cli_open second time returned %s\n",
2296 if (!cli_lock(cli1, fnum2, 1, 1, 0, READ_LOCK)) {
2297 printf("Unable to apply read lock on range 1:1, error was "
2298 "%s\n", cli_errstr(cli1));
2302 status = cli_close(cli1, fnum1);
2303 if (!NT_STATUS_IS_OK(status)) {
2304 d_fprintf(stderr, "cli_close(fnum1) %s\n", cli_errstr(cli1));
2308 status = cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2309 if (!NT_STATUS_IS_OK(status)) {
2310 d_fprintf(stderr, "cli_open third time returned %s\n",
2318 cli_close(cli1, fnum1);
2319 cli_close(cli1, fnum2);
2320 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2321 torture_close_connection(cli1);
2323 printf("finished locktest8\n");
2328 * This test is designed to be run in conjunction with
2329 * external NFS or POSIX locks taken in the filesystem.
2330 * It checks that the smbd server will block until the
2331 * lock is released and then acquire it. JRA.
2334 static bool got_alarm;
2335 static int alarm_fd;
2337 static void alarm_handler(int dummy)
2342 static void alarm_handler_parent(int dummy)
2347 static void do_local_lock(int read_fd, int write_fd)
2352 const char *local_pathname = NULL;
2355 local_pathname = talloc_asprintf(talloc_tos(),
2356 "%s/lockt9.lck", local_path);
2357 if (!local_pathname) {
2358 printf("child: alloc fail\n");
2362 unlink(local_pathname);
2363 fd = open(local_pathname, O_RDWR|O_CREAT, 0666);
2365 printf("child: open of %s failed %s.\n",
2366 local_pathname, strerror(errno));
2370 /* Now take a fcntl lock. */
2371 lock.l_type = F_WRLCK;
2372 lock.l_whence = SEEK_SET;
2375 lock.l_pid = getpid();
2377 ret = fcntl(fd,F_SETLK,&lock);
2379 printf("child: failed to get lock 0:4 on file %s. Error %s\n",
2380 local_pathname, strerror(errno));
2383 printf("child: got lock 0:4 on file %s.\n",
2388 CatchSignal(SIGALRM, alarm_handler);
2390 /* Signal the parent. */
2391 if (write(write_fd, &c, 1) != 1) {
2392 printf("child: start signal fail %s.\n",
2399 /* Wait for the parent to be ready. */
2400 if (read(read_fd, &c, 1) != 1) {
2401 printf("child: reply signal fail %s.\n",
2409 printf("child: released lock 0:4 on file %s.\n",
2415 static bool run_locktest9(int dummy)
2417 struct cli_state *cli1;
2418 const char *fname = "\\lockt9.lck";
2420 bool correct = False;
2421 int pipe_in[2], pipe_out[2];
2425 struct timeval start;
2429 printf("starting locktest9\n");
2431 if (local_path == NULL) {
2432 d_fprintf(stderr, "locktest9 must be given a local path via -l <localpath>\n");
2436 if (pipe(pipe_in) == -1 || pipe(pipe_out) == -1) {
2441 if (child_pid == -1) {
2445 if (child_pid == 0) {
2447 do_local_lock(pipe_out[0], pipe_in[1]);
2457 ret = read(pipe_in[0], &c, 1);
2459 d_fprintf(stderr, "failed to read start signal from child. %s\n",
2464 if (!torture_open_connection(&cli1, 0)) {
2468 cli_sockopt(cli1, sockops);
2470 status = cli_open(cli1, fname, O_RDWR, DENY_NONE,
2472 if (!NT_STATUS_IS_OK(status)) {
2473 d_fprintf(stderr, "cli_open returned %s\n", cli_errstr(cli1));
2477 /* Ensure the child has the lock. */
2478 if (cli_lock(cli1, fnum, 0, 4, 0, WRITE_LOCK)) {
2479 d_fprintf(stderr, "Got the lock on range 0:4 - this should not happen !\n");
2482 d_printf("Child has the lock.\n");
2485 /* Tell the child to wait 5 seconds then exit. */
2486 ret = write(pipe_out[1], &c, 1);
2488 d_fprintf(stderr, "failed to send exit signal to child. %s\n",
2493 /* Wait 20 seconds for the lock. */
2494 alarm_fd = cli1->fd;
2495 CatchSignal(SIGALRM, alarm_handler_parent);
2498 start = timeval_current();
2500 if (!cli_lock(cli1, fnum, 0, 4, -1, WRITE_LOCK)) {
2501 d_fprintf(stderr, "Unable to apply write lock on range 0:4, error was "
2502 "%s\n", cli_errstr(cli1));
2507 seconds = timeval_elapsed(&start);
2509 printf("Parent got the lock after %.2f seconds.\n",
2512 status = cli_close(cli1, fnum);
2513 if (!NT_STATUS_IS_OK(status)) {
2514 d_fprintf(stderr, "cli_close(fnum1) %s\n", cli_errstr(cli1));
2521 cli_close(cli1, fnum);
2522 torture_close_connection(cli1);
2526 printf("finished locktest9\n");
2531 test whether fnums and tids open on one VC are available on another (a major
2534 static bool run_fdpasstest(int dummy)
2536 struct cli_state *cli1, *cli2;
2537 const char *fname = "\\fdpass.tst";
2541 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2544 cli_sockopt(cli1, sockops);
2545 cli_sockopt(cli2, sockops);
2547 printf("starting fdpasstest\n");
2549 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2551 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
2552 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2556 if (cli_write(cli1, fnum1, 0, "hello world\n", 0, 13) != 13) {
2557 printf("write failed (%s)\n", cli_errstr(cli1));
2561 cli2->vuid = cli1->vuid;
2562 cli2->cnum = cli1->cnum;
2563 cli2->pid = cli1->pid;
2565 if (cli_read(cli2, fnum1, buf, 0, 13) == 13) {
2566 printf("read succeeded! nasty security hole [%s]\n",
2571 cli_close(cli1, fnum1);
2572 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2574 torture_close_connection(cli1);
2575 torture_close_connection(cli2);
2577 printf("finished fdpasstest\n");
2581 static bool run_fdsesstest(int dummy)
2583 struct cli_state *cli;
2588 const char *fname = "\\fdsess.tst";
2589 const char *fname1 = "\\fdsess1.tst";
2595 if (!torture_open_connection(&cli, 0))
2597 cli_sockopt(cli, sockops);
2599 if (!torture_cli_session_setup2(cli, &new_vuid))
2602 saved_cnum = cli->cnum;
2603 if (!NT_STATUS_IS_OK(cli_tcon_andx(cli, share, "?????", "", 1)))
2605 new_cnum = cli->cnum;
2606 cli->cnum = saved_cnum;
2608 printf("starting fdsesstest\n");
2610 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2611 cli_unlink(cli, fname1, aSYSTEM | aHIDDEN);
2613 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
2614 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2618 if (cli_write(cli, fnum1, 0, "hello world\n", 0, 13) != 13) {
2619 printf("write failed (%s)\n", cli_errstr(cli));
2623 saved_vuid = cli->vuid;
2624 cli->vuid = new_vuid;
2626 if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2627 printf("read succeeded with different vuid! nasty security hole [%s]\n",
2631 /* Try to open a file with different vuid, samba cnum. */
2632 if (NT_STATUS_IS_OK(cli_open(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum2))) {
2633 printf("create with different vuid, same cnum succeeded.\n");
2634 cli_close(cli, fnum2);
2635 cli_unlink(cli, fname1, aSYSTEM | aHIDDEN);
2637 printf("create with different vuid, same cnum failed.\n");
2638 printf("This will cause problems with service clients.\n");
2642 cli->vuid = saved_vuid;
2644 /* Try with same vuid, different cnum. */
2645 cli->cnum = new_cnum;
2647 if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2648 printf("read succeeded with different cnum![%s]\n",
2653 cli->cnum = saved_cnum;
2654 cli_close(cli, fnum1);
2655 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2657 torture_close_connection(cli);
2659 printf("finished fdsesstest\n");
2664 This test checks that
2666 1) the server does not allow an unlink on a file that is open
2668 static bool run_unlinktest(int dummy)
2670 struct cli_state *cli;
2671 const char *fname = "\\unlink.tst";
2673 bool correct = True;
2675 if (!torture_open_connection(&cli, 0)) {
2679 cli_sockopt(cli, sockops);
2681 printf("starting unlink test\n");
2683 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2687 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
2688 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2692 if (NT_STATUS_IS_OK(cli_unlink(cli, fname, aSYSTEM | aHIDDEN))) {
2693 printf("error: server allowed unlink on an open file\n");
2696 correct = check_error(__LINE__, cli, ERRDOS, ERRbadshare,
2697 NT_STATUS_SHARING_VIOLATION);
2700 cli_close(cli, fnum);
2701 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2703 if (!torture_close_connection(cli)) {
2707 printf("unlink test finished\n");
2714 test how many open files this server supports on the one socket
2716 static bool run_maxfidtest(int dummy)
2718 struct cli_state *cli;
2719 const char *ftemplate = "\\maxfid.%d.%d";
2721 uint16_t fnums[0x11000];
2724 bool correct = True;
2729 printf("failed to connect\n");
2733 cli_sockopt(cli, sockops);
2735 for (i=0; i<0x11000; i++) {
2736 slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2737 if (!NT_STATUS_IS_OK(cli_open(cli, fname,
2738 O_RDWR|O_CREAT|O_TRUNC, DENY_NONE, &fnums[i]))) {
2739 printf("open of %s failed (%s)\n",
2740 fname, cli_errstr(cli));
2741 printf("maximum fnum is %d\n", i);
2749 printf("cleaning up\n");
2751 slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2752 cli_close(cli, fnums[i]);
2753 if (!NT_STATUS_IS_OK(cli_unlink(cli, fname, aSYSTEM | aHIDDEN))) {
2754 printf("unlink of %s failed (%s)\n",
2755 fname, cli_errstr(cli));
2762 printf("maxfid test finished\n");
2763 if (!torture_close_connection(cli)) {
2769 /* generate a random buffer */
2770 static void rand_buf(char *buf, int len)
2773 *buf = (char)sys_random();
2778 /* send smb negprot commands, not reading the response */
2779 static bool run_negprot_nowait(int dummy)
2781 struct tevent_context *ev;
2783 struct cli_state *cli;
2784 bool correct = True;
2786 printf("starting negprot nowait test\n");
2788 ev = tevent_context_init(talloc_tos());
2793 if (!(cli = open_nbt_connection())) {
2798 for (i=0;i<50000;i++) {
2799 struct tevent_req *req;
2801 req = cli_negprot_send(ev, ev, cli);
2806 if (!tevent_req_poll(req, ev)) {
2807 d_fprintf(stderr, "tevent_req_poll failed: %s\n",
2815 if (torture_close_connection(cli)) {
2819 printf("finished negprot nowait test\n");
2824 /* send smb negprot commands, not reading the response */
2825 static bool run_bad_nbt_session(int dummy)
2827 static struct cli_state *cli;
2829 printf("starting bad nbt session test\n");
2831 if (!(cli = open_bad_nbt_connection())) {
2836 printf("finished bad nbt session test\n");
2840 /* send random IPC commands */
2841 static bool run_randomipc(int dummy)
2843 char *rparam = NULL;
2845 unsigned int rdrcnt,rprcnt;
2847 int api, param_len, i;
2848 struct cli_state *cli;
2849 bool correct = True;
2852 printf("starting random ipc test\n");
2854 if (!torture_open_connection(&cli, 0)) {
2858 for (i=0;i<count;i++) {
2859 api = sys_random() % 500;
2860 param_len = (sys_random() % 64);
2862 rand_buf(param, param_len);
2867 param, param_len, 8,
2868 NULL, 0, BUFFER_SIZE,
2872 printf("%d/%d\r", i,count);
2875 printf("%d/%d\n", i, count);
2877 if (!torture_close_connection(cli)) {
2881 printf("finished random ipc test\n");
2888 static void browse_callback(const char *sname, uint32 stype,
2889 const char *comment, void *state)
2891 printf("\t%20.20s %08x %s\n", sname, stype, comment);
2897 This test checks the browse list code
2900 static bool run_browsetest(int dummy)
2902 static struct cli_state *cli;
2903 bool correct = True;
2905 printf("starting browse test\n");
2907 if (!torture_open_connection(&cli, 0)) {
2911 printf("domain list:\n");
2912 cli_NetServerEnum(cli, cli->server_domain,
2913 SV_TYPE_DOMAIN_ENUM,
2914 browse_callback, NULL);
2916 printf("machine list:\n");
2917 cli_NetServerEnum(cli, cli->server_domain,
2919 browse_callback, NULL);
2921 if (!torture_close_connection(cli)) {
2925 printf("browse test finished\n");
2933 This checks how the getatr calls works
2935 static bool run_attrtest(int dummy)
2937 struct cli_state *cli;
2940 const char *fname = "\\attrib123456789.tst";
2941 bool correct = True;
2943 printf("starting attrib test\n");
2945 if (!torture_open_connection(&cli, 0)) {
2949 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2950 cli_open(cli, fname,
2951 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
2952 cli_close(cli, fnum);
2953 if (!NT_STATUS_IS_OK(cli_getatr(cli, fname, NULL, NULL, &t))) {
2954 printf("getatr failed (%s)\n", cli_errstr(cli));
2958 if (abs(t - time(NULL)) > 60*60*24*10) {
2959 printf("ERROR: SMBgetatr bug. time is %s",
2965 t2 = t-60*60*24; /* 1 day ago */
2967 if (!NT_STATUS_IS_OK(cli_setatr(cli, fname, 0, t2))) {
2968 printf("setatr failed (%s)\n", cli_errstr(cli));
2972 if (!NT_STATUS_IS_OK(cli_getatr(cli, fname, NULL, NULL, &t))) {
2973 printf("getatr failed (%s)\n", cli_errstr(cli));
2978 printf("ERROR: getatr/setatr bug. times are\n%s",
2980 printf("%s", ctime(&t2));
2984 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2986 if (!torture_close_connection(cli)) {
2990 printf("attrib test finished\n");
2997 This checks a couple of trans2 calls
2999 static bool run_trans2test(int dummy)
3001 struct cli_state *cli;
3004 time_t c_time, a_time, m_time;
3005 struct timespec c_time_ts, a_time_ts, m_time_ts, w_time_ts, m_time2_ts;
3006 const char *fname = "\\trans2.tst";
3007 const char *dname = "\\trans2";
3008 const char *fname2 = "\\trans2\\trans2.tst";
3010 bool correct = True;
3014 printf("starting trans2 test\n");
3016 if (!torture_open_connection(&cli, 0)) {
3020 status = cli_get_fs_attr_info(cli, &fs_attr);
3021 if (!NT_STATUS_IS_OK(status)) {
3022 printf("ERROR: cli_get_fs_attr_info returned %s\n",
3027 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
3028 cli_open(cli, fname,
3029 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3030 if (!NT_STATUS_IS_OK(cli_qfileinfo_basic(
3031 cli, fnum, NULL, &size, &c_time_ts,
3032 &a_time_ts, &w_time_ts,
3033 &m_time_ts, NULL))) {
3034 printf("ERROR: qfileinfo failed (%s)\n", cli_errstr(cli));
3038 if (!NT_STATUS_IS_OK(cli_qfilename(cli, fnum, pname, sizeof(pname)))) {
3039 printf("ERROR: qfilename failed (%s)\n", cli_errstr(cli));
3043 if (strcmp(pname, fname)) {
3044 printf("qfilename gave different name? [%s] [%s]\n",
3049 cli_close(cli, fnum);
3053 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
3054 if (!NT_STATUS_IS_OK(cli_open(cli, fname,
3055 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum))) {
3056 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
3059 cli_close(cli, fnum);
3061 status = cli_qpathinfo1(cli, fname, &c_time, &a_time, &m_time, &size,
3063 if (!NT_STATUS_IS_OK(status)) {
3064 printf("ERROR: qpathinfo failed (%s)\n", nt_errstr(status));
3067 if (c_time != m_time) {
3068 printf("create time=%s", ctime(&c_time));
3069 printf("modify time=%s", ctime(&m_time));
3070 printf("This system appears to have sticky create times\n");
3072 if (a_time % (60*60) == 0) {
3073 printf("access time=%s", ctime(&a_time));
3074 printf("This system appears to set a midnight access time\n");
3078 if (abs(m_time - time(NULL)) > 60*60*24*7) {
3079 printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
3085 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
3086 cli_open(cli, fname,
3087 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3088 cli_close(cli, fnum);
3089 status = cli_qpathinfo2(cli, fname, &c_time_ts, &a_time_ts, &w_time_ts,
3090 &m_time_ts, &size, NULL, NULL);
3091 if (!NT_STATUS_IS_OK(status)) {
3092 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
3095 if (w_time_ts.tv_sec < 60*60*24*2) {
3096 printf("write time=%s", ctime(&w_time_ts.tv_sec));
3097 printf("This system appears to set a initial 0 write time\n");
3102 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
3105 /* check if the server updates the directory modification time
3106 when creating a new file */
3107 if (!NT_STATUS_IS_OK(cli_mkdir(cli, dname))) {
3108 printf("ERROR: mkdir failed (%s)\n", cli_errstr(cli));
3112 status = cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts,
3113 &w_time_ts, &m_time_ts, &size, NULL, NULL);
3114 if (!NT_STATUS_IS_OK(status)) {
3115 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
3119 cli_open(cli, fname2,
3120 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3121 cli_write(cli, fnum, 0, (char *)&fnum, 0, sizeof(fnum));
3122 cli_close(cli, fnum);
3123 status = cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts,
3124 &w_time_ts, &m_time2_ts, &size, NULL, NULL);
3125 if (!NT_STATUS_IS_OK(status)) {
3126 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
3129 if (memcmp(&m_time_ts, &m_time2_ts, sizeof(struct timespec))
3131 printf("This system does not update directory modification times\n");
3135 cli_unlink(cli, fname2, aSYSTEM | aHIDDEN);
3136 cli_rmdir(cli, dname);
3138 if (!torture_close_connection(cli)) {
3142 printf("trans2 test finished\n");
3148 This checks new W2K calls.
3151 static NTSTATUS new_trans(struct cli_state *pcli, int fnum, int level)
3153 uint8_t *buf = NULL;
3157 status = cli_qfileinfo(talloc_tos(), pcli, fnum, level, 0,
3158 pcli->max_xmit, &buf, &len);
3159 if (!NT_STATUS_IS_OK(status)) {
3160 printf("ERROR: qfileinfo (%d) failed (%s)\n", level,
3163 printf("qfileinfo: level %d, len = %u\n", level, len);
3164 dump_data(0, (uint8 *)buf, len);
3171 static bool run_w2ktest(int dummy)
3173 struct cli_state *cli;
3175 const char *fname = "\\w2ktest\\w2k.tst";
3177 bool correct = True;
3179 printf("starting w2k test\n");
3181 if (!torture_open_connection(&cli, 0)) {
3185 cli_open(cli, fname,
3186 O_RDWR | O_CREAT , DENY_NONE, &fnum);
3188 for (level = 1004; level < 1040; level++) {
3189 new_trans(cli, fnum, level);
3192 cli_close(cli, fnum);
3194 if (!torture_close_connection(cli)) {
3198 printf("w2k test finished\n");
3205 this is a harness for some oplock tests
3207 static bool run_oplock1(int dummy)
3209 struct cli_state *cli1;
3210 const char *fname = "\\lockt1.lck";
3212 bool correct = True;
3214 printf("starting oplock test 1\n");
3216 if (!torture_open_connection(&cli1, 0)) {
3220 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3222 cli_sockopt(cli1, sockops);
3224 cli1->use_oplocks = True;
3226 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
3227 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3231 cli1->use_oplocks = False;
3233 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3234 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3236 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3237 printf("close2 failed (%s)\n", cli_errstr(cli1));
3241 if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
3242 printf("unlink failed (%s)\n", cli_errstr(cli1));
3246 if (!torture_close_connection(cli1)) {
3250 printf("finished oplock test 1\n");
3255 static bool run_oplock2(int dummy)
3257 struct cli_state *cli1, *cli2;
3258 const char *fname = "\\lockt2.lck";
3259 uint16_t fnum1, fnum2;
3260 int saved_use_oplocks = use_oplocks;
3262 bool correct = True;
3263 volatile bool *shared_correct;
3265 shared_correct = (volatile bool *)shm_setup(sizeof(bool));
3266 *shared_correct = True;
3268 use_level_II_oplocks = True;
3271 printf("starting oplock test 2\n");
3273 if (!torture_open_connection(&cli1, 0)) {
3274 use_level_II_oplocks = False;
3275 use_oplocks = saved_use_oplocks;
3279 cli1->use_oplocks = True;
3280 cli1->use_level_II_oplocks = True;
3282 if (!torture_open_connection(&cli2, 1)) {
3283 use_level_II_oplocks = False;
3284 use_oplocks = saved_use_oplocks;
3288 cli2->use_oplocks = True;
3289 cli2->use_level_II_oplocks = True;
3291 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3293 cli_sockopt(cli1, sockops);
3294 cli_sockopt(cli2, sockops);
3296 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
3297 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3301 /* Don't need the globals any more. */
3302 use_level_II_oplocks = False;
3303 use_oplocks = saved_use_oplocks;
3307 if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2))) {
3308 printf("second open of %s failed (%s)\n", fname, cli_errstr(cli1));
3309 *shared_correct = False;
3315 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
3316 printf("close2 failed (%s)\n", cli_errstr(cli1));
3317 *shared_correct = False;
3325 /* Ensure cli1 processes the break. Empty file should always return 0
3328 if (cli_read(cli1, fnum1, buf, 0, 4) != 0) {
3329 printf("read on fnum1 failed (%s)\n", cli_errstr(cli1));
3333 /* Should now be at level II. */
3334 /* Test if sending a write locks causes a break to none. */
3336 if (!cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK)) {
3337 printf("lock failed (%s)\n", cli_errstr(cli1));
3341 cli_unlock(cli1, fnum1, 0, 4);
3345 if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
3346 printf("lock failed (%s)\n", cli_errstr(cli1));
3350 cli_unlock(cli1, fnum1, 0, 4);
3354 cli_read(cli1, fnum1, buf, 0, 4);
3357 if (cli_write(cli1, fnum1, 0, buf, 0, 4) != 4) {
3358 printf("write on fnum1 failed (%s)\n", cli_errstr(cli1));
3363 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3364 printf("close1 failed (%s)\n", cli_errstr(cli1));
3370 if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
3371 printf("unlink failed (%s)\n", cli_errstr(cli1));
3375 if (!torture_close_connection(cli1)) {
3379 if (!*shared_correct) {
3383 printf("finished oplock test 2\n");
3388 /* handler for oplock 3 tests */
3389 static NTSTATUS oplock3_handler(struct cli_state *cli, uint16_t fnum, unsigned char level)
3391 printf("got oplock break fnum=%d level=%d\n",
3393 return cli_oplock_ack(cli, fnum, level);
3396 static bool run_oplock3(int dummy)
3398 struct cli_state *cli;
3399 const char *fname = "\\oplockt3.dat";
3401 char buf[4] = "abcd";
3402 bool correct = True;
3403 volatile bool *shared_correct;
3405 shared_correct = (volatile bool *)shm_setup(sizeof(bool));
3406 *shared_correct = True;
3408 printf("starting oplock test 3\n");
3413 use_level_II_oplocks = True;
3414 if (!torture_open_connection(&cli, 0)) {
3415 *shared_correct = False;
3419 /* try to trigger a oplock break in parent */
3420 cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum);
3421 cli_write(cli, fnum, 0, buf, 0, 4);
3427 use_level_II_oplocks = True;
3428 if (!torture_open_connection(&cli, 1)) { /* other is forked */
3431 cli_oplock_handler(cli, oplock3_handler);
3432 cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum);
3433 cli_write(cli, fnum, 0, buf, 0, 4);
3434 cli_close(cli, fnum);
3435 cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum);
3436 cli->timeout = 20000;
3437 cli_receive_smb(cli);
3438 printf("finished oplock test 3\n");
3440 return (correct && *shared_correct);
3442 /* What are we looking for here? What's sucess and what's FAILURE? */
3445 /* handler for oplock 4 tests */
3446 bool *oplock4_shared_correct;
3448 static NTSTATUS oplock4_handler(struct cli_state *cli, uint16_t fnum, unsigned char level)
3450 printf("got oplock break fnum=%d level=%d\n",
3452 *oplock4_shared_correct = true;
3453 cli_oplock_ack(cli, fnum, level);
3454 return NT_STATUS_UNSUCCESSFUL; /* Cause cli_receive_smb to return. */
3457 static bool run_oplock4(int dummy)
3459 struct cli_state *cli1, *cli2;
3460 const char *fname = "\\lockt4.lck";
3461 const char *fname_ln = "\\lockt4_ln.lck";
3462 uint16_t fnum1, fnum2;
3463 int saved_use_oplocks = use_oplocks;
3465 bool correct = true;
3467 oplock4_shared_correct = (bool *)shm_setup(sizeof(bool));
3468 *oplock4_shared_correct = false;
3470 printf("starting oplock test 4\n");
3472 if (!torture_open_connection(&cli1, 0)) {
3473 use_level_II_oplocks = false;
3474 use_oplocks = saved_use_oplocks;
3478 if (!torture_open_connection(&cli2, 1)) {
3479 use_level_II_oplocks = false;
3480 use_oplocks = saved_use_oplocks;
3484 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3485 cli_unlink(cli1, fname_ln, aSYSTEM | aHIDDEN);
3487 cli_sockopt(cli1, sockops);
3488 cli_sockopt(cli2, sockops);
3490 /* Create the file. */
3491 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
3492 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3496 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3497 printf("close1 failed (%s)\n", cli_errstr(cli1));
3501 /* Now create a hardlink. */
3502 if (!NT_STATUS_IS_OK(cli_nt_hardlink(cli1, fname, fname_ln))) {
3503 printf("nt hardlink failed (%s)\n", cli_errstr(cli1));
3507 /* Prove that opening hardlinks cause deny modes to conflict. */
3508 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum1))) {
3509 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3513 status = cli_open(cli1, fname_ln, O_RDWR, DENY_NONE, &fnum2);
3514 if (NT_STATUS_IS_OK(status)) {
3515 printf("open of %s succeeded - should fail with sharing violation.\n",
3520 if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
3521 printf("open of %s should fail with sharing violation. Got %s\n",
3522 fname_ln, nt_errstr(status));
3526 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3527 printf("close1 failed (%s)\n", cli_errstr(cli1));
3531 cli1->use_oplocks = true;
3532 cli1->use_level_II_oplocks = true;
3534 cli2->use_oplocks = true;
3535 cli2->use_level_II_oplocks = true;
3537 cli_oplock_handler(cli1, oplock4_handler);
3538 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1))) {
3539 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3545 if (!NT_STATUS_IS_OK(cli_open(cli2, fname_ln, O_RDWR, DENY_NONE, &fnum2))) {
3546 printf("open of %s failed (%s)\n", fname_ln, cli_errstr(cli1));
3547 *oplock4_shared_correct = false;
3551 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
3552 printf("close2 failed (%s)\n", cli_errstr(cli1));
3553 *oplock4_shared_correct = false;
3561 /* Process the oplock break. */
3562 cli_receive_smb(cli1);
3564 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3565 printf("close1 failed (%s)\n", cli_errstr(cli1));
3569 if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
3570 printf("unlink failed (%s)\n", cli_errstr(cli1));
3573 if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname_ln, aSYSTEM | aHIDDEN))) {
3574 printf("unlink failed (%s)\n", cli_errstr(cli1));
3578 if (!torture_close_connection(cli1)) {
3582 if (!*oplock4_shared_correct) {
3586 printf("finished oplock test 4\n");
3593 Test delete on close semantics.
3595 static bool run_deletetest(int dummy)
3597 struct cli_state *cli1 = NULL;
3598 struct cli_state *cli2 = NULL;
3599 const char *fname = "\\delete.file";
3600 uint16_t fnum1 = (uint16_t)-1;
3601 uint16_t fnum2 = (uint16_t)-1;
3602 bool correct = True;
3604 printf("starting delete test\n");
3606 if (!torture_open_connection(&cli1, 0)) {
3610 cli_sockopt(cli1, sockops);
3612 /* Test 1 - this should delete the file on close. */
3614 cli_setatr(cli1, fname, 0, 0);
3615 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3617 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
3618 0, FILE_OVERWRITE_IF,
3619 FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
3620 printf("[1] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3625 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3626 printf("[1] close failed (%s)\n", cli_errstr(cli1));
3631 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1))) {
3632 printf("[1] open of %s succeeded (should fail)\n", fname);
3637 printf("first delete on close test succeeded.\n");
3639 /* Test 2 - this should delete the file on close. */
3641 cli_setatr(cli1, fname, 0, 0);
3642 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3644 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
3645 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
3646 FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3647 printf("[2] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3652 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3653 printf("[2] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3658 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3659 printf("[2] close failed (%s)\n", cli_errstr(cli1));
3664 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3665 printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
3666 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3667 printf("[2] close failed (%s)\n", cli_errstr(cli1));
3671 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3673 printf("second delete on close test succeeded.\n");
3676 cli_setatr(cli1, fname, 0, 0);
3677 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3679 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
3680 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3681 printf("[3] open - 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3686 /* This should fail with a sharing violation - open for delete is only compatible
3687 with SHARE_DELETE. */
3689 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3690 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0, 0, &fnum2))) {
3691 printf("[3] open - 2 of %s succeeded - should have failed.\n", fname);
3696 /* This should succeed. */
3698 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3699 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0, &fnum2))) {
3700 printf("[3] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3705 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3706 printf("[3] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3711 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3712 printf("[3] close 1 failed (%s)\n", cli_errstr(cli1));
3717 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
3718 printf("[3] close 2 failed (%s)\n", cli_errstr(cli1));
3723 /* This should fail - file should no longer be there. */
3725 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3726 printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
3727 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3728 printf("[3] close failed (%s)\n", cli_errstr(cli1));
3730 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3734 printf("third delete on close test succeeded.\n");
3737 cli_setatr(cli1, fname, 0, 0);
3738 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3740 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3741 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3742 printf("[4] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3747 /* This should succeed. */
3748 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
3749 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0, &fnum2))) {
3750 printf("[4] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3755 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
3756 printf("[4] close - 1 failed (%s)\n", cli_errstr(cli1));
3761 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3762 printf("[4] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3767 /* This should fail - no more opens once delete on close set. */
3768 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
3769 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3770 FILE_OPEN, 0, 0, &fnum2))) {
3771 printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname );
3775 printf("fourth delete on close test succeeded.\n");
3777 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3778 printf("[4] close - 2 failed (%s)\n", cli_errstr(cli1));
3784 cli_setatr(cli1, fname, 0, 0);
3785 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3787 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum1))) {
3788 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3793 /* This should fail - only allowed on NT opens with DELETE access. */
3795 if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3796 printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
3801 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3802 printf("[5] close - 2 failed (%s)\n", cli_errstr(cli1));
3807 printf("fifth delete on close test succeeded.\n");
3810 cli_setatr(cli1, fname, 0, 0);
3811 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3813 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
3814 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3815 FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3816 printf("[6] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3821 /* This should fail - only allowed on NT opens with DELETE access. */
3823 if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3824 printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
3829 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3830 printf("[6] close - 2 failed (%s)\n", cli_errstr(cli1));
3835 printf("sixth delete on close test succeeded.\n");
3838 cli_setatr(cli1, fname, 0, 0);
3839 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3841 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3842 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3843 printf("[7] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3848 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3849 printf("[7] setting delete_on_close on file failed !\n");
3854 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, false))) {
3855 printf("[7] unsetting delete_on_close on file failed !\n");
3860 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3861 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3866 /* This next open should succeed - we reset the flag. */
3868 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3869 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3874 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3875 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3880 printf("seventh delete on close test succeeded.\n");
3883 cli_setatr(cli1, fname, 0, 0);
3884 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3886 if (!torture_open_connection(&cli2, 1)) {
3887 printf("[8] failed to open second connection.\n");
3892 cli_sockopt(cli1, sockops);
3894 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3895 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3896 FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3897 printf("[8] open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3902 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3903 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3904 FILE_OPEN, 0, 0, &fnum2))) {
3905 printf("[8] open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3910 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3911 printf("[8] setting delete_on_close on file failed !\n");
3916 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3917 printf("[8] close - 1 failed (%s)\n", cli_errstr(cli1));
3922 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
3923 printf("[8] close - 2 failed (%s)\n", cli_errstr(cli2));
3928 /* This should fail.. */
3929 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3930 printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
3934 printf("eighth delete on close test succeeded.\n");
3936 /* This should fail - we need to set DELETE_ACCESS. */
3937 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,FILE_READ_DATA|FILE_WRITE_DATA,
3938 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
3939 printf("[9] open of %s succeeded should have failed!\n", fname);
3944 printf("ninth delete on close test succeeded.\n");
3946 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3947 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
3948 printf("[10] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3953 /* This should delete the file. */
3954 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3955 printf("[10] close failed (%s)\n", cli_errstr(cli1));
3960 /* This should fail.. */
3961 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3962 printf("[10] open of %s succeeded should have been deleted on close !\n", fname);
3966 printf("tenth delete on close test succeeded.\n");
3968 cli_setatr(cli1, fname, 0, 0);
3969 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3971 /* What error do we get when attempting to open a read-only file with
3974 /* Create a readonly file. */
3975 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
3976 FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3977 printf("[11] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3982 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3983 printf("[11] close failed (%s)\n", cli_errstr(cli1));
3988 /* Now try open for delete access. */
3989 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES|DELETE_ACCESS,
3990 0, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3991 FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3992 printf("[11] open of %s succeeded should have been denied with ACCESS_DENIED!\n", fname);
3993 cli_close(cli1, fnum1);
3997 NTSTATUS nterr = cli_nt_error(cli1);
3998 if (!NT_STATUS_EQUAL(nterr,NT_STATUS_ACCESS_DENIED)) {
3999 printf("[11] open of %s should have been denied with ACCESS_DENIED! Got error %s\n", fname, nt_errstr(nterr));
4003 printf("eleventh delete on close test succeeded.\n");
4007 printf("finished delete test\n");
4010 /* FIXME: This will crash if we aborted before cli2 got
4011 * intialized, because these functions don't handle
4012 * uninitialized connections. */
4014 if (fnum1 != (uint16_t)-1) cli_close(cli1, fnum1);
4015 if (fnum2 != (uint16_t)-1) cli_close(cli1, fnum2);
4016 cli_setatr(cli1, fname, 0, 0);
4017 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4019 if (cli1 && !torture_close_connection(cli1)) {
4022 if (cli2 && !torture_close_connection(cli2)) {
4028 static bool run_deletetest_ln(int dummy)
4030 struct cli_state *cli;
4031 const char *fname = "\\delete1";
4032 const char *fname_ln = "\\delete1_ln";
4036 bool correct = true;
4039 printf("starting deletetest-ln\n");
4041 if (!torture_open_connection(&cli, 0)) {
4045 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
4046 cli_unlink(cli, fname_ln, aSYSTEM | aHIDDEN);
4048 cli_sockopt(cli, sockops);
4050 /* Create the file. */
4051 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
4052 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
4056 if (!NT_STATUS_IS_OK(cli_close(cli, fnum))) {
4057 printf("close1 failed (%s)\n", cli_errstr(cli));
4061 /* Now create a hardlink. */
4062 if (!NT_STATUS_IS_OK(cli_nt_hardlink(cli, fname, fname_ln))) {
4063 printf("nt hardlink failed (%s)\n", cli_errstr(cli));
4067 /* Open the original file. */
4068 status = cli_ntcreate(cli, fname, 0, FILE_READ_DATA,
4069 FILE_ATTRIBUTE_NORMAL,
4070 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4071 FILE_OPEN_IF, 0, 0, &fnum);
4072 if (!NT_STATUS_IS_OK(status)) {
4073 printf("ntcreate of %s failed (%s)\n", fname, nt_errstr(status));
4077 /* Unlink the hard link path. */
4078 status = cli_ntcreate(cli, fname_ln, 0, DELETE_ACCESS,
4079 FILE_ATTRIBUTE_NORMAL,
4080 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4081 FILE_OPEN_IF, 0, 0, &fnum1);
4082 if (!NT_STATUS_IS_OK(status)) {
4083 printf("ntcreate of %s failed (%s)\n", fname_ln, nt_errstr(status));
4086 status = cli_nt_delete_on_close(cli, fnum1, true);
4087 if (!NT_STATUS_IS_OK(status)) {
4088 d_printf("(%s) failed to set delete_on_close %s: %s\n",
4089 __location__, fname_ln, nt_errstr(status));
4093 status = cli_close(cli, fnum1);
4094 if (!NT_STATUS_IS_OK(status)) {
4095 printf("close %s failed (%s)\n",
4096 fname_ln, nt_errstr(status));
4100 status = cli_close(cli, fnum);
4101 if (!NT_STATUS_IS_OK(status)) {
4102 printf("close %s failed (%s)\n",
4103 fname, nt_errstr(status));
4107 /* Ensure the original file is still there. */
4108 status = cli_getatr(cli, fname, NULL, NULL, &t);
4109 if (!NT_STATUS_IS_OK(status)) {
4110 printf("%s getatr on file %s failed (%s)\n",
4117 /* Ensure the link path is gone. */
4118 status = cli_getatr(cli, fname_ln, NULL, NULL, &t);
4119 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
4120 printf("%s, getatr for file %s returned wrong error code %s "
4121 "- should have been deleted\n",
4123 fname_ln, nt_errstr(status));
4127 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
4128 cli_unlink(cli, fname_ln, aSYSTEM | aHIDDEN);
4130 if (!torture_close_connection(cli)) {
4134 printf("finished deletetest-ln\n");
4140 print out server properties
4142 static bool run_properties(int dummy)
4144 struct cli_state *cli;
4145 bool correct = True;
4147 printf("starting properties test\n");
4151 if (!torture_open_connection(&cli, 0)) {
4155 cli_sockopt(cli, sockops);
4157 d_printf("Capabilities 0x%08x\n", cli->capabilities);
4159 if (!torture_close_connection(cli)) {
4168 /* FIRST_DESIRED_ACCESS 0xf019f */
4169 #define FIRST_DESIRED_ACCESS FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\
4170 FILE_READ_EA| /* 0xf */ \
4171 FILE_WRITE_EA|FILE_READ_ATTRIBUTES| /* 0x90 */ \
4172 FILE_WRITE_ATTRIBUTES| /* 0x100 */ \
4173 DELETE_ACCESS|READ_CONTROL_ACCESS|\
4174 WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS /* 0xf0000 */
4175 /* SECOND_DESIRED_ACCESS 0xe0080 */
4176 #define SECOND_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
4177 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
4178 WRITE_OWNER_ACCESS /* 0xe0000 */
4181 #define THIRD_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
4182 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
4184 WRITE_OWNER_ACCESS /* */
4188 Test ntcreate calls made by xcopy
4190 static bool run_xcopy(int dummy)
4192 static struct cli_state *cli1;
4193 const char *fname = "\\test.txt";
4194 bool correct = True;
4195 uint16_t fnum1, fnum2;
4197 printf("starting xcopy test\n");
4199 if (!torture_open_connection(&cli1, 0)) {
4203 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,
4204 FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
4205 FILE_SHARE_NONE, FILE_OVERWRITE_IF,
4206 0x4044, 0, &fnum1))) {
4207 printf("First open failed - %s\n", cli_errstr(cli1));
4211 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,
4212 SECOND_DESIRED_ACCESS, 0,
4213 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN,
4214 0x200000, 0, &fnum2))) {
4215 printf("second open failed - %s\n", cli_errstr(cli1));
4219 if (!torture_close_connection(cli1)) {
4227 Test rename on files open with share delete and no share delete.
4229 static bool run_rename(int dummy)
4231 static struct cli_state *cli1;
4232 const char *fname = "\\test.txt";
4233 const char *fname1 = "\\test1.txt";
4234 bool correct = True;
4239 printf("starting rename test\n");
4241 if (!torture_open_connection(&cli1, 0)) {
4245 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4246 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
4247 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4248 FILE_SHARE_READ, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4249 printf("First open failed - %s\n", cli_errstr(cli1));
4253 if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
4254 printf("First rename failed (SHARE_READ) (this is correct) - %s\n", cli_errstr(cli1));
4256 printf("First rename succeeded (SHARE_READ) - this should have failed !\n");
4260 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4261 printf("close - 1 failed (%s)\n", cli_errstr(cli1));
4265 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4266 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
4267 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4269 FILE_SHARE_DELETE|FILE_SHARE_NONE,
4271 FILE_SHARE_DELETE|FILE_SHARE_READ,
4273 FILE_OVERWRITE_IF, 0, 0, &fnum1);
4274 if (!NT_STATUS_IS_OK(status)) {
4275 printf("Second open failed - %s\n", cli_errstr(cli1));
4279 if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
4280 printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", cli_errstr(cli1));
4283 printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n");
4286 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4287 printf("close - 2 failed (%s)\n", cli_errstr(cli1));
4291 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4292 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
4294 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, READ_CONTROL_ACCESS, FILE_ATTRIBUTE_NORMAL,
4295 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4296 printf("Third open failed - %s\n", cli_errstr(cli1));
4305 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
4306 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
4307 printf("Fourth open failed - %s\n", cli_errstr(cli1));
4310 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum2, true))) {
4311 printf("[8] setting delete_on_close on file failed !\n");
4315 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
4316 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
4322 if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
4323 printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", cli_errstr(cli1));
4326 printf("Third rename succeeded (SHARE_NONE)\n");
4329 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4330 printf("close - 3 failed (%s)\n", cli_errstr(cli1));
4334 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4335 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
4339 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4340 FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4341 printf("Fourth open failed - %s\n", cli_errstr(cli1));
4345 if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
4346 printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", cli_errstr(cli1));
4348 printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n");
4352 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4353 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
4357 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4358 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
4362 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4363 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4364 printf("Fifth open failed - %s\n", cli_errstr(cli1));
4368 if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
4369 printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n",
4373 printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", cli_errstr(cli1));
4377 * Now check if the first name still exists ...
4380 /* if (!NT_STATUS_OP(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4381 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
4382 printf("Opening original file after rename of open file fails: %s\n",
4386 printf("Opening original file after rename of open file works ...\n");
4387 (void)cli_close(cli1, fnum2);
4391 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4392 printf("close - 5 failed (%s)\n", cli_errstr(cli1));
4396 /* Check that the renamed file has FILE_ATTRIBUTE_ARCHIVE. */
4397 if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname1, &attr, NULL, NULL))) {
4398 printf("getatr on file %s failed - %s ! \n",
4403 if (attr != FILE_ATTRIBUTE_ARCHIVE) {
4404 printf("Renamed file %s has wrong attr 0x%x "
4405 "(should be 0x%x)\n",
4408 (unsigned int)FILE_ATTRIBUTE_ARCHIVE);
4411 printf("Renamed file %s has archive bit set\n", fname1);
4415 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4416 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
4418 if (!torture_close_connection(cli1)) {
4425 static bool run_pipe_number(int dummy)
4427 struct cli_state *cli1;
4428 const char *pipe_name = "\\SPOOLSS";
4432 printf("starting pipenumber test\n");
4433 if (!torture_open_connection(&cli1, 0)) {
4437 cli_sockopt(cli1, sockops);
4439 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, pipe_name, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
4440 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF, 0, 0, &fnum))) {
4441 printf("Open of pipe %s failed with error (%s)\n", pipe_name, cli_errstr(cli1));
4445 printf("\r%6d", num_pipes);
4448 printf("pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
4449 torture_close_connection(cli1);
4454 Test open mode returns on read-only files.
4456 static bool run_opentest(int dummy)
4458 static struct cli_state *cli1;
4459 static struct cli_state *cli2;
4460 const char *fname = "\\readonly.file";
4461 uint16_t fnum1, fnum2;
4464 bool correct = True;
4468 printf("starting open test\n");
4470 if (!torture_open_connection(&cli1, 0)) {
4474 cli_setatr(cli1, fname, 0, 0);
4475 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4477 cli_sockopt(cli1, sockops);
4479 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
4480 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
4484 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4485 printf("close2 failed (%s)\n", cli_errstr(cli1));
4489 if (!NT_STATUS_IS_OK(cli_setatr(cli1, fname, aRONLY, 0))) {
4490 printf("cli_setatr failed (%s)\n", cli_errstr(cli1));
4494 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1))) {
4495 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
4499 /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
4500 cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
4502 if (check_error(__LINE__, cli1, ERRDOS, ERRnoaccess,
4503 NT_STATUS_ACCESS_DENIED)) {
4504 printf("correct error code ERRDOS/ERRnoaccess returned\n");
4507 printf("finished open test 1\n");
4509 cli_close(cli1, fnum1);
4511 /* Now try not readonly and ensure ERRbadshare is returned. */
4513 cli_setatr(cli1, fname, 0, 0);
4515 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1))) {
4516 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
4520 /* This will fail - but the error should be ERRshare. */
4521 cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
4523 if (check_error(__LINE__, cli1, ERRDOS, ERRbadshare,
4524 NT_STATUS_SHARING_VIOLATION)) {
4525 printf("correct error code ERRDOS/ERRbadshare returned\n");
4528 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4529 printf("close2 failed (%s)\n", cli_errstr(cli1));
4533 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4535 printf("finished open test 2\n");
4537 /* Test truncate open disposition on file opened for read. */
4539 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
4540 printf("(3) open (1) of %s failed (%s)\n", fname, cli_errstr(cli1));
4544 /* write 20 bytes. */
4546 memset(buf, '\0', 20);
4548 if (cli_write(cli1, fnum1, 0, buf, 0, 20) != 20) {
4549 printf("write failed (%s)\n", cli_errstr(cli1));
4553 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4554 printf("(3) close1 failed (%s)\n", cli_errstr(cli1));
4558 /* Ensure size == 20. */
4559 if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname, NULL, &fsize, NULL))) {
4560 printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
4565 printf("(3) file size != 20\n");
4569 /* Now test if we can truncate a file opened for readonly. */
4571 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE, &fnum1))) {
4572 printf("(3) open (2) of %s failed (%s)\n", fname, cli_errstr(cli1));
4576 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4577 printf("close2 failed (%s)\n", cli_errstr(cli1));
4581 /* Ensure size == 0. */
4582 if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname, NULL, &fsize, NULL))) {
4583 printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
4588 printf("(3) file size != 0\n");
4591 printf("finished open test 3\n");
4593 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4595 printf("Do ctemp tests\n");
4596 if (!NT_STATUS_IS_OK(cli_ctemp(cli1, talloc_tos(), "\\", &fnum1, &tmp_path))) {
4597 printf("ctemp failed (%s)\n", cli_errstr(cli1));
4600 printf("ctemp gave path %s\n", tmp_path);
4601 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4602 printf("close of temp failed (%s)\n", cli_errstr(cli1));
4604 if (!NT_STATUS_IS_OK(cli_unlink(cli1, tmp_path, aSYSTEM | aHIDDEN))) {
4605 printf("unlink of temp failed (%s)\n", cli_errstr(cli1));
4608 /* Test the non-io opens... */
4610 if (!torture_open_connection(&cli2, 1)) {
4614 cli_setatr(cli2, fname, 0, 0);
4615 cli_unlink(cli2, fname, aSYSTEM | aHIDDEN);
4617 cli_sockopt(cli2, sockops);
4619 printf("TEST #1 testing 2 non-io opens (no delete)\n");
4621 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4622 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4623 printf("TEST #1 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4627 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4628 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4629 printf("TEST #1 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4633 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4634 printf("TEST #1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4637 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
4638 printf("TEST #1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4642 printf("non-io open test #1 passed.\n");
4644 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4646 printf("TEST #2 testing 2 non-io opens (first with delete)\n");
4648 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4649 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4650 printf("TEST #2 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4654 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4655 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4656 printf("TEST #2 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4660 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4661 printf("TEST #2 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4664 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
4665 printf("TEST #2 close 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
4669 printf("non-io open test #2 passed.\n");
4671 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4673 printf("TEST #3 testing 2 non-io opens (second with delete)\n");
4675 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4676 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4677 printf("TEST #3 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4681 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4682 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4683 printf("TEST #3 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4687 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4688 printf("TEST #3 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4691 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
4692 printf("TEST #3 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4696 printf("non-io open test #3 passed.\n");
4698 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4700 printf("TEST #4 testing 2 non-io opens (both with delete)\n");
4702 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4703 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4704 printf("TEST #4 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4708 if (NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4709 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4710 printf("TEST #4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
4714 printf("TEST #4 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
4716 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4717 printf("TEST #4 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4721 printf("non-io open test #4 passed.\n");
4723 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4725 printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
4727 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4728 FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4729 printf("TEST #5 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4733 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4734 FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4735 printf("TEST #5 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4739 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4740 printf("TEST #5 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4744 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
4745 printf("TEST #5 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4749 printf("non-io open test #5 passed.\n");
4751 printf("TEST #6 testing 1 non-io open, one io open\n");
4753 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4755 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
4756 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4757 printf("TEST #6 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4761 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4762 FILE_SHARE_READ, FILE_OPEN_IF, 0, 0, &fnum2))) {
4763 printf("TEST #6 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4767 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4768 printf("TEST #6 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4772 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
4773 printf("TEST #6 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4777 printf("non-io open test #6 passed.\n");
4779 printf("TEST #7 testing 1 non-io open, one io open with delete\n");
4781 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4783 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
4784 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4785 printf("TEST #7 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4789 if (NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4790 FILE_SHARE_READ|FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4791 printf("TEST #7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
4795 printf("TEST #7 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
4797 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4798 printf("TEST #7 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4802 printf("non-io open test #7 passed.\n");
4804 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4806 printf("TEST #8 testing open without WRITE_ATTRIBUTES, updating close write time.\n");
4807 status = cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA, FILE_ATTRIBUTE_NORMAL,
4808 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4809 FILE_OVERWRITE_IF, 0, 0, &fnum1);
4810 if (!NT_STATUS_IS_OK(status)) {
4811 printf("TEST #8 open of %s failed (%s)\n", fname, nt_errstr(status));
4816 /* Write to ensure we have to update the file time. */
4817 if (cli_write(cli1, fnum1, 0, "TEST DATA\n", 0, 10) != 10) {
4818 printf("TEST #8 cli_write failed: %s\n", cli_errstr(cli1));
4823 status = cli_close(cli1, fnum1);
4824 if (!NT_STATUS_IS_OK(status)) {
4825 printf("TEST #8 close of %s failed (%s)\n", fname, nt_errstr(status));
4831 if (!torture_close_connection(cli1)) {
4834 if (!torture_close_connection(cli2)) {
4841 NTSTATUS torture_setup_unix_extensions(struct cli_state *cli)
4843 uint16 major, minor;
4844 uint32 caplow, caphigh;
4847 if (!SERVER_HAS_UNIX_CIFS(cli)) {
4848 printf("Server doesn't support UNIX CIFS extensions.\n");
4849 return NT_STATUS_NOT_SUPPORTED;
4852 status = cli_unix_extensions_version(cli, &major, &minor, &caplow,
4854 if (!NT_STATUS_IS_OK(status)) {
4855 printf("Server didn't return UNIX CIFS extensions: %s\n",
4860 status = cli_set_unix_extensions_capabilities(cli, major, minor,
4862 if (!NT_STATUS_IS_OK(status)) {
4863 printf("Server doesn't support setting UNIX CIFS extensions: "
4864 "%s.\n", nt_errstr(status));
4868 return NT_STATUS_OK;
4872 Test POSIX open /mkdir calls.
4874 static bool run_simple_posix_open_test(int dummy)
4876 static struct cli_state *cli1;
4877 const char *fname = "posix:file";
4878 const char *hname = "posix:hlink";
4879 const char *sname = "posix:symlink";
4880 const char *dname = "posix:dir";
4883 uint16_t fnum1 = (uint16_t)-1;
4884 SMB_STRUCT_STAT sbuf;
4885 bool correct = false;
4888 printf("Starting simple POSIX open test\n");
4890 if (!torture_open_connection(&cli1, 0)) {
4894 cli_sockopt(cli1, sockops);
4896 status = torture_setup_unix_extensions(cli1);
4897 if (!NT_STATUS_IS_OK(status)) {
4901 cli_setatr(cli1, fname, 0, 0);
4902 cli_posix_unlink(cli1, fname);
4903 cli_setatr(cli1, dname, 0, 0);
4904 cli_posix_rmdir(cli1, dname);
4905 cli_setatr(cli1, hname, 0, 0);
4906 cli_posix_unlink(cli1, hname);
4907 cli_setatr(cli1, sname, 0, 0);
4908 cli_posix_unlink(cli1, sname);
4910 /* Create a directory. */
4911 if (!NT_STATUS_IS_OK(cli_posix_mkdir(cli1, dname, 0777))) {
4912 printf("POSIX mkdir of %s failed (%s)\n", dname, cli_errstr(cli1));
4916 if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1))) {
4917 printf("POSIX create of %s failed (%s)\n", fname, cli_errstr(cli1));
4921 /* Test ftruncate - set file size. */
4922 if (!NT_STATUS_IS_OK(cli_ftruncate(cli1, fnum1, 1000))) {
4923 printf("ftruncate failed (%s)\n", cli_errstr(cli1));
4927 /* Ensure st_size == 1000 */
4928 if (!NT_STATUS_IS_OK(cli_posix_stat(cli1, fname, &sbuf))) {
4929 printf("stat failed (%s)\n", cli_errstr(cli1));
4933 if (sbuf.st_ex_size != 1000) {
4934 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
4938 /* Test ftruncate - set file size back to zero. */
4939 if (!NT_STATUS_IS_OK(cli_ftruncate(cli1, fnum1, 0))) {
4940 printf("ftruncate failed (%s)\n", cli_errstr(cli1));
4944 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4945 printf("close failed (%s)\n", cli_errstr(cli1));
4949 /* Now open the file again for read only. */
4950 if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1))) {
4951 printf("POSIX open of %s failed (%s)\n", fname, cli_errstr(cli1));
4955 /* Now unlink while open. */
4956 if (!NT_STATUS_IS_OK(cli_posix_unlink(cli1, fname))) {
4957 printf("POSIX unlink of %s failed (%s)\n", fname, cli_errstr(cli1));
4961 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4962 printf("close(2) failed (%s)\n", cli_errstr(cli1));
4966 /* Ensure the file has gone. */
4967 if (NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1))) {
4968 printf("POSIX open of %s succeeded, should have been deleted.\n", fname);
4972 /* What happens when we try and POSIX open a directory ? */
4973 if (NT_STATUS_IS_OK(cli_posix_open(cli1, dname, O_RDONLY, 0, &fnum1))) {
4974 printf("POSIX open of directory %s succeeded, should have failed.\n", fname);
4977 if (!check_error(__LINE__, cli1, ERRDOS, EISDIR,
4978 NT_STATUS_FILE_IS_A_DIRECTORY)) {
4983 /* Create the file. */
4984 if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1))) {
4985 printf("POSIX create of %s failed (%s)\n", fname, cli_errstr(cli1));
4989 /* Write some data into it. */
4990 if (cli_write(cli1, fnum1, 0, "TEST DATA\n", 0, 10) != 10) {
4991 printf("cli_write failed: %s\n", cli_errstr(cli1));
4995 cli_close(cli1, fnum1);
4997 /* Now create a hardlink. */
4998 if (!NT_STATUS_IS_OK(cli_posix_hardlink(cli1, fname, hname))) {
4999 printf("POSIX hardlink of %s failed (%s)\n", hname, cli_errstr(cli1));
5003 /* Now create a symlink. */
5004 if (!NT_STATUS_IS_OK(cli_posix_symlink(cli1, fname, sname))) {
5005 printf("POSIX symlink of %s failed (%s)\n", sname, cli_errstr(cli1));
5009 /* Open the hardlink for read. */
5010 if (!NT_STATUS_IS_OK(cli_posix_open(cli1, hname, O_RDONLY, 0, &fnum1))) {
5011 printf("POSIX open of %s failed (%s)\n", hname, cli_errstr(cli1));
5015 if (cli_read(cli1, fnum1, buf, 0, 10) != 10) {
5016 printf("POSIX read of %s failed (%s)\n", hname, cli_errstr(cli1));
5020 if (memcmp(buf, "TEST DATA\n", 10)) {
5021 printf("invalid data read from hardlink\n");
5025 /* Do a POSIX lock/unlock. */
5026 if (!NT_STATUS_IS_OK(cli_posix_lock(cli1, fnum1, 0, 100, true, READ_LOCK))) {
5027 printf("POSIX lock failed %s\n", cli_errstr(cli1));
5031 /* Punch a hole in the locked area. */
5032 if (!NT_STATUS_IS_OK(cli_posix_unlock(cli1, fnum1, 10, 80))) {
5033 printf("POSIX unlock failed %s\n", cli_errstr(cli1));
5037 cli_close(cli1, fnum1);
5039 /* Open the symlink for read - this should fail. A POSIX
5040 client should not be doing opens on a symlink. */
5041 if (NT_STATUS_IS_OK(cli_posix_open(cli1, sname, O_RDONLY, 0, &fnum1))) {
5042 printf("POSIX open of %s succeeded (should have failed)\n", sname);
5045 if (!check_error(__LINE__, cli1, ERRDOS, ERRbadpath,
5046 NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
5047 printf("POSIX open of %s should have failed "
5048 "with NT_STATUS_OBJECT_PATH_NOT_FOUND, "
5049 "failed with %s instead.\n",
5050 sname, cli_errstr(cli1));
5055 if (!NT_STATUS_IS_OK(cli_posix_readlink(cli1, sname, namebuf, sizeof(namebuf)))) {
5056 printf("POSIX readlink on %s failed (%s)\n", sname, cli_errstr(cli1));
5060 if (strcmp(namebuf, fname) != 0) {
5061 printf("POSIX readlink on %s failed to match name %s (read %s)\n",
5062 sname, fname, namebuf);
5066 if (!NT_STATUS_IS_OK(cli_posix_rmdir(cli1, dname))) {
5067 printf("POSIX rmdir failed (%s)\n", cli_errstr(cli1));
5071 printf("Simple POSIX open test passed\n");
5076 if (fnum1 != (uint16_t)-1) {
5077 cli_close(cli1, fnum1);
5078 fnum1 = (uint16_t)-1;
5081 cli_setatr(cli1, sname, 0, 0);
5082 cli_posix_unlink(cli1, sname);
5083 cli_setatr(cli1, hname, 0, 0);
5084 cli_posix_unlink(cli1, hname);
5085 cli_setatr(cli1, fname, 0, 0);
5086 cli_posix_unlink(cli1, fname);
5087 cli_setatr(cli1, dname, 0, 0);
5088 cli_posix_rmdir(cli1, dname);
5090 if (!torture_close_connection(cli1)) {
5098 static uint32 open_attrs_table[] = {
5099 FILE_ATTRIBUTE_NORMAL,
5100 FILE_ATTRIBUTE_ARCHIVE,
5101 FILE_ATTRIBUTE_READONLY,
5102 FILE_ATTRIBUTE_HIDDEN,
5103 FILE_ATTRIBUTE_SYSTEM,
5105 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY,
5106 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN,
5107 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,
5108 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
5109 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
5110 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
5112 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
5113 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
5114 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
5115 FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM,
5118 struct trunc_open_results {
5125 static struct trunc_open_results attr_results[] = {
5126 { 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
5127 { 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
5128 { 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
5129 { 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
5130 { 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
5131 { 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
5132 { 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5133 { 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5134 { 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
5135 { 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5136 { 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5137 { 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
5138 { 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5139 { 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5140 { 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 },
5141 { 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5142 { 119, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5143 { 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 },
5144 { 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 },
5145 { 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 },
5146 { 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5147 { 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5148 { 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
5149 { 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5150 { 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5151 { 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
5154 static bool run_openattrtest(int dummy)
5156 static struct cli_state *cli1;
5157 const char *fname = "\\openattr.file";
5159 bool correct = True;
5161 unsigned int i, j, k, l;
5163 printf("starting open attr test\n");
5165 if (!torture_open_connection(&cli1, 0)) {
5169 cli_sockopt(cli1, sockops);
5171 for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32); i++) {
5172 cli_setatr(cli1, fname, 0, 0);
5173 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
5174 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA, open_attrs_table[i],
5175 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
5176 printf("open %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
5180 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
5181 printf("close %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
5185 for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32); j++) {
5186 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA, open_attrs_table[j],
5187 FILE_SHARE_NONE, FILE_OVERWRITE, 0, 0, &fnum1))) {
5188 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
5189 if (attr_results[l].num == k) {
5190 printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
5191 k, open_attrs_table[i],
5192 open_attrs_table[j],
5193 fname, NT_STATUS_V(cli_nt_error(cli1)), cli_errstr(cli1));
5197 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_ACCESS_DENIED)) {
5198 printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n",
5199 k, open_attrs_table[i], open_attrs_table[j],
5204 printf("[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]);
5210 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
5211 printf("close %d (2) of %s failed (%s)\n", j, fname, cli_errstr(cli1));
5215 if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname, &attr, NULL, NULL))) {
5216 printf("getatr(2) failed (%s)\n", cli_errstr(cli1));
5221 printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
5222 k, open_attrs_table[i], open_attrs_table[j], attr );
5225 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
5226 if (attr_results[l].num == k) {
5227 if (attr != attr_results[l].result_attr ||
5228 open_attrs_table[i] != attr_results[l].init_attr ||
5229 open_attrs_table[j] != attr_results[l].trunc_attr) {
5230 printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
5231 open_attrs_table[i],
5232 open_attrs_table[j],
5234 attr_results[l].result_attr);
5244 cli_setatr(cli1, fname, 0, 0);
5245 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
5247 printf("open attr test %s.\n", correct ? "passed" : "failed");
5249 if (!torture_close_connection(cli1)) {
5255 static NTSTATUS list_fn(const char *mnt, struct file_info *finfo,
5256 const char *name, void *state)
5258 int *matched = (int *)state;
5259 if (matched != NULL) {
5262 return NT_STATUS_OK;
5266 test directory listing speed
5268 static bool run_dirtest(int dummy)
5271 static struct cli_state *cli;
5273 struct timeval core_start;
5274 bool correct = True;
5277 printf("starting directory test\n");
5279 if (!torture_open_connection(&cli, 0)) {
5283 cli_sockopt(cli, sockops);
5286 for (i=0;i<torture_numops;i++) {
5288 slprintf(fname, sizeof(fname), "\\%x", (int)random());
5289 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum))) {
5290 fprintf(stderr,"Failed to open %s\n", fname);
5293 cli_close(cli, fnum);
5296 core_start = timeval_current();
5299 cli_list(cli, "a*.*", 0, list_fn, &matched);
5300 printf("Matched %d\n", matched);
5303 cli_list(cli, "b*.*", 0, list_fn, &matched);
5304 printf("Matched %d\n", matched);
5307 cli_list(cli, "xyzabc", 0, list_fn, &matched);
5308 printf("Matched %d\n", matched);
5310 printf("dirtest core %g seconds\n", timeval_elapsed(&core_start));
5313 for (i=0;i<torture_numops;i++) {
5315 slprintf(fname, sizeof(fname), "\\%x", (int)random());
5316 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
5319 if (!torture_close_connection(cli)) {
5323 printf("finished dirtest\n");
5328 static NTSTATUS del_fn(const char *mnt, struct file_info *finfo, const char *mask,
5331 struct cli_state *pcli = (struct cli_state *)state;
5333 slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name);
5335 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
5336 return NT_STATUS_OK;
5338 if (finfo->mode & aDIR) {
5339 if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname)))
5340 printf("del_fn: failed to rmdir %s\n,", fname );
5342 if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, aSYSTEM | aHIDDEN)))
5343 printf("del_fn: failed to unlink %s\n,", fname );
5345 return NT_STATUS_OK;
5350 sees what IOCTLs are supported
5352 bool torture_ioctl_test(int dummy)
5354 static struct cli_state *cli;
5355 uint16_t device, function;
5357 const char *fname = "\\ioctl.dat";
5361 if (!torture_open_connection(&cli, 0)) {
5365 printf("starting ioctl test\n");
5367 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
5369 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
5370 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
5374 status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob);
5375 printf("ioctl device info: %s\n", nt_errstr(status));
5377 status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob);
5378 printf("ioctl job info: %s\n", nt_errstr(status));
5380 for (device=0;device<0x100;device++) {
5381 printf("ioctl test with device = 0x%x\n", device);
5382 for (function=0;function<0x100;function++) {
5383 uint32 code = (device<<16) | function;
5385 status = cli_raw_ioctl(cli, fnum, code, &blob);
5387 if (NT_STATUS_IS_OK(status)) {
5388 printf("ioctl 0x%x OK : %d bytes\n", (int)code,
5390 data_blob_free(&blob);
5395 if (!torture_close_connection(cli)) {
5404 tries varients of chkpath
5406 bool torture_chkpath_test(int dummy)
5408 static struct cli_state *cli;
5412 if (!torture_open_connection(&cli, 0)) {
5416 printf("starting chkpath test\n");
5418 /* cleanup from an old run */
5419 cli_rmdir(cli, "\\chkpath.dir\\dir2");
5420 cli_unlink(cli, "\\chkpath.dir\\*", aSYSTEM | aHIDDEN);
5421 cli_rmdir(cli, "\\chkpath.dir");
5423 if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\chkpath.dir"))) {
5424 printf("mkdir1 failed : %s\n", cli_errstr(cli));
5428 if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\chkpath.dir\\dir2"))) {
5429 printf("mkdir2 failed : %s\n", cli_errstr(cli));
5433 if (!NT_STATUS_IS_OK(cli_open(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
5434 printf("open1 failed (%s)\n", cli_errstr(cli));
5437 cli_close(cli, fnum);
5439 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir"))) {
5440 printf("chkpath1 failed: %s\n", cli_errstr(cli));
5444 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\dir2"))) {
5445 printf("chkpath2 failed: %s\n", cli_errstr(cli));
5449 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\foo.txt"))) {
5450 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
5451 NT_STATUS_NOT_A_DIRECTORY);
5453 printf("* chkpath on a file should fail\n");
5457 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\bar.txt"))) {
5458 ret = check_error(__LINE__, cli, ERRDOS, ERRbadfile,
5459 NT_STATUS_OBJECT_NAME_NOT_FOUND);
5461 printf("* chkpath on a non existant file should fail\n");
5465 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt"))) {
5466 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
5467 NT_STATUS_OBJECT_PATH_NOT_FOUND);
5469 printf("* chkpath on a non existent component should fail\n");
5473 cli_rmdir(cli, "\\chkpath.dir\\dir2");
5474 cli_unlink(cli, "\\chkpath.dir\\*", aSYSTEM | aHIDDEN);
5475 cli_rmdir(cli, "\\chkpath.dir");
5477 if (!torture_close_connection(cli)) {
5484 static bool run_eatest(int dummy)
5486 static struct cli_state *cli;
5487 const char *fname = "\\eatest.txt";
5488 bool correct = True;
5492 struct ea_struct *ea_list = NULL;
5493 TALLOC_CTX *mem_ctx = talloc_init("eatest");
5496 printf("starting eatest\n");
5498 if (!torture_open_connection(&cli, 0)) {
5499 talloc_destroy(mem_ctx);
5503 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
5504 if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0,
5505 FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
5506 FILE_SHARE_NONE, FILE_OVERWRITE_IF,
5507 0x4044, 0, &fnum))) {
5508 printf("open failed - %s\n", cli_errstr(cli));
5509 talloc_destroy(mem_ctx);
5513 for (i = 0; i < 10; i++) {
5514 fstring ea_name, ea_val;
5516 slprintf(ea_name, sizeof(ea_name), "EA_%d", i);
5517 memset(ea_val, (char)i+1, i+1);
5518 status = cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1);
5519 if (!NT_STATUS_IS_OK(status)) {
5520 printf("ea_set of name %s failed - %s\n", ea_name,
5522 talloc_destroy(mem_ctx);
5527 cli_close(cli, fnum);
5528 for (i = 0; i < 10; i++) {
5529 fstring ea_name, ea_val;
5531 slprintf(ea_name, sizeof(ea_name), "EA_%d", i+10);
5532 memset(ea_val, (char)i+1, i+1);
5533 status = cli_set_ea_path(cli, fname, ea_name, ea_val, i+1);
5534 if (!NT_STATUS_IS_OK(status)) {
5535 printf("ea_set of name %s failed - %s\n", ea_name,
5537 talloc_destroy(mem_ctx);
5542 status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
5543 if (!NT_STATUS_IS_OK(status)) {
5544 printf("ea_get list failed - %s\n", nt_errstr(status));
5548 printf("num_eas = %d\n", (int)num_eas);
5550 if (num_eas != 20) {
5551 printf("Should be 20 EA's stored... failing.\n");
5555 for (i = 0; i < num_eas; i++) {
5556 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
5557 dump_data(0, ea_list[i].value.data,
5558 ea_list[i].value.length);
5561 /* Setting EA's to zero length deletes them. Test this */
5562 printf("Now deleting all EA's - case indepenent....\n");
5565 cli_set_ea_path(cli, fname, "", "", 0);
5567 for (i = 0; i < 20; i++) {
5569 slprintf(ea_name, sizeof(ea_name), "ea_%d", i);
5570 status = cli_set_ea_path(cli, fname, ea_name, "", 0);
5571 if (!NT_STATUS_IS_OK(status)) {
5572 printf("ea_set of name %s failed - %s\n", ea_name,
5574 talloc_destroy(mem_ctx);
5580 status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
5581 if (!NT_STATUS_IS_OK(status)) {
5582 printf("ea_get list failed - %s\n", nt_errstr(status));
5586 printf("num_eas = %d\n", (int)num_eas);
5587 for (i = 0; i < num_eas; i++) {
5588 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
5589 dump_data(0, ea_list[i].value.data,
5590 ea_list[i].value.length);
5594 printf("deleting EA's failed.\n");
5598 /* Try and delete a non existant EA. */
5599 status = cli_set_ea_path(cli, fname, "foo", "", 0);
5600 if (!NT_STATUS_IS_OK(status)) {
5601 printf("deleting non-existant EA 'foo' should succeed. %s\n",
5606 talloc_destroy(mem_ctx);
5607 if (!torture_close_connection(cli)) {
5614 static bool run_dirtest1(int dummy)
5617 static struct cli_state *cli;
5620 bool correct = True;
5622 printf("starting directory test\n");
5624 if (!torture_open_connection(&cli, 0)) {
5628 cli_sockopt(cli, sockops);
5630 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
5631 cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
5632 cli_rmdir(cli, "\\LISTDIR");
5633 cli_mkdir(cli, "\\LISTDIR");
5635 /* Create 1000 files and 1000 directories. */
5636 for (i=0;i<1000;i++) {
5638 slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i);
5639 if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
5640 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum))) {
5641 fprintf(stderr,"Failed to open %s\n", fname);
5644 cli_close(cli, fnum);
5646 for (i=0;i<1000;i++) {
5648 slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i);
5649 if (!NT_STATUS_IS_OK(cli_mkdir(cli, fname))) {
5650 fprintf(stderr,"Failed to open %s\n", fname);
5655 /* Now ensure that doing an old list sees both files and directories. */
5657 cli_list_old(cli, "\\LISTDIR\\*", aDIR, list_fn, &num_seen);
5658 printf("num_seen = %d\n", num_seen );
5659 /* We should see 100 files + 1000 directories + . and .. */
5660 if (num_seen != 2002)
5663 /* Ensure if we have the "must have" bits we only see the
5667 cli_list_old(cli, "\\LISTDIR\\*", (aDIR<<8)|aDIR, list_fn, &num_seen);
5668 printf("num_seen = %d\n", num_seen );
5669 if (num_seen != 1002)
5673 cli_list_old(cli, "\\LISTDIR\\*", (aARCH<<8)|aDIR, list_fn, &num_seen);
5674 printf("num_seen = %d\n", num_seen );
5675 if (num_seen != 1000)
5678 /* Delete everything. */
5679 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
5680 cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
5681 cli_rmdir(cli, "\\LISTDIR");
5684 printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
5685 printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
5686 printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
5689 if (!torture_close_connection(cli)) {
5693 printf("finished dirtest1\n");
5698 static bool run_error_map_extract(int dummy) {
5700 static struct cli_state *c_dos;
5701 static struct cli_state *c_nt;
5706 uint32 flgs2, errnum;
5713 /* NT-Error connection */
5715 if (!(c_nt = open_nbt_connection())) {
5719 c_nt->use_spnego = False;
5721 status = cli_negprot(c_nt);
5723 if (!NT_STATUS_IS_OK(status)) {
5724 printf("%s rejected the NT-error negprot (%s)\n", host,
5730 if (!NT_STATUS_IS_OK(cli_session_setup(c_nt, "", "", 0, "", 0,
5732 printf("%s rejected the NT-error initial session setup (%s)\n",host, cli_errstr(c_nt));
5736 /* DOS-Error connection */
5738 if (!(c_dos = open_nbt_connection())) {
5742 c_dos->use_spnego = False;
5743 c_dos->force_dos_errors = True;
5745 status = cli_negprot(c_dos);
5746 if (!NT_STATUS_IS_OK(status)) {
5747 printf("%s rejected the DOS-error negprot (%s)\n", host,
5749 cli_shutdown(c_dos);
5753 if (!NT_STATUS_IS_OK(cli_session_setup(c_dos, "", "", 0, "", 0,
5755 printf("%s rejected the DOS-error initial session setup (%s)\n",host, cli_errstr(c_dos));
5759 for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) {
5760 fstr_sprintf(user, "%X", error);
5762 if (NT_STATUS_IS_OK(cli_session_setup(c_nt, user,
5763 password, strlen(password),
5764 password, strlen(password),
5766 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
5769 flgs2 = SVAL(c_nt->inbuf,smb_flg2);
5771 /* Case #1: 32-bit NT errors */
5772 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
5773 nt_status = NT_STATUS(IVAL(c_nt->inbuf,smb_rcls));
5775 printf("/** Dos error on NT connection! (%s) */\n",
5777 nt_status = NT_STATUS(0xc0000000);
5780 if (NT_STATUS_IS_OK(cli_session_setup(c_dos, user,
5781 password, strlen(password),
5782 password, strlen(password),
5784 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
5786 flgs2 = SVAL(c_dos->inbuf,smb_flg2), errnum;
5788 /* Case #1: 32-bit NT errors */
5789 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
5790 printf("/** NT error on DOS connection! (%s) */\n",
5792 errnum = errclass = 0;
5794 cli_dos_error(c_dos, &errclass, &errnum);
5797 if (NT_STATUS_V(nt_status) != error) {
5798 printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n",
5799 get_nt_error_c_code(NT_STATUS(error)),
5800 get_nt_error_c_code(nt_status));
5803 printf("\t{%s,\t%s,\t%s},\n",
5804 smb_dos_err_class(errclass),
5805 smb_dos_err_name(errclass, errnum),
5806 get_nt_error_c_code(NT_STATUS(error)));
5811 static bool run_sesssetup_bench(int dummy)
5813 static struct cli_state *c;
5814 const char *fname = "\\file.dat";
5819 if (!torture_open_connection(&c, 0)) {
5823 if (!NT_STATUS_IS_OK(cli_ntcreate(
5824 c, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
5825 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
5826 FILE_DELETE_ON_CLOSE, 0, &fnum))) {
5827 d_printf("open %s failed: %s\n", fname, cli_errstr(c));
5831 for (i=0; i<torture_numops; i++) {
5832 status = cli_session_setup(
5834 password, strlen(password),
5835 password, strlen(password),
5837 if (!NT_STATUS_IS_OK(status)) {
5838 d_printf("(%s) cli_session_setup failed: %s\n",
5839 __location__, nt_errstr(status));
5843 d_printf("\r%d ", (int)c->vuid);
5845 status = cli_ulogoff(c);
5846 if (!NT_STATUS_IS_OK(status)) {
5847 d_printf("(%s) cli_ulogoff failed: %s\n",
5848 __location__, nt_errstr(status));
5857 static bool subst_test(const char *str, const char *user, const char *domain,
5858 uid_t uid, gid_t gid, const char *expected)
5863 subst = talloc_sub_specified(talloc_tos(), str, user, domain, uid, gid);
5865 if (strcmp(subst, expected) != 0) {
5866 printf("sub_specified(%s, %s, %s, %d, %d) returned [%s], expected "
5867 "[%s]\n", str, user, domain, (int)uid, (int)gid, subst,
5876 static void chain1_open_completion(struct tevent_req *req)
5880 status = cli_open_recv(req, &fnum);
5883 d_printf("cli_open_recv returned %s: %d\n",
5885 NT_STATUS_IS_OK(status) ? fnum : -1);
5888 static void chain1_write_completion(struct tevent_req *req)
5892 status = cli_write_andx_recv(req, &written);
5895 d_printf("cli_write_andx_recv returned %s: %d\n",
5897 NT_STATUS_IS_OK(status) ? (int)written : -1);
5900 static void chain1_close_completion(struct tevent_req *req)
5903 bool *done = (bool *)tevent_req_callback_data_void(req);
5905 status = cli_close_recv(req);
5910 d_printf("cli_close returned %s\n", nt_errstr(status));
5913 static bool run_chain1(int dummy)
5915 struct cli_state *cli1;
5916 struct event_context *evt = event_context_init(NULL);
5917 struct tevent_req *reqs[3], *smbreqs[3];
5919 const char *str = "foobar";
5922 printf("starting chain1 test\n");
5923 if (!torture_open_connection(&cli1, 0)) {
5927 cli_sockopt(cli1, sockops);
5929 reqs[0] = cli_open_create(talloc_tos(), evt, cli1, "\\test",
5930 O_CREAT|O_RDWR, 0, &smbreqs[0]);
5931 if (reqs[0] == NULL) return false;
5932 tevent_req_set_callback(reqs[0], chain1_open_completion, NULL);
5935 reqs[1] = cli_write_andx_create(talloc_tos(), evt, cli1, 0, 0,
5936 (uint8_t *)str, 0, strlen(str)+1,
5937 smbreqs, 1, &smbreqs[1]);
5938 if (reqs[1] == NULL) return false;
5939 tevent_req_set_callback(reqs[1], chain1_write_completion, NULL);
5941 reqs[2] = cli_close_create(talloc_tos(), evt, cli1, 0, &smbreqs[2]);
5942 if (reqs[2] == NULL) return false;
5943 tevent_req_set_callback(reqs[2], chain1_close_completion, &done);
5945 status = cli_smb_chain_send(smbreqs, ARRAY_SIZE(smbreqs));
5946 if (!NT_STATUS_IS_OK(status)) {
5951 event_loop_once(evt);
5954 torture_close_connection(cli1);
5958 static void chain2_sesssetup_completion(struct tevent_req *req)
5961 status = cli_session_setup_guest_recv(req);
5962 d_printf("sesssetup returned %s\n", nt_errstr(status));
5965 static void chain2_tcon_completion(struct tevent_req *req)
5967 bool *done = (bool *)tevent_req_callback_data_void(req);
5969 status = cli_tcon_andx_recv(req);
5970 d_printf("tcon_and_x returned %s\n", nt_errstr(status));
5974 static bool run_chain2(int dummy)
5976 struct cli_state *cli1;
5977 struct event_context *evt = event_context_init(NULL);
5978 struct tevent_req *reqs[2], *smbreqs[2];
5982 printf("starting chain2 test\n");
5983 status = cli_start_connection(&cli1, global_myname(), host, NULL,
5984 port_to_use, Undefined, 0);
5985 if (!NT_STATUS_IS_OK(status)) {
5989 cli_sockopt(cli1, sockops);
5991 reqs[0] = cli_session_setup_guest_create(talloc_tos(), evt, cli1,
5993 if (reqs[0] == NULL) return false;
5994 tevent_req_set_callback(reqs[0], chain2_sesssetup_completion, NULL);
5996 reqs[1] = cli_tcon_andx_create(talloc_tos(), evt, cli1, "IPC$",
5997 "?????", NULL, 0, &smbreqs[1]);
5998 if (reqs[1] == NULL) return false;
5999 tevent_req_set_callback(reqs[1], chain2_tcon_completion, &done);
6001 status = cli_smb_chain_send(smbreqs, ARRAY_SIZE(smbreqs));
6002 if (!NT_STATUS_IS_OK(status)) {
6007 event_loop_once(evt);
6010 torture_close_connection(cli1);
6015 struct torture_createdel_state {
6016 struct tevent_context *ev;
6017 struct cli_state *cli;
6020 static void torture_createdel_created(struct tevent_req *subreq);
6021 static void torture_createdel_closed(struct tevent_req *subreq);
6023 static struct tevent_req *torture_createdel_send(TALLOC_CTX *mem_ctx,
6024 struct tevent_context *ev,
6025 struct cli_state *cli,
6028 struct tevent_req *req, *subreq;
6029 struct torture_createdel_state *state;
6031 req = tevent_req_create(mem_ctx, &state,
6032 struct torture_createdel_state);
6039 subreq = cli_ntcreate_send(
6040 state, ev, cli, name, 0,
6041 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
6042 FILE_ATTRIBUTE_NORMAL,
6043 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
6044 FILE_OPEN_IF, FILE_DELETE_ON_CLOSE, 0);
6046 if (tevent_req_nomem(subreq, req)) {
6047 return tevent_req_post(req, ev);
6049 tevent_req_set_callback(subreq, torture_createdel_created, req);
6053 static void torture_createdel_created(struct tevent_req *subreq)
6055 struct tevent_req *req = tevent_req_callback_data(
6056 subreq, struct tevent_req);
6057 struct torture_createdel_state *state = tevent_req_data(
6058 req, struct torture_createdel_state);
6062 status = cli_ntcreate_recv(subreq, &fnum);
6063 TALLOC_FREE(subreq);
6064 if (!NT_STATUS_IS_OK(status)) {
6065 DEBUG(10, ("cli_ntcreate_recv returned %s\n",
6066 nt_errstr(status)));
6067 tevent_req_nterror(req, status);
6071 subreq = cli_close_send(state, state->ev, state->cli, fnum);
6072 if (tevent_req_nomem(subreq, req)) {
6075 tevent_req_set_callback(subreq, torture_createdel_closed, req);
6078 static void torture_createdel_closed(struct tevent_req *subreq)
6080 struct tevent_req *req = tevent_req_callback_data(
6081 subreq, struct tevent_req);
6084 status = cli_close_recv(subreq);
6085 if (!NT_STATUS_IS_OK(status)) {
6086 DEBUG(10, ("cli_close_recv returned %s\n", nt_errstr(status)));
6087 tevent_req_nterror(req, status);
6090 tevent_req_done(req);
6093 static NTSTATUS torture_createdel_recv(struct tevent_req *req)
6095 return tevent_req_simple_recv_ntstatus(req);
6098 struct torture_createdels_state {
6099 struct tevent_context *ev;
6100 struct cli_state *cli;
6101 const char *base_name;
6105 struct tevent_req **reqs;
6108 static void torture_createdels_done(struct tevent_req *subreq);
6110 static struct tevent_req *torture_createdels_send(TALLOC_CTX *mem_ctx,
6111 struct tevent_context *ev,
6112 struct cli_state *cli,
6113 const char *base_name,
6117 struct tevent_req *req;
6118 struct torture_createdels_state *state;
6121 req = tevent_req_create(mem_ctx, &state,
6122 struct torture_createdels_state);
6128 state->base_name = talloc_strdup(state, base_name);
6129 if (tevent_req_nomem(state->base_name, req)) {
6130 return tevent_req_post(req, ev);
6132 state->num_files = MAX(num_parallel, num_files);
6134 state->received = 0;
6136 state->reqs = talloc_array(state, struct tevent_req *, num_parallel);
6137 if (tevent_req_nomem(state->reqs, req)) {
6138 return tevent_req_post(req, ev);
6141 for (i=0; i<num_parallel; i++) {
6144 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
6146 if (tevent_req_nomem(name, req)) {
6147 return tevent_req_post(req, ev);
6149 state->reqs[i] = torture_createdel_send(
6150 state->reqs, state->ev, state->cli, name);
6151 if (tevent_req_nomem(state->reqs[i], req)) {
6152 return tevent_req_post(req, ev);
6154 name = talloc_move(state->reqs[i], &name);
6155 tevent_req_set_callback(state->reqs[i],
6156 torture_createdels_done, req);
6162 static void torture_createdels_done(struct tevent_req *subreq)
6164 struct tevent_req *req = tevent_req_callback_data(
6165 subreq, struct tevent_req);
6166 struct torture_createdels_state *state = tevent_req_data(
6167 req, struct torture_createdels_state);
6168 size_t num_parallel = talloc_array_length(state->reqs);
6173 status = torture_createdel_recv(subreq);
6174 if (!NT_STATUS_IS_OK(status)){
6175 DEBUG(10, ("torture_createdel_recv returned %s\n",
6176 nt_errstr(status)));
6177 TALLOC_FREE(subreq);
6178 tevent_req_nterror(req, status);
6182 for (i=0; i<num_parallel; i++) {
6183 if (subreq == state->reqs[i]) {
6187 if (i == num_parallel) {
6188 DEBUG(10, ("received something we did not send\n"));
6189 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
6192 TALLOC_FREE(state->reqs[i]);
6194 if (state->sent >= state->num_files) {
6195 tevent_req_done(req);
6199 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
6201 if (tevent_req_nomem(name, req)) {
6204 state->reqs[i] = torture_createdel_send(state->reqs, state->ev,
6206 if (tevent_req_nomem(state->reqs[i], req)) {
6209 name = talloc_move(state->reqs[i], &name);
6210 tevent_req_set_callback(state->reqs[i], torture_createdels_done, req);
6214 static NTSTATUS torture_createdels_recv(struct tevent_req *req)
6216 return tevent_req_simple_recv_ntstatus(req);
6219 struct swallow_notify_state {
6220 struct tevent_context *ev;
6221 struct cli_state *cli;
6223 uint32_t completion_filter;
6225 bool (*fn)(uint32_t action, const char *name, void *priv);
6229 static void swallow_notify_done(struct tevent_req *subreq);
6231 static struct tevent_req *swallow_notify_send(TALLOC_CTX *mem_ctx,
6232 struct tevent_context *ev,
6233 struct cli_state *cli,
6235 uint32_t completion_filter,
6237 bool (*fn)(uint32_t action,
6242 struct tevent_req *req, *subreq;
6243 struct swallow_notify_state *state;
6245 req = tevent_req_create(mem_ctx, &state,
6246 struct swallow_notify_state);
6253 state->completion_filter = completion_filter;
6254 state->recursive = recursive;
6258 subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
6259 0xffff, state->completion_filter,
6261 if (tevent_req_nomem(subreq, req)) {
6262 return tevent_req_post(req, ev);
6264 tevent_req_set_callback(subreq, swallow_notify_done, req);
6268 static void swallow_notify_done(struct tevent_req *subreq)
6270 struct tevent_req *req = tevent_req_callback_data(
6271 subreq, struct tevent_req);
6272 struct swallow_notify_state *state = tevent_req_data(
6273 req, struct swallow_notify_state);
6275 uint32_t i, num_changes;
6276 struct notify_change *changes;
6278 status = cli_notify_recv(subreq, state, &num_changes, &changes);
6279 TALLOC_FREE(subreq);
6280 if (!NT_STATUS_IS_OK(status)) {
6281 DEBUG(10, ("cli_notify_recv returned %s\n",
6282 nt_errstr(status)));
6283 tevent_req_nterror(req, status);
6287 for (i=0; i<num_changes; i++) {
6288 state->fn(changes[i].action, changes[i].name, state->priv);
6290 TALLOC_FREE(changes);
6292 subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
6293 0xffff, state->completion_filter,
6295 if (tevent_req_nomem(subreq, req)) {
6298 tevent_req_set_callback(subreq, swallow_notify_done, req);
6301 static bool print_notifies(uint32_t action, const char *name, void *priv)
6303 if (DEBUGLEVEL > 5) {
6304 d_printf("%d %s\n", (int)action, name);
6309 static void notify_bench_done(struct tevent_req *req)
6311 int *num_finished = (int *)tevent_req_callback_data_void(req);
6315 static bool run_notify_bench(int dummy)
6317 const char *dname = "\\notify-bench";
6318 struct tevent_context *ev;
6321 struct tevent_req *req1;
6322 struct tevent_req *req2 = NULL;
6323 int i, num_unc_names;
6324 int num_finished = 0;
6326 printf("starting notify-bench test\n");
6328 if (use_multishare_conn) {
6330 unc_list = file_lines_load(multishare_conn_fname,
6331 &num_unc_names, 0, NULL);
6332 if (!unc_list || num_unc_names <= 0) {
6333 d_printf("Failed to load unc names list from '%s'\n",
6334 multishare_conn_fname);
6337 TALLOC_FREE(unc_list);
6342 ev = tevent_context_init(talloc_tos());
6344 d_printf("tevent_context_init failed\n");
6348 for (i=0; i<num_unc_names; i++) {
6349 struct cli_state *cli;
6352 base_fname = talloc_asprintf(talloc_tos(), "%s\\file%3.3d.",
6354 if (base_fname == NULL) {
6358 if (!torture_open_connection(&cli, i)) {
6362 status = cli_ntcreate(cli, dname, 0,
6363 MAXIMUM_ALLOWED_ACCESS,
6364 0, FILE_SHARE_READ|FILE_SHARE_WRITE|
6366 FILE_OPEN_IF, FILE_DIRECTORY_FILE, 0,
6369 if (!NT_STATUS_IS_OK(status)) {
6370 d_printf("Could not create %s: %s\n", dname,
6375 req1 = swallow_notify_send(talloc_tos(), ev, cli, dnum,
6376 FILE_NOTIFY_CHANGE_FILE_NAME |
6377 FILE_NOTIFY_CHANGE_DIR_NAME |
6378 FILE_NOTIFY_CHANGE_ATTRIBUTES |
6379 FILE_NOTIFY_CHANGE_LAST_WRITE,
6380 false, print_notifies, NULL);
6382 d_printf("Could not create notify request\n");
6386 req2 = torture_createdels_send(talloc_tos(), ev, cli,
6387 base_fname, 10, torture_numops);
6389 d_printf("Could not create createdels request\n");
6392 TALLOC_FREE(base_fname);
6394 tevent_req_set_callback(req2, notify_bench_done,
6398 while (num_finished < num_unc_names) {
6400 ret = tevent_loop_once(ev);
6402 d_printf("tevent_loop_once failed\n");
6407 if (!tevent_req_poll(req2, ev)) {
6408 d_printf("tevent_req_poll failed\n");
6411 status = torture_createdels_recv(req2);
6412 d_printf("torture_createdels_recv returned %s\n", nt_errstr(status));
6417 static bool run_mangle1(int dummy)
6419 struct cli_state *cli;
6420 const char *fname = "this_is_a_long_fname_to_be_mangled.txt";
6424 time_t change_time, access_time, write_time;
6428 printf("starting mangle1 test\n");
6429 if (!torture_open_connection(&cli, 0)) {
6433 cli_sockopt(cli, sockops);
6435 if (!NT_STATUS_IS_OK(cli_ntcreate(
6436 cli, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
6437 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0, &fnum))) {
6438 d_printf("open %s failed: %s\n", fname, cli_errstr(cli));
6441 cli_close(cli, fnum);
6443 status = cli_qpathinfo_alt_name(cli, fname, alt_name);
6444 if (!NT_STATUS_IS_OK(status)) {
6445 d_printf("cli_qpathinfo_alt_name failed: %s\n",
6449 d_printf("alt_name: %s\n", alt_name);
6451 if (!NT_STATUS_IS_OK(cli_open(cli, alt_name, O_RDONLY, DENY_NONE, &fnum))) {
6452 d_printf("cli_open(%s) failed: %s\n", alt_name,
6456 cli_close(cli, fnum);
6458 status = cli_qpathinfo1(cli, alt_name, &change_time, &access_time,
6459 &write_time, &size, &mode);
6460 if (!NT_STATUS_IS_OK(status)) {
6461 d_printf("cli_qpathinfo1(%s) failed: %s\n", alt_name,
6469 static size_t null_source(uint8_t *buf, size_t n, void *priv)
6471 size_t *to_pull = (size_t *)priv;
6472 size_t thistime = *to_pull;
6474 thistime = MIN(thistime, n);
6475 if (thistime == 0) {
6479 memset(buf, 0, thistime);
6480 *to_pull -= thistime;
6484 static bool run_windows_write(int dummy)
6486 struct cli_state *cli1;
6490 const char *fname = "\\writetest.txt";
6491 struct timeval start_time;
6495 printf("starting windows_write test\n");
6496 if (!torture_open_connection(&cli1, 0)) {
6500 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
6501 printf("open failed (%s)\n", cli_errstr(cli1));
6505 cli_sockopt(cli1, sockops);
6507 start_time = timeval_current();
6509 for (i=0; i<torture_numops; i++) {
6511 off_t start = i * torture_blocksize;
6513 size_t to_pull = torture_blocksize - 1;
6515 if (cli_write(cli1, fnum, 0, &c,
6516 start + torture_blocksize - 1, 1) != 1) {
6517 printf("cli_write failed: %s\n", cli_errstr(cli1));
6521 status = cli_push(cli1, fnum, 0, i * torture_blocksize, torture_blocksize,
6522 null_source, &to_pull);
6523 if (!NT_STATUS_IS_OK(status)) {
6524 printf("cli_push returned: %s\n", nt_errstr(status));
6529 seconds = timeval_elapsed(&start_time);
6530 kbytes = (double)torture_blocksize * torture_numops;
6533 printf("Wrote %d kbytes in %.2f seconds: %d kb/sec\n", (int)kbytes,
6534 (double)seconds, (int)(kbytes/seconds));
6538 cli_close(cli1, fnum);
6539 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
6540 torture_close_connection(cli1);
6544 static bool run_cli_echo(int dummy)
6546 struct cli_state *cli;
6549 printf("starting cli_echo test\n");
6550 if (!torture_open_connection(&cli, 0)) {
6553 cli_sockopt(cli, sockops);
6555 status = cli_echo(cli, 5, data_blob_const("hello", 5));
6557 d_printf("cli_echo returned %s\n", nt_errstr(status));
6559 torture_close_connection(cli);
6560 return NT_STATUS_IS_OK(status);
6563 static bool run_uid_regression_test(int dummy)
6565 static struct cli_state *cli;
6568 bool correct = True;
6571 printf("starting uid regression test\n");
6573 if (!torture_open_connection(&cli, 0)) {
6577 cli_sockopt(cli, sockops);
6579 /* Ok - now save then logoff our current user. */
6580 old_vuid = cli->vuid;
6582 status = cli_ulogoff(cli);
6583 if (!NT_STATUS_IS_OK(status)) {
6584 d_printf("(%s) cli_ulogoff failed: %s\n",
6585 __location__, nt_errstr(status));
6590 cli->vuid = old_vuid;
6592 /* Try an operation. */
6593 status = cli_mkdir(cli, "\\uid_reg_test");
6594 if (NT_STATUS_IS_OK(status)) {
6595 d_printf("(%s) cli_mkdir succeeded\n",
6600 /* Should be bad uid. */
6601 if (!check_error(__LINE__, cli, ERRSRV, ERRbaduid,
6602 NT_STATUS_USER_SESSION_DELETED)) {
6608 old_cnum = cli->cnum;
6610 /* Now try a SMBtdis with the invald vuid set to zero. */
6613 /* This should succeed. */
6614 status = cli_tdis(cli);
6616 if (NT_STATUS_IS_OK(status)) {
6617 d_printf("First tdis with invalid vuid should succeed.\n");
6619 d_printf("First tdis failed (%s)\n", nt_errstr(status));
6624 cli->vuid = old_vuid;
6625 cli->cnum = old_cnum;
6627 /* This should fail. */
6628 status = cli_tdis(cli);
6629 if (NT_STATUS_IS_OK(status)) {
6630 d_printf("Second tdis with invalid vuid should fail - succeeded instead !.\n");
6634 /* Should be bad tid. */
6635 if (!check_error(__LINE__, cli, ERRSRV, ERRinvnid,
6636 NT_STATUS_NETWORK_NAME_DELETED)) {
6642 cli_rmdir(cli, "\\uid_reg_test");
6651 static const char *illegal_chars = "*\\/?<>|\":";
6652 static char force_shortname_chars[] = " +,.[];=\177";
6654 static NTSTATUS shortname_del_fn(const char *mnt, struct file_info *finfo,
6655 const char *mask, void *state)
6657 struct cli_state *pcli = (struct cli_state *)state;
6659 NTSTATUS status = NT_STATUS_OK;
6661 slprintf(fname, sizeof(fname), "\\shortname\\%s", finfo->name);
6663 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
6664 return NT_STATUS_OK;
6666 if (finfo->mode & aDIR) {
6667 status = cli_rmdir(pcli, fname);
6668 if (!NT_STATUS_IS_OK(status)) {
6669 printf("del_fn: failed to rmdir %s\n,", fname );
6672 status = cli_unlink(pcli, fname, aSYSTEM | aHIDDEN);
6673 if (!NT_STATUS_IS_OK(status)) {
6674 printf("del_fn: failed to unlink %s\n,", fname );
6686 static NTSTATUS shortname_list_fn(const char *mnt, struct file_info *finfo,
6687 const char *name, void *state)
6689 struct sn_state *s = (struct sn_state *)state;
6693 printf("shortname list: i = %d, name = |%s|, shortname = |%s|\n",
6694 i, finfo->name, finfo->short_name);
6697 if (strchr(force_shortname_chars, i)) {
6698 if (!finfo->short_name[0]) {
6699 /* Shortname not created when it should be. */
6700 d_printf("(%s) ERROR: Shortname was not created for file %s containing %d\n",
6701 __location__, finfo->name, i);
6704 } else if (finfo->short_name[0]){
6705 /* Shortname created when it should not be. */
6706 d_printf("(%s) ERROR: Shortname %s was created for file %s\n",
6707 __location__, finfo->short_name, finfo->name);
6711 return NT_STATUS_OK;
6714 static bool run_shortname_test(int dummy)
6716 static struct cli_state *cli;
6717 bool correct = True;
6722 printf("starting shortname test\n");
6724 if (!torture_open_connection(&cli, 0)) {
6728 cli_sockopt(cli, sockops);
6730 cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
6731 cli_list(cli, "\\shortname\\*", aDIR, shortname_del_fn, cli);
6732 cli_rmdir(cli, "\\shortname");
6734 if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\shortname"))) {
6735 d_printf("(%s) cli_mkdir of \\shortname failed: %s\n",
6736 __location__, cli_errstr(cli));
6741 strlcpy(fname, "\\shortname\\", sizeof(fname));
6742 strlcat(fname, "test .txt", sizeof(fname));
6746 for (i = 32; i < 128; i++) {
6748 uint16_t fnum = (uint16_t)-1;
6752 if (strchr(illegal_chars, i)) {
6757 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
6758 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum);
6759 if (!NT_STATUS_IS_OK(status)) {
6760 d_printf("(%s) cli_nt_create of %s failed: %s\n",
6761 __location__, fname, cli_errstr(cli));
6765 cli_close(cli, fnum);
6768 cli_list(cli, "\\shortname\\test*.*", 0, shortname_list_fn,
6770 if (s.matched != 1) {
6771 d_printf("(%s) failed to list %s: %s\n",
6772 __location__, fname, cli_errstr(cli));
6776 if (!NT_STATUS_IS_OK(cli_unlink(cli, fname, aSYSTEM | aHIDDEN))) {
6777 d_printf("(%s) failed to delete %s: %s\n",
6778 __location__, fname, cli_errstr(cli));
6791 cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
6792 cli_list(cli, "\\shortname\\*", aDIR, shortname_del_fn, cli);
6793 cli_rmdir(cli, "\\shortname");
6794 torture_close_connection(cli);
6798 static void pagedsearch_cb(struct tevent_req *req)
6801 struct tldap_message *msg;
6804 rc = tldap_search_paged_recv(req, talloc_tos(), &msg);
6805 if (rc != TLDAP_SUCCESS) {
6806 d_printf("tldap_search_paged_recv failed: %s\n",
6807 tldap_err2string(rc));
6810 if (tldap_msg_type(msg) != TLDAP_RES_SEARCH_ENTRY) {
6814 if (!tldap_entry_dn(msg, &dn)) {
6815 d_printf("tldap_entry_dn failed\n");
6818 d_printf("%s\n", dn);
6822 static bool run_tldap(int dummy)
6824 struct tldap_context *ld;
6827 struct sockaddr_storage addr;
6828 struct tevent_context *ev;
6829 struct tevent_req *req;
6833 if (!resolve_name(host, &addr, 0, false)) {
6834 d_printf("could not find host %s\n", host);
6837 status = open_socket_out(&addr, 389, 9999, &fd);
6838 if (!NT_STATUS_IS_OK(status)) {
6839 d_printf("open_socket_out failed: %s\n", nt_errstr(status));
6843 ld = tldap_context_create(talloc_tos(), fd);
6846 d_printf("tldap_context_create failed\n");
6850 rc = tldap_fetch_rootdse(ld);
6851 if (rc != TLDAP_SUCCESS) {
6852 d_printf("tldap_fetch_rootdse failed: %s\n",
6853 tldap_errstr(talloc_tos(), ld, rc));
6857 basedn = tldap_talloc_single_attribute(
6858 tldap_rootdse(ld), "defaultNamingContext", talloc_tos());
6859 if (basedn == NULL) {
6860 d_printf("no defaultNamingContext\n");
6863 d_printf("defaultNamingContext: %s\n", basedn);
6865 ev = tevent_context_init(talloc_tos());
6867 d_printf("tevent_context_init failed\n");
6871 req = tldap_search_paged_send(talloc_tos(), ev, ld, basedn,
6872 TLDAP_SCOPE_SUB, "(objectclass=*)",
6874 NULL, 0, NULL, 0, 0, 0, 0, 5);
6876 d_printf("tldap_search_paged_send failed\n");
6879 tevent_req_set_callback(req, pagedsearch_cb, NULL);
6881 tevent_req_poll(req, ev);
6885 /* test search filters against rootDSE */
6886 filter = "(&(|(name=samba)(nextRid<=10000000)(usnChanged>=10)(samba~=ambas)(!(name=s*m*a)))"
6887 "(|(name:=samba)(name:dn:2.5.13.5:=samba)(:dn:2.5.13.5:=samba)(!(name=*samba))))";
6889 rc = tldap_search(ld, "", TLDAP_SCOPE_BASE, filter,
6890 NULL, 0, 0, NULL, 0, NULL, 0, 0, 0, 0,
6891 talloc_tos(), NULL, NULL);
6892 if (rc != TLDAP_SUCCESS) {
6893 d_printf("tldap_search with complex filter failed: %s\n",
6894 tldap_errstr(talloc_tos(), ld, rc));
6902 /* Torture test to ensure no regression of :
6903 https://bugzilla.samba.org/show_bug.cgi?id=7084
6906 static bool run_dir_createtime(int dummy)
6908 struct cli_state *cli;
6909 const char *dname = "\\testdir";
6910 const char *fname = "\\testdir\\testfile";
6912 struct timespec create_time;
6913 struct timespec create_time1;
6917 if (!torture_open_connection(&cli, 0)) {
6921 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
6922 cli_rmdir(cli, dname);
6924 status = cli_mkdir(cli, dname);
6925 if (!NT_STATUS_IS_OK(status)) {
6926 printf("mkdir failed: %s\n", nt_errstr(status));
6930 status = cli_qpathinfo2(cli, dname, &create_time, NULL, NULL, NULL,
6932 if (!NT_STATUS_IS_OK(status)) {
6933 printf("cli_qpathinfo2 returned %s\n",
6938 /* Sleep 3 seconds, then create a file. */
6941 status = cli_open(cli, fname, O_RDWR | O_CREAT | O_EXCL,
6943 if (!NT_STATUS_IS_OK(status)) {
6944 printf("cli_open failed: %s\n", nt_errstr(status));
6948 status = cli_qpathinfo2(cli, dname, &create_time1, NULL, NULL, NULL,
6950 if (!NT_STATUS_IS_OK(status)) {
6951 printf("cli_qpathinfo2 (2) returned %s\n",
6956 if (timespec_compare(&create_time1, &create_time)) {
6957 printf("run_dir_createtime: create time was updated (error)\n");
6959 printf("run_dir_createtime: create time was not updated (correct)\n");
6965 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
6966 cli_rmdir(cli, dname);
6967 if (!torture_close_connection(cli)) {
6974 static bool run_streamerror(int dummy)
6976 struct cli_state *cli;
6977 const char *dname = "\\testdir";
6978 const char *streamname =
6979 "testdir:{4c8cc155-6c1e-11d1-8e41-00c04fb9386d}:$DATA";
6981 time_t change_time, access_time, write_time;
6983 uint16_t mode, fnum;
6986 if (!torture_open_connection(&cli, 0)) {
6990 cli_unlink(cli, "\\testdir\\*", aSYSTEM | aHIDDEN);
6991 cli_rmdir(cli, dname);
6993 status = cli_mkdir(cli, dname);
6994 if (!NT_STATUS_IS_OK(status)) {
6995 printf("mkdir failed: %s\n", nt_errstr(status));
6999 cli_qpathinfo1(cli, streamname, &change_time, &access_time, &write_time,
7001 status = cli_nt_error(cli);
7003 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
7004 printf("pathinfo returned %s, expected "
7005 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
7010 status = cli_ntcreate(cli, streamname, 0x16,
7011 FILE_READ_DATA|FILE_READ_EA|
7012 FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS,
7013 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
7014 FILE_OPEN, 0, 0, &fnum);
7016 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
7017 printf("ntcreate returned %s, expected "
7018 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
7024 cli_rmdir(cli, dname);
7028 static bool run_local_substitute(int dummy)
7032 ok &= subst_test("%U", "bla", "", -1, -1, "bla");
7033 ok &= subst_test("%u%U", "bla", "", -1, -1, "blabla");
7034 ok &= subst_test("%g", "", "", -1, -1, "NO_GROUP");
7035 ok &= subst_test("%G", "", "", -1, -1, "NO_GROUP");
7036 ok &= subst_test("%g", "", "", -1, 0, gidtoname(0));
7037 ok &= subst_test("%G", "", "", -1, 0, gidtoname(0));
7038 ok &= subst_test("%D%u", "u", "dom", -1, 0, "domu");
7039 ok &= subst_test("%i %I", "", "", -1, -1, "0.0.0.0 0.0.0.0");
7041 /* Different captialization rules in sub_basic... */
7043 ok &= (strcmp(talloc_sub_basic(talloc_tos(), "BLA", "dom", "%U%D"),
7049 static bool run_local_base64(int dummy)
7054 for (i=1; i<2000; i++) {
7055 DATA_BLOB blob1, blob2;
7058 blob1.data = talloc_array(talloc_tos(), uint8_t, i);
7060 generate_random_buffer(blob1.data, blob1.length);
7062 b64 = base64_encode_data_blob(talloc_tos(), blob1);
7064 d_fprintf(stderr, "base64_encode_data_blob failed "
7065 "for %d bytes\n", i);
7068 blob2 = base64_decode_data_blob(b64);
7071 if (data_blob_cmp(&blob1, &blob2)) {
7072 d_fprintf(stderr, "data_blob_cmp failed for %d "
7076 TALLOC_FREE(blob1.data);
7077 data_blob_free(&blob2);
7082 static bool run_local_gencache(int dummy)
7088 if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
7089 d_printf("%s: gencache_set() failed\n", __location__);
7093 if (!gencache_get("foo", NULL, NULL)) {
7094 d_printf("%s: gencache_get() failed\n", __location__);
7098 if (!gencache_get("foo", &val, &tm)) {
7099 d_printf("%s: gencache_get() failed\n", __location__);
7103 if (strcmp(val, "bar") != 0) {
7104 d_printf("%s: gencache_get() returned %s, expected %s\n",
7105 __location__, val, "bar");
7112 if (!gencache_del("foo")) {
7113 d_printf("%s: gencache_del() failed\n", __location__);
7116 if (gencache_del("foo")) {
7117 d_printf("%s: second gencache_del() succeeded\n",
7122 if (gencache_get("foo", &val, &tm)) {
7123 d_printf("%s: gencache_get() on deleted entry "
7124 "succeeded\n", __location__);
7128 blob = data_blob_string_const_null("bar");
7129 tm = time(NULL) + 60;
7131 if (!gencache_set_data_blob("foo", &blob, tm)) {
7132 d_printf("%s: gencache_set_data_blob() failed\n", __location__);
7136 if (!gencache_get_data_blob("foo", &blob, NULL, NULL)) {
7137 d_printf("%s: gencache_get_data_blob() failed\n", __location__);
7141 if (strcmp((const char *)blob.data, "bar") != 0) {
7142 d_printf("%s: gencache_get_data_blob() returned %s, expected %s\n",
7143 __location__, (const char *)blob.data, "bar");
7144 data_blob_free(&blob);
7148 data_blob_free(&blob);
7150 if (!gencache_del("foo")) {
7151 d_printf("%s: gencache_del() failed\n", __location__);
7154 if (gencache_del("foo")) {
7155 d_printf("%s: second gencache_del() succeeded\n",
7160 if (gencache_get_data_blob("foo", &blob, NULL, NULL)) {
7161 d_printf("%s: gencache_get_data_blob() on deleted entry "
7162 "succeeded\n", __location__);
7169 static bool rbt_testval(struct db_context *db, const char *key,
7172 struct db_record *rec;
7173 TDB_DATA data = string_tdb_data(value);
7177 rec = db->fetch_locked(db, db, string_tdb_data(key));
7179 d_fprintf(stderr, "fetch_locked failed\n");
7182 status = rec->store(rec, data, 0);
7183 if (!NT_STATUS_IS_OK(status)) {
7184 d_fprintf(stderr, "store failed: %s\n", nt_errstr(status));
7189 rec = db->fetch_locked(db, db, string_tdb_data(key));
7191 d_fprintf(stderr, "second fetch_locked failed\n");
7194 if ((rec->value.dsize != data.dsize)
7195 || (memcmp(rec->value.dptr, data.dptr, data.dsize) != 0)) {
7196 d_fprintf(stderr, "Got wrong data back\n");
7206 static bool run_local_rbtree(int dummy)
7208 struct db_context *db;
7212 db = db_open_rbt(NULL);
7215 d_fprintf(stderr, "db_open_rbt failed\n");
7219 for (i=0; i<1000; i++) {
7222 if (asprintf(&key, "key%ld", random()) == -1) {
7225 if (asprintf(&value, "value%ld", random()) == -1) {
7230 if (!rbt_testval(db, key, value)) {
7237 if (asprintf(&value, "value%ld", random()) == -1) {
7242 if (!rbt_testval(db, key, value)) {
7259 struct talloc_dict_test {
7263 static int talloc_dict_traverse_fn(DATA_BLOB key, void *data, void *priv)
7265 int *count = (int *)priv;
7270 static bool run_local_talloc_dict(int dummy)
7272 struct talloc_dict *dict;
7273 struct talloc_dict_test *t;
7276 dict = talloc_dict_init(talloc_tos());
7281 t = talloc(talloc_tos(), struct talloc_dict_test);
7288 if (!talloc_dict_set(dict, data_blob_const(&key, sizeof(key)), t)) {
7293 if (talloc_dict_traverse(dict, talloc_dict_traverse_fn, &count) != 0) {
7306 static bool run_local_string_to_sid(int dummy) {
7309 if (string_to_sid(&sid, "S--1-5-32-545")) {
7310 printf("allowing S--1-5-32-545\n");
7313 if (string_to_sid(&sid, "S-1-5-32-+545")) {
7314 printf("allowing S-1-5-32-+545\n");
7317 if (string_to_sid(&sid, "S-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0")) {
7318 printf("allowing S-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0\n");
7321 if (string_to_sid(&sid, "S-1-5-32-545-abc")) {
7322 printf("allowing S-1-5-32-545-abc\n");
7325 if (!string_to_sid(&sid, "S-1-5-32-545")) {
7326 printf("could not parse S-1-5-32-545\n");
7329 if (!dom_sid_equal(&sid, &global_sid_Builtin_Users)) {
7330 printf("mis-parsed S-1-5-32-545 as %s\n",
7331 sid_string_tos(&sid));
7337 static bool run_local_binary_to_sid(int dummy) {
7338 struct dom_sid *sid = talloc(NULL, struct dom_sid);
7339 static const char good_binary_sid[] = {
7340 0x1, /* revision number */
7342 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
7343 0x1, 0x1, 0x1, 0x1, /* auth[0] */
7344 0x1, 0x1, 0x1, 0x1, /* auth[1] */
7345 0x1, 0x1, 0x1, 0x1, /* auth[2] */
7346 0x1, 0x1, 0x1, 0x1, /* auth[3] */
7347 0x1, 0x1, 0x1, 0x1, /* auth[4] */
7348 0x1, 0x1, 0x1, 0x1, /* auth[5] */
7349 0x1, 0x1, 0x1, 0x1, /* auth[6] */
7350 0x1, 0x1, 0x1, 0x1, /* auth[7] */
7351 0x1, 0x1, 0x1, 0x1, /* auth[8] */
7352 0x1, 0x1, 0x1, 0x1, /* auth[9] */
7353 0x1, 0x1, 0x1, 0x1, /* auth[10] */
7354 0x1, 0x1, 0x1, 0x1, /* auth[11] */
7355 0x1, 0x1, 0x1, 0x1, /* auth[12] */
7356 0x1, 0x1, 0x1, 0x1, /* auth[13] */
7357 0x1, 0x1, 0x1, 0x1, /* auth[14] */
7360 static const char long_binary_sid[] = {
7361 0x1, /* revision number */
7363 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
7364 0x1, 0x1, 0x1, 0x1, /* auth[0] */
7365 0x1, 0x1, 0x1, 0x1, /* auth[1] */
7366 0x1, 0x1, 0x1, 0x1, /* auth[2] */
7367 0x1, 0x1, 0x1, 0x1, /* auth[3] */
7368 0x1, 0x1, 0x1, 0x1, /* auth[4] */
7369 0x1, 0x1, 0x1, 0x1, /* auth[5] */
7370 0x1, 0x1, 0x1, 0x1, /* auth[6] */
7371 0x1, 0x1, 0x1, 0x1, /* auth[7] */
7372 0x1, 0x1, 0x1, 0x1, /* auth[8] */
7373 0x1, 0x1, 0x1, 0x1, /* auth[9] */
7374 0x1, 0x1, 0x1, 0x1, /* auth[10] */
7375 0x1, 0x1, 0x1, 0x1, /* auth[11] */
7376 0x1, 0x1, 0x1, 0x1, /* auth[12] */
7377 0x1, 0x1, 0x1, 0x1, /* auth[13] */
7378 0x1, 0x1, 0x1, 0x1, /* auth[14] */
7379 0x1, 0x1, 0x1, 0x1, /* auth[15] */
7380 0x1, 0x1, 0x1, 0x1, /* auth[16] */
7381 0x1, 0x1, 0x1, 0x1, /* auth[17] */
7384 static const char long_binary_sid2[] = {
7385 0x1, /* revision number */
7387 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
7388 0x1, 0x1, 0x1, 0x1, /* auth[0] */
7389 0x1, 0x1, 0x1, 0x1, /* auth[1] */
7390 0x1, 0x1, 0x1, 0x1, /* auth[2] */
7391 0x1, 0x1, 0x1, 0x1, /* auth[3] */
7392 0x1, 0x1, 0x1, 0x1, /* auth[4] */
7393 0x1, 0x1, 0x1, 0x1, /* auth[5] */
7394 0x1, 0x1, 0x1, 0x1, /* auth[6] */
7395 0x1, 0x1, 0x1, 0x1, /* auth[7] */
7396 0x1, 0x1, 0x1, 0x1, /* auth[8] */
7397 0x1, 0x1, 0x1, 0x1, /* auth[9] */
7398 0x1, 0x1, 0x1, 0x1, /* auth[10] */
7399 0x1, 0x1, 0x1, 0x1, /* auth[11] */
7400 0x1, 0x1, 0x1, 0x1, /* auth[12] */
7401 0x1, 0x1, 0x1, 0x1, /* auth[13] */
7402 0x1, 0x1, 0x1, 0x1, /* auth[14] */
7403 0x1, 0x1, 0x1, 0x1, /* auth[15] */
7404 0x1, 0x1, 0x1, 0x1, /* auth[16] */
7405 0x1, 0x1, 0x1, 0x1, /* auth[17] */
7406 0x1, 0x1, 0x1, 0x1, /* auth[18] */
7407 0x1, 0x1, 0x1, 0x1, /* auth[19] */
7408 0x1, 0x1, 0x1, 0x1, /* auth[20] */
7409 0x1, 0x1, 0x1, 0x1, /* auth[21] */
7410 0x1, 0x1, 0x1, 0x1, /* auth[22] */
7411 0x1, 0x1, 0x1, 0x1, /* auth[23] */
7412 0x1, 0x1, 0x1, 0x1, /* auth[24] */
7413 0x1, 0x1, 0x1, 0x1, /* auth[25] */
7414 0x1, 0x1, 0x1, 0x1, /* auth[26] */
7415 0x1, 0x1, 0x1, 0x1, /* auth[27] */
7416 0x1, 0x1, 0x1, 0x1, /* auth[28] */
7417 0x1, 0x1, 0x1, 0x1, /* auth[29] */
7418 0x1, 0x1, 0x1, 0x1, /* auth[30] */
7419 0x1, 0x1, 0x1, 0x1, /* auth[31] */
7422 if (!sid_parse(good_binary_sid, sizeof(good_binary_sid), sid)) {
7425 if (sid_parse(long_binary_sid2, sizeof(long_binary_sid2), sid)) {
7428 if (sid_parse(long_binary_sid, sizeof(long_binary_sid), sid)) {
7434 /* Split a path name into filename and stream name components. Canonicalise
7435 * such that an implicit $DATA token is always explicit.
7437 * The "specification" of this function can be found in the
7438 * run_local_stream_name() function in torture.c, I've tried those
7439 * combinations against a W2k3 server.
7442 static NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
7443 char **pbase, char **pstream)
7446 char *stream = NULL;
7447 char *sname; /* stream name */
7448 const char *stype; /* stream type */
7450 DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
7452 sname = strchr_m(fname, ':');
7454 if (lp_posix_pathnames() || (sname == NULL)) {
7455 if (pbase != NULL) {
7456 base = talloc_strdup(mem_ctx, fname);
7457 NT_STATUS_HAVE_NO_MEMORY(base);
7462 if (pbase != NULL) {
7463 base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
7464 NT_STATUS_HAVE_NO_MEMORY(base);
7469 stype = strchr_m(sname, ':');
7471 if (stype == NULL) {
7472 sname = talloc_strdup(mem_ctx, sname);
7476 if (StrCaseCmp(stype, ":$DATA") != 0) {
7478 * If there is an explicit stream type, so far we only
7479 * allow $DATA. Is there anything else allowed? -- vl
7481 DEBUG(10, ("[%s] is an invalid stream type\n", stype));
7483 return NT_STATUS_OBJECT_NAME_INVALID;
7485 sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
7489 if (sname == NULL) {
7491 return NT_STATUS_NO_MEMORY;
7494 if (sname[0] == '\0') {
7496 * no stream name, so no stream
7501 if (pstream != NULL) {
7502 stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
7503 if (stream == NULL) {
7506 return NT_STATUS_NO_MEMORY;
7509 * upper-case the type field
7511 strupper_m(strchr_m(stream, ':')+1);
7515 if (pbase != NULL) {
7518 if (pstream != NULL) {
7521 return NT_STATUS_OK;
7524 static bool test_stream_name(const char *fname, const char *expected_base,
7525 const char *expected_stream,
7526 NTSTATUS expected_status)
7530 char *stream = NULL;
7532 status = split_ntfs_stream_name(talloc_tos(), fname, &base, &stream);
7533 if (!NT_STATUS_EQUAL(status, expected_status)) {
7537 if (!NT_STATUS_IS_OK(status)) {
7541 if (base == NULL) goto error;
7543 if (strcmp(expected_base, base) != 0) goto error;
7545 if ((expected_stream != NULL) && (stream == NULL)) goto error;
7546 if ((expected_stream == NULL) && (stream != NULL)) goto error;
7548 if ((stream != NULL) && (strcmp(expected_stream, stream) != 0))
7552 TALLOC_FREE(stream);
7556 d_fprintf(stderr, "Do test_stream(%s, %s, %s, %s)\n",
7557 fname, expected_base ? expected_base : "<NULL>",
7558 expected_stream ? expected_stream : "<NULL>",
7559 nt_errstr(expected_status));
7560 d_fprintf(stderr, "-> base=%s, stream=%s, status=%s\n",
7561 base ? base : "<NULL>", stream ? stream : "<NULL>",
7564 TALLOC_FREE(stream);
7568 static bool run_local_stream_name(int dummy)
7572 ret &= test_stream_name(
7573 "bla", "bla", NULL, NT_STATUS_OK);
7574 ret &= test_stream_name(
7575 "bla::$DATA", "bla", NULL, NT_STATUS_OK);
7576 ret &= test_stream_name(
7577 "bla:blub:", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
7578 ret &= test_stream_name(
7579 "bla::", NULL, NULL, NT_STATUS_OBJECT_NAME_INVALID);
7580 ret &= test_stream_name(
7581 "bla::123", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
7582 ret &= test_stream_name(
7583 "bla:$DATA", "bla", "$DATA:$DATA", NT_STATUS_OK);
7584 ret &= test_stream_name(
7585 "bla:x:$DATA", "bla", "x:$DATA", NT_STATUS_OK);
7586 ret &= test_stream_name(
7587 "bla:x", "bla", "x:$DATA", NT_STATUS_OK);
7592 static bool data_blob_equal(DATA_BLOB a, DATA_BLOB b)
7594 if (a.length != b.length) {
7595 printf("a.length=%d != b.length=%d\n",
7596 (int)a.length, (int)b.length);
7599 if (memcmp(a.data, b.data, a.length) != 0) {
7600 printf("a.data and b.data differ\n");
7606 static bool run_local_memcache(int dummy)
7608 struct memcache *cache;
7610 DATA_BLOB d1, d2, d3;
7611 DATA_BLOB v1, v2, v3;
7613 TALLOC_CTX *mem_ctx;
7615 size_t size1, size2;
7618 cache = memcache_init(NULL, 100);
7620 if (cache == NULL) {
7621 printf("memcache_init failed\n");
7625 d1 = data_blob_const("d1", 2);
7626 d2 = data_blob_const("d2", 2);
7627 d3 = data_blob_const("d3", 2);
7629 k1 = data_blob_const("d1", 2);
7630 k2 = data_blob_const("d2", 2);
7632 memcache_add(cache, STAT_CACHE, k1, d1);
7633 memcache_add(cache, GETWD_CACHE, k2, d2);
7635 if (!memcache_lookup(cache, STAT_CACHE, k1, &v1)) {
7636 printf("could not find k1\n");
7639 if (!data_blob_equal(d1, v1)) {
7643 if (!memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
7644 printf("could not find k2\n");
7647 if (!data_blob_equal(d2, v2)) {
7651 memcache_add(cache, STAT_CACHE, k1, d3);
7653 if (!memcache_lookup(cache, STAT_CACHE, k1, &v3)) {
7654 printf("could not find replaced k1\n");
7657 if (!data_blob_equal(d3, v3)) {
7661 memcache_add(cache, GETWD_CACHE, k1, d1);
7663 if (memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
7664 printf("Did find k2, should have been purged\n");
7670 cache = memcache_init(NULL, 0);
7672 mem_ctx = talloc_init("foo");
7674 str1 = talloc_strdup(mem_ctx, "string1");
7675 str2 = talloc_strdup(mem_ctx, "string2");
7677 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
7678 data_blob_string_const("torture"), &str1);
7679 size1 = talloc_total_size(cache);
7681 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
7682 data_blob_string_const("torture"), &str2);
7683 size2 = talloc_total_size(cache);
7685 printf("size1=%d, size2=%d\n", (int)size1, (int)size2);
7687 if (size2 > size1) {
7688 printf("memcache leaks memory!\n");
7698 static void wbclient_done(struct tevent_req *req)
7701 struct winbindd_response *wb_resp;
7702 int *i = (int *)tevent_req_callback_data_void(req);
7704 wbc_err = wb_trans_recv(req, req, &wb_resp);
7707 d_printf("wb_trans_recv %d returned %s\n", *i, wbcErrorString(wbc_err));
7710 static bool run_local_wbclient(int dummy)
7712 struct event_context *ev;
7713 struct wb_context **wb_ctx;
7714 struct winbindd_request wb_req;
7715 bool result = false;
7718 BlockSignals(True, SIGPIPE);
7720 ev = tevent_context_init_byname(talloc_tos(), "epoll");
7725 wb_ctx = TALLOC_ARRAY(ev, struct wb_context *, nprocs);
7726 if (wb_ctx == NULL) {
7730 ZERO_STRUCT(wb_req);
7731 wb_req.cmd = WINBINDD_PING;
7733 d_printf("nprocs=%d, numops=%d\n", (int)nprocs, (int)torture_numops);
7735 for (i=0; i<nprocs; i++) {
7736 wb_ctx[i] = wb_context_init(ev, NULL);
7737 if (wb_ctx[i] == NULL) {
7740 for (j=0; j<torture_numops; j++) {
7741 struct tevent_req *req;
7742 req = wb_trans_send(ev, ev, wb_ctx[i],
7743 (j % 2) == 0, &wb_req);
7747 tevent_req_set_callback(req, wbclient_done, &i);
7753 while (i < nprocs * torture_numops) {
7754 event_loop_once(ev);
7763 static void getaddrinfo_finished(struct tevent_req *req)
7765 char *name = (char *)tevent_req_callback_data_void(req);
7766 struct addrinfo *ainfo;
7769 res = getaddrinfo_recv(req, &ainfo);
7771 d_printf("gai(%s) returned %s\n", name, gai_strerror(res));
7774 d_printf("gai(%s) succeeded\n", name);
7775 freeaddrinfo(ainfo);
7778 static bool run_getaddrinfo_send(int dummy)
7780 TALLOC_CTX *frame = talloc_stackframe();
7781 struct fncall_context *ctx;
7782 struct tevent_context *ev;
7783 bool result = false;
7784 const char *names[4] = { "www.samba.org", "notfound.samba.org",
7785 "www.slashdot.org", "heise.de" };
7786 struct tevent_req *reqs[4];
7789 ev = event_context_init(frame);
7794 ctx = fncall_context_init(frame, 4);
7796 for (i=0; i<ARRAY_SIZE(names); i++) {
7797 reqs[i] = getaddrinfo_send(frame, ev, ctx, names[i], NULL,
7799 if (reqs[i] == NULL) {
7802 tevent_req_set_callback(reqs[i], getaddrinfo_finished,
7806 for (i=0; i<ARRAY_SIZE(reqs); i++) {
7807 tevent_loop_once(ev);
7816 static bool dbtrans_inc(struct db_context *db)
7818 struct db_record *rec;
7823 rec = db->fetch_locked(db, db, string_term_tdb_data("transtest"));
7825 printf(__location__ "fetch_lock failed\n");
7829 if (rec->value.dsize != sizeof(uint32_t)) {
7830 printf(__location__ "value.dsize = %d\n",
7831 (int)rec->value.dsize);
7835 val = (uint32_t *)rec->value.dptr;
7838 status = rec->store(rec, make_tdb_data((uint8_t *)val,
7841 if (!NT_STATUS_IS_OK(status)) {
7842 printf(__location__ "store failed: %s\n",
7853 static bool run_local_dbtrans(int dummy)
7855 struct db_context *db;
7856 struct db_record *rec;
7861 db = db_open(talloc_tos(), "transtest.tdb", 0, TDB_DEFAULT,
7862 O_RDWR|O_CREAT, 0600);
7864 printf("Could not open transtest.db\n");
7868 res = db->transaction_start(db);
7870 printf(__location__ "transaction_start failed\n");
7874 rec = db->fetch_locked(db, db, string_term_tdb_data("transtest"));
7876 printf(__location__ "fetch_lock failed\n");
7880 if (rec->value.dptr == NULL) {
7882 status = rec->store(
7883 rec, make_tdb_data((uint8_t *)&initial,
7886 if (!NT_STATUS_IS_OK(status)) {
7887 printf(__location__ "store returned %s\n",
7895 res = db->transaction_commit(db);
7897 printf(__location__ "transaction_commit failed\n");
7905 res = db->transaction_start(db);
7907 printf(__location__ "transaction_start failed\n");
7911 if (!dbwrap_fetch_uint32(db, "transtest", &val)) {
7912 printf(__location__ "dbwrap_fetch_uint32 failed\n");
7916 for (i=0; i<10; i++) {
7917 if (!dbtrans_inc(db)) {
7922 if (!dbwrap_fetch_uint32(db, "transtest", &val2)) {
7923 printf(__location__ "dbwrap_fetch_uint32 failed\n");
7927 if (val2 != val + 10) {
7928 printf(__location__ "val=%d, val2=%d\n",
7929 (int)val, (int)val2);
7933 printf("val2=%d\r", val2);
7935 res = db->transaction_commit(db);
7937 printf(__location__ "transaction_commit failed\n");
7947 * Just a dummy test to be run under a debugger. There's no real way
7948 * to inspect the tevent_select specific function from outside of
7952 static bool run_local_tevent_select(int dummy)
7954 struct tevent_context *ev;
7955 struct tevent_fd *fd1, *fd2;
7956 bool result = false;
7958 ev = tevent_context_init_byname(NULL, "select");
7960 d_fprintf(stderr, "tevent_context_init_byname failed\n");
7964 fd1 = tevent_add_fd(ev, ev, 2, 0, NULL, NULL);
7966 d_fprintf(stderr, "tevent_add_fd failed\n");
7969 fd2 = tevent_add_fd(ev, ev, 3, 0, NULL, NULL);
7971 d_fprintf(stderr, "tevent_add_fd failed\n");
7976 fd2 = tevent_add_fd(ev, ev, 1, 0, NULL, NULL);
7978 d_fprintf(stderr, "tevent_add_fd failed\n");
7988 static double create_procs(bool (*fn)(int), bool *result)
7991 volatile pid_t *child_status;
7992 volatile bool *child_status_out;
7995 struct timeval start;
7999 child_status = (volatile pid_t *)shm_setup(sizeof(pid_t)*nprocs);
8000 if (!child_status) {
8001 printf("Failed to setup shared memory\n");
8005 child_status_out = (volatile bool *)shm_setup(sizeof(bool)*nprocs);
8006 if (!child_status_out) {
8007 printf("Failed to setup result status shared memory\n");
8011 for (i = 0; i < nprocs; i++) {
8012 child_status[i] = 0;
8013 child_status_out[i] = True;
8016 start = timeval_current();
8018 for (i=0;i<nprocs;i++) {
8021 pid_t mypid = getpid();
8022 sys_srandom(((int)mypid) ^ ((int)time(NULL)));
8024 slprintf(myname,sizeof(myname),"CLIENT%d", i);
8027 if (torture_open_connection(¤t_cli, i)) break;
8029 printf("pid %d failed to start\n", (int)getpid());
8035 child_status[i] = getpid();
8037 while (child_status[i] && timeval_elapsed(&start) < 5) smb_msleep(2);
8039 child_status_out[i] = fn(i);
8046 for (i=0;i<nprocs;i++) {
8047 if (child_status[i]) synccount++;
8049 if (synccount == nprocs) break;
8051 } while (timeval_elapsed(&start) < 30);
8053 if (synccount != nprocs) {
8054 printf("FAILED TO START %d CLIENTS (started %d)\n", nprocs, synccount);
8056 return timeval_elapsed(&start);
8059 /* start the client load */
8060 start = timeval_current();
8062 for (i=0;i<nprocs;i++) {
8063 child_status[i] = 0;
8066 printf("%d clients started\n", nprocs);
8068 for (i=0;i<nprocs;i++) {
8069 while (waitpid(0, &status, 0) == -1 && errno == EINTR) /* noop */ ;
8074 for (i=0;i<nprocs;i++) {
8075 if (!child_status_out[i]) {
8079 return timeval_elapsed(&start);
8082 #define FLAG_MULTIPROC 1
8089 {"FDPASS", run_fdpasstest, 0},
8090 {"LOCK1", run_locktest1, 0},
8091 {"LOCK2", run_locktest2, 0},
8092 {"LOCK3", run_locktest3, 0},
8093 {"LOCK4", run_locktest4, 0},
8094 {"LOCK5", run_locktest5, 0},
8095 {"LOCK6", run_locktest6, 0},
8096 {"LOCK7", run_locktest7, 0},
8097 {"LOCK8", run_locktest8, 0},
8098 {"LOCK9", run_locktest9, 0},
8099 {"UNLINK", run_unlinktest, 0},
8100 {"BROWSE", run_browsetest, 0},
8101 {"ATTR", run_attrtest, 0},
8102 {"TRANS2", run_trans2test, 0},
8103 {"MAXFID", run_maxfidtest, FLAG_MULTIPROC},
8104 {"TORTURE",run_torture, FLAG_MULTIPROC},
8105 {"RANDOMIPC", run_randomipc, 0},
8106 {"NEGNOWAIT", run_negprot_nowait, 0},
8107 {"NBENCH", run_nbench, 0},
8108 {"NBENCH2", run_nbench2, 0},
8109 {"OPLOCK1", run_oplock1, 0},
8110 {"OPLOCK2", run_oplock2, 0},
8111 {"OPLOCK3", run_oplock3, 0},
8112 {"OPLOCK4", run_oplock4, 0},
8113 {"DIR", run_dirtest, 0},
8114 {"DIR1", run_dirtest1, 0},
8115 {"DIR-CREATETIME", run_dir_createtime, 0},
8116 {"DENY1", torture_denytest1, 0},
8117 {"DENY2", torture_denytest2, 0},
8118 {"TCON", run_tcon_test, 0},
8119 {"TCONDEV", run_tcon_devtype_test, 0},
8120 {"RW1", run_readwritetest, 0},
8121 {"RW2", run_readwritemulti, FLAG_MULTIPROC},
8122 {"RW3", run_readwritelarge, 0},
8123 {"RW-SIGNING", run_readwritelarge_signtest, 0},
8124 {"OPEN", run_opentest, 0},
8125 {"POSIX", run_simple_posix_open_test, 0},
8126 {"POSIX-APPEND", run_posix_append, 0},
8127 {"ASYNC-ECHO", run_async_echo, 0},
8128 { "UID-REGRESSION-TEST", run_uid_regression_test, 0},
8129 { "SHORTNAME-TEST", run_shortname_test, 0},
8130 { "ADDRCHANGE", run_addrchange, 0},
8132 {"OPENATTR", run_openattrtest, 0},
8134 {"XCOPY", run_xcopy, 0},
8135 {"RENAME", run_rename, 0},
8136 {"DELETE", run_deletetest, 0},
8137 {"DELETE-LN", run_deletetest_ln, 0},
8138 {"PROPERTIES", run_properties, 0},
8139 {"MANGLE", torture_mangle, 0},
8140 {"MANGLE1", run_mangle1, 0},
8141 {"W2K", run_w2ktest, 0},
8142 {"TRANS2SCAN", torture_trans2_scan, 0},
8143 {"NTTRANSSCAN", torture_nttrans_scan, 0},
8144 {"UTABLE", torture_utable, 0},
8145 {"CASETABLE", torture_casetable, 0},
8146 {"ERRMAPEXTRACT", run_error_map_extract, 0},
8147 {"PIPE_NUMBER", run_pipe_number, 0},
8148 {"TCON2", run_tcon2_test, 0},
8149 {"IOCTL", torture_ioctl_test, 0},
8150 {"CHKPATH", torture_chkpath_test, 0},
8151 {"FDSESS", run_fdsesstest, 0},
8152 { "EATEST", run_eatest, 0},
8153 { "SESSSETUP_BENCH", run_sesssetup_bench, 0},
8154 { "CHAIN1", run_chain1, 0},
8155 { "CHAIN2", run_chain2, 0},
8156 { "WINDOWS-WRITE", run_windows_write, 0},
8157 { "CLI_ECHO", run_cli_echo, 0},
8158 { "GETADDRINFO", run_getaddrinfo_send, 0},
8159 { "TLDAP", run_tldap },
8160 { "STREAMERROR", run_streamerror },
8161 { "NOTIFY-BENCH", run_notify_bench },
8162 { "BAD-NBT-SESSION", run_bad_nbt_session },
8163 { "SMB-ANY-CONNECT", run_smb_any_connect },
8164 { "LOCAL-SUBSTITUTE", run_local_substitute, 0},
8165 { "LOCAL-GENCACHE", run_local_gencache, 0},
8166 { "LOCAL-TALLOC-DICT", run_local_talloc_dict, 0},
8167 { "LOCAL-BASE64", run_local_base64, 0},
8168 { "LOCAL-RBTREE", run_local_rbtree, 0},
8169 { "LOCAL-MEMCACHE", run_local_memcache, 0},
8170 { "LOCAL-STREAM-NAME", run_local_stream_name, 0},
8171 { "LOCAL-WBCLIENT", run_local_wbclient, 0},
8172 { "LOCAL-string_to_sid", run_local_string_to_sid, 0},
8173 { "LOCAL-binary_to_sid", run_local_binary_to_sid, 0},
8174 { "LOCAL-DBTRANS", run_local_dbtrans, 0},
8175 { "LOCAL-TEVENT-SELECT", run_local_tevent_select, 0},
8180 /****************************************************************************
8181 run a specified test or "ALL"
8182 ****************************************************************************/
8183 static bool run_test(const char *name)
8190 if (strequal(name,"ALL")) {
8191 for (i=0;torture_ops[i].name;i++) {
8192 run_test(torture_ops[i].name);
8197 for (i=0;torture_ops[i].name;i++) {
8198 fstr_sprintf(randomfname, "\\XX%x",
8199 (unsigned)random());
8201 if (strequal(name, torture_ops[i].name)) {
8203 printf("Running %s\n", name);
8204 if (torture_ops[i].flags & FLAG_MULTIPROC) {
8205 t = create_procs(torture_ops[i].fn, &result);
8208 printf("TEST %s FAILED!\n", name);
8211 struct timeval start;
8212 start = timeval_current();
8213 if (!torture_ops[i].fn(0)) {
8215 printf("TEST %s FAILED!\n", name);
8217 t = timeval_elapsed(&start);
8219 printf("%s took %g secs\n\n", name, t);
8224 printf("Did not find a test named %s\n", name);
8232 static void usage(void)
8236 printf("WARNING samba4 test suite is much more complete nowadays.\n");
8237 printf("Please use samba4 torture.\n\n");
8239 printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
8241 printf("\t-d debuglevel\n");
8242 printf("\t-U user%%pass\n");
8243 printf("\t-k use kerberos\n");
8244 printf("\t-N numprocs\n");
8245 printf("\t-n my_netbios_name\n");
8246 printf("\t-W workgroup\n");
8247 printf("\t-o num_operations\n");
8248 printf("\t-O socket_options\n");
8249 printf("\t-m maximum protocol\n");
8250 printf("\t-L use oplocks\n");
8251 printf("\t-c CLIENT.TXT specify client load file for NBENCH\n");
8252 printf("\t-A showall\n");
8253 printf("\t-p port\n");
8254 printf("\t-s seed\n");
8255 printf("\t-b unclist_filename specify multiple shares for multiple connections\n");
8258 printf("tests are:");
8259 for (i=0;torture_ops[i].name;i++) {
8260 printf(" %s", torture_ops[i].name);
8264 printf("default test is ALL\n");
8269 /****************************************************************************
8271 ****************************************************************************/
8272 int main(int argc,char *argv[])
8278 bool correct = True;
8279 TALLOC_CTX *frame = talloc_stackframe();
8280 int seed = time(NULL);
8282 #ifdef HAVE_SETBUFFER
8283 setbuffer(stdout, NULL, 0);
8286 setup_logging("smbtorture", DEBUG_STDOUT);
8290 if (is_default_dyn_CONFIGFILE()) {
8291 if(getenv("SMB_CONF_PATH")) {
8292 set_dyn_CONFIGFILE(getenv("SMB_CONF_PATH"));
8295 lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
8302 for(p = argv[1]; *p; p++)
8306 if (strncmp(argv[1], "//", 2)) {
8310 fstrcpy(host, &argv[1][2]);
8311 p = strchr_m(&host[2],'/');
8316 fstrcpy(share, p+1);
8318 fstrcpy(myname, get_myname(talloc_tos()));
8320 fprintf(stderr, "Failed to get my hostname.\n");
8324 if (*username == 0 && getenv("LOGNAME")) {
8325 fstrcpy(username,getenv("LOGNAME"));
8331 fstrcpy(workgroup, lp_workgroup());
8333 while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ll:d:Aec:ks:b:B:")) != EOF) {
8336 port_to_use = atoi(optarg);
8339 seed = atoi(optarg);
8342 fstrcpy(workgroup,optarg);
8345 max_protocol = interpret_protocol(optarg, max_protocol);
8348 nprocs = atoi(optarg);
8351 torture_numops = atoi(optarg);
8354 lp_set_cmdline("log level", optarg);
8363 local_path = optarg;
8366 torture_showall = True;
8369 fstrcpy(myname, optarg);
8372 client_txt = optarg;
8379 use_kerberos = True;
8381 d_printf("No kerberos support compiled in\n");
8387 fstrcpy(username,optarg);
8388 p = strchr_m(username,'%');
8391 fstrcpy(password, p+1);
8396 fstrcpy(multishare_conn_fname, optarg);
8397 use_multishare_conn = True;
8400 torture_blocksize = atoi(optarg);
8403 printf("Unknown option %c (%d)\n", (char)opt, opt);
8408 d_printf("using seed %d\n", seed);
8412 if(use_kerberos && !gotuser) gotpass = True;
8415 p = getpass("Password:");
8417 fstrcpy(password, p);
8422 printf("host=%s share=%s user=%s myname=%s\n",
8423 host, share, username, myname);
8425 if (argc == optind) {
8426 correct = run_test("ALL");
8428 for (i=optind;i<argc;i++) {
8429 if (!run_test(argv[i])) {