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 "system/shmem.h"
23 #include "wbc_async.h"
24 #include "torture/proto.h"
25 #include "libcli/security/security.h"
27 #include "tldap_util.h"
28 #include "../librpc/gen_ndr/svcctl.h"
29 #include "../lib/util/memcache.h"
30 #include "nsswitch/winbind_client.h"
31 #include "dbwrap/dbwrap.h"
32 #include "dbwrap/dbwrap_open.h"
33 #include "dbwrap/dbwrap_rbt.h"
34 #include "talloc_dict.h"
35 #include "async_smb.h"
36 #include "libsmb/libsmb.h"
37 #include "libsmb/clirap.h"
39 #include "libsmb/nmblib.h"
40 #include "../lib/util/tevent_ntstatus.h"
42 #include "../libcli/smb/read_smb.h"
43 #include "../libcli/smb/smbXcli_base.h"
44 #include "lib/util/sys_rw_data.h"
49 fstring host, workgroup, share, password, username, myname;
50 static const char *sockops="TCP_NODELAY";
52 static int port_to_use=0;
53 int torture_numops=100;
54 int torture_blocksize=1024*1024;
55 static int procnum; /* records process count number when forking */
56 static struct cli_state *current_cli;
57 static fstring randomfname;
58 static bool use_oplocks;
59 static bool use_level_II_oplocks;
60 static const char *client_txt = "client_oplocks.txt";
61 static bool disable_spnego;
62 static bool use_kerberos;
63 static bool force_dos_errors;
64 static fstring multishare_conn_fname;
65 static bool use_multishare_conn = False;
66 static bool do_encrypt;
67 static const char *local_path = NULL;
68 static enum smb_signing_setting signing_state = SMB_SIGNING_DEFAULT;
71 bool torture_showall = False;
73 static double create_procs(bool (*fn)(int), bool *result);
75 /********************************************************************
76 Ensure a connection is encrypted.
77 ********************************************************************/
79 static bool force_cli_encryption(struct cli_state *c,
80 const char *sharename)
82 uint16_t major, minor;
83 uint32_t caplow, caphigh;
86 if (!SERVER_HAS_UNIX_CIFS(c)) {
87 d_printf("Encryption required and "
88 "server that doesn't support "
89 "UNIX extensions - failing connect\n");
93 status = cli_unix_extensions_version(c, &major, &minor, &caplow,
95 if (!NT_STATUS_IS_OK(status)) {
96 d_printf("Encryption required and "
97 "can't get UNIX CIFS extensions "
98 "version from server: %s\n", nt_errstr(status));
102 if (!(caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)) {
103 d_printf("Encryption required and "
104 "share %s doesn't support "
105 "encryption.\n", sharename);
109 if (c->use_kerberos) {
110 status = cli_gss_smb_encryption_start(c);
112 status = cli_raw_ntlm_smb_encryption_start(c,
118 if (!NT_STATUS_IS_OK(status)) {
119 d_printf("Encryption required and "
120 "setup failed with error %s.\n",
129 static struct cli_state *open_nbt_connection(void)
135 if (disable_spnego) {
136 flags |= CLI_FULL_CONNECTION_DONT_SPNEGO;
140 flags |= CLI_FULL_CONNECTION_OPLOCKS;
143 if (use_level_II_oplocks) {
144 flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS;
148 flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
151 if (force_dos_errors) {
152 flags |= CLI_FULL_CONNECTION_FORCE_DOS_ERRORS;
155 status = cli_connect_nb(host, NULL, port_to_use, 0x20, myname,
156 signing_state, flags, &c);
157 if (!NT_STATUS_IS_OK(status)) {
158 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
162 cli_set_timeout(c, 120000); /* set a really long timeout (2 minutes) */
167 /****************************************************************************
168 Send a corrupt session request. See rfc1002.txt 4.3 and 4.3.2.
169 ****************************************************************************/
171 static bool cli_bad_session_request(int fd,
172 struct nmb_name *calling, struct nmb_name *called)
181 uint8_t message_type;
183 struct tevent_context *ev;
184 struct tevent_req *req;
186 frame = talloc_stackframe();
188 iov[0].iov_base = len_buf;
189 iov[0].iov_len = sizeof(len_buf);
191 /* put in the destination name */
193 iov[1].iov_base = name_mangle(talloc_tos(), called->name,
195 if (iov[1].iov_base == NULL) {
198 iov[1].iov_len = name_len((unsigned char *)iov[1].iov_base,
199 talloc_get_size(iov[1].iov_base));
203 iov[2].iov_base = name_mangle(talloc_tos(), calling->name,
205 if (iov[2].iov_base == NULL) {
208 iov[2].iov_len = name_len((unsigned char *)iov[2].iov_base,
209 talloc_get_size(iov[2].iov_base));
211 /* Deliberately corrupt the name len (first byte) */
212 *((uint8_t *)iov[2].iov_base) = 100;
214 /* send a session request (RFC 1002) */
215 /* setup the packet length
216 * Remove four bytes from the length count, since the length
217 * field in the NBT Session Service header counts the number
218 * of bytes which follow. The cli_send_smb() function knows
219 * about this and accounts for those four bytes.
223 _smb_setlen(len_buf, iov[1].iov_len + iov[2].iov_len);
224 SCVAL(len_buf,0,0x81);
226 len = write_data_iov(fd, iov, 3);
231 ev = samba_tevent_context_init(frame);
235 req = read_smb_send(frame, ev, fd);
239 if (!tevent_req_poll(req, ev)) {
242 len = read_smb_recv(req, talloc_tos(), &inbuf, &err);
249 message_type = CVAL(inbuf, 0);
250 if (message_type != 0x83) {
251 d_fprintf(stderr, "Expected msg type 0x83, got 0x%2.2x\n",
256 if (smb_len(inbuf) != 1) {
257 d_fprintf(stderr, "Expected smb_len 1, got %d\n",
258 (int)smb_len(inbuf));
262 error = CVAL(inbuf, 4);
264 d_fprintf(stderr, "Expected error 0x82, got %d\n",
275 /* Insert a NULL at the first separator of the given path and return a pointer
276 * to the remainder of the string.
279 terminate_path_at_separator(char * path)
287 if ((p = strchr_m(path, '/'))) {
292 if ((p = strchr_m(path, '\\'))) {
302 parse a //server/share type UNC name
304 bool smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
305 char **hostname, char **sharename)
309 *hostname = *sharename = NULL;
311 if (strncmp(unc_name, "\\\\", 2) &&
312 strncmp(unc_name, "//", 2)) {
316 *hostname = talloc_strdup(mem_ctx, &unc_name[2]);
317 p = terminate_path_at_separator(*hostname);
320 *sharename = talloc_strdup(mem_ctx, p);
321 terminate_path_at_separator(*sharename);
324 if (*hostname && *sharename) {
328 TALLOC_FREE(*hostname);
329 TALLOC_FREE(*sharename);
333 static bool torture_open_connection_share(struct cli_state **c,
334 const char *hostname,
335 const char *sharename)
341 flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
343 flags |= CLI_FULL_CONNECTION_OPLOCKS;
344 if (use_level_II_oplocks)
345 flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS;
347 status = cli_full_connection(c, myname,
348 hostname, NULL, port_to_use,
351 password, flags, signing_state);
352 if (!NT_STATUS_IS_OK(status)) {
353 printf("failed to open share connection: //%s/%s port:%d - %s\n",
354 hostname, sharename, port_to_use, nt_errstr(status));
358 cli_set_timeout(*c, 120000); /* set a really long timeout (2 minutes) */
361 return force_cli_encryption(*c,
367 bool torture_open_connection(struct cli_state **c, int conn_index)
369 char **unc_list = NULL;
370 int num_unc_names = 0;
373 if (use_multishare_conn==True) {
375 unc_list = file_lines_load(multishare_conn_fname, &num_unc_names, 0, NULL);
376 if (!unc_list || num_unc_names <= 0) {
377 printf("Failed to load unc names list from '%s'\n", multishare_conn_fname);
381 if (!smbcli_parse_unc(unc_list[conn_index % num_unc_names],
383 printf("Failed to parse UNC name %s\n",
384 unc_list[conn_index % num_unc_names]);
385 TALLOC_FREE(unc_list);
389 result = torture_open_connection_share(c, h, s);
391 /* h, s were copied earlier */
392 TALLOC_FREE(unc_list);
396 return torture_open_connection_share(c, host, share);
399 bool torture_init_connection(struct cli_state **pcli)
401 struct cli_state *cli;
403 cli = open_nbt_connection();
412 bool torture_cli_session_setup2(struct cli_state *cli, uint16_t *new_vuid)
414 uint16_t old_vuid = cli_state_get_uid(cli);
415 size_t passlen = strlen(password);
419 cli_state_set_uid(cli, 0);
420 status = cli_session_setup(cli, username,
424 ret = NT_STATUS_IS_OK(status);
425 *new_vuid = cli_state_get_uid(cli);
426 cli_state_set_uid(cli, old_vuid);
431 bool torture_close_connection(struct cli_state *c)
436 status = cli_tdis(c);
437 if (!NT_STATUS_IS_OK(status)) {
438 printf("tdis failed (%s)\n", nt_errstr(status));
448 /* check if the server produced the expected dos or nt error code */
449 static bool check_both_error(int line, NTSTATUS status,
450 uint8_t eclass, uint32_t ecode, NTSTATUS nterr)
452 if (NT_STATUS_IS_DOS(status)) {
456 /* Check DOS error */
457 cclass = NT_STATUS_DOS_CLASS(status);
458 num = NT_STATUS_DOS_CODE(status);
460 if (eclass != cclass || ecode != num) {
461 printf("unexpected error code class=%d code=%d\n",
462 (int)cclass, (int)num);
463 printf(" expected %d/%d %s (line=%d)\n",
464 (int)eclass, (int)ecode, nt_errstr(nterr), line);
469 if (!NT_STATUS_EQUAL(nterr, status)) {
470 printf("unexpected error code %s\n",
472 printf(" expected %s (line=%d)\n",
473 nt_errstr(nterr), line);
482 /* check if the server produced the expected error code */
483 static bool check_error(int line, NTSTATUS status,
484 uint8_t eclass, uint32_t ecode, NTSTATUS nterr)
486 if (NT_STATUS_IS_DOS(status)) {
490 /* Check DOS error */
492 cclass = NT_STATUS_DOS_CLASS(status);
493 num = NT_STATUS_DOS_CODE(status);
495 if (eclass != cclass || ecode != num) {
496 printf("unexpected error code class=%d code=%d\n",
497 (int)cclass, (int)num);
498 printf(" expected %d/%d %s (line=%d)\n",
499 (int)eclass, (int)ecode, nt_errstr(nterr),
507 if (NT_STATUS_V(nterr) != NT_STATUS_V(status)) {
508 printf("unexpected error code %s\n",
510 printf(" expected %s (line=%d)\n", nt_errstr(nterr),
520 static bool wait_lock(struct cli_state *c, int fnum, uint32_t offset, uint32_t len)
524 status = cli_lock32(c, fnum, offset, len, -1, WRITE_LOCK);
526 while (!NT_STATUS_IS_OK(status)) {
527 if (!check_both_error(__LINE__, status, ERRDOS,
528 ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) {
532 status = cli_lock32(c, fnum, offset, len, -1, WRITE_LOCK);
539 static bool rw_torture(struct cli_state *c)
541 const char *lockfname = "\\torture.lck";
545 pid_t pid2, pid = getpid();
552 memset(buf, '\0', sizeof(buf));
554 status = cli_openx(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
556 if (!NT_STATUS_IS_OK(status)) {
557 status = cli_openx(c, lockfname, O_RDWR, DENY_NONE, &fnum2);
559 if (!NT_STATUS_IS_OK(status)) {
560 printf("open of %s failed (%s)\n",
561 lockfname, nt_errstr(status));
565 for (i=0;i<torture_numops;i++) {
566 unsigned n = (unsigned)sys_random()%10;
569 printf("%d\r", i); fflush(stdout);
571 slprintf(fname, sizeof(fstring) - 1, "\\torture.%u", n);
573 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
577 status = cli_openx(c, fname, O_RDWR | O_CREAT | O_TRUNC,
579 if (!NT_STATUS_IS_OK(status)) {
580 printf("open failed (%s)\n", nt_errstr(status));
585 status = cli_writeall(c, fnum, 0, (uint8_t *)&pid, 0,
587 if (!NT_STATUS_IS_OK(status)) {
588 printf("write failed (%s)\n", nt_errstr(status));
593 status = cli_writeall(c, fnum, 0, (uint8_t *)buf,
594 sizeof(pid)+(j*sizeof(buf)),
596 if (!NT_STATUS_IS_OK(status)) {
597 printf("write failed (%s)\n",
605 status = cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid),
607 if (!NT_STATUS_IS_OK(status)) {
608 printf("read failed (%s)\n", nt_errstr(status));
610 } else if (nread != sizeof(pid)) {
611 printf("read/write compare failed: "
612 "recv %ld req %ld\n", (unsigned long)nread,
613 (unsigned long)sizeof(pid));
618 printf("data corruption!\n");
622 status = cli_close(c, fnum);
623 if (!NT_STATUS_IS_OK(status)) {
624 printf("close failed (%s)\n", nt_errstr(status));
628 status = cli_unlink(c, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
629 if (!NT_STATUS_IS_OK(status)) {
630 printf("unlink failed (%s)\n", nt_errstr(status));
634 status = cli_unlock(c, fnum2, n*sizeof(int), sizeof(int));
635 if (!NT_STATUS_IS_OK(status)) {
636 printf("unlock failed (%s)\n", nt_errstr(status));
642 cli_unlink(c, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
649 static bool run_torture(int dummy)
651 struct cli_state *cli;
656 smbXcli_conn_set_sockopt(cli->conn, sockops);
658 ret = rw_torture(cli);
660 if (!torture_close_connection(cli)) {
667 static bool rw_torture3(struct cli_state *c, char *lockfname)
669 uint16_t fnum = (uint16_t)-1;
674 unsigned countprev = 0;
677 NTSTATUS status = NT_STATUS_OK;
680 for (i = 0; i < sizeof(buf); i += sizeof(uint32_t))
682 SIVAL(buf, i, sys_random());
689 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
690 if (!NT_STATUS_IS_OK(status)) {
691 printf("unlink failed (%s) (normal, this file should "
692 "not exist)\n", nt_errstr(status));
695 status = cli_openx(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
697 if (!NT_STATUS_IS_OK(status)) {
698 printf("first open read/write of %s failed (%s)\n",
699 lockfname, nt_errstr(status));
705 for (i = 0; i < 500 && fnum == (uint16_t)-1; i++)
707 status = cli_openx(c, lockfname, O_RDONLY,
709 if (NT_STATUS_IS_OK(status)) {
714 if (!NT_STATUS_IS_OK(status)) {
715 printf("second open read-only of %s failed (%s)\n",
716 lockfname, nt_errstr(status));
722 for (count = 0; count < sizeof(buf); count += sent)
724 if (count >= countprev) {
725 printf("%d %8d\r", i, count);
728 countprev += (sizeof(buf) / 20);
733 sent = ((unsigned)sys_random()%(20))+ 1;
734 if (sent > sizeof(buf) - count)
736 sent = sizeof(buf) - count;
739 status = cli_writeall(c, fnum, 0, (uint8_t *)buf+count,
741 if (!NT_STATUS_IS_OK(status)) {
742 printf("write failed (%s)\n",
749 status = cli_read(c, fnum, buf_rd+count, count,
750 sizeof(buf)-count, &sent);
751 if(!NT_STATUS_IS_OK(status)) {
752 printf("read failed offset:%d size:%ld (%s)\n",
753 count, (unsigned long)sizeof(buf)-count,
757 } else if (sent > 0) {
758 if (memcmp(buf_rd+count, buf+count, sent) != 0)
760 printf("read/write compare failed\n");
761 printf("offset: %d req %ld recvd %ld\n", count, (unsigned long)sizeof(buf)-count, (unsigned long)sent);
770 status = cli_close(c, fnum);
771 if (!NT_STATUS_IS_OK(status)) {
772 printf("close failed (%s)\n", nt_errstr(status));
779 static bool rw_torture2(struct cli_state *c1, struct cli_state *c2)
781 const char *lockfname = "\\torture2.lck";
791 status = cli_unlink(c1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
792 if (!NT_STATUS_IS_OK(status)) {
793 printf("unlink failed (%s) (normal, this file should not exist)\n", nt_errstr(status));
796 status = cli_openx(c1, lockfname, O_RDWR | O_CREAT | O_EXCL,
798 if (!NT_STATUS_IS_OK(status)) {
799 printf("first open read/write of %s failed (%s)\n",
800 lockfname, nt_errstr(status));
804 status = cli_openx(c2, lockfname, O_RDONLY, DENY_NONE, &fnum2);
805 if (!NT_STATUS_IS_OK(status)) {
806 printf("second open read-only of %s failed (%s)\n",
807 lockfname, nt_errstr(status));
808 cli_close(c1, fnum1);
812 for (i = 0; i < torture_numops; i++)
814 size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
816 printf("%d\r", i); fflush(stdout);
819 generate_random_buffer((unsigned char *)buf, buf_size);
821 status = cli_writeall(c1, fnum1, 0, (uint8_t *)buf, 0,
823 if (!NT_STATUS_IS_OK(status)) {
824 printf("write failed (%s)\n", nt_errstr(status));
829 status = cli_read(c2, fnum2, buf_rd, 0, buf_size, &bytes_read);
830 if(!NT_STATUS_IS_OK(status)) {
831 printf("read failed (%s)\n", nt_errstr(status));
834 } else if (bytes_read != buf_size) {
835 printf("read failed\n");
836 printf("read %ld, expected %ld\n",
837 (unsigned long)bytes_read,
838 (unsigned long)buf_size);
843 if (memcmp(buf_rd, buf, buf_size) != 0)
845 printf("read/write compare failed\n");
851 status = cli_close(c2, fnum2);
852 if (!NT_STATUS_IS_OK(status)) {
853 printf("close failed (%s)\n", nt_errstr(status));
857 status = cli_close(c1, fnum1);
858 if (!NT_STATUS_IS_OK(status)) {
859 printf("close failed (%s)\n", nt_errstr(status));
863 status = cli_unlink(c1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
864 if (!NT_STATUS_IS_OK(status)) {
865 printf("unlink failed (%s)\n", nt_errstr(status));
872 static bool run_readwritetest(int dummy)
874 struct cli_state *cli1, *cli2;
875 bool test1, test2 = False;
877 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
880 smbXcli_conn_set_sockopt(cli1->conn, sockops);
881 smbXcli_conn_set_sockopt(cli2->conn, sockops);
883 printf("starting readwritetest\n");
885 test1 = rw_torture2(cli1, cli2);
886 printf("Passed readwritetest v1: %s\n", BOOLSTR(test1));
889 test2 = rw_torture2(cli1, cli1);
890 printf("Passed readwritetest v2: %s\n", BOOLSTR(test2));
893 if (!torture_close_connection(cli1)) {
897 if (!torture_close_connection(cli2)) {
901 return (test1 && test2);
904 static bool run_readwritemulti(int dummy)
906 struct cli_state *cli;
911 smbXcli_conn_set_sockopt(cli->conn, sockops);
913 printf("run_readwritemulti: fname %s\n", randomfname);
914 test = rw_torture3(cli, randomfname);
916 if (!torture_close_connection(cli)) {
923 static bool run_readwritelarge_internal(void)
925 static struct cli_state *cli1;
927 const char *lockfname = "\\large.dat";
933 if (!torture_open_connection(&cli1, 0)) {
936 smbXcli_conn_set_sockopt(cli1->conn, sockops);
937 memset(buf,'\0',sizeof(buf));
939 printf("starting readwritelarge_internal\n");
941 cli_unlink(cli1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
943 status = cli_openx(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL,
945 if (!NT_STATUS_IS_OK(status)) {
946 printf("open read/write of %s failed (%s)\n", lockfname, nt_errstr(status));
950 cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf), NULL);
952 status = cli_qfileinfo_basic(cli1, fnum1, NULL, &fsize, NULL, NULL,
954 if (!NT_STATUS_IS_OK(status)) {
955 printf("qfileinfo failed (%s)\n", nt_errstr(status));
959 if (fsize == sizeof(buf))
960 printf("readwritelarge_internal test 1 succeeded (size = %lx)\n",
961 (unsigned long)fsize);
963 printf("readwritelarge_internal test 1 failed (size = %lx)\n",
964 (unsigned long)fsize);
968 status = cli_close(cli1, fnum1);
969 if (!NT_STATUS_IS_OK(status)) {
970 printf("close failed (%s)\n", nt_errstr(status));
974 status = cli_unlink(cli1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
975 if (!NT_STATUS_IS_OK(status)) {
976 printf("unlink failed (%s)\n", nt_errstr(status));
980 status = cli_openx(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL,
982 if (!NT_STATUS_IS_OK(status)) {
983 printf("open read/write of %s failed (%s)\n", lockfname, nt_errstr(status));
987 cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf), NULL);
989 status = cli_qfileinfo_basic(cli1, fnum1, NULL, &fsize, NULL, NULL,
991 if (!NT_STATUS_IS_OK(status)) {
992 printf("qfileinfo failed (%s)\n", nt_errstr(status));
996 if (fsize == sizeof(buf))
997 printf("readwritelarge_internal test 2 succeeded (size = %lx)\n",
998 (unsigned long)fsize);
1000 printf("readwritelarge_internal test 2 failed (size = %lx)\n",
1001 (unsigned long)fsize);
1006 /* ToDo - set allocation. JRA */
1007 if(!cli_set_allocation_size(cli1, fnum1, 0)) {
1008 printf("set allocation size to zero failed (%s)\n", cli_errstr(&cli1));
1011 if (!cli_qfileinfo_basic(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL,
1013 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
1017 printf("readwritelarge test 3 (truncate test) succeeded (size = %x)\n", fsize);
1020 status = cli_close(cli1, fnum1);
1021 if (!NT_STATUS_IS_OK(status)) {
1022 printf("close failed (%s)\n", nt_errstr(status));
1026 if (!torture_close_connection(cli1)) {
1032 static bool run_readwritelarge(int dummy)
1034 return run_readwritelarge_internal();
1037 static bool run_readwritelarge_signtest(int dummy)
1040 signing_state = SMB_SIGNING_REQUIRED;
1041 ret = run_readwritelarge_internal();
1042 signing_state = SMB_SIGNING_DEFAULT;
1049 #define ival(s) strtol(s, NULL, 0)
1051 /* run a test that simulates an approximate netbench client load */
1052 static bool run_netbench(int client)
1054 struct cli_state *cli;
1059 const char *params[20];
1060 bool correct = True;
1066 smbXcli_conn_set_sockopt(cli->conn, sockops);
1070 slprintf(cname,sizeof(cname)-1, "client%d", client);
1072 f = fopen(client_txt, "r");
1079 while (fgets(line, sizeof(line)-1, f)) {
1083 line[strlen(line)-1] = 0;
1085 /* printf("[%d] %s\n", line_count, line); */
1087 all_string_sub(line,"client1", cname, sizeof(line));
1089 /* parse the command parameters */
1090 params[0] = strtok_r(line, " ", &saveptr);
1092 while (params[i]) params[++i] = strtok_r(NULL, " ", &saveptr);
1096 if (i < 2) continue;
1098 if (!strncmp(params[0],"SMB", 3)) {
1099 printf("ERROR: You are using a dbench 1 load file\n");
1103 if (!strcmp(params[0],"NTCreateX")) {
1104 nb_createx(params[1], ival(params[2]), ival(params[3]),
1106 } else if (!strcmp(params[0],"Close")) {
1107 nb_close(ival(params[1]));
1108 } else if (!strcmp(params[0],"Rename")) {
1109 nb_rename(params[1], params[2]);
1110 } else if (!strcmp(params[0],"Unlink")) {
1111 nb_unlink(params[1]);
1112 } else if (!strcmp(params[0],"Deltree")) {
1113 nb_deltree(params[1]);
1114 } else if (!strcmp(params[0],"Rmdir")) {
1115 nb_rmdir(params[1]);
1116 } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
1117 nb_qpathinfo(params[1]);
1118 } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
1119 nb_qfileinfo(ival(params[1]));
1120 } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
1121 nb_qfsinfo(ival(params[1]));
1122 } else if (!strcmp(params[0],"FIND_FIRST")) {
1123 nb_findfirst(params[1]);
1124 } else if (!strcmp(params[0],"WriteX")) {
1125 nb_writex(ival(params[1]),
1126 ival(params[2]), ival(params[3]), ival(params[4]));
1127 } else if (!strcmp(params[0],"ReadX")) {
1128 nb_readx(ival(params[1]),
1129 ival(params[2]), ival(params[3]), ival(params[4]));
1130 } else if (!strcmp(params[0],"Flush")) {
1131 nb_flush(ival(params[1]));
1133 printf("Unknown operation %s\n", params[0]);
1141 if (!torture_close_connection(cli)) {
1149 /* run a test that simulates an approximate netbench client load */
1150 static bool run_nbench(int dummy)
1153 bool correct = True;
1155 nbio_shmem(torture_nprocs);
1159 signal(SIGALRM, nb_alarm);
1161 t = create_procs(run_netbench, &correct);
1164 printf("\nThroughput %g MB/sec\n",
1165 1.0e-6 * nbio_total() / t);
1171 This test checks for two things:
1173 1) correct support for retaining locks over a close (ie. the server
1174 must not use posix semantics)
1175 2) support for lock timeouts
1177 static bool run_locktest1(int dummy)
1179 struct cli_state *cli1, *cli2;
1180 const char *fname = "\\lockt1.lck";
1181 uint16_t fnum1, fnum2, fnum3;
1183 unsigned lock_timeout;
1186 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1189 smbXcli_conn_set_sockopt(cli1->conn, sockops);
1190 smbXcli_conn_set_sockopt(cli2->conn, sockops);
1192 printf("starting locktest1\n");
1194 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1196 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
1198 if (!NT_STATUS_IS_OK(status)) {
1199 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1203 status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum2);
1204 if (!NT_STATUS_IS_OK(status)) {
1205 printf("open2 of %s failed (%s)\n", fname, nt_errstr(status));
1209 status = cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum3);
1210 if (!NT_STATUS_IS_OK(status)) {
1211 printf("open3 of %s failed (%s)\n", fname, nt_errstr(status));
1215 status = cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK);
1216 if (!NT_STATUS_IS_OK(status)) {
1217 printf("lock1 failed (%s)\n", nt_errstr(status));
1221 status = cli_lock32(cli2, fnum3, 0, 4, 0, WRITE_LOCK);
1222 if (NT_STATUS_IS_OK(status)) {
1223 printf("lock2 succeeded! This is a locking bug\n");
1226 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1227 NT_STATUS_LOCK_NOT_GRANTED)) {
1232 lock_timeout = (1 + (random() % 20));
1233 printf("Testing lock timeout with timeout=%u\n", lock_timeout);
1235 status = cli_lock32(cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK);
1236 if (NT_STATUS_IS_OK(status)) {
1237 printf("lock3 succeeded! This is a locking bug\n");
1240 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1241 NT_STATUS_FILE_LOCK_CONFLICT)) {
1247 if (ABS(t2 - t1) < lock_timeout-1) {
1248 printf("error: This server appears not to support timed lock requests\n");
1251 printf("server slept for %u seconds for a %u second timeout\n",
1252 (unsigned int)(t2-t1), lock_timeout);
1254 status = cli_close(cli1, fnum2);
1255 if (!NT_STATUS_IS_OK(status)) {
1256 printf("close1 failed (%s)\n", nt_errstr(status));
1260 status = cli_lock32(cli2, fnum3, 0, 4, 0, WRITE_LOCK);
1261 if (NT_STATUS_IS_OK(status)) {
1262 printf("lock4 succeeded! This is a locking bug\n");
1265 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1266 NT_STATUS_FILE_LOCK_CONFLICT)) {
1271 status = cli_close(cli1, fnum1);
1272 if (!NT_STATUS_IS_OK(status)) {
1273 printf("close2 failed (%s)\n", nt_errstr(status));
1277 status = cli_close(cli2, fnum3);
1278 if (!NT_STATUS_IS_OK(status)) {
1279 printf("close3 failed (%s)\n", nt_errstr(status));
1283 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1284 if (!NT_STATUS_IS_OK(status)) {
1285 printf("unlink failed (%s)\n", nt_errstr(status));
1290 if (!torture_close_connection(cli1)) {
1294 if (!torture_close_connection(cli2)) {
1298 printf("Passed locktest1\n");
1303 this checks to see if a secondary tconx can use open files from an
1306 static bool run_tcon_test(int dummy)
1308 static struct cli_state *cli;
1309 const char *fname = "\\tcontest.tmp";
1311 uint16_t cnum1, cnum2, cnum3;
1312 uint16_t vuid1, vuid2;
1317 memset(buf, '\0', sizeof(buf));
1319 if (!torture_open_connection(&cli, 0)) {
1322 smbXcli_conn_set_sockopt(cli->conn, sockops);
1324 printf("starting tcontest\n");
1326 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1328 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1329 if (!NT_STATUS_IS_OK(status)) {
1330 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1334 cnum1 = cli_state_get_tid(cli);
1335 vuid1 = cli_state_get_uid(cli);
1337 status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1338 if (!NT_STATUS_IS_OK(status)) {
1339 printf("initial write failed (%s)", nt_errstr(status));
1343 status = cli_tree_connect(cli, share, "?????",
1344 password, strlen(password)+1);
1345 if (!NT_STATUS_IS_OK(status)) {
1346 printf("%s refused 2nd tree connect (%s)\n", host,
1352 cnum2 = cli_state_get_tid(cli);
1353 cnum3 = MAX(cnum1, cnum2) + 1; /* any invalid number */
1354 vuid2 = cli_state_get_uid(cli) + 1;
1356 /* try a write with the wrong tid */
1357 cli_state_set_tid(cli, cnum2);
1359 status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1360 if (NT_STATUS_IS_OK(status)) {
1361 printf("* server allows write with wrong TID\n");
1364 printf("server fails write with wrong TID : %s\n",
1369 /* try a write with an invalid tid */
1370 cli_state_set_tid(cli, cnum3);
1372 status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1373 if (NT_STATUS_IS_OK(status)) {
1374 printf("* server allows write with invalid TID\n");
1377 printf("server fails write with invalid TID : %s\n",
1381 /* try a write with an invalid vuid */
1382 cli_state_set_uid(cli, vuid2);
1383 cli_state_set_tid(cli, cnum1);
1385 status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1386 if (NT_STATUS_IS_OK(status)) {
1387 printf("* server allows write with invalid VUID\n");
1390 printf("server fails write with invalid VUID : %s\n",
1394 cli_state_set_tid(cli, cnum1);
1395 cli_state_set_uid(cli, vuid1);
1397 status = cli_close(cli, fnum1);
1398 if (!NT_STATUS_IS_OK(status)) {
1399 printf("close failed (%s)\n", nt_errstr(status));
1403 cli_state_set_tid(cli, cnum2);
1405 status = cli_tdis(cli);
1406 if (!NT_STATUS_IS_OK(status)) {
1407 printf("secondary tdis failed (%s)\n", nt_errstr(status));
1411 cli_state_set_tid(cli, cnum1);
1413 if (!torture_close_connection(cli)) {
1422 checks for old style tcon support
1424 static bool run_tcon2_test(int dummy)
1426 static struct cli_state *cli;
1427 uint16_t cnum, max_xmit;
1431 if (!torture_open_connection(&cli, 0)) {
1434 smbXcli_conn_set_sockopt(cli->conn, sockops);
1436 printf("starting tcon2 test\n");
1438 if (asprintf(&service, "\\\\%s\\%s", host, share) == -1) {
1442 status = cli_raw_tcon(cli, service, password, "?????", &max_xmit, &cnum);
1446 if (!NT_STATUS_IS_OK(status)) {
1447 printf("tcon2 failed : %s\n", nt_errstr(status));
1449 printf("tcon OK : max_xmit=%d cnum=%d\n",
1450 (int)max_xmit, (int)cnum);
1453 if (!torture_close_connection(cli)) {
1457 printf("Passed tcon2 test\n");
1461 static bool tcon_devtest(struct cli_state *cli,
1462 const char *myshare, const char *devtype,
1463 const char *return_devtype,
1464 NTSTATUS expected_error)
1469 status = cli_tree_connect(cli, myshare, devtype,
1470 password, strlen(password)+1);
1472 if (NT_STATUS_IS_OK(expected_error)) {
1473 if (NT_STATUS_IS_OK(status)) {
1474 if (strcmp(cli->dev, return_devtype) == 0) {
1477 printf("tconX to share %s with type %s "
1478 "succeeded but returned the wrong "
1479 "device type (got [%s] but should have got [%s])\n",
1480 myshare, devtype, cli->dev, return_devtype);
1484 printf("tconX to share %s with type %s "
1485 "should have succeeded but failed\n",
1491 if (NT_STATUS_IS_OK(status)) {
1492 printf("tconx to share %s with type %s "
1493 "should have failed but succeeded\n",
1497 if (NT_STATUS_EQUAL(status, expected_error)) {
1500 printf("Returned unexpected error\n");
1509 checks for correct tconX support
1511 static bool run_tcon_devtype_test(int dummy)
1513 static struct cli_state *cli1 = NULL;
1518 status = cli_full_connection(&cli1, myname,
1519 host, NULL, port_to_use,
1521 username, workgroup,
1522 password, flags, signing_state);
1524 if (!NT_STATUS_IS_OK(status)) {
1525 printf("could not open connection\n");
1529 if (!tcon_devtest(cli1, "IPC$", "A:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1532 if (!tcon_devtest(cli1, "IPC$", "?????", "IPC", NT_STATUS_OK))
1535 if (!tcon_devtest(cli1, "IPC$", "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1538 if (!tcon_devtest(cli1, "IPC$", "IPC", "IPC", NT_STATUS_OK))
1541 if (!tcon_devtest(cli1, "IPC$", "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1544 if (!tcon_devtest(cli1, share, "A:", "A:", NT_STATUS_OK))
1547 if (!tcon_devtest(cli1, share, "?????", "A:", NT_STATUS_OK))
1550 if (!tcon_devtest(cli1, share, "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1553 if (!tcon_devtest(cli1, share, "IPC", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1556 if (!tcon_devtest(cli1, share, "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1562 printf("Passed tcondevtest\n");
1569 This test checks that
1571 1) the server supports multiple locking contexts on the one SMB
1572 connection, distinguished by PID.
1574 2) the server correctly fails overlapping locks made by the same PID (this
1575 goes against POSIX behaviour, which is why it is tricky to implement)
1577 3) the server denies unlock requests by an incorrect client PID
1579 static bool run_locktest2(int dummy)
1581 static struct cli_state *cli;
1582 const char *fname = "\\lockt2.lck";
1583 uint16_t fnum1, fnum2, fnum3;
1584 bool correct = True;
1587 if (!torture_open_connection(&cli, 0)) {
1591 smbXcli_conn_set_sockopt(cli->conn, sockops);
1593 printf("starting locktest2\n");
1595 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1599 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1600 if (!NT_STATUS_IS_OK(status)) {
1601 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1605 status = cli_openx(cli, fname, O_RDWR, DENY_NONE, &fnum2);
1606 if (!NT_STATUS_IS_OK(status)) {
1607 printf("open2 of %s failed (%s)\n", fname, nt_errstr(status));
1613 status = cli_openx(cli, fname, O_RDWR, DENY_NONE, &fnum3);
1614 if (!NT_STATUS_IS_OK(status)) {
1615 printf("open3 of %s failed (%s)\n", fname, nt_errstr(status));
1621 status = cli_lock32(cli, fnum1, 0, 4, 0, WRITE_LOCK);
1622 if (!NT_STATUS_IS_OK(status)) {
1623 printf("lock1 failed (%s)\n", nt_errstr(status));
1627 status = cli_lock32(cli, fnum1, 0, 4, 0, WRITE_LOCK);
1628 if (NT_STATUS_IS_OK(status)) {
1629 printf("WRITE lock1 succeeded! This is a locking bug\n");
1632 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1633 NT_STATUS_LOCK_NOT_GRANTED)) {
1638 status = cli_lock32(cli, fnum2, 0, 4, 0, WRITE_LOCK);
1639 if (NT_STATUS_IS_OK(status)) {
1640 printf("WRITE lock2 succeeded! This is a locking bug\n");
1643 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1644 NT_STATUS_LOCK_NOT_GRANTED)) {
1649 status = cli_lock32(cli, fnum2, 0, 4, 0, READ_LOCK);
1650 if (NT_STATUS_IS_OK(status)) {
1651 printf("READ lock2 succeeded! This is a locking bug\n");
1654 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1655 NT_STATUS_FILE_LOCK_CONFLICT)) {
1660 status = cli_lock32(cli, fnum1, 100, 4, 0, WRITE_LOCK);
1661 if (!NT_STATUS_IS_OK(status)) {
1662 printf("lock at 100 failed (%s)\n", nt_errstr(status));
1665 if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 100, 4))) {
1666 printf("unlock at 100 succeeded! This is a locking bug\n");
1670 status = cli_unlock(cli, fnum1, 0, 4);
1671 if (NT_STATUS_IS_OK(status)) {
1672 printf("unlock1 succeeded! This is a locking bug\n");
1675 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1676 NT_STATUS_RANGE_NOT_LOCKED)) {
1681 status = cli_unlock(cli, fnum1, 0, 8);
1682 if (NT_STATUS_IS_OK(status)) {
1683 printf("unlock2 succeeded! This is a locking bug\n");
1686 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1687 NT_STATUS_RANGE_NOT_LOCKED)) {
1692 status = cli_lock32(cli, fnum3, 0, 4, 0, WRITE_LOCK);
1693 if (NT_STATUS_IS_OK(status)) {
1694 printf("lock3 succeeded! This is a locking bug\n");
1697 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1698 NT_STATUS_LOCK_NOT_GRANTED)) {
1705 status = cli_close(cli, fnum1);
1706 if (!NT_STATUS_IS_OK(status)) {
1707 printf("close1 failed (%s)\n", nt_errstr(status));
1711 status = cli_close(cli, fnum2);
1712 if (!NT_STATUS_IS_OK(status)) {
1713 printf("close2 failed (%s)\n", nt_errstr(status));
1717 status = cli_close(cli, fnum3);
1718 if (!NT_STATUS_IS_OK(status)) {
1719 printf("close3 failed (%s)\n", nt_errstr(status));
1723 if (!torture_close_connection(cli)) {
1727 printf("locktest2 finished\n");
1734 This test checks that
1736 1) the server supports the full offset range in lock requests
1738 static bool run_locktest3(int dummy)
1740 static struct cli_state *cli1, *cli2;
1741 const char *fname = "\\lockt3.lck";
1742 uint16_t fnum1, fnum2;
1745 bool correct = True;
1748 #define NEXT_OFFSET offset += (~(uint32_t)0) / torture_numops
1750 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1753 smbXcli_conn_set_sockopt(cli1->conn, sockops);
1754 smbXcli_conn_set_sockopt(cli2->conn, sockops);
1756 printf("starting locktest3\n");
1758 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1760 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
1762 if (!NT_STATUS_IS_OK(status)) {
1763 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1767 status = cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1768 if (!NT_STATUS_IS_OK(status)) {
1769 printf("open2 of %s failed (%s)\n", fname, nt_errstr(status));
1773 for (offset=i=0;i<torture_numops;i++) {
1776 status = cli_lock32(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK);
1777 if (!NT_STATUS_IS_OK(status)) {
1778 printf("lock1 %d failed (%s)\n",
1784 status = cli_lock32(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK);
1785 if (!NT_STATUS_IS_OK(status)) {
1786 printf("lock2 %d failed (%s)\n",
1793 for (offset=i=0;i<torture_numops;i++) {
1796 status = cli_lock32(cli1, fnum1, offset-2, 1, 0, WRITE_LOCK);
1797 if (NT_STATUS_IS_OK(status)) {
1798 printf("error: lock1 %d succeeded!\n", i);
1802 status = cli_lock32(cli2, fnum2, offset-1, 1, 0, WRITE_LOCK);
1803 if (NT_STATUS_IS_OK(status)) {
1804 printf("error: lock2 %d succeeded!\n", i);
1808 status = cli_lock32(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK);
1809 if (NT_STATUS_IS_OK(status)) {
1810 printf("error: lock3 %d succeeded!\n", i);
1814 status = cli_lock32(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK);
1815 if (NT_STATUS_IS_OK(status)) {
1816 printf("error: lock4 %d succeeded!\n", i);
1821 for (offset=i=0;i<torture_numops;i++) {
1824 status = cli_unlock(cli1, fnum1, offset-1, 1);
1825 if (!NT_STATUS_IS_OK(status)) {
1826 printf("unlock1 %d failed (%s)\n",
1832 status = cli_unlock(cli2, fnum2, offset-2, 1);
1833 if (!NT_STATUS_IS_OK(status)) {
1834 printf("unlock2 %d failed (%s)\n",
1841 status = cli_close(cli1, fnum1);
1842 if (!NT_STATUS_IS_OK(status)) {
1843 printf("close1 failed (%s)\n", nt_errstr(status));
1847 status = cli_close(cli2, fnum2);
1848 if (!NT_STATUS_IS_OK(status)) {
1849 printf("close2 failed (%s)\n", nt_errstr(status));
1853 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1854 if (!NT_STATUS_IS_OK(status)) {
1855 printf("unlink failed (%s)\n", nt_errstr(status));
1859 if (!torture_close_connection(cli1)) {
1863 if (!torture_close_connection(cli2)) {
1867 printf("finished locktest3\n");
1872 static bool test_cli_read(struct cli_state *cli, uint16_t fnum,
1873 char *buf, off_t offset, size_t size,
1874 size_t *nread, size_t expect)
1879 status = cli_read(cli, fnum, buf, offset, size, &l_nread);
1881 if(!NT_STATUS_IS_OK(status)) {
1883 } else if (l_nread != expect) {
1894 #define EXPECTED(ret, v) if ((ret) != (v)) { \
1895 printf("** "); correct = False; \
1899 looks at overlapping locks
1901 static bool run_locktest4(int dummy)
1903 static struct cli_state *cli1, *cli2;
1904 const char *fname = "\\lockt4.lck";
1905 uint16_t fnum1, fnum2, f;
1908 bool correct = True;
1911 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1915 smbXcli_conn_set_sockopt(cli1->conn, sockops);
1916 smbXcli_conn_set_sockopt(cli2->conn, sockops);
1918 printf("starting locktest4\n");
1920 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1922 cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1923 cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1925 memset(buf, 0, sizeof(buf));
1927 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf),
1929 if (!NT_STATUS_IS_OK(status)) {
1930 printf("Failed to create file: %s\n", nt_errstr(status));
1935 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) &&
1936 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 2, 4, 0, WRITE_LOCK));
1937 EXPECTED(ret, False);
1938 printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
1940 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 10, 4, 0, READ_LOCK)) &&
1941 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 12, 4, 0, READ_LOCK));
1942 EXPECTED(ret, True);
1943 printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
1945 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 20, 4, 0, WRITE_LOCK)) &&
1946 NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 22, 4, 0, WRITE_LOCK));
1947 EXPECTED(ret, False);
1948 printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
1950 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 30, 4, 0, READ_LOCK)) &&
1951 NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 32, 4, 0, READ_LOCK));
1952 EXPECTED(ret, True);
1953 printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
1955 ret = (cli_setpid(cli1, 1),
1956 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 40, 4, 0, WRITE_LOCK))) &&
1957 (cli_setpid(cli1, 2),
1958 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 42, 4, 0, WRITE_LOCK)));
1959 EXPECTED(ret, False);
1960 printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
1962 ret = (cli_setpid(cli1, 1),
1963 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 50, 4, 0, READ_LOCK))) &&
1964 (cli_setpid(cli1, 2),
1965 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 52, 4, 0, READ_LOCK)));
1966 EXPECTED(ret, True);
1967 printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
1969 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 60, 4, 0, READ_LOCK)) &&
1970 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 60, 4, 0, READ_LOCK));
1971 EXPECTED(ret, True);
1972 printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
1974 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 70, 4, 0, WRITE_LOCK)) &&
1975 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 70, 4, 0, WRITE_LOCK));
1976 EXPECTED(ret, False);
1977 printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
1979 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 80, 4, 0, READ_LOCK)) &&
1980 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 80, 4, 0, WRITE_LOCK));
1981 EXPECTED(ret, False);
1982 printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
1984 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 90, 4, 0, WRITE_LOCK)) &&
1985 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 90, 4, 0, READ_LOCK));
1986 EXPECTED(ret, True);
1987 printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1989 ret = (cli_setpid(cli1, 1),
1990 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 100, 4, 0, WRITE_LOCK))) &&
1991 (cli_setpid(cli1, 2),
1992 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 100, 4, 0, READ_LOCK)));
1993 EXPECTED(ret, False);
1994 printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1996 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 110, 4, 0, READ_LOCK)) &&
1997 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 112, 4, 0, READ_LOCK)) &&
1998 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 110, 6));
1999 EXPECTED(ret, False);
2000 printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
2003 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 120, 4, 0, WRITE_LOCK)) &&
2004 test_cli_read(cli2, fnum2, buf, 120, 4, NULL, 4);
2005 EXPECTED(ret, False);
2006 printf("this server %s strict write locking\n", ret?"doesn't do":"does");
2008 status = cli_lock32(cli1, fnum1, 130, 4, 0, READ_LOCK);
2009 ret = NT_STATUS_IS_OK(status);
2011 status = cli_writeall(cli2, fnum2, 0, (uint8_t *)buf, 130, 4,
2013 ret = NT_STATUS_IS_OK(status);
2015 EXPECTED(ret, False);
2016 printf("this server %s strict read locking\n", ret?"doesn't do":"does");
2019 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 140, 4, 0, READ_LOCK)) &&
2020 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 140, 4, 0, READ_LOCK)) &&
2021 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4)) &&
2022 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4));
2023 EXPECTED(ret, True);
2024 printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
2027 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 150, 4, 0, WRITE_LOCK)) &&
2028 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 150, 4, 0, READ_LOCK)) &&
2029 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4)) &&
2030 test_cli_read(cli2, fnum2, buf, 150, 4, NULL, 4) &&
2031 !(NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2033 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4));
2034 EXPECTED(ret, True);
2035 printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
2037 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 160, 4, 0, READ_LOCK)) &&
2038 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 160, 4)) &&
2039 NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2041 test_cli_read(cli2, fnum2, buf, 160, 4, NULL, 4);
2042 EXPECTED(ret, True);
2043 printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
2045 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 170, 4, 0, WRITE_LOCK)) &&
2046 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 170, 4)) &&
2047 NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2049 test_cli_read(cli2, fnum2, buf, 170, 4, NULL, 4);
2050 EXPECTED(ret, True);
2051 printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
2053 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 190, 4, 0, WRITE_LOCK)) &&
2054 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 190, 4, 0, READ_LOCK)) &&
2055 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 190, 4)) &&
2056 !NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2058 test_cli_read(cli2, fnum2, buf, 190, 4, NULL, 4);
2059 EXPECTED(ret, True);
2060 printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
2062 cli_close(cli1, fnum1);
2063 cli_close(cli2, fnum2);
2064 cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2065 cli_openx(cli1, fname, O_RDWR, DENY_NONE, &f);
2066 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 8, 0, READ_LOCK)) &&
2067 NT_STATUS_IS_OK(cli_lock32(cli1, f, 0, 1, 0, READ_LOCK)) &&
2068 NT_STATUS_IS_OK(cli_close(cli1, fnum1)) &&
2069 NT_STATUS_IS_OK(cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1)) &&
2070 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 7, 1, 0, WRITE_LOCK));
2072 cli_close(cli1, fnum1);
2073 EXPECTED(ret, True);
2074 printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
2077 cli_close(cli1, fnum1);
2078 cli_close(cli2, fnum2);
2079 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2080 torture_close_connection(cli1);
2081 torture_close_connection(cli2);
2083 printf("finished locktest4\n");
2088 looks at lock upgrade/downgrade.
2090 static bool run_locktest5(int dummy)
2092 static struct cli_state *cli1, *cli2;
2093 const char *fname = "\\lockt5.lck";
2094 uint16_t fnum1, fnum2, fnum3;
2097 bool correct = True;
2100 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2104 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2105 smbXcli_conn_set_sockopt(cli2->conn, sockops);
2107 printf("starting locktest5\n");
2109 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2111 cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2112 cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
2113 cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum3);
2115 memset(buf, 0, sizeof(buf));
2117 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf),
2119 if (!NT_STATUS_IS_OK(status)) {
2120 printf("Failed to create file: %s\n", nt_errstr(status));
2125 /* Check for NT bug... */
2126 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 8, 0, READ_LOCK)) &&
2127 NT_STATUS_IS_OK(cli_lock32(cli1, fnum3, 0, 1, 0, READ_LOCK));
2128 cli_close(cli1, fnum1);
2129 cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2130 status = cli_lock32(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
2131 ret = NT_STATUS_IS_OK(status);
2132 EXPECTED(ret, True);
2133 printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
2134 cli_close(cli1, fnum1);
2135 cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2136 cli_unlock(cli1, fnum3, 0, 1);
2138 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) &&
2139 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 1, 1, 0, READ_LOCK));
2140 EXPECTED(ret, True);
2141 printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
2143 status = cli_lock32(cli2, fnum2, 0, 4, 0, READ_LOCK);
2144 ret = NT_STATUS_IS_OK(status);
2145 EXPECTED(ret, False);
2147 printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
2149 /* Unlock the process 2 lock. */
2150 cli_unlock(cli2, fnum2, 0, 4);
2152 status = cli_lock32(cli1, fnum3, 0, 4, 0, READ_LOCK);
2153 ret = NT_STATUS_IS_OK(status);
2154 EXPECTED(ret, False);
2156 printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
2158 /* Unlock the process 1 fnum3 lock. */
2159 cli_unlock(cli1, fnum3, 0, 4);
2161 /* Stack 2 more locks here. */
2162 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK)) &&
2163 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK));
2165 EXPECTED(ret, True);
2166 printf("the same process %s stack read locks\n", ret?"can":"cannot");
2168 /* Unlock the first process lock, then check this was the WRITE lock that was
2171 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
2172 NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 0, 4, 0, READ_LOCK));
2174 EXPECTED(ret, True);
2175 printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
2177 /* Unlock the process 2 lock. */
2178 cli_unlock(cli2, fnum2, 0, 4);
2180 /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
2182 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 1, 1)) &&
2183 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
2184 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
2186 EXPECTED(ret, True);
2187 printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
2189 /* Ensure the next unlock fails. */
2190 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
2191 EXPECTED(ret, False);
2192 printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
2194 /* Ensure connection 2 can get a write lock. */
2195 status = cli_lock32(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
2196 ret = NT_STATUS_IS_OK(status);
2197 EXPECTED(ret, True);
2199 printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
2203 cli_close(cli1, fnum1);
2204 cli_close(cli2, fnum2);
2205 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2206 if (!torture_close_connection(cli1)) {
2209 if (!torture_close_connection(cli2)) {
2213 printf("finished locktest5\n");
2219 tries the unusual lockingX locktype bits
2221 static bool run_locktest6(int dummy)
2223 static struct cli_state *cli;
2224 const char *fname[1] = { "\\lock6.txt" };
2229 if (!torture_open_connection(&cli, 0)) {
2233 smbXcli_conn_set_sockopt(cli->conn, sockops);
2235 printf("starting locktest6\n");
2238 printf("Testing %s\n", fname[i]);
2240 cli_unlink(cli, fname[i], FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2242 cli_openx(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
2243 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
2244 cli_close(cli, fnum);
2245 printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
2247 cli_openx(cli, fname[i], O_RDWR, DENY_NONE, &fnum);
2248 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
2249 cli_close(cli, fnum);
2250 printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
2252 cli_unlink(cli, fname[i], FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2255 torture_close_connection(cli);
2257 printf("finished locktest6\n");
2261 static bool run_locktest7(int dummy)
2263 struct cli_state *cli1;
2264 const char *fname = "\\lockt7.lck";
2267 bool correct = False;
2271 if (!torture_open_connection(&cli1, 0)) {
2275 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2277 printf("starting locktest7\n");
2279 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2281 cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2283 memset(buf, 0, sizeof(buf));
2285 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf),
2287 if (!NT_STATUS_IS_OK(status)) {
2288 printf("Failed to create file: %s\n", nt_errstr(status));
2292 cli_setpid(cli1, 1);
2294 status = cli_lock32(cli1, fnum1, 130, 4, 0, READ_LOCK);
2295 if (!NT_STATUS_IS_OK(status)) {
2296 printf("Unable to apply read lock on range 130:4, "
2297 "error was %s\n", nt_errstr(status));
2300 printf("pid1 successfully locked range 130:4 for READ\n");
2303 status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2304 if (!NT_STATUS_IS_OK(status)) {
2305 printf("pid1 unable to read the range 130:4, error was %s\n",
2308 } else if (nread != 4) {
2309 printf("pid1 unable to read the range 130:4, "
2310 "recv %ld req %d\n", (unsigned long)nread, 4);
2313 printf("pid1 successfully read the range 130:4\n");
2316 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2317 if (!NT_STATUS_IS_OK(status)) {
2318 printf("pid1 unable to write to the range 130:4, error was "
2319 "%s\n", nt_errstr(status));
2320 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2321 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2325 printf("pid1 successfully wrote to the range 130:4 (should be denied)\n");
2329 cli_setpid(cli1, 2);
2331 status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2332 if (!NT_STATUS_IS_OK(status)) {
2333 printf("pid2 unable to read the range 130:4, error was %s\n",
2336 } else if (nread != 4) {
2337 printf("pid2 unable to read the range 130:4, "
2338 "recv %ld req %d\n", (unsigned long)nread, 4);
2341 printf("pid2 successfully read the range 130:4\n");
2344 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2345 if (!NT_STATUS_IS_OK(status)) {
2346 printf("pid2 unable to write to the range 130:4, error was "
2347 "%s\n", nt_errstr(status));
2348 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2349 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2353 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2357 cli_setpid(cli1, 1);
2358 cli_unlock(cli1, fnum1, 130, 4);
2360 status = cli_lock32(cli1, fnum1, 130, 4, 0, WRITE_LOCK);
2361 if (!NT_STATUS_IS_OK(status)) {
2362 printf("Unable to apply write lock on range 130:4, error was %s\n", nt_errstr(status));
2365 printf("pid1 successfully locked range 130:4 for WRITE\n");
2368 status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2369 if (!NT_STATUS_IS_OK(status)) {
2370 printf("pid1 unable to read the range 130:4, error was %s\n",
2373 } else if (nread != 4) {
2374 printf("pid1 unable to read the range 130:4, "
2375 "recv %ld req %d\n", (unsigned long)nread, 4);
2378 printf("pid1 successfully read the range 130:4\n");
2381 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2382 if (!NT_STATUS_IS_OK(status)) {
2383 printf("pid1 unable to write to the range 130:4, error was "
2384 "%s\n", nt_errstr(status));
2387 printf("pid1 successfully wrote to the range 130:4\n");
2390 cli_setpid(cli1, 2);
2392 status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2393 if (!NT_STATUS_IS_OK(status)) {
2394 printf("pid2 unable to read the range 130:4, error was "
2395 "%s\n", nt_errstr(status));
2396 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2397 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2401 printf("pid2 successfully read the range 130:4 (should be denied) recv %ld\n",
2402 (unsigned long)nread);
2406 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2407 if (!NT_STATUS_IS_OK(status)) {
2408 printf("pid2 unable to write to the range 130:4, error was "
2409 "%s\n", nt_errstr(status));
2410 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2411 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2415 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2419 cli_unlock(cli1, fnum1, 130, 0);
2423 cli_close(cli1, fnum1);
2424 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2425 torture_close_connection(cli1);
2427 printf("finished locktest7\n");
2432 * This demonstrates a problem with our use of GPFS share modes: A file
2433 * descriptor sitting in the pending close queue holding a GPFS share mode
2434 * blocks opening a file another time. Happens with Word 2007 temp files.
2435 * With "posix locking = yes" and "gpfs:sharemodes = yes" enabled, the third
2436 * open is denied with NT_STATUS_SHARING_VIOLATION.
2439 static bool run_locktest8(int dummy)
2441 struct cli_state *cli1;
2442 const char *fname = "\\lockt8.lck";
2443 uint16_t fnum1, fnum2;
2445 bool correct = False;
2448 if (!torture_open_connection(&cli1, 0)) {
2452 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2454 printf("starting locktest8\n");
2456 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2458 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_WRITE,
2460 if (!NT_STATUS_IS_OK(status)) {
2461 d_fprintf(stderr, "cli_openx returned %s\n", nt_errstr(status));
2465 memset(buf, 0, sizeof(buf));
2467 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum2);
2468 if (!NT_STATUS_IS_OK(status)) {
2469 d_fprintf(stderr, "cli_openx second time returned %s\n",
2474 status = cli_lock32(cli1, fnum2, 1, 1, 0, READ_LOCK);
2475 if (!NT_STATUS_IS_OK(status)) {
2476 printf("Unable to apply read lock on range 1:1, error was "
2477 "%s\n", nt_errstr(status));
2481 status = cli_close(cli1, fnum1);
2482 if (!NT_STATUS_IS_OK(status)) {
2483 d_fprintf(stderr, "cli_close(fnum1) %s\n", nt_errstr(status));
2487 status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2488 if (!NT_STATUS_IS_OK(status)) {
2489 d_fprintf(stderr, "cli_openx third time returned %s\n",
2497 cli_close(cli1, fnum1);
2498 cli_close(cli1, fnum2);
2499 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2500 torture_close_connection(cli1);
2502 printf("finished locktest8\n");
2507 * This test is designed to be run in conjunction with
2508 * external NFS or POSIX locks taken in the filesystem.
2509 * It checks that the smbd server will block until the
2510 * lock is released and then acquire it. JRA.
2513 static bool got_alarm;
2514 static struct cli_state *alarm_cli;
2516 static void alarm_handler(int dummy)
2521 static void alarm_handler_parent(int dummy)
2523 smbXcli_conn_disconnect(alarm_cli->conn, NT_STATUS_OK);
2526 static void do_local_lock(int read_fd, int write_fd)
2531 const char *local_pathname = NULL;
2534 local_pathname = talloc_asprintf(talloc_tos(),
2535 "%s/lockt9.lck", local_path);
2536 if (!local_pathname) {
2537 printf("child: alloc fail\n");
2541 unlink(local_pathname);
2542 fd = open(local_pathname, O_RDWR|O_CREAT, 0666);
2544 printf("child: open of %s failed %s.\n",
2545 local_pathname, strerror(errno));
2549 /* Now take a fcntl lock. */
2550 lock.l_type = F_WRLCK;
2551 lock.l_whence = SEEK_SET;
2554 lock.l_pid = getpid();
2556 ret = fcntl(fd,F_SETLK,&lock);
2558 printf("child: failed to get lock 0:4 on file %s. Error %s\n",
2559 local_pathname, strerror(errno));
2562 printf("child: got lock 0:4 on file %s.\n",
2567 CatchSignal(SIGALRM, alarm_handler);
2569 /* Signal the parent. */
2570 if (write(write_fd, &c, 1) != 1) {
2571 printf("child: start signal fail %s.\n",
2578 /* Wait for the parent to be ready. */
2579 if (read(read_fd, &c, 1) != 1) {
2580 printf("child: reply signal fail %s.\n",
2588 printf("child: released lock 0:4 on file %s.\n",
2594 static bool run_locktest9(int dummy)
2596 struct cli_state *cli1;
2597 const char *fname = "\\lockt9.lck";
2599 bool correct = False;
2600 int pipe_in[2], pipe_out[2];
2604 struct timeval start;
2608 printf("starting locktest9\n");
2610 if (local_path == NULL) {
2611 d_fprintf(stderr, "locktest9 must be given a local path via -l <localpath>\n");
2615 if (pipe(pipe_in) == -1 || pipe(pipe_out) == -1) {
2620 if (child_pid == -1) {
2624 if (child_pid == 0) {
2626 do_local_lock(pipe_out[0], pipe_in[1]);
2636 ret = read(pipe_in[0], &c, 1);
2638 d_fprintf(stderr, "failed to read start signal from child. %s\n",
2643 if (!torture_open_connection(&cli1, 0)) {
2647 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2649 status = cli_openx(cli1, fname, O_RDWR, DENY_NONE,
2651 if (!NT_STATUS_IS_OK(status)) {
2652 d_fprintf(stderr, "cli_openx returned %s\n", nt_errstr(status));
2656 /* Ensure the child has the lock. */
2657 status = cli_lock32(cli1, fnum, 0, 4, 0, WRITE_LOCK);
2658 if (NT_STATUS_IS_OK(status)) {
2659 d_fprintf(stderr, "Got the lock on range 0:4 - this should not happen !\n");
2662 d_printf("Child has the lock.\n");
2665 /* Tell the child to wait 5 seconds then exit. */
2666 ret = write(pipe_out[1], &c, 1);
2668 d_fprintf(stderr, "failed to send exit signal to child. %s\n",
2673 /* Wait 20 seconds for the lock. */
2675 CatchSignal(SIGALRM, alarm_handler_parent);
2678 start = timeval_current();
2680 status = cli_lock32(cli1, fnum, 0, 4, -1, WRITE_LOCK);
2681 if (!NT_STATUS_IS_OK(status)) {
2682 d_fprintf(stderr, "Unable to apply write lock on range 0:4, error was "
2683 "%s\n", nt_errstr(status));
2688 seconds = timeval_elapsed(&start);
2690 printf("Parent got the lock after %.2f seconds.\n",
2693 status = cli_close(cli1, fnum);
2694 if (!NT_STATUS_IS_OK(status)) {
2695 d_fprintf(stderr, "cli_close(fnum1) %s\n", nt_errstr(status));
2702 cli_close(cli1, fnum);
2703 torture_close_connection(cli1);
2707 printf("finished locktest9\n");
2712 test whether fnums and tids open on one VC are available on another (a major
2715 static bool run_fdpasstest(int dummy)
2717 struct cli_state *cli1, *cli2;
2718 const char *fname = "\\fdpass.tst";
2723 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2726 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2727 smbXcli_conn_set_sockopt(cli2->conn, sockops);
2729 printf("starting fdpasstest\n");
2731 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2733 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
2735 if (!NT_STATUS_IS_OK(status)) {
2736 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
2740 status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"hello world\n", 0,
2742 if (!NT_STATUS_IS_OK(status)) {
2743 printf("write failed (%s)\n", nt_errstr(status));
2747 cli_state_set_uid(cli2, cli_state_get_uid(cli1));
2748 cli_state_set_tid(cli2, cli_state_get_tid(cli1));
2749 cli_setpid(cli2, cli_getpid(cli1));
2751 if (test_cli_read(cli2, fnum1, buf, 0, 13, NULL, 13)) {
2752 printf("read succeeded! nasty security hole [%s]\n", buf);
2756 cli_close(cli1, fnum1);
2757 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2759 torture_close_connection(cli1);
2760 torture_close_connection(cli2);
2762 printf("finished fdpasstest\n");
2766 static bool run_fdsesstest(int dummy)
2768 struct cli_state *cli;
2770 uint16_t saved_vuid;
2772 uint16_t saved_cnum;
2773 const char *fname = "\\fdsess.tst";
2774 const char *fname1 = "\\fdsess1.tst";
2781 if (!torture_open_connection(&cli, 0))
2783 smbXcli_conn_set_sockopt(cli->conn, sockops);
2785 if (!torture_cli_session_setup2(cli, &new_vuid))
2788 saved_cnum = cli_state_get_tid(cli);
2789 if (!NT_STATUS_IS_OK(cli_tree_connect(cli, share, "?????", "", 1)))
2791 new_cnum = cli_state_get_tid(cli);
2792 cli_state_set_tid(cli, saved_cnum);
2794 printf("starting fdsesstest\n");
2796 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2797 cli_unlink(cli, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2799 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2800 if (!NT_STATUS_IS_OK(status)) {
2801 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
2805 status = cli_writeall(cli, fnum1, 0, (const uint8_t *)"hello world\n", 0, 13,
2807 if (!NT_STATUS_IS_OK(status)) {
2808 printf("write failed (%s)\n", nt_errstr(status));
2812 saved_vuid = cli_state_get_uid(cli);
2813 cli_state_set_uid(cli, new_vuid);
2815 if (test_cli_read(cli, fnum1, buf, 0, 13, NULL, 13)) {
2816 printf("read succeeded with different vuid! "
2817 "nasty security hole [%s]\n", buf);
2820 /* Try to open a file with different vuid, samba cnum. */
2821 if (NT_STATUS_IS_OK(cli_openx(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum2))) {
2822 printf("create with different vuid, same cnum succeeded.\n");
2823 cli_close(cli, fnum2);
2824 cli_unlink(cli, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2826 printf("create with different vuid, same cnum failed.\n");
2827 printf("This will cause problems with service clients.\n");
2831 cli_state_set_uid(cli, saved_vuid);
2833 /* Try with same vuid, different cnum. */
2834 cli_state_set_tid(cli, new_cnum);
2836 if (test_cli_read(cli, fnum1, buf, 0, 13, NULL, 13)) {
2837 printf("read succeeded with different cnum![%s]\n", buf);
2841 cli_state_set_tid(cli, saved_cnum);
2842 cli_close(cli, fnum1);
2843 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2845 torture_close_connection(cli);
2847 printf("finished fdsesstest\n");
2852 This test checks that
2854 1) the server does not allow an unlink on a file that is open
2856 static bool run_unlinktest(int dummy)
2858 struct cli_state *cli;
2859 const char *fname = "\\unlink.tst";
2861 bool correct = True;
2864 if (!torture_open_connection(&cli, 0)) {
2868 smbXcli_conn_set_sockopt(cli->conn, sockops);
2870 printf("starting unlink test\n");
2872 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2876 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
2877 if (!NT_STATUS_IS_OK(status)) {
2878 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
2882 status = cli_unlink(cli, fname,
2883 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2884 if (NT_STATUS_IS_OK(status)) {
2885 printf("error: server allowed unlink on an open file\n");
2888 correct = check_error(__LINE__, status, ERRDOS, ERRbadshare,
2889 NT_STATUS_SHARING_VIOLATION);
2892 cli_close(cli, fnum);
2893 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2895 if (!torture_close_connection(cli)) {
2899 printf("unlink test finished\n");
2906 test how many open files this server supports on the one socket
2908 static bool run_maxfidtest(int dummy)
2910 struct cli_state *cli;
2912 uint16_t fnums[0x11000];
2915 bool correct = True;
2921 printf("failed to connect\n");
2925 smbXcli_conn_set_sockopt(cli->conn, sockops);
2927 for (i=0; i<0x11000; i++) {
2928 slprintf(fname,sizeof(fname)-1,"\\maxfid.%d.%d", i,(int)getpid());
2929 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE,
2931 if (!NT_STATUS_IS_OK(status)) {
2932 printf("open of %s failed (%s)\n",
2933 fname, nt_errstr(status));
2934 printf("maximum fnum is %d\n", i);
2942 printf("cleaning up\n");
2944 slprintf(fname,sizeof(fname)-1,"\\maxfid.%d.%d", i,(int)getpid());
2945 cli_close(cli, fnums[i]);
2947 status = cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2948 if (!NT_STATUS_IS_OK(status)) {
2949 printf("unlink of %s failed (%s)\n",
2950 fname, nt_errstr(status));
2957 printf("maxfid test finished\n");
2958 if (!torture_close_connection(cli)) {
2964 /* generate a random buffer */
2965 static void rand_buf(char *buf, int len)
2968 *buf = (char)sys_random();
2973 /* send smb negprot commands, not reading the response */
2974 static bool run_negprot_nowait(int dummy)
2976 struct tevent_context *ev;
2978 struct cli_state *cli;
2979 bool correct = True;
2981 printf("starting negprot nowait test\n");
2983 ev = samba_tevent_context_init(talloc_tos());
2988 if (!(cli = open_nbt_connection())) {
2993 for (i=0;i<50000;i++) {
2994 struct tevent_req *req;
2996 req = smbXcli_negprot_send(ev, ev, cli->conn, cli->timeout,
2997 PROTOCOL_CORE, PROTOCOL_NT1);
3002 if (!tevent_req_poll(req, ev)) {
3003 d_fprintf(stderr, "tevent_req_poll failed: %s\n",
3011 if (torture_close_connection(cli)) {
3015 printf("finished negprot nowait test\n");
3020 /* send smb negprot commands, not reading the response */
3021 static bool run_bad_nbt_session(int dummy)
3023 struct nmb_name called, calling;
3024 struct sockaddr_storage ss;
3029 printf("starting bad nbt session test\n");
3031 make_nmb_name(&calling, myname, 0x0);
3032 make_nmb_name(&called , host, 0x20);
3034 if (!resolve_name(host, &ss, 0x20, true)) {
3035 d_fprintf(stderr, "Could not resolve name %s\n", host);
3039 status = open_socket_out(&ss, NBT_SMB_PORT, 10000, &fd);
3040 if (!NT_STATUS_IS_OK(status)) {
3041 d_fprintf(stderr, "open_socket_out failed: %s\n",
3046 ret = cli_bad_session_request(fd, &calling, &called);
3049 d_fprintf(stderr, "open_socket_out failed: %s\n",
3054 printf("finished bad nbt session test\n");
3058 /* send random IPC commands */
3059 static bool run_randomipc(int dummy)
3061 char *rparam = NULL;
3063 unsigned int rdrcnt,rprcnt;
3065 int api, param_len, i;
3066 struct cli_state *cli;
3067 bool correct = True;
3070 printf("starting random ipc test\n");
3072 if (!torture_open_connection(&cli, 0)) {
3076 for (i=0;i<count;i++) {
3077 api = sys_random() % 500;
3078 param_len = (sys_random() % 64);
3080 rand_buf(param, param_len);
3085 param, param_len, 8,
3086 NULL, 0, CLI_BUFFER_SIZE,
3090 printf("%d/%d\r", i,count);
3093 printf("%d/%d\n", i, count);
3095 if (!torture_close_connection(cli)) {
3102 printf("finished random ipc test\n");
3109 static void browse_callback(const char *sname, uint32_t stype,
3110 const char *comment, void *state)
3112 printf("\t%20.20s %08x %s\n", sname, stype, comment);
3118 This test checks the browse list code
3121 static bool run_browsetest(int dummy)
3123 static struct cli_state *cli;
3124 bool correct = True;
3126 printf("starting browse test\n");
3128 if (!torture_open_connection(&cli, 0)) {
3132 printf("domain list:\n");
3133 cli_NetServerEnum(cli, cli->server_domain,
3134 SV_TYPE_DOMAIN_ENUM,
3135 browse_callback, NULL);
3137 printf("machine list:\n");
3138 cli_NetServerEnum(cli, cli->server_domain,
3140 browse_callback, NULL);
3142 if (!torture_close_connection(cli)) {
3146 printf("browse test finished\n");
3154 This checks how the getatr calls works
3156 static bool run_attrtest(int dummy)
3158 struct cli_state *cli;
3161 const char *fname = "\\attrib123456789.tst";
3162 bool correct = True;
3165 printf("starting attrib test\n");
3167 if (!torture_open_connection(&cli, 0)) {
3171 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3172 cli_openx(cli, fname,
3173 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3174 cli_close(cli, fnum);
3176 status = cli_getatr(cli, fname, NULL, NULL, &t);
3177 if (!NT_STATUS_IS_OK(status)) {
3178 printf("getatr failed (%s)\n", nt_errstr(status));
3182 if (abs(t - time(NULL)) > 60*60*24*10) {
3183 printf("ERROR: SMBgetatr bug. time is %s",
3189 t2 = t-60*60*24; /* 1 day ago */
3191 status = cli_setatr(cli, fname, 0, t2);
3192 if (!NT_STATUS_IS_OK(status)) {
3193 printf("setatr failed (%s)\n", nt_errstr(status));
3197 status = cli_getatr(cli, fname, NULL, NULL, &t);
3198 if (!NT_STATUS_IS_OK(status)) {
3199 printf("getatr failed (%s)\n", nt_errstr(status));
3204 printf("ERROR: getatr/setatr bug. times are\n%s",
3206 printf("%s", ctime(&t2));
3210 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3212 if (!torture_close_connection(cli)) {
3216 printf("attrib test finished\n");
3223 This checks a couple of trans2 calls
3225 static bool run_trans2test(int dummy)
3227 struct cli_state *cli;
3230 time_t c_time, a_time, m_time;
3231 struct timespec c_time_ts, a_time_ts, m_time_ts, w_time_ts, m_time2_ts;
3232 const char *fname = "\\trans2.tst";
3233 const char *dname = "\\trans2";
3234 const char *fname2 = "\\trans2\\trans2.tst";
3236 bool correct = True;
3240 printf("starting trans2 test\n");
3242 if (!torture_open_connection(&cli, 0)) {
3246 status = cli_get_fs_attr_info(cli, &fs_attr);
3247 if (!NT_STATUS_IS_OK(status)) {
3248 printf("ERROR: cli_get_fs_attr_info returned %s\n",
3253 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3254 cli_openx(cli, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3255 status = cli_qfileinfo_basic(cli, fnum, NULL, &size, &c_time_ts,
3256 &a_time_ts, &w_time_ts, &m_time_ts, NULL);
3257 if (!NT_STATUS_IS_OK(status)) {
3258 printf("ERROR: qfileinfo failed (%s)\n", nt_errstr(status));
3262 status = cli_qfilename(cli, fnum, talloc_tos(), &pname);
3263 if (!NT_STATUS_IS_OK(status)) {
3264 printf("ERROR: qfilename failed (%s)\n", nt_errstr(status));
3267 else if (strcmp(pname, fname)) {
3268 printf("qfilename gave different name? [%s] [%s]\n",
3273 cli_close(cli, fnum);
3277 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3278 status = cli_openx(cli, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE,
3280 if (!NT_STATUS_IS_OK(status)) {
3281 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3284 cli_close(cli, fnum);
3286 status = cli_qpathinfo1(cli, fname, &c_time, &a_time, &m_time, &size,
3288 if (!NT_STATUS_IS_OK(status)) {
3289 printf("ERROR: qpathinfo failed (%s)\n", nt_errstr(status));
3292 time_t t = time(NULL);
3294 if (c_time != m_time) {
3295 printf("create time=%s", ctime(&c_time));
3296 printf("modify time=%s", ctime(&m_time));
3297 printf("This system appears to have sticky create times\n");
3299 if ((abs(a_time - t) > 60) && (a_time % (60*60) == 0)) {
3300 printf("access time=%s", ctime(&a_time));
3301 printf("This system appears to set a midnight access time\n");
3305 if (abs(m_time - t) > 60*60*24*7) {
3306 printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
3312 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3313 cli_openx(cli, fname,
3314 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3315 cli_close(cli, fnum);
3316 status = cli_qpathinfo2(cli, fname, &c_time_ts, &a_time_ts, &w_time_ts,
3317 &m_time_ts, &size, NULL, NULL);
3318 if (!NT_STATUS_IS_OK(status)) {
3319 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
3322 if (w_time_ts.tv_sec < 60*60*24*2) {
3323 printf("write time=%s", ctime(&w_time_ts.tv_sec));
3324 printf("This system appears to set a initial 0 write time\n");
3329 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3332 /* check if the server updates the directory modification time
3333 when creating a new file */
3334 status = cli_mkdir(cli, dname);
3335 if (!NT_STATUS_IS_OK(status)) {
3336 printf("ERROR: mkdir failed (%s)\n", nt_errstr(status));
3340 status = cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts,
3341 &w_time_ts, &m_time_ts, &size, NULL, NULL);
3342 if (!NT_STATUS_IS_OK(status)) {
3343 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
3347 cli_openx(cli, fname2,
3348 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3349 cli_writeall(cli, fnum, 0, (uint8_t *)&fnum, 0, sizeof(fnum), NULL);
3350 cli_close(cli, fnum);
3351 status = cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts,
3352 &w_time_ts, &m_time2_ts, &size, NULL, NULL);
3353 if (!NT_STATUS_IS_OK(status)) {
3354 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
3357 if (memcmp(&m_time_ts, &m_time2_ts, sizeof(struct timespec))
3359 printf("This system does not update directory modification times\n");
3363 cli_unlink(cli, fname2, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3364 cli_rmdir(cli, dname);
3366 if (!torture_close_connection(cli)) {
3370 printf("trans2 test finished\n");
3376 This checks new W2K calls.
3379 static NTSTATUS new_trans(struct cli_state *pcli, int fnum, int level)
3381 uint8_t *buf = NULL;
3385 status = cli_qfileinfo(talloc_tos(), pcli, fnum, level, 0,
3386 CLI_BUFFER_SIZE, NULL, &buf, &len);
3387 if (!NT_STATUS_IS_OK(status)) {
3388 printf("ERROR: qfileinfo (%d) failed (%s)\n", level,
3391 printf("qfileinfo: level %d, len = %u\n", level, len);
3392 dump_data(0, (uint8_t *)buf, len);
3399 static bool run_w2ktest(int dummy)
3401 struct cli_state *cli;
3403 const char *fname = "\\w2ktest\\w2k.tst";
3405 bool correct = True;
3407 printf("starting w2k test\n");
3409 if (!torture_open_connection(&cli, 0)) {
3413 cli_openx(cli, fname,
3414 O_RDWR | O_CREAT , DENY_NONE, &fnum);
3416 for (level = 1004; level < 1040; level++) {
3417 new_trans(cli, fnum, level);
3420 cli_close(cli, fnum);
3422 if (!torture_close_connection(cli)) {
3426 printf("w2k test finished\n");
3433 this is a harness for some oplock tests
3435 static bool run_oplock1(int dummy)
3437 struct cli_state *cli1;
3438 const char *fname = "\\lockt1.lck";
3440 bool correct = True;
3443 printf("starting oplock test 1\n");
3445 if (!torture_open_connection(&cli1, 0)) {
3449 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3451 smbXcli_conn_set_sockopt(cli1->conn, sockops);
3453 cli1->use_oplocks = True;
3455 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
3457 if (!NT_STATUS_IS_OK(status)) {
3458 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3462 cli1->use_oplocks = False;
3464 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3465 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3467 status = cli_close(cli1, fnum1);
3468 if (!NT_STATUS_IS_OK(status)) {
3469 printf("close2 failed (%s)\n", nt_errstr(status));
3473 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3474 if (!NT_STATUS_IS_OK(status)) {
3475 printf("unlink failed (%s)\n", nt_errstr(status));
3479 if (!torture_close_connection(cli1)) {
3483 printf("finished oplock test 1\n");
3488 static bool run_oplock2(int dummy)
3490 struct cli_state *cli1, *cli2;
3491 const char *fname = "\\lockt2.lck";
3492 uint16_t fnum1, fnum2;
3493 int saved_use_oplocks = use_oplocks;
3495 bool correct = True;
3496 volatile bool *shared_correct;
3500 shared_correct = (volatile bool *)anonymous_shared_allocate(sizeof(bool));
3501 *shared_correct = True;
3503 use_level_II_oplocks = True;
3506 printf("starting oplock test 2\n");
3508 if (!torture_open_connection(&cli1, 0)) {
3509 use_level_II_oplocks = False;
3510 use_oplocks = saved_use_oplocks;
3514 if (!torture_open_connection(&cli2, 1)) {
3515 use_level_II_oplocks = False;
3516 use_oplocks = saved_use_oplocks;
3520 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3522 smbXcli_conn_set_sockopt(cli1->conn, sockops);
3523 smbXcli_conn_set_sockopt(cli2->conn, sockops);
3525 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
3527 if (!NT_STATUS_IS_OK(status)) {
3528 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3532 /* Don't need the globals any more. */
3533 use_level_II_oplocks = False;
3534 use_oplocks = saved_use_oplocks;
3538 status = cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
3539 if (!NT_STATUS_IS_OK(status)) {
3540 printf("second open of %s failed (%s)\n", fname, nt_errstr(status));
3541 *shared_correct = False;
3547 status = cli_close(cli2, fnum2);
3548 if (!NT_STATUS_IS_OK(status)) {
3549 printf("close2 failed (%s)\n", nt_errstr(status));
3550 *shared_correct = False;
3558 /* Ensure cli1 processes the break. Empty file should always return 0
3560 status = cli_read(cli1, fnum1, buf, 0, 4, &nread);
3561 if (!NT_STATUS_IS_OK(status)) {
3562 printf("read on fnum1 failed (%s)\n", nt_errstr(status));
3564 } else if (nread != 0) {
3565 printf("read on empty fnum1 failed. recv %ld expected %d\n",
3566 (unsigned long)nread, 0);
3570 /* Should now be at level II. */
3571 /* Test if sending a write locks causes a break to none. */
3572 status = cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK);
3573 if (!NT_STATUS_IS_OK(status)) {
3574 printf("lock failed (%s)\n", nt_errstr(status));
3578 cli_unlock(cli1, fnum1, 0, 4);
3582 status = cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK);
3583 if (!NT_STATUS_IS_OK(status)) {
3584 printf("lock failed (%s)\n", nt_errstr(status));
3588 cli_unlock(cli1, fnum1, 0, 4);
3592 cli_read(cli1, fnum1, buf, 0, 4, NULL);
3594 status = cli_close(cli1, fnum1);
3595 if (!NT_STATUS_IS_OK(status)) {
3596 printf("close1 failed (%s)\n", nt_errstr(status));
3602 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3603 if (!NT_STATUS_IS_OK(status)) {
3604 printf("unlink failed (%s)\n", nt_errstr(status));
3608 if (!torture_close_connection(cli1)) {
3612 if (!*shared_correct) {
3616 printf("finished oplock test 2\n");
3621 struct oplock4_state {
3622 struct tevent_context *ev;
3623 struct cli_state *cli;
3628 static void oplock4_got_break(struct tevent_req *req);
3629 static void oplock4_got_open(struct tevent_req *req);
3631 static bool run_oplock4(int dummy)
3633 struct tevent_context *ev;
3634 struct cli_state *cli1, *cli2;
3635 struct tevent_req *oplock_req, *open_req;
3636 const char *fname = "\\lockt4.lck";
3637 const char *fname_ln = "\\lockt4_ln.lck";
3638 uint16_t fnum1, fnum2;
3639 int saved_use_oplocks = use_oplocks;
3641 bool correct = true;
3645 struct oplock4_state *state;
3647 printf("starting oplock test 4\n");
3649 if (!torture_open_connection(&cli1, 0)) {
3650 use_level_II_oplocks = false;
3651 use_oplocks = saved_use_oplocks;
3655 if (!torture_open_connection(&cli2, 1)) {
3656 use_level_II_oplocks = false;
3657 use_oplocks = saved_use_oplocks;
3661 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3662 cli_unlink(cli1, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3664 smbXcli_conn_set_sockopt(cli1->conn, sockops);
3665 smbXcli_conn_set_sockopt(cli2->conn, sockops);
3667 /* Create the file. */
3668 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
3670 if (!NT_STATUS_IS_OK(status)) {
3671 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3675 status = cli_close(cli1, fnum1);
3676 if (!NT_STATUS_IS_OK(status)) {
3677 printf("close1 failed (%s)\n", nt_errstr(status));
3681 /* Now create a hardlink. */
3682 status = cli_nt_hardlink(cli1, fname, fname_ln);
3683 if (!NT_STATUS_IS_OK(status)) {
3684 printf("nt hardlink failed (%s)\n", nt_errstr(status));
3688 /* Prove that opening hardlinks cause deny modes to conflict. */
3689 status = cli_openx(cli1, fname, O_RDWR, DENY_ALL, &fnum1);
3690 if (!NT_STATUS_IS_OK(status)) {
3691 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3695 status = cli_openx(cli1, fname_ln, O_RDWR, DENY_NONE, &fnum2);
3696 if (NT_STATUS_IS_OK(status)) {
3697 printf("open of %s succeeded - should fail with sharing violation.\n",
3702 if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
3703 printf("open of %s should fail with sharing violation. Got %s\n",
3704 fname_ln, nt_errstr(status));
3708 status = cli_close(cli1, fnum1);
3709 if (!NT_STATUS_IS_OK(status)) {
3710 printf("close1 failed (%s)\n", nt_errstr(status));
3714 cli1->use_oplocks = true;
3715 cli2->use_oplocks = true;
3717 status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
3718 if (!NT_STATUS_IS_OK(status)) {
3719 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3723 ev = samba_tevent_context_init(talloc_tos());
3725 printf("tevent_context_init failed\n");
3729 state = talloc(ev, struct oplock4_state);
3730 if (state == NULL) {
3731 printf("talloc failed\n");
3736 state->got_break = &got_break;
3737 state->fnum2 = &fnum2;
3739 oplock_req = cli_smb_oplock_break_waiter_send(
3740 talloc_tos(), ev, cli1);
3741 if (oplock_req == NULL) {
3742 printf("cli_smb_oplock_break_waiter_send failed\n");
3745 tevent_req_set_callback(oplock_req, oplock4_got_break, state);
3747 open_req = cli_openx_send(
3748 talloc_tos(), ev, cli2, fname_ln, O_RDWR, DENY_NONE);
3749 if (open_req == NULL) {
3750 printf("cli_openx_send failed\n");
3753 tevent_req_set_callback(open_req, oplock4_got_open, state);
3758 while (!got_break || fnum2 == 0xffff) {
3760 ret = tevent_loop_once(ev);
3762 printf("tevent_loop_once failed: %s\n",
3768 status = cli_close(cli2, fnum2);
3769 if (!NT_STATUS_IS_OK(status)) {
3770 printf("close2 failed (%s)\n", nt_errstr(status));
3774 status = cli_close(cli1, fnum1);
3775 if (!NT_STATUS_IS_OK(status)) {
3776 printf("close1 failed (%s)\n", nt_errstr(status));
3780 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3781 if (!NT_STATUS_IS_OK(status)) {
3782 printf("unlink failed (%s)\n", nt_errstr(status));
3786 status = cli_unlink(cli1, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3787 if (!NT_STATUS_IS_OK(status)) {
3788 printf("unlink failed (%s)\n", nt_errstr(status));
3792 if (!torture_close_connection(cli1)) {
3800 printf("finished oplock test 4\n");
3805 static void oplock4_got_break(struct tevent_req *req)
3807 struct oplock4_state *state = tevent_req_callback_data(
3808 req, struct oplock4_state);
3813 status = cli_smb_oplock_break_waiter_recv(req, &fnum, &level);
3815 if (!NT_STATUS_IS_OK(status)) {
3816 printf("cli_smb_oplock_break_waiter_recv returned %s\n",
3820 *state->got_break = true;
3822 req = cli_oplock_ack_send(state, state->ev, state->cli, fnum,
3825 printf("cli_oplock_ack_send failed\n");
3830 static void oplock4_got_open(struct tevent_req *req)
3832 struct oplock4_state *state = tevent_req_callback_data(
3833 req, struct oplock4_state);
3836 status = cli_openx_recv(req, state->fnum2);
3837 if (!NT_STATUS_IS_OK(status)) {
3838 printf("cli_openx_recv returned %s\n", nt_errstr(status));
3839 *state->fnum2 = 0xffff;
3844 Test delete on close semantics.
3846 static bool run_deletetest(int dummy)
3848 struct cli_state *cli1 = NULL;
3849 struct cli_state *cli2 = NULL;
3850 const char *fname = "\\delete.file";
3851 uint16_t fnum1 = (uint16_t)-1;
3852 uint16_t fnum2 = (uint16_t)-1;
3853 bool correct = false;
3856 printf("starting delete test\n");
3858 if (!torture_open_connection(&cli1, 0)) {
3862 smbXcli_conn_set_sockopt(cli1->conn, sockops);
3864 /* Test 1 - this should delete the file on close. */
3866 cli_setatr(cli1, fname, 0, 0);
3867 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3869 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
3870 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
3871 FILE_DELETE_ON_CLOSE, 0, &fnum1, NULL);
3872 if (!NT_STATUS_IS_OK(status)) {
3873 printf("[1] open of %s failed (%s)\n", fname, nt_errstr(status));
3877 status = cli_close(cli1, fnum1);
3878 if (!NT_STATUS_IS_OK(status)) {
3879 printf("[1] close failed (%s)\n", nt_errstr(status));
3883 status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
3884 if (NT_STATUS_IS_OK(status)) {
3885 printf("[1] open of %s succeeded (should fail)\n", fname);
3889 printf("first delete on close test succeeded.\n");
3891 /* Test 2 - this should delete the file on close. */
3893 cli_setatr(cli1, fname, 0, 0);
3894 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3896 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
3897 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
3898 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
3899 if (!NT_STATUS_IS_OK(status)) {
3900 printf("[2] open of %s failed (%s)\n", fname, nt_errstr(status));
3904 status = cli_nt_delete_on_close(cli1, fnum1, true);
3905 if (!NT_STATUS_IS_OK(status)) {
3906 printf("[2] setting delete_on_close failed (%s)\n", nt_errstr(status));
3910 status = cli_close(cli1, fnum1);
3911 if (!NT_STATUS_IS_OK(status)) {
3912 printf("[2] close failed (%s)\n", nt_errstr(status));
3916 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
3917 if (NT_STATUS_IS_OK(status)) {
3918 printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
3919 status = cli_close(cli1, fnum1);
3920 if (!NT_STATUS_IS_OK(status)) {
3921 printf("[2] close failed (%s)\n", nt_errstr(status));
3923 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3927 printf("second delete on close test succeeded.\n");
3930 cli_setatr(cli1, fname, 0, 0);
3931 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3933 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
3934 FILE_ATTRIBUTE_NORMAL,
3935 FILE_SHARE_READ|FILE_SHARE_WRITE,
3936 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
3937 if (!NT_STATUS_IS_OK(status)) {
3938 printf("[3] open - 1 of %s failed (%s)\n", fname, nt_errstr(status));
3942 /* This should fail with a sharing violation - open for delete is only compatible
3943 with SHARE_DELETE. */
3945 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
3946 FILE_ATTRIBUTE_NORMAL,
3947 FILE_SHARE_READ|FILE_SHARE_WRITE,
3948 FILE_OPEN, 0, 0, &fnum2, NULL);
3949 if (NT_STATUS_IS_OK(status)) {
3950 printf("[3] open - 2 of %s succeeded - should have failed.\n", fname);
3954 /* This should succeed. */
3955 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
3956 FILE_ATTRIBUTE_NORMAL,
3957 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3958 FILE_OPEN, 0, 0, &fnum2, NULL);
3959 if (!NT_STATUS_IS_OK(status)) {
3960 printf("[3] open - 3 of %s failed (%s)\n", fname, nt_errstr(status));
3964 status = cli_nt_delete_on_close(cli1, fnum1, true);
3965 if (!NT_STATUS_IS_OK(status)) {
3966 printf("[3] setting delete_on_close failed (%s)\n", nt_errstr(status));
3970 status = cli_close(cli1, fnum1);
3971 if (!NT_STATUS_IS_OK(status)) {
3972 printf("[3] close 1 failed (%s)\n", nt_errstr(status));
3976 status = cli_close(cli1, fnum2);
3977 if (!NT_STATUS_IS_OK(status)) {
3978 printf("[3] close 2 failed (%s)\n", nt_errstr(status));
3982 /* This should fail - file should no longer be there. */
3984 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
3985 if (NT_STATUS_IS_OK(status)) {
3986 printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
3987 status = cli_close(cli1, fnum1);
3988 if (!NT_STATUS_IS_OK(status)) {
3989 printf("[3] close failed (%s)\n", nt_errstr(status));
3991 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3995 printf("third delete on close test succeeded.\n");
3998 cli_setatr(cli1, fname, 0, 0);
3999 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4001 status = cli_ntcreate(cli1, fname, 0,
4002 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4003 FILE_ATTRIBUTE_NORMAL,
4004 FILE_SHARE_READ|FILE_SHARE_WRITE,
4005 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4006 if (!NT_STATUS_IS_OK(status)) {
4007 printf("[4] open of %s failed (%s)\n", fname, nt_errstr(status));
4011 /* This should succeed. */
4012 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4013 FILE_ATTRIBUTE_NORMAL,
4014 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4015 FILE_OPEN, 0, 0, &fnum2, NULL);
4016 if (!NT_STATUS_IS_OK(status)) {
4017 printf("[4] open - 2 of %s failed (%s)\n", fname, nt_errstr(status));
4021 status = cli_close(cli1, fnum2);
4022 if (!NT_STATUS_IS_OK(status)) {
4023 printf("[4] close - 1 failed (%s)\n", nt_errstr(status));
4027 status = cli_nt_delete_on_close(cli1, fnum1, true);
4028 if (!NT_STATUS_IS_OK(status)) {
4029 printf("[4] setting delete_on_close failed (%s)\n", nt_errstr(status));
4033 /* This should fail - no more opens once delete on close set. */
4034 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4035 FILE_ATTRIBUTE_NORMAL,
4036 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4037 FILE_OPEN, 0, 0, &fnum2, NULL);
4038 if (NT_STATUS_IS_OK(status)) {
4039 printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname );
4043 status = cli_close(cli1, fnum1);
4044 if (!NT_STATUS_IS_OK(status)) {
4045 printf("[4] close - 2 failed (%s)\n", nt_errstr(status));
4049 printf("fourth delete on close test succeeded.\n");
4052 cli_setatr(cli1, fname, 0, 0);
4053 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4055 status = cli_openx(cli1, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum1);
4056 if (!NT_STATUS_IS_OK(status)) {
4057 printf("[5] open of %s failed (%s)\n", fname, nt_errstr(status));
4061 /* This should fail - only allowed on NT opens with DELETE access. */
4063 status = cli_nt_delete_on_close(cli1, fnum1, true);
4064 if (NT_STATUS_IS_OK(status)) {
4065 printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
4069 status = cli_close(cli1, fnum1);
4070 if (!NT_STATUS_IS_OK(status)) {
4071 printf("[5] close failed (%s)\n", nt_errstr(status));
4075 printf("fifth delete on close test succeeded.\n");
4078 cli_setatr(cli1, fname, 0, 0);
4079 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4081 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
4082 FILE_ATTRIBUTE_NORMAL,
4083 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4084 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4085 if (!NT_STATUS_IS_OK(status)) {
4086 printf("[6] open of %s failed (%s)\n", fname,
4091 /* This should fail - only allowed on NT opens with DELETE access. */
4093 status = cli_nt_delete_on_close(cli1, fnum1, true);
4094 if (NT_STATUS_IS_OK(status)) {
4095 printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
4099 status = cli_close(cli1, fnum1);
4100 if (!NT_STATUS_IS_OK(status)) {
4101 printf("[6] close failed (%s)\n", nt_errstr(status));
4105 printf("sixth delete on close test succeeded.\n");
4108 cli_setatr(cli1, fname, 0, 0);
4109 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4111 status = cli_ntcreate(cli1, fname, 0,
4112 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4113 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
4114 0, 0, &fnum1, NULL);
4115 if (!NT_STATUS_IS_OK(status)) {
4116 printf("[7] open of %s failed (%s)\n", fname, nt_errstr(status));
4120 status = cli_nt_delete_on_close(cli1, fnum1, true);
4121 if (!NT_STATUS_IS_OK(status)) {
4122 printf("[7] setting delete_on_close on file failed !\n");
4126 status = cli_nt_delete_on_close(cli1, fnum1, false);
4127 if (!NT_STATUS_IS_OK(status)) {
4128 printf("[7] unsetting delete_on_close on file failed !\n");
4132 status = cli_close(cli1, fnum1);
4133 if (!NT_STATUS_IS_OK(status)) {
4134 printf("[7] close - 1 failed (%s)\n", nt_errstr(status));
4138 /* This next open should succeed - we reset the flag. */
4139 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
4140 if (!NT_STATUS_IS_OK(status)) {
4141 printf("[7] open of %s failed (%s)\n", fname, nt_errstr(status));
4145 status = cli_close(cli1, fnum1);
4146 if (!NT_STATUS_IS_OK(status)) {
4147 printf("[7] close - 2 failed (%s)\n", nt_errstr(status));
4151 printf("seventh delete on close test succeeded.\n");
4154 cli_setatr(cli1, fname, 0, 0);
4155 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4157 if (!torture_open_connection(&cli2, 1)) {
4158 printf("[8] failed to open second connection.\n");
4162 smbXcli_conn_set_sockopt(cli1->conn, sockops);
4164 status = cli_ntcreate(cli1, fname, 0,
4165 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4166 FILE_ATTRIBUTE_NORMAL,
4167 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4168 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4169 if (!NT_STATUS_IS_OK(status)) {
4170 printf("[8] open 1 of %s failed (%s)\n", fname, nt_errstr(status));
4174 status = cli_ntcreate(cli2, fname, 0,
4175 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4176 FILE_ATTRIBUTE_NORMAL,
4177 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4178 FILE_OPEN, 0, 0, &fnum2, NULL);
4179 if (!NT_STATUS_IS_OK(status)) {
4180 printf("[8] open 2 of %s failed (%s)\n", fname, nt_errstr(status));
4184 status = cli_nt_delete_on_close(cli1, fnum1, true);
4185 if (!NT_STATUS_IS_OK(status)) {
4186 printf("[8] setting delete_on_close on file failed !\n");
4190 status = cli_close(cli1, fnum1);
4191 if (!NT_STATUS_IS_OK(status)) {
4192 printf("[8] close - 1 failed (%s)\n", nt_errstr(status));
4196 status = cli_close(cli2, fnum2);
4197 if (!NT_STATUS_IS_OK(status)) {
4198 printf("[8] close - 2 failed (%s)\n", nt_errstr(status));
4202 /* This should fail.. */
4203 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
4204 if (NT_STATUS_IS_OK(status)) {
4205 printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
4209 printf("eighth delete on close test succeeded.\n");
4213 /* This should fail - we need to set DELETE_ACCESS. */
4214 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
4215 FILE_ATTRIBUTE_NORMAL,
4218 FILE_DELETE_ON_CLOSE, 0, &fnum1, NULL);
4219 if (NT_STATUS_IS_OK(status)) {
4220 printf("[9] open of %s succeeded should have failed!\n", fname);
4224 printf("ninth delete on close test succeeded.\n");
4228 status = cli_ntcreate(cli1, fname, 0,
4229 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4230 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
4231 FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE,
4233 if (!NT_STATUS_IS_OK(status)) {
4234 printf("[10] open of %s failed (%s)\n", fname, nt_errstr(status));
4238 /* This should delete the file. */
4239 status = cli_close(cli1, fnum1);
4240 if (!NT_STATUS_IS_OK(status)) {
4241 printf("[10] close failed (%s)\n", nt_errstr(status));
4245 /* This should fail.. */
4246 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
4247 if (NT_STATUS_IS_OK(status)) {
4248 printf("[10] open of %s succeeded should have been deleted on close !\n", fname);
4252 printf("tenth delete on close test succeeded.\n");
4256 cli_setatr(cli1, fname, 0, 0);
4257 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4259 /* Can we open a read-only file with delete access? */
4261 /* Create a readonly file. */
4262 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
4263 FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE,
4264 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4265 if (!NT_STATUS_IS_OK(status)) {
4266 printf("[11] open of %s failed (%s)\n", fname, nt_errstr(status));
4270 status = cli_close(cli1, fnum1);
4271 if (!NT_STATUS_IS_OK(status)) {
4272 printf("[11] close failed (%s)\n", nt_errstr(status));
4276 /* Now try open for delete access. */
4277 status = cli_ntcreate(cli1, fname, 0,
4278 FILE_READ_ATTRIBUTES|DELETE_ACCESS,
4280 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4281 FILE_OPEN, 0, 0, &fnum1, NULL);
4282 if (!NT_STATUS_IS_OK(status)) {
4283 printf("[11] open of %s failed: %s\n", fname, nt_errstr(status));
4287 cli_close(cli1, fnum1);
4289 printf("eleventh delete on close test succeeded.\n");
4293 * like test 4 but with initial delete on close
4296 cli_setatr(cli1, fname, 0, 0);
4297 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4299 status = cli_ntcreate(cli1, fname, 0,
4300 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4301 FILE_ATTRIBUTE_NORMAL,
4302 FILE_SHARE_READ|FILE_SHARE_WRITE,
4304 FILE_DELETE_ON_CLOSE, 0, &fnum1, NULL);
4305 if (!NT_STATUS_IS_OK(status)) {
4306 printf("[12] open 1 of %s failed (%s)\n", fname, nt_errstr(status));
4310 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4311 FILE_ATTRIBUTE_NORMAL,
4312 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4313 FILE_OPEN, 0, 0, &fnum2, NULL);
4314 if (!NT_STATUS_IS_OK(status)) {
4315 printf("[12] open 2 of %s failed(%s).\n", fname, nt_errstr(status));
4319 status = cli_close(cli1, fnum2);
4320 if (!NT_STATUS_IS_OK(status)) {
4321 printf("[12] close 1 failed (%s)\n", nt_errstr(status));
4325 status = cli_nt_delete_on_close(cli1, fnum1, true);
4326 if (!NT_STATUS_IS_OK(status)) {
4327 printf("[12] setting delete_on_close failed (%s)\n", nt_errstr(status));
4331 /* This should fail - no more opens once delete on close set. */
4332 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4333 FILE_ATTRIBUTE_NORMAL,
4334 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4335 FILE_OPEN, 0, 0, &fnum2, NULL);
4336 if (NT_STATUS_IS_OK(status)) {
4337 printf("[12] open 3 of %s succeeded - should fail).\n", fname);
4341 status = cli_nt_delete_on_close(cli1, fnum1, false);
4342 if (!NT_STATUS_IS_OK(status)) {
4343 printf("[12] unsetting delete_on_close failed (%s)\n", nt_errstr(status));
4347 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4348 FILE_ATTRIBUTE_NORMAL,
4349 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4350 FILE_OPEN, 0, 0, &fnum2, NULL);
4351 if (!NT_STATUS_IS_OK(status)) {
4352 printf("[12] open 4 of %s failed (%s)\n", fname, nt_errstr(status));
4356 status = cli_close(cli1, fnum2);
4357 if (!NT_STATUS_IS_OK(status)) {
4358 printf("[12] close 2 failed (%s)\n", nt_errstr(status));
4362 status = cli_close(cli1, fnum1);
4363 if (!NT_STATUS_IS_OK(status)) {
4364 printf("[12] close 3 failed (%s)\n", nt_errstr(status));
4369 * setting delete on close on the handle does
4370 * not unset the initial delete on close...
4372 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4373 FILE_ATTRIBUTE_NORMAL,
4374 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4375 FILE_OPEN, 0, 0, &fnum2, NULL);
4376 if (NT_STATUS_IS_OK(status)) {
4377 printf("[12] open 5 of %s succeeded - should fail).\n", fname);
4379 } else if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
4380 printf("ntcreate returned %s, expected "
4381 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
4386 printf("twelfth delete on close test succeeded.\n");
4389 printf("finished delete test\n");
4394 /* FIXME: This will crash if we aborted before cli2 got
4395 * intialized, because these functions don't handle
4396 * uninitialized connections. */
4398 if (fnum1 != (uint16_t)-1) cli_close(cli1, fnum1);
4399 if (fnum2 != (uint16_t)-1) cli_close(cli1, fnum2);
4400 cli_setatr(cli1, fname, 0, 0);
4401 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4403 if (cli1 && !torture_close_connection(cli1)) {
4406 if (cli2 && !torture_close_connection(cli2)) {
4414 Test wildcard delete.
4416 static bool run_wild_deletetest(int dummy)
4418 struct cli_state *cli = NULL;
4419 const char *dname = "\\WTEST";
4420 const char *fname = "\\WTEST\\A";
4421 const char *wunlink_name = "\\WTEST\\*";
4422 uint16_t fnum1 = (uint16_t)-1;
4423 bool correct = false;
4426 printf("starting wildcard delete test\n");
4428 if (!torture_open_connection(&cli, 0)) {
4432 smbXcli_conn_set_sockopt(cli->conn, sockops);
4434 cli_unlink(cli, fname, 0);
4435 cli_rmdir(cli, dname);
4436 status = cli_mkdir(cli, dname);
4437 if (!NT_STATUS_IS_OK(status)) {
4438 printf("mkdir of %s failed %s!\n", dname, nt_errstr(status));
4441 status = cli_openx(cli, fname, O_CREAT|O_RDONLY, DENY_NONE, &fnum1);
4442 if (!NT_STATUS_IS_OK(status)) {
4443 printf("open of %s failed %s!\n", fname, nt_errstr(status));
4446 status = cli_close(cli, fnum1);
4450 * Note the unlink attribute-type of zero. This should
4451 * map into FILE_ATTRIBUTE_NORMAL at the server even
4452 * on a wildcard delete.
4455 status = cli_unlink(cli, wunlink_name, 0);
4456 if (!NT_STATUS_IS_OK(status)) {
4457 printf("unlink of %s failed %s!\n",
4458 wunlink_name, nt_errstr(status));
4462 printf("finished wildcard delete test\n");
4468 if (fnum1 != (uint16_t)-1) cli_close(cli, fnum1);
4469 cli_unlink(cli, fname, 0);
4470 cli_rmdir(cli, dname);
4472 if (cli && !torture_close_connection(cli)) {
4478 static bool run_deletetest_ln(int dummy)
4480 struct cli_state *cli;
4481 const char *fname = "\\delete1";
4482 const char *fname_ln = "\\delete1_ln";
4486 bool correct = true;
4489 printf("starting deletetest-ln\n");
4491 if (!torture_open_connection(&cli, 0)) {
4495 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4496 cli_unlink(cli, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4498 smbXcli_conn_set_sockopt(cli->conn, sockops);
4500 /* Create the file. */
4501 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
4502 if (!NT_STATUS_IS_OK(status)) {
4503 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4507 status = cli_close(cli, fnum);
4508 if (!NT_STATUS_IS_OK(status)) {
4509 printf("close1 failed (%s)\n", nt_errstr(status));
4513 /* Now create a hardlink. */
4514 status = cli_nt_hardlink(cli, fname, fname_ln);
4515 if (!NT_STATUS_IS_OK(status)) {
4516 printf("nt hardlink failed (%s)\n", nt_errstr(status));
4520 /* Open the original file. */
4521 status = cli_ntcreate(cli, fname, 0, FILE_READ_DATA,
4522 FILE_ATTRIBUTE_NORMAL,
4523 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4524 FILE_OPEN_IF, 0, 0, &fnum, NULL);
4525 if (!NT_STATUS_IS_OK(status)) {
4526 printf("ntcreate of %s failed (%s)\n", fname, nt_errstr(status));
4530 /* Unlink the hard link path. */
4531 status = cli_ntcreate(cli, fname_ln, 0, DELETE_ACCESS,
4532 FILE_ATTRIBUTE_NORMAL,
4533 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4534 FILE_OPEN_IF, 0, 0, &fnum1, NULL);
4535 if (!NT_STATUS_IS_OK(status)) {
4536 printf("ntcreate of %s failed (%s)\n", fname_ln, nt_errstr(status));
4539 status = cli_nt_delete_on_close(cli, fnum1, true);
4540 if (!NT_STATUS_IS_OK(status)) {
4541 d_printf("(%s) failed to set delete_on_close %s: %s\n",
4542 __location__, fname_ln, nt_errstr(status));
4546 status = cli_close(cli, fnum1);
4547 if (!NT_STATUS_IS_OK(status)) {
4548 printf("close %s failed (%s)\n",
4549 fname_ln, nt_errstr(status));
4553 status = cli_close(cli, fnum);
4554 if (!NT_STATUS_IS_OK(status)) {
4555 printf("close %s failed (%s)\n",
4556 fname, nt_errstr(status));
4560 /* Ensure the original file is still there. */
4561 status = cli_getatr(cli, fname, NULL, NULL, &t);
4562 if (!NT_STATUS_IS_OK(status)) {
4563 printf("%s getatr on file %s failed (%s)\n",
4570 /* Ensure the link path is gone. */
4571 status = cli_getatr(cli, fname_ln, NULL, NULL, &t);
4572 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
4573 printf("%s, getatr for file %s returned wrong error code %s "
4574 "- should have been deleted\n",
4576 fname_ln, nt_errstr(status));
4580 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4581 cli_unlink(cli, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4583 if (!torture_close_connection(cli)) {
4587 printf("finished deletetest-ln\n");
4593 print out server properties
4595 static bool run_properties(int dummy)
4597 struct cli_state *cli;
4598 bool correct = True;
4600 printf("starting properties test\n");
4604 if (!torture_open_connection(&cli, 0)) {
4608 smbXcli_conn_set_sockopt(cli->conn, sockops);
4610 d_printf("Capabilities 0x%08x\n", smb1cli_conn_capabilities(cli->conn));
4612 if (!torture_close_connection(cli)) {
4621 /* FIRST_DESIRED_ACCESS 0xf019f */
4622 #define FIRST_DESIRED_ACCESS FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\
4623 FILE_READ_EA| /* 0xf */ \
4624 FILE_WRITE_EA|FILE_READ_ATTRIBUTES| /* 0x90 */ \
4625 FILE_WRITE_ATTRIBUTES| /* 0x100 */ \
4626 DELETE_ACCESS|READ_CONTROL_ACCESS|\
4627 WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS /* 0xf0000 */
4628 /* SECOND_DESIRED_ACCESS 0xe0080 */
4629 #define SECOND_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
4630 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
4631 WRITE_OWNER_ACCESS /* 0xe0000 */
4634 #define THIRD_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
4635 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
4637 WRITE_OWNER_ACCESS /* */
4641 Test ntcreate calls made by xcopy
4643 static bool run_xcopy(int dummy)
4645 static struct cli_state *cli1;
4646 const char *fname = "\\test.txt";
4647 bool correct = True;
4648 uint16_t fnum1, fnum2;
4651 printf("starting xcopy test\n");
4653 if (!torture_open_connection(&cli1, 0)) {
4657 status = cli_ntcreate(cli1, fname, 0, FIRST_DESIRED_ACCESS,
4658 FILE_ATTRIBUTE_ARCHIVE, FILE_SHARE_NONE,
4659 FILE_OVERWRITE_IF, 0x4044, 0, &fnum1, NULL);
4660 if (!NT_STATUS_IS_OK(status)) {
4661 printf("First open failed - %s\n", nt_errstr(status));
4665 status = cli_ntcreate(cli1, fname, 0, SECOND_DESIRED_ACCESS, 0,
4666 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4667 FILE_OPEN, 0x200000, 0, &fnum2, NULL);
4668 if (!NT_STATUS_IS_OK(status)) {
4669 printf("second open failed - %s\n", nt_errstr(status));
4673 if (!torture_close_connection(cli1)) {
4681 Test rename on files open with share delete and no share delete.
4683 static bool run_rename(int dummy)
4685 static struct cli_state *cli1;
4686 const char *fname = "\\test.txt";
4687 const char *fname1 = "\\test1.txt";
4688 bool correct = True;
4693 printf("starting rename test\n");
4695 if (!torture_open_connection(&cli1, 0)) {
4699 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4700 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4702 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4703 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
4704 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4705 if (!NT_STATUS_IS_OK(status)) {
4706 printf("First open failed - %s\n", nt_errstr(status));
4710 status = cli_rename(cli1, fname, fname1);
4711 if (!NT_STATUS_IS_OK(status)) {
4712 printf("First rename failed (SHARE_READ) (this is correct) - %s\n", nt_errstr(status));
4714 printf("First rename succeeded (SHARE_READ) - this should have failed !\n");
4718 status = cli_close(cli1, fnum1);
4719 if (!NT_STATUS_IS_OK(status)) {
4720 printf("close - 1 failed (%s)\n", nt_errstr(status));
4724 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4725 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4726 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4728 FILE_SHARE_DELETE|FILE_SHARE_NONE,
4730 FILE_SHARE_DELETE|FILE_SHARE_READ,
4732 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4733 if (!NT_STATUS_IS_OK(status)) {
4734 printf("Second open failed - %s\n", nt_errstr(status));
4738 status = cli_rename(cli1, fname, fname1);
4739 if (!NT_STATUS_IS_OK(status)) {
4740 printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", nt_errstr(status));
4743 printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n");
4746 status = cli_close(cli1, fnum1);
4747 if (!NT_STATUS_IS_OK(status)) {
4748 printf("close - 2 failed (%s)\n", nt_errstr(status));
4752 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4753 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4755 status = cli_ntcreate(cli1, fname, 0, READ_CONTROL_ACCESS,
4756 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
4757 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4758 if (!NT_STATUS_IS_OK(status)) {
4759 printf("Third open failed - %s\n", nt_errstr(status));
4768 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
4769 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum2, NULL))) {
4770 printf("Fourth open failed - %s\n", cli_errstr(cli1));
4773 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum2, true))) {
4774 printf("[8] setting delete_on_close on file failed !\n");
4778 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
4779 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
4785 status = cli_rename(cli1, fname, fname1);
4786 if (!NT_STATUS_IS_OK(status)) {
4787 printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", nt_errstr(status));
4790 printf("Third rename succeeded (SHARE_NONE)\n");
4793 status = cli_close(cli1, fnum1);
4794 if (!NT_STATUS_IS_OK(status)) {
4795 printf("close - 3 failed (%s)\n", nt_errstr(status));
4799 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4800 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4804 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4805 FILE_ATTRIBUTE_NORMAL,
4806 FILE_SHARE_READ | FILE_SHARE_WRITE,
4807 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4808 if (!NT_STATUS_IS_OK(status)) {
4809 printf("Fourth open failed - %s\n", nt_errstr(status));
4813 status = cli_rename(cli1, fname, fname1);
4814 if (!NT_STATUS_IS_OK(status)) {
4815 printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", nt_errstr(status));
4817 printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n");
4821 status = cli_close(cli1, fnum1);
4822 if (!NT_STATUS_IS_OK(status)) {
4823 printf("close - 4 failed (%s)\n", nt_errstr(status));
4827 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4828 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4832 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4833 FILE_ATTRIBUTE_NORMAL,
4834 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
4835 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4836 if (!NT_STATUS_IS_OK(status)) {
4837 printf("Fifth open failed - %s\n", nt_errstr(status));
4841 status = cli_rename(cli1, fname, fname1);
4842 if (!NT_STATUS_IS_OK(status)) {
4843 printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n", nt_errstr(status));
4846 printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", nt_errstr(status));
4850 * Now check if the first name still exists ...
4853 /* if (!NT_STATUS_OP(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4854 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
4855 FILE_OVERWRITE_IF, 0, 0, &fnum2, NULL))) {
4856 printf("Opening original file after rename of open file fails: %s\n",
4860 printf("Opening original file after rename of open file works ...\n");
4861 (void)cli_close(cli1, fnum2);
4865 status = cli_close(cli1, fnum1);
4866 if (!NT_STATUS_IS_OK(status)) {
4867 printf("close - 5 failed (%s)\n", nt_errstr(status));
4871 /* Check that the renamed file has FILE_ATTRIBUTE_ARCHIVE. */
4872 status = cli_getatr(cli1, fname1, &attr, NULL, NULL);
4873 if (!NT_STATUS_IS_OK(status)) {
4874 printf("getatr on file %s failed - %s ! \n",
4875 fname1, nt_errstr(status));
4878 if (attr != FILE_ATTRIBUTE_ARCHIVE) {
4879 printf("Renamed file %s has wrong attr 0x%x "
4880 "(should be 0x%x)\n",
4883 (unsigned int)FILE_ATTRIBUTE_ARCHIVE);
4886 printf("Renamed file %s has archive bit set\n", fname1);
4890 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4891 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4893 if (!torture_close_connection(cli1)) {
4900 static bool run_pipe_number(int dummy)
4902 struct cli_state *cli1;
4903 const char *pipe_name = "\\SPOOLSS";
4908 printf("starting pipenumber test\n");
4909 if (!torture_open_connection(&cli1, 0)) {
4913 smbXcli_conn_set_sockopt(cli1->conn, sockops);
4915 status = cli_ntcreate(cli1, pipe_name, 0, FILE_READ_DATA,
4916 FILE_ATTRIBUTE_NORMAL,
4917 FILE_SHARE_READ|FILE_SHARE_WRITE,
4918 FILE_OPEN_IF, 0, 0, &fnum, NULL);
4919 if (!NT_STATUS_IS_OK(status)) {
4920 printf("Open of pipe %s failed with error (%s)\n", pipe_name, nt_errstr(status));
4924 printf("\r%6d", num_pipes);
4927 printf("pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
4928 torture_close_connection(cli1);
4933 Test open mode returns on read-only files.
4935 static bool run_opentest(int dummy)
4937 static struct cli_state *cli1;
4938 static struct cli_state *cli2;
4939 const char *fname = "\\readonly.file";
4940 uint16_t fnum1, fnum2;
4943 bool correct = True;
4947 printf("starting open test\n");
4949 if (!torture_open_connection(&cli1, 0)) {
4953 cli_setatr(cli1, fname, 0, 0);
4954 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4956 smbXcli_conn_set_sockopt(cli1->conn, sockops);
4958 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
4959 if (!NT_STATUS_IS_OK(status)) {
4960 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4964 status = cli_close(cli1, fnum1);
4965 if (!NT_STATUS_IS_OK(status)) {
4966 printf("close2 failed (%s)\n", nt_errstr(status));
4970 status = cli_setatr(cli1, fname, FILE_ATTRIBUTE_READONLY, 0);
4971 if (!NT_STATUS_IS_OK(status)) {
4972 printf("cli_setatr failed (%s)\n", nt_errstr(status));
4976 status = cli_openx(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1);
4977 if (!NT_STATUS_IS_OK(status)) {
4978 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4982 /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
4983 status = cli_openx(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
4985 if (check_error(__LINE__, status, ERRDOS, ERRnoaccess,
4986 NT_STATUS_ACCESS_DENIED)) {
4987 printf("correct error code ERRDOS/ERRnoaccess returned\n");
4990 printf("finished open test 1\n");
4992 cli_close(cli1, fnum1);
4994 /* Now try not readonly and ensure ERRbadshare is returned. */
4996 cli_setatr(cli1, fname, 0, 0);
4998 status = cli_openx(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1);
4999 if (!NT_STATUS_IS_OK(status)) {
5000 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
5004 /* This will fail - but the error should be ERRshare. */
5005 status = cli_openx(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
5007 if (check_error(__LINE__, status, ERRDOS, ERRbadshare,
5008 NT_STATUS_SHARING_VIOLATION)) {
5009 printf("correct error code ERRDOS/ERRbadshare returned\n");
5012 status = cli_close(cli1, fnum1);
5013 if (!NT_STATUS_IS_OK(status)) {
5014 printf("close2 failed (%s)\n", nt_errstr(status));
5018 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5020 printf("finished open test 2\n");
5022 /* Test truncate open disposition on file opened for read. */
5023 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
5024 if (!NT_STATUS_IS_OK(status)) {
5025 printf("(3) open (1) of %s failed (%s)\n", fname, nt_errstr(status));
5029 /* write 20 bytes. */
5031 memset(buf, '\0', 20);
5033 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, 20, NULL);
5034 if (!NT_STATUS_IS_OK(status)) {
5035 printf("write failed (%s)\n", nt_errstr(status));
5039 status = cli_close(cli1, fnum1);
5040 if (!NT_STATUS_IS_OK(status)) {
5041 printf("(3) close1 failed (%s)\n", nt_errstr(status));
5045 /* Ensure size == 20. */
5046 status = cli_getatr(cli1, fname, NULL, &fsize, NULL);
5047 if (!NT_STATUS_IS_OK(status)) {
5048 printf("(3) getatr failed (%s)\n", nt_errstr(status));
5053 printf("(3) file size != 20\n");
5057 /* Now test if we can truncate a file opened for readonly. */
5058 status = cli_openx(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE, &fnum1);
5059 if (!NT_STATUS_IS_OK(status)) {
5060 printf("(3) open (2) of %s failed (%s)\n", fname, nt_errstr(status));
5064 status = cli_close(cli1, fnum1);
5065 if (!NT_STATUS_IS_OK(status)) {
5066 printf("close2 failed (%s)\n", nt_errstr(status));
5070 /* Ensure size == 0. */
5071 status = cli_getatr(cli1, fname, NULL, &fsize, NULL);
5072 if (!NT_STATUS_IS_OK(status)) {
5073 printf("(3) getatr failed (%s)\n", nt_errstr(status));
5078 printf("(3) file size != 0\n");
5081 printf("finished open test 3\n");
5083 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5085 printf("Do ctemp tests\n");
5086 status = cli_ctemp(cli1, talloc_tos(), "\\", &fnum1, &tmp_path);
5087 if (!NT_STATUS_IS_OK(status)) {
5088 printf("ctemp failed (%s)\n", nt_errstr(status));
5092 printf("ctemp gave path %s\n", tmp_path);
5093 status = cli_close(cli1, fnum1);
5094 if (!NT_STATUS_IS_OK(status)) {
5095 printf("close of temp failed (%s)\n", nt_errstr(status));
5098 status = cli_unlink(cli1, tmp_path, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5099 if (!NT_STATUS_IS_OK(status)) {
5100 printf("unlink of temp failed (%s)\n", nt_errstr(status));
5103 /* Test the non-io opens... */
5105 if (!torture_open_connection(&cli2, 1)) {
5109 cli_setatr(cli2, fname, 0, 0);
5110 cli_unlink(cli2, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5112 smbXcli_conn_set_sockopt(cli2->conn, sockops);
5114 printf("TEST #1 testing 2 non-io opens (no delete)\n");
5115 status = cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES,
5116 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5117 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5118 if (!NT_STATUS_IS_OK(status)) {
5119 printf("TEST #1 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5123 status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
5124 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5125 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
5126 if (!NT_STATUS_IS_OK(status)) {
5127 printf("TEST #1 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5131 status = cli_close(cli1, fnum1);
5132 if (!NT_STATUS_IS_OK(status)) {
5133 printf("TEST #1 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5137 status = cli_close(cli2, fnum2);
5138 if (!NT_STATUS_IS_OK(status)) {
5139 printf("TEST #1 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5143 printf("non-io open test #1 passed.\n");
5145 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5147 printf("TEST #2 testing 2 non-io opens (first with delete)\n");
5149 status = cli_ntcreate(cli1, fname, 0,
5150 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5151 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5152 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5153 if (!NT_STATUS_IS_OK(status)) {
5154 printf("TEST #2 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5158 status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
5159 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5160 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
5161 if (!NT_STATUS_IS_OK(status)) {
5162 printf("TEST #2 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5166 status = cli_close(cli1, fnum1);
5167 if (!NT_STATUS_IS_OK(status)) {
5168 printf("TEST #2 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5172 status = cli_close(cli2, fnum2);
5173 if (!NT_STATUS_IS_OK(status)) {
5174 printf("TEST #2 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5178 printf("non-io open test #2 passed.\n");
5180 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5182 printf("TEST #3 testing 2 non-io opens (second with delete)\n");
5184 status = cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES,
5185 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5186 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5187 if (!NT_STATUS_IS_OK(status)) {
5188 printf("TEST #3 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5192 status = cli_ntcreate(cli2, fname, 0,
5193 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5194 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5195 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
5196 if (!NT_STATUS_IS_OK(status)) {
5197 printf("TEST #3 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5201 status = cli_close(cli1, fnum1);
5202 if (!NT_STATUS_IS_OK(status)) {
5203 printf("TEST #3 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5207 status = cli_close(cli2, fnum2);
5208 if (!NT_STATUS_IS_OK(status)) {
5209 printf("TEST #3 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5213 printf("non-io open test #3 passed.\n");
5215 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5217 printf("TEST #4 testing 2 non-io opens (both with delete)\n");
5219 status = cli_ntcreate(cli1, fname, 0,
5220 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5221 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5222 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5223 if (!NT_STATUS_IS_OK(status)) {
5224 printf("TEST #4 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5228 status = cli_ntcreate(cli2, fname, 0,
5229 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5230 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5231 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
5232 if (NT_STATUS_IS_OK(status)) {
5233 printf("TEST #4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, nt_errstr(status));
5237 printf("TEST #4 open 2 of %s gave %s (correct error should be %s)\n", fname, nt_errstr(status), "sharing violation");
5239 status = cli_close(cli1, fnum1);
5240 if (!NT_STATUS_IS_OK(status)) {
5241 printf("TEST #4 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5245 printf("non-io open test #4 passed.\n");
5247 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5249 printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
5251 status = cli_ntcreate(cli1, fname, 0,
5252 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5253 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE,
5254 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5255 if (!NT_STATUS_IS_OK(status)) {
5256 printf("TEST #5 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5260 status = cli_ntcreate(cli2, fname, 0,
5261 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5262 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE,
5263 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
5264 if (!NT_STATUS_IS_OK(status)) {
5265 printf("TEST #5 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5269 status = cli_close(cli1, fnum1);
5270 if (!NT_STATUS_IS_OK(status)) {
5271 printf("TEST #5 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5275 status = cli_close(cli2, fnum2);
5276 if (!NT_STATUS_IS_OK(status)) {
5277 printf("TEST #5 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5281 printf("non-io open test #5 passed.\n");
5283 printf("TEST #6 testing 1 non-io open, one io open\n");
5285 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5287 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA,
5288 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5289 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5290 if (!NT_STATUS_IS_OK(status)) {
5291 printf("TEST #6 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5295 status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
5296 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
5297 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
5298 if (!NT_STATUS_IS_OK(status)) {
5299 printf("TEST #6 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5303 status = cli_close(cli1, fnum1);
5304 if (!NT_STATUS_IS_OK(status)) {
5305 printf("TEST #6 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5309 status = cli_close(cli2, fnum2);
5310 if (!NT_STATUS_IS_OK(status)) {
5311 printf("TEST #6 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5315 printf("non-io open test #6 passed.\n");
5317 printf("TEST #7 testing 1 non-io open, one io open with delete\n");
5319 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5321 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA,
5322 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5323 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5324 if (!NT_STATUS_IS_OK(status)) {
5325 printf("TEST #7 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5329 status = cli_ntcreate(cli2, fname, 0,
5330 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5331 FILE_ATTRIBUTE_NORMAL,
5332 FILE_SHARE_READ|FILE_SHARE_DELETE,
5333 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
5334 if (NT_STATUS_IS_OK(status)) {
5335 printf("TEST #7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, nt_errstr(status));
5339 printf("TEST #7 open 2 of %s gave %s (correct error should be %s)\n", fname, nt_errstr(status), "sharing violation");
5341 status = cli_close(cli1, fnum1);
5342 if (!NT_STATUS_IS_OK(status)) {
5343 printf("TEST #7 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5347 printf("non-io open test #7 passed.\n");
5349 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5351 printf("TEST #8 testing open without WRITE_ATTRIBUTES, updating close write time.\n");
5352 status = cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA, FILE_ATTRIBUTE_NORMAL,
5353 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5354 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5355 if (!NT_STATUS_IS_OK(status)) {
5356 printf("TEST #8 open of %s failed (%s)\n", fname, nt_errstr(status));
5361 /* Write to ensure we have to update the file time. */
5362 status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
5364 if (!NT_STATUS_IS_OK(status)) {
5365 printf("TEST #8 cli_write failed: %s\n", nt_errstr(status));
5370 status = cli_close(cli1, fnum1);
5371 if (!NT_STATUS_IS_OK(status)) {
5372 printf("TEST #8 close of %s failed (%s)\n", fname, nt_errstr(status));
5378 if (!torture_close_connection(cli1)) {
5381 if (!torture_close_connection(cli2)) {
5388 NTSTATUS torture_setup_unix_extensions(struct cli_state *cli)
5390 uint16_t major, minor;
5391 uint32_t caplow, caphigh;
5394 if (!SERVER_HAS_UNIX_CIFS(cli)) {
5395 printf("Server doesn't support UNIX CIFS extensions.\n");
5396 return NT_STATUS_NOT_SUPPORTED;
5399 status = cli_unix_extensions_version(cli, &major, &minor, &caplow,
5401 if (!NT_STATUS_IS_OK(status)) {
5402 printf("Server didn't return UNIX CIFS extensions: %s\n",
5407 status = cli_set_unix_extensions_capabilities(cli, major, minor,
5409 if (!NT_STATUS_IS_OK(status)) {
5410 printf("Server doesn't support setting UNIX CIFS extensions: "
5411 "%s.\n", nt_errstr(status));
5415 return NT_STATUS_OK;
5419 Test POSIX open /mkdir calls.
5421 static bool run_simple_posix_open_test(int dummy)
5423 static struct cli_state *cli1;
5424 const char *fname = "posix:file";
5425 const char *hname = "posix:hlink";
5426 const char *sname = "posix:symlink";
5427 const char *dname = "posix:dir";
5430 uint16_t fnum1 = (uint16_t)-1;
5431 SMB_STRUCT_STAT sbuf;
5432 bool correct = false;
5435 const char *fname_windows = "windows_file";
5436 uint16_t fnum2 = (uint16_t)-1;
5438 printf("Starting simple POSIX open test\n");
5440 if (!torture_open_connection(&cli1, 0)) {
5444 smbXcli_conn_set_sockopt(cli1->conn, sockops);
5446 status = torture_setup_unix_extensions(cli1);
5447 if (!NT_STATUS_IS_OK(status)) {
5451 cli_setatr(cli1, fname, 0, 0);
5452 cli_posix_unlink(cli1, fname);
5453 cli_setatr(cli1, dname, 0, 0);
5454 cli_posix_rmdir(cli1, dname);
5455 cli_setatr(cli1, hname, 0, 0);
5456 cli_posix_unlink(cli1, hname);
5457 cli_setatr(cli1, sname, 0, 0);
5458 cli_posix_unlink(cli1, sname);
5459 cli_setatr(cli1, fname_windows, 0, 0);
5460 cli_posix_unlink(cli1, fname_windows);
5462 /* Create a directory. */
5463 status = cli_posix_mkdir(cli1, dname, 0777);
5464 if (!NT_STATUS_IS_OK(status)) {
5465 printf("POSIX mkdir of %s failed (%s)\n", dname, nt_errstr(status));
5469 status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL,
5471 if (!NT_STATUS_IS_OK(status)) {
5472 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5476 /* Test ftruncate - set file size. */
5477 status = cli_ftruncate(cli1, fnum1, 1000);
5478 if (!NT_STATUS_IS_OK(status)) {
5479 printf("ftruncate failed (%s)\n", nt_errstr(status));
5483 /* Ensure st_size == 1000 */
5484 status = cli_posix_stat(cli1, fname, &sbuf);
5485 if (!NT_STATUS_IS_OK(status)) {
5486 printf("stat failed (%s)\n", nt_errstr(status));
5490 if (sbuf.st_ex_size != 1000) {
5491 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
5495 /* Ensure st_mode == 0600 */
5496 if ((sbuf.st_ex_mode & 07777) != 0600) {
5497 printf("posix_open - bad permissions 0%o != 0600\n",
5498 (unsigned int)(sbuf.st_ex_mode & 07777));
5502 /* Test ftruncate - set file size back to zero. */
5503 status = cli_ftruncate(cli1, fnum1, 0);
5504 if (!NT_STATUS_IS_OK(status)) {
5505 printf("ftruncate failed (%s)\n", nt_errstr(status));
5509 status = cli_close(cli1, fnum1);
5510 if (!NT_STATUS_IS_OK(status)) {
5511 printf("close failed (%s)\n", nt_errstr(status));
5515 /* Now open the file again for read only. */
5516 status = cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1);
5517 if (!NT_STATUS_IS_OK(status)) {
5518 printf("POSIX open of %s failed (%s)\n", fname, nt_errstr(status));
5522 /* Now unlink while open. */
5523 status = cli_posix_unlink(cli1, fname);
5524 if (!NT_STATUS_IS_OK(status)) {
5525 printf("POSIX unlink of %s failed (%s)\n", fname, nt_errstr(status));
5529 status = cli_close(cli1, fnum1);
5530 if (!NT_STATUS_IS_OK(status)) {
5531 printf("close(2) failed (%s)\n", nt_errstr(status));
5535 /* Ensure the file has gone. */
5536 status = cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1);
5537 if (NT_STATUS_IS_OK(status)) {
5538 printf("POSIX open of %s succeeded, should have been deleted.\n", fname);
5542 /* Create again to test open with O_TRUNC. */
5543 status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1);
5544 if (!NT_STATUS_IS_OK(status)) {
5545 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5549 /* Test ftruncate - set file size. */
5550 status = cli_ftruncate(cli1, fnum1, 1000);
5551 if (!NT_STATUS_IS_OK(status)) {
5552 printf("ftruncate failed (%s)\n", nt_errstr(status));
5556 /* Ensure st_size == 1000 */
5557 status = cli_posix_stat(cli1, fname, &sbuf);
5558 if (!NT_STATUS_IS_OK(status)) {
5559 printf("stat failed (%s)\n", nt_errstr(status));
5563 if (sbuf.st_ex_size != 1000) {
5564 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
5568 status = cli_close(cli1, fnum1);
5569 if (!NT_STATUS_IS_OK(status)) {
5570 printf("close(2) failed (%s)\n", nt_errstr(status));
5574 /* Re-open with O_TRUNC. */
5575 status = cli_posix_open(cli1, fname, O_WRONLY|O_TRUNC, 0600, &fnum1);
5576 if (!NT_STATUS_IS_OK(status)) {
5577 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5581 /* Ensure st_size == 0 */
5582 status = cli_posix_stat(cli1, fname, &sbuf);
5583 if (!NT_STATUS_IS_OK(status)) {
5584 printf("stat failed (%s)\n", nt_errstr(status));
5588 if (sbuf.st_ex_size != 0) {
5589 printf("O_TRUNC - stat size (%u) != 0\n", (unsigned int)sbuf.st_ex_size);
5593 status = cli_close(cli1, fnum1);
5594 if (!NT_STATUS_IS_OK(status)) {
5595 printf("close failed (%s)\n", nt_errstr(status));
5599 status = cli_posix_unlink(cli1, fname);
5600 if (!NT_STATUS_IS_OK(status)) {
5601 printf("POSIX unlink of %s failed (%s)\n", fname, nt_errstr(status));
5605 status = cli_posix_open(cli1, dname, O_RDONLY, 0, &fnum1);
5606 if (!NT_STATUS_IS_OK(status)) {
5607 printf("POSIX open directory O_RDONLY of %s failed (%s)\n",
5608 dname, nt_errstr(status));
5612 cli_close(cli1, fnum1);
5614 /* What happens when we try and POSIX open a directory for write ? */
5615 status = cli_posix_open(cli1, dname, O_RDWR, 0, &fnum1);
5616 if (NT_STATUS_IS_OK(status)) {
5617 printf("POSIX open of directory %s succeeded, should have failed.\n", fname);
5620 if (!check_both_error(__LINE__, status, ERRDOS, EISDIR,
5621 NT_STATUS_FILE_IS_A_DIRECTORY)) {
5626 /* Create the file. */
5627 status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL,
5629 if (!NT_STATUS_IS_OK(status)) {
5630 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5634 /* Write some data into it. */
5635 status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
5637 if (!NT_STATUS_IS_OK(status)) {
5638 printf("cli_write failed: %s\n", nt_errstr(status));
5642 cli_close(cli1, fnum1);
5644 /* Now create a hardlink. */
5645 status = cli_posix_hardlink(cli1, fname, hname);
5646 if (!NT_STATUS_IS_OK(status)) {
5647 printf("POSIX hardlink of %s failed (%s)\n", hname, nt_errstr(status));
5651 /* Now create a symlink. */
5652 status = cli_posix_symlink(cli1, fname, sname);
5653 if (!NT_STATUS_IS_OK(status)) {
5654 printf("POSIX symlink of %s failed (%s)\n", sname, nt_errstr(status));
5658 /* Open the hardlink for read. */
5659 status = cli_posix_open(cli1, hname, O_RDONLY, 0, &fnum1);
5660 if (!NT_STATUS_IS_OK(status)) {
5661 printf("POSIX open of %s failed (%s)\n", hname, nt_errstr(status));
5665 status = cli_read(cli1, fnum1, buf, 0, 10, &nread);
5666 if (!NT_STATUS_IS_OK(status)) {
5667 printf("POSIX read of %s failed (%s)\n", hname,
5670 } else if (nread != 10) {
5671 printf("POSIX read of %s failed. Received %ld, expected %d\n",
5672 hname, (unsigned long)nread, 10);
5676 if (memcmp(buf, "TEST DATA\n", 10)) {
5677 printf("invalid data read from hardlink\n");
5681 /* Do a POSIX lock/unlock. */
5682 status = cli_posix_lock(cli1, fnum1, 0, 100, true, READ_LOCK);
5683 if (!NT_STATUS_IS_OK(status)) {
5684 printf("POSIX lock failed %s\n", nt_errstr(status));
5688 /* Punch a hole in the locked area. */
5689 status = cli_posix_unlock(cli1, fnum1, 10, 80);
5690 if (!NT_STATUS_IS_OK(status)) {
5691 printf("POSIX unlock failed %s\n", nt_errstr(status));
5695 cli_close(cli1, fnum1);
5697 /* Open the symlink for read - this should fail. A POSIX
5698 client should not be doing opens on a symlink. */
5699 status = cli_posix_open(cli1, sname, O_RDONLY, 0, &fnum1);
5700 if (NT_STATUS_IS_OK(status)) {
5701 printf("POSIX open of %s succeeded (should have failed)\n", sname);
5704 if (!check_both_error(__LINE__, status, ERRDOS, ERRbadpath,
5705 NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
5706 printf("POSIX open of %s should have failed "
5707 "with NT_STATUS_OBJECT_PATH_NOT_FOUND, "
5708 "failed with %s instead.\n",
5709 sname, nt_errstr(status));
5714 status = cli_posix_readlink(cli1, sname, namebuf, sizeof(namebuf));
5715 if (!NT_STATUS_IS_OK(status)) {
5716 printf("POSIX readlink on %s failed (%s)\n", sname, nt_errstr(status));
5720 if (strcmp(namebuf, fname) != 0) {
5721 printf("POSIX readlink on %s failed to match name %s (read %s)\n",
5722 sname, fname, namebuf);
5726 status = cli_posix_rmdir(cli1, dname);
5727 if (!NT_STATUS_IS_OK(status)) {
5728 printf("POSIX rmdir failed (%s)\n", nt_errstr(status));
5732 /* Check directory opens with a specific permission. */
5733 status = cli_posix_mkdir(cli1, dname, 0700);
5734 if (!NT_STATUS_IS_OK(status)) {
5735 printf("POSIX mkdir of %s failed (%s)\n", dname, nt_errstr(status));
5739 /* Ensure st_mode == 0700 */
5740 status = cli_posix_stat(cli1, dname, &sbuf);
5741 if (!NT_STATUS_IS_OK(status)) {
5742 printf("stat failed (%s)\n", nt_errstr(status));
5746 if ((sbuf.st_ex_mode & 07777) != 0700) {
5747 printf("posix_mkdir - bad permissions 0%o != 0700\n",
5748 (unsigned int)(sbuf.st_ex_mode & 07777));
5753 * Now create a Windows file, and attempt a POSIX unlink.
5754 * This should fail with a sharing violation but due to:
5756 * [Bug 9571] Unlink after open causes smbd to panic
5758 * ensure we've fixed the lock ordering violation.
5761 status = cli_ntcreate(cli1, fname_windows, 0,
5762 FILE_READ_DATA|FILE_WRITE_DATA, 0,
5763 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5765 0x0, 0x0, &fnum2, NULL);
5766 if (!NT_STATUS_IS_OK(status)) {
5767 printf("Windows create of %s failed (%s)\n", fname_windows,
5772 /* Now try posix_unlink. */
5773 status = cli_posix_unlink(cli1, fname_windows);
5774 if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
5775 printf("POSIX unlink of %s should fail "
5776 "with NT_STATUS_SHARING_VIOLATION "
5777 "got %s instead !\n",
5783 cli_close(cli1, fnum2);
5785 printf("Simple POSIX open test passed\n");
5790 if (fnum1 != (uint16_t)-1) {
5791 cli_close(cli1, fnum1);
5792 fnum1 = (uint16_t)-1;
5795 if (fnum2 != (uint16_t)-1) {
5796 cli_close(cli1, fnum2);
5797 fnum2 = (uint16_t)-1;
5800 cli_setatr(cli1, sname, 0, 0);
5801 cli_posix_unlink(cli1, sname);
5802 cli_setatr(cli1, hname, 0, 0);
5803 cli_posix_unlink(cli1, hname);
5804 cli_setatr(cli1, fname, 0, 0);
5805 cli_posix_unlink(cli1, fname);
5806 cli_setatr(cli1, dname, 0, 0);
5807 cli_posix_rmdir(cli1, dname);
5808 cli_setatr(cli1, fname_windows, 0, 0);
5809 cli_posix_unlink(cli1, fname_windows);
5811 if (!torture_close_connection(cli1)) {
5819 Test POSIX and Windows ACLs are rejected on symlinks.
5821 static bool run_acl_symlink_test(int dummy)
5823 static struct cli_state *cli;
5824 const char *fname = "posix_file";
5825 const char *sname = "posix_symlink";
5826 uint16_t fnum = (uint16_t)-1;
5827 bool correct = false;
5829 char *posix_acl = NULL;
5830 size_t posix_acl_len = 0;
5831 char *posix_acl_sym = NULL;
5832 size_t posix_acl_len_sym = 0;
5833 struct security_descriptor *sd = NULL;
5834 struct security_descriptor *sd_sym = NULL;
5835 TALLOC_CTX *frame = NULL;
5837 frame = talloc_stackframe();
5839 printf("Starting acl symlink test\n");
5841 if (!torture_open_connection(&cli, 0)) {
5846 smbXcli_conn_set_sockopt(cli->conn, sockops);
5848 status = torture_setup_unix_extensions(cli);
5849 if (!NT_STATUS_IS_OK(status)) {
5854 cli_setatr(cli, fname, 0, 0);
5855 cli_posix_unlink(cli, fname);
5856 cli_setatr(cli, sname, 0, 0);
5857 cli_posix_unlink(cli, sname);
5859 status = cli_ntcreate(cli,
5862 READ_CONTROL_ACCESS,
5864 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5871 if (!NT_STATUS_IS_OK(status)) {
5872 printf("cli_ntcreate of %s failed (%s)\n",
5878 /* Get the Windows ACL on the file. */
5879 status = cli_query_secdesc(cli,
5883 if (!NT_STATUS_IS_OK(status)) {
5884 printf("cli_query_secdesc failed (%s)\n",
5889 /* Get the POSIX ACL on the file. */
5890 status = cli_posix_getacl(cli,
5896 if (!NT_STATUS_IS_OK(status)) {
5897 printf("cli_posix_getacl failed (%s)\n",
5902 status = cli_close(cli, fnum);
5903 if (!NT_STATUS_IS_OK(status)) {
5904 printf("close failed (%s)\n", nt_errstr(status));
5907 fnum = (uint16_t)-1;
5909 /* Now create a symlink. */
5910 status = cli_posix_symlink(cli, fname, sname);
5911 if (!NT_STATUS_IS_OK(status)) {
5912 printf("cli_posix_symlink of %s -> %s failed (%s)\n",
5919 /* Open a handle on the symlink. */
5920 status = cli_ntcreate(cli,
5923 READ_CONTROL_ACCESS|SEC_STD_WRITE_DAC,
5925 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5932 if (!NT_STATUS_IS_OK(status)) {
5933 printf("cli_posix_open of %s failed (%s)\n",
5939 /* Get the Windows ACL on the symlink handle. Should fail */
5940 status = cli_query_secdesc(cli,
5945 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
5946 printf("cli_query_secdesc on a symlink gave %s. "
5947 "Should be NT_STATUS_ACCESS_DENIED.\n",
5952 /* Get the POSIX ACL on the symlink pathname. Should fail. */
5953 status = cli_posix_getacl(cli,
5959 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
5960 printf("cli_posix_getacl on a symlink gave %s. "
5961 "Should be NT_STATUS_ACCESS_DENIED.\n",
5966 /* Set the Windows ACL on the symlink handle. Should fail */
5967 status = cli_set_security_descriptor(cli,
5972 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
5973 printf("cli_query_secdesc on a symlink gave %s. "
5974 "Should be NT_STATUS_ACCESS_DENIED.\n",
5979 /* Set the POSIX ACL on the symlink pathname. Should fail. */
5980 status = cli_posix_setacl(cli,
5985 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
5986 printf("cli_posix_getacl on a symlink gave %s. "
5987 "Should be NT_STATUS_ACCESS_DENIED.\n",
5992 printf("ACL symlink test passed\n");
5997 if (fnum != (uint16_t)-1) {
5998 cli_close(cli, fnum);
5999 fnum = (uint16_t)-1;
6002 cli_setatr(cli, sname, 0, 0);
6003 cli_posix_unlink(cli, sname);
6004 cli_setatr(cli, fname, 0, 0);
6005 cli_posix_unlink(cli, fname);
6007 if (!torture_close_connection(cli)) {
6016 Test setting EA's are rejected on symlinks.
6018 static bool run_ea_symlink_test(int dummy)
6020 static struct cli_state *cli;
6021 const char *fname = "posix_file_ea";
6022 const char *sname = "posix_symlink_ea";
6023 const char *ea_name = "testea_name";
6024 const char *ea_value = "testea_value";
6025 uint16_t fnum = (uint16_t)-1;
6026 bool correct = false;
6029 struct ea_struct *eas = NULL;
6030 TALLOC_CTX *frame = NULL;
6032 frame = talloc_stackframe();
6034 printf("Starting EA symlink test\n");
6036 if (!torture_open_connection(&cli, 0)) {
6041 smbXcli_conn_set_sockopt(cli->conn, sockops);
6043 status = torture_setup_unix_extensions(cli);
6044 if (!NT_STATUS_IS_OK(status)) {
6049 cli_setatr(cli, fname, 0, 0);
6050 cli_posix_unlink(cli, fname);
6051 cli_setatr(cli, sname, 0, 0);
6052 cli_posix_unlink(cli, sname);
6054 status = cli_ntcreate(cli,
6057 READ_CONTROL_ACCESS,
6059 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
6066 if (!NT_STATUS_IS_OK(status)) {
6067 printf("cli_ntcreate of %s failed (%s)\n",
6073 status = cli_close(cli, fnum);
6074 if (!NT_STATUS_IS_OK(status)) {
6075 printf("close failed (%s)\n",
6079 fnum = (uint16_t)-1;
6081 /* Set an EA on the path. */
6082 status = cli_set_ea_path(cli,
6086 strlen(ea_value)+1);
6088 if (!NT_STATUS_IS_OK(status)) {
6089 printf("cli_set_ea_path failed (%s)\n",
6094 /* Now create a symlink. */
6095 status = cli_posix_symlink(cli, fname, sname);
6096 if (!NT_STATUS_IS_OK(status)) {
6097 printf("cli_posix_symlink of %s -> %s failed (%s)\n",
6104 /* Get the EA list on the path. Should return value set. */
6105 status = cli_get_ea_list_path(cli,
6111 if (!NT_STATUS_IS_OK(status)) {
6112 printf("cli_get_ea_list_path failed (%s)\n",
6117 /* Ensure the EA we set is there. */
6118 for (i=0; i<num_eas; i++) {
6119 if (strcmp(eas[i].name, ea_name) == 0 &&
6120 eas[i].value.length == strlen(ea_value)+1 &&
6121 memcmp(eas[i].value.data,
6123 eas[i].value.length) == 0) {
6129 printf("Didn't find EA on pathname %s\n",
6137 /* Get the EA list on the symlink. Should return empty list. */
6138 status = cli_get_ea_list_path(cli,
6144 if (!NT_STATUS_IS_OK(status)) {
6145 printf("cli_get_ea_list_path failed (%s)\n",
6151 printf("cli_get_ea_list_path failed (%s)\n",
6156 /* Set an EA on the symlink. Should fail. */
6157 status = cli_set_ea_path(cli,
6161 strlen(ea_value)+1);
6163 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
6164 printf("cli_set_ea_path on a symlink gave %s. "
6165 "Should be NT_STATUS_ACCESS_DENIED.\n",
6170 printf("EA symlink test passed\n");
6175 if (fnum != (uint16_t)-1) {
6176 cli_close(cli, fnum);
6177 fnum = (uint16_t)-1;
6180 cli_setatr(cli, sname, 0, 0);
6181 cli_posix_unlink(cli, sname);
6182 cli_setatr(cli, fname, 0, 0);
6183 cli_posix_unlink(cli, fname);
6185 if (!torture_close_connection(cli)) {
6193 static uint32_t open_attrs_table[] = {
6194 FILE_ATTRIBUTE_NORMAL,
6195 FILE_ATTRIBUTE_ARCHIVE,
6196 FILE_ATTRIBUTE_READONLY,
6197 FILE_ATTRIBUTE_HIDDEN,
6198 FILE_ATTRIBUTE_SYSTEM,
6200 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY,
6201 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN,
6202 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,
6203 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
6204 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
6205 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
6207 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
6208 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
6209 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
6210 FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM,
6213 struct trunc_open_results {
6216 uint32_t trunc_attr;
6217 uint32_t result_attr;
6220 static struct trunc_open_results attr_results[] = {
6221 { 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
6222 { 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
6223 { 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
6224 { 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
6225 { 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
6226 { 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
6227 { 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
6228 { 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
6229 { 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
6230 { 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
6231 { 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
6232 { 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
6233 { 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
6234 { 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
6235 { 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 },
6236 { 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
6237 { 119, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
6238 { 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 },
6239 { 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 },
6240 { 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 },
6241 { 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
6242 { 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
6243 { 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
6244 { 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
6245 { 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
6246 { 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
6249 static bool run_openattrtest(int dummy)
6251 static struct cli_state *cli1;
6252 const char *fname = "\\openattr.file";
6254 bool correct = True;
6256 unsigned int i, j, k, l;
6259 printf("starting open attr test\n");
6261 if (!torture_open_connection(&cli1, 0)) {
6265 smbXcli_conn_set_sockopt(cli1->conn, sockops);
6267 for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32_t); i++) {
6268 cli_setatr(cli1, fname, 0, 0);
6269 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6271 status = cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA,
6272 open_attrs_table[i], FILE_SHARE_NONE,
6273 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
6274 if (!NT_STATUS_IS_OK(status)) {
6275 printf("open %d (1) of %s failed (%s)\n", i, fname, nt_errstr(status));
6279 status = cli_close(cli1, fnum1);
6280 if (!NT_STATUS_IS_OK(status)) {
6281 printf("close %d (1) of %s failed (%s)\n", i, fname, nt_errstr(status));
6285 for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32_t); j++) {
6286 status = cli_ntcreate(cli1, fname, 0,
6287 FILE_READ_DATA|FILE_WRITE_DATA,
6288 open_attrs_table[j],
6289 FILE_SHARE_NONE, FILE_OVERWRITE,
6290 0, 0, &fnum1, NULL);
6291 if (!NT_STATUS_IS_OK(status)) {
6292 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
6293 if (attr_results[l].num == k) {
6294 printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
6295 k, open_attrs_table[i],
6296 open_attrs_table[j],
6297 fname, NT_STATUS_V(status), nt_errstr(status));
6302 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
6303 printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n",
6304 k, open_attrs_table[i], open_attrs_table[j],
6309 printf("[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]);
6315 status = cli_close(cli1, fnum1);
6316 if (!NT_STATUS_IS_OK(status)) {
6317 printf("close %d (2) of %s failed (%s)\n", j, fname, nt_errstr(status));
6321 status = cli_getatr(cli1, fname, &attr, NULL, NULL);
6322 if (!NT_STATUS_IS_OK(status)) {
6323 printf("getatr(2) failed (%s)\n", nt_errstr(status));
6328 printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
6329 k, open_attrs_table[i], open_attrs_table[j], attr );
6332 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
6333 if (attr_results[l].num == k) {
6334 if (attr != attr_results[l].result_attr ||
6335 open_attrs_table[i] != attr_results[l].init_attr ||
6336 open_attrs_table[j] != attr_results[l].trunc_attr) {
6337 printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
6338 open_attrs_table[i],
6339 open_attrs_table[j],
6341 attr_results[l].result_attr);
6351 cli_setatr(cli1, fname, 0, 0);
6352 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6354 printf("open attr test %s.\n", correct ? "passed" : "failed");
6356 if (!torture_close_connection(cli1)) {
6362 static NTSTATUS list_fn(const char *mnt, struct file_info *finfo,
6363 const char *name, void *state)
6365 int *matched = (int *)state;
6366 if (matched != NULL) {
6369 return NT_STATUS_OK;
6373 test directory listing speed
6375 static bool run_dirtest(int dummy)
6378 static struct cli_state *cli;
6380 struct timeval core_start;
6381 bool correct = True;
6384 printf("starting directory test\n");
6386 if (!torture_open_connection(&cli, 0)) {
6390 smbXcli_conn_set_sockopt(cli->conn, sockops);
6393 for (i=0;i<torture_numops;i++) {
6395 slprintf(fname, sizeof(fname), "\\%x", (int)random());
6396 if (!NT_STATUS_IS_OK(cli_openx(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum))) {
6397 fprintf(stderr,"Failed to open %s\n", fname);
6400 cli_close(cli, fnum);
6403 core_start = timeval_current();
6406 cli_list(cli, "a*.*", 0, list_fn, &matched);
6407 printf("Matched %d\n", matched);
6410 cli_list(cli, "b*.*", 0, list_fn, &matched);
6411 printf("Matched %d\n", matched);
6414 cli_list(cli, "xyzabc", 0, list_fn, &matched);
6415 printf("Matched %d\n", matched);
6417 printf("dirtest core %g seconds\n", timeval_elapsed(&core_start));
6420 for (i=0;i<torture_numops;i++) {
6422 slprintf(fname, sizeof(fname), "\\%x", (int)random());
6423 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6426 if (!torture_close_connection(cli)) {
6430 printf("finished dirtest\n");
6435 static NTSTATUS del_fn(const char *mnt, struct file_info *finfo, const char *mask,
6438 struct cli_state *pcli = (struct cli_state *)state;
6440 slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name);
6442 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
6443 return NT_STATUS_OK;
6445 if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
6446 if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname)))
6447 printf("del_fn: failed to rmdir %s\n,", fname );
6449 if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN)))
6450 printf("del_fn: failed to unlink %s\n,", fname );
6452 return NT_STATUS_OK;
6457 sees what IOCTLs are supported
6459 bool torture_ioctl_test(int dummy)
6461 static struct cli_state *cli;
6462 uint16_t device, function;
6464 const char *fname = "\\ioctl.dat";
6468 if (!torture_open_connection(&cli, 0)) {
6472 printf("starting ioctl test\n");
6474 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6476 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
6477 if (!NT_STATUS_IS_OK(status)) {
6478 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
6482 status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob);
6483 printf("ioctl device info: %s\n", nt_errstr(status));
6485 status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob);
6486 printf("ioctl job info: %s\n", nt_errstr(status));
6488 for (device=0;device<0x100;device++) {
6489 printf("ioctl test with device = 0x%x\n", device);
6490 for (function=0;function<0x100;function++) {
6491 uint32_t code = (device<<16) | function;
6493 status = cli_raw_ioctl(cli, fnum, code, &blob);
6495 if (NT_STATUS_IS_OK(status)) {
6496 printf("ioctl 0x%x OK : %d bytes\n", (int)code,
6498 data_blob_free(&blob);
6503 if (!torture_close_connection(cli)) {
6512 tries varients of chkpath
6514 bool torture_chkpath_test(int dummy)
6516 static struct cli_state *cli;
6521 if (!torture_open_connection(&cli, 0)) {
6525 printf("starting chkpath test\n");
6527 /* cleanup from an old run */
6528 cli_rmdir(cli, "\\chkpath.dir\\dir2");
6529 cli_unlink(cli, "\\chkpath.dir\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6530 cli_rmdir(cli, "\\chkpath.dir");
6532 status = cli_mkdir(cli, "\\chkpath.dir");
6533 if (!NT_STATUS_IS_OK(status)) {
6534 printf("mkdir1 failed : %s\n", nt_errstr(status));
6538 status = cli_mkdir(cli, "\\chkpath.dir\\dir2");
6539 if (!NT_STATUS_IS_OK(status)) {
6540 printf("mkdir2 failed : %s\n", nt_errstr(status));
6544 status = cli_openx(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL,
6546 if (!NT_STATUS_IS_OK(status)) {
6547 printf("open1 failed (%s)\n", nt_errstr(status));
6550 cli_close(cli, fnum);
6552 status = cli_chkpath(cli, "\\chkpath.dir");
6553 if (!NT_STATUS_IS_OK(status)) {
6554 printf("chkpath1 failed: %s\n", nt_errstr(status));
6558 status = cli_chkpath(cli, "\\chkpath.dir\\dir2");
6559 if (!NT_STATUS_IS_OK(status)) {
6560 printf("chkpath2 failed: %s\n", nt_errstr(status));
6564 status = cli_chkpath(cli, "\\chkpath.dir\\foo.txt");
6565 if (!NT_STATUS_IS_OK(status)) {
6566 ret = check_error(__LINE__, status, ERRDOS, ERRbadpath,
6567 NT_STATUS_NOT_A_DIRECTORY);
6569 printf("* chkpath on a file should fail\n");
6573 status = cli_chkpath(cli, "\\chkpath.dir\\bar.txt");
6574 if (!NT_STATUS_IS_OK(status)) {
6575 ret = check_error(__LINE__, status, ERRDOS, ERRbadfile,
6576 NT_STATUS_OBJECT_NAME_NOT_FOUND);
6578 printf("* chkpath on a non existent file should fail\n");
6582 status = cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt");
6583 if (!NT_STATUS_IS_OK(status)) {
6584 ret = check_error(__LINE__, status, ERRDOS, ERRbadpath,
6585 NT_STATUS_OBJECT_PATH_NOT_FOUND);
6587 printf("* chkpath on a non existent component should fail\n");
6591 cli_rmdir(cli, "\\chkpath.dir\\dir2");
6592 cli_unlink(cli, "\\chkpath.dir\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6593 cli_rmdir(cli, "\\chkpath.dir");
6595 if (!torture_close_connection(cli)) {
6602 static bool run_eatest(int dummy)
6604 static struct cli_state *cli;
6605 const char *fname = "\\eatest.txt";
6606 bool correct = True;
6610 struct ea_struct *ea_list = NULL;
6611 TALLOC_CTX *mem_ctx = talloc_init("eatest");
6614 printf("starting eatest\n");
6616 if (!torture_open_connection(&cli, 0)) {
6617 talloc_destroy(mem_ctx);
6621 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6623 status = cli_ntcreate(cli, fname, 0,
6624 FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
6625 FILE_SHARE_NONE, FILE_OVERWRITE_IF,
6626 0x4044, 0, &fnum, NULL);
6627 if (!NT_STATUS_IS_OK(status)) {
6628 printf("open failed - %s\n", nt_errstr(status));
6629 talloc_destroy(mem_ctx);
6633 for (i = 0; i < 10; i++) {
6634 fstring ea_name, ea_val;
6636 slprintf(ea_name, sizeof(ea_name), "EA_%d", i);
6637 memset(ea_val, (char)i+1, i+1);
6638 status = cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1);
6639 if (!NT_STATUS_IS_OK(status)) {
6640 printf("ea_set of name %s failed - %s\n", ea_name,
6642 talloc_destroy(mem_ctx);
6647 cli_close(cli, fnum);
6648 for (i = 0; i < 10; i++) {
6649 fstring ea_name, ea_val;
6651 slprintf(ea_name, sizeof(ea_name), "EA_%d", i+10);
6652 memset(ea_val, (char)i+1, i+1);
6653 status = cli_set_ea_path(cli, fname, ea_name, ea_val, i+1);
6654 if (!NT_STATUS_IS_OK(status)) {
6655 printf("ea_set of name %s failed - %s\n", ea_name,
6657 talloc_destroy(mem_ctx);
6662 status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
6663 if (!NT_STATUS_IS_OK(status)) {
6664 printf("ea_get list failed - %s\n", nt_errstr(status));
6668 printf("num_eas = %d\n", (int)num_eas);
6670 if (num_eas != 20) {
6671 printf("Should be 20 EA's stored... failing.\n");
6675 for (i = 0; i < num_eas; i++) {
6676 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
6677 dump_data(0, ea_list[i].value.data,
6678 ea_list[i].value.length);
6681 /* Setting EA's to zero length deletes them. Test this */
6682 printf("Now deleting all EA's - case indepenent....\n");
6685 cli_set_ea_path(cli, fname, "", "", 0);
6687 for (i = 0; i < 20; i++) {
6689 slprintf(ea_name, sizeof(ea_name), "ea_%d", i);
6690 status = cli_set_ea_path(cli, fname, ea_name, "", 0);
6691 if (!NT_STATUS_IS_OK(status)) {
6692 printf("ea_set of name %s failed - %s\n", ea_name,
6694 talloc_destroy(mem_ctx);
6700 status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
6701 if (!NT_STATUS_IS_OK(status)) {
6702 printf("ea_get list failed - %s\n", nt_errstr(status));
6706 printf("num_eas = %d\n", (int)num_eas);
6707 for (i = 0; i < num_eas; i++) {
6708 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
6709 dump_data(0, ea_list[i].value.data,
6710 ea_list[i].value.length);
6714 printf("deleting EA's failed.\n");
6718 /* Try and delete a non existent EA. */
6719 status = cli_set_ea_path(cli, fname, "foo", "", 0);
6720 if (!NT_STATUS_IS_OK(status)) {
6721 printf("deleting non-existent EA 'foo' should succeed. %s\n",
6726 talloc_destroy(mem_ctx);
6727 if (!torture_close_connection(cli)) {
6734 static bool run_dirtest1(int dummy)
6737 static struct cli_state *cli;
6740 bool correct = True;
6742 printf("starting directory test\n");
6744 if (!torture_open_connection(&cli, 0)) {
6748 smbXcli_conn_set_sockopt(cli->conn, sockops);
6750 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
6751 cli_list(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, del_fn, cli);
6752 cli_rmdir(cli, "\\LISTDIR");
6753 cli_mkdir(cli, "\\LISTDIR");
6755 /* Create 1000 files and 1000 directories. */
6756 for (i=0;i<1000;i++) {
6758 slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i);
6759 if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
6760 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF,
6761 0, 0, &fnum, NULL))) {
6762 fprintf(stderr,"Failed to open %s\n", fname);
6765 cli_close(cli, fnum);
6767 for (i=0;i<1000;i++) {
6769 slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i);
6770 if (!NT_STATUS_IS_OK(cli_mkdir(cli, fname))) {
6771 fprintf(stderr,"Failed to open %s\n", fname);
6776 /* Now ensure that doing an old list sees both files and directories. */
6778 cli_list_old(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
6779 printf("num_seen = %d\n", num_seen );
6780 /* We should see 100 files + 1000 directories + . and .. */
6781 if (num_seen != 2002)
6784 /* Ensure if we have the "must have" bits we only see the
6788 cli_list_old(cli, "\\LISTDIR\\*", (FILE_ATTRIBUTE_DIRECTORY<<8)|FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
6789 printf("num_seen = %d\n", num_seen );
6790 if (num_seen != 1002)
6794 cli_list_old(cli, "\\LISTDIR\\*", (FILE_ATTRIBUTE_ARCHIVE<<8)|FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
6795 printf("num_seen = %d\n", num_seen );
6796 if (num_seen != 1000)
6799 /* Delete everything. */
6800 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
6801 cli_list(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, del_fn, cli);
6802 cli_rmdir(cli, "\\LISTDIR");
6805 printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
6806 printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
6807 printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
6810 if (!torture_close_connection(cli)) {
6814 printf("finished dirtest1\n");
6819 static bool run_error_map_extract(int dummy) {
6821 static struct cli_state *c_dos;
6822 static struct cli_state *c_nt;
6834 /* NT-Error connection */
6836 disable_spnego = true;
6837 if (!(c_nt = open_nbt_connection())) {
6838 disable_spnego = false;
6841 disable_spnego = false;
6843 status = smbXcli_negprot(c_nt->conn, c_nt->timeout, PROTOCOL_CORE,
6846 if (!NT_STATUS_IS_OK(status)) {
6847 printf("%s rejected the NT-error negprot (%s)\n", host,
6853 status = cli_session_setup(c_nt, "", "", 0, "", 0, workgroup);
6854 if (!NT_STATUS_IS_OK(status)) {
6855 printf("%s rejected the NT-error initial session setup (%s)\n",host, nt_errstr(status));
6859 /* DOS-Error connection */
6861 disable_spnego = true;
6862 force_dos_errors = true;
6863 if (!(c_dos = open_nbt_connection())) {
6864 disable_spnego = false;
6865 force_dos_errors = false;
6868 disable_spnego = false;
6869 force_dos_errors = false;
6871 status = smbXcli_negprot(c_dos->conn, c_dos->timeout, PROTOCOL_CORE,
6873 if (!NT_STATUS_IS_OK(status)) {
6874 printf("%s rejected the DOS-error negprot (%s)\n", host,
6876 cli_shutdown(c_dos);
6880 status = cli_session_setup(c_dos, "", "", 0, "", 0, workgroup);
6881 if (!NT_STATUS_IS_OK(status)) {
6882 printf("%s rejected the DOS-error initial session setup (%s)\n",
6883 host, nt_errstr(status));
6887 c_nt->map_dos_errors = false;
6888 c_dos->map_dos_errors = false;
6890 for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) {
6891 fstr_sprintf(user, "%X", error);
6893 status = cli_session_setup(c_nt, user,
6894 password, strlen(password),
6895 password, strlen(password),
6897 if (NT_STATUS_IS_OK(status)) {
6898 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
6901 /* Case #1: 32-bit NT errors */
6902 if (!NT_STATUS_IS_DOS(status)) {
6905 printf("/** Dos error on NT connection! (%s) */\n",
6907 nt_status = NT_STATUS(0xc0000000);
6910 status = cli_session_setup(c_dos, user,
6911 password, strlen(password),
6912 password, strlen(password),
6914 if (NT_STATUS_IS_OK(status)) {
6915 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
6918 /* Case #1: 32-bit NT errors */
6919 if (NT_STATUS_IS_DOS(status)) {
6920 printf("/** NT error on DOS connection! (%s) */\n",
6922 errnum = errclass = 0;
6924 errclass = NT_STATUS_DOS_CLASS(status);
6925 errnum = NT_STATUS_DOS_CODE(status);
6928 if (NT_STATUS_V(nt_status) != error) {
6929 printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n",
6930 get_nt_error_c_code(talloc_tos(), NT_STATUS(error)),
6931 get_nt_error_c_code(talloc_tos(), nt_status));
6934 printf("\t{%s,\t%s,\t%s},\n",
6935 smb_dos_err_class(errclass),
6936 smb_dos_err_name(errclass, errnum),
6937 get_nt_error_c_code(talloc_tos(), NT_STATUS(error)));
6942 static bool run_sesssetup_bench(int dummy)
6944 static struct cli_state *c;
6945 const char *fname = "\\file.dat";
6950 if (!torture_open_connection(&c, 0)) {
6954 status = cli_ntcreate(c, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
6955 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
6956 FILE_DELETE_ON_CLOSE, 0, &fnum, NULL);
6957 if (!NT_STATUS_IS_OK(status)) {
6958 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
6962 for (i=0; i<torture_numops; i++) {
6963 status = cli_session_setup(
6965 password, strlen(password),
6966 password, strlen(password),
6968 if (!NT_STATUS_IS_OK(status)) {
6969 d_printf("(%s) cli_session_setup failed: %s\n",
6970 __location__, nt_errstr(status));
6974 d_printf("\r%d ", (int)cli_state_get_uid(c));
6976 status = cli_ulogoff(c);
6977 if (!NT_STATUS_IS_OK(status)) {
6978 d_printf("(%s) cli_ulogoff failed: %s\n",
6979 __location__, nt_errstr(status));
6987 static bool subst_test(const char *str, const char *user, const char *domain,
6988 uid_t uid, gid_t gid, const char *expected)
6993 subst = talloc_sub_specified(talloc_tos(), str, user, NULL, domain, uid, gid);
6995 if (strcmp(subst, expected) != 0) {
6996 printf("sub_specified(%s, %s, %s, %d, %d) returned [%s], expected "
6997 "[%s]\n", str, user, domain, (int)uid, (int)gid, subst,
7006 static void chain1_open_completion(struct tevent_req *req)
7010 status = cli_openx_recv(req, &fnum);
7013 d_printf("cli_openx_recv returned %s: %d\n",
7015 NT_STATUS_IS_OK(status) ? fnum : -1);
7018 static void chain1_write_completion(struct tevent_req *req)
7022 status = cli_write_andx_recv(req, &written);
7025 d_printf("cli_write_andx_recv returned %s: %d\n",
7027 NT_STATUS_IS_OK(status) ? (int)written : -1);
7030 static void chain1_close_completion(struct tevent_req *req)
7033 bool *done = (bool *)tevent_req_callback_data_void(req);
7035 status = cli_close_recv(req);
7040 d_printf("cli_close returned %s\n", nt_errstr(status));
7043 static bool run_chain1(int dummy)
7045 struct cli_state *cli1;
7046 struct tevent_context *evt = samba_tevent_context_init(NULL);
7047 struct tevent_req *reqs[3], *smbreqs[3];
7049 const char *str = "foobar";
7052 printf("starting chain1 test\n");
7053 if (!torture_open_connection(&cli1, 0)) {
7057 smbXcli_conn_set_sockopt(cli1->conn, sockops);
7059 reqs[0] = cli_openx_create(talloc_tos(), evt, cli1, "\\test",
7060 O_CREAT|O_RDWR, 0, &smbreqs[0]);
7061 if (reqs[0] == NULL) return false;
7062 tevent_req_set_callback(reqs[0], chain1_open_completion, NULL);
7065 reqs[1] = cli_write_andx_create(talloc_tos(), evt, cli1, 0, 0,
7066 (const uint8_t *)str, 0, strlen(str)+1,
7067 smbreqs, 1, &smbreqs[1]);
7068 if (reqs[1] == NULL) return false;
7069 tevent_req_set_callback(reqs[1], chain1_write_completion, NULL);
7071 reqs[2] = cli_close_create(talloc_tos(), evt, cli1, 0, &smbreqs[2]);
7072 if (reqs[2] == NULL) return false;
7073 tevent_req_set_callback(reqs[2], chain1_close_completion, &done);
7075 status = smb1cli_req_chain_submit(smbreqs, ARRAY_SIZE(smbreqs));
7076 if (!NT_STATUS_IS_OK(status)) {
7081 tevent_loop_once(evt);
7084 torture_close_connection(cli1);
7088 static void chain2_sesssetup_completion(struct tevent_req *req)
7091 status = cli_session_setup_guest_recv(req);
7092 d_printf("sesssetup returned %s\n", nt_errstr(status));
7095 static void chain2_tcon_completion(struct tevent_req *req)
7097 bool *done = (bool *)tevent_req_callback_data_void(req);
7099 status = cli_tcon_andx_recv(req);
7100 d_printf("tcon_and_x returned %s\n", nt_errstr(status));
7104 static bool run_chain2(int dummy)
7106 struct cli_state *cli1;
7107 struct tevent_context *evt = samba_tevent_context_init(NULL);
7108 struct tevent_req *reqs[2], *smbreqs[2];
7112 printf("starting chain2 test\n");
7113 status = cli_start_connection(&cli1, lp_netbios_name(), host, NULL,
7114 port_to_use, SMB_SIGNING_DEFAULT, 0);
7115 if (!NT_STATUS_IS_OK(status)) {
7119 smbXcli_conn_set_sockopt(cli1->conn, sockops);
7121 reqs[0] = cli_session_setup_guest_create(talloc_tos(), evt, cli1,
7123 if (reqs[0] == NULL) return false;
7124 tevent_req_set_callback(reqs[0], chain2_sesssetup_completion, NULL);
7126 reqs[1] = cli_tcon_andx_create(talloc_tos(), evt, cli1, "IPC$",
7127 "?????", NULL, 0, &smbreqs[1]);
7128 if (reqs[1] == NULL) return false;
7129 tevent_req_set_callback(reqs[1], chain2_tcon_completion, &done);
7131 status = smb1cli_req_chain_submit(smbreqs, ARRAY_SIZE(smbreqs));
7132 if (!NT_STATUS_IS_OK(status)) {
7137 tevent_loop_once(evt);
7140 torture_close_connection(cli1);
7145 struct torture_createdel_state {
7146 struct tevent_context *ev;
7147 struct cli_state *cli;
7150 static void torture_createdel_created(struct tevent_req *subreq);
7151 static void torture_createdel_closed(struct tevent_req *subreq);
7153 static struct tevent_req *torture_createdel_send(TALLOC_CTX *mem_ctx,
7154 struct tevent_context *ev,
7155 struct cli_state *cli,
7158 struct tevent_req *req, *subreq;
7159 struct torture_createdel_state *state;
7161 req = tevent_req_create(mem_ctx, &state,
7162 struct torture_createdel_state);
7169 subreq = cli_ntcreate_send(
7170 state, ev, cli, name, 0,
7171 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
7172 FILE_ATTRIBUTE_NORMAL,
7173 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
7174 FILE_OPEN_IF, FILE_DELETE_ON_CLOSE, 0);
7176 if (tevent_req_nomem(subreq, req)) {
7177 return tevent_req_post(req, ev);
7179 tevent_req_set_callback(subreq, torture_createdel_created, req);
7183 static void torture_createdel_created(struct tevent_req *subreq)
7185 struct tevent_req *req = tevent_req_callback_data(
7186 subreq, struct tevent_req);
7187 struct torture_createdel_state *state = tevent_req_data(
7188 req, struct torture_createdel_state);
7192 status = cli_ntcreate_recv(subreq, &fnum, NULL);
7193 TALLOC_FREE(subreq);
7194 if (tevent_req_nterror(req, status)) {
7195 DEBUG(10, ("cli_ntcreate_recv returned %s\n",
7196 nt_errstr(status)));
7200 subreq = cli_close_send(state, state->ev, state->cli, fnum);
7201 if (tevent_req_nomem(subreq, req)) {
7204 tevent_req_set_callback(subreq, torture_createdel_closed, req);
7207 static void torture_createdel_closed(struct tevent_req *subreq)
7209 struct tevent_req *req = tevent_req_callback_data(
7210 subreq, struct tevent_req);
7213 status = cli_close_recv(subreq);
7214 if (tevent_req_nterror(req, status)) {
7215 DEBUG(10, ("cli_close_recv returned %s\n", nt_errstr(status)));
7218 tevent_req_done(req);
7221 static NTSTATUS torture_createdel_recv(struct tevent_req *req)
7223 return tevent_req_simple_recv_ntstatus(req);
7226 struct torture_createdels_state {
7227 struct tevent_context *ev;
7228 struct cli_state *cli;
7229 const char *base_name;
7233 struct tevent_req **reqs;
7236 static void torture_createdels_done(struct tevent_req *subreq);
7238 static struct tevent_req *torture_createdels_send(TALLOC_CTX *mem_ctx,
7239 struct tevent_context *ev,
7240 struct cli_state *cli,
7241 const char *base_name,
7245 struct tevent_req *req;
7246 struct torture_createdels_state *state;
7249 req = tevent_req_create(mem_ctx, &state,
7250 struct torture_createdels_state);
7256 state->base_name = talloc_strdup(state, base_name);
7257 if (tevent_req_nomem(state->base_name, req)) {
7258 return tevent_req_post(req, ev);
7260 state->num_files = MAX(num_parallel, num_files);
7262 state->received = 0;
7264 state->reqs = talloc_array(state, struct tevent_req *, num_parallel);
7265 if (tevent_req_nomem(state->reqs, req)) {
7266 return tevent_req_post(req, ev);
7269 for (i=0; i<num_parallel; i++) {
7272 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
7274 if (tevent_req_nomem(name, req)) {
7275 return tevent_req_post(req, ev);
7277 state->reqs[i] = torture_createdel_send(
7278 state->reqs, state->ev, state->cli, name);
7279 if (tevent_req_nomem(state->reqs[i], req)) {
7280 return tevent_req_post(req, ev);
7282 name = talloc_move(state->reqs[i], &name);
7283 tevent_req_set_callback(state->reqs[i],
7284 torture_createdels_done, req);
7290 static void torture_createdels_done(struct tevent_req *subreq)
7292 struct tevent_req *req = tevent_req_callback_data(
7293 subreq, struct tevent_req);
7294 struct torture_createdels_state *state = tevent_req_data(
7295 req, struct torture_createdels_state);
7296 size_t num_parallel = talloc_array_length(state->reqs);
7301 status = torture_createdel_recv(subreq);
7302 if (!NT_STATUS_IS_OK(status)){
7303 DEBUG(10, ("torture_createdel_recv returned %s\n",
7304 nt_errstr(status)));
7305 TALLOC_FREE(subreq);
7306 tevent_req_nterror(req, status);
7310 for (i=0; i<num_parallel; i++) {
7311 if (subreq == state->reqs[i]) {
7315 if (i == num_parallel) {
7316 DEBUG(10, ("received something we did not send\n"));
7317 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
7320 TALLOC_FREE(state->reqs[i]);
7322 if (state->sent >= state->num_files) {
7323 tevent_req_done(req);
7327 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
7329 if (tevent_req_nomem(name, req)) {
7332 state->reqs[i] = torture_createdel_send(state->reqs, state->ev,
7334 if (tevent_req_nomem(state->reqs[i], req)) {
7337 name = talloc_move(state->reqs[i], &name);
7338 tevent_req_set_callback(state->reqs[i], torture_createdels_done, req);
7342 static NTSTATUS torture_createdels_recv(struct tevent_req *req)
7344 return tevent_req_simple_recv_ntstatus(req);
7347 struct swallow_notify_state {
7348 struct tevent_context *ev;
7349 struct cli_state *cli;
7351 uint32_t completion_filter;
7353 bool (*fn)(uint32_t action, const char *name, void *priv);
7357 static void swallow_notify_done(struct tevent_req *subreq);
7359 static struct tevent_req *swallow_notify_send(TALLOC_CTX *mem_ctx,
7360 struct tevent_context *ev,
7361 struct cli_state *cli,
7363 uint32_t completion_filter,
7365 bool (*fn)(uint32_t action,
7370 struct tevent_req *req, *subreq;
7371 struct swallow_notify_state *state;
7373 req = tevent_req_create(mem_ctx, &state,
7374 struct swallow_notify_state);
7381 state->completion_filter = completion_filter;
7382 state->recursive = recursive;
7386 subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
7387 0xffff, state->completion_filter,
7389 if (tevent_req_nomem(subreq, req)) {
7390 return tevent_req_post(req, ev);
7392 tevent_req_set_callback(subreq, swallow_notify_done, req);
7396 static void swallow_notify_done(struct tevent_req *subreq)
7398 struct tevent_req *req = tevent_req_callback_data(
7399 subreq, struct tevent_req);
7400 struct swallow_notify_state *state = tevent_req_data(
7401 req, struct swallow_notify_state);
7403 uint32_t i, num_changes;
7404 struct notify_change *changes;
7406 status = cli_notify_recv(subreq, state, &num_changes, &changes);
7407 TALLOC_FREE(subreq);
7408 if (!NT_STATUS_IS_OK(status)) {
7409 DEBUG(10, ("cli_notify_recv returned %s\n",
7410 nt_errstr(status)));
7411 tevent_req_nterror(req, status);
7415 for (i=0; i<num_changes; i++) {
7416 state->fn(changes[i].action, changes[i].name, state->priv);
7418 TALLOC_FREE(changes);
7420 subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
7421 0xffff, state->completion_filter,
7423 if (tevent_req_nomem(subreq, req)) {
7426 tevent_req_set_callback(subreq, swallow_notify_done, req);
7429 static bool print_notifies(uint32_t action, const char *name, void *priv)
7431 if (DEBUGLEVEL > 5) {
7432 d_printf("%d %s\n", (int)action, name);
7437 static void notify_bench_done(struct tevent_req *req)
7439 int *num_finished = (int *)tevent_req_callback_data_void(req);
7443 static bool run_notify_bench(int dummy)
7445 const char *dname = "\\notify-bench";
7446 struct tevent_context *ev;
7449 struct tevent_req *req1;
7450 struct tevent_req *req2 = NULL;
7451 int i, num_unc_names;
7452 int num_finished = 0;
7454 printf("starting notify-bench test\n");
7456 if (use_multishare_conn) {
7458 unc_list = file_lines_load(multishare_conn_fname,
7459 &num_unc_names, 0, NULL);
7460 if (!unc_list || num_unc_names <= 0) {
7461 d_printf("Failed to load unc names list from '%s'\n",
7462 multishare_conn_fname);
7465 TALLOC_FREE(unc_list);
7470 ev = samba_tevent_context_init(talloc_tos());
7472 d_printf("tevent_context_init failed\n");
7476 for (i=0; i<num_unc_names; i++) {
7477 struct cli_state *cli;
7480 base_fname = talloc_asprintf(talloc_tos(), "%s\\file%3.3d.",
7482 if (base_fname == NULL) {
7486 if (!torture_open_connection(&cli, i)) {
7490 status = cli_ntcreate(cli, dname, 0,
7491 MAXIMUM_ALLOWED_ACCESS,
7492 0, FILE_SHARE_READ|FILE_SHARE_WRITE|
7494 FILE_OPEN_IF, FILE_DIRECTORY_FILE, 0,
7497 if (!NT_STATUS_IS_OK(status)) {
7498 d_printf("Could not create %s: %s\n", dname,
7503 req1 = swallow_notify_send(talloc_tos(), ev, cli, dnum,
7504 FILE_NOTIFY_CHANGE_FILE_NAME |
7505 FILE_NOTIFY_CHANGE_DIR_NAME |
7506 FILE_NOTIFY_CHANGE_ATTRIBUTES |
7507 FILE_NOTIFY_CHANGE_LAST_WRITE,
7508 false, print_notifies, NULL);
7510 d_printf("Could not create notify request\n");
7514 req2 = torture_createdels_send(talloc_tos(), ev, cli,
7515 base_fname, 10, torture_numops);
7517 d_printf("Could not create createdels request\n");
7520 TALLOC_FREE(base_fname);
7522 tevent_req_set_callback(req2, notify_bench_done,
7526 while (num_finished < num_unc_names) {
7528 ret = tevent_loop_once(ev);
7530 d_printf("tevent_loop_once failed\n");
7535 if (!tevent_req_poll(req2, ev)) {
7536 d_printf("tevent_req_poll failed\n");
7539 status = torture_createdels_recv(req2);
7540 d_printf("torture_createdels_recv returned %s\n", nt_errstr(status));
7545 static bool run_mangle1(int dummy)
7547 struct cli_state *cli;
7548 const char *fname = "this_is_a_long_fname_to_be_mangled.txt";
7552 time_t change_time, access_time, write_time;
7556 printf("starting mangle1 test\n");
7557 if (!torture_open_connection(&cli, 0)) {
7561 smbXcli_conn_set_sockopt(cli->conn, sockops);
7563 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
7564 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
7566 if (!NT_STATUS_IS_OK(status)) {
7567 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
7570 cli_close(cli, fnum);
7572 status = cli_qpathinfo_alt_name(cli, fname, alt_name);
7573 if (!NT_STATUS_IS_OK(status)) {
7574 d_printf("cli_qpathinfo_alt_name failed: %s\n",
7578 d_printf("alt_name: %s\n", alt_name);
7580 status = cli_openx(cli, alt_name, O_RDONLY, DENY_NONE, &fnum);
7581 if (!NT_STATUS_IS_OK(status)) {
7582 d_printf("cli_openx(%s) failed: %s\n", alt_name,
7586 cli_close(cli, fnum);
7588 status = cli_qpathinfo1(cli, alt_name, &change_time, &access_time,
7589 &write_time, &size, &mode);
7590 if (!NT_STATUS_IS_OK(status)) {
7591 d_printf("cli_qpathinfo1(%s) failed: %s\n", alt_name,
7599 static size_t null_source(uint8_t *buf, size_t n, void *priv)
7601 size_t *to_pull = (size_t *)priv;
7602 size_t thistime = *to_pull;
7604 thistime = MIN(thistime, n);
7605 if (thistime == 0) {
7609 memset(buf, 0, thistime);
7610 *to_pull -= thistime;
7614 static bool run_windows_write(int dummy)
7616 struct cli_state *cli1;
7620 const char *fname = "\\writetest.txt";
7621 struct timeval start_time;
7626 printf("starting windows_write test\n");
7627 if (!torture_open_connection(&cli1, 0)) {
7631 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
7632 if (!NT_STATUS_IS_OK(status)) {
7633 printf("open failed (%s)\n", nt_errstr(status));
7637 smbXcli_conn_set_sockopt(cli1->conn, sockops);
7639 start_time = timeval_current();
7641 for (i=0; i<torture_numops; i++) {
7643 off_t start = i * torture_blocksize;
7644 size_t to_pull = torture_blocksize - 1;
7646 status = cli_writeall(cli1, fnum, 0, &c,
7647 start + torture_blocksize - 1, 1, NULL);
7648 if (!NT_STATUS_IS_OK(status)) {
7649 printf("cli_write failed: %s\n", nt_errstr(status));
7653 status = cli_push(cli1, fnum, 0, i * torture_blocksize, torture_blocksize,
7654 null_source, &to_pull);
7655 if (!NT_STATUS_IS_OK(status)) {
7656 printf("cli_push returned: %s\n", nt_errstr(status));
7661 seconds = timeval_elapsed(&start_time);
7662 kbytes = (double)torture_blocksize * torture_numops;
7665 printf("Wrote %d kbytes in %.2f seconds: %d kb/sec\n", (int)kbytes,
7666 (double)seconds, (int)(kbytes/seconds));
7670 cli_close(cli1, fnum);
7671 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7672 torture_close_connection(cli1);
7676 static size_t calc_expected_return(struct cli_state *cli, size_t len_requested)
7678 size_t max_pdu = 0x1FFFF;
7680 if (cli->server_posix_capabilities & CIFS_UNIX_LARGE_READ_CAP) {
7684 if (smb1cli_conn_signing_is_active(cli->conn)) {
7688 if (smb1cli_conn_encryption_on(cli->conn)) {
7689 max_pdu = CLI_BUFFER_SIZE;
7692 if ((len_requested & 0xFFFF0000) == 0xFFFF0000) {
7693 len_requested &= 0xFFFF;
7696 return MIN(len_requested,
7697 max_pdu - (MIN_SMB_SIZE + VWV(12) + 1 /* padding byte */));
7700 static bool check_read_call(struct cli_state *cli,
7703 size_t len_requested)
7706 struct tevent_req *subreq = NULL;
7707 ssize_t len_read = 0;
7708 size_t len_expected = 0;
7709 struct tevent_context *ev = NULL;
7711 ev = samba_tevent_context_init(talloc_tos());
7716 subreq = cli_read_andx_send(talloc_tos(),
7723 if (!tevent_req_poll_ntstatus(subreq, ev, &status)) {
7727 status = cli_read_andx_recv(subreq, &len_read, &buf);
7728 if (!NT_STATUS_IS_OK(status)) {
7729 d_printf("cli_read_andx_recv failed: %s\n", nt_errstr(status));
7733 TALLOC_FREE(subreq);
7736 len_expected = calc_expected_return(cli, len_requested);
7738 if (len_expected > 0x10000 && len_read == 0x10000) {
7739 /* Windows servers only return a max of 0x10000,
7740 doesn't matter if you set CAP_LARGE_READX in
7741 the client sessionsetupX call or not. */
7742 d_printf("Windows server - returned 0x10000 on a read of 0x%x\n",
7743 (unsigned int)len_requested);
7744 } else if (len_read != len_expected) {
7745 d_printf("read of 0x%x failed: got 0x%x, expected 0x%x\n",
7746 (unsigned int)len_requested,
7747 (unsigned int)len_read,
7748 (unsigned int)len_expected);
7751 d_printf("Correct read reply.\n");
7757 /* Test large readX variants. */
7758 static bool large_readx_tests(struct cli_state *cli,
7762 /* A read of 0xFFFF0001 should *always* return 1 byte. */
7763 if (check_read_call(cli, fnum, buf, 0xFFFF0001) == false) {
7766 /* A read of 0x10000 should return 0x10000 bytes. */
7767 if (check_read_call(cli, fnum, buf, 0x10000) == false) {
7770 /* A read of 0x10000 should return 0x10001 bytes. */
7771 if (check_read_call(cli, fnum, buf, 0x10001) == false) {
7774 /* A read of 0x1FFFF - (MIN_SMB_SIZE + VWV(12) should return
7775 the requested number of bytes. */
7776 if (check_read_call(cli, fnum, buf, 0x1FFFF - (MIN_SMB_SIZE + VWV(12))) == false) {
7779 /* A read of 1MB should return 1MB bytes (on Samba). */
7780 if (check_read_call(cli, fnum, buf, 0x100000) == false) {
7784 if (check_read_call(cli, fnum, buf, 0x20001) == false) {
7787 if (check_read_call(cli, fnum, buf, 0x22000001) == false) {
7790 if (check_read_call(cli, fnum, buf, 0xFFFE0001) == false) {
7796 static bool run_large_readx(int dummy)
7798 uint8_t *buf = NULL;
7799 struct cli_state *cli1 = NULL;
7800 struct cli_state *cli2 = NULL;
7801 bool correct = false;
7802 const char *fname = "\\large_readx.dat";
7804 uint16_t fnum1 = UINT16_MAX;
7805 uint32_t normal_caps = 0;
7806 size_t file_size = 20*1024*1024;
7807 TALLOC_CTX *frame = talloc_stackframe();
7811 enum smb_signing_setting signing_setting;
7812 enum protocol_types protocol;
7816 .signing_setting = SMB_SIGNING_IF_REQUIRED,
7817 .protocol = PROTOCOL_NT1,
7819 .name = "NT1 - SIGNING_REQUIRED",
7820 .signing_setting = SMB_SIGNING_REQUIRED,
7821 .protocol = PROTOCOL_NT1,
7825 printf("starting large_readx test\n");
7827 if (!torture_open_connection(&cli1, 0)) {
7831 normal_caps = smb1cli_conn_capabilities(cli1->conn);
7833 if (!(normal_caps & CAP_LARGE_READX)) {
7834 d_printf("Server doesn't have CAP_LARGE_READX 0x%x\n",
7835 (unsigned int)normal_caps);
7839 /* Create a file of size 4MB. */
7840 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
7841 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
7842 0, 0, &fnum1, NULL);
7844 if (!NT_STATUS_IS_OK(status)) {
7845 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
7849 /* Write file_size bytes. */
7850 buf = talloc_zero_array(frame, uint8_t, file_size);
7855 status = cli_writeall(cli1,
7862 if (!NT_STATUS_IS_OK(status)) {
7863 d_printf("cli_writeall failed: %s\n", nt_errstr(status));
7867 status = cli_close(cli1, fnum1);
7868 if (!NT_STATUS_IS_OK(status)) {
7869 d_printf("cli_close failed: %s\n", nt_errstr(status));
7875 for (i=0; i < ARRAY_SIZE(runs); i++) {
7876 enum smb_signing_setting saved_signing_setting = signing_state;
7877 uint16_t fnum2 = -1;
7880 (runs[i].signing_setting == SMB_SIGNING_REQUIRED))
7882 d_printf("skip[%u] - %s\n", (unsigned)i, runs[i].name);
7886 d_printf("run[%u] - %s\n", (unsigned)i, runs[i].name);
7888 signing_state = runs[i].signing_setting;
7889 cli2 = open_nbt_connection();
7890 signing_state = saved_signing_setting;
7895 status = smbXcli_negprot(cli2->conn,
7899 if (!NT_STATUS_IS_OK(status)) {
7903 status = cli_session_setup(cli2,
7910 if (!NT_STATUS_IS_OK(status)) {
7914 status = cli_tree_connect(cli2,
7918 strlen(password)+1);
7919 if (!NT_STATUS_IS_OK(status)) {
7923 cli_set_timeout(cli2, 120000); /* set a really long timeout (2 minutes) */
7925 normal_caps = smb1cli_conn_capabilities(cli2->conn);
7927 if (!(normal_caps & CAP_LARGE_READX)) {
7928 d_printf("Server doesn't have CAP_LARGE_READX 0x%x\n",
7929 (unsigned int)normal_caps);
7934 if (force_cli_encryption(cli2, share) == false) {
7937 } else if (SERVER_HAS_UNIX_CIFS(cli2)) {
7938 uint16_t major, minor;
7939 uint32_t caplow, caphigh;
7941 status = cli_unix_extensions_version(cli2,
7944 if (!NT_STATUS_IS_OK(status)) {
7949 status = cli_ntcreate(cli2, fname, 0, FILE_READ_DATA,
7950 FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN,
7951 0, 0, &fnum2, NULL);
7952 if (!NT_STATUS_IS_OK(status)) {
7953 d_printf("Second open %s failed: %s\n", fname, nt_errstr(status));
7957 /* All reads must return less than file_size bytes. */
7958 if (!large_readx_tests(cli2, fnum2, buf)) {
7962 status = cli_close(cli2, fnum2);
7963 if (!NT_STATUS_IS_OK(status)) {
7964 d_printf("cli_close failed: %s\n", nt_errstr(status));
7969 if (!torture_close_connection(cli2)) {
7976 printf("Success on large_readx test\n");
7981 if (!torture_close_connection(cli2)) {
7987 if (fnum1 != UINT16_MAX) {
7988 status = cli_close(cli1, fnum1);
7989 if (!NT_STATUS_IS_OK(status)) {
7990 d_printf("cli_close failed: %s\n", nt_errstr(status));
7995 status = cli_unlink(cli1, fname,
7996 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7997 if (!NT_STATUS_IS_OK(status)) {
7998 printf("unlink failed (%s)\n", nt_errstr(status));
8001 if (!torture_close_connection(cli1)) {
8008 printf("finished large_readx test\n");
8012 static bool run_cli_echo(int dummy)
8014 struct cli_state *cli;
8017 printf("starting cli_echo test\n");
8018 if (!torture_open_connection(&cli, 0)) {
8021 smbXcli_conn_set_sockopt(cli->conn, sockops);
8023 status = cli_echo(cli, 5, data_blob_const("hello", 5));
8025 d_printf("cli_echo returned %s\n", nt_errstr(status));
8027 torture_close_connection(cli);
8028 return NT_STATUS_IS_OK(status);
8031 static bool run_uid_regression_test(int dummy)
8033 static struct cli_state *cli;
8036 bool correct = True;
8039 printf("starting uid regression test\n");
8041 if (!torture_open_connection(&cli, 0)) {
8045 smbXcli_conn_set_sockopt(cli->conn, sockops);
8047 /* Ok - now save then logoff our current user. */
8048 old_vuid = cli_state_get_uid(cli);
8050 status = cli_ulogoff(cli);
8051 if (!NT_STATUS_IS_OK(status)) {
8052 d_printf("(%s) cli_ulogoff failed: %s\n",
8053 __location__, nt_errstr(status));
8058 cli_state_set_uid(cli, old_vuid);
8060 /* Try an operation. */
8061 status = cli_mkdir(cli, "\\uid_reg_test");
8062 if (NT_STATUS_IS_OK(status)) {
8063 d_printf("(%s) cli_mkdir succeeded\n",
8068 /* Should be bad uid. */
8069 if (!check_error(__LINE__, status, ERRSRV, ERRbaduid,
8070 NT_STATUS_USER_SESSION_DELETED)) {
8076 old_cnum = cli_state_get_tid(cli);
8078 /* Now try a SMBtdis with the invald vuid set to zero. */
8079 cli_state_set_uid(cli, 0);
8081 /* This should succeed. */
8082 status = cli_tdis(cli);
8084 if (NT_STATUS_IS_OK(status)) {
8085 d_printf("First tdis with invalid vuid should succeed.\n");
8087 d_printf("First tdis failed (%s)\n", nt_errstr(status));
8092 cli_state_set_uid(cli, old_vuid);
8093 cli_state_set_tid(cli, old_cnum);
8095 /* This should fail. */
8096 status = cli_tdis(cli);
8097 if (NT_STATUS_IS_OK(status)) {
8098 d_printf("Second tdis with invalid vuid should fail - succeeded instead !.\n");
8102 /* Should be bad tid. */
8103 if (!check_error(__LINE__, status, ERRSRV, ERRinvnid,
8104 NT_STATUS_NETWORK_NAME_DELETED)) {
8110 cli_rmdir(cli, "\\uid_reg_test");
8119 static const char *illegal_chars = "*\\/?<>|\":";
8120 static char force_shortname_chars[] = " +,.[];=\177";
8122 static NTSTATUS shortname_del_fn(const char *mnt, struct file_info *finfo,
8123 const char *mask, void *state)
8125 struct cli_state *pcli = (struct cli_state *)state;
8127 NTSTATUS status = NT_STATUS_OK;
8129 slprintf(fname, sizeof(fname), "\\shortname\\%s", finfo->name);
8131 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
8132 return NT_STATUS_OK;
8134 if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
8135 status = cli_rmdir(pcli, fname);
8136 if (!NT_STATUS_IS_OK(status)) {
8137 printf("del_fn: failed to rmdir %s\n,", fname );
8140 status = cli_unlink(pcli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
8141 if (!NT_STATUS_IS_OK(status)) {
8142 printf("del_fn: failed to unlink %s\n,", fname );
8154 static NTSTATUS shortname_list_fn(const char *mnt, struct file_info *finfo,
8155 const char *name, void *state)
8157 struct sn_state *s = (struct sn_state *)state;
8161 printf("shortname list: i = %d, name = |%s|, shortname = |%s|\n",
8162 i, finfo->name, finfo->short_name);
8165 if (strchr(force_shortname_chars, i)) {
8166 if (!finfo->short_name) {
8167 /* Shortname not created when it should be. */
8168 d_printf("(%s) ERROR: Shortname was not created for file %s containing %d\n",
8169 __location__, finfo->name, i);
8172 } else if (finfo->short_name){
8173 /* Shortname created when it should not be. */
8174 d_printf("(%s) ERROR: Shortname %s was created for file %s\n",
8175 __location__, finfo->short_name, finfo->name);
8179 return NT_STATUS_OK;
8182 static bool run_shortname_test(int dummy)
8184 static struct cli_state *cli;
8185 bool correct = True;
8191 printf("starting shortname test\n");
8193 if (!torture_open_connection(&cli, 0)) {
8197 smbXcli_conn_set_sockopt(cli->conn, sockops);
8199 cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
8200 cli_list(cli, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY, shortname_del_fn, cli);
8201 cli_rmdir(cli, "\\shortname");
8203 status = cli_mkdir(cli, "\\shortname");
8204 if (!NT_STATUS_IS_OK(status)) {
8205 d_printf("(%s) cli_mkdir of \\shortname failed: %s\n",
8206 __location__, nt_errstr(status));
8211 if (strlcpy(fname, "\\shortname\\", sizeof(fname)) >= sizeof(fname)) {
8215 if (strlcat(fname, "test .txt", sizeof(fname)) >= sizeof(fname)) {
8222 for (i = 32; i < 128; i++) {
8223 uint16_t fnum = (uint16_t)-1;
8227 if (strchr(illegal_chars, i)) {
8232 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
8233 FILE_SHARE_READ|FILE_SHARE_WRITE,
8234 FILE_OVERWRITE_IF, 0, 0, &fnum, NULL);
8235 if (!NT_STATUS_IS_OK(status)) {
8236 d_printf("(%s) cli_nt_create of %s failed: %s\n",
8237 __location__, fname, nt_errstr(status));
8241 cli_close(cli, fnum);
8244 status = cli_list(cli, "\\shortname\\test*.*", 0,
8245 shortname_list_fn, &s);
8246 if (s.matched != 1) {
8247 d_printf("(%s) failed to list %s: %s\n",
8248 __location__, fname, nt_errstr(status));
8253 status = cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
8254 if (!NT_STATUS_IS_OK(status)) {
8255 d_printf("(%s) failed to delete %s: %s\n",
8256 __location__, fname, nt_errstr(status));
8269 cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
8270 cli_list(cli, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY, shortname_del_fn, cli);
8271 cli_rmdir(cli, "\\shortname");
8272 torture_close_connection(cli);
8276 static void pagedsearch_cb(struct tevent_req *req)
8279 struct tldap_message *msg;
8282 rc = tldap_search_paged_recv(req, talloc_tos(), &msg);
8283 if (!TLDAP_RC_IS_SUCCESS(rc)) {
8284 d_printf("tldap_search_paged_recv failed: %s\n",
8285 tldap_rc2string(rc));
8288 if (tldap_msg_type(msg) != TLDAP_RES_SEARCH_ENTRY) {
8292 if (!tldap_entry_dn(msg, &dn)) {
8293 d_printf("tldap_entry_dn failed\n");
8296 d_printf("%s\n", dn);
8300 static bool run_tldap(int dummy)
8302 struct tldap_context *ld;
8306 struct sockaddr_storage addr;
8307 struct tevent_context *ev;
8308 struct tevent_req *req;
8312 if (!resolve_name(host, &addr, 0, false)) {
8313 d_printf("could not find host %s\n", host);
8316 status = open_socket_out(&addr, 389, 9999, &fd);
8317 if (!NT_STATUS_IS_OK(status)) {
8318 d_printf("open_socket_out failed: %s\n", nt_errstr(status));
8322 ld = tldap_context_create(talloc_tos(), fd);
8325 d_printf("tldap_context_create failed\n");
8329 rc = tldap_fetch_rootdse(ld);
8330 if (!TLDAP_RC_IS_SUCCESS(rc)) {
8331 d_printf("tldap_fetch_rootdse failed: %s\n",
8332 tldap_errstr(talloc_tos(), ld, rc));
8336 basedn = tldap_talloc_single_attribute(
8337 tldap_rootdse(ld), "defaultNamingContext", talloc_tos());
8338 if (basedn == NULL) {
8339 d_printf("no defaultNamingContext\n");
8342 d_printf("defaultNamingContext: %s\n", basedn);
8344 ev = samba_tevent_context_init(talloc_tos());
8346 d_printf("tevent_context_init failed\n");
8350 req = tldap_search_paged_send(talloc_tos(), ev, ld, basedn,
8351 TLDAP_SCOPE_SUB, "(objectclass=*)",
8353 NULL, 0, NULL, 0, 0, 0, 0, 5);
8355 d_printf("tldap_search_paged_send failed\n");
8358 tevent_req_set_callback(req, pagedsearch_cb, NULL);
8360 tevent_req_poll(req, ev);
8364 /* test search filters against rootDSE */
8365 filter = "(&(|(name=samba)(nextRid<=10000000)(usnChanged>=10)(samba~=ambas)(!(name=s*m*a)))"
8366 "(|(name:=samba)(name:dn:2.5.13.5:=samba)(:dn:2.5.13.5:=samba)(!(name=*samba))))";
8368 rc = tldap_search(ld, "", TLDAP_SCOPE_BASE, filter,
8369 NULL, 0, 0, NULL, 0, NULL, 0, 0, 0, 0,
8370 talloc_tos(), NULL);
8371 if (!TLDAP_RC_IS_SUCCESS(rc)) {
8372 d_printf("tldap_search with complex filter failed: %s\n",
8373 tldap_errstr(talloc_tos(), ld, rc));
8381 /* Torture test to ensure no regression of :
8382 https://bugzilla.samba.org/show_bug.cgi?id=7084
8385 static bool run_dir_createtime(int dummy)
8387 struct cli_state *cli;
8388 const char *dname = "\\testdir";
8389 const char *fname = "\\testdir\\testfile";
8391 struct timespec create_time;
8392 struct timespec create_time1;
8396 if (!torture_open_connection(&cli, 0)) {
8400 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
8401 cli_rmdir(cli, dname);
8403 status = cli_mkdir(cli, dname);
8404 if (!NT_STATUS_IS_OK(status)) {
8405 printf("mkdir failed: %s\n", nt_errstr(status));
8409 status = cli_qpathinfo2(cli, dname, &create_time, NULL, NULL, NULL,
8411 if (!NT_STATUS_IS_OK(status)) {
8412 printf("cli_qpathinfo2 returned %s\n",
8417 /* Sleep 3 seconds, then create a file. */
8420 status = cli_openx(cli, fname, O_RDWR | O_CREAT | O_EXCL,
8422 if (!NT_STATUS_IS_OK(status)) {
8423 printf("cli_openx failed: %s\n", nt_errstr(status));
8427 status = cli_qpathinfo2(cli, dname, &create_time1, NULL, NULL, NULL,
8429 if (!NT_STATUS_IS_OK(status)) {
8430 printf("cli_qpathinfo2 (2) returned %s\n",
8435 if (timespec_compare(&create_time1, &create_time)) {
8436 printf("run_dir_createtime: create time was updated (error)\n");
8438 printf("run_dir_createtime: create time was not updated (correct)\n");
8444 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
8445 cli_rmdir(cli, dname);
8446 if (!torture_close_connection(cli)) {
8453 static bool run_streamerror(int dummy)
8455 struct cli_state *cli;
8456 const char *dname = "\\testdir";
8457 const char *streamname =
8458 "testdir:{4c8cc155-6c1e-11d1-8e41-00c04fb9386d}:$DATA";
8460 time_t change_time, access_time, write_time;
8462 uint16_t mode, fnum;
8465 if (!torture_open_connection(&cli, 0)) {
8469 cli_unlink(cli, "\\testdir\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
8470 cli_rmdir(cli, dname);
8472 status = cli_mkdir(cli, dname);
8473 if (!NT_STATUS_IS_OK(status)) {
8474 printf("mkdir failed: %s\n", nt_errstr(status));
8478 status = cli_qpathinfo1(cli, streamname, &change_time, &access_time,
8479 &write_time, &size, &mode);
8480 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
8481 printf("pathinfo returned %s, expected "
8482 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
8487 status = cli_ntcreate(cli, streamname, 0x16,
8488 FILE_READ_DATA|FILE_READ_EA|
8489 FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS,
8490 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
8491 FILE_OPEN, 0, 0, &fnum, NULL);
8493 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
8494 printf("ntcreate returned %s, expected "
8495 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
8501 cli_rmdir(cli, dname);
8505 static bool run_local_substitute(int dummy)
8509 ok &= subst_test("%U", "bla", "", -1, -1, "bla");
8510 ok &= subst_test("%u%U", "bla", "", -1, -1, "blabla");
8511 ok &= subst_test("%g", "", "", -1, -1, "NO_GROUP");
8512 ok &= subst_test("%G", "", "", -1, -1, "NO_GROUP");
8513 ok &= subst_test("%g", "", "", -1, 0, gidtoname(0));
8514 ok &= subst_test("%G", "", "", -1, 0, gidtoname(0));
8515 ok &= subst_test("%D%u", "u", "dom", -1, 0, "domu");
8516 ok &= subst_test("%i %I", "", "", -1, -1, "0.0.0.0 0.0.0.0");
8518 /* Different captialization rules in sub_basic... */
8520 ok &= (strcmp(talloc_sub_basic(talloc_tos(), "BLA", "dom", "%U%D"),
8526 static bool run_local_base64(int dummy)
8531 for (i=1; i<2000; i++) {
8532 DATA_BLOB blob1, blob2;
8535 blob1.data = talloc_array(talloc_tos(), uint8_t, i);
8537 generate_random_buffer(blob1.data, blob1.length);
8539 b64 = base64_encode_data_blob(talloc_tos(), blob1);
8541 d_fprintf(stderr, "base64_encode_data_blob failed "
8542 "for %d bytes\n", i);
8545 blob2 = base64_decode_data_blob(b64);
8548 if (data_blob_cmp(&blob1, &blob2)) {
8549 d_fprintf(stderr, "data_blob_cmp failed for %d "
8553 TALLOC_FREE(blob1.data);
8554 data_blob_free(&blob2);
8559 static void parse_fn(time_t timeout, DATA_BLOB blob, void *private_data)
8564 static bool run_local_gencache(int dummy)
8570 struct memcache *mem;
8573 mem = memcache_init(NULL, 0);
8575 d_printf("%s: memcache_init failed\n", __location__);
8578 memcache_set_global(mem);
8580 if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
8581 d_printf("%s: gencache_set() failed\n", __location__);
8585 if (!gencache_get("foo", NULL, NULL, NULL)) {
8586 d_printf("%s: gencache_get() failed\n", __location__);
8590 for (i=0; i<1000000; i++) {
8591 gencache_parse("foo", parse_fn, NULL);
8594 if (!gencache_get("foo", talloc_tos(), &val, &tm)) {
8595 d_printf("%s: gencache_get() failed\n", __location__);
8600 if (!gencache_get("foo", talloc_tos(), &val, &tm)) {
8601 d_printf("%s: gencache_get() failed\n", __location__);
8605 if (strcmp(val, "bar") != 0) {
8606 d_printf("%s: gencache_get() returned %s, expected %s\n",
8607 __location__, val, "bar");
8614 if (!gencache_del("foo")) {
8615 d_printf("%s: gencache_del() failed\n", __location__);
8618 if (gencache_del("foo")) {
8619 d_printf("%s: second gencache_del() succeeded\n",
8624 if (gencache_get("foo", talloc_tos(), &val, &tm)) {
8625 d_printf("%s: gencache_get() on deleted entry "
8626 "succeeded\n", __location__);
8630 blob = data_blob_string_const_null("bar");
8631 tm = time(NULL) + 60;
8633 if (!gencache_set_data_blob("foo", &blob, tm)) {
8634 d_printf("%s: gencache_set_data_blob() failed\n", __location__);
8638 if (!gencache_get_data_blob("foo", talloc_tos(), &blob, NULL, NULL)) {
8639 d_printf("%s: gencache_get_data_blob() failed\n", __location__);
8643 if (strcmp((const char *)blob.data, "bar") != 0) {
8644 d_printf("%s: gencache_get_data_blob() returned %s, expected %s\n",
8645 __location__, (const char *)blob.data, "bar");
8646 data_blob_free(&blob);
8650 data_blob_free(&blob);
8652 if (!gencache_del("foo")) {
8653 d_printf("%s: gencache_del() failed\n", __location__);
8656 if (gencache_del("foo")) {
8657 d_printf("%s: second gencache_del() succeeded\n",
8662 if (gencache_get_data_blob("foo", talloc_tos(), &blob, NULL, NULL)) {
8663 d_printf("%s: gencache_get_data_blob() on deleted entry "
8664 "succeeded\n", __location__);
8669 blob.data = (uint8_t *)&v;
8670 blob.length = sizeof(v);
8672 if (!gencache_set_data_blob("blob", &blob, tm)) {
8673 d_printf("%s: gencache_set_data_blob() failed\n",
8677 if (gencache_get("blob", talloc_tos(), &val, &tm)) {
8678 d_printf("%s: gencache_get succeeded\n", __location__);
8685 static bool rbt_testval(struct db_context *db, const char *key,
8688 struct db_record *rec;
8689 TDB_DATA data = string_tdb_data(value);
8694 rec = dbwrap_fetch_locked(db, db, string_tdb_data(key));
8696 d_fprintf(stderr, "fetch_locked failed\n");
8699 status = dbwrap_record_store(rec, data, 0);
8700 if (!NT_STATUS_IS_OK(status)) {
8701 d_fprintf(stderr, "store failed: %s\n", nt_errstr(status));
8706 rec = dbwrap_fetch_locked(db, db, string_tdb_data(key));
8708 d_fprintf(stderr, "second fetch_locked failed\n");
8712 dbvalue = dbwrap_record_get_value(rec);
8713 if ((dbvalue.dsize != data.dsize)
8714 || (memcmp(dbvalue.dptr, data.dptr, data.dsize) != 0)) {
8715 d_fprintf(stderr, "Got wrong data back\n");
8725 static int local_rbtree_traverse_read(struct db_record *rec, void *private_data)
8727 int *count2 = (int *)private_data;
8732 static int local_rbtree_traverse_delete(struct db_record *rec, void *private_data)
8734 int *count2 = (int *)private_data;
8736 dbwrap_record_delete(rec);
8740 static bool run_local_rbtree(int dummy)
8742 struct db_context *db;
8749 db = db_open_rbt(NULL);
8752 d_fprintf(stderr, "db_open_rbt failed\n");
8756 for (i=0; i<1000; i++) {
8759 if (asprintf(&key, "key%ld", random()) == -1) {
8762 if (asprintf(&value, "value%ld", random()) == -1) {
8767 if (!rbt_testval(db, key, value)) {
8774 if (asprintf(&value, "value%ld", random()) == -1) {
8779 if (!rbt_testval(db, key, value)) {
8790 count = 0; count2 = 0;
8791 status = dbwrap_traverse_read(db, local_rbtree_traverse_read,
8793 printf("%s: read1: %d %d, %s\n", __func__, count, count2, nt_errstr(status));
8794 if ((count != count2) || (count != 1000)) {
8797 count = 0; count2 = 0;
8798 status = dbwrap_traverse(db, local_rbtree_traverse_delete,
8800 printf("%s: delete: %d %d, %s\n", __func__, count, count2, nt_errstr(status));
8801 if ((count != count2) || (count != 1000)) {
8804 count = 0; count2 = 0;
8805 status = dbwrap_traverse_read(db, local_rbtree_traverse_read,
8807 printf("%s: read2: %d %d, %s\n", __func__, count, count2, nt_errstr(status));
8808 if ((count != count2) || (count != 0)) {
8819 local test for character set functions
8821 This is a very simple test for the functionality in convert_string_error()
8823 static bool run_local_convert_string(int dummy)
8825 TALLOC_CTX *tmp_ctx = talloc_new(NULL);
8826 const char *test_strings[2] = { "March", "M\303\244rz" };
8830 for (i=0; i<2; i++) {
8831 const char *str = test_strings[i];
8832 int len = strlen(str);
8833 size_t converted_size;
8836 memset(dst, 'X', sizeof(dst));
8838 /* first try with real source length */
8839 ret = convert_string_error(CH_UNIX, CH_UTF8,
8844 d_fprintf(stderr, "Failed to convert '%s' to CH_DISPLAY\n", str);
8848 if (converted_size != len) {
8849 d_fprintf(stderr, "Converted size of '%s' should be %d - got %d\n",
8850 str, len, (int)converted_size);
8854 if (strncmp(str, dst, converted_size) != 0) {
8855 d_fprintf(stderr, "Expected '%s' to match '%s'\n", str, dst);
8859 if (strlen(str) != converted_size) {
8860 d_fprintf(stderr, "Expected '%s' length %d - got %d\n", str,
8861 (int)strlen(str), (int)converted_size);
8865 if (dst[converted_size] != 'X') {
8866 d_fprintf(stderr, "Expected no termination of '%s'\n", dst);
8870 /* now with srclen==-1, this causes the nul to be
8872 ret = convert_string_error(CH_UNIX, CH_UTF8,
8877 d_fprintf(stderr, "Failed to convert '%s' to CH_DISPLAY\n", str);
8881 if (converted_size != len+1) {
8882 d_fprintf(stderr, "Converted size of '%s' should be %d - got %d\n",
8883 str, len, (int)converted_size);
8887 if (strncmp(str, dst, converted_size) != 0) {
8888 d_fprintf(stderr, "Expected '%s' to match '%s'\n", str, dst);
8892 if (len+1 != converted_size) {
8893 d_fprintf(stderr, "Expected '%s' length %d - got %d\n", str,
8894 len+1, (int)converted_size);
8898 if (dst[converted_size] != 'X') {
8899 d_fprintf(stderr, "Expected no termination of '%s'\n", dst);
8906 TALLOC_FREE(tmp_ctx);
8909 TALLOC_FREE(tmp_ctx);
8914 struct talloc_dict_test {
8918 static int talloc_dict_traverse_fn(DATA_BLOB key, void *data, void *priv)
8920 int *count = (int *)priv;
8925 static bool run_local_talloc_dict(int dummy)
8927 struct talloc_dict *dict;
8928 struct talloc_dict_test *t;
8929 int key, count, res;
8932 dict = talloc_dict_init(talloc_tos());
8937 t = talloc(talloc_tos(), struct talloc_dict_test);
8944 ok = talloc_dict_set(dict, data_blob_const(&key, sizeof(key)), &t);
8950 res = talloc_dict_traverse(dict, talloc_dict_traverse_fn, &count);
8968 static bool run_local_string_to_sid(int dummy) {
8971 if (string_to_sid(&sid, "S--1-5-32-545")) {
8972 printf("allowing S--1-5-32-545\n");
8975 if (string_to_sid(&sid, "S-1-5-32-+545")) {
8976 printf("allowing S-1-5-32-+545\n");
8979 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")) {
8980 printf("allowing S-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0\n");
8983 if (string_to_sid(&sid, "S-1-5-32-545-abc")) {
8984 printf("allowing S-1-5-32-545-abc\n");
8987 if (string_to_sid(&sid, "S-300-5-32-545")) {
8988 printf("allowing S-300-5-32-545\n");
8991 if (string_to_sid(&sid, "S-1-0xfffffffffffffe-32-545")) {
8992 printf("allowing S-1-0xfffffffffffffe-32-545\n");
8995 if (string_to_sid(&sid, "S-1-0xffffffffffff-5294967297-545")) {
8996 printf("allowing S-1-0xffffffffffff-5294967297-545\n");
8999 if (!string_to_sid(&sid, "S-1-0xfffffffffffe-32-545")) {
9000 printf("could not parse S-1-0xfffffffffffe-32-545\n");
9003 if (!string_to_sid(&sid, "S-1-5-32-545")) {
9004 printf("could not parse S-1-5-32-545\n");
9007 if (!dom_sid_equal(&sid, &global_sid_Builtin_Users)) {
9008 printf("mis-parsed S-1-5-32-545 as %s\n",
9009 sid_string_tos(&sid));
9015 static bool sid_to_string_test(const char *expected) {
9020 if (!string_to_sid(&sid, expected)) {
9021 printf("could not parse %s\n", expected);
9025 str = dom_sid_string(NULL, &sid);
9026 if (strcmp(str, expected)) {
9027 printf("Comparison failed (%s != %s)\n", str, expected);
9034 static bool run_local_sid_to_string(int dummy) {
9035 if (!sid_to_string_test("S-1-0xffffffffffff-1-1-1-1-1-1-1-1-1-1-1-1"))
9037 if (!sid_to_string_test("S-1-545"))
9039 if (!sid_to_string_test("S-255-3840-1-1-1-1"))
9044 static bool run_local_binary_to_sid(int dummy) {
9045 struct dom_sid *sid = talloc(NULL, struct dom_sid);
9046 static const uint8_t good_binary_sid[] = {
9047 0x1, /* revision number */
9049 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
9050 0x1, 0x1, 0x1, 0x1, /* auth[0] */
9051 0x1, 0x1, 0x1, 0x1, /* auth[1] */
9052 0x1, 0x1, 0x1, 0x1, /* auth[2] */
9053 0x1, 0x1, 0x1, 0x1, /* auth[3] */
9054 0x1, 0x1, 0x1, 0x1, /* auth[4] */
9055 0x1, 0x1, 0x1, 0x1, /* auth[5] */
9056 0x1, 0x1, 0x1, 0x1, /* auth[6] */
9057 0x1, 0x1, 0x1, 0x1, /* auth[7] */
9058 0x1, 0x1, 0x1, 0x1, /* auth[8] */
9059 0x1, 0x1, 0x1, 0x1, /* auth[9] */
9060 0x1, 0x1, 0x1, 0x1, /* auth[10] */
9061 0x1, 0x1, 0x1, 0x1, /* auth[11] */
9062 0x1, 0x1, 0x1, 0x1, /* auth[12] */
9063 0x1, 0x1, 0x1, 0x1, /* auth[13] */
9064 0x1, 0x1, 0x1, 0x1, /* auth[14] */
9067 static const uint8_t long_binary_sid[] = {
9068 0x1, /* revision number */
9070 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
9071 0x1, 0x1, 0x1, 0x1, /* auth[0] */
9072 0x1, 0x1, 0x1, 0x1, /* auth[1] */
9073 0x1, 0x1, 0x1, 0x1, /* auth[2] */
9074 0x1, 0x1, 0x1, 0x1, /* auth[3] */
9075 0x1, 0x1, 0x1, 0x1, /* auth[4] */
9076 0x1, 0x1, 0x1, 0x1, /* auth[5] */
9077 0x1, 0x1, 0x1, 0x1, /* auth[6] */
9078 0x1, 0x1, 0x1, 0x1, /* auth[7] */
9079 0x1, 0x1, 0x1, 0x1, /* auth[8] */
9080 0x1, 0x1, 0x1, 0x1, /* auth[9] */
9081 0x1, 0x1, 0x1, 0x1, /* auth[10] */
9082 0x1, 0x1, 0x1, 0x1, /* auth[11] */
9083 0x1, 0x1, 0x1, 0x1, /* auth[12] */
9084 0x1, 0x1, 0x1, 0x1, /* auth[13] */
9085 0x1, 0x1, 0x1, 0x1, /* auth[14] */
9086 0x1, 0x1, 0x1, 0x1, /* auth[15] */
9087 0x1, 0x1, 0x1, 0x1, /* auth[16] */
9088 0x1, 0x1, 0x1, 0x1, /* auth[17] */
9091 static const uint8_t long_binary_sid2[] = {
9092 0x1, /* revision number */
9094 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
9095 0x1, 0x1, 0x1, 0x1, /* auth[0] */
9096 0x1, 0x1, 0x1, 0x1, /* auth[1] */
9097 0x1, 0x1, 0x1, 0x1, /* auth[2] */
9098 0x1, 0x1, 0x1, 0x1, /* auth[3] */
9099 0x1, 0x1, 0x1, 0x1, /* auth[4] */
9100 0x1, 0x1, 0x1, 0x1, /* auth[5] */
9101 0x1, 0x1, 0x1, 0x1, /* auth[6] */
9102 0x1, 0x1, 0x1, 0x1, /* auth[7] */
9103 0x1, 0x1, 0x1, 0x1, /* auth[8] */
9104 0x1, 0x1, 0x1, 0x1, /* auth[9] */
9105 0x1, 0x1, 0x1, 0x1, /* auth[10] */
9106 0x1, 0x1, 0x1, 0x1, /* auth[11] */
9107 0x1, 0x1, 0x1, 0x1, /* auth[12] */
9108 0x1, 0x1, 0x1, 0x1, /* auth[13] */
9109 0x1, 0x1, 0x1, 0x1, /* auth[14] */
9110 0x1, 0x1, 0x1, 0x1, /* auth[15] */
9111 0x1, 0x1, 0x1, 0x1, /* auth[16] */
9112 0x1, 0x1, 0x1, 0x1, /* auth[17] */
9113 0x1, 0x1, 0x1, 0x1, /* auth[18] */
9114 0x1, 0x1, 0x1, 0x1, /* auth[19] */
9115 0x1, 0x1, 0x1, 0x1, /* auth[20] */
9116 0x1, 0x1, 0x1, 0x1, /* auth[21] */
9117 0x1, 0x1, 0x1, 0x1, /* auth[22] */
9118 0x1, 0x1, 0x1, 0x1, /* auth[23] */
9119 0x1, 0x1, 0x1, 0x1, /* auth[24] */
9120 0x1, 0x1, 0x1, 0x1, /* auth[25] */
9121 0x1, 0x1, 0x1, 0x1, /* auth[26] */
9122 0x1, 0x1, 0x1, 0x1, /* auth[27] */
9123 0x1, 0x1, 0x1, 0x1, /* auth[28] */
9124 0x1, 0x1, 0x1, 0x1, /* auth[29] */
9125 0x1, 0x1, 0x1, 0x1, /* auth[30] */
9126 0x1, 0x1, 0x1, 0x1, /* auth[31] */
9129 if (!sid_parse(good_binary_sid, sizeof(good_binary_sid), sid)) {
9132 if (sid_parse(long_binary_sid2, sizeof(long_binary_sid2), sid)) {
9135 if (sid_parse(long_binary_sid, sizeof(long_binary_sid), sid)) {
9141 /* Split a path name into filename and stream name components. Canonicalise
9142 * such that an implicit $DATA token is always explicit.
9144 * The "specification" of this function can be found in the
9145 * run_local_stream_name() function in torture.c, I've tried those
9146 * combinations against a W2k3 server.
9149 static NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
9150 char **pbase, char **pstream)
9153 char *stream = NULL;
9154 char *sname; /* stream name */
9155 const char *stype; /* stream type */
9157 DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
9159 sname = strchr_m(fname, ':');
9161 if (sname == NULL) {
9162 if (pbase != NULL) {
9163 base = talloc_strdup(mem_ctx, fname);
9164 NT_STATUS_HAVE_NO_MEMORY(base);
9169 if (pbase != NULL) {
9170 base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
9171 NT_STATUS_HAVE_NO_MEMORY(base);
9176 stype = strchr_m(sname, ':');
9178 if (stype == NULL) {
9179 sname = talloc_strdup(mem_ctx, sname);
9183 if (strcasecmp_m(stype, ":$DATA") != 0) {
9185 * If there is an explicit stream type, so far we only
9186 * allow $DATA. Is there anything else allowed? -- vl
9188 DEBUG(10, ("[%s] is an invalid stream type\n", stype));
9190 return NT_STATUS_OBJECT_NAME_INVALID;
9192 sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
9196 if (sname == NULL) {
9198 return NT_STATUS_NO_MEMORY;
9201 if (sname[0] == '\0') {
9203 * no stream name, so no stream
9208 if (pstream != NULL) {
9209 stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
9210 if (stream == NULL) {
9213 return NT_STATUS_NO_MEMORY;
9216 * upper-case the type field
9218 (void)strupper_m(strchr_m(stream, ':')+1);
9222 if (pbase != NULL) {
9225 if (pstream != NULL) {
9228 return NT_STATUS_OK;
9231 static bool test_stream_name(const char *fname, const char *expected_base,
9232 const char *expected_stream,
9233 NTSTATUS expected_status)
9237 char *stream = NULL;
9239 status = split_ntfs_stream_name(talloc_tos(), fname, &base, &stream);
9240 if (!NT_STATUS_EQUAL(status, expected_status)) {
9244 if (!NT_STATUS_IS_OK(status)) {
9248 if (base == NULL) goto error;
9250 if (strcmp(expected_base, base) != 0) goto error;
9252 if ((expected_stream != NULL) && (stream == NULL)) goto error;
9253 if ((expected_stream == NULL) && (stream != NULL)) goto error;
9255 if ((stream != NULL) && (strcmp(expected_stream, stream) != 0))
9259 TALLOC_FREE(stream);
9263 d_fprintf(stderr, "Do test_stream(%s, %s, %s, %s)\n",
9264 fname, expected_base ? expected_base : "<NULL>",
9265 expected_stream ? expected_stream : "<NULL>",
9266 nt_errstr(expected_status));
9267 d_fprintf(stderr, "-> base=%s, stream=%s, status=%s\n",
9268 base ? base : "<NULL>", stream ? stream : "<NULL>",
9271 TALLOC_FREE(stream);
9275 static bool run_local_stream_name(int dummy)
9279 ret &= test_stream_name(
9280 "bla", "bla", NULL, NT_STATUS_OK);
9281 ret &= test_stream_name(
9282 "bla::$DATA", "bla", NULL, NT_STATUS_OK);
9283 ret &= test_stream_name(
9284 "bla:blub:", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
9285 ret &= test_stream_name(
9286 "bla::", NULL, NULL, NT_STATUS_OBJECT_NAME_INVALID);
9287 ret &= test_stream_name(
9288 "bla::123", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
9289 ret &= test_stream_name(
9290 "bla:$DATA", "bla", "$DATA:$DATA", NT_STATUS_OK);
9291 ret &= test_stream_name(
9292 "bla:x:$DATA", "bla", "x:$DATA", NT_STATUS_OK);
9293 ret &= test_stream_name(
9294 "bla:x", "bla", "x:$DATA", NT_STATUS_OK);
9299 static bool data_blob_equal(DATA_BLOB a, DATA_BLOB b)
9301 if (a.length != b.length) {
9302 printf("a.length=%d != b.length=%d\n",
9303 (int)a.length, (int)b.length);
9306 if (memcmp(a.data, b.data, a.length) != 0) {
9307 printf("a.data and b.data differ\n");
9313 static bool run_local_memcache(int dummy)
9315 struct memcache *cache;
9317 DATA_BLOB d1, d2, d3;
9318 DATA_BLOB v1, v2, v3;
9320 TALLOC_CTX *mem_ctx;
9322 size_t size1, size2;
9325 cache = memcache_init(NULL, sizeof(void *) == 8 ? 200 : 100);
9327 if (cache == NULL) {
9328 printf("memcache_init failed\n");
9332 d1 = data_blob_const("d1", 2);
9333 d2 = data_blob_const("d2", 2);
9334 d3 = data_blob_const("d3", 2);
9336 k1 = data_blob_const("d1", 2);
9337 k2 = data_blob_const("d2", 2);
9339 memcache_add(cache, STAT_CACHE, k1, d1);
9340 memcache_add(cache, GETWD_CACHE, k2, d2);
9342 if (!memcache_lookup(cache, STAT_CACHE, k1, &v1)) {
9343 printf("could not find k1\n");
9346 if (!data_blob_equal(d1, v1)) {
9350 if (!memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
9351 printf("could not find k2\n");
9354 if (!data_blob_equal(d2, v2)) {
9358 memcache_add(cache, STAT_CACHE, k1, d3);
9360 if (!memcache_lookup(cache, STAT_CACHE, k1, &v3)) {
9361 printf("could not find replaced k1\n");
9364 if (!data_blob_equal(d3, v3)) {
9368 memcache_add(cache, GETWD_CACHE, k1, d1);
9370 if (memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
9371 printf("Did find k2, should have been purged\n");
9377 cache = memcache_init(NULL, 0);
9379 mem_ctx = talloc_init("foo");
9381 str1 = talloc_strdup(mem_ctx, "string1");
9382 str2 = talloc_strdup(mem_ctx, "string2");
9384 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
9385 data_blob_string_const("torture"), &str1);
9386 size1 = talloc_total_size(cache);
9388 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
9389 data_blob_string_const("torture"), &str2);
9390 size2 = talloc_total_size(cache);
9392 printf("size1=%d, size2=%d\n", (int)size1, (int)size2);
9394 if (size2 > size1) {
9395 printf("memcache leaks memory!\n");
9405 static void wbclient_done(struct tevent_req *req)
9408 struct winbindd_response *wb_resp;
9409 int *i = (int *)tevent_req_callback_data_void(req);
9411 wbc_err = wb_trans_recv(req, req, &wb_resp);
9414 d_printf("wb_trans_recv %d returned %s\n", *i, wbcErrorString(wbc_err));
9417 static bool run_wbclient_multi_ping(int dummy)
9419 struct tevent_context *ev;
9420 struct wb_context **wb_ctx;
9421 struct winbindd_request wb_req;
9422 bool result = false;
9425 BlockSignals(True, SIGPIPE);
9427 ev = tevent_context_init(talloc_tos());
9432 wb_ctx = talloc_array(ev, struct wb_context *, torture_nprocs);
9433 if (wb_ctx == NULL) {
9437 ZERO_STRUCT(wb_req);
9438 wb_req.cmd = WINBINDD_PING;
9440 d_printf("torture_nprocs=%d, numops=%d\n", (int)torture_nprocs, (int)torture_numops);
9442 for (i=0; i<torture_nprocs; i++) {
9443 wb_ctx[i] = wb_context_init(ev, NULL);
9444 if (wb_ctx[i] == NULL) {
9447 for (j=0; j<torture_numops; j++) {
9448 struct tevent_req *req;
9449 req = wb_trans_send(ev, ev, wb_ctx[i],
9450 (j % 2) == 0, &wb_req);
9454 tevent_req_set_callback(req, wbclient_done, &i);
9460 while (i < torture_nprocs * torture_numops) {
9461 tevent_loop_once(ev);
9470 static void getaddrinfo_finished(struct tevent_req *req)
9472 char *name = (char *)tevent_req_callback_data_void(req);
9473 struct addrinfo *ainfo;
9476 res = getaddrinfo_recv(req, &ainfo);
9478 d_printf("gai(%s) returned %s\n", name, gai_strerror(res));
9481 d_printf("gai(%s) succeeded\n", name);
9482 freeaddrinfo(ainfo);
9485 static bool run_getaddrinfo_send(int dummy)
9487 TALLOC_CTX *frame = talloc_stackframe();
9488 struct fncall_context *ctx;
9489 struct tevent_context *ev;
9490 bool result = false;
9491 const char *names[4] = { "www.samba.org", "notfound.samba.org",
9492 "www.slashdot.org", "heise.de" };
9493 struct tevent_req *reqs[4];
9496 ev = samba_tevent_context_init(frame);
9501 ctx = fncall_context_init(frame, 4);
9503 for (i=0; i<ARRAY_SIZE(names); i++) {
9504 reqs[i] = getaddrinfo_send(frame, ev, ctx, names[i], NULL,
9506 if (reqs[i] == NULL) {
9509 tevent_req_set_callback(reqs[i], getaddrinfo_finished,
9510 discard_const_p(void, names[i]));
9513 for (i=0; i<ARRAY_SIZE(reqs); i++) {
9514 tevent_loop_once(ev);
9523 static bool dbtrans_inc(struct db_context *db)
9525 struct db_record *rec;
9531 rec = dbwrap_fetch_locked(db, db, string_term_tdb_data("transtest"));
9533 printf(__location__ "fetch_lock failed\n");
9537 value = dbwrap_record_get_value(rec);
9539 if (value.dsize != sizeof(uint32_t)) {
9540 printf(__location__ "value.dsize = %d\n",
9545 memcpy(&val, value.dptr, sizeof(val));
9548 status = dbwrap_record_store(
9549 rec, make_tdb_data((uint8_t *)&val, sizeof(val)), 0);
9550 if (!NT_STATUS_IS_OK(status)) {
9551 printf(__location__ "store failed: %s\n",
9562 static bool run_local_dbtrans(int dummy)
9564 struct db_context *db;
9565 struct db_record *rec;
9571 db = db_open(talloc_tos(), "transtest.tdb", 0, TDB_DEFAULT,
9572 O_RDWR|O_CREAT, 0600, DBWRAP_LOCK_ORDER_1,
9575 printf("Could not open transtest.db\n");
9579 res = dbwrap_transaction_start(db);
9581 printf(__location__ "transaction_start failed\n");
9585 rec = dbwrap_fetch_locked(db, db, string_term_tdb_data("transtest"));
9587 printf(__location__ "fetch_lock failed\n");
9591 value = dbwrap_record_get_value(rec);
9593 if (value.dptr == NULL) {
9595 status = dbwrap_record_store(
9596 rec, make_tdb_data((uint8_t *)&initial,
9599 if (!NT_STATUS_IS_OK(status)) {
9600 printf(__location__ "store returned %s\n",
9608 res = dbwrap_transaction_commit(db);
9610 printf(__location__ "transaction_commit failed\n");
9618 res = dbwrap_transaction_start(db);
9620 printf(__location__ "transaction_start failed\n");
9624 status = dbwrap_fetch_uint32_bystring(db, "transtest", &val);
9625 if (!NT_STATUS_IS_OK(status)) {
9626 printf(__location__ "dbwrap_fetch_uint32 failed: %s\n",
9631 for (i=0; i<10; i++) {
9632 if (!dbtrans_inc(db)) {
9637 status = dbwrap_fetch_uint32_bystring(db, "transtest", &val2);
9638 if (!NT_STATUS_IS_OK(status)) {
9639 printf(__location__ "dbwrap_fetch_uint32 failed: %s\n",
9644 if (val2 != val + 10) {
9645 printf(__location__ "val=%d, val2=%d\n",
9646 (int)val, (int)val2);
9650 printf("val2=%d\r", val2);
9652 res = dbwrap_transaction_commit(db);
9654 printf(__location__ "transaction_commit failed\n");
9664 * Just a dummy test to be run under a debugger. There's no real way
9665 * to inspect the tevent_select specific function from outside of
9669 static bool run_local_tevent_select(int dummy)
9671 struct tevent_context *ev;
9672 struct tevent_fd *fd1, *fd2;
9673 bool result = false;
9675 ev = tevent_context_init_byname(NULL, "select");
9677 d_fprintf(stderr, "tevent_context_init_byname failed\n");
9681 fd1 = tevent_add_fd(ev, ev, 2, 0, NULL, NULL);
9683 d_fprintf(stderr, "tevent_add_fd failed\n");
9686 fd2 = tevent_add_fd(ev, ev, 3, 0, NULL, NULL);
9688 d_fprintf(stderr, "tevent_add_fd failed\n");
9693 fd2 = tevent_add_fd(ev, ev, 1, 0, NULL, NULL);
9695 d_fprintf(stderr, "tevent_add_fd failed\n");
9705 static bool run_local_hex_encode_buf(int dummy)
9711 for (i=0; i<sizeof(src); i++) {
9714 hex_encode_buf(buf, src, sizeof(src));
9715 if (strcmp(buf, "0001020304050607") != 0) {
9718 hex_encode_buf(buf, NULL, 0);
9719 if (buf[0] != '\0') {
9725 static const char *remove_duplicate_addrs2_test_strings_vector[] = {
9747 "1001:1111:1111:1000:0:1111:1111:1111",
9756 static const char *remove_duplicate_addrs2_test_strings_result[] = {
9770 "1001:1111:1111:1000:0:1111:1111:1111"
9773 static bool run_local_remove_duplicate_addrs2(int dummy)
9775 struct ip_service test_vector[28];
9778 /* Construct the sockaddr_storage test vector. */
9779 for (i = 0; i < 28; i++) {
9780 struct addrinfo hints;
9781 struct addrinfo *res = NULL;
9784 memset(&hints, '\0', sizeof(hints));
9785 hints.ai_flags = AI_NUMERICHOST;
9786 ret = getaddrinfo(remove_duplicate_addrs2_test_strings_vector[i],
9791 fprintf(stderr, "getaddrinfo failed on [%s]\n",
9792 remove_duplicate_addrs2_test_strings_vector[i]);
9795 memset(&test_vector[i], '\0', sizeof(test_vector[i]));
9796 memcpy(&test_vector[i].ss,
9802 count = remove_duplicate_addrs2(test_vector, i);
9805 fprintf(stderr, "count wrong (%d) should be 14\n",
9810 for (i = 0; i < count; i++) {
9811 char addr[INET6_ADDRSTRLEN];
9813 print_sockaddr(addr, sizeof(addr), &test_vector[i].ss);
9815 if (strcmp(addr, remove_duplicate_addrs2_test_strings_result[i]) != 0) {
9816 fprintf(stderr, "mismatch on [%d] [%s] [%s]\n",
9819 remove_duplicate_addrs2_test_strings_result[i]);
9824 printf("run_local_remove_duplicate_addrs2: success\n");
9828 static bool run_local_tdb_opener(int dummy)
9834 t = tdb_open("test.tdb", 1000, TDB_CLEAR_IF_FIRST,
9835 O_RDWR|O_CREAT, 0755);
9837 perror("tdb_open failed");
9848 static bool run_local_tdb_writer(int dummy)
9854 t = tdb_open("test.tdb", 1000, 0, O_RDWR|O_CREAT, 0755);
9856 perror("tdb_open failed");
9860 val.dptr = (uint8_t *)&v;
9861 val.dsize = sizeof(v);
9867 ret = tdb_store(t, val, val, 0);
9869 printf("%s\n", tdb_errorstr(t));
9874 data = tdb_fetch(t, val);
9875 if (data.dptr != NULL) {
9876 SAFE_FREE(data.dptr);
9882 static double create_procs(bool (*fn)(int), bool *result)
9885 volatile pid_t *child_status;
9886 volatile bool *child_status_out;
9889 struct timeval start;
9893 child_status = (volatile pid_t *)anonymous_shared_allocate(sizeof(pid_t)*torture_nprocs);
9894 if (!child_status) {
9895 printf("Failed to setup shared memory\n");
9899 child_status_out = (volatile bool *)anonymous_shared_allocate(sizeof(bool)*torture_nprocs);
9900 if (!child_status_out) {
9901 printf("Failed to setup result status shared memory\n");
9905 for (i = 0; i < torture_nprocs; i++) {
9906 child_status[i] = 0;
9907 child_status_out[i] = True;
9910 start = timeval_current();
9912 for (i=0;i<torture_nprocs;i++) {
9915 pid_t mypid = getpid();
9916 sys_srandom(((int)mypid) ^ ((int)time(NULL)));
9918 slprintf(myname,sizeof(myname),"CLIENT%d", i);
9921 if (torture_open_connection(¤t_cli, i)) break;
9923 printf("pid %d failed to start\n", (int)getpid());
9929 child_status[i] = getpid();
9931 while (child_status[i] && timeval_elapsed(&start) < 5) smb_msleep(2);
9933 child_status_out[i] = fn(i);
9940 for (i=0;i<torture_nprocs;i++) {
9941 if (child_status[i]) synccount++;
9943 if (synccount == torture_nprocs) break;
9945 } while (timeval_elapsed(&start) < 30);
9947 if (synccount != torture_nprocs) {
9948 printf("FAILED TO START %d CLIENTS (started %d)\n", torture_nprocs, synccount);
9950 return timeval_elapsed(&start);
9953 /* start the client load */
9954 start = timeval_current();
9956 for (i=0;i<torture_nprocs;i++) {
9957 child_status[i] = 0;
9960 printf("%d clients started\n", torture_nprocs);
9962 for (i=0;i<torture_nprocs;i++) {
9963 while (waitpid(0, &status, 0) == -1 && errno == EINTR) /* noop */ ;
9968 for (i=0;i<torture_nprocs;i++) {
9969 if (!child_status_out[i]) {
9973 return timeval_elapsed(&start);
9976 #define FLAG_MULTIPROC 1
9983 {"FDPASS", run_fdpasstest, 0},
9984 {"LOCK1", run_locktest1, 0},
9985 {"LOCK2", run_locktest2, 0},
9986 {"LOCK3", run_locktest3, 0},
9987 {"LOCK4", run_locktest4, 0},
9988 {"LOCK5", run_locktest5, 0},
9989 {"LOCK6", run_locktest6, 0},
9990 {"LOCK7", run_locktest7, 0},
9991 {"LOCK8", run_locktest8, 0},
9992 {"LOCK9", run_locktest9, 0},
9993 {"UNLINK", run_unlinktest, 0},
9994 {"BROWSE", run_browsetest, 0},
9995 {"ATTR", run_attrtest, 0},
9996 {"TRANS2", run_trans2test, 0},
9997 {"MAXFID", run_maxfidtest, FLAG_MULTIPROC},
9998 {"TORTURE",run_torture, FLAG_MULTIPROC},
9999 {"RANDOMIPC", run_randomipc, 0},
10000 {"NEGNOWAIT", run_negprot_nowait, 0},
10001 {"NBENCH", run_nbench, 0},
10002 {"NBENCH2", run_nbench2, 0},
10003 {"OPLOCK1", run_oplock1, 0},
10004 {"OPLOCK2", run_oplock2, 0},
10005 {"OPLOCK4", run_oplock4, 0},
10006 {"DIR", run_dirtest, 0},
10007 {"DIR1", run_dirtest1, 0},
10008 {"DIR-CREATETIME", run_dir_createtime, 0},
10009 {"DENY1", torture_denytest1, 0},
10010 {"DENY2", torture_denytest2, 0},
10011 {"TCON", run_tcon_test, 0},
10012 {"TCONDEV", run_tcon_devtype_test, 0},
10013 {"RW1", run_readwritetest, 0},
10014 {"RW2", run_readwritemulti, FLAG_MULTIPROC},
10015 {"RW3", run_readwritelarge, 0},
10016 {"RW-SIGNING", run_readwritelarge_signtest, 0},
10017 {"OPEN", run_opentest, 0},
10018 {"POSIX", run_simple_posix_open_test, 0},
10019 {"POSIX-APPEND", run_posix_append, 0},
10020 {"POSIX-SYMLINK-ACL", run_acl_symlink_test, 0},
10021 {"POSIX-SYMLINK-EA", run_ea_symlink_test, 0},
10022 {"CASE-INSENSITIVE-CREATE", run_case_insensitive_create, 0},
10023 {"ASYNC-ECHO", run_async_echo, 0},
10024 { "UID-REGRESSION-TEST", run_uid_regression_test, 0},
10025 { "SHORTNAME-TEST", run_shortname_test, 0},
10026 { "ADDRCHANGE", run_addrchange, 0},
10028 {"OPENATTR", run_openattrtest, 0},
10030 {"XCOPY", run_xcopy, 0},
10031 {"RENAME", run_rename, 0},
10032 {"DELETE", run_deletetest, 0},
10033 {"WILDDELETE", run_wild_deletetest, 0},
10034 {"DELETE-LN", run_deletetest_ln, 0},
10035 {"PROPERTIES", run_properties, 0},
10036 {"MANGLE", torture_mangle, 0},
10037 {"MANGLE1", run_mangle1, 0},
10038 {"W2K", run_w2ktest, 0},
10039 {"TRANS2SCAN", torture_trans2_scan, 0},
10040 {"NTTRANSSCAN", torture_nttrans_scan, 0},
10041 {"UTABLE", torture_utable, 0},
10042 {"CASETABLE", torture_casetable, 0},
10043 {"ERRMAPEXTRACT", run_error_map_extract, 0},
10044 {"PIPE_NUMBER", run_pipe_number, 0},
10045 {"TCON2", run_tcon2_test, 0},
10046 {"IOCTL", torture_ioctl_test, 0},
10047 {"CHKPATH", torture_chkpath_test, 0},
10048 {"FDSESS", run_fdsesstest, 0},
10049 { "EATEST", run_eatest, 0},
10050 { "SESSSETUP_BENCH", run_sesssetup_bench, 0},
10051 { "CHAIN1", run_chain1, 0},
10052 { "CHAIN2", run_chain2, 0},
10053 { "CHAIN3", run_chain3, 0},
10054 { "WINDOWS-WRITE", run_windows_write, 0},
10055 { "LARGE_READX", run_large_readx, 0},
10056 { "NTTRANS-CREATE", run_nttrans_create, 0},
10057 { "NTTRANS-FSCTL", run_nttrans_fsctl, 0},
10058 { "CLI_ECHO", run_cli_echo, 0},
10059 { "GETADDRINFO", run_getaddrinfo_send, 0},
10060 { "TLDAP", run_tldap },
10061 { "STREAMERROR", run_streamerror },
10062 { "NOTIFY-BENCH", run_notify_bench },
10063 { "NOTIFY-BENCH2", run_notify_bench2 },
10064 { "NOTIFY-BENCH3", run_notify_bench3 },
10065 { "BAD-NBT-SESSION", run_bad_nbt_session },
10066 { "SMB-ANY-CONNECT", run_smb_any_connect },
10067 { "NOTIFY-ONLINE", run_notify_online },
10068 { "SMB2-BASIC", run_smb2_basic },
10069 { "SMB2-NEGPROT", run_smb2_negprot },
10070 { "SMB2-SESSION-RECONNECT", run_smb2_session_reconnect },
10071 { "SMB2-TCON-DEPENDENCE", run_smb2_tcon_dependence },
10072 { "SMB2-MULTI-CHANNEL", run_smb2_multi_channel },
10073 { "SMB2-SESSION-REAUTH", run_smb2_session_reauth },
10074 { "CLEANUP1", run_cleanup1 },
10075 { "CLEANUP2", run_cleanup2 },
10076 { "CLEANUP3", run_cleanup3 },
10077 { "CLEANUP4", run_cleanup4 },
10078 { "OPLOCK-CANCEL", run_oplock_cancel },
10079 { "LOCAL-SUBSTITUTE", run_local_substitute, 0},
10080 { "LOCAL-GENCACHE", run_local_gencache, 0},
10081 { "LOCAL-TALLOC-DICT", run_local_talloc_dict, 0},
10082 { "LOCAL-DBWRAP-WATCH1", run_dbwrap_watch1, 0 },
10083 { "LOCAL-MESSAGING-READ1", run_messaging_read1, 0 },
10084 { "LOCAL-MESSAGING-READ2", run_messaging_read2, 0 },
10085 { "LOCAL-MESSAGING-READ3", run_messaging_read3, 0 },
10086 { "LOCAL-MESSAGING-READ4", run_messaging_read4, 0 },
10087 { "LOCAL-MESSAGING-FDPASS1", run_messaging_fdpass1, 0 },
10088 { "LOCAL-MESSAGING-FDPASS2", run_messaging_fdpass2, 0 },
10089 { "LOCAL-MESSAGING-FDPASS2a", run_messaging_fdpass2a, 0 },
10090 { "LOCAL-MESSAGING-FDPASS2b", run_messaging_fdpass2b, 0 },
10091 { "LOCAL-BASE64", run_local_base64, 0},
10092 { "LOCAL-RBTREE", run_local_rbtree, 0},
10093 { "LOCAL-MEMCACHE", run_local_memcache, 0},
10094 { "LOCAL-STREAM-NAME", run_local_stream_name, 0},
10095 { "WBCLIENT-MULTI-PING", run_wbclient_multi_ping, 0},
10096 { "LOCAL-string_to_sid", run_local_string_to_sid, 0},
10097 { "LOCAL-sid_to_string", run_local_sid_to_string, 0},
10098 { "LOCAL-binary_to_sid", run_local_binary_to_sid, 0},
10099 { "LOCAL-DBTRANS", run_local_dbtrans, 0},
10100 { "LOCAL-TEVENT-SELECT", run_local_tevent_select, 0},
10101 { "LOCAL-CONVERT-STRING", run_local_convert_string, 0},
10102 { "LOCAL-CONV-AUTH-INFO", run_local_conv_auth_info, 0},
10103 { "LOCAL-sprintf_append", run_local_sprintf_append, 0},
10104 { "LOCAL-hex_encode_buf", run_local_hex_encode_buf, 0},
10105 { "LOCAL-IDMAP-TDB-COMMON", run_idmap_tdb_common_test, 0},
10106 { "LOCAL-remove_duplicate_addrs2", run_local_remove_duplicate_addrs2, 0},
10107 { "local-tdb-opener", run_local_tdb_opener, 0 },
10108 { "local-tdb-writer", run_local_tdb_writer, 0 },
10109 { "LOCAL-DBWRAP-CTDB", run_local_dbwrap_ctdb, 0 },
10110 { "LOCAL-BENCH-PTHREADPOOL", run_bench_pthreadpool, 0 },
10111 { "qpathinfo-bufsize", run_qpathinfo_bufsize, 0 },
10115 * dummy function to satisfy linker dependency
10117 struct tevent_context *winbind_event_context(void);
10118 struct tevent_context *winbind_event_context(void)
10123 /****************************************************************************
10124 run a specified test or "ALL"
10125 ****************************************************************************/
10126 static bool run_test(const char *name)
10129 bool result = True;
10130 bool found = False;
10133 if (strequal(name,"ALL")) {
10134 for (i=0;torture_ops[i].name;i++) {
10135 run_test(torture_ops[i].name);
10140 for (i=0;torture_ops[i].name;i++) {
10141 fstr_sprintf(randomfname, "\\XX%x",
10142 (unsigned)random());
10144 if (strequal(name, torture_ops[i].name)) {
10146 printf("Running %s\n", name);
10147 if (torture_ops[i].flags & FLAG_MULTIPROC) {
10148 t = create_procs(torture_ops[i].fn, &result);
10151 printf("TEST %s FAILED!\n", name);
10154 struct timeval start;
10155 start = timeval_current();
10156 if (!torture_ops[i].fn(0)) {
10158 printf("TEST %s FAILED!\n", name);
10160 t = timeval_elapsed(&start);
10162 printf("%s took %g secs\n\n", name, t);
10167 printf("Did not find a test named %s\n", name);
10175 static void usage(void)
10179 printf("WARNING samba4 test suite is much more complete nowadays.\n");
10180 printf("Please use samba4 torture.\n\n");
10182 printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
10184 printf("\t-d debuglevel\n");
10185 printf("\t-U user%%pass\n");
10186 printf("\t-k use kerberos\n");
10187 printf("\t-N numprocs\n");
10188 printf("\t-n my_netbios_name\n");
10189 printf("\t-W workgroup\n");
10190 printf("\t-o num_operations\n");
10191 printf("\t-O socket_options\n");
10192 printf("\t-m maximum protocol\n");
10193 printf("\t-L use oplocks\n");
10194 printf("\t-c CLIENT.TXT specify client load file for NBENCH\n");
10195 printf("\t-A showall\n");
10196 printf("\t-p port\n");
10197 printf("\t-s seed\n");
10198 printf("\t-b unclist_filename specify multiple shares for multiple connections\n");
10199 printf("\t-f filename filename to test\n");
10200 printf("\t-e encrypt\n");
10203 printf("tests are:");
10204 for (i=0;torture_ops[i].name;i++) {
10205 printf(" %s", torture_ops[i].name);
10209 printf("default test is ALL\n");
10214 /****************************************************************************
10216 ****************************************************************************/
10217 int main(int argc,char *argv[])
10223 bool correct = True;
10224 TALLOC_CTX *frame = talloc_stackframe();
10225 int seed = time(NULL);
10227 #ifdef HAVE_SETBUFFER
10228 setbuffer(stdout, NULL, 0);
10231 setup_logging("smbtorture", DEBUG_STDOUT);
10236 if (is_default_dyn_CONFIGFILE()) {
10237 if(getenv("SMB_CONF_PATH")) {
10238 set_dyn_CONFIGFILE(getenv("SMB_CONF_PATH"));
10241 lp_load_global(get_dyn_CONFIGFILE());
10248 for(p = argv[1]; *p; p++)
10252 if (strncmp(argv[1], "//", 2)) {
10256 fstrcpy(host, &argv[1][2]);
10257 p = strchr_m(&host[2],'/');
10262 fstrcpy(share, p+1);
10264 fstrcpy(myname, get_myname(talloc_tos()));
10266 fprintf(stderr, "Failed to get my hostname.\n");
10270 if (*username == 0 && getenv("LOGNAME")) {
10271 fstrcpy(username,getenv("LOGNAME"));
10277 fstrcpy(workgroup, lp_workgroup());
10279 while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ll:d:Aec:ks:b:B:f:"))
10283 port_to_use = atoi(optarg);
10286 seed = atoi(optarg);
10289 fstrcpy(workgroup,optarg);
10292 lp_set_cmdline("client max protocol", optarg);
10295 torture_nprocs = atoi(optarg);
10298 torture_numops = atoi(optarg);
10301 lp_set_cmdline("log level", optarg);
10307 use_oplocks = True;
10310 local_path = optarg;
10313 torture_showall = True;
10316 fstrcpy(myname, optarg);
10319 client_txt = optarg;
10326 use_kerberos = True;
10328 d_printf("No kerberos support compiled in\n");
10334 fstrcpy(username,optarg);
10335 p = strchr_m(username,'%');
10338 fstrcpy(password, p+1);
10343 fstrcpy(multishare_conn_fname, optarg);
10344 use_multishare_conn = True;
10347 torture_blocksize = atoi(optarg);
10350 test_filename = SMB_STRDUP(optarg);
10353 printf("Unknown option %c (%d)\n", (char)opt, opt);
10358 d_printf("using seed %d\n", seed);
10362 if(use_kerberos && !gotuser) gotpass = True;
10365 char pwd[256] = {0};
10368 rc = samba_getpass("Password:", pwd, sizeof(pwd), false, false);
10370 fstrcpy(password, pwd);
10375 printf("host=%s share=%s user=%s myname=%s\n",
10376 host, share, username, myname);
10378 if (argc == optind) {
10379 correct = run_test("ALL");
10381 for (i=optind;i<argc;i++) {
10382 if (!run_test(argv[i])) {
10388 TALLOC_FREE(frame);