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"
30 #include "nsswitch/winbind_client.h"
32 #include "talloc_dict.h"
33 #include "async_smb.h"
34 #include "libsmb/libsmb.h"
35 #include "libsmb/clirap.h"
37 #include "libsmb/nmblib.h"
38 #include "../lib/util/tevent_ntstatus.h"
40 #include "libsmb/read_smb.h"
45 fstring host
, workgroup
, share
, password
, username
, myname
;
46 static int max_protocol
= PROTOCOL_NT1
;
47 static const char *sockops
="TCP_NODELAY";
49 static int port_to_use
=0;
50 int torture_numops
=100;
51 int torture_blocksize
=1024*1024;
52 static int procnum
; /* records process count number when forking */
53 static struct cli_state
*current_cli
;
54 static fstring randomfname
;
55 static bool use_oplocks
;
56 static bool use_level_II_oplocks
;
57 static const char *client_txt
= "client_oplocks.txt";
58 static bool use_kerberos
;
59 static fstring multishare_conn_fname
;
60 static bool use_multishare_conn
= False
;
61 static bool do_encrypt
;
62 static const char *local_path
= NULL
;
63 static int signing_state
= Undefined
;
66 bool torture_showall
= False
;
68 static double create_procs(bool (*fn
)(int), bool *result
);
71 /* return a pointer to a anonymous shared memory segment of size "size"
72 which will persist across fork() but will disappear when all processes
75 The memory is not zeroed
77 This function uses system5 shared memory. It takes advantage of a property
78 that the memory is not destroyed if it is attached when the id is removed
80 void *shm_setup(int size
)
86 shmid
= shm_open("private", O_RDWR
| O_CREAT
| O_EXCL
, S_IRUSR
| S_IWUSR
);
88 printf("can't get shared memory\n");
91 shm_unlink("private");
92 if (ftruncate(shmid
, size
) == -1) {
93 printf("can't set shared memory size\n");
96 ret
= mmap(0, size
, PROT_READ
| PROT_WRITE
, MAP_SHARED
, shmid
, 0);
97 if (ret
== MAP_FAILED
) {
98 printf("can't map shared memory\n");
102 shmid
= shmget(IPC_PRIVATE
, size
, S_IRUSR
| S_IWUSR
);
104 printf("can't get shared memory\n");
107 ret
= (void *)shmat(shmid
, 0, 0);
108 if (!ret
|| ret
== (void *)-1) {
109 printf("can't attach to shared memory\n");
112 /* the following releases the ipc, but note that this process
113 and all its children will still have access to the memory, its
114 just that the shmid is no longer valid for other shm calls. This
115 means we don't leave behind lots of shm segments after we exit
117 See Stevens "advanced programming in unix env" for details
119 shmctl(shmid
, IPC_RMID
, 0);
125 /********************************************************************
126 Ensure a connection is encrypted.
127 ********************************************************************/
129 static bool force_cli_encryption(struct cli_state
*c
,
130 const char *sharename
)
133 uint32 caplow
, caphigh
;
136 if (!SERVER_HAS_UNIX_CIFS(c
)) {
137 d_printf("Encryption required and "
138 "server that doesn't support "
139 "UNIX extensions - failing connect\n");
143 status
= cli_unix_extensions_version(c
, &major
, &minor
, &caplow
,
145 if (!NT_STATUS_IS_OK(status
)) {
146 d_printf("Encryption required and "
147 "can't get UNIX CIFS extensions "
148 "version from server: %s\n", nt_errstr(status
));
152 if (!(caplow
& CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
)) {
153 d_printf("Encryption required and "
154 "share %s doesn't support "
155 "encryption.\n", sharename
);
159 if (c
->use_kerberos
) {
160 status
= cli_gss_smb_encryption_start(c
);
162 status
= cli_raw_ntlm_smb_encryption_start(c
,
168 if (!NT_STATUS_IS_OK(status
)) {
169 d_printf("Encryption required and "
170 "setup failed with error %s.\n",
179 static struct cli_state
*open_nbt_connection(void)
184 status
= cli_connect_nb(host
, NULL
, port_to_use
, 0x20, myname
,
186 if (!NT_STATUS_IS_OK(status
)) {
187 printf("Failed to connect with %s. Error %s\n", host
, nt_errstr(status
) );
191 c
->use_kerberos
= use_kerberos
;
193 c
->timeout
= 120000; /* set a really long timeout (2 minutes) */
194 if (use_oplocks
) c
->use_oplocks
= True
;
195 if (use_level_II_oplocks
) c
->use_level_II_oplocks
= True
;
200 /****************************************************************************
201 Send a corrupt session request. See rfc1002.txt 4.3 and 4.3.2.
202 ****************************************************************************/
204 static bool cli_bad_session_request(int fd
,
205 struct nmb_name
*calling
, struct nmb_name
*called
)
214 uint8_t message_type
;
217 frame
= talloc_stackframe();
219 iov
[0].iov_base
= len_buf
;
220 iov
[0].iov_len
= sizeof(len_buf
);
222 /* put in the destination name */
224 iov
[1].iov_base
= name_mangle(talloc_tos(), called
->name
,
226 if (iov
[1].iov_base
== NULL
) {
229 iov
[1].iov_len
= name_len((unsigned char *)iov
[1].iov_base
,
230 talloc_get_size(iov
[1].iov_base
));
234 iov
[2].iov_base
= name_mangle(talloc_tos(), calling
->name
,
236 if (iov
[2].iov_base
== NULL
) {
239 iov
[2].iov_len
= name_len((unsigned char *)iov
[2].iov_base
,
240 talloc_get_size(iov
[2].iov_base
));
242 /* Deliberately corrupt the name len (first byte) */
243 *((uint8_t *)iov
[2].iov_base
) = 100;
245 /* send a session request (RFC 1002) */
246 /* setup the packet length
247 * Remove four bytes from the length count, since the length
248 * field in the NBT Session Service header counts the number
249 * of bytes which follow. The cli_send_smb() function knows
250 * about this and accounts for those four bytes.
254 _smb_setlen(len_buf
, iov
[1].iov_len
+ iov
[2].iov_len
);
255 SCVAL(len_buf
,0,0x81);
257 len
= write_data_iov(fd
, iov
, 3);
261 len
= read_smb(fd
, talloc_tos(), &inbuf
, &err
);
267 message_type
= CVAL(inbuf
, 0);
268 if (message_type
!= 0x83) {
269 d_fprintf(stderr
, "Expected msg type 0x83, got 0x%2.2x\n",
274 if (smb_len(inbuf
) != 1) {
275 d_fprintf(stderr
, "Expected smb_len 1, got %d\n",
276 (int)smb_len(inbuf
));
280 error
= CVAL(inbuf
, 4);
282 d_fprintf(stderr
, "Expected error 0x82, got %d\n",
293 /* Insert a NULL at the first separator of the given path and return a pointer
294 * to the remainder of the string.
297 terminate_path_at_separator(char * path
)
305 if ((p
= strchr_m(path
, '/'))) {
310 if ((p
= strchr_m(path
, '\\'))) {
320 parse a //server/share type UNC name
322 bool smbcli_parse_unc(const char *unc_name
, TALLOC_CTX
*mem_ctx
,
323 char **hostname
, char **sharename
)
327 *hostname
= *sharename
= NULL
;
329 if (strncmp(unc_name
, "\\\\", 2) &&
330 strncmp(unc_name
, "//", 2)) {
334 *hostname
= talloc_strdup(mem_ctx
, &unc_name
[2]);
335 p
= terminate_path_at_separator(*hostname
);
338 *sharename
= talloc_strdup(mem_ctx
, p
);
339 terminate_path_at_separator(*sharename
);
342 if (*hostname
&& *sharename
) {
346 TALLOC_FREE(*hostname
);
347 TALLOC_FREE(*sharename
);
351 static bool torture_open_connection_share(struct cli_state
**c
,
352 const char *hostname
,
353 const char *sharename
)
359 flags
|= CLI_FULL_CONNECTION_USE_KERBEROS
;
361 flags
|= CLI_FULL_CONNECTION_OPLOCKS
;
362 if (use_level_II_oplocks
)
363 flags
|= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS
;
365 status
= cli_full_connection(c
, myname
,
366 hostname
, NULL
, port_to_use
,
369 password
, flags
, signing_state
);
370 if (!NT_STATUS_IS_OK(status
)) {
371 printf("failed to open share connection: //%s/%s port:%d - %s\n",
372 hostname
, sharename
, port_to_use
, nt_errstr(status
));
376 (*c
)->timeout
= 120000; /* set a really long timeout (2 minutes) */
379 return force_cli_encryption(*c
,
385 bool torture_open_connection(struct cli_state
**c
, int conn_index
)
387 char **unc_list
= NULL
;
388 int num_unc_names
= 0;
391 if (use_multishare_conn
==True
) {
393 unc_list
= file_lines_load(multishare_conn_fname
, &num_unc_names
, 0, NULL
);
394 if (!unc_list
|| num_unc_names
<= 0) {
395 printf("Failed to load unc names list from '%s'\n", multishare_conn_fname
);
399 if (!smbcli_parse_unc(unc_list
[conn_index
% num_unc_names
],
401 printf("Failed to parse UNC name %s\n",
402 unc_list
[conn_index
% num_unc_names
]);
403 TALLOC_FREE(unc_list
);
407 result
= torture_open_connection_share(c
, h
, s
);
409 /* h, s were copied earlier */
410 TALLOC_FREE(unc_list
);
414 return torture_open_connection_share(c
, host
, share
);
417 bool torture_init_connection(struct cli_state
**pcli
)
419 struct cli_state
*cli
;
421 cli
= open_nbt_connection();
430 bool torture_cli_session_setup2(struct cli_state
*cli
, uint16
*new_vuid
)
432 uint16_t old_vuid
= cli_state_get_uid(cli
);
433 fstring old_user_name
;
434 size_t passlen
= strlen(password
);
438 fstrcpy(old_user_name
, cli
->user_name
);
439 cli_state_set_uid(cli
, 0);
440 ret
= NT_STATUS_IS_OK(cli_session_setup(cli
, username
,
444 *new_vuid
= cli_state_get_uid(cli
);
445 cli_state_set_uid(cli
, old_vuid
);
446 status
= cli_set_username(cli
, old_user_name
);
447 if (!NT_STATUS_IS_OK(status
)) {
454 bool torture_close_connection(struct cli_state
*c
)
459 status
= cli_tdis(c
);
460 if (!NT_STATUS_IS_OK(status
)) {
461 printf("tdis failed (%s)\n", nt_errstr(status
));
471 /* check if the server produced the expected dos or nt error code */
472 static bool check_both_error(int line
, NTSTATUS status
,
473 uint8 eclass
, uint32 ecode
, NTSTATUS nterr
)
475 if (NT_STATUS_IS_DOS(status
)) {
479 /* Check DOS error */
480 cclass
= NT_STATUS_DOS_CLASS(status
);
481 num
= NT_STATUS_DOS_CODE(status
);
483 if (eclass
!= cclass
|| ecode
!= num
) {
484 printf("unexpected error code class=%d code=%d\n",
485 (int)cclass
, (int)num
);
486 printf(" expected %d/%d %s (line=%d)\n",
487 (int)eclass
, (int)ecode
, nt_errstr(nterr
), line
);
492 if (!NT_STATUS_EQUAL(nterr
, status
)) {
493 printf("unexpected error code %s\n",
495 printf(" expected %s (line=%d)\n",
496 nt_errstr(nterr
), line
);
505 /* check if the server produced the expected error code */
506 static bool check_error(int line
, struct cli_state
*c
,
507 uint8 eclass
, uint32 ecode
, NTSTATUS nterr
)
509 if (cli_is_dos_error(c
)) {
513 /* Check DOS error */
515 cli_dos_error(c
, &cclass
, &num
);
517 if (eclass
!= cclass
|| ecode
!= num
) {
518 printf("unexpected error code class=%d code=%d\n",
519 (int)cclass
, (int)num
);
520 printf(" expected %d/%d %s (line=%d)\n",
521 (int)eclass
, (int)ecode
, nt_errstr(nterr
), line
);
530 status
= cli_nt_error(c
);
532 if (NT_STATUS_V(nterr
) != NT_STATUS_V(status
)) {
533 printf("unexpected error code %s\n", nt_errstr(status
));
534 printf(" expected %s (line=%d)\n", nt_errstr(nterr
), line
);
543 static bool wait_lock(struct cli_state
*c
, int fnum
, uint32 offset
, uint32 len
)
547 status
= cli_lock32(c
, fnum
, offset
, len
, -1, WRITE_LOCK
);
549 while (!NT_STATUS_IS_OK(status
)) {
550 if (!check_both_error(__LINE__
, status
, ERRDOS
,
551 ERRlock
, NT_STATUS_LOCK_NOT_GRANTED
)) {
555 status
= cli_lock32(c
, fnum
, offset
, len
, -1, WRITE_LOCK
);
562 static bool rw_torture(struct cli_state
*c
)
564 const char *lockfname
= "\\torture.lck";
568 pid_t pid2
, pid
= getpid();
575 memset(buf
, '\0', sizeof(buf
));
577 status
= cli_open(c
, lockfname
, O_RDWR
| O_CREAT
| O_EXCL
,
579 if (!NT_STATUS_IS_OK(status
)) {
580 status
= cli_open(c
, lockfname
, O_RDWR
, DENY_NONE
, &fnum2
);
582 if (!NT_STATUS_IS_OK(status
)) {
583 printf("open of %s failed (%s)\n",
584 lockfname
, nt_errstr(status
));
588 for (i
=0;i
<torture_numops
;i
++) {
589 unsigned n
= (unsigned)sys_random()%10;
592 printf("%d\r", i
); fflush(stdout
);
594 slprintf(fname
, sizeof(fstring
) - 1, "\\torture.%u", n
);
596 if (!wait_lock(c
, fnum2
, n
*sizeof(int), sizeof(int))) {
600 status
= cli_open(c
, fname
, O_RDWR
| O_CREAT
| O_TRUNC
,
602 if (!NT_STATUS_IS_OK(status
)) {
603 printf("open failed (%s)\n", nt_errstr(status
));
608 status
= cli_writeall(c
, fnum
, 0, (uint8_t *)&pid
, 0,
610 if (!NT_STATUS_IS_OK(status
)) {
611 printf("write failed (%s)\n", nt_errstr(status
));
616 status
= cli_writeall(c
, fnum
, 0, (uint8_t *)buf
,
617 sizeof(pid
)+(j
*sizeof(buf
)),
619 if (!NT_STATUS_IS_OK(status
)) {
620 printf("write failed (%s)\n",
628 status
= cli_read(c
, fnum
, (char *)&pid2
, 0, sizeof(pid
),
630 if (!NT_STATUS_IS_OK(status
)) {
631 printf("read failed (%s)\n", nt_errstr(status
));
633 } else if (nread
!= sizeof(pid
)) {
634 printf("read/write compare failed: "
635 "recv %ld req %ld\n", (unsigned long)nread
,
636 (unsigned long)sizeof(pid
));
641 printf("data corruption!\n");
645 status
= cli_close(c
, fnum
);
646 if (!NT_STATUS_IS_OK(status
)) {
647 printf("close failed (%s)\n", nt_errstr(status
));
651 status
= cli_unlink(c
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
652 if (!NT_STATUS_IS_OK(status
)) {
653 printf("unlink failed (%s)\n", nt_errstr(status
));
657 status
= cli_unlock(c
, fnum2
, n
*sizeof(int), sizeof(int));
658 if (!NT_STATUS_IS_OK(status
)) {
659 printf("unlock failed (%s)\n", nt_errstr(status
));
665 cli_unlink(c
, lockfname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
672 static bool run_torture(int dummy
)
674 struct cli_state
*cli
;
679 cli_sockopt(cli
, sockops
);
681 ret
= rw_torture(cli
);
683 if (!torture_close_connection(cli
)) {
690 static bool rw_torture3(struct cli_state
*c
, char *lockfname
)
692 uint16_t fnum
= (uint16_t)-1;
697 unsigned countprev
= 0;
700 NTSTATUS status
= NT_STATUS_OK
;
703 for (i
= 0; i
< sizeof(buf
); i
+= sizeof(uint32
))
705 SIVAL(buf
, i
, sys_random());
712 FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
713 if (!NT_STATUS_IS_OK(status
)) {
714 printf("unlink failed (%s) (normal, this file should "
715 "not exist)\n", nt_errstr(status
));
718 status
= cli_open(c
, lockfname
, O_RDWR
| O_CREAT
| O_EXCL
,
720 if (!NT_STATUS_IS_OK(status
)) {
721 printf("first open read/write of %s failed (%s)\n",
722 lockfname
, nt_errstr(status
));
728 for (i
= 0; i
< 500 && fnum
== (uint16_t)-1; i
++)
730 status
= cli_open(c
, lockfname
, O_RDONLY
,
732 if (!NT_STATUS_IS_OK(status
)) {
737 if (!NT_STATUS_IS_OK(status
)) {
738 printf("second open read-only of %s failed (%s)\n",
739 lockfname
, nt_errstr(status
));
745 for (count
= 0; count
< sizeof(buf
); count
+= sent
)
747 if (count
>= countprev
) {
748 printf("%d %8d\r", i
, count
);
751 countprev
+= (sizeof(buf
) / 20);
756 sent
= ((unsigned)sys_random()%(20))+ 1;
757 if (sent
> sizeof(buf
) - count
)
759 sent
= sizeof(buf
) - count
;
762 status
= cli_writeall(c
, fnum
, 0, (uint8_t *)buf
+count
,
764 if (!NT_STATUS_IS_OK(status
)) {
765 printf("write failed (%s)\n",
772 status
= cli_read(c
, fnum
, buf_rd
+count
, count
,
773 sizeof(buf
)-count
, &sent
);
774 if(!NT_STATUS_IS_OK(status
)) {
775 printf("read failed offset:%d size:%ld (%s)\n",
776 count
, (unsigned long)sizeof(buf
)-count
,
780 } else if (sent
> 0) {
781 if (memcmp(buf_rd
+count
, buf
+count
, sent
) != 0)
783 printf("read/write compare failed\n");
784 printf("offset: %d req %ld recvd %ld\n", count
, (unsigned long)sizeof(buf
)-count
, (unsigned long)sent
);
793 status
= cli_close(c
, fnum
);
794 if (!NT_STATUS_IS_OK(status
)) {
795 printf("close failed (%s)\n", nt_errstr(status
));
802 static bool rw_torture2(struct cli_state
*c1
, struct cli_state
*c2
)
804 const char *lockfname
= "\\torture2.lck";
814 status
= cli_unlink(c1
, lockfname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
815 if (!NT_STATUS_IS_OK(status
)) {
816 printf("unlink failed (%s) (normal, this file should not exist)\n", nt_errstr(status
));
819 status
= cli_open(c1
, lockfname
, O_RDWR
| O_CREAT
| O_EXCL
,
821 if (!NT_STATUS_IS_OK(status
)) {
822 printf("first open read/write of %s failed (%s)\n",
823 lockfname
, nt_errstr(status
));
827 status
= cli_open(c2
, lockfname
, O_RDONLY
, DENY_NONE
, &fnum2
);
828 if (!NT_STATUS_IS_OK(status
)) {
829 printf("second open read-only of %s failed (%s)\n",
830 lockfname
, nt_errstr(status
));
831 cli_close(c1
, fnum1
);
835 for (i
= 0; i
< torture_numops
; i
++)
837 size_t buf_size
= ((unsigned)sys_random()%(sizeof(buf
)-1))+ 1;
839 printf("%d\r", i
); fflush(stdout
);
842 generate_random_buffer((unsigned char *)buf
, buf_size
);
844 status
= cli_writeall(c1
, fnum1
, 0, (uint8_t *)buf
, 0,
846 if (!NT_STATUS_IS_OK(status
)) {
847 printf("write failed (%s)\n", nt_errstr(status
));
852 status
= cli_read(c2
, fnum2
, buf_rd
, 0, buf_size
, &bytes_read
);
853 if(!NT_STATUS_IS_OK(status
)) {
854 printf("read failed (%s)\n", nt_errstr(status
));
857 } else if (bytes_read
!= buf_size
) {
858 printf("read failed\n");
859 printf("read %ld, expected %ld\n",
860 (unsigned long)bytes_read
,
861 (unsigned long)buf_size
);
866 if (memcmp(buf_rd
, buf
, buf_size
) != 0)
868 printf("read/write compare failed\n");
874 status
= cli_close(c2
, fnum2
);
875 if (!NT_STATUS_IS_OK(status
)) {
876 printf("close failed (%s)\n", nt_errstr(status
));
880 status
= cli_close(c1
, fnum1
);
881 if (!NT_STATUS_IS_OK(status
)) {
882 printf("close failed (%s)\n", nt_errstr(status
));
886 status
= cli_unlink(c1
, lockfname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
887 if (!NT_STATUS_IS_OK(status
)) {
888 printf("unlink failed (%s)\n", nt_errstr(status
));
895 static bool run_readwritetest(int dummy
)
897 struct cli_state
*cli1
, *cli2
;
898 bool test1
, test2
= False
;
900 if (!torture_open_connection(&cli1
, 0) || !torture_open_connection(&cli2
, 1)) {
903 cli_sockopt(cli1
, sockops
);
904 cli_sockopt(cli2
, sockops
);
906 printf("starting readwritetest\n");
908 test1
= rw_torture2(cli1
, cli2
);
909 printf("Passed readwritetest v1: %s\n", BOOLSTR(test1
));
912 test2
= rw_torture2(cli1
, cli1
);
913 printf("Passed readwritetest v2: %s\n", BOOLSTR(test2
));
916 if (!torture_close_connection(cli1
)) {
920 if (!torture_close_connection(cli2
)) {
924 return (test1
&& test2
);
927 static bool run_readwritemulti(int dummy
)
929 struct cli_state
*cli
;
934 cli_sockopt(cli
, sockops
);
936 printf("run_readwritemulti: fname %s\n", randomfname
);
937 test
= rw_torture3(cli
, randomfname
);
939 if (!torture_close_connection(cli
)) {
946 static bool run_readwritelarge_internal(int max_xmit_k
)
948 static struct cli_state
*cli1
;
950 const char *lockfname
= "\\large.dat";
956 if (!torture_open_connection(&cli1
, 0)) {
959 cli_sockopt(cli1
, sockops
);
960 memset(buf
,'\0',sizeof(buf
));
962 cli1
->max_xmit
= max_xmit_k
*1024;
964 if (signing_state
== Required
) {
965 /* Horrible cheat to force
966 multiple signed outstanding
967 packets against a Samba server.
969 cli1
->is_samba
= false;
972 printf("starting readwritelarge_internal\n");
974 cli_unlink(cli1
, lockfname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
976 status
= cli_open(cli1
, lockfname
, O_RDWR
| O_CREAT
| O_EXCL
,
978 if (!NT_STATUS_IS_OK(status
)) {
979 printf("open read/write of %s failed (%s)\n", lockfname
, nt_errstr(status
));
983 cli_writeall(cli1
, fnum1
, 0, (uint8_t *)buf
, 0, sizeof(buf
), NULL
);
985 status
= cli_qfileinfo_basic(cli1
, fnum1
, NULL
, &fsize
, NULL
, NULL
,
987 if (!NT_STATUS_IS_OK(status
)) {
988 printf("qfileinfo failed (%s)\n", nt_errstr(status
));
992 if (fsize
== sizeof(buf
))
993 printf("readwritelarge_internal test 1 succeeded (size = %lx)\n",
994 (unsigned long)fsize
);
996 printf("readwritelarge_internal test 1 failed (size = %lx)\n",
997 (unsigned long)fsize
);
1001 status
= cli_close(cli1
, fnum1
);
1002 if (!NT_STATUS_IS_OK(status
)) {
1003 printf("close failed (%s)\n", nt_errstr(status
));
1007 status
= cli_unlink(cli1
, lockfname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
1008 if (!NT_STATUS_IS_OK(status
)) {
1009 printf("unlink failed (%s)\n", nt_errstr(status
));
1013 status
= cli_open(cli1
, lockfname
, O_RDWR
| O_CREAT
| O_EXCL
,
1015 if (!NT_STATUS_IS_OK(status
)) {
1016 printf("open read/write of %s failed (%s)\n", lockfname
, nt_errstr(status
));
1020 cli1
->max_xmit
= 4*1024;
1022 cli_smbwrite(cli1
, fnum1
, buf
, 0, sizeof(buf
), NULL
);
1024 status
= cli_qfileinfo_basic(cli1
, fnum1
, NULL
, &fsize
, NULL
, NULL
,
1026 if (!NT_STATUS_IS_OK(status
)) {
1027 printf("qfileinfo failed (%s)\n", nt_errstr(status
));
1031 if (fsize
== sizeof(buf
))
1032 printf("readwritelarge_internal test 2 succeeded (size = %lx)\n",
1033 (unsigned long)fsize
);
1035 printf("readwritelarge_internal test 2 failed (size = %lx)\n",
1036 (unsigned long)fsize
);
1041 /* ToDo - set allocation. JRA */
1042 if(!cli_set_allocation_size(cli1
, fnum1
, 0)) {
1043 printf("set allocation size to zero failed (%s)\n", cli_errstr(&cli1
));
1046 if (!cli_qfileinfo_basic(cli1
, fnum1
, NULL
, &fsize
, NULL
, NULL
, NULL
,
1048 printf("qfileinfo failed (%s)\n", cli_errstr(cli1
));
1052 printf("readwritelarge test 3 (truncate test) succeeded (size = %x)\n", fsize
);
1055 status
= cli_close(cli1
, fnum1
);
1056 if (!NT_STATUS_IS_OK(status
)) {
1057 printf("close failed (%s)\n", nt_errstr(status
));
1061 if (!torture_close_connection(cli1
)) {
1067 static bool run_readwritelarge(int dummy
)
1069 return run_readwritelarge_internal(128);
1072 static bool run_readwritelarge_signtest(int dummy
)
1075 signing_state
= Required
;
1076 ret
= run_readwritelarge_internal(2);
1077 signing_state
= Undefined
;
1084 #define ival(s) strtol(s, NULL, 0)
1086 /* run a test that simulates an approximate netbench client load */
1087 static bool run_netbench(int client
)
1089 struct cli_state
*cli
;
1094 const char *params
[20];
1095 bool correct
= True
;
1101 cli_sockopt(cli
, sockops
);
1105 slprintf(cname
,sizeof(cname
)-1, "client%d", client
);
1107 f
= fopen(client_txt
, "r");
1114 while (fgets(line
, sizeof(line
)-1, f
)) {
1118 line
[strlen(line
)-1] = 0;
1120 /* printf("[%d] %s\n", line_count, line); */
1122 all_string_sub(line
,"client1", cname
, sizeof(line
));
1124 /* parse the command parameters */
1125 params
[0] = strtok_r(line
, " ", &saveptr
);
1127 while (params
[i
]) params
[++i
] = strtok_r(NULL
, " ", &saveptr
);
1131 if (i
< 2) continue;
1133 if (!strncmp(params
[0],"SMB", 3)) {
1134 printf("ERROR: You are using a dbench 1 load file\n");
1138 if (!strcmp(params
[0],"NTCreateX")) {
1139 nb_createx(params
[1], ival(params
[2]), ival(params
[3]),
1141 } else if (!strcmp(params
[0],"Close")) {
1142 nb_close(ival(params
[1]));
1143 } else if (!strcmp(params
[0],"Rename")) {
1144 nb_rename(params
[1], params
[2]);
1145 } else if (!strcmp(params
[0],"Unlink")) {
1146 nb_unlink(params
[1]);
1147 } else if (!strcmp(params
[0],"Deltree")) {
1148 nb_deltree(params
[1]);
1149 } else if (!strcmp(params
[0],"Rmdir")) {
1150 nb_rmdir(params
[1]);
1151 } else if (!strcmp(params
[0],"QUERY_PATH_INFORMATION")) {
1152 nb_qpathinfo(params
[1]);
1153 } else if (!strcmp(params
[0],"QUERY_FILE_INFORMATION")) {
1154 nb_qfileinfo(ival(params
[1]));
1155 } else if (!strcmp(params
[0],"QUERY_FS_INFORMATION")) {
1156 nb_qfsinfo(ival(params
[1]));
1157 } else if (!strcmp(params
[0],"FIND_FIRST")) {
1158 nb_findfirst(params
[1]);
1159 } else if (!strcmp(params
[0],"WriteX")) {
1160 nb_writex(ival(params
[1]),
1161 ival(params
[2]), ival(params
[3]), ival(params
[4]));
1162 } else if (!strcmp(params
[0],"ReadX")) {
1163 nb_readx(ival(params
[1]),
1164 ival(params
[2]), ival(params
[3]), ival(params
[4]));
1165 } else if (!strcmp(params
[0],"Flush")) {
1166 nb_flush(ival(params
[1]));
1168 printf("Unknown operation %s\n", params
[0]);
1176 if (!torture_close_connection(cli
)) {
1184 /* run a test that simulates an approximate netbench client load */
1185 static bool run_nbench(int dummy
)
1188 bool correct
= True
;
1194 signal(SIGALRM
, nb_alarm
);
1196 t
= create_procs(run_netbench
, &correct
);
1199 printf("\nThroughput %g MB/sec\n",
1200 1.0e-6 * nbio_total() / t
);
1206 This test checks for two things:
1208 1) correct support for retaining locks over a close (ie. the server
1209 must not use posix semantics)
1210 2) support for lock timeouts
1212 static bool run_locktest1(int dummy
)
1214 struct cli_state
*cli1
, *cli2
;
1215 const char *fname
= "\\lockt1.lck";
1216 uint16_t fnum1
, fnum2
, fnum3
;
1218 unsigned lock_timeout
;
1221 if (!torture_open_connection(&cli1
, 0) || !torture_open_connection(&cli2
, 1)) {
1224 cli_sockopt(cli1
, sockops
);
1225 cli_sockopt(cli2
, sockops
);
1227 printf("starting locktest1\n");
1229 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
1231 status
= cli_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
,
1233 if (!NT_STATUS_IS_OK(status
)) {
1234 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
1238 status
= cli_open(cli1
, fname
, O_RDWR
, DENY_NONE
, &fnum2
);
1239 if (!NT_STATUS_IS_OK(status
)) {
1240 printf("open2 of %s failed (%s)\n", fname
, nt_errstr(status
));
1244 status
= cli_open(cli2
, fname
, O_RDWR
, DENY_NONE
, &fnum3
);
1245 if (!NT_STATUS_IS_OK(status
)) {
1246 printf("open3 of %s failed (%s)\n", fname
, nt_errstr(status
));
1250 status
= cli_lock32(cli1
, fnum1
, 0, 4, 0, WRITE_LOCK
);
1251 if (!NT_STATUS_IS_OK(status
)) {
1252 printf("lock1 failed (%s)\n", nt_errstr(status
));
1256 status
= cli_lock32(cli2
, fnum3
, 0, 4, 0, WRITE_LOCK
);
1257 if (NT_STATUS_IS_OK(status
)) {
1258 printf("lock2 succeeded! This is a locking bug\n");
1261 if (!check_both_error(__LINE__
, status
, ERRDOS
, ERRlock
,
1262 NT_STATUS_LOCK_NOT_GRANTED
)) {
1267 lock_timeout
= (1 + (random() % 20));
1268 printf("Testing lock timeout with timeout=%u\n", lock_timeout
);
1270 status
= cli_lock32(cli2
, fnum3
, 0, 4, lock_timeout
* 1000, WRITE_LOCK
);
1271 if (NT_STATUS_IS_OK(status
)) {
1272 printf("lock3 succeeded! This is a locking bug\n");
1275 if (!check_both_error(__LINE__
, status
, ERRDOS
, ERRlock
,
1276 NT_STATUS_FILE_LOCK_CONFLICT
)) {
1282 if (ABS(t2
- t1
) < lock_timeout
-1) {
1283 printf("error: This server appears not to support timed lock requests\n");
1286 printf("server slept for %u seconds for a %u second timeout\n",
1287 (unsigned int)(t2
-t1
), lock_timeout
);
1289 status
= cli_close(cli1
, fnum2
);
1290 if (!NT_STATUS_IS_OK(status
)) {
1291 printf("close1 failed (%s)\n", nt_errstr(status
));
1295 status
= cli_lock32(cli2
, fnum3
, 0, 4, 0, WRITE_LOCK
);
1296 if (NT_STATUS_IS_OK(status
)) {
1297 printf("lock4 succeeded! This is a locking bug\n");
1300 if (!check_both_error(__LINE__
, status
, ERRDOS
, ERRlock
,
1301 NT_STATUS_FILE_LOCK_CONFLICT
)) {
1306 status
= cli_close(cli1
, fnum1
);
1307 if (!NT_STATUS_IS_OK(status
)) {
1308 printf("close2 failed (%s)\n", nt_errstr(status
));
1312 status
= cli_close(cli2
, fnum3
);
1313 if (!NT_STATUS_IS_OK(status
)) {
1314 printf("close3 failed (%s)\n", nt_errstr(status
));
1318 status
= cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
1319 if (!NT_STATUS_IS_OK(status
)) {
1320 printf("unlink failed (%s)\n", nt_errstr(status
));
1325 if (!torture_close_connection(cli1
)) {
1329 if (!torture_close_connection(cli2
)) {
1333 printf("Passed locktest1\n");
1338 this checks to see if a secondary tconx can use open files from an
1341 static bool run_tcon_test(int dummy
)
1343 static struct cli_state
*cli
;
1344 const char *fname
= "\\tcontest.tmp";
1346 uint16 cnum1
, cnum2
, cnum3
;
1347 uint16 vuid1
, vuid2
;
1352 memset(buf
, '\0', sizeof(buf
));
1354 if (!torture_open_connection(&cli
, 0)) {
1357 cli_sockopt(cli
, sockops
);
1359 printf("starting tcontest\n");
1361 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
1363 status
= cli_open(cli
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
, &fnum1
);
1364 if (!NT_STATUS_IS_OK(status
)) {
1365 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
1369 cnum1
= cli_state_get_tid(cli
);
1370 vuid1
= cli_state_get_uid(cli
);
1372 status
= cli_writeall(cli
, fnum1
, 0, (uint8_t *)buf
, 130, 4, NULL
);
1373 if (!NT_STATUS_IS_OK(status
)) {
1374 printf("initial write failed (%s)", nt_errstr(status
));
1378 status
= cli_tcon_andx(cli
, share
, "?????",
1379 password
, strlen(password
)+1);
1380 if (!NT_STATUS_IS_OK(status
)) {
1381 printf("%s refused 2nd tree connect (%s)\n", host
,
1387 cnum2
= cli_state_get_tid(cli
);
1388 cnum3
= MAX(cnum1
, cnum2
) + 1; /* any invalid number */
1389 vuid2
= cli_state_get_uid(cli
) + 1;
1391 /* try a write with the wrong tid */
1392 cli_state_set_tid(cli
, cnum2
);
1394 status
= cli_writeall(cli
, fnum1
, 0, (uint8_t *)buf
, 130, 4, NULL
);
1395 if (NT_STATUS_IS_OK(status
)) {
1396 printf("* server allows write with wrong TID\n");
1399 printf("server fails write with wrong TID : %s\n",
1404 /* try a write with an invalid tid */
1405 cli_state_set_tid(cli
, cnum3
);
1407 status
= cli_writeall(cli
, fnum1
, 0, (uint8_t *)buf
, 130, 4, NULL
);
1408 if (NT_STATUS_IS_OK(status
)) {
1409 printf("* server allows write with invalid TID\n");
1412 printf("server fails write with invalid TID : %s\n",
1416 /* try a write with an invalid vuid */
1417 cli_state_set_uid(cli
, vuid2
);
1418 cli_state_set_tid(cli
, cnum1
);
1420 status
= cli_writeall(cli
, fnum1
, 0, (uint8_t *)buf
, 130, 4, NULL
);
1421 if (NT_STATUS_IS_OK(status
)) {
1422 printf("* server allows write with invalid VUID\n");
1425 printf("server fails write with invalid VUID : %s\n",
1429 cli_state_set_tid(cli
, cnum1
);
1430 cli_state_set_uid(cli
, vuid1
);
1432 status
= cli_close(cli
, fnum1
);
1433 if (!NT_STATUS_IS_OK(status
)) {
1434 printf("close failed (%s)\n", nt_errstr(status
));
1438 cli_state_set_tid(cli
, cnum2
);
1440 status
= cli_tdis(cli
);
1441 if (!NT_STATUS_IS_OK(status
)) {
1442 printf("secondary tdis failed (%s)\n", nt_errstr(status
));
1446 cli_state_set_tid(cli
, cnum1
);
1448 if (!torture_close_connection(cli
)) {
1457 checks for old style tcon support
1459 static bool run_tcon2_test(int dummy
)
1461 static struct cli_state
*cli
;
1462 uint16 cnum
, max_xmit
;
1466 if (!torture_open_connection(&cli
, 0)) {
1469 cli_sockopt(cli
, sockops
);
1471 printf("starting tcon2 test\n");
1473 if (asprintf(&service
, "\\\\%s\\%s", host
, share
) == -1) {
1477 status
= cli_raw_tcon(cli
, service
, password
, "?????", &max_xmit
, &cnum
);
1481 if (!NT_STATUS_IS_OK(status
)) {
1482 printf("tcon2 failed : %s\n", nt_errstr(status
));
1484 printf("tcon OK : max_xmit=%d cnum=%d\n",
1485 (int)max_xmit
, (int)cnum
);
1488 if (!torture_close_connection(cli
)) {
1492 printf("Passed tcon2 test\n");
1496 static bool tcon_devtest(struct cli_state
*cli
,
1497 const char *myshare
, const char *devtype
,
1498 const char *return_devtype
,
1499 NTSTATUS expected_error
)
1504 status
= cli_tcon_andx(cli
, myshare
, devtype
,
1505 password
, strlen(password
)+1);
1507 if (NT_STATUS_IS_OK(expected_error
)) {
1508 if (NT_STATUS_IS_OK(status
)) {
1509 if (strcmp(cli
->dev
, return_devtype
) == 0) {
1512 printf("tconX to share %s with type %s "
1513 "succeeded but returned the wrong "
1514 "device type (got [%s] but should have got [%s])\n",
1515 myshare
, devtype
, cli
->dev
, return_devtype
);
1519 printf("tconX to share %s with type %s "
1520 "should have succeeded but failed\n",
1526 if (NT_STATUS_IS_OK(status
)) {
1527 printf("tconx to share %s with type %s "
1528 "should have failed but succeeded\n",
1532 if (NT_STATUS_EQUAL(cli_nt_error(cli
),
1536 printf("Returned unexpected error\n");
1545 checks for correct tconX support
1547 static bool run_tcon_devtype_test(int dummy
)
1549 static struct cli_state
*cli1
= NULL
;
1554 status
= cli_full_connection(&cli1
, myname
,
1555 host
, NULL
, port_to_use
,
1557 username
, workgroup
,
1558 password
, flags
, signing_state
);
1560 if (!NT_STATUS_IS_OK(status
)) {
1561 printf("could not open connection\n");
1565 if (!tcon_devtest(cli1
, "IPC$", "A:", NULL
, NT_STATUS_BAD_DEVICE_TYPE
))
1568 if (!tcon_devtest(cli1
, "IPC$", "?????", "IPC", NT_STATUS_OK
))
1571 if (!tcon_devtest(cli1
, "IPC$", "LPT:", NULL
, NT_STATUS_BAD_DEVICE_TYPE
))
1574 if (!tcon_devtest(cli1
, "IPC$", "IPC", "IPC", NT_STATUS_OK
))
1577 if (!tcon_devtest(cli1
, "IPC$", "FOOBA", NULL
, NT_STATUS_BAD_DEVICE_TYPE
))
1580 if (!tcon_devtest(cli1
, share
, "A:", "A:", NT_STATUS_OK
))
1583 if (!tcon_devtest(cli1
, share
, "?????", "A:", NT_STATUS_OK
))
1586 if (!tcon_devtest(cli1
, share
, "LPT:", NULL
, NT_STATUS_BAD_DEVICE_TYPE
))
1589 if (!tcon_devtest(cli1
, share
, "IPC", NULL
, NT_STATUS_BAD_DEVICE_TYPE
))
1592 if (!tcon_devtest(cli1
, share
, "FOOBA", NULL
, NT_STATUS_BAD_DEVICE_TYPE
))
1598 printf("Passed tcondevtest\n");
1605 This test checks that
1607 1) the server supports multiple locking contexts on the one SMB
1608 connection, distinguished by PID.
1610 2) the server correctly fails overlapping locks made by the same PID (this
1611 goes against POSIX behaviour, which is why it is tricky to implement)
1613 3) the server denies unlock requests by an incorrect client PID
1615 static bool run_locktest2(int dummy
)
1617 static struct cli_state
*cli
;
1618 const char *fname
= "\\lockt2.lck";
1619 uint16_t fnum1
, fnum2
, fnum3
;
1620 bool correct
= True
;
1623 if (!torture_open_connection(&cli
, 0)) {
1627 cli_sockopt(cli
, sockops
);
1629 printf("starting locktest2\n");
1631 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
1635 status
= cli_open(cli
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
, &fnum1
);
1636 if (!NT_STATUS_IS_OK(status
)) {
1637 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
1641 status
= cli_open(cli
, fname
, O_RDWR
, DENY_NONE
, &fnum2
);
1642 if (!NT_STATUS_IS_OK(status
)) {
1643 printf("open2 of %s failed (%s)\n", fname
, nt_errstr(status
));
1649 status
= cli_open(cli
, fname
, O_RDWR
, DENY_NONE
, &fnum3
);
1650 if (!NT_STATUS_IS_OK(status
)) {
1651 printf("open3 of %s failed (%s)\n", fname
, nt_errstr(status
));
1657 status
= cli_lock32(cli
, fnum1
, 0, 4, 0, WRITE_LOCK
);
1658 if (!NT_STATUS_IS_OK(status
)) {
1659 printf("lock1 failed (%s)\n", nt_errstr(status
));
1663 status
= cli_lock32(cli
, fnum1
, 0, 4, 0, WRITE_LOCK
);
1664 if (NT_STATUS_IS_OK(status
)) {
1665 printf("WRITE lock1 succeeded! This is a locking bug\n");
1668 if (!check_both_error(__LINE__
, status
, ERRDOS
, ERRlock
,
1669 NT_STATUS_LOCK_NOT_GRANTED
)) {
1674 status
= cli_lock32(cli
, fnum2
, 0, 4, 0, WRITE_LOCK
);
1675 if (NT_STATUS_IS_OK(status
)) {
1676 printf("WRITE lock2 succeeded! This is a locking bug\n");
1679 if (!check_both_error(__LINE__
, status
, ERRDOS
, ERRlock
,
1680 NT_STATUS_LOCK_NOT_GRANTED
)) {
1685 status
= cli_lock32(cli
, fnum2
, 0, 4, 0, READ_LOCK
);
1686 if (NT_STATUS_IS_OK(status
)) {
1687 printf("READ lock2 succeeded! This is a locking bug\n");
1690 if (!check_both_error(__LINE__
, status
, ERRDOS
, ERRlock
,
1691 NT_STATUS_FILE_LOCK_CONFLICT
)) {
1696 status
= cli_lock32(cli
, fnum1
, 100, 4, 0, WRITE_LOCK
);
1697 if (!NT_STATUS_IS_OK(status
)) {
1698 printf("lock at 100 failed (%s)\n", nt_errstr(status
));
1701 if (NT_STATUS_IS_OK(cli_unlock(cli
, fnum1
, 100, 4))) {
1702 printf("unlock at 100 succeeded! This is a locking bug\n");
1706 status
= cli_unlock(cli
, fnum1
, 0, 4);
1707 if (NT_STATUS_IS_OK(status
)) {
1708 printf("unlock1 succeeded! This is a locking bug\n");
1711 if (!check_both_error(__LINE__
, status
, ERRDOS
, ERRlock
,
1712 NT_STATUS_RANGE_NOT_LOCKED
)) {
1717 status
= cli_unlock(cli
, fnum1
, 0, 8);
1718 if (NT_STATUS_IS_OK(status
)) {
1719 printf("unlock2 succeeded! This is a locking bug\n");
1722 if (!check_both_error(__LINE__
, status
, ERRDOS
, ERRlock
,
1723 NT_STATUS_RANGE_NOT_LOCKED
)) {
1728 status
= cli_lock32(cli
, fnum3
, 0, 4, 0, WRITE_LOCK
);
1729 if (NT_STATUS_IS_OK(status
)) {
1730 printf("lock3 succeeded! This is a locking bug\n");
1733 if (!check_both_error(__LINE__
, status
, ERRDOS
, ERRlock
,
1734 NT_STATUS_LOCK_NOT_GRANTED
)) {
1741 status
= cli_close(cli
, fnum1
);
1742 if (!NT_STATUS_IS_OK(status
)) {
1743 printf("close1 failed (%s)\n", nt_errstr(status
));
1747 status
= cli_close(cli
, fnum2
);
1748 if (!NT_STATUS_IS_OK(status
)) {
1749 printf("close2 failed (%s)\n", nt_errstr(status
));
1753 status
= cli_close(cli
, fnum3
);
1754 if (!NT_STATUS_IS_OK(status
)) {
1755 printf("close3 failed (%s)\n", nt_errstr(status
));
1759 if (!torture_close_connection(cli
)) {
1763 printf("locktest2 finished\n");
1770 This test checks that
1772 1) the server supports the full offset range in lock requests
1774 static bool run_locktest3(int dummy
)
1776 static struct cli_state
*cli1
, *cli2
;
1777 const char *fname
= "\\lockt3.lck";
1778 uint16_t fnum1
, fnum2
;
1781 bool correct
= True
;
1784 #define NEXT_OFFSET offset += (~(uint32)0) / torture_numops
1786 if (!torture_open_connection(&cli1
, 0) || !torture_open_connection(&cli2
, 1)) {
1789 cli_sockopt(cli1
, sockops
);
1790 cli_sockopt(cli2
, sockops
);
1792 printf("starting locktest3\n");
1794 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
1796 status
= cli_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
,
1798 if (!NT_STATUS_IS_OK(status
)) {
1799 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
1803 status
= cli_open(cli2
, fname
, O_RDWR
, DENY_NONE
, &fnum2
);
1804 if (!NT_STATUS_IS_OK(status
)) {
1805 printf("open2 of %s failed (%s)\n", fname
, nt_errstr(status
));
1809 for (offset
=i
=0;i
<torture_numops
;i
++) {
1812 status
= cli_lock32(cli1
, fnum1
, offset
-1, 1, 0, WRITE_LOCK
);
1813 if (!NT_STATUS_IS_OK(status
)) {
1814 printf("lock1 %d failed (%s)\n",
1820 status
= cli_lock32(cli2
, fnum2
, offset
-2, 1, 0, WRITE_LOCK
);
1821 if (!NT_STATUS_IS_OK(status
)) {
1822 printf("lock2 %d failed (%s)\n",
1829 for (offset
=i
=0;i
<torture_numops
;i
++) {
1832 status
= cli_lock32(cli1
, fnum1
, offset
-2, 1, 0, WRITE_LOCK
);
1833 if (NT_STATUS_IS_OK(status
)) {
1834 printf("error: lock1 %d succeeded!\n", i
);
1838 status
= cli_lock32(cli2
, fnum2
, offset
-1, 1, 0, WRITE_LOCK
);
1839 if (NT_STATUS_IS_OK(status
)) {
1840 printf("error: lock2 %d succeeded!\n", i
);
1844 status
= cli_lock32(cli1
, fnum1
, offset
-1, 1, 0, WRITE_LOCK
);
1845 if (NT_STATUS_IS_OK(status
)) {
1846 printf("error: lock3 %d succeeded!\n", i
);
1850 status
= cli_lock32(cli2
, fnum2
, offset
-2, 1, 0, WRITE_LOCK
);
1851 if (NT_STATUS_IS_OK(status
)) {
1852 printf("error: lock4 %d succeeded!\n", i
);
1857 for (offset
=i
=0;i
<torture_numops
;i
++) {
1860 status
= cli_unlock(cli1
, fnum1
, offset
-1, 1);
1861 if (!NT_STATUS_IS_OK(status
)) {
1862 printf("unlock1 %d failed (%s)\n",
1868 status
= cli_unlock(cli2
, fnum2
, offset
-2, 1);
1869 if (!NT_STATUS_IS_OK(status
)) {
1870 printf("unlock2 %d failed (%s)\n",
1877 status
= cli_close(cli1
, fnum1
);
1878 if (!NT_STATUS_IS_OK(status
)) {
1879 printf("close1 failed (%s)\n", nt_errstr(status
));
1883 status
= cli_close(cli2
, fnum2
);
1884 if (!NT_STATUS_IS_OK(status
)) {
1885 printf("close2 failed (%s)\n", nt_errstr(status
));
1889 status
= cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
1890 if (!NT_STATUS_IS_OK(status
)) {
1891 printf("unlink failed (%s)\n", nt_errstr(status
));
1895 if (!torture_close_connection(cli1
)) {
1899 if (!torture_close_connection(cli2
)) {
1903 printf("finished locktest3\n");
1908 static bool test_cli_read(struct cli_state
*cli
, uint16_t fnum
,
1909 char *buf
, off_t offset
, size_t size
,
1910 size_t *nread
, size_t expect
)
1915 status
= cli_read(cli
, fnum
, buf
, offset
, size
, &l_nread
);
1917 if(!NT_STATUS_IS_OK(status
)) {
1919 } else if (l_nread
!= expect
) {
1930 #define EXPECTED(ret, v) if ((ret) != (v)) { \
1931 printf("** "); correct = False; \
1935 looks at overlapping locks
1937 static bool run_locktest4(int dummy
)
1939 static struct cli_state
*cli1
, *cli2
;
1940 const char *fname
= "\\lockt4.lck";
1941 uint16_t fnum1
, fnum2
, f
;
1944 bool correct
= True
;
1947 if (!torture_open_connection(&cli1
, 0) || !torture_open_connection(&cli2
, 1)) {
1951 cli_sockopt(cli1
, sockops
);
1952 cli_sockopt(cli2
, sockops
);
1954 printf("starting locktest4\n");
1956 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
1958 cli_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
, &fnum1
);
1959 cli_open(cli2
, fname
, O_RDWR
, DENY_NONE
, &fnum2
);
1961 memset(buf
, 0, sizeof(buf
));
1963 status
= cli_writeall(cli1
, fnum1
, 0, (uint8_t *)buf
, 0, sizeof(buf
),
1965 if (!NT_STATUS_IS_OK(status
)) {
1966 printf("Failed to create file: %s\n", nt_errstr(status
));
1971 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 0, 4, 0, WRITE_LOCK
)) &&
1972 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 2, 4, 0, WRITE_LOCK
));
1973 EXPECTED(ret
, False
);
1974 printf("the same process %s set overlapping write locks\n", ret
?"can":"cannot");
1976 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 10, 4, 0, READ_LOCK
)) &&
1977 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 12, 4, 0, READ_LOCK
));
1978 EXPECTED(ret
, True
);
1979 printf("the same process %s set overlapping read locks\n", ret
?"can":"cannot");
1981 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 20, 4, 0, WRITE_LOCK
)) &&
1982 NT_STATUS_IS_OK(cli_lock32(cli2
, fnum2
, 22, 4, 0, WRITE_LOCK
));
1983 EXPECTED(ret
, False
);
1984 printf("a different connection %s set overlapping write locks\n", ret
?"can":"cannot");
1986 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 30, 4, 0, READ_LOCK
)) &&
1987 NT_STATUS_IS_OK(cli_lock32(cli2
, fnum2
, 32, 4, 0, READ_LOCK
));
1988 EXPECTED(ret
, True
);
1989 printf("a different connection %s set overlapping read locks\n", ret
?"can":"cannot");
1991 ret
= (cli_setpid(cli1
, 1),
1992 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 40, 4, 0, WRITE_LOCK
))) &&
1993 (cli_setpid(cli1
, 2),
1994 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 42, 4, 0, WRITE_LOCK
)));
1995 EXPECTED(ret
, False
);
1996 printf("a different pid %s set overlapping write locks\n", ret
?"can":"cannot");
1998 ret
= (cli_setpid(cli1
, 1),
1999 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 50, 4, 0, READ_LOCK
))) &&
2000 (cli_setpid(cli1
, 2),
2001 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 52, 4, 0, READ_LOCK
)));
2002 EXPECTED(ret
, True
);
2003 printf("a different pid %s set overlapping read locks\n", ret
?"can":"cannot");
2005 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 60, 4, 0, READ_LOCK
)) &&
2006 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 60, 4, 0, READ_LOCK
));
2007 EXPECTED(ret
, True
);
2008 printf("the same process %s set the same read lock twice\n", ret
?"can":"cannot");
2010 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 70, 4, 0, WRITE_LOCK
)) &&
2011 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 70, 4, 0, WRITE_LOCK
));
2012 EXPECTED(ret
, False
);
2013 printf("the same process %s set the same write lock twice\n", ret
?"can":"cannot");
2015 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 80, 4, 0, READ_LOCK
)) &&
2016 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 80, 4, 0, WRITE_LOCK
));
2017 EXPECTED(ret
, False
);
2018 printf("the same process %s overlay a read lock with a write lock\n", ret
?"can":"cannot");
2020 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 90, 4, 0, WRITE_LOCK
)) &&
2021 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 90, 4, 0, READ_LOCK
));
2022 EXPECTED(ret
, True
);
2023 printf("the same process %s overlay a write lock with a read lock\n", ret
?"can":"cannot");
2025 ret
= (cli_setpid(cli1
, 1),
2026 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 100, 4, 0, WRITE_LOCK
))) &&
2027 (cli_setpid(cli1
, 2),
2028 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 100, 4, 0, READ_LOCK
)));
2029 EXPECTED(ret
, False
);
2030 printf("a different pid %s overlay a write lock with a read lock\n", ret
?"can":"cannot");
2032 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 110, 4, 0, READ_LOCK
)) &&
2033 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 112, 4, 0, READ_LOCK
)) &&
2034 NT_STATUS_IS_OK(cli_unlock(cli1
, fnum1
, 110, 6));
2035 EXPECTED(ret
, False
);
2036 printf("the same process %s coalesce read locks\n", ret
?"can":"cannot");
2039 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 120, 4, 0, WRITE_LOCK
)) &&
2040 test_cli_read(cli2
, fnum2
, buf
, 120, 4, NULL
, 4);
2041 EXPECTED(ret
, False
);
2042 printf("this server %s strict write locking\n", ret
?"doesn't do":"does");
2044 status
= cli_lock32(cli1
, fnum1
, 130, 4, 0, READ_LOCK
);
2045 ret
= NT_STATUS_IS_OK(status
);
2047 status
= cli_writeall(cli2
, fnum2
, 0, (uint8_t *)buf
, 130, 4,
2049 ret
= NT_STATUS_IS_OK(status
);
2051 EXPECTED(ret
, False
);
2052 printf("this server %s strict read locking\n", ret
?"doesn't do":"does");
2055 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 140, 4, 0, READ_LOCK
)) &&
2056 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 140, 4, 0, READ_LOCK
)) &&
2057 NT_STATUS_IS_OK(cli_unlock(cli1
, fnum1
, 140, 4)) &&
2058 NT_STATUS_IS_OK(cli_unlock(cli1
, fnum1
, 140, 4));
2059 EXPECTED(ret
, True
);
2060 printf("this server %s do recursive read locking\n", ret
?"does":"doesn't");
2063 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 150, 4, 0, WRITE_LOCK
)) &&
2064 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 150, 4, 0, READ_LOCK
)) &&
2065 NT_STATUS_IS_OK(cli_unlock(cli1
, fnum1
, 150, 4)) &&
2066 test_cli_read(cli2
, fnum2
, buf
, 150, 4, NULL
, 4) &&
2067 !(NT_STATUS_IS_OK(cli_writeall(cli2
, fnum2
, 0, (uint8_t *)buf
,
2069 NT_STATUS_IS_OK(cli_unlock(cli1
, fnum1
, 150, 4));
2070 EXPECTED(ret
, True
);
2071 printf("this server %s do recursive lock overlays\n", ret
?"does":"doesn't");
2073 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 160, 4, 0, READ_LOCK
)) &&
2074 NT_STATUS_IS_OK(cli_unlock(cli1
, fnum1
, 160, 4)) &&
2075 NT_STATUS_IS_OK(cli_writeall(cli2
, fnum2
, 0, (uint8_t *)buf
,
2077 test_cli_read(cli2
, fnum2
, buf
, 160, 4, NULL
, 4);
2078 EXPECTED(ret
, True
);
2079 printf("the same process %s remove a read lock using write locking\n", ret
?"can":"cannot");
2081 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 170, 4, 0, WRITE_LOCK
)) &&
2082 NT_STATUS_IS_OK(cli_unlock(cli1
, fnum1
, 170, 4)) &&
2083 NT_STATUS_IS_OK(cli_writeall(cli2
, fnum2
, 0, (uint8_t *)buf
,
2085 test_cli_read(cli2
, fnum2
, buf
, 170, 4, NULL
, 4);
2086 EXPECTED(ret
, True
);
2087 printf("the same process %s remove a write lock using read locking\n", ret
?"can":"cannot");
2089 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 190, 4, 0, WRITE_LOCK
)) &&
2090 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 190, 4, 0, READ_LOCK
)) &&
2091 NT_STATUS_IS_OK(cli_unlock(cli1
, fnum1
, 190, 4)) &&
2092 !NT_STATUS_IS_OK(cli_writeall(cli2
, fnum2
, 0, (uint8_t *)buf
,
2094 test_cli_read(cli2
, fnum2
, buf
, 190, 4, NULL
, 4);
2095 EXPECTED(ret
, True
);
2096 printf("the same process %s remove the first lock first\n", ret
?"does":"doesn't");
2098 cli_close(cli1
, fnum1
);
2099 cli_close(cli2
, fnum2
);
2100 cli_open(cli1
, fname
, O_RDWR
, DENY_NONE
, &fnum1
);
2101 cli_open(cli1
, fname
, O_RDWR
, DENY_NONE
, &f
);
2102 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 0, 8, 0, READ_LOCK
)) &&
2103 NT_STATUS_IS_OK(cli_lock32(cli1
, f
, 0, 1, 0, READ_LOCK
)) &&
2104 NT_STATUS_IS_OK(cli_close(cli1
, fnum1
)) &&
2105 NT_STATUS_IS_OK(cli_open(cli1
, fname
, O_RDWR
, DENY_NONE
, &fnum1
)) &&
2106 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 7, 1, 0, WRITE_LOCK
));
2108 cli_close(cli1
, fnum1
);
2109 EXPECTED(ret
, True
);
2110 printf("the server %s have the NT byte range lock bug\n", !ret
?"does":"doesn't");
2113 cli_close(cli1
, fnum1
);
2114 cli_close(cli2
, fnum2
);
2115 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2116 torture_close_connection(cli1
);
2117 torture_close_connection(cli2
);
2119 printf("finished locktest4\n");
2124 looks at lock upgrade/downgrade.
2126 static bool run_locktest5(int dummy
)
2128 static struct cli_state
*cli1
, *cli2
;
2129 const char *fname
= "\\lockt5.lck";
2130 uint16_t fnum1
, fnum2
, fnum3
;
2133 bool correct
= True
;
2136 if (!torture_open_connection(&cli1
, 0) || !torture_open_connection(&cli2
, 1)) {
2140 cli_sockopt(cli1
, sockops
);
2141 cli_sockopt(cli2
, sockops
);
2143 printf("starting locktest5\n");
2145 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2147 cli_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
, &fnum1
);
2148 cli_open(cli2
, fname
, O_RDWR
, DENY_NONE
, &fnum2
);
2149 cli_open(cli1
, fname
, O_RDWR
, DENY_NONE
, &fnum3
);
2151 memset(buf
, 0, sizeof(buf
));
2153 status
= cli_writeall(cli1
, fnum1
, 0, (uint8_t *)buf
, 0, sizeof(buf
),
2155 if (!NT_STATUS_IS_OK(status
)) {
2156 printf("Failed to create file: %s\n", nt_errstr(status
));
2161 /* Check for NT bug... */
2162 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 0, 8, 0, READ_LOCK
)) &&
2163 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum3
, 0, 1, 0, READ_LOCK
));
2164 cli_close(cli1
, fnum1
);
2165 cli_open(cli1
, fname
, O_RDWR
, DENY_NONE
, &fnum1
);
2166 status
= cli_lock32(cli1
, fnum1
, 7, 1, 0, WRITE_LOCK
);
2167 ret
= NT_STATUS_IS_OK(status
);
2168 EXPECTED(ret
, True
);
2169 printf("this server %s the NT locking bug\n", ret
? "doesn't have" : "has");
2170 cli_close(cli1
, fnum1
);
2171 cli_open(cli1
, fname
, O_RDWR
, DENY_NONE
, &fnum1
);
2172 cli_unlock(cli1
, fnum3
, 0, 1);
2174 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 0, 4, 0, WRITE_LOCK
)) &&
2175 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 1, 1, 0, READ_LOCK
));
2176 EXPECTED(ret
, True
);
2177 printf("the same process %s overlay a write with a read lock\n", ret
?"can":"cannot");
2179 status
= cli_lock32(cli2
, fnum2
, 0, 4, 0, READ_LOCK
);
2180 ret
= NT_STATUS_IS_OK(status
);
2181 EXPECTED(ret
, False
);
2183 printf("a different processs %s get a read lock on the first process lock stack\n", ret
?"can":"cannot");
2185 /* Unlock the process 2 lock. */
2186 cli_unlock(cli2
, fnum2
, 0, 4);
2188 status
= cli_lock32(cli1
, fnum3
, 0, 4, 0, READ_LOCK
);
2189 ret
= NT_STATUS_IS_OK(status
);
2190 EXPECTED(ret
, False
);
2192 printf("the same processs on a different fnum %s get a read lock\n", ret
?"can":"cannot");
2194 /* Unlock the process 1 fnum3 lock. */
2195 cli_unlock(cli1
, fnum3
, 0, 4);
2197 /* Stack 2 more locks here. */
2198 ret
= NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 0, 4, 0, READ_LOCK
)) &&
2199 NT_STATUS_IS_OK(cli_lock32(cli1
, fnum1
, 0, 4, 0, READ_LOCK
));
2201 EXPECTED(ret
, True
);
2202 printf("the same process %s stack read locks\n", ret
?"can":"cannot");
2204 /* Unlock the first process lock, then check this was the WRITE lock that was
2207 ret
= NT_STATUS_IS_OK(cli_unlock(cli1
, fnum1
, 0, 4)) &&
2208 NT_STATUS_IS_OK(cli_lock32(cli2
, fnum2
, 0, 4, 0, READ_LOCK
));
2210 EXPECTED(ret
, True
);
2211 printf("the first unlock removes the %s lock\n", ret
?"WRITE":"READ");
2213 /* Unlock the process 2 lock. */
2214 cli_unlock(cli2
, fnum2
, 0, 4);
2216 /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
2218 ret
= NT_STATUS_IS_OK(cli_unlock(cli1
, fnum1
, 1, 1)) &&
2219 NT_STATUS_IS_OK(cli_unlock(cli1
, fnum1
, 0, 4)) &&
2220 NT_STATUS_IS_OK(cli_unlock(cli1
, fnum1
, 0, 4));
2222 EXPECTED(ret
, True
);
2223 printf("the same process %s unlock the stack of 4 locks\n", ret
?"can":"cannot");
2225 /* Ensure the next unlock fails. */
2226 ret
= NT_STATUS_IS_OK(cli_unlock(cli1
, fnum1
, 0, 4));
2227 EXPECTED(ret
, False
);
2228 printf("the same process %s count the lock stack\n", !ret
?"can":"cannot");
2230 /* Ensure connection 2 can get a write lock. */
2231 status
= cli_lock32(cli2
, fnum2
, 0, 4, 0, WRITE_LOCK
);
2232 ret
= NT_STATUS_IS_OK(status
);
2233 EXPECTED(ret
, True
);
2235 printf("a different processs %s get a write lock on the unlocked stack\n", ret
?"can":"cannot");
2239 cli_close(cli1
, fnum1
);
2240 cli_close(cli2
, fnum2
);
2241 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2242 if (!torture_close_connection(cli1
)) {
2245 if (!torture_close_connection(cli2
)) {
2249 printf("finished locktest5\n");
2255 tries the unusual lockingX locktype bits
2257 static bool run_locktest6(int dummy
)
2259 static struct cli_state
*cli
;
2260 const char *fname
[1] = { "\\lock6.txt" };
2265 if (!torture_open_connection(&cli
, 0)) {
2269 cli_sockopt(cli
, sockops
);
2271 printf("starting locktest6\n");
2274 printf("Testing %s\n", fname
[i
]);
2276 cli_unlink(cli
, fname
[i
], FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2278 cli_open(cli
, fname
[i
], O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
, &fnum
);
2279 status
= cli_locktype(cli
, fnum
, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE
);
2280 cli_close(cli
, fnum
);
2281 printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status
));
2283 cli_open(cli
, fname
[i
], O_RDWR
, DENY_NONE
, &fnum
);
2284 status
= cli_locktype(cli
, fnum
, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK
);
2285 cli_close(cli
, fnum
);
2286 printf("CANCEL_LOCK gave %s\n", nt_errstr(status
));
2288 cli_unlink(cli
, fname
[i
], FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2291 torture_close_connection(cli
);
2293 printf("finished locktest6\n");
2297 static bool run_locktest7(int dummy
)
2299 struct cli_state
*cli1
;
2300 const char *fname
= "\\lockt7.lck";
2303 bool correct
= False
;
2306 if (!torture_open_connection(&cli1
, 0)) {
2310 cli_sockopt(cli1
, sockops
);
2312 printf("starting locktest7\n");
2314 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2316 cli_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
, &fnum1
);
2318 memset(buf
, 0, sizeof(buf
));
2320 status
= cli_writeall(cli1
, fnum1
, 0, (uint8_t *)buf
, 0, sizeof(buf
),
2322 if (!NT_STATUS_IS_OK(status
)) {
2323 printf("Failed to create file: %s\n", nt_errstr(status
));
2327 cli_setpid(cli1
, 1);
2329 status
= cli_lock32(cli1
, fnum1
, 130, 4, 0, READ_LOCK
);
2330 if (!NT_STATUS_IS_OK(status
)) {
2331 printf("Unable to apply read lock on range 130:4, error was %s\n", nt_errstr(status
));
2334 printf("pid1 successfully locked range 130:4 for READ\n");
2337 if (cli_read_old(cli1
, fnum1
, buf
, 130, 4) != 4) {
2338 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1
));
2341 printf("pid1 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("pid1 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("pid1 successfully wrote to the range 130:4 (should be denied)\n");
2357 cli_setpid(cli1
, 2);
2359 if (cli_read_old(cli1
, fnum1
, buf
, 130, 4) != 4) {
2360 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1
));
2362 printf("pid2 successfully read the range 130:4\n");
2365 status
= cli_writeall(cli1
, fnum1
, 0, (uint8_t *)buf
, 130, 4, NULL
);
2366 if (!NT_STATUS_IS_OK(status
)) {
2367 printf("pid2 unable to write to the range 130:4, error was "
2368 "%s\n", nt_errstr(status
));
2369 if (!NT_STATUS_EQUAL(status
, NT_STATUS_FILE_LOCK_CONFLICT
)) {
2370 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2374 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2378 cli_setpid(cli1
, 1);
2379 cli_unlock(cli1
, fnum1
, 130, 4);
2381 status
= cli_lock32(cli1
, fnum1
, 130, 4, 0, WRITE_LOCK
);
2382 if (!NT_STATUS_IS_OK(status
)) {
2383 printf("Unable to apply write lock on range 130:4, error was %s\n", nt_errstr(status
));
2386 printf("pid1 successfully locked range 130:4 for WRITE\n");
2389 if (cli_read_old(cli1
, fnum1
, buf
, 130, 4) != 4) {
2390 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1
));
2393 printf("pid1 successfully read the range 130:4\n");
2396 status
= cli_writeall(cli1
, fnum1
, 0, (uint8_t *)buf
, 130, 4, NULL
);
2397 if (!NT_STATUS_IS_OK(status
)) {
2398 printf("pid1 unable to write to the range 130:4, error was "
2399 "%s\n", nt_errstr(status
));
2402 printf("pid1 successfully wrote to the range 130:4\n");
2405 cli_setpid(cli1
, 2);
2407 if (cli_read_old(cli1
, fnum1
, buf
, 130, 4) != 4) {
2408 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1
));
2409 if (NT_STATUS_V(cli_nt_error(cli1
)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT
)) {
2410 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2414 printf("pid2 successfully read the range 130:4 (should be denied)\n");
2418 status
= cli_writeall(cli1
, fnum1
, 0, (uint8_t *)buf
, 130, 4, NULL
);
2419 if (!NT_STATUS_IS_OK(status
)) {
2420 printf("pid2 unable to write to the range 130:4, error was "
2421 "%s\n", nt_errstr(status
));
2422 if (!NT_STATUS_EQUAL(status
, NT_STATUS_FILE_LOCK_CONFLICT
)) {
2423 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2427 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2431 cli_unlock(cli1
, fnum1
, 130, 0);
2435 cli_close(cli1
, fnum1
);
2436 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2437 torture_close_connection(cli1
);
2439 printf("finished locktest7\n");
2444 * This demonstrates a problem with our use of GPFS share modes: A file
2445 * descriptor sitting in the pending close queue holding a GPFS share mode
2446 * blocks opening a file another time. Happens with Word 2007 temp files.
2447 * With "posix locking = yes" and "gpfs:sharemodes = yes" enabled, the third
2448 * open is denied with NT_STATUS_SHARING_VIOLATION.
2451 static bool run_locktest8(int dummy
)
2453 struct cli_state
*cli1
;
2454 const char *fname
= "\\lockt8.lck";
2455 uint16_t fnum1
, fnum2
;
2457 bool correct
= False
;
2460 if (!torture_open_connection(&cli1
, 0)) {
2464 cli_sockopt(cli1
, sockops
);
2466 printf("starting locktest8\n");
2468 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2470 status
= cli_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_WRITE
,
2472 if (!NT_STATUS_IS_OK(status
)) {
2473 d_fprintf(stderr
, "cli_open returned %s\n", nt_errstr(status
));
2477 memset(buf
, 0, sizeof(buf
));
2479 status
= cli_open(cli1
, fname
, O_RDONLY
, DENY_NONE
, &fnum2
);
2480 if (!NT_STATUS_IS_OK(status
)) {
2481 d_fprintf(stderr
, "cli_open second time returned %s\n",
2486 status
= cli_lock32(cli1
, fnum2
, 1, 1, 0, READ_LOCK
);
2487 if (!NT_STATUS_IS_OK(status
)) {
2488 printf("Unable to apply read lock on range 1:1, error was "
2489 "%s\n", nt_errstr(status
));
2493 status
= cli_close(cli1
, fnum1
);
2494 if (!NT_STATUS_IS_OK(status
)) {
2495 d_fprintf(stderr
, "cli_close(fnum1) %s\n", nt_errstr(status
));
2499 status
= cli_open(cli1
, fname
, O_RDWR
, DENY_NONE
, &fnum1
);
2500 if (!NT_STATUS_IS_OK(status
)) {
2501 d_fprintf(stderr
, "cli_open third time returned %s\n",
2509 cli_close(cli1
, fnum1
);
2510 cli_close(cli1
, fnum2
);
2511 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2512 torture_close_connection(cli1
);
2514 printf("finished locktest8\n");
2519 * This test is designed to be run in conjunction with
2520 * external NFS or POSIX locks taken in the filesystem.
2521 * It checks that the smbd server will block until the
2522 * lock is released and then acquire it. JRA.
2525 static bool got_alarm
;
2526 static struct cli_state
*alarm_cli
;
2528 static void alarm_handler(int dummy
)
2533 static void alarm_handler_parent(int dummy
)
2535 cli_state_disconnect(alarm_cli
);
2538 static void do_local_lock(int read_fd
, int write_fd
)
2543 const char *local_pathname
= NULL
;
2546 local_pathname
= talloc_asprintf(talloc_tos(),
2547 "%s/lockt9.lck", local_path
);
2548 if (!local_pathname
) {
2549 printf("child: alloc fail\n");
2553 unlink(local_pathname
);
2554 fd
= open(local_pathname
, O_RDWR
|O_CREAT
, 0666);
2556 printf("child: open of %s failed %s.\n",
2557 local_pathname
, strerror(errno
));
2561 /* Now take a fcntl lock. */
2562 lock
.l_type
= F_WRLCK
;
2563 lock
.l_whence
= SEEK_SET
;
2566 lock
.l_pid
= getpid();
2568 ret
= fcntl(fd
,F_SETLK
,&lock
);
2570 printf("child: failed to get lock 0:4 on file %s. Error %s\n",
2571 local_pathname
, strerror(errno
));
2574 printf("child: got lock 0:4 on file %s.\n",
2579 CatchSignal(SIGALRM
, alarm_handler
);
2581 /* Signal the parent. */
2582 if (write(write_fd
, &c
, 1) != 1) {
2583 printf("child: start signal fail %s.\n",
2590 /* Wait for the parent to be ready. */
2591 if (read(read_fd
, &c
, 1) != 1) {
2592 printf("child: reply signal fail %s.\n",
2600 printf("child: released lock 0:4 on file %s.\n",
2606 static bool run_locktest9(int dummy
)
2608 struct cli_state
*cli1
;
2609 const char *fname
= "\\lockt9.lck";
2611 bool correct
= False
;
2612 int pipe_in
[2], pipe_out
[2];
2616 struct timeval start
;
2620 printf("starting locktest9\n");
2622 if (local_path
== NULL
) {
2623 d_fprintf(stderr
, "locktest9 must be given a local path via -l <localpath>\n");
2627 if (pipe(pipe_in
) == -1 || pipe(pipe_out
) == -1) {
2632 if (child_pid
== -1) {
2636 if (child_pid
== 0) {
2638 do_local_lock(pipe_out
[0], pipe_in
[1]);
2648 ret
= read(pipe_in
[0], &c
, 1);
2650 d_fprintf(stderr
, "failed to read start signal from child. %s\n",
2655 if (!torture_open_connection(&cli1
, 0)) {
2659 cli_sockopt(cli1
, sockops
);
2661 status
= cli_open(cli1
, fname
, O_RDWR
, DENY_NONE
,
2663 if (!NT_STATUS_IS_OK(status
)) {
2664 d_fprintf(stderr
, "cli_open returned %s\n", nt_errstr(status
));
2668 /* Ensure the child has the lock. */
2669 status
= cli_lock32(cli1
, fnum
, 0, 4, 0, WRITE_LOCK
);
2670 if (NT_STATUS_IS_OK(status
)) {
2671 d_fprintf(stderr
, "Got the lock on range 0:4 - this should not happen !\n");
2674 d_printf("Child has the lock.\n");
2677 /* Tell the child to wait 5 seconds then exit. */
2678 ret
= write(pipe_out
[1], &c
, 1);
2680 d_fprintf(stderr
, "failed to send exit signal to child. %s\n",
2685 /* Wait 20 seconds for the lock. */
2687 CatchSignal(SIGALRM
, alarm_handler_parent
);
2690 start
= timeval_current();
2692 status
= cli_lock32(cli1
, fnum
, 0, 4, -1, WRITE_LOCK
);
2693 if (!NT_STATUS_IS_OK(status
)) {
2694 d_fprintf(stderr
, "Unable to apply write lock on range 0:4, error was "
2695 "%s\n", nt_errstr(status
));
2700 seconds
= timeval_elapsed(&start
);
2702 printf("Parent got the lock after %.2f seconds.\n",
2705 status
= cli_close(cli1
, fnum
);
2706 if (!NT_STATUS_IS_OK(status
)) {
2707 d_fprintf(stderr
, "cli_close(fnum1) %s\n", nt_errstr(status
));
2714 cli_close(cli1
, fnum
);
2715 torture_close_connection(cli1
);
2719 printf("finished locktest9\n");
2724 test whether fnums and tids open on one VC are available on another (a major
2727 static bool run_fdpasstest(int dummy
)
2729 struct cli_state
*cli1
, *cli2
;
2730 const char *fname
= "\\fdpass.tst";
2735 if (!torture_open_connection(&cli1
, 0) || !torture_open_connection(&cli2
, 1)) {
2738 cli_sockopt(cli1
, sockops
);
2739 cli_sockopt(cli2
, sockops
);
2741 printf("starting fdpasstest\n");
2743 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2745 status
= cli_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
,
2747 if (!NT_STATUS_IS_OK(status
)) {
2748 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
2752 status
= cli_writeall(cli1
, fnum1
, 0, (const uint8_t *)"hello world\n", 0,
2754 if (!NT_STATUS_IS_OK(status
)) {
2755 printf("write failed (%s)\n", nt_errstr(status
));
2759 cli_state_set_uid(cli2
, cli_state_get_uid(cli1
));
2760 cli_state_set_tid(cli2
, cli_state_get_tid(cli1
));
2761 cli_setpid(cli2
, cli_getpid(cli1
));
2763 if (cli_read_old(cli2
, fnum1
, buf
, 0, 13) == 13) {
2764 printf("read succeeded! nasty security hole [%s]\n",
2769 cli_close(cli1
, fnum1
);
2770 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2772 torture_close_connection(cli1
);
2773 torture_close_connection(cli2
);
2775 printf("finished fdpasstest\n");
2779 static bool run_fdsesstest(int dummy
)
2781 struct cli_state
*cli
;
2786 const char *fname
= "\\fdsess.tst";
2787 const char *fname1
= "\\fdsess1.tst";
2794 if (!torture_open_connection(&cli
, 0))
2796 cli_sockopt(cli
, sockops
);
2798 if (!torture_cli_session_setup2(cli
, &new_vuid
))
2801 saved_cnum
= cli_state_get_tid(cli
);
2802 if (!NT_STATUS_IS_OK(cli_tcon_andx(cli
, share
, "?????", "", 1)))
2804 new_cnum
= cli_state_get_tid(cli
);
2805 cli_state_set_tid(cli
, saved_cnum
);
2807 printf("starting fdsesstest\n");
2809 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2810 cli_unlink(cli
, fname1
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2812 status
= cli_open(cli
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
, &fnum1
);
2813 if (!NT_STATUS_IS_OK(status
)) {
2814 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
2818 status
= cli_writeall(cli
, fnum1
, 0, (const uint8_t *)"hello world\n", 0, 13,
2820 if (!NT_STATUS_IS_OK(status
)) {
2821 printf("write failed (%s)\n", nt_errstr(status
));
2825 saved_vuid
= cli_state_get_uid(cli
);
2826 cli_state_set_uid(cli
, new_vuid
);
2828 if (cli_read_old(cli
, fnum1
, buf
, 0, 13) == 13) {
2829 printf("read succeeded with different vuid! nasty security hole [%s]\n",
2833 /* Try to open a file with different vuid, samba cnum. */
2834 if (NT_STATUS_IS_OK(cli_open(cli
, fname1
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
, &fnum2
))) {
2835 printf("create with different vuid, same cnum succeeded.\n");
2836 cli_close(cli
, fnum2
);
2837 cli_unlink(cli
, fname1
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2839 printf("create with different vuid, same cnum failed.\n");
2840 printf("This will cause problems with service clients.\n");
2844 cli_state_set_uid(cli
, saved_vuid
);
2846 /* Try with same vuid, different cnum. */
2847 cli_state_set_tid(cli
, new_cnum
);
2849 if (cli_read_old(cli
, fnum1
, buf
, 0, 13) == 13) {
2850 printf("read succeeded with different cnum![%s]\n",
2855 cli_state_set_tid(cli
, saved_cnum
);
2856 cli_close(cli
, fnum1
);
2857 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2859 torture_close_connection(cli
);
2861 printf("finished fdsesstest\n");
2866 This test checks that
2868 1) the server does not allow an unlink on a file that is open
2870 static bool run_unlinktest(int dummy
)
2872 struct cli_state
*cli
;
2873 const char *fname
= "\\unlink.tst";
2875 bool correct
= True
;
2878 if (!torture_open_connection(&cli
, 0)) {
2882 cli_sockopt(cli
, sockops
);
2884 printf("starting unlink test\n");
2886 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2890 status
= cli_open(cli
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
, &fnum
);
2891 if (!NT_STATUS_IS_OK(status
)) {
2892 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
2896 status
= cli_unlink(cli
, fname
,
2897 FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2898 if (NT_STATUS_IS_OK(status
)) {
2899 printf("error: server allowed unlink on an open file\n");
2902 correct
= check_error(__LINE__
, cli
, ERRDOS
, ERRbadshare
,
2903 NT_STATUS_SHARING_VIOLATION
);
2906 cli_close(cli
, fnum
);
2907 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2909 if (!torture_close_connection(cli
)) {
2913 printf("unlink test finished\n");
2920 test how many open files this server supports on the one socket
2922 static bool run_maxfidtest(int dummy
)
2924 struct cli_state
*cli
;
2926 uint16_t fnums
[0x11000];
2929 bool correct
= True
;
2935 printf("failed to connect\n");
2939 cli_sockopt(cli
, sockops
);
2941 for (i
=0; i
<0x11000; i
++) {
2942 slprintf(fname
,sizeof(fname
)-1,"\\maxfid.%d.%d", i
,(int)getpid());
2943 status
= cli_open(cli
, fname
, O_RDWR
|O_CREAT
|O_TRUNC
, DENY_NONE
,
2945 if (!NT_STATUS_IS_OK(status
)) {
2946 printf("open of %s failed (%s)\n",
2947 fname
, nt_errstr(status
));
2948 printf("maximum fnum is %d\n", i
);
2956 printf("cleaning up\n");
2958 slprintf(fname
,sizeof(fname
)-1,"\\maxfid.%d.%d", i
,(int)getpid());
2959 cli_close(cli
, fnums
[i
]);
2961 status
= cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2962 if (!NT_STATUS_IS_OK(status
)) {
2963 printf("unlink of %s failed (%s)\n",
2964 fname
, nt_errstr(status
));
2971 printf("maxfid test finished\n");
2972 if (!torture_close_connection(cli
)) {
2978 /* generate a random buffer */
2979 static void rand_buf(char *buf
, int len
)
2982 *buf
= (char)sys_random();
2987 /* send smb negprot commands, not reading the response */
2988 static bool run_negprot_nowait(int dummy
)
2990 struct tevent_context
*ev
;
2992 struct cli_state
*cli
;
2993 bool correct
= True
;
2995 printf("starting negprot nowait test\n");
2997 ev
= tevent_context_init(talloc_tos());
3002 if (!(cli
= open_nbt_connection())) {
3007 for (i
=0;i
<50000;i
++) {
3008 struct tevent_req
*req
;
3010 req
= cli_negprot_send(ev
, ev
, cli
);
3015 if (!tevent_req_poll(req
, ev
)) {
3016 d_fprintf(stderr
, "tevent_req_poll failed: %s\n",
3024 if (torture_close_connection(cli
)) {
3028 printf("finished negprot nowait test\n");
3033 /* send smb negprot commands, not reading the response */
3034 static bool run_bad_nbt_session(int dummy
)
3036 struct nmb_name called
, calling
;
3037 struct sockaddr_storage ss
;
3042 printf("starting bad nbt session test\n");
3044 make_nmb_name(&calling
, myname
, 0x0);
3045 make_nmb_name(&called
, host
, 0x20);
3047 if (!resolve_name(host
, &ss
, 0x20, true)) {
3048 d_fprintf(stderr
, "Could not resolve name %s\n", host
);
3052 status
= open_socket_out(&ss
, 139, 10000, &fd
);
3053 if (!NT_STATUS_IS_OK(status
)) {
3054 d_fprintf(stderr
, "open_socket_out failed: %s\n",
3059 ret
= cli_bad_session_request(fd
, &calling
, &called
);
3062 d_fprintf(stderr
, "open_socket_out failed: %s\n",
3067 printf("finished bad nbt session test\n");
3071 /* send random IPC commands */
3072 static bool run_randomipc(int dummy
)
3074 char *rparam
= NULL
;
3076 unsigned int rdrcnt
,rprcnt
;
3078 int api
, param_len
, i
;
3079 struct cli_state
*cli
;
3080 bool correct
= True
;
3083 printf("starting random ipc test\n");
3085 if (!torture_open_connection(&cli
, 0)) {
3089 for (i
=0;i
<count
;i
++) {
3090 api
= sys_random() % 500;
3091 param_len
= (sys_random() % 64);
3093 rand_buf(param
, param_len
);
3098 param
, param_len
, 8,
3099 NULL
, 0, BUFFER_SIZE
,
3103 printf("%d/%d\r", i
,count
);
3106 printf("%d/%d\n", i
, count
);
3108 if (!torture_close_connection(cli
)) {
3112 printf("finished random ipc test\n");
3119 static void browse_callback(const char *sname
, uint32 stype
,
3120 const char *comment
, void *state
)
3122 printf("\t%20.20s %08x %s\n", sname
, stype
, comment
);
3128 This test checks the browse list code
3131 static bool run_browsetest(int dummy
)
3133 static struct cli_state
*cli
;
3134 bool correct
= True
;
3136 printf("starting browse test\n");
3138 if (!torture_open_connection(&cli
, 0)) {
3142 printf("domain list:\n");
3143 cli_NetServerEnum(cli
, cli
->server_domain
,
3144 SV_TYPE_DOMAIN_ENUM
,
3145 browse_callback
, NULL
);
3147 printf("machine list:\n");
3148 cli_NetServerEnum(cli
, cli
->server_domain
,
3150 browse_callback
, NULL
);
3152 if (!torture_close_connection(cli
)) {
3156 printf("browse test finished\n");
3164 This checks how the getatr calls works
3166 static bool run_attrtest(int dummy
)
3168 struct cli_state
*cli
;
3171 const char *fname
= "\\attrib123456789.tst";
3172 bool correct
= True
;
3175 printf("starting attrib test\n");
3177 if (!torture_open_connection(&cli
, 0)) {
3181 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3182 cli_open(cli
, fname
,
3183 O_RDWR
| O_CREAT
| O_TRUNC
, DENY_NONE
, &fnum
);
3184 cli_close(cli
, fnum
);
3186 status
= cli_getatr(cli
, fname
, NULL
, NULL
, &t
);
3187 if (!NT_STATUS_IS_OK(status
)) {
3188 printf("getatr failed (%s)\n", nt_errstr(status
));
3192 if (abs(t
- time(NULL
)) > 60*60*24*10) {
3193 printf("ERROR: SMBgetatr bug. time is %s",
3199 t2
= t
-60*60*24; /* 1 day ago */
3201 status
= cli_setatr(cli
, fname
, 0, t2
);
3202 if (!NT_STATUS_IS_OK(status
)) {
3203 printf("setatr failed (%s)\n", nt_errstr(status
));
3207 status
= cli_getatr(cli
, fname
, NULL
, NULL
, &t
);
3208 if (!NT_STATUS_IS_OK(status
)) {
3209 printf("getatr failed (%s)\n", nt_errstr(status
));
3214 printf("ERROR: getatr/setatr bug. times are\n%s",
3216 printf("%s", ctime(&t2
));
3220 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3222 if (!torture_close_connection(cli
)) {
3226 printf("attrib test finished\n");
3233 This checks a couple of trans2 calls
3235 static bool run_trans2test(int dummy
)
3237 struct cli_state
*cli
;
3240 time_t c_time
, a_time
, m_time
;
3241 struct timespec c_time_ts
, a_time_ts
, m_time_ts
, w_time_ts
, m_time2_ts
;
3242 const char *fname
= "\\trans2.tst";
3243 const char *dname
= "\\trans2";
3244 const char *fname2
= "\\trans2\\trans2.tst";
3246 bool correct
= True
;
3250 printf("starting trans2 test\n");
3252 if (!torture_open_connection(&cli
, 0)) {
3256 status
= cli_get_fs_attr_info(cli
, &fs_attr
);
3257 if (!NT_STATUS_IS_OK(status
)) {
3258 printf("ERROR: cli_get_fs_attr_info returned %s\n",
3263 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3264 cli_open(cli
, fname
, O_RDWR
| O_CREAT
| O_TRUNC
, DENY_NONE
, &fnum
);
3265 status
= cli_qfileinfo_basic(cli
, fnum
, NULL
, &size
, &c_time_ts
,
3266 &a_time_ts
, &w_time_ts
, &m_time_ts
, NULL
);
3267 if (!NT_STATUS_IS_OK(status
)) {
3268 printf("ERROR: qfileinfo failed (%s)\n", nt_errstr(status
));
3272 status
= cli_qfilename(cli
, fnum
, talloc_tos(), &pname
);
3273 if (!NT_STATUS_IS_OK(status
)) {
3274 printf("ERROR: qfilename failed (%s)\n", nt_errstr(status
));
3278 if (strcmp(pname
, fname
)) {
3279 printf("qfilename gave different name? [%s] [%s]\n",
3284 cli_close(cli
, fnum
);
3288 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3289 status
= cli_open(cli
, fname
, O_RDWR
| O_CREAT
| O_TRUNC
, DENY_NONE
,
3291 if (!NT_STATUS_IS_OK(status
)) {
3292 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
3295 cli_close(cli
, fnum
);
3297 status
= cli_qpathinfo1(cli
, fname
, &c_time
, &a_time
, &m_time
, &size
,
3299 if (!NT_STATUS_IS_OK(status
)) {
3300 printf("ERROR: qpathinfo failed (%s)\n", nt_errstr(status
));
3303 if (c_time
!= m_time
) {
3304 printf("create time=%s", ctime(&c_time
));
3305 printf("modify time=%s", ctime(&m_time
));
3306 printf("This system appears to have sticky create times\n");
3308 if (a_time
% (60*60) == 0) {
3309 printf("access time=%s", ctime(&a_time
));
3310 printf("This system appears to set a midnight access time\n");
3314 if (abs(m_time
- time(NULL
)) > 60*60*24*7) {
3315 printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time
));
3321 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3322 cli_open(cli
, fname
,
3323 O_RDWR
| O_CREAT
| O_TRUNC
, DENY_NONE
, &fnum
);
3324 cli_close(cli
, fnum
);
3325 status
= cli_qpathinfo2(cli
, fname
, &c_time_ts
, &a_time_ts
, &w_time_ts
,
3326 &m_time_ts
, &size
, NULL
, NULL
);
3327 if (!NT_STATUS_IS_OK(status
)) {
3328 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status
));
3331 if (w_time_ts
.tv_sec
< 60*60*24*2) {
3332 printf("write time=%s", ctime(&w_time_ts
.tv_sec
));
3333 printf("This system appears to set a initial 0 write time\n");
3338 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3341 /* check if the server updates the directory modification time
3342 when creating a new file */
3343 status
= cli_mkdir(cli
, dname
);
3344 if (!NT_STATUS_IS_OK(status
)) {
3345 printf("ERROR: mkdir failed (%s)\n", nt_errstr(status
));
3349 status
= cli_qpathinfo2(cli
, "\\trans2\\", &c_time_ts
, &a_time_ts
,
3350 &w_time_ts
, &m_time_ts
, &size
, NULL
, NULL
);
3351 if (!NT_STATUS_IS_OK(status
)) {
3352 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status
));
3356 cli_open(cli
, fname2
,
3357 O_RDWR
| O_CREAT
| O_TRUNC
, DENY_NONE
, &fnum
);
3358 cli_writeall(cli
, fnum
, 0, (uint8_t *)&fnum
, 0, sizeof(fnum
), NULL
);
3359 cli_close(cli
, fnum
);
3360 status
= cli_qpathinfo2(cli
, "\\trans2\\", &c_time_ts
, &a_time_ts
,
3361 &w_time_ts
, &m_time2_ts
, &size
, NULL
, NULL
);
3362 if (!NT_STATUS_IS_OK(status
)) {
3363 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status
));
3366 if (memcmp(&m_time_ts
, &m_time2_ts
, sizeof(struct timespec
))
3368 printf("This system does not update directory modification times\n");
3372 cli_unlink(cli
, fname2
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3373 cli_rmdir(cli
, dname
);
3375 if (!torture_close_connection(cli
)) {
3379 printf("trans2 test finished\n");
3385 This checks new W2K calls.
3388 static NTSTATUS
new_trans(struct cli_state
*pcli
, int fnum
, int level
)
3390 uint8_t *buf
= NULL
;
3394 status
= cli_qfileinfo(talloc_tos(), pcli
, fnum
, level
, 0,
3395 pcli
->max_xmit
, NULL
, &buf
, &len
);
3396 if (!NT_STATUS_IS_OK(status
)) {
3397 printf("ERROR: qfileinfo (%d) failed (%s)\n", level
,
3400 printf("qfileinfo: level %d, len = %u\n", level
, len
);
3401 dump_data(0, (uint8
*)buf
, len
);
3408 static bool run_w2ktest(int dummy
)
3410 struct cli_state
*cli
;
3412 const char *fname
= "\\w2ktest\\w2k.tst";
3414 bool correct
= True
;
3416 printf("starting w2k test\n");
3418 if (!torture_open_connection(&cli
, 0)) {
3422 cli_open(cli
, fname
,
3423 O_RDWR
| O_CREAT
, DENY_NONE
, &fnum
);
3425 for (level
= 1004; level
< 1040; level
++) {
3426 new_trans(cli
, fnum
, level
);
3429 cli_close(cli
, fnum
);
3431 if (!torture_close_connection(cli
)) {
3435 printf("w2k test finished\n");
3442 this is a harness for some oplock tests
3444 static bool run_oplock1(int dummy
)
3446 struct cli_state
*cli1
;
3447 const char *fname
= "\\lockt1.lck";
3449 bool correct
= True
;
3452 printf("starting oplock test 1\n");
3454 if (!torture_open_connection(&cli1
, 0)) {
3458 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3460 cli_sockopt(cli1
, sockops
);
3462 cli1
->use_oplocks
= True
;
3464 status
= cli_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
,
3466 if (!NT_STATUS_IS_OK(status
)) {
3467 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
3471 cli1
->use_oplocks
= False
;
3473 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3474 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3476 status
= cli_close(cli1
, fnum1
);
3477 if (!NT_STATUS_IS_OK(status
)) {
3478 printf("close2 failed (%s)\n", nt_errstr(status
));
3482 status
= cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3483 if (!NT_STATUS_IS_OK(status
)) {
3484 printf("unlink failed (%s)\n", nt_errstr(status
));
3488 if (!torture_close_connection(cli1
)) {
3492 printf("finished oplock test 1\n");
3497 static bool run_oplock2(int dummy
)
3499 struct cli_state
*cli1
, *cli2
;
3500 const char *fname
= "\\lockt2.lck";
3501 uint16_t fnum1
, fnum2
;
3502 int saved_use_oplocks
= use_oplocks
;
3504 bool correct
= True
;
3505 volatile bool *shared_correct
;
3508 shared_correct
= (volatile bool *)shm_setup(sizeof(bool));
3509 *shared_correct
= True
;
3511 use_level_II_oplocks
= True
;
3514 printf("starting oplock test 2\n");
3516 if (!torture_open_connection(&cli1
, 0)) {
3517 use_level_II_oplocks
= False
;
3518 use_oplocks
= saved_use_oplocks
;
3522 cli1
->use_oplocks
= True
;
3523 cli1
->use_level_II_oplocks
= True
;
3525 if (!torture_open_connection(&cli2
, 1)) {
3526 use_level_II_oplocks
= False
;
3527 use_oplocks
= saved_use_oplocks
;
3531 cli2
->use_oplocks
= True
;
3532 cli2
->use_level_II_oplocks
= True
;
3534 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3536 cli_sockopt(cli1
, sockops
);
3537 cli_sockopt(cli2
, sockops
);
3539 status
= cli_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
,
3541 if (!NT_STATUS_IS_OK(status
)) {
3542 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
3546 /* Don't need the globals any more. */
3547 use_level_II_oplocks
= False
;
3548 use_oplocks
= saved_use_oplocks
;
3552 status
= cli_open(cli2
, fname
, O_RDWR
, DENY_NONE
, &fnum2
);
3553 if (!NT_STATUS_IS_OK(status
)) {
3554 printf("second open of %s failed (%s)\n", fname
, nt_errstr(status
));
3555 *shared_correct
= False
;
3561 status
= cli_close(cli2
, fnum2
);
3562 if (!NT_STATUS_IS_OK(status
)) {
3563 printf("close2 failed (%s)\n", nt_errstr(status
));
3564 *shared_correct
= False
;
3572 /* Ensure cli1 processes the break. Empty file should always return 0
3575 if (cli_read_old(cli1
, fnum1
, buf
, 0, 4) != 0) {
3576 printf("read on fnum1 failed (%s)\n", cli_errstr(cli1
));
3580 /* Should now be at level II. */
3581 /* Test if sending a write locks causes a break to none. */
3582 status
= cli_lock32(cli1
, fnum1
, 0, 4, 0, READ_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 status
= cli_lock32(cli1
, fnum1
, 0, 4, 0, WRITE_LOCK
);
3593 if (!NT_STATUS_IS_OK(status
)) {
3594 printf("lock failed (%s)\n", nt_errstr(status
));
3598 cli_unlock(cli1
, fnum1
, 0, 4);
3602 cli_read_old(cli1
, fnum1
, buf
, 0, 4);
3604 status
= cli_close(cli1
, fnum1
);
3605 if (!NT_STATUS_IS_OK(status
)) {
3606 printf("close1 failed (%s)\n", nt_errstr(status
));
3612 status
= cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3613 if (!NT_STATUS_IS_OK(status
)) {
3614 printf("unlink failed (%s)\n", nt_errstr(status
));
3618 if (!torture_close_connection(cli1
)) {
3622 if (!*shared_correct
) {
3626 printf("finished oplock test 2\n");
3631 struct oplock4_state
{
3632 struct tevent_context
*ev
;
3633 struct cli_state
*cli
;
3638 static void oplock4_got_break(struct tevent_req
*req
);
3639 static void oplock4_got_open(struct tevent_req
*req
);
3641 static bool run_oplock4(int dummy
)
3643 struct tevent_context
*ev
;
3644 struct cli_state
*cli1
, *cli2
;
3645 struct tevent_req
*oplock_req
, *open_req
;
3646 const char *fname
= "\\lockt4.lck";
3647 const char *fname_ln
= "\\lockt4_ln.lck";
3648 uint16_t fnum1
, fnum2
;
3649 int saved_use_oplocks
= use_oplocks
;
3651 bool correct
= true;
3655 struct oplock4_state
*state
;
3657 printf("starting oplock test 4\n");
3659 if (!torture_open_connection(&cli1
, 0)) {
3660 use_level_II_oplocks
= false;
3661 use_oplocks
= saved_use_oplocks
;
3665 if (!torture_open_connection(&cli2
, 1)) {
3666 use_level_II_oplocks
= false;
3667 use_oplocks
= saved_use_oplocks
;
3671 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3672 cli_unlink(cli1
, fname_ln
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3674 cli_sockopt(cli1
, sockops
);
3675 cli_sockopt(cli2
, sockops
);
3677 /* Create the file. */
3678 status
= cli_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
,
3680 if (!NT_STATUS_IS_OK(status
)) {
3681 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
3685 status
= cli_close(cli1
, fnum1
);
3686 if (!NT_STATUS_IS_OK(status
)) {
3687 printf("close1 failed (%s)\n", nt_errstr(status
));
3691 /* Now create a hardlink. */
3692 status
= cli_nt_hardlink(cli1
, fname
, fname_ln
);
3693 if (!NT_STATUS_IS_OK(status
)) {
3694 printf("nt hardlink failed (%s)\n", nt_errstr(status
));
3698 /* Prove that opening hardlinks cause deny modes to conflict. */
3699 status
= cli_open(cli1
, fname
, O_RDWR
, DENY_ALL
, &fnum1
);
3700 if (!NT_STATUS_IS_OK(status
)) {
3701 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
3705 status
= cli_open(cli1
, fname_ln
, O_RDWR
, DENY_NONE
, &fnum2
);
3706 if (NT_STATUS_IS_OK(status
)) {
3707 printf("open of %s succeeded - should fail with sharing violation.\n",
3712 if (!NT_STATUS_EQUAL(status
, NT_STATUS_SHARING_VIOLATION
)) {
3713 printf("open of %s should fail with sharing violation. Got %s\n",
3714 fname_ln
, nt_errstr(status
));
3718 status
= cli_close(cli1
, fnum1
);
3719 if (!NT_STATUS_IS_OK(status
)) {
3720 printf("close1 failed (%s)\n", nt_errstr(status
));
3724 cli1
->use_oplocks
= true;
3725 cli1
->use_level_II_oplocks
= true;
3727 cli2
->use_oplocks
= true;
3728 cli2
->use_level_II_oplocks
= true;
3730 status
= cli_open(cli1
, fname
, O_RDWR
, DENY_NONE
, &fnum1
);
3731 if (!NT_STATUS_IS_OK(status
)) {
3732 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
3736 ev
= tevent_context_init(talloc_tos());
3738 printf("tevent_req_create failed\n");
3742 state
= talloc(ev
, struct oplock4_state
);
3743 if (state
== NULL
) {
3744 printf("talloc failed\n");
3749 state
->got_break
= &got_break
;
3750 state
->fnum2
= &fnum2
;
3752 oplock_req
= cli_smb_oplock_break_waiter_send(
3753 talloc_tos(), ev
, cli1
);
3754 if (oplock_req
== NULL
) {
3755 printf("cli_smb_oplock_break_waiter_send failed\n");
3758 tevent_req_set_callback(oplock_req
, oplock4_got_break
, state
);
3760 open_req
= cli_open_send(
3761 talloc_tos(), ev
, cli2
, fname_ln
, O_RDWR
, DENY_NONE
);
3762 if (oplock_req
== NULL
) {
3763 printf("cli_open_send failed\n");
3766 tevent_req_set_callback(open_req
, oplock4_got_open
, state
);
3771 while (!got_break
|| fnum2
== 0xffff) {
3773 ret
= tevent_loop_once(ev
);
3775 printf("tevent_loop_once failed: %s\n",
3781 status
= cli_close(cli2
, fnum2
);
3782 if (!NT_STATUS_IS_OK(status
)) {
3783 printf("close2 failed (%s)\n", nt_errstr(status
));
3787 status
= cli_close(cli1
, fnum1
);
3788 if (!NT_STATUS_IS_OK(status
)) {
3789 printf("close1 failed (%s)\n", nt_errstr(status
));
3793 status
= cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3794 if (!NT_STATUS_IS_OK(status
)) {
3795 printf("unlink failed (%s)\n", nt_errstr(status
));
3799 status
= cli_unlink(cli1
, fname_ln
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3800 if (!NT_STATUS_IS_OK(status
)) {
3801 printf("unlink failed (%s)\n", nt_errstr(status
));
3805 if (!torture_close_connection(cli1
)) {
3813 printf("finished oplock test 4\n");
3818 static void oplock4_got_break(struct tevent_req
*req
)
3820 struct oplock4_state
*state
= tevent_req_callback_data(
3821 req
, struct oplock4_state
);
3826 status
= cli_smb_oplock_break_waiter_recv(req
, &fnum
, &level
);
3828 if (!NT_STATUS_IS_OK(status
)) {
3829 printf("cli_smb_oplock_break_waiter_recv returned %s\n",
3833 *state
->got_break
= true;
3835 req
= cli_oplock_ack_send(state
, state
->ev
, state
->cli
, fnum
,
3838 printf("cli_oplock_ack_send failed\n");
3843 static void oplock4_got_open(struct tevent_req
*req
)
3845 struct oplock4_state
*state
= tevent_req_callback_data(
3846 req
, struct oplock4_state
);
3849 status
= cli_open_recv(req
, state
->fnum2
);
3850 if (!NT_STATUS_IS_OK(status
)) {
3851 printf("cli_open_recv returned %s\n", nt_errstr(status
));
3852 *state
->fnum2
= 0xffff;
3857 Test delete on close semantics.
3859 static bool run_deletetest(int dummy
)
3861 struct cli_state
*cli1
= NULL
;
3862 struct cli_state
*cli2
= NULL
;
3863 const char *fname
= "\\delete.file";
3864 uint16_t fnum1
= (uint16_t)-1;
3865 uint16_t fnum2
= (uint16_t)-1;
3866 bool correct
= True
;
3869 printf("starting delete test\n");
3871 if (!torture_open_connection(&cli1
, 0)) {
3875 cli_sockopt(cli1
, sockops
);
3877 /* Test 1 - this should delete the file on close. */
3879 cli_setatr(cli1
, fname
, 0, 0);
3880 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3882 status
= cli_ntcreate(cli1
, fname
, 0, GENERIC_ALL_ACCESS
|DELETE_ACCESS
,
3883 FILE_ATTRIBUTE_NORMAL
, 0, FILE_OVERWRITE_IF
,
3884 FILE_DELETE_ON_CLOSE
, 0, &fnum1
);
3885 if (!NT_STATUS_IS_OK(status
)) {
3886 printf("[1] open of %s failed (%s)\n", fname
, nt_errstr(status
));
3891 status
= cli_close(cli1
, fnum1
);
3892 if (!NT_STATUS_IS_OK(status
)) {
3893 printf("[1] close failed (%s)\n", nt_errstr(status
));
3898 if (NT_STATUS_IS_OK(cli_open(cli1
, fname
, O_RDWR
, DENY_NONE
, &fnum1
))) {
3899 printf("[1] open of %s succeeded (should fail)\n", fname
);
3904 printf("first delete on close test succeeded.\n");
3906 /* Test 2 - this should delete the file on close. */
3908 cli_setatr(cli1
, fname
, 0, 0);
3909 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3911 status
= cli_ntcreate(cli1
, fname
, 0, GENERIC_ALL_ACCESS
,
3912 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_NONE
,
3913 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
3914 if (!NT_STATUS_IS_OK(status
)) {
3915 printf("[2] open of %s failed (%s)\n", fname
, nt_errstr(status
));
3920 status
= cli_nt_delete_on_close(cli1
, fnum1
, true);
3921 if (!NT_STATUS_IS_OK(status
)) {
3922 printf("[2] setting delete_on_close failed (%s)\n", nt_errstr(status
));
3927 status
= cli_close(cli1
, fnum1
);
3928 if (!NT_STATUS_IS_OK(status
)) {
3929 printf("[2] close failed (%s)\n", nt_errstr(status
));
3934 if (NT_STATUS_IS_OK(cli_open(cli1
, fname
, O_RDONLY
, DENY_NONE
, &fnum1
))) {
3935 printf("[2] open of %s succeeded should have been deleted on close !\n", fname
);
3936 status
= cli_close(cli1
, fnum1
);
3937 if (!NT_STATUS_IS_OK(status
)) {
3938 printf("[2] close failed (%s)\n", nt_errstr(status
));
3942 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3944 printf("second delete on close test succeeded.\n");
3947 cli_setatr(cli1
, fname
, 0, 0);
3948 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
3950 status
= cli_ntcreate(cli1
, fname
, 0, GENERIC_ALL_ACCESS
,
3951 FILE_ATTRIBUTE_NORMAL
,
3952 FILE_SHARE_READ
|FILE_SHARE_WRITE
,
3953 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
3954 if (!NT_STATUS_IS_OK(status
)) {
3955 printf("[3] open - 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
3960 /* This should fail with a sharing violation - open for delete is only compatible
3961 with SHARE_DELETE. */
3963 if (NT_STATUS_IS_OK(cli_ntcreate(cli1
, fname
, 0, GENERIC_READ_ACCESS
, FILE_ATTRIBUTE_NORMAL
,
3964 FILE_SHARE_READ
|FILE_SHARE_WRITE
, FILE_OPEN
, 0, 0, &fnum2
))) {
3965 printf("[3] open - 2 of %s succeeded - should have failed.\n", fname
);
3970 /* This should succeed. */
3971 status
= cli_ntcreate(cli1
, fname
, 0, GENERIC_READ_ACCESS
,
3972 FILE_ATTRIBUTE_NORMAL
,
3973 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
3974 FILE_OPEN
, 0, 0, &fnum2
);
3975 if (!NT_STATUS_IS_OK(status
)) {
3976 printf("[3] open - 2 of %s failed (%s)\n", fname
, nt_errstr(status
));
3981 status
= cli_nt_delete_on_close(cli1
, fnum1
, true);
3982 if (!NT_STATUS_IS_OK(status
)) {
3983 printf("[3] setting delete_on_close failed (%s)\n", nt_errstr(status
));
3988 status
= cli_close(cli1
, fnum1
);
3989 if (!NT_STATUS_IS_OK(status
)) {
3990 printf("[3] close 1 failed (%s)\n", nt_errstr(status
));
3995 status
= cli_close(cli1
, fnum2
);
3996 if (!NT_STATUS_IS_OK(status
)) {
3997 printf("[3] close 2 failed (%s)\n", nt_errstr(status
));
4002 /* This should fail - file should no longer be there. */
4004 if (NT_STATUS_IS_OK(cli_open(cli1
, fname
, O_RDONLY
, DENY_NONE
, &fnum1
))) {
4005 printf("[3] open of %s succeeded should have been deleted on close !\n", fname
);
4006 status
= cli_close(cli1
, fnum1
);
4007 if (!NT_STATUS_IS_OK(status
)) {
4008 printf("[3] close failed (%s)\n", nt_errstr(status
));
4010 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4014 printf("third delete on close test succeeded.\n");
4017 cli_setatr(cli1
, fname
, 0, 0);
4018 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4020 status
= cli_ntcreate(cli1
, fname
, 0,
4021 FILE_READ_DATA
|FILE_WRITE_DATA
|DELETE_ACCESS
,
4022 FILE_ATTRIBUTE_NORMAL
,
4023 FILE_SHARE_READ
|FILE_SHARE_WRITE
,
4024 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
4025 if (!NT_STATUS_IS_OK(status
)) {
4026 printf("[4] open of %s failed (%s)\n", fname
, nt_errstr(status
));
4031 /* This should succeed. */
4032 status
= cli_ntcreate(cli1
, fname
, 0, GENERIC_READ_ACCESS
,
4033 FILE_ATTRIBUTE_NORMAL
,
4034 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
4035 FILE_OPEN
, 0, 0, &fnum2
);
4036 if (!NT_STATUS_IS_OK(status
)) {
4037 printf("[4] open - 2 of %s failed (%s)\n", fname
, nt_errstr(status
));
4042 status
= cli_close(cli1
, fnum2
);
4043 if (!NT_STATUS_IS_OK(status
)) {
4044 printf("[4] close - 1 failed (%s)\n", nt_errstr(status
));
4049 status
= cli_nt_delete_on_close(cli1
, fnum1
, true);
4050 if (!NT_STATUS_IS_OK(status
)) {
4051 printf("[4] setting delete_on_close failed (%s)\n", nt_errstr(status
));
4056 /* This should fail - no more opens once delete on close set. */
4057 if (NT_STATUS_IS_OK(cli_ntcreate(cli1
, fname
, 0, GENERIC_READ_ACCESS
,
4058 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
4059 FILE_OPEN
, 0, 0, &fnum2
))) {
4060 printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname
);
4064 printf("fourth delete on close test succeeded.\n");
4066 status
= cli_close(cli1
, fnum1
);
4067 if (!NT_STATUS_IS_OK(status
)) {
4068 printf("[4] close - 2 failed (%s)\n", nt_errstr(status
));
4074 cli_setatr(cli1
, fname
, 0, 0);
4075 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4077 status
= cli_open(cli1
, fname
, O_RDWR
|O_CREAT
, DENY_NONE
, &fnum1
);
4078 if (!NT_STATUS_IS_OK(status
)) {
4079 printf("[5] open of %s failed (%s)\n", fname
, nt_errstr(status
));
4084 /* This should fail - only allowed on NT opens with DELETE access. */
4086 if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1
, fnum1
, true))) {
4087 printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
4092 status
= cli_close(cli1
, fnum1
);
4093 if (!NT_STATUS_IS_OK(status
)) {
4094 printf("[5] close - 2 failed (%s)\n", nt_errstr(status
));
4099 printf("fifth delete on close test succeeded.\n");
4102 cli_setatr(cli1
, fname
, 0, 0);
4103 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4105 status
= cli_ntcreate(cli1
, fname
, 0, FILE_READ_DATA
|FILE_WRITE_DATA
,
4106 FILE_ATTRIBUTE_NORMAL
,
4107 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
4108 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
4109 if (!NT_STATUS_IS_OK(status
)) {
4110 printf("[6] open of %s failed (%s)\n", fname
,
4116 /* This should fail - only allowed on NT opens with DELETE access. */
4118 if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1
, fnum1
, true))) {
4119 printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
4124 status
= cli_close(cli1
, fnum1
);
4125 if (!NT_STATUS_IS_OK(status
)) {
4126 printf("[6] close - 2 failed (%s)\n", nt_errstr(status
));
4131 printf("sixth delete on close test succeeded.\n");
4134 cli_setatr(cli1
, fname
, 0, 0);
4135 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4137 status
= cli_ntcreate(cli1
, fname
, 0,
4138 FILE_READ_DATA
|FILE_WRITE_DATA
|DELETE_ACCESS
,
4139 FILE_ATTRIBUTE_NORMAL
, 0, FILE_OVERWRITE_IF
,
4141 if (!NT_STATUS_IS_OK(status
)) {
4142 printf("[7] open of %s failed (%s)\n", fname
, nt_errstr(status
));
4147 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1
, fnum1
, true))) {
4148 printf("[7] setting delete_on_close on file failed !\n");
4153 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1
, fnum1
, false))) {
4154 printf("[7] unsetting delete_on_close on file failed !\n");
4159 status
= cli_close(cli1
, fnum1
);
4160 if (!NT_STATUS_IS_OK(status
)) {
4161 printf("[7] close - 2 failed (%s)\n", nt_errstr(status
));
4166 /* This next open should succeed - we reset the flag. */
4167 status
= cli_open(cli1
, fname
, O_RDONLY
, DENY_NONE
, &fnum1
);
4168 if (!NT_STATUS_IS_OK(status
)) {
4169 printf("[5] open of %s failed (%s)\n", fname
, nt_errstr(status
));
4174 status
= cli_close(cli1
, fnum1
);
4175 if (!NT_STATUS_IS_OK(status
)) {
4176 printf("[7] close - 2 failed (%s)\n", nt_errstr(status
));
4181 printf("seventh delete on close test succeeded.\n");
4184 cli_setatr(cli1
, fname
, 0, 0);
4185 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4187 if (!torture_open_connection(&cli2
, 1)) {
4188 printf("[8] failed to open second connection.\n");
4193 cli_sockopt(cli1
, sockops
);
4195 status
= cli_ntcreate(cli1
, fname
, 0,
4196 FILE_READ_DATA
|FILE_WRITE_DATA
|DELETE_ACCESS
,
4197 FILE_ATTRIBUTE_NORMAL
,
4198 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
4199 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
4200 if (!NT_STATUS_IS_OK(status
)) {
4201 printf("[8] open 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
4206 status
= cli_ntcreate(cli2
, fname
, 0,
4207 FILE_READ_DATA
|FILE_WRITE_DATA
|DELETE_ACCESS
,
4208 FILE_ATTRIBUTE_NORMAL
,
4209 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
4210 FILE_OPEN
, 0, 0, &fnum2
);
4211 if (!NT_STATUS_IS_OK(status
)) {
4212 printf("[8] open 2 of %s failed (%s)\n", fname
, nt_errstr(status
));
4217 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1
, fnum1
, true))) {
4218 printf("[8] setting delete_on_close on file failed !\n");
4223 status
= cli_close(cli1
, fnum1
);
4224 if (!NT_STATUS_IS_OK(status
)) {
4225 printf("[8] close - 1 failed (%s)\n", nt_errstr(status
));
4230 status
= cli_close(cli2
, fnum2
);
4231 if (!NT_STATUS_IS_OK(status
)) {
4232 printf("[8] close - 2 failed (%s)\n", nt_errstr(status
));
4237 /* This should fail.. */
4238 status
= cli_open(cli1
, fname
, O_RDONLY
, DENY_NONE
, &fnum1
);
4239 if (NT_STATUS_IS_OK(status
)) {
4240 printf("[8] open of %s succeeded should have been deleted on close !\n", fname
);
4244 printf("eighth delete on close test succeeded.\n");
4246 /* This should fail - we need to set DELETE_ACCESS. */
4247 if (NT_STATUS_IS_OK(cli_ntcreate(cli1
, fname
, 0,FILE_READ_DATA
|FILE_WRITE_DATA
,
4248 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_NONE
, FILE_OVERWRITE_IF
, FILE_DELETE_ON_CLOSE
, 0, &fnum1
))) {
4249 printf("[9] open of %s succeeded should have failed!\n", fname
);
4254 printf("ninth delete on close test succeeded.\n");
4256 status
= cli_ntcreate(cli1
, fname
, 0,
4257 FILE_READ_DATA
|FILE_WRITE_DATA
|DELETE_ACCESS
,
4258 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_NONE
,
4259 FILE_OVERWRITE_IF
, FILE_DELETE_ON_CLOSE
,
4261 if (!NT_STATUS_IS_OK(status
)) {
4262 printf("[10] open of %s failed (%s)\n", fname
, nt_errstr(status
));
4267 /* This should delete the file. */
4268 status
= cli_close(cli1
, fnum1
);
4269 if (!NT_STATUS_IS_OK(status
)) {
4270 printf("[10] close failed (%s)\n", nt_errstr(status
));
4275 /* This should fail.. */
4276 if (NT_STATUS_IS_OK(cli_open(cli1
, fname
, O_RDONLY
, DENY_NONE
, &fnum1
))) {
4277 printf("[10] open of %s succeeded should have been deleted on close !\n", fname
);
4281 printf("tenth delete on close test succeeded.\n");
4283 cli_setatr(cli1
, fname
, 0, 0);
4284 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4286 /* What error do we get when attempting to open a read-only file with
4289 /* Create a readonly file. */
4290 status
= cli_ntcreate(cli1
, fname
, 0, FILE_READ_DATA
|FILE_WRITE_DATA
,
4291 FILE_ATTRIBUTE_READONLY
, FILE_SHARE_NONE
,
4292 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
4293 if (!NT_STATUS_IS_OK(status
)) {
4294 printf("[11] open of %s failed (%s)\n", fname
, nt_errstr(status
));
4299 status
= cli_close(cli1
, fnum1
);
4300 if (!NT_STATUS_IS_OK(status
)) {
4301 printf("[11] close failed (%s)\n", nt_errstr(status
));
4306 /* Now try open for delete access. */
4307 if (NT_STATUS_IS_OK(cli_ntcreate(cli1
, fname
, 0, FILE_READ_ATTRIBUTES
|DELETE_ACCESS
,
4308 0, FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
4309 FILE_OVERWRITE_IF
, 0, 0, &fnum1
))) {
4310 printf("[11] open of %s succeeded should have been denied with ACCESS_DENIED!\n", fname
);
4311 cli_close(cli1
, fnum1
);
4315 NTSTATUS nterr
= cli_nt_error(cli1
);
4316 if (!NT_STATUS_EQUAL(nterr
,NT_STATUS_ACCESS_DENIED
)) {
4317 printf("[11] open of %s should have been denied with ACCESS_DENIED! Got error %s\n", fname
, nt_errstr(nterr
));
4321 printf("eleventh delete on close test succeeded.\n");
4325 printf("finished delete test\n");
4328 /* FIXME: This will crash if we aborted before cli2 got
4329 * intialized, because these functions don't handle
4330 * uninitialized connections. */
4332 if (fnum1
!= (uint16_t)-1) cli_close(cli1
, fnum1
);
4333 if (fnum2
!= (uint16_t)-1) cli_close(cli1
, fnum2
);
4334 cli_setatr(cli1
, fname
, 0, 0);
4335 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4337 if (cli1
&& !torture_close_connection(cli1
)) {
4340 if (cli2
&& !torture_close_connection(cli2
)) {
4346 static bool run_deletetest_ln(int dummy
)
4348 struct cli_state
*cli
;
4349 const char *fname
= "\\delete1";
4350 const char *fname_ln
= "\\delete1_ln";
4354 bool correct
= true;
4357 printf("starting deletetest-ln\n");
4359 if (!torture_open_connection(&cli
, 0)) {
4363 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4364 cli_unlink(cli
, fname_ln
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4366 cli_sockopt(cli
, sockops
);
4368 /* Create the file. */
4369 status
= cli_open(cli
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
, &fnum
);
4370 if (!NT_STATUS_IS_OK(status
)) {
4371 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
4375 status
= cli_close(cli
, fnum
);
4376 if (!NT_STATUS_IS_OK(status
)) {
4377 printf("close1 failed (%s)\n", nt_errstr(status
));
4381 /* Now create a hardlink. */
4382 status
= cli_nt_hardlink(cli
, fname
, fname_ln
);
4383 if (!NT_STATUS_IS_OK(status
)) {
4384 printf("nt hardlink failed (%s)\n", nt_errstr(status
));
4388 /* Open the original file. */
4389 status
= cli_ntcreate(cli
, fname
, 0, FILE_READ_DATA
,
4390 FILE_ATTRIBUTE_NORMAL
,
4391 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
4392 FILE_OPEN_IF
, 0, 0, &fnum
);
4393 if (!NT_STATUS_IS_OK(status
)) {
4394 printf("ntcreate of %s failed (%s)\n", fname
, nt_errstr(status
));
4398 /* Unlink the hard link path. */
4399 status
= cli_ntcreate(cli
, fname_ln
, 0, DELETE_ACCESS
,
4400 FILE_ATTRIBUTE_NORMAL
,
4401 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
4402 FILE_OPEN_IF
, 0, 0, &fnum1
);
4403 if (!NT_STATUS_IS_OK(status
)) {
4404 printf("ntcreate of %s failed (%s)\n", fname_ln
, nt_errstr(status
));
4407 status
= cli_nt_delete_on_close(cli
, fnum1
, true);
4408 if (!NT_STATUS_IS_OK(status
)) {
4409 d_printf("(%s) failed to set delete_on_close %s: %s\n",
4410 __location__
, fname_ln
, nt_errstr(status
));
4414 status
= cli_close(cli
, fnum1
);
4415 if (!NT_STATUS_IS_OK(status
)) {
4416 printf("close %s failed (%s)\n",
4417 fname_ln
, nt_errstr(status
));
4421 status
= cli_close(cli
, fnum
);
4422 if (!NT_STATUS_IS_OK(status
)) {
4423 printf("close %s failed (%s)\n",
4424 fname
, nt_errstr(status
));
4428 /* Ensure the original file is still there. */
4429 status
= cli_getatr(cli
, fname
, NULL
, NULL
, &t
);
4430 if (!NT_STATUS_IS_OK(status
)) {
4431 printf("%s getatr on file %s failed (%s)\n",
4438 /* Ensure the link path is gone. */
4439 status
= cli_getatr(cli
, fname_ln
, NULL
, NULL
, &t
);
4440 if (!NT_STATUS_EQUAL(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
)) {
4441 printf("%s, getatr for file %s returned wrong error code %s "
4442 "- should have been deleted\n",
4444 fname_ln
, nt_errstr(status
));
4448 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4449 cli_unlink(cli
, fname_ln
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4451 if (!torture_close_connection(cli
)) {
4455 printf("finished deletetest-ln\n");
4461 print out server properties
4463 static bool run_properties(int dummy
)
4465 struct cli_state
*cli
;
4466 bool correct
= True
;
4468 printf("starting properties test\n");
4472 if (!torture_open_connection(&cli
, 0)) {
4476 cli_sockopt(cli
, sockops
);
4478 d_printf("Capabilities 0x%08x\n", cli
->capabilities
);
4480 if (!torture_close_connection(cli
)) {
4489 /* FIRST_DESIRED_ACCESS 0xf019f */
4490 #define FIRST_DESIRED_ACCESS FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\
4491 FILE_READ_EA| /* 0xf */ \
4492 FILE_WRITE_EA|FILE_READ_ATTRIBUTES| /* 0x90 */ \
4493 FILE_WRITE_ATTRIBUTES| /* 0x100 */ \
4494 DELETE_ACCESS|READ_CONTROL_ACCESS|\
4495 WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS /* 0xf0000 */
4496 /* SECOND_DESIRED_ACCESS 0xe0080 */
4497 #define SECOND_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
4498 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
4499 WRITE_OWNER_ACCESS /* 0xe0000 */
4502 #define THIRD_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
4503 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
4505 WRITE_OWNER_ACCESS /* */
4509 Test ntcreate calls made by xcopy
4511 static bool run_xcopy(int dummy
)
4513 static struct cli_state
*cli1
;
4514 const char *fname
= "\\test.txt";
4515 bool correct
= True
;
4516 uint16_t fnum1
, fnum2
;
4519 printf("starting xcopy test\n");
4521 if (!torture_open_connection(&cli1
, 0)) {
4525 status
= cli_ntcreate(cli1
, fname
, 0, FIRST_DESIRED_ACCESS
,
4526 FILE_ATTRIBUTE_ARCHIVE
, FILE_SHARE_NONE
,
4527 FILE_OVERWRITE_IF
, 0x4044, 0, &fnum1
);
4528 if (!NT_STATUS_IS_OK(status
)) {
4529 printf("First open failed - %s\n", nt_errstr(status
));
4533 status
= cli_ntcreate(cli1
, fname
, 0, SECOND_DESIRED_ACCESS
, 0,
4534 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
4535 FILE_OPEN
, 0x200000, 0, &fnum2
);
4536 if (!NT_STATUS_IS_OK(status
)) {
4537 printf("second open failed - %s\n", nt_errstr(status
));
4541 if (!torture_close_connection(cli1
)) {
4549 Test rename on files open with share delete and no share delete.
4551 static bool run_rename(int dummy
)
4553 static struct cli_state
*cli1
;
4554 const char *fname
= "\\test.txt";
4555 const char *fname1
= "\\test1.txt";
4556 bool correct
= True
;
4561 printf("starting rename test\n");
4563 if (!torture_open_connection(&cli1
, 0)) {
4567 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4568 cli_unlink(cli1
, fname1
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4570 status
= cli_ntcreate(cli1
, fname
, 0, GENERIC_READ_ACCESS
,
4571 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_READ
,
4572 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
4573 if (!NT_STATUS_IS_OK(status
)) {
4574 printf("First open failed - %s\n", nt_errstr(status
));
4578 status
= cli_rename(cli1
, fname
, fname1
);
4579 if (!NT_STATUS_IS_OK(status
)) {
4580 printf("First rename failed (SHARE_READ) (this is correct) - %s\n", nt_errstr(status
));
4582 printf("First rename succeeded (SHARE_READ) - this should have failed !\n");
4586 status
= cli_close(cli1
, fnum1
);
4587 if (!NT_STATUS_IS_OK(status
)) {
4588 printf("close - 1 failed (%s)\n", nt_errstr(status
));
4592 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4593 cli_unlink(cli1
, fname1
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4594 status
= cli_ntcreate(cli1
, fname
, 0, GENERIC_READ_ACCESS
, FILE_ATTRIBUTE_NORMAL
,
4596 FILE_SHARE_DELETE
|FILE_SHARE_NONE
,
4598 FILE_SHARE_DELETE
|FILE_SHARE_READ
,
4600 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
4601 if (!NT_STATUS_IS_OK(status
)) {
4602 printf("Second open failed - %s\n", nt_errstr(status
));
4606 status
= cli_rename(cli1
, fname
, fname1
);
4607 if (!NT_STATUS_IS_OK(status
)) {
4608 printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", nt_errstr(status
));
4611 printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n");
4614 status
= cli_close(cli1
, fnum1
);
4615 if (!NT_STATUS_IS_OK(status
)) {
4616 printf("close - 2 failed (%s)\n", nt_errstr(status
));
4620 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4621 cli_unlink(cli1
, fname1
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4623 status
= cli_ntcreate(cli1
, fname
, 0, READ_CONTROL_ACCESS
,
4624 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_NONE
,
4625 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
4626 if (!NT_STATUS_IS_OK(status
)) {
4627 printf("Third open failed - %s\n", nt_errstr(status
));
4636 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1
, fname
, 0, DELETE_ACCESS
, FILE_ATTRIBUTE_NORMAL
,
4637 FILE_SHARE_NONE
, FILE_OVERWRITE_IF
, 0, 0, &fnum2
))) {
4638 printf("Fourth open failed - %s\n", cli_errstr(cli1
));
4641 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1
, fnum2
, true))) {
4642 printf("[8] setting delete_on_close on file failed !\n");
4646 if (!NT_STATUS_IS_OK(cli_close(cli1
, fnum2
))) {
4647 printf("close - 4 failed (%s)\n", cli_errstr(cli1
));
4653 status
= cli_rename(cli1
, fname
, fname1
);
4654 if (!NT_STATUS_IS_OK(status
)) {
4655 printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", nt_errstr(status
));
4658 printf("Third rename succeeded (SHARE_NONE)\n");
4661 status
= cli_close(cli1
, fnum1
);
4662 if (!NT_STATUS_IS_OK(status
)) {
4663 printf("close - 3 failed (%s)\n", nt_errstr(status
));
4667 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4668 cli_unlink(cli1
, fname1
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4672 status
= cli_ntcreate(cli1
, fname
, 0, GENERIC_READ_ACCESS
,
4673 FILE_ATTRIBUTE_NORMAL
,
4674 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
4675 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
4676 if (!NT_STATUS_IS_OK(status
)) {
4677 printf("Fourth open failed - %s\n", nt_errstr(status
));
4681 status
= cli_rename(cli1
, fname
, fname1
);
4682 if (!NT_STATUS_IS_OK(status
)) {
4683 printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", nt_errstr(status
));
4685 printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n");
4689 status
= cli_close(cli1
, fnum1
);
4690 if (!NT_STATUS_IS_OK(status
)) {
4691 printf("close - 4 failed (%s)\n", nt_errstr(status
));
4695 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4696 cli_unlink(cli1
, fname1
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4700 status
= cli_ntcreate(cli1
, fname
, 0, GENERIC_READ_ACCESS
,
4701 FILE_ATTRIBUTE_NORMAL
,
4702 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
4703 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
4704 if (!NT_STATUS_IS_OK(status
)) {
4705 printf("Fifth open failed - %s\n", nt_errstr(status
));
4709 status
= cli_rename(cli1
, fname
, fname1
);
4710 if (!NT_STATUS_IS_OK(status
)) {
4711 printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n", nt_errstr(status
));
4714 printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", nt_errstr(status
));
4718 * Now check if the first name still exists ...
4721 /* if (!NT_STATUS_OP(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4722 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
4723 printf("Opening original file after rename of open file fails: %s\n",
4727 printf("Opening original file after rename of open file works ...\n");
4728 (void)cli_close(cli1, fnum2);
4732 status
= cli_close(cli1
, fnum1
);
4733 if (!NT_STATUS_IS_OK(status
)) {
4734 printf("close - 5 failed (%s)\n", nt_errstr(status
));
4738 /* Check that the renamed file has FILE_ATTRIBUTE_ARCHIVE. */
4739 status
= cli_getatr(cli1
, fname1
, &attr
, NULL
, NULL
);
4740 if (!NT_STATUS_IS_OK(status
)) {
4741 printf("getatr on file %s failed - %s ! \n",
4742 fname1
, nt_errstr(status
));
4745 if (attr
!= FILE_ATTRIBUTE_ARCHIVE
) {
4746 printf("Renamed file %s has wrong attr 0x%x "
4747 "(should be 0x%x)\n",
4750 (unsigned int)FILE_ATTRIBUTE_ARCHIVE
);
4753 printf("Renamed file %s has archive bit set\n", fname1
);
4757 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4758 cli_unlink(cli1
, fname1
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4760 if (!torture_close_connection(cli1
)) {
4767 static bool run_pipe_number(int dummy
)
4769 struct cli_state
*cli1
;
4770 const char *pipe_name
= "\\SPOOLSS";
4775 printf("starting pipenumber test\n");
4776 if (!torture_open_connection(&cli1
, 0)) {
4780 cli_sockopt(cli1
, sockops
);
4782 status
= cli_ntcreate(cli1
, pipe_name
, 0, FILE_READ_DATA
,
4783 FILE_ATTRIBUTE_NORMAL
,
4784 FILE_SHARE_READ
|FILE_SHARE_WRITE
,
4785 FILE_OPEN_IF
, 0, 0, &fnum
);
4786 if (!NT_STATUS_IS_OK(status
)) {
4787 printf("Open of pipe %s failed with error (%s)\n", pipe_name
, nt_errstr(status
));
4791 printf("\r%6d", num_pipes
);
4794 printf("pipe_number test - we can open %d %s pipes.\n", num_pipes
, pipe_name
);
4795 torture_close_connection(cli1
);
4800 Test open mode returns on read-only files.
4802 static bool run_opentest(int dummy
)
4804 static struct cli_state
*cli1
;
4805 static struct cli_state
*cli2
;
4806 const char *fname
= "\\readonly.file";
4807 uint16_t fnum1
, fnum2
;
4810 bool correct
= True
;
4814 printf("starting open test\n");
4816 if (!torture_open_connection(&cli1
, 0)) {
4820 cli_setatr(cli1
, fname
, 0, 0);
4821 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4823 cli_sockopt(cli1
, sockops
);
4825 status
= cli_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
, &fnum1
);
4826 if (!NT_STATUS_IS_OK(status
)) {
4827 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
4831 status
= cli_close(cli1
, fnum1
);
4832 if (!NT_STATUS_IS_OK(status
)) {
4833 printf("close2 failed (%s)\n", nt_errstr(status
));
4837 status
= cli_setatr(cli1
, fname
, FILE_ATTRIBUTE_READONLY
, 0);
4838 if (!NT_STATUS_IS_OK(status
)) {
4839 printf("cli_setatr failed (%s)\n", nt_errstr(status
));
4843 status
= cli_open(cli1
, fname
, O_RDONLY
, DENY_WRITE
, &fnum1
);
4844 if (!NT_STATUS_IS_OK(status
)) {
4845 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
4849 /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
4850 cli_open(cli1
, fname
, O_RDWR
, DENY_ALL
, &fnum2
);
4852 if (check_error(__LINE__
, cli1
, ERRDOS
, ERRnoaccess
,
4853 NT_STATUS_ACCESS_DENIED
)) {
4854 printf("correct error code ERRDOS/ERRnoaccess returned\n");
4857 printf("finished open test 1\n");
4859 cli_close(cli1
, fnum1
);
4861 /* Now try not readonly and ensure ERRbadshare is returned. */
4863 cli_setatr(cli1
, fname
, 0, 0);
4865 status
= cli_open(cli1
, fname
, O_RDONLY
, DENY_WRITE
, &fnum1
);
4866 if (!NT_STATUS_IS_OK(status
)) {
4867 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
4871 /* This will fail - but the error should be ERRshare. */
4872 cli_open(cli1
, fname
, O_RDWR
, DENY_ALL
, &fnum2
);
4874 if (check_error(__LINE__
, cli1
, ERRDOS
, ERRbadshare
,
4875 NT_STATUS_SHARING_VIOLATION
)) {
4876 printf("correct error code ERRDOS/ERRbadshare returned\n");
4879 status
= cli_close(cli1
, fnum1
);
4880 if (!NT_STATUS_IS_OK(status
)) {
4881 printf("close2 failed (%s)\n", nt_errstr(status
));
4885 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4887 printf("finished open test 2\n");
4889 /* Test truncate open disposition on file opened for read. */
4890 status
= cli_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
, &fnum1
);
4891 if (!NT_STATUS_IS_OK(status
)) {
4892 printf("(3) open (1) of %s failed (%s)\n", fname
, nt_errstr(status
));
4896 /* write 20 bytes. */
4898 memset(buf
, '\0', 20);
4900 status
= cli_writeall(cli1
, fnum1
, 0, (uint8_t *)buf
, 0, 20, NULL
);
4901 if (!NT_STATUS_IS_OK(status
)) {
4902 printf("write failed (%s)\n", nt_errstr(status
));
4906 status
= cli_close(cli1
, fnum1
);
4907 if (!NT_STATUS_IS_OK(status
)) {
4908 printf("(3) close1 failed (%s)\n", nt_errstr(status
));
4912 /* Ensure size == 20. */
4913 status
= cli_getatr(cli1
, fname
, NULL
, &fsize
, NULL
);
4914 if (!NT_STATUS_IS_OK(status
)) {
4915 printf("(3) getatr failed (%s)\n", nt_errstr(status
));
4920 printf("(3) file size != 20\n");
4924 /* Now test if we can truncate a file opened for readonly. */
4925 status
= cli_open(cli1
, fname
, O_RDONLY
|O_TRUNC
, DENY_NONE
, &fnum1
);
4926 if (!NT_STATUS_IS_OK(status
)) {
4927 printf("(3) open (2) of %s failed (%s)\n", fname
, nt_errstr(status
));
4931 status
= cli_close(cli1
, fnum1
);
4932 if (!NT_STATUS_IS_OK(status
)) {
4933 printf("close2 failed (%s)\n", nt_errstr(status
));
4937 /* Ensure size == 0. */
4938 status
= cli_getatr(cli1
, fname
, NULL
, &fsize
, NULL
);
4939 if (!NT_STATUS_IS_OK(status
)) {
4940 printf("(3) getatr failed (%s)\n", nt_errstr(status
));
4945 printf("(3) file size != 0\n");
4948 printf("finished open test 3\n");
4950 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4952 printf("Do ctemp tests\n");
4953 status
= cli_ctemp(cli1
, talloc_tos(), "\\", &fnum1
, &tmp_path
);
4954 if (!NT_STATUS_IS_OK(status
)) {
4955 printf("ctemp failed (%s)\n", nt_errstr(status
));
4959 printf("ctemp gave path %s\n", tmp_path
);
4960 status
= cli_close(cli1
, fnum1
);
4961 if (!NT_STATUS_IS_OK(status
)) {
4962 printf("close of temp failed (%s)\n", nt_errstr(status
));
4965 status
= cli_unlink(cli1
, tmp_path
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4966 if (!NT_STATUS_IS_OK(status
)) {
4967 printf("unlink of temp failed (%s)\n", nt_errstr(status
));
4970 /* Test the non-io opens... */
4972 if (!torture_open_connection(&cli2
, 1)) {
4976 cli_setatr(cli2
, fname
, 0, 0);
4977 cli_unlink(cli2
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
4979 cli_sockopt(cli2
, sockops
);
4981 printf("TEST #1 testing 2 non-io opens (no delete)\n");
4982 status
= cli_ntcreate(cli1
, fname
, 0, FILE_READ_ATTRIBUTES
,
4983 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_NONE
,
4984 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
4985 if (!NT_STATUS_IS_OK(status
)) {
4986 printf("TEST #1 open 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
4990 status
= cli_ntcreate(cli2
, fname
, 0, FILE_READ_ATTRIBUTES
,
4991 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_NONE
,
4992 FILE_OPEN_IF
, 0, 0, &fnum2
);
4993 if (!NT_STATUS_IS_OK(status
)) {
4994 printf("TEST #1 open 2 of %s failed (%s)\n", fname
, nt_errstr(status
));
4998 status
= cli_close(cli1
, fnum1
);
4999 if (!NT_STATUS_IS_OK(status
)) {
5000 printf("TEST #1 close 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
5004 status
= cli_close(cli2
, fnum2
);
5005 if (!NT_STATUS_IS_OK(status
)) {
5006 printf("TEST #1 close 2 of %s failed (%s)\n", fname
, nt_errstr(status
));
5010 printf("non-io open test #1 passed.\n");
5012 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
5014 printf("TEST #2 testing 2 non-io opens (first with delete)\n");
5016 status
= cli_ntcreate(cli1
, fname
, 0,
5017 DELETE_ACCESS
|FILE_READ_ATTRIBUTES
,
5018 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_NONE
,
5019 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
5020 if (!NT_STATUS_IS_OK(status
)) {
5021 printf("TEST #2 open 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
5025 status
= cli_ntcreate(cli2
, fname
, 0, FILE_READ_ATTRIBUTES
,
5026 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_NONE
,
5027 FILE_OPEN_IF
, 0, 0, &fnum2
);
5028 if (!NT_STATUS_IS_OK(status
)) {
5029 printf("TEST #2 open 2 of %s failed (%s)\n", fname
, nt_errstr(status
));
5033 status
= cli_close(cli1
, fnum1
);
5034 if (!NT_STATUS_IS_OK(status
)) {
5035 printf("TEST #2 close 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
5039 status
= cli_close(cli2
, fnum2
);
5040 if (!NT_STATUS_IS_OK(status
)) {
5041 printf("TEST #2 close 2 of %s failed (%s)\n", fname
, nt_errstr(status
));
5045 printf("non-io open test #2 passed.\n");
5047 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
5049 printf("TEST #3 testing 2 non-io opens (second with delete)\n");
5051 status
= cli_ntcreate(cli1
, fname
, 0, FILE_READ_ATTRIBUTES
,
5052 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_NONE
,
5053 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
5054 if (!NT_STATUS_IS_OK(status
)) {
5055 printf("TEST #3 open 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
5059 status
= cli_ntcreate(cli2
, fname
, 0,
5060 DELETE_ACCESS
|FILE_READ_ATTRIBUTES
,
5061 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_NONE
,
5062 FILE_OPEN_IF
, 0, 0, &fnum2
);
5063 if (!NT_STATUS_IS_OK(status
)) {
5064 printf("TEST #3 open 2 of %s failed (%s)\n", fname
, nt_errstr(status
));
5068 status
= cli_close(cli1
, fnum1
);
5069 if (!NT_STATUS_IS_OK(status
)) {
5070 printf("TEST #3 close 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
5074 status
= cli_close(cli2
, fnum2
);
5075 if (!NT_STATUS_IS_OK(status
)) {
5076 printf("TEST #3 close 2 of %s failed (%s)\n", fname
, nt_errstr(status
));
5080 printf("non-io open test #3 passed.\n");
5082 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
5084 printf("TEST #4 testing 2 non-io opens (both with delete)\n");
5086 status
= cli_ntcreate(cli1
, fname
, 0,
5087 DELETE_ACCESS
|FILE_READ_ATTRIBUTES
,
5088 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_NONE
,
5089 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
5090 if (!NT_STATUS_IS_OK(status
)) {
5091 printf("TEST #4 open 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
5095 status
= cli_ntcreate(cli2
, fname
, 0,
5096 DELETE_ACCESS
|FILE_READ_ATTRIBUTES
,
5097 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_NONE
,
5098 FILE_OPEN_IF
, 0, 0, &fnum2
);
5099 if (NT_STATUS_IS_OK(status
)) {
5100 printf("TEST #4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname
, nt_errstr(status
));
5104 printf("TEST #4 open 2 of %s gave %s (correct error should be %s)\n", fname
, nt_errstr(status
), "sharing violation");
5106 status
= cli_close(cli1
, fnum1
);
5107 if (!NT_STATUS_IS_OK(status
)) {
5108 printf("TEST #4 close 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
5112 printf("non-io open test #4 passed.\n");
5114 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
5116 printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
5118 status
= cli_ntcreate(cli1
, fname
, 0,
5119 DELETE_ACCESS
|FILE_READ_ATTRIBUTES
,
5120 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_DELETE
,
5121 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
5122 if (!NT_STATUS_IS_OK(status
)) {
5123 printf("TEST #5 open 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
5127 status
= cli_ntcreate(cli2
, fname
, 0,
5128 DELETE_ACCESS
|FILE_READ_ATTRIBUTES
,
5129 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_DELETE
,
5130 FILE_OPEN_IF
, 0, 0, &fnum2
);
5131 if (!NT_STATUS_IS_OK(status
)) {
5132 printf("TEST #5 open 2 of %s failed (%s)\n", fname
, nt_errstr(status
));
5136 status
= cli_close(cli1
, fnum1
);
5137 if (!NT_STATUS_IS_OK(status
)) {
5138 printf("TEST #5 close 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
5142 status
= cli_close(cli2
, fnum2
);
5143 if (!NT_STATUS_IS_OK(status
)) {
5144 printf("TEST #5 close 2 of %s failed (%s)\n", fname
, nt_errstr(status
));
5148 printf("non-io open test #5 passed.\n");
5150 printf("TEST #6 testing 1 non-io open, one io open\n");
5152 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
5154 status
= cli_ntcreate(cli1
, fname
, 0, FILE_READ_DATA
,
5155 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_NONE
,
5156 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
5157 if (!NT_STATUS_IS_OK(status
)) {
5158 printf("TEST #6 open 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
5162 status
= cli_ntcreate(cli2
, fname
, 0, FILE_READ_ATTRIBUTES
,
5163 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_READ
,
5164 FILE_OPEN_IF
, 0, 0, &fnum2
);
5165 if (!NT_STATUS_IS_OK(status
)) {
5166 printf("TEST #6 open 2 of %s failed (%s)\n", fname
, nt_errstr(status
));
5170 status
= cli_close(cli1
, fnum1
);
5171 if (!NT_STATUS_IS_OK(status
)) {
5172 printf("TEST #6 close 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
5176 status
= cli_close(cli2
, fnum2
);
5177 if (!NT_STATUS_IS_OK(status
)) {
5178 printf("TEST #6 close 2 of %s failed (%s)\n", fname
, nt_errstr(status
));
5182 printf("non-io open test #6 passed.\n");
5184 printf("TEST #7 testing 1 non-io open, one io open with delete\n");
5186 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
5188 status
= cli_ntcreate(cli1
, fname
, 0, FILE_READ_DATA
,
5189 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_NONE
,
5190 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
5191 if (!NT_STATUS_IS_OK(status
)) {
5192 printf("TEST #7 open 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
5196 status
= cli_ntcreate(cli2
, fname
, 0,
5197 DELETE_ACCESS
|FILE_READ_ATTRIBUTES
,
5198 FILE_ATTRIBUTE_NORMAL
,
5199 FILE_SHARE_READ
|FILE_SHARE_DELETE
,
5200 FILE_OPEN_IF
, 0, 0, &fnum2
);
5201 if (NT_STATUS_IS_OK(status
)) {
5202 printf("TEST #7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname
, nt_errstr(status
));
5206 printf("TEST #7 open 2 of %s gave %s (correct error should be %s)\n", fname
, nt_errstr(status
), "sharing violation");
5208 status
= cli_close(cli1
, fnum1
);
5209 if (!NT_STATUS_IS_OK(status
)) {
5210 printf("TEST #7 close 1 of %s failed (%s)\n", fname
, nt_errstr(status
));
5214 printf("non-io open test #7 passed.\n");
5216 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
5218 printf("TEST #8 testing open without WRITE_ATTRIBUTES, updating close write time.\n");
5219 status
= cli_ntcreate(cli1
, fname
, 0, FILE_WRITE_DATA
, FILE_ATTRIBUTE_NORMAL
,
5220 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
5221 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
5222 if (!NT_STATUS_IS_OK(status
)) {
5223 printf("TEST #8 open of %s failed (%s)\n", fname
, nt_errstr(status
));
5228 /* Write to ensure we have to update the file time. */
5229 status
= cli_writeall(cli1
, fnum1
, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
5231 if (!NT_STATUS_IS_OK(status
)) {
5232 printf("TEST #8 cli_write failed: %s\n", nt_errstr(status
));
5237 status
= cli_close(cli1
, fnum1
);
5238 if (!NT_STATUS_IS_OK(status
)) {
5239 printf("TEST #8 close of %s failed (%s)\n", fname
, nt_errstr(status
));
5245 if (!torture_close_connection(cli1
)) {
5248 if (!torture_close_connection(cli2
)) {
5255 NTSTATUS
torture_setup_unix_extensions(struct cli_state
*cli
)
5257 uint16 major
, minor
;
5258 uint32 caplow
, caphigh
;
5261 if (!SERVER_HAS_UNIX_CIFS(cli
)) {
5262 printf("Server doesn't support UNIX CIFS extensions.\n");
5263 return NT_STATUS_NOT_SUPPORTED
;
5266 status
= cli_unix_extensions_version(cli
, &major
, &minor
, &caplow
,
5268 if (!NT_STATUS_IS_OK(status
)) {
5269 printf("Server didn't return UNIX CIFS extensions: %s\n",
5274 status
= cli_set_unix_extensions_capabilities(cli
, major
, minor
,
5276 if (!NT_STATUS_IS_OK(status
)) {
5277 printf("Server doesn't support setting UNIX CIFS extensions: "
5278 "%s.\n", nt_errstr(status
));
5282 return NT_STATUS_OK
;
5286 Test POSIX open /mkdir calls.
5288 static bool run_simple_posix_open_test(int dummy
)
5290 static struct cli_state
*cli1
;
5291 const char *fname
= "posix:file";
5292 const char *hname
= "posix:hlink";
5293 const char *sname
= "posix:symlink";
5294 const char *dname
= "posix:dir";
5297 uint16_t fnum1
= (uint16_t)-1;
5298 SMB_STRUCT_STAT sbuf
;
5299 bool correct
= false;
5303 printf("Starting simple POSIX open test\n");
5305 if (!torture_open_connection(&cli1
, 0)) {
5309 cli_sockopt(cli1
, sockops
);
5311 status
= torture_setup_unix_extensions(cli1
);
5312 if (!NT_STATUS_IS_OK(status
)) {
5316 cli_setatr(cli1
, fname
, 0, 0);
5317 cli_posix_unlink(cli1
, fname
);
5318 cli_setatr(cli1
, dname
, 0, 0);
5319 cli_posix_rmdir(cli1
, dname
);
5320 cli_setatr(cli1
, hname
, 0, 0);
5321 cli_posix_unlink(cli1
, hname
);
5322 cli_setatr(cli1
, sname
, 0, 0);
5323 cli_posix_unlink(cli1
, sname
);
5325 /* Create a directory. */
5326 status
= cli_posix_mkdir(cli1
, dname
, 0777);
5327 if (!NT_STATUS_IS_OK(status
)) {
5328 printf("POSIX mkdir of %s failed (%s)\n", dname
, nt_errstr(status
));
5332 status
= cli_posix_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
,
5334 if (!NT_STATUS_IS_OK(status
)) {
5335 printf("POSIX create of %s failed (%s)\n", fname
, nt_errstr(status
));
5339 /* Test ftruncate - set file size. */
5340 status
= cli_ftruncate(cli1
, fnum1
, 1000);
5341 if (!NT_STATUS_IS_OK(status
)) {
5342 printf("ftruncate failed (%s)\n", nt_errstr(status
));
5346 /* Ensure st_size == 1000 */
5347 status
= cli_posix_stat(cli1
, fname
, &sbuf
);
5348 if (!NT_STATUS_IS_OK(status
)) {
5349 printf("stat failed (%s)\n", nt_errstr(status
));
5353 if (sbuf
.st_ex_size
!= 1000) {
5354 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf
.st_ex_size
);
5358 /* Test ftruncate - set file size back to zero. */
5359 status
= cli_ftruncate(cli1
, fnum1
, 0);
5360 if (!NT_STATUS_IS_OK(status
)) {
5361 printf("ftruncate failed (%s)\n", nt_errstr(status
));
5365 status
= cli_close(cli1
, fnum1
);
5366 if (!NT_STATUS_IS_OK(status
)) {
5367 printf("close failed (%s)\n", nt_errstr(status
));
5371 /* Now open the file again for read only. */
5372 status
= cli_posix_open(cli1
, fname
, O_RDONLY
, 0, &fnum1
);
5373 if (!NT_STATUS_IS_OK(status
)) {
5374 printf("POSIX open of %s failed (%s)\n", fname
, nt_errstr(status
));
5378 /* Now unlink while open. */
5379 status
= cli_posix_unlink(cli1
, fname
);
5380 if (!NT_STATUS_IS_OK(status
)) {
5381 printf("POSIX unlink of %s failed (%s)\n", fname
, nt_errstr(status
));
5385 status
= cli_close(cli1
, fnum1
);
5386 if (!NT_STATUS_IS_OK(status
)) {
5387 printf("close(2) failed (%s)\n", nt_errstr(status
));
5391 /* Ensure the file has gone. */
5392 status
= cli_posix_open(cli1
, fname
, O_RDONLY
, 0, &fnum1
);
5393 if (NT_STATUS_IS_OK(status
)) {
5394 printf("POSIX open of %s succeeded, should have been deleted.\n", fname
);
5398 /* Create again to test open with O_TRUNC. */
5399 status
= cli_posix_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, 0600, &fnum1
);
5400 if (!NT_STATUS_IS_OK(status
)) {
5401 printf("POSIX create of %s failed (%s)\n", fname
, nt_errstr(status
));
5405 /* Test ftruncate - set file size. */
5406 status
= cli_ftruncate(cli1
, fnum1
, 1000);
5407 if (!NT_STATUS_IS_OK(status
)) {
5408 printf("ftruncate failed (%s)\n", nt_errstr(status
));
5412 /* Ensure st_size == 1000 */
5413 status
= cli_posix_stat(cli1
, fname
, &sbuf
);
5414 if (!NT_STATUS_IS_OK(status
)) {
5415 printf("stat failed (%s)\n", nt_errstr(status
));
5419 if (sbuf
.st_ex_size
!= 1000) {
5420 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf
.st_ex_size
);
5424 status
= cli_close(cli1
, fnum1
);
5425 if (!NT_STATUS_IS_OK(status
)) {
5426 printf("close(2) failed (%s)\n", nt_errstr(status
));
5430 /* Re-open with O_TRUNC. */
5431 status
= cli_posix_open(cli1
, fname
, O_WRONLY
|O_TRUNC
, 0600, &fnum1
);
5432 if (!NT_STATUS_IS_OK(status
)) {
5433 printf("POSIX create of %s failed (%s)\n", fname
, nt_errstr(status
));
5437 /* Ensure st_size == 0 */
5438 status
= cli_posix_stat(cli1
, fname
, &sbuf
);
5439 if (!NT_STATUS_IS_OK(status
)) {
5440 printf("stat failed (%s)\n", nt_errstr(status
));
5444 if (sbuf
.st_ex_size
!= 0) {
5445 printf("O_TRUNC - stat size (%u) != 0\n", (unsigned int)sbuf
.st_ex_size
);
5449 status
= cli_close(cli1
, fnum1
);
5450 if (!NT_STATUS_IS_OK(status
)) {
5451 printf("close failed (%s)\n", nt_errstr(status
));
5455 status
= cli_posix_unlink(cli1
, fname
);
5456 if (!NT_STATUS_IS_OK(status
)) {
5457 printf("POSIX unlink of %s failed (%s)\n", fname
, nt_errstr(status
));
5461 status
= cli_posix_open(cli1
, dname
, O_RDONLY
, 0, &fnum1
);
5462 if (!NT_STATUS_IS_OK(status
)) {
5463 printf("POSIX open directory O_RDONLY of %s failed (%s)\n",
5464 dname
, nt_errstr(status
));
5468 cli_close(cli1
, fnum1
);
5470 /* What happens when we try and POSIX open a directory for write ? */
5471 status
= cli_posix_open(cli1
, dname
, O_RDWR
, 0, &fnum1
);
5472 if (NT_STATUS_IS_OK(status
)) {
5473 printf("POSIX open of directory %s succeeded, should have failed.\n", fname
);
5476 if (!check_both_error(__LINE__
, status
, ERRDOS
, EISDIR
,
5477 NT_STATUS_FILE_IS_A_DIRECTORY
)) {
5482 /* Create the file. */
5483 status
= cli_posix_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
,
5485 if (!NT_STATUS_IS_OK(status
)) {
5486 printf("POSIX create of %s failed (%s)\n", fname
, nt_errstr(status
));
5490 /* Write some data into it. */
5491 status
= cli_writeall(cli1
, fnum1
, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
5493 if (!NT_STATUS_IS_OK(status
)) {
5494 printf("cli_write failed: %s\n", nt_errstr(status
));
5498 cli_close(cli1
, fnum1
);
5500 /* Now create a hardlink. */
5501 status
= cli_posix_hardlink(cli1
, fname
, hname
);
5502 if (!NT_STATUS_IS_OK(status
)) {
5503 printf("POSIX hardlink of %s failed (%s)\n", hname
, nt_errstr(status
));
5507 /* Now create a symlink. */
5508 status
= cli_posix_symlink(cli1
, fname
, sname
);
5509 if (!NT_STATUS_IS_OK(status
)) {
5510 printf("POSIX symlink of %s failed (%s)\n", sname
, nt_errstr(status
));
5514 /* Open the hardlink for read. */
5515 status
= cli_posix_open(cli1
, hname
, O_RDONLY
, 0, &fnum1
);
5516 if (!NT_STATUS_IS_OK(status
)) {
5517 printf("POSIX open of %s failed (%s)\n", hname
, nt_errstr(status
));
5521 status
= cli_read(cli1
, fnum1
, buf
, 0, 10, &nread
);
5522 if (!NT_STATUS_IS_OK(status
)) {
5523 printf("POSIX read of %s failed (%s)\n", hname
,
5526 } else if (nread
!= 10) {
5527 printf("POSIX read of %s failed. Received %ld, expected %d\n",
5528 hname
, (unsigned long)nread
, 10);
5532 if (memcmp(buf
, "TEST DATA\n", 10)) {
5533 printf("invalid data read from hardlink\n");
5537 /* Do a POSIX lock/unlock. */
5538 status
= cli_posix_lock(cli1
, fnum1
, 0, 100, true, READ_LOCK
);
5539 if (!NT_STATUS_IS_OK(status
)) {
5540 printf("POSIX lock failed %s\n", nt_errstr(status
));
5544 /* Punch a hole in the locked area. */
5545 status
= cli_posix_unlock(cli1
, fnum1
, 10, 80);
5546 if (!NT_STATUS_IS_OK(status
)) {
5547 printf("POSIX unlock failed %s\n", nt_errstr(status
));
5551 cli_close(cli1
, fnum1
);
5553 /* Open the symlink for read - this should fail. A POSIX
5554 client should not be doing opens on a symlink. */
5555 status
= cli_posix_open(cli1
, sname
, O_RDONLY
, 0, &fnum1
);
5556 if (NT_STATUS_IS_OK(status
)) {
5557 printf("POSIX open of %s succeeded (should have failed)\n", sname
);
5560 if (!check_both_error(__LINE__
, status
, ERRDOS
, ERRbadpath
,
5561 NT_STATUS_OBJECT_PATH_NOT_FOUND
)) {
5562 printf("POSIX open of %s should have failed "
5563 "with NT_STATUS_OBJECT_PATH_NOT_FOUND, "
5564 "failed with %s instead.\n",
5565 sname
, nt_errstr(status
));
5570 status
= cli_posix_readlink(cli1
, sname
, namebuf
, sizeof(namebuf
));
5571 if (!NT_STATUS_IS_OK(status
)) {
5572 printf("POSIX readlink on %s failed (%s)\n", sname
, nt_errstr(status
));
5576 if (strcmp(namebuf
, fname
) != 0) {
5577 printf("POSIX readlink on %s failed to match name %s (read %s)\n",
5578 sname
, fname
, namebuf
);
5582 status
= cli_posix_rmdir(cli1
, dname
);
5583 if (!NT_STATUS_IS_OK(status
)) {
5584 printf("POSIX rmdir failed (%s)\n", nt_errstr(status
));
5588 printf("Simple POSIX open test passed\n");
5593 if (fnum1
!= (uint16_t)-1) {
5594 cli_close(cli1
, fnum1
);
5595 fnum1
= (uint16_t)-1;
5598 cli_setatr(cli1
, sname
, 0, 0);
5599 cli_posix_unlink(cli1
, sname
);
5600 cli_setatr(cli1
, hname
, 0, 0);
5601 cli_posix_unlink(cli1
, hname
);
5602 cli_setatr(cli1
, fname
, 0, 0);
5603 cli_posix_unlink(cli1
, fname
);
5604 cli_setatr(cli1
, dname
, 0, 0);
5605 cli_posix_rmdir(cli1
, dname
);
5607 if (!torture_close_connection(cli1
)) {
5615 static uint32 open_attrs_table
[] = {
5616 FILE_ATTRIBUTE_NORMAL
,
5617 FILE_ATTRIBUTE_ARCHIVE
,
5618 FILE_ATTRIBUTE_READONLY
,
5619 FILE_ATTRIBUTE_HIDDEN
,
5620 FILE_ATTRIBUTE_SYSTEM
,
5622 FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
,
5623 FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_HIDDEN
,
5624 FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_SYSTEM
,
5625 FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_HIDDEN
,
5626 FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_SYSTEM
,
5627 FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_HIDDEN
|FILE_ATTRIBUTE_SYSTEM
,
5629 FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_HIDDEN
,
5630 FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_SYSTEM
,
5631 FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_HIDDEN
|FILE_ATTRIBUTE_SYSTEM
,
5632 FILE_ATTRIBUTE_HIDDEN
,FILE_ATTRIBUTE_SYSTEM
,
5635 struct trunc_open_results
{
5642 static struct trunc_open_results attr_results
[] = {
5643 { 0, FILE_ATTRIBUTE_NORMAL
, FILE_ATTRIBUTE_NORMAL
, FILE_ATTRIBUTE_ARCHIVE
},
5644 { 1, FILE_ATTRIBUTE_NORMAL
, FILE_ATTRIBUTE_ARCHIVE
, FILE_ATTRIBUTE_ARCHIVE
},
5645 { 2, FILE_ATTRIBUTE_NORMAL
, FILE_ATTRIBUTE_READONLY
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
},
5646 { 16, FILE_ATTRIBUTE_ARCHIVE
, FILE_ATTRIBUTE_NORMAL
, FILE_ATTRIBUTE_ARCHIVE
},
5647 { 17, FILE_ATTRIBUTE_ARCHIVE
, FILE_ATTRIBUTE_ARCHIVE
, FILE_ATTRIBUTE_ARCHIVE
},
5648 { 18, FILE_ATTRIBUTE_ARCHIVE
, FILE_ATTRIBUTE_READONLY
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
},
5649 { 51, FILE_ATTRIBUTE_HIDDEN
, FILE_ATTRIBUTE_HIDDEN
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_HIDDEN
},
5650 { 54, FILE_ATTRIBUTE_HIDDEN
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_HIDDEN
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_HIDDEN
},
5651 { 56, FILE_ATTRIBUTE_HIDDEN
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_HIDDEN
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_HIDDEN
},
5652 { 68, FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_SYSTEM
},
5653 { 71, FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_SYSTEM
},
5654 { 73, FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_SYSTEM
},
5655 { 99, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_HIDDEN
, FILE_ATTRIBUTE_HIDDEN
,FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_HIDDEN
},
5656 { 102, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_HIDDEN
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_HIDDEN
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_HIDDEN
},
5657 { 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
},
5658 { 116, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_SYSTEM
},
5659 { 119, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_SYSTEM
},
5660 { 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
},
5661 { 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
},
5662 { 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
},
5663 { 227, FILE_ATTRIBUTE_HIDDEN
, FILE_ATTRIBUTE_HIDDEN
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_HIDDEN
},
5664 { 230, FILE_ATTRIBUTE_HIDDEN
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_HIDDEN
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_HIDDEN
},
5665 { 232, FILE_ATTRIBUTE_HIDDEN
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_HIDDEN
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_HIDDEN
},
5666 { 244, FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_SYSTEM
},
5667 { 247, FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_SYSTEM
},
5668 { 249, FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_SYSTEM
, FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_SYSTEM
}
5671 static bool run_openattrtest(int dummy
)
5673 static struct cli_state
*cli1
;
5674 const char *fname
= "\\openattr.file";
5676 bool correct
= True
;
5678 unsigned int i
, j
, k
, l
;
5681 printf("starting open attr test\n");
5683 if (!torture_open_connection(&cli1
, 0)) {
5687 cli_sockopt(cli1
, sockops
);
5689 for (k
= 0, i
= 0; i
< sizeof(open_attrs_table
)/sizeof(uint32
); i
++) {
5690 cli_setatr(cli1
, fname
, 0, 0);
5691 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
5693 status
= cli_ntcreate(cli1
, fname
, 0, FILE_WRITE_DATA
,
5694 open_attrs_table
[i
], FILE_SHARE_NONE
,
5695 FILE_OVERWRITE_IF
, 0, 0, &fnum1
);
5696 if (!NT_STATUS_IS_OK(status
)) {
5697 printf("open %d (1) of %s failed (%s)\n", i
, fname
, nt_errstr(status
));
5701 status
= cli_close(cli1
, fnum1
);
5702 if (!NT_STATUS_IS_OK(status
)) {
5703 printf("close %d (1) of %s failed (%s)\n", i
, fname
, nt_errstr(status
));
5707 for (j
= 0; j
< sizeof(open_attrs_table
)/sizeof(uint32
); j
++) {
5708 status
= cli_ntcreate(cli1
, fname
, 0,
5709 FILE_READ_DATA
|FILE_WRITE_DATA
,
5710 open_attrs_table
[j
],
5711 FILE_SHARE_NONE
, FILE_OVERWRITE
,
5713 if (!NT_STATUS_IS_OK(status
)) {
5714 for (l
= 0; l
< sizeof(attr_results
)/sizeof(struct trunc_open_results
); l
++) {
5715 if (attr_results
[l
].num
== k
) {
5716 printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
5717 k
, open_attrs_table
[i
],
5718 open_attrs_table
[j
],
5719 fname
, NT_STATUS_V(status
), nt_errstr(status
));
5724 if (!NT_STATUS_EQUAL(status
, NT_STATUS_ACCESS_DENIED
)) {
5725 printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n",
5726 k
, open_attrs_table
[i
], open_attrs_table
[j
],
5731 printf("[%d] trunc open 0x%x -> 0x%x failed\n", k
, open_attrs_table
[i
], open_attrs_table
[j
]);
5737 status
= cli_close(cli1
, fnum1
);
5738 if (!NT_STATUS_IS_OK(status
)) {
5739 printf("close %d (2) of %s failed (%s)\n", j
, fname
, nt_errstr(status
));
5743 status
= cli_getatr(cli1
, fname
, &attr
, NULL
, NULL
);
5744 if (!NT_STATUS_IS_OK(status
)) {
5745 printf("getatr(2) failed (%s)\n", nt_errstr(status
));
5750 printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
5751 k
, open_attrs_table
[i
], open_attrs_table
[j
], attr
);
5754 for (l
= 0; l
< sizeof(attr_results
)/sizeof(struct trunc_open_results
); l
++) {
5755 if (attr_results
[l
].num
== k
) {
5756 if (attr
!= attr_results
[l
].result_attr
||
5757 open_attrs_table
[i
] != attr_results
[l
].init_attr
||
5758 open_attrs_table
[j
] != attr_results
[l
].trunc_attr
) {
5759 printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
5760 open_attrs_table
[i
],
5761 open_attrs_table
[j
],
5763 attr_results
[l
].result_attr
);
5773 cli_setatr(cli1
, fname
, 0, 0);
5774 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
5776 printf("open attr test %s.\n", correct
? "passed" : "failed");
5778 if (!torture_close_connection(cli1
)) {
5784 static NTSTATUS
list_fn(const char *mnt
, struct file_info
*finfo
,
5785 const char *name
, void *state
)
5787 int *matched
= (int *)state
;
5788 if (matched
!= NULL
) {
5791 return NT_STATUS_OK
;
5795 test directory listing speed
5797 static bool run_dirtest(int dummy
)
5800 static struct cli_state
*cli
;
5802 struct timeval core_start
;
5803 bool correct
= True
;
5806 printf("starting directory test\n");
5808 if (!torture_open_connection(&cli
, 0)) {
5812 cli_sockopt(cli
, sockops
);
5815 for (i
=0;i
<torture_numops
;i
++) {
5817 slprintf(fname
, sizeof(fname
), "\\%x", (int)random());
5818 if (!NT_STATUS_IS_OK(cli_open(cli
, fname
, O_RDWR
|O_CREAT
, DENY_NONE
, &fnum
))) {
5819 fprintf(stderr
,"Failed to open %s\n", fname
);
5822 cli_close(cli
, fnum
);
5825 core_start
= timeval_current();
5828 cli_list(cli
, "a*.*", 0, list_fn
, &matched
);
5829 printf("Matched %d\n", matched
);
5832 cli_list(cli
, "b*.*", 0, list_fn
, &matched
);
5833 printf("Matched %d\n", matched
);
5836 cli_list(cli
, "xyzabc", 0, list_fn
, &matched
);
5837 printf("Matched %d\n", matched
);
5839 printf("dirtest core %g seconds\n", timeval_elapsed(&core_start
));
5842 for (i
=0;i
<torture_numops
;i
++) {
5844 slprintf(fname
, sizeof(fname
), "\\%x", (int)random());
5845 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
5848 if (!torture_close_connection(cli
)) {
5852 printf("finished dirtest\n");
5857 static NTSTATUS
del_fn(const char *mnt
, struct file_info
*finfo
, const char *mask
,
5860 struct cli_state
*pcli
= (struct cli_state
*)state
;
5862 slprintf(fname
, sizeof(fname
), "\\LISTDIR\\%s", finfo
->name
);
5864 if (strcmp(finfo
->name
, ".") == 0 || strcmp(finfo
->name
, "..") == 0)
5865 return NT_STATUS_OK
;
5867 if (finfo
->mode
& FILE_ATTRIBUTE_DIRECTORY
) {
5868 if (!NT_STATUS_IS_OK(cli_rmdir(pcli
, fname
)))
5869 printf("del_fn: failed to rmdir %s\n,", fname
);
5871 if (!NT_STATUS_IS_OK(cli_unlink(pcli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
)))
5872 printf("del_fn: failed to unlink %s\n,", fname
);
5874 return NT_STATUS_OK
;
5879 sees what IOCTLs are supported
5881 bool torture_ioctl_test(int dummy
)
5883 static struct cli_state
*cli
;
5884 uint16_t device
, function
;
5886 const char *fname
= "\\ioctl.dat";
5890 if (!torture_open_connection(&cli
, 0)) {
5894 printf("starting ioctl test\n");
5896 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
5898 status
= cli_open(cli
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
, &fnum
);
5899 if (!NT_STATUS_IS_OK(status
)) {
5900 printf("open of %s failed (%s)\n", fname
, nt_errstr(status
));
5904 status
= cli_raw_ioctl(cli
, fnum
, 0x2d0000 | (0x0420<<2), &blob
);
5905 printf("ioctl device info: %s\n", nt_errstr(status
));
5907 status
= cli_raw_ioctl(cli
, fnum
, IOCTL_QUERY_JOB_INFO
, &blob
);
5908 printf("ioctl job info: %s\n", nt_errstr(status
));
5910 for (device
=0;device
<0x100;device
++) {
5911 printf("ioctl test with device = 0x%x\n", device
);
5912 for (function
=0;function
<0x100;function
++) {
5913 uint32 code
= (device
<<16) | function
;
5915 status
= cli_raw_ioctl(cli
, fnum
, code
, &blob
);
5917 if (NT_STATUS_IS_OK(status
)) {
5918 printf("ioctl 0x%x OK : %d bytes\n", (int)code
,
5920 data_blob_free(&blob
);
5925 if (!torture_close_connection(cli
)) {
5934 tries varients of chkpath
5936 bool torture_chkpath_test(int dummy
)
5938 static struct cli_state
*cli
;
5943 if (!torture_open_connection(&cli
, 0)) {
5947 printf("starting chkpath test\n");
5949 /* cleanup from an old run */
5950 cli_rmdir(cli
, "\\chkpath.dir\\dir2");
5951 cli_unlink(cli
, "\\chkpath.dir\\*", FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
5952 cli_rmdir(cli
, "\\chkpath.dir");
5954 status
= cli_mkdir(cli
, "\\chkpath.dir");
5955 if (!NT_STATUS_IS_OK(status
)) {
5956 printf("mkdir1 failed : %s\n", nt_errstr(status
));
5960 status
= cli_mkdir(cli
, "\\chkpath.dir\\dir2");
5961 if (!NT_STATUS_IS_OK(status
)) {
5962 printf("mkdir2 failed : %s\n", nt_errstr(status
));
5966 status
= cli_open(cli
, "\\chkpath.dir\\foo.txt", O_RDWR
|O_CREAT
|O_EXCL
,
5968 if (!NT_STATUS_IS_OK(status
)) {
5969 printf("open1 failed (%s)\n", nt_errstr(status
));
5972 cli_close(cli
, fnum
);
5974 status
= cli_chkpath(cli
, "\\chkpath.dir");
5975 if (!NT_STATUS_IS_OK(status
)) {
5976 printf("chkpath1 failed: %s\n", nt_errstr(status
));
5980 status
= cli_chkpath(cli
, "\\chkpath.dir\\dir2");
5981 if (!NT_STATUS_IS_OK(status
)) {
5982 printf("chkpath2 failed: %s\n", nt_errstr(status
));
5986 status
= cli_chkpath(cli
, "\\chkpath.dir\\foo.txt");
5987 if (!NT_STATUS_IS_OK(status
)) {
5988 ret
= check_error(__LINE__
, cli
, ERRDOS
, ERRbadpath
,
5989 NT_STATUS_NOT_A_DIRECTORY
);
5991 printf("* chkpath on a file should fail\n");
5995 if (!NT_STATUS_IS_OK(cli_chkpath(cli
, "\\chkpath.dir\\bar.txt"))) {
5996 ret
= check_error(__LINE__
, cli
, ERRDOS
, ERRbadfile
,
5997 NT_STATUS_OBJECT_NAME_NOT_FOUND
);
5999 printf("* chkpath on a non existant file should fail\n");
6003 if (!NT_STATUS_IS_OK(cli_chkpath(cli
, "\\chkpath.dir\\dirxx\\bar.txt"))) {
6004 ret
= check_error(__LINE__
, cli
, ERRDOS
, ERRbadpath
,
6005 NT_STATUS_OBJECT_PATH_NOT_FOUND
);
6007 printf("* chkpath on a non existent component should fail\n");
6011 cli_rmdir(cli
, "\\chkpath.dir\\dir2");
6012 cli_unlink(cli
, "\\chkpath.dir\\*", FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
6013 cli_rmdir(cli
, "\\chkpath.dir");
6015 if (!torture_close_connection(cli
)) {
6022 static bool run_eatest(int dummy
)
6024 static struct cli_state
*cli
;
6025 const char *fname
= "\\eatest.txt";
6026 bool correct
= True
;
6030 struct ea_struct
*ea_list
= NULL
;
6031 TALLOC_CTX
*mem_ctx
= talloc_init("eatest");
6034 printf("starting eatest\n");
6036 if (!torture_open_connection(&cli
, 0)) {
6037 talloc_destroy(mem_ctx
);
6041 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
6043 status
= cli_ntcreate(cli
, fname
, 0,
6044 FIRST_DESIRED_ACCESS
, FILE_ATTRIBUTE_ARCHIVE
,
6045 FILE_SHARE_NONE
, FILE_OVERWRITE_IF
,
6047 if (!NT_STATUS_IS_OK(status
)) {
6048 printf("open failed - %s\n", nt_errstr(status
));
6049 talloc_destroy(mem_ctx
);
6053 for (i
= 0; i
< 10; i
++) {
6054 fstring ea_name
, ea_val
;
6056 slprintf(ea_name
, sizeof(ea_name
), "EA_%d", i
);
6057 memset(ea_val
, (char)i
+1, i
+1);
6058 status
= cli_set_ea_fnum(cli
, fnum
, ea_name
, ea_val
, i
+1);
6059 if (!NT_STATUS_IS_OK(status
)) {
6060 printf("ea_set of name %s failed - %s\n", ea_name
,
6062 talloc_destroy(mem_ctx
);
6067 cli_close(cli
, fnum
);
6068 for (i
= 0; i
< 10; i
++) {
6069 fstring ea_name
, ea_val
;
6071 slprintf(ea_name
, sizeof(ea_name
), "EA_%d", i
+10);
6072 memset(ea_val
, (char)i
+1, i
+1);
6073 status
= cli_set_ea_path(cli
, fname
, ea_name
, ea_val
, i
+1);
6074 if (!NT_STATUS_IS_OK(status
)) {
6075 printf("ea_set of name %s failed - %s\n", ea_name
,
6077 talloc_destroy(mem_ctx
);
6082 status
= cli_get_ea_list_path(cli
, fname
, mem_ctx
, &num_eas
, &ea_list
);
6083 if (!NT_STATUS_IS_OK(status
)) {
6084 printf("ea_get list failed - %s\n", nt_errstr(status
));
6088 printf("num_eas = %d\n", (int)num_eas
);
6090 if (num_eas
!= 20) {
6091 printf("Should be 20 EA's stored... failing.\n");
6095 for (i
= 0; i
< num_eas
; i
++) {
6096 printf("%d: ea_name = %s. Val = ", i
, ea_list
[i
].name
);
6097 dump_data(0, ea_list
[i
].value
.data
,
6098 ea_list
[i
].value
.length
);
6101 /* Setting EA's to zero length deletes them. Test this */
6102 printf("Now deleting all EA's - case indepenent....\n");
6105 cli_set_ea_path(cli
, fname
, "", "", 0);
6107 for (i
= 0; i
< 20; i
++) {
6109 slprintf(ea_name
, sizeof(ea_name
), "ea_%d", i
);
6110 status
= cli_set_ea_path(cli
, fname
, ea_name
, "", 0);
6111 if (!NT_STATUS_IS_OK(status
)) {
6112 printf("ea_set of name %s failed - %s\n", ea_name
,
6114 talloc_destroy(mem_ctx
);
6120 status
= cli_get_ea_list_path(cli
, fname
, mem_ctx
, &num_eas
, &ea_list
);
6121 if (!NT_STATUS_IS_OK(status
)) {
6122 printf("ea_get list failed - %s\n", nt_errstr(status
));
6126 printf("num_eas = %d\n", (int)num_eas
);
6127 for (i
= 0; i
< num_eas
; i
++) {
6128 printf("%d: ea_name = %s. Val = ", i
, ea_list
[i
].name
);
6129 dump_data(0, ea_list
[i
].value
.data
,
6130 ea_list
[i
].value
.length
);
6134 printf("deleting EA's failed.\n");
6138 /* Try and delete a non existant EA. */
6139 status
= cli_set_ea_path(cli
, fname
, "foo", "", 0);
6140 if (!NT_STATUS_IS_OK(status
)) {
6141 printf("deleting non-existant EA 'foo' should succeed. %s\n",
6146 talloc_destroy(mem_ctx
);
6147 if (!torture_close_connection(cli
)) {
6154 static bool run_dirtest1(int dummy
)
6157 static struct cli_state
*cli
;
6160 bool correct
= True
;
6162 printf("starting directory test\n");
6164 if (!torture_open_connection(&cli
, 0)) {
6168 cli_sockopt(cli
, sockops
);
6170 cli_list(cli
, "\\LISTDIR\\*", 0, del_fn
, cli
);
6171 cli_list(cli
, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY
, del_fn
, cli
);
6172 cli_rmdir(cli
, "\\LISTDIR");
6173 cli_mkdir(cli
, "\\LISTDIR");
6175 /* Create 1000 files and 1000 directories. */
6176 for (i
=0;i
<1000;i
++) {
6178 slprintf(fname
, sizeof(fname
), "\\LISTDIR\\f%d", i
);
6179 if (!NT_STATUS_IS_OK(cli_ntcreate(cli
, fname
, 0, GENERIC_ALL_ACCESS
, FILE_ATTRIBUTE_ARCHIVE
,
6180 FILE_SHARE_READ
|FILE_SHARE_WRITE
, FILE_OVERWRITE_IF
, 0, 0, &fnum
))) {
6181 fprintf(stderr
,"Failed to open %s\n", fname
);
6184 cli_close(cli
, fnum
);
6186 for (i
=0;i
<1000;i
++) {
6188 slprintf(fname
, sizeof(fname
), "\\LISTDIR\\d%d", i
);
6189 if (!NT_STATUS_IS_OK(cli_mkdir(cli
, fname
))) {
6190 fprintf(stderr
,"Failed to open %s\n", fname
);
6195 /* Now ensure that doing an old list sees both files and directories. */
6197 cli_list_old(cli
, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY
, list_fn
, &num_seen
);
6198 printf("num_seen = %d\n", num_seen
);
6199 /* We should see 100 files + 1000 directories + . and .. */
6200 if (num_seen
!= 2002)
6203 /* Ensure if we have the "must have" bits we only see the
6207 cli_list_old(cli
, "\\LISTDIR\\*", (FILE_ATTRIBUTE_DIRECTORY
<<8)|FILE_ATTRIBUTE_DIRECTORY
, list_fn
, &num_seen
);
6208 printf("num_seen = %d\n", num_seen
);
6209 if (num_seen
!= 1002)
6213 cli_list_old(cli
, "\\LISTDIR\\*", (FILE_ATTRIBUTE_ARCHIVE
<<8)|FILE_ATTRIBUTE_DIRECTORY
, list_fn
, &num_seen
);
6214 printf("num_seen = %d\n", num_seen
);
6215 if (num_seen
!= 1000)
6218 /* Delete everything. */
6219 cli_list(cli
, "\\LISTDIR\\*", 0, del_fn
, cli
);
6220 cli_list(cli
, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY
, del_fn
, cli
);
6221 cli_rmdir(cli
, "\\LISTDIR");
6224 printf("Matched %d\n", cli_list(cli
, "a*.*", 0, list_fn
, NULL
));
6225 printf("Matched %d\n", cli_list(cli
, "b*.*", 0, list_fn
, NULL
));
6226 printf("Matched %d\n", cli_list(cli
, "xyzabc", 0, list_fn
, NULL
));
6229 if (!torture_close_connection(cli
)) {
6233 printf("finished dirtest1\n");
6238 static bool run_error_map_extract(int dummy
) {
6240 static struct cli_state
*c_dos
;
6241 static struct cli_state
*c_nt
;
6253 /* NT-Error connection */
6255 if (!(c_nt
= open_nbt_connection())) {
6259 c_nt
->use_spnego
= False
;
6261 status
= cli_negprot(c_nt
);
6263 if (!NT_STATUS_IS_OK(status
)) {
6264 printf("%s rejected the NT-error negprot (%s)\n", host
,
6270 status
= cli_session_setup(c_nt
, "", "", 0, "", 0, workgroup
);
6271 if (!NT_STATUS_IS_OK(status
)) {
6272 printf("%s rejected the NT-error initial session setup (%s)\n",host
, nt_errstr(status
));
6276 /* DOS-Error connection */
6278 if (!(c_dos
= open_nbt_connection())) {
6282 c_dos
->use_spnego
= False
;
6283 c_dos
->force_dos_errors
= True
;
6285 status
= cli_negprot(c_dos
);
6286 if (!NT_STATUS_IS_OK(status
)) {
6287 printf("%s rejected the DOS-error negprot (%s)\n", host
,
6289 cli_shutdown(c_dos
);
6293 status
= cli_session_setup(c_dos
, "", "", 0, "", 0, workgroup
);
6294 if (!NT_STATUS_IS_OK(status
)) {
6295 printf("%s rejected the DOS-error initial session setup (%s)\n",
6296 host
, nt_errstr(status
));
6300 for (error
=(0xc0000000 | 0x1); error
< (0xc0000000| 0xFFF); error
++) {
6301 fstr_sprintf(user
, "%X", error
);
6303 status
= cli_session_setup(c_nt
, user
,
6304 password
, strlen(password
),
6305 password
, strlen(password
),
6307 if (NT_STATUS_IS_OK(status
)) {
6308 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
6311 /* Case #1: 32-bit NT errors */
6312 if (cli_is_nt_error(c_nt
)) {
6313 nt_status
= cli_nt_error(c_nt
);
6315 printf("/** Dos error on NT connection! (%s) */\n",
6317 nt_status
= NT_STATUS(0xc0000000);
6320 status
= cli_session_setup(c_dos
, user
,
6321 password
, strlen(password
),
6322 password
, strlen(password
),
6324 if (NT_STATUS_IS_OK(status
)) {
6325 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
6328 /* Case #1: 32-bit NT errors */
6329 if (!cli_is_dos_error(c_dos
)) {
6330 printf("/** NT error on DOS connection! (%s) */\n",
6332 errnum
= errclass
= 0;
6334 cli_dos_error(c_dos
, &errclass
, &errnum
);
6337 if (NT_STATUS_V(nt_status
) != error
) {
6338 printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n",
6339 get_nt_error_c_code(talloc_tos(), NT_STATUS(error
)),
6340 get_nt_error_c_code(talloc_tos(), nt_status
));
6343 printf("\t{%s,\t%s,\t%s},\n",
6344 smb_dos_err_class(errclass
),
6345 smb_dos_err_name(errclass
, errnum
),
6346 get_nt_error_c_code(talloc_tos(), NT_STATUS(error
)));
6351 static bool run_sesssetup_bench(int dummy
)
6353 static struct cli_state
*c
;
6354 const char *fname
= "\\file.dat";
6359 if (!torture_open_connection(&c
, 0)) {
6363 status
= cli_ntcreate(c
, fname
, 0, GENERIC_ALL_ACCESS
|DELETE_ACCESS
,
6364 FILE_ATTRIBUTE_NORMAL
, 0, FILE_OVERWRITE_IF
,
6365 FILE_DELETE_ON_CLOSE
, 0, &fnum
);
6366 if (!NT_STATUS_IS_OK(status
)) {
6367 d_printf("open %s failed: %s\n", fname
, nt_errstr(status
));
6371 for (i
=0; i
<torture_numops
; i
++) {
6372 status
= cli_session_setup(
6374 password
, strlen(password
),
6375 password
, strlen(password
),
6377 if (!NT_STATUS_IS_OK(status
)) {
6378 d_printf("(%s) cli_session_setup failed: %s\n",
6379 __location__
, nt_errstr(status
));
6383 d_printf("\r%d ", (int)cli_state_get_uid(c
));
6385 status
= cli_ulogoff(c
);
6386 if (!NT_STATUS_IS_OK(status
)) {
6387 d_printf("(%s) cli_ulogoff failed: %s\n",
6388 __location__
, nt_errstr(status
));
6396 static bool subst_test(const char *str
, const char *user
, const char *domain
,
6397 uid_t uid
, gid_t gid
, const char *expected
)
6402 subst
= talloc_sub_specified(talloc_tos(), str
, user
, domain
, uid
, gid
);
6404 if (strcmp(subst
, expected
) != 0) {
6405 printf("sub_specified(%s, %s, %s, %d, %d) returned [%s], expected "
6406 "[%s]\n", str
, user
, domain
, (int)uid
, (int)gid
, subst
,
6415 static void chain1_open_completion(struct tevent_req
*req
)
6419 status
= cli_open_recv(req
, &fnum
);
6422 d_printf("cli_open_recv returned %s: %d\n",
6424 NT_STATUS_IS_OK(status
) ? fnum
: -1);
6427 static void chain1_write_completion(struct tevent_req
*req
)
6431 status
= cli_write_andx_recv(req
, &written
);
6434 d_printf("cli_write_andx_recv returned %s: %d\n",
6436 NT_STATUS_IS_OK(status
) ? (int)written
: -1);
6439 static void chain1_close_completion(struct tevent_req
*req
)
6442 bool *done
= (bool *)tevent_req_callback_data_void(req
);
6444 status
= cli_close_recv(req
);
6449 d_printf("cli_close returned %s\n", nt_errstr(status
));
6452 static bool run_chain1(int dummy
)
6454 struct cli_state
*cli1
;
6455 struct event_context
*evt
= event_context_init(NULL
);
6456 struct tevent_req
*reqs
[3], *smbreqs
[3];
6458 const char *str
= "foobar";
6461 printf("starting chain1 test\n");
6462 if (!torture_open_connection(&cli1
, 0)) {
6466 cli_sockopt(cli1
, sockops
);
6468 reqs
[0] = cli_open_create(talloc_tos(), evt
, cli1
, "\\test",
6469 O_CREAT
|O_RDWR
, 0, &smbreqs
[0]);
6470 if (reqs
[0] == NULL
) return false;
6471 tevent_req_set_callback(reqs
[0], chain1_open_completion
, NULL
);
6474 reqs
[1] = cli_write_andx_create(talloc_tos(), evt
, cli1
, 0, 0,
6475 (const uint8_t *)str
, 0, strlen(str
)+1,
6476 smbreqs
, 1, &smbreqs
[1]);
6477 if (reqs
[1] == NULL
) return false;
6478 tevent_req_set_callback(reqs
[1], chain1_write_completion
, NULL
);
6480 reqs
[2] = cli_close_create(talloc_tos(), evt
, cli1
, 0, &smbreqs
[2]);
6481 if (reqs
[2] == NULL
) return false;
6482 tevent_req_set_callback(reqs
[2], chain1_close_completion
, &done
);
6484 status
= cli_smb_chain_send(smbreqs
, ARRAY_SIZE(smbreqs
));
6485 if (!NT_STATUS_IS_OK(status
)) {
6490 event_loop_once(evt
);
6493 torture_close_connection(cli1
);
6497 static void chain2_sesssetup_completion(struct tevent_req
*req
)
6500 status
= cli_session_setup_guest_recv(req
);
6501 d_printf("sesssetup returned %s\n", nt_errstr(status
));
6504 static void chain2_tcon_completion(struct tevent_req
*req
)
6506 bool *done
= (bool *)tevent_req_callback_data_void(req
);
6508 status
= cli_tcon_andx_recv(req
);
6509 d_printf("tcon_and_x returned %s\n", nt_errstr(status
));
6513 static bool run_chain2(int dummy
)
6515 struct cli_state
*cli1
;
6516 struct event_context
*evt
= event_context_init(NULL
);
6517 struct tevent_req
*reqs
[2], *smbreqs
[2];
6521 printf("starting chain2 test\n");
6522 status
= cli_start_connection(&cli1
, lp_netbios_name(), host
, NULL
,
6523 port_to_use
, Undefined
, 0);
6524 if (!NT_STATUS_IS_OK(status
)) {
6528 cli_sockopt(cli1
, sockops
);
6530 reqs
[0] = cli_session_setup_guest_create(talloc_tos(), evt
, cli1
,
6532 if (reqs
[0] == NULL
) return false;
6533 tevent_req_set_callback(reqs
[0], chain2_sesssetup_completion
, NULL
);
6535 reqs
[1] = cli_tcon_andx_create(talloc_tos(), evt
, cli1
, "IPC$",
6536 "?????", NULL
, 0, &smbreqs
[1]);
6537 if (reqs
[1] == NULL
) return false;
6538 tevent_req_set_callback(reqs
[1], chain2_tcon_completion
, &done
);
6540 status
= cli_smb_chain_send(smbreqs
, ARRAY_SIZE(smbreqs
));
6541 if (!NT_STATUS_IS_OK(status
)) {
6546 event_loop_once(evt
);
6549 torture_close_connection(cli1
);
6554 struct torture_createdel_state
{
6555 struct tevent_context
*ev
;
6556 struct cli_state
*cli
;
6559 static void torture_createdel_created(struct tevent_req
*subreq
);
6560 static void torture_createdel_closed(struct tevent_req
*subreq
);
6562 static struct tevent_req
*torture_createdel_send(TALLOC_CTX
*mem_ctx
,
6563 struct tevent_context
*ev
,
6564 struct cli_state
*cli
,
6567 struct tevent_req
*req
, *subreq
;
6568 struct torture_createdel_state
*state
;
6570 req
= tevent_req_create(mem_ctx
, &state
,
6571 struct torture_createdel_state
);
6578 subreq
= cli_ntcreate_send(
6579 state
, ev
, cli
, name
, 0,
6580 FILE_READ_DATA
|FILE_WRITE_DATA
|DELETE_ACCESS
,
6581 FILE_ATTRIBUTE_NORMAL
,
6582 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
6583 FILE_OPEN_IF
, FILE_DELETE_ON_CLOSE
, 0);
6585 if (tevent_req_nomem(subreq
, req
)) {
6586 return tevent_req_post(req
, ev
);
6588 tevent_req_set_callback(subreq
, torture_createdel_created
, req
);
6592 static void torture_createdel_created(struct tevent_req
*subreq
)
6594 struct tevent_req
*req
= tevent_req_callback_data(
6595 subreq
, struct tevent_req
);
6596 struct torture_createdel_state
*state
= tevent_req_data(
6597 req
, struct torture_createdel_state
);
6601 status
= cli_ntcreate_recv(subreq
, &fnum
);
6602 TALLOC_FREE(subreq
);
6603 if (!NT_STATUS_IS_OK(status
)) {
6604 DEBUG(10, ("cli_ntcreate_recv returned %s\n",
6605 nt_errstr(status
)));
6606 tevent_req_nterror(req
, status
);
6610 subreq
= cli_close_send(state
, state
->ev
, state
->cli
, fnum
);
6611 if (tevent_req_nomem(subreq
, req
)) {
6614 tevent_req_set_callback(subreq
, torture_createdel_closed
, req
);
6617 static void torture_createdel_closed(struct tevent_req
*subreq
)
6619 struct tevent_req
*req
= tevent_req_callback_data(
6620 subreq
, struct tevent_req
);
6623 status
= cli_close_recv(subreq
);
6624 if (!NT_STATUS_IS_OK(status
)) {
6625 DEBUG(10, ("cli_close_recv returned %s\n", nt_errstr(status
)));
6626 tevent_req_nterror(req
, status
);
6629 tevent_req_done(req
);
6632 static NTSTATUS
torture_createdel_recv(struct tevent_req
*req
)
6634 return tevent_req_simple_recv_ntstatus(req
);
6637 struct torture_createdels_state
{
6638 struct tevent_context
*ev
;
6639 struct cli_state
*cli
;
6640 const char *base_name
;
6644 struct tevent_req
**reqs
;
6647 static void torture_createdels_done(struct tevent_req
*subreq
);
6649 static struct tevent_req
*torture_createdels_send(TALLOC_CTX
*mem_ctx
,
6650 struct tevent_context
*ev
,
6651 struct cli_state
*cli
,
6652 const char *base_name
,
6656 struct tevent_req
*req
;
6657 struct torture_createdels_state
*state
;
6660 req
= tevent_req_create(mem_ctx
, &state
,
6661 struct torture_createdels_state
);
6667 state
->base_name
= talloc_strdup(state
, base_name
);
6668 if (tevent_req_nomem(state
->base_name
, req
)) {
6669 return tevent_req_post(req
, ev
);
6671 state
->num_files
= MAX(num_parallel
, num_files
);
6673 state
->received
= 0;
6675 state
->reqs
= talloc_array(state
, struct tevent_req
*, num_parallel
);
6676 if (tevent_req_nomem(state
->reqs
, req
)) {
6677 return tevent_req_post(req
, ev
);
6680 for (i
=0; i
<num_parallel
; i
++) {
6683 name
= talloc_asprintf(state
, "%s%8.8d", state
->base_name
,
6685 if (tevent_req_nomem(name
, req
)) {
6686 return tevent_req_post(req
, ev
);
6688 state
->reqs
[i
] = torture_createdel_send(
6689 state
->reqs
, state
->ev
, state
->cli
, name
);
6690 if (tevent_req_nomem(state
->reqs
[i
], req
)) {
6691 return tevent_req_post(req
, ev
);
6693 name
= talloc_move(state
->reqs
[i
], &name
);
6694 tevent_req_set_callback(state
->reqs
[i
],
6695 torture_createdels_done
, req
);
6701 static void torture_createdels_done(struct tevent_req
*subreq
)
6703 struct tevent_req
*req
= tevent_req_callback_data(
6704 subreq
, struct tevent_req
);
6705 struct torture_createdels_state
*state
= tevent_req_data(
6706 req
, struct torture_createdels_state
);
6707 size_t num_parallel
= talloc_array_length(state
->reqs
);
6712 status
= torture_createdel_recv(subreq
);
6713 if (!NT_STATUS_IS_OK(status
)){
6714 DEBUG(10, ("torture_createdel_recv returned %s\n",
6715 nt_errstr(status
)));
6716 TALLOC_FREE(subreq
);
6717 tevent_req_nterror(req
, status
);
6721 for (i
=0; i
<num_parallel
; i
++) {
6722 if (subreq
== state
->reqs
[i
]) {
6726 if (i
== num_parallel
) {
6727 DEBUG(10, ("received something we did not send\n"));
6728 tevent_req_nterror(req
, NT_STATUS_INTERNAL_ERROR
);
6731 TALLOC_FREE(state
->reqs
[i
]);
6733 if (state
->sent
>= state
->num_files
) {
6734 tevent_req_done(req
);
6738 name
= talloc_asprintf(state
, "%s%8.8d", state
->base_name
,
6740 if (tevent_req_nomem(name
, req
)) {
6743 state
->reqs
[i
] = torture_createdel_send(state
->reqs
, state
->ev
,
6745 if (tevent_req_nomem(state
->reqs
[i
], req
)) {
6748 name
= talloc_move(state
->reqs
[i
], &name
);
6749 tevent_req_set_callback(state
->reqs
[i
], torture_createdels_done
, req
);
6753 static NTSTATUS
torture_createdels_recv(struct tevent_req
*req
)
6755 return tevent_req_simple_recv_ntstatus(req
);
6758 struct swallow_notify_state
{
6759 struct tevent_context
*ev
;
6760 struct cli_state
*cli
;
6762 uint32_t completion_filter
;
6764 bool (*fn
)(uint32_t action
, const char *name
, void *priv
);
6768 static void swallow_notify_done(struct tevent_req
*subreq
);
6770 static struct tevent_req
*swallow_notify_send(TALLOC_CTX
*mem_ctx
,
6771 struct tevent_context
*ev
,
6772 struct cli_state
*cli
,
6774 uint32_t completion_filter
,
6776 bool (*fn
)(uint32_t action
,
6781 struct tevent_req
*req
, *subreq
;
6782 struct swallow_notify_state
*state
;
6784 req
= tevent_req_create(mem_ctx
, &state
,
6785 struct swallow_notify_state
);
6792 state
->completion_filter
= completion_filter
;
6793 state
->recursive
= recursive
;
6797 subreq
= cli_notify_send(state
, state
->ev
, state
->cli
, state
->fnum
,
6798 0xffff, state
->completion_filter
,
6800 if (tevent_req_nomem(subreq
, req
)) {
6801 return tevent_req_post(req
, ev
);
6803 tevent_req_set_callback(subreq
, swallow_notify_done
, req
);
6807 static void swallow_notify_done(struct tevent_req
*subreq
)
6809 struct tevent_req
*req
= tevent_req_callback_data(
6810 subreq
, struct tevent_req
);
6811 struct swallow_notify_state
*state
= tevent_req_data(
6812 req
, struct swallow_notify_state
);
6814 uint32_t i
, num_changes
;
6815 struct notify_change
*changes
;
6817 status
= cli_notify_recv(subreq
, state
, &num_changes
, &changes
);
6818 TALLOC_FREE(subreq
);
6819 if (!NT_STATUS_IS_OK(status
)) {
6820 DEBUG(10, ("cli_notify_recv returned %s\n",
6821 nt_errstr(status
)));
6822 tevent_req_nterror(req
, status
);
6826 for (i
=0; i
<num_changes
; i
++) {
6827 state
->fn(changes
[i
].action
, changes
[i
].name
, state
->priv
);
6829 TALLOC_FREE(changes
);
6831 subreq
= cli_notify_send(state
, state
->ev
, state
->cli
, state
->fnum
,
6832 0xffff, state
->completion_filter
,
6834 if (tevent_req_nomem(subreq
, req
)) {
6837 tevent_req_set_callback(subreq
, swallow_notify_done
, req
);
6840 static bool print_notifies(uint32_t action
, const char *name
, void *priv
)
6842 if (DEBUGLEVEL
> 5) {
6843 d_printf("%d %s\n", (int)action
, name
);
6848 static void notify_bench_done(struct tevent_req
*req
)
6850 int *num_finished
= (int *)tevent_req_callback_data_void(req
);
6854 static bool run_notify_bench(int dummy
)
6856 const char *dname
= "\\notify-bench";
6857 struct tevent_context
*ev
;
6860 struct tevent_req
*req1
;
6861 struct tevent_req
*req2
= NULL
;
6862 int i
, num_unc_names
;
6863 int num_finished
= 0;
6865 printf("starting notify-bench test\n");
6867 if (use_multishare_conn
) {
6869 unc_list
= file_lines_load(multishare_conn_fname
,
6870 &num_unc_names
, 0, NULL
);
6871 if (!unc_list
|| num_unc_names
<= 0) {
6872 d_printf("Failed to load unc names list from '%s'\n",
6873 multishare_conn_fname
);
6876 TALLOC_FREE(unc_list
);
6881 ev
= tevent_context_init(talloc_tos());
6883 d_printf("tevent_context_init failed\n");
6887 for (i
=0; i
<num_unc_names
; i
++) {
6888 struct cli_state
*cli
;
6891 base_fname
= talloc_asprintf(talloc_tos(), "%s\\file%3.3d.",
6893 if (base_fname
== NULL
) {
6897 if (!torture_open_connection(&cli
, i
)) {
6901 status
= cli_ntcreate(cli
, dname
, 0,
6902 MAXIMUM_ALLOWED_ACCESS
,
6903 0, FILE_SHARE_READ
|FILE_SHARE_WRITE
|
6905 FILE_OPEN_IF
, FILE_DIRECTORY_FILE
, 0,
6908 if (!NT_STATUS_IS_OK(status
)) {
6909 d_printf("Could not create %s: %s\n", dname
,
6914 req1
= swallow_notify_send(talloc_tos(), ev
, cli
, dnum
,
6915 FILE_NOTIFY_CHANGE_FILE_NAME
|
6916 FILE_NOTIFY_CHANGE_DIR_NAME
|
6917 FILE_NOTIFY_CHANGE_ATTRIBUTES
|
6918 FILE_NOTIFY_CHANGE_LAST_WRITE
,
6919 false, print_notifies
, NULL
);
6921 d_printf("Could not create notify request\n");
6925 req2
= torture_createdels_send(talloc_tos(), ev
, cli
,
6926 base_fname
, 10, torture_numops
);
6928 d_printf("Could not create createdels request\n");
6931 TALLOC_FREE(base_fname
);
6933 tevent_req_set_callback(req2
, notify_bench_done
,
6937 while (num_finished
< num_unc_names
) {
6939 ret
= tevent_loop_once(ev
);
6941 d_printf("tevent_loop_once failed\n");
6946 if (!tevent_req_poll(req2
, ev
)) {
6947 d_printf("tevent_req_poll failed\n");
6950 status
= torture_createdels_recv(req2
);
6951 d_printf("torture_createdels_recv returned %s\n", nt_errstr(status
));
6956 static bool run_mangle1(int dummy
)
6958 struct cli_state
*cli
;
6959 const char *fname
= "this_is_a_long_fname_to_be_mangled.txt";
6963 time_t change_time
, access_time
, write_time
;
6967 printf("starting mangle1 test\n");
6968 if (!torture_open_connection(&cli
, 0)) {
6972 cli_sockopt(cli
, sockops
);
6974 status
= cli_ntcreate(cli
, fname
, 0, GENERIC_ALL_ACCESS
|DELETE_ACCESS
,
6975 FILE_ATTRIBUTE_NORMAL
, 0, FILE_OVERWRITE_IF
,
6977 if (!NT_STATUS_IS_OK(status
)) {
6978 d_printf("open %s failed: %s\n", fname
, nt_errstr(status
));
6981 cli_close(cli
, fnum
);
6983 status
= cli_qpathinfo_alt_name(cli
, fname
, alt_name
);
6984 if (!NT_STATUS_IS_OK(status
)) {
6985 d_printf("cli_qpathinfo_alt_name failed: %s\n",
6989 d_printf("alt_name: %s\n", alt_name
);
6991 status
= cli_open(cli
, alt_name
, O_RDONLY
, DENY_NONE
, &fnum
);
6992 if (!NT_STATUS_IS_OK(status
)) {
6993 d_printf("cli_open(%s) failed: %s\n", alt_name
,
6997 cli_close(cli
, fnum
);
6999 status
= cli_qpathinfo1(cli
, alt_name
, &change_time
, &access_time
,
7000 &write_time
, &size
, &mode
);
7001 if (!NT_STATUS_IS_OK(status
)) {
7002 d_printf("cli_qpathinfo1(%s) failed: %s\n", alt_name
,
7010 static size_t null_source(uint8_t *buf
, size_t n
, void *priv
)
7012 size_t *to_pull
= (size_t *)priv
;
7013 size_t thistime
= *to_pull
;
7015 thistime
= MIN(thistime
, n
);
7016 if (thistime
== 0) {
7020 memset(buf
, 0, thistime
);
7021 *to_pull
-= thistime
;
7025 static bool run_windows_write(int dummy
)
7027 struct cli_state
*cli1
;
7031 const char *fname
= "\\writetest.txt";
7032 struct timeval start_time
;
7037 printf("starting windows_write test\n");
7038 if (!torture_open_connection(&cli1
, 0)) {
7042 status
= cli_open(cli1
, fname
, O_RDWR
|O_CREAT
|O_EXCL
, DENY_NONE
, &fnum
);
7043 if (!NT_STATUS_IS_OK(status
)) {
7044 printf("open failed (%s)\n", nt_errstr(status
));
7048 cli_sockopt(cli1
, sockops
);
7050 start_time
= timeval_current();
7052 for (i
=0; i
<torture_numops
; i
++) {
7054 off_t start
= i
* torture_blocksize
;
7055 size_t to_pull
= torture_blocksize
- 1;
7057 status
= cli_writeall(cli1
, fnum
, 0, &c
,
7058 start
+ torture_blocksize
- 1, 1, NULL
);
7059 if (!NT_STATUS_IS_OK(status
)) {
7060 printf("cli_write failed: %s\n", nt_errstr(status
));
7064 status
= cli_push(cli1
, fnum
, 0, i
* torture_blocksize
, torture_blocksize
,
7065 null_source
, &to_pull
);
7066 if (!NT_STATUS_IS_OK(status
)) {
7067 printf("cli_push returned: %s\n", nt_errstr(status
));
7072 seconds
= timeval_elapsed(&start_time
);
7073 kbytes
= (double)torture_blocksize
* torture_numops
;
7076 printf("Wrote %d kbytes in %.2f seconds: %d kb/sec\n", (int)kbytes
,
7077 (double)seconds
, (int)(kbytes
/seconds
));
7081 cli_close(cli1
, fnum
);
7082 cli_unlink(cli1
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
7083 torture_close_connection(cli1
);
7087 static bool run_cli_echo(int dummy
)
7089 struct cli_state
*cli
;
7092 printf("starting cli_echo test\n");
7093 if (!torture_open_connection(&cli
, 0)) {
7096 cli_sockopt(cli
, sockops
);
7098 status
= cli_echo(cli
, 5, data_blob_const("hello", 5));
7100 d_printf("cli_echo returned %s\n", nt_errstr(status
));
7102 torture_close_connection(cli
);
7103 return NT_STATUS_IS_OK(status
);
7106 static bool run_uid_regression_test(int dummy
)
7108 static struct cli_state
*cli
;
7111 bool correct
= True
;
7114 printf("starting uid regression test\n");
7116 if (!torture_open_connection(&cli
, 0)) {
7120 cli_sockopt(cli
, sockops
);
7122 /* Ok - now save then logoff our current user. */
7123 old_vuid
= cli_state_get_uid(cli
);
7125 status
= cli_ulogoff(cli
);
7126 if (!NT_STATUS_IS_OK(status
)) {
7127 d_printf("(%s) cli_ulogoff failed: %s\n",
7128 __location__
, nt_errstr(status
));
7133 cli_state_set_uid(cli
, old_vuid
);
7135 /* Try an operation. */
7136 status
= cli_mkdir(cli
, "\\uid_reg_test");
7137 if (NT_STATUS_IS_OK(status
)) {
7138 d_printf("(%s) cli_mkdir succeeded\n",
7143 /* Should be bad uid. */
7144 if (!check_error(__LINE__
, cli
, ERRSRV
, ERRbaduid
,
7145 NT_STATUS_USER_SESSION_DELETED
)) {
7151 old_cnum
= cli_state_get_tid(cli
);
7153 /* Now try a SMBtdis with the invald vuid set to zero. */
7154 cli_state_set_uid(cli
, 0);
7156 /* This should succeed. */
7157 status
= cli_tdis(cli
);
7159 if (NT_STATUS_IS_OK(status
)) {
7160 d_printf("First tdis with invalid vuid should succeed.\n");
7162 d_printf("First tdis failed (%s)\n", nt_errstr(status
));
7167 cli_state_set_uid(cli
, old_vuid
);
7168 cli_state_set_tid(cli
, old_cnum
);
7170 /* This should fail. */
7171 status
= cli_tdis(cli
);
7172 if (NT_STATUS_IS_OK(status
)) {
7173 d_printf("Second tdis with invalid vuid should fail - succeeded instead !.\n");
7177 /* Should be bad tid. */
7178 if (!check_error(__LINE__
, cli
, ERRSRV
, ERRinvnid
,
7179 NT_STATUS_NETWORK_NAME_DELETED
)) {
7185 cli_rmdir(cli
, "\\uid_reg_test");
7194 static const char *illegal_chars
= "*\\/?<>|\":";
7195 static char force_shortname_chars
[] = " +,.[];=\177";
7197 static NTSTATUS
shortname_del_fn(const char *mnt
, struct file_info
*finfo
,
7198 const char *mask
, void *state
)
7200 struct cli_state
*pcli
= (struct cli_state
*)state
;
7202 NTSTATUS status
= NT_STATUS_OK
;
7204 slprintf(fname
, sizeof(fname
), "\\shortname\\%s", finfo
->name
);
7206 if (strcmp(finfo
->name
, ".") == 0 || strcmp(finfo
->name
, "..") == 0)
7207 return NT_STATUS_OK
;
7209 if (finfo
->mode
& FILE_ATTRIBUTE_DIRECTORY
) {
7210 status
= cli_rmdir(pcli
, fname
);
7211 if (!NT_STATUS_IS_OK(status
)) {
7212 printf("del_fn: failed to rmdir %s\n,", fname
);
7215 status
= cli_unlink(pcli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
7216 if (!NT_STATUS_IS_OK(status
)) {
7217 printf("del_fn: failed to unlink %s\n,", fname
);
7229 static NTSTATUS
shortname_list_fn(const char *mnt
, struct file_info
*finfo
,
7230 const char *name
, void *state
)
7232 struct sn_state
*s
= (struct sn_state
*)state
;
7236 printf("shortname list: i = %d, name = |%s|, shortname = |%s|\n",
7237 i
, finfo
->name
, finfo
->short_name
);
7240 if (strchr(force_shortname_chars
, i
)) {
7241 if (!finfo
->short_name
) {
7242 /* Shortname not created when it should be. */
7243 d_printf("(%s) ERROR: Shortname was not created for file %s containing %d\n",
7244 __location__
, finfo
->name
, i
);
7247 } else if (finfo
->short_name
){
7248 /* Shortname created when it should not be. */
7249 d_printf("(%s) ERROR: Shortname %s was created for file %s\n",
7250 __location__
, finfo
->short_name
, finfo
->name
);
7254 return NT_STATUS_OK
;
7257 static bool run_shortname_test(int dummy
)
7259 static struct cli_state
*cli
;
7260 bool correct
= True
;
7266 printf("starting shortname test\n");
7268 if (!torture_open_connection(&cli
, 0)) {
7272 cli_sockopt(cli
, sockops
);
7274 cli_list(cli
, "\\shortname\\*", 0, shortname_del_fn
, cli
);
7275 cli_list(cli
, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY
, shortname_del_fn
, cli
);
7276 cli_rmdir(cli
, "\\shortname");
7278 status
= cli_mkdir(cli
, "\\shortname");
7279 if (!NT_STATUS_IS_OK(status
)) {
7280 d_printf("(%s) cli_mkdir of \\shortname failed: %s\n",
7281 __location__
, nt_errstr(status
));
7286 strlcpy(fname
, "\\shortname\\", sizeof(fname
));
7287 strlcat(fname
, "test .txt", sizeof(fname
));
7291 for (i
= 32; i
< 128; i
++) {
7292 uint16_t fnum
= (uint16_t)-1;
7296 if (strchr(illegal_chars
, i
)) {
7301 status
= cli_ntcreate(cli
, fname
, 0, GENERIC_ALL_ACCESS
, FILE_ATTRIBUTE_NORMAL
,
7302 FILE_SHARE_READ
|FILE_SHARE_WRITE
, FILE_OVERWRITE_IF
, 0, 0, &fnum
);
7303 if (!NT_STATUS_IS_OK(status
)) {
7304 d_printf("(%s) cli_nt_create of %s failed: %s\n",
7305 __location__
, fname
, nt_errstr(status
));
7309 cli_close(cli
, fnum
);
7312 status
= cli_list(cli
, "\\shortname\\test*.*", 0,
7313 shortname_list_fn
, &s
);
7314 if (s
.matched
!= 1) {
7315 d_printf("(%s) failed to list %s: %s\n",
7316 __location__
, fname
, nt_errstr(status
));
7321 status
= cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
7322 if (!NT_STATUS_IS_OK(status
)) {
7323 d_printf("(%s) failed to delete %s: %s\n",
7324 __location__
, fname
, nt_errstr(status
));
7337 cli_list(cli
, "\\shortname\\*", 0, shortname_del_fn
, cli
);
7338 cli_list(cli
, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY
, shortname_del_fn
, cli
);
7339 cli_rmdir(cli
, "\\shortname");
7340 torture_close_connection(cli
);
7344 static void pagedsearch_cb(struct tevent_req
*req
)
7347 struct tldap_message
*msg
;
7350 rc
= tldap_search_paged_recv(req
, talloc_tos(), &msg
);
7351 if (rc
!= TLDAP_SUCCESS
) {
7352 d_printf("tldap_search_paged_recv failed: %s\n",
7353 tldap_err2string(rc
));
7356 if (tldap_msg_type(msg
) != TLDAP_RES_SEARCH_ENTRY
) {
7360 if (!tldap_entry_dn(msg
, &dn
)) {
7361 d_printf("tldap_entry_dn failed\n");
7364 d_printf("%s\n", dn
);
7368 static bool run_tldap(int dummy
)
7370 struct tldap_context
*ld
;
7373 struct sockaddr_storage addr
;
7374 struct tevent_context
*ev
;
7375 struct tevent_req
*req
;
7379 if (!resolve_name(host
, &addr
, 0, false)) {
7380 d_printf("could not find host %s\n", host
);
7383 status
= open_socket_out(&addr
, 389, 9999, &fd
);
7384 if (!NT_STATUS_IS_OK(status
)) {
7385 d_printf("open_socket_out failed: %s\n", nt_errstr(status
));
7389 ld
= tldap_context_create(talloc_tos(), fd
);
7392 d_printf("tldap_context_create failed\n");
7396 rc
= tldap_fetch_rootdse(ld
);
7397 if (rc
!= TLDAP_SUCCESS
) {
7398 d_printf("tldap_fetch_rootdse failed: %s\n",
7399 tldap_errstr(talloc_tos(), ld
, rc
));
7403 basedn
= tldap_talloc_single_attribute(
7404 tldap_rootdse(ld
), "defaultNamingContext", talloc_tos());
7405 if (basedn
== NULL
) {
7406 d_printf("no defaultNamingContext\n");
7409 d_printf("defaultNamingContext: %s\n", basedn
);
7411 ev
= tevent_context_init(talloc_tos());
7413 d_printf("tevent_context_init failed\n");
7417 req
= tldap_search_paged_send(talloc_tos(), ev
, ld
, basedn
,
7418 TLDAP_SCOPE_SUB
, "(objectclass=*)",
7420 NULL
, 0, NULL
, 0, 0, 0, 0, 5);
7422 d_printf("tldap_search_paged_send failed\n");
7425 tevent_req_set_callback(req
, pagedsearch_cb
, NULL
);
7427 tevent_req_poll(req
, ev
);
7431 /* test search filters against rootDSE */
7432 filter
= "(&(|(name=samba)(nextRid<=10000000)(usnChanged>=10)(samba~=ambas)(!(name=s*m*a)))"
7433 "(|(name:=samba)(name:dn:2.5.13.5:=samba)(:dn:2.5.13.5:=samba)(!(name=*samba))))";
7435 rc
= tldap_search(ld
, "", TLDAP_SCOPE_BASE
, filter
,
7436 NULL
, 0, 0, NULL
, 0, NULL
, 0, 0, 0, 0,
7437 talloc_tos(), NULL
, NULL
);
7438 if (rc
!= TLDAP_SUCCESS
) {
7439 d_printf("tldap_search with complex filter failed: %s\n",
7440 tldap_errstr(talloc_tos(), ld
, rc
));
7448 /* Torture test to ensure no regression of :
7449 https://bugzilla.samba.org/show_bug.cgi?id=7084
7452 static bool run_dir_createtime(int dummy
)
7454 struct cli_state
*cli
;
7455 const char *dname
= "\\testdir";
7456 const char *fname
= "\\testdir\\testfile";
7458 struct timespec create_time
;
7459 struct timespec create_time1
;
7463 if (!torture_open_connection(&cli
, 0)) {
7467 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
7468 cli_rmdir(cli
, dname
);
7470 status
= cli_mkdir(cli
, dname
);
7471 if (!NT_STATUS_IS_OK(status
)) {
7472 printf("mkdir failed: %s\n", nt_errstr(status
));
7476 status
= cli_qpathinfo2(cli
, dname
, &create_time
, NULL
, NULL
, NULL
,
7478 if (!NT_STATUS_IS_OK(status
)) {
7479 printf("cli_qpathinfo2 returned %s\n",
7484 /* Sleep 3 seconds, then create a file. */
7487 status
= cli_open(cli
, fname
, O_RDWR
| O_CREAT
| O_EXCL
,
7489 if (!NT_STATUS_IS_OK(status
)) {
7490 printf("cli_open failed: %s\n", nt_errstr(status
));
7494 status
= cli_qpathinfo2(cli
, dname
, &create_time1
, NULL
, NULL
, NULL
,
7496 if (!NT_STATUS_IS_OK(status
)) {
7497 printf("cli_qpathinfo2 (2) returned %s\n",
7502 if (timespec_compare(&create_time1
, &create_time
)) {
7503 printf("run_dir_createtime: create time was updated (error)\n");
7505 printf("run_dir_createtime: create time was not updated (correct)\n");
7511 cli_unlink(cli
, fname
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
7512 cli_rmdir(cli
, dname
);
7513 if (!torture_close_connection(cli
)) {
7520 static bool run_streamerror(int dummy
)
7522 struct cli_state
*cli
;
7523 const char *dname
= "\\testdir";
7524 const char *streamname
=
7525 "testdir:{4c8cc155-6c1e-11d1-8e41-00c04fb9386d}:$DATA";
7527 time_t change_time
, access_time
, write_time
;
7529 uint16_t mode
, fnum
;
7532 if (!torture_open_connection(&cli
, 0)) {
7536 cli_unlink(cli
, "\\testdir\\*", FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
7537 cli_rmdir(cli
, dname
);
7539 status
= cli_mkdir(cli
, dname
);
7540 if (!NT_STATUS_IS_OK(status
)) {
7541 printf("mkdir failed: %s\n", nt_errstr(status
));
7545 cli_qpathinfo1(cli
, streamname
, &change_time
, &access_time
, &write_time
,
7547 status
= cli_nt_error(cli
);
7549 if (!NT_STATUS_EQUAL(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
)) {
7550 printf("pathinfo returned %s, expected "
7551 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
7556 status
= cli_ntcreate(cli
, streamname
, 0x16,
7557 FILE_READ_DATA
|FILE_READ_EA
|
7558 FILE_READ_ATTRIBUTES
|READ_CONTROL_ACCESS
,
7559 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_READ
,
7560 FILE_OPEN
, 0, 0, &fnum
);
7562 if (!NT_STATUS_EQUAL(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
)) {
7563 printf("ntcreate returned %s, expected "
7564 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
7570 cli_rmdir(cli
, dname
);
7574 static bool run_local_substitute(int dummy
)
7578 ok
&= subst_test("%U", "bla", "", -1, -1, "bla");
7579 ok
&= subst_test("%u%U", "bla", "", -1, -1, "blabla");
7580 ok
&= subst_test("%g", "", "", -1, -1, "NO_GROUP");
7581 ok
&= subst_test("%G", "", "", -1, -1, "NO_GROUP");
7582 ok
&= subst_test("%g", "", "", -1, 0, gidtoname(0));
7583 ok
&= subst_test("%G", "", "", -1, 0, gidtoname(0));
7584 ok
&= subst_test("%D%u", "u", "dom", -1, 0, "domu");
7585 ok
&= subst_test("%i %I", "", "", -1, -1, "0.0.0.0 0.0.0.0");
7587 /* Different captialization rules in sub_basic... */
7589 ok
&= (strcmp(talloc_sub_basic(talloc_tos(), "BLA", "dom", "%U%D"),
7595 static bool run_local_base64(int dummy
)
7600 for (i
=1; i
<2000; i
++) {
7601 DATA_BLOB blob1
, blob2
;
7604 blob1
.data
= talloc_array(talloc_tos(), uint8_t, i
);
7606 generate_random_buffer(blob1
.data
, blob1
.length
);
7608 b64
= base64_encode_data_blob(talloc_tos(), blob1
);
7610 d_fprintf(stderr
, "base64_encode_data_blob failed "
7611 "for %d bytes\n", i
);
7614 blob2
= base64_decode_data_blob(b64
);
7617 if (data_blob_cmp(&blob1
, &blob2
)) {
7618 d_fprintf(stderr
, "data_blob_cmp failed for %d "
7622 TALLOC_FREE(blob1
.data
);
7623 data_blob_free(&blob2
);
7628 static bool run_local_gencache(int dummy
)
7634 if (!gencache_set("foo", "bar", time(NULL
) + 1000)) {
7635 d_printf("%s: gencache_set() failed\n", __location__
);
7639 if (!gencache_get("foo", NULL
, NULL
)) {
7640 d_printf("%s: gencache_get() failed\n", __location__
);
7644 if (!gencache_get("foo", &val
, &tm
)) {
7645 d_printf("%s: gencache_get() failed\n", __location__
);
7649 if (strcmp(val
, "bar") != 0) {
7650 d_printf("%s: gencache_get() returned %s, expected %s\n",
7651 __location__
, val
, "bar");
7658 if (!gencache_del("foo")) {
7659 d_printf("%s: gencache_del() failed\n", __location__
);
7662 if (gencache_del("foo")) {
7663 d_printf("%s: second gencache_del() succeeded\n",
7668 if (gencache_get("foo", &val
, &tm
)) {
7669 d_printf("%s: gencache_get() on deleted entry "
7670 "succeeded\n", __location__
);
7674 blob
= data_blob_string_const_null("bar");
7675 tm
= time(NULL
) + 60;
7677 if (!gencache_set_data_blob("foo", &blob
, tm
)) {
7678 d_printf("%s: gencache_set_data_blob() failed\n", __location__
);
7682 if (!gencache_get_data_blob("foo", &blob
, NULL
, NULL
)) {
7683 d_printf("%s: gencache_get_data_blob() failed\n", __location__
);
7687 if (strcmp((const char *)blob
.data
, "bar") != 0) {
7688 d_printf("%s: gencache_get_data_blob() returned %s, expected %s\n",
7689 __location__
, (const char *)blob
.data
, "bar");
7690 data_blob_free(&blob
);
7694 data_blob_free(&blob
);
7696 if (!gencache_del("foo")) {
7697 d_printf("%s: gencache_del() failed\n", __location__
);
7700 if (gencache_del("foo")) {
7701 d_printf("%s: second gencache_del() succeeded\n",
7706 if (gencache_get_data_blob("foo", &blob
, NULL
, NULL
)) {
7707 d_printf("%s: gencache_get_data_blob() on deleted entry "
7708 "succeeded\n", __location__
);
7715 static bool rbt_testval(struct db_context
*db
, const char *key
,
7718 struct db_record
*rec
;
7719 TDB_DATA data
= string_tdb_data(value
);
7723 rec
= db
->fetch_locked(db
, db
, string_tdb_data(key
));
7725 d_fprintf(stderr
, "fetch_locked failed\n");
7728 status
= rec
->store(rec
, data
, 0);
7729 if (!NT_STATUS_IS_OK(status
)) {
7730 d_fprintf(stderr
, "store failed: %s\n", nt_errstr(status
));
7735 rec
= db
->fetch_locked(db
, db
, string_tdb_data(key
));
7737 d_fprintf(stderr
, "second fetch_locked failed\n");
7740 if ((rec
->value
.dsize
!= data
.dsize
)
7741 || (memcmp(rec
->value
.dptr
, data
.dptr
, data
.dsize
) != 0)) {
7742 d_fprintf(stderr
, "Got wrong data back\n");
7752 static bool run_local_rbtree(int dummy
)
7754 struct db_context
*db
;
7758 db
= db_open_rbt(NULL
);
7761 d_fprintf(stderr
, "db_open_rbt failed\n");
7765 for (i
=0; i
<1000; i
++) {
7768 if (asprintf(&key
, "key%ld", random()) == -1) {
7771 if (asprintf(&value
, "value%ld", random()) == -1) {
7776 if (!rbt_testval(db
, key
, value
)) {
7783 if (asprintf(&value
, "value%ld", random()) == -1) {
7788 if (!rbt_testval(db
, key
, value
)) {
7807 local test for character set functions
7809 This is a very simple test for the functionality in convert_string_error()
7811 static bool run_local_convert_string(int dummy
)
7813 TALLOC_CTX
*tmp_ctx
= talloc_new(NULL
);
7814 const char *test_strings
[2] = { "March", "M\303\244rz" };
7818 for (i
=0; i
<2; i
++) {
7819 const char *str
= test_strings
[i
];
7820 int len
= strlen(str
);
7821 size_t converted_size
;
7824 memset(dst
, 'X', sizeof(dst
));
7826 /* first try with real source length */
7827 ret
= convert_string_error(CH_UNIX
, CH_UTF8
,
7832 d_fprintf(stderr
, "Failed to convert '%s' to CH_DISPLAY\n", str
);
7836 if (converted_size
!= len
) {
7837 d_fprintf(stderr
, "Converted size of '%s' should be %d - got %d\n",
7838 str
, len
, (int)converted_size
);
7842 if (strncmp(str
, dst
, converted_size
) != 0) {
7843 d_fprintf(stderr
, "Expected '%s' to match '%s'\n", str
, dst
);
7847 if (strlen(str
) != converted_size
) {
7848 d_fprintf(stderr
, "Expected '%s' length %d - got %d\n", str
,
7849 (int)strlen(str
), (int)converted_size
);
7853 if (dst
[converted_size
] != 'X') {
7854 d_fprintf(stderr
, "Expected no termination of '%s'\n", dst
);
7858 /* now with srclen==-1, this causes the nul to be
7860 ret
= convert_string_error(CH_UNIX
, CH_UTF8
,
7865 d_fprintf(stderr
, "Failed to convert '%s' to CH_DISPLAY\n", str
);
7869 if (converted_size
!= len
+1) {
7870 d_fprintf(stderr
, "Converted size of '%s' should be %d - got %d\n",
7871 str
, len
, (int)converted_size
);
7875 if (strncmp(str
, dst
, converted_size
) != 0) {
7876 d_fprintf(stderr
, "Expected '%s' to match '%s'\n", str
, dst
);
7880 if (len
+1 != converted_size
) {
7881 d_fprintf(stderr
, "Expected '%s' length %d - got %d\n", str
,
7882 len
+1, (int)converted_size
);
7886 if (dst
[converted_size
] != 'X') {
7887 d_fprintf(stderr
, "Expected no termination of '%s'\n", dst
);
7894 TALLOC_FREE(tmp_ctx
);
7897 TALLOC_FREE(tmp_ctx
);
7902 struct talloc_dict_test
{
7906 static int talloc_dict_traverse_fn(DATA_BLOB key
, void *data
, void *priv
)
7908 int *count
= (int *)priv
;
7913 static bool run_local_talloc_dict(int dummy
)
7915 struct talloc_dict
*dict
;
7916 struct talloc_dict_test
*t
;
7919 dict
= talloc_dict_init(talloc_tos());
7924 t
= talloc(talloc_tos(), struct talloc_dict_test
);
7931 if (!talloc_dict_set(dict
, data_blob_const(&key
, sizeof(key
)), t
)) {
7936 if (talloc_dict_traverse(dict
, talloc_dict_traverse_fn
, &count
) != 0) {
7949 static bool run_local_string_to_sid(int dummy
) {
7952 if (string_to_sid(&sid
, "S--1-5-32-545")) {
7953 printf("allowing S--1-5-32-545\n");
7956 if (string_to_sid(&sid
, "S-1-5-32-+545")) {
7957 printf("allowing S-1-5-32-+545\n");
7960 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")) {
7961 printf("allowing S-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0\n");
7964 if (string_to_sid(&sid
, "S-1-5-32-545-abc")) {
7965 printf("allowing S-1-5-32-545-abc\n");
7968 if (!string_to_sid(&sid
, "S-1-5-32-545")) {
7969 printf("could not parse S-1-5-32-545\n");
7972 if (!dom_sid_equal(&sid
, &global_sid_Builtin_Users
)) {
7973 printf("mis-parsed S-1-5-32-545 as %s\n",
7974 sid_string_tos(&sid
));
7980 static bool run_local_binary_to_sid(int dummy
) {
7981 struct dom_sid
*sid
= talloc(NULL
, struct dom_sid
);
7982 static const char good_binary_sid
[] = {
7983 0x1, /* revision number */
7985 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
7986 0x1, 0x1, 0x1, 0x1, /* auth[0] */
7987 0x1, 0x1, 0x1, 0x1, /* auth[1] */
7988 0x1, 0x1, 0x1, 0x1, /* auth[2] */
7989 0x1, 0x1, 0x1, 0x1, /* auth[3] */
7990 0x1, 0x1, 0x1, 0x1, /* auth[4] */
7991 0x1, 0x1, 0x1, 0x1, /* auth[5] */
7992 0x1, 0x1, 0x1, 0x1, /* auth[6] */
7993 0x1, 0x1, 0x1, 0x1, /* auth[7] */
7994 0x1, 0x1, 0x1, 0x1, /* auth[8] */
7995 0x1, 0x1, 0x1, 0x1, /* auth[9] */
7996 0x1, 0x1, 0x1, 0x1, /* auth[10] */
7997 0x1, 0x1, 0x1, 0x1, /* auth[11] */
7998 0x1, 0x1, 0x1, 0x1, /* auth[12] */
7999 0x1, 0x1, 0x1, 0x1, /* auth[13] */
8000 0x1, 0x1, 0x1, 0x1, /* auth[14] */
8003 static const char long_binary_sid
[] = {
8004 0x1, /* revision number */
8006 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
8007 0x1, 0x1, 0x1, 0x1, /* auth[0] */
8008 0x1, 0x1, 0x1, 0x1, /* auth[1] */
8009 0x1, 0x1, 0x1, 0x1, /* auth[2] */
8010 0x1, 0x1, 0x1, 0x1, /* auth[3] */
8011 0x1, 0x1, 0x1, 0x1, /* auth[4] */
8012 0x1, 0x1, 0x1, 0x1, /* auth[5] */
8013 0x1, 0x1, 0x1, 0x1, /* auth[6] */
8014 0x1, 0x1, 0x1, 0x1, /* auth[7] */
8015 0x1, 0x1, 0x1, 0x1, /* auth[8] */
8016 0x1, 0x1, 0x1, 0x1, /* auth[9] */
8017 0x1, 0x1, 0x1, 0x1, /* auth[10] */
8018 0x1, 0x1, 0x1, 0x1, /* auth[11] */
8019 0x1, 0x1, 0x1, 0x1, /* auth[12] */
8020 0x1, 0x1, 0x1, 0x1, /* auth[13] */
8021 0x1, 0x1, 0x1, 0x1, /* auth[14] */
8022 0x1, 0x1, 0x1, 0x1, /* auth[15] */
8023 0x1, 0x1, 0x1, 0x1, /* auth[16] */
8024 0x1, 0x1, 0x1, 0x1, /* auth[17] */
8027 static const char long_binary_sid2
[] = {
8028 0x1, /* revision number */
8030 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
8031 0x1, 0x1, 0x1, 0x1, /* auth[0] */
8032 0x1, 0x1, 0x1, 0x1, /* auth[1] */
8033 0x1, 0x1, 0x1, 0x1, /* auth[2] */
8034 0x1, 0x1, 0x1, 0x1, /* auth[3] */
8035 0x1, 0x1, 0x1, 0x1, /* auth[4] */
8036 0x1, 0x1, 0x1, 0x1, /* auth[5] */
8037 0x1, 0x1, 0x1, 0x1, /* auth[6] */
8038 0x1, 0x1, 0x1, 0x1, /* auth[7] */
8039 0x1, 0x1, 0x1, 0x1, /* auth[8] */
8040 0x1, 0x1, 0x1, 0x1, /* auth[9] */
8041 0x1, 0x1, 0x1, 0x1, /* auth[10] */
8042 0x1, 0x1, 0x1, 0x1, /* auth[11] */
8043 0x1, 0x1, 0x1, 0x1, /* auth[12] */
8044 0x1, 0x1, 0x1, 0x1, /* auth[13] */
8045 0x1, 0x1, 0x1, 0x1, /* auth[14] */
8046 0x1, 0x1, 0x1, 0x1, /* auth[15] */
8047 0x1, 0x1, 0x1, 0x1, /* auth[16] */
8048 0x1, 0x1, 0x1, 0x1, /* auth[17] */
8049 0x1, 0x1, 0x1, 0x1, /* auth[18] */
8050 0x1, 0x1, 0x1, 0x1, /* auth[19] */
8051 0x1, 0x1, 0x1, 0x1, /* auth[20] */
8052 0x1, 0x1, 0x1, 0x1, /* auth[21] */
8053 0x1, 0x1, 0x1, 0x1, /* auth[22] */
8054 0x1, 0x1, 0x1, 0x1, /* auth[23] */
8055 0x1, 0x1, 0x1, 0x1, /* auth[24] */
8056 0x1, 0x1, 0x1, 0x1, /* auth[25] */
8057 0x1, 0x1, 0x1, 0x1, /* auth[26] */
8058 0x1, 0x1, 0x1, 0x1, /* auth[27] */
8059 0x1, 0x1, 0x1, 0x1, /* auth[28] */
8060 0x1, 0x1, 0x1, 0x1, /* auth[29] */
8061 0x1, 0x1, 0x1, 0x1, /* auth[30] */
8062 0x1, 0x1, 0x1, 0x1, /* auth[31] */
8065 if (!sid_parse(good_binary_sid
, sizeof(good_binary_sid
), sid
)) {
8068 if (sid_parse(long_binary_sid2
, sizeof(long_binary_sid2
), sid
)) {
8071 if (sid_parse(long_binary_sid
, sizeof(long_binary_sid
), sid
)) {
8077 /* Split a path name into filename and stream name components. Canonicalise
8078 * such that an implicit $DATA token is always explicit.
8080 * The "specification" of this function can be found in the
8081 * run_local_stream_name() function in torture.c, I've tried those
8082 * combinations against a W2k3 server.
8085 static NTSTATUS
split_ntfs_stream_name(TALLOC_CTX
*mem_ctx
, const char *fname
,
8086 char **pbase
, char **pstream
)
8089 char *stream
= NULL
;
8090 char *sname
; /* stream name */
8091 const char *stype
; /* stream type */
8093 DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname
));
8095 sname
= strchr_m(fname
, ':');
8097 if (lp_posix_pathnames() || (sname
== NULL
)) {
8098 if (pbase
!= NULL
) {
8099 base
= talloc_strdup(mem_ctx
, fname
);
8100 NT_STATUS_HAVE_NO_MEMORY(base
);
8105 if (pbase
!= NULL
) {
8106 base
= talloc_strndup(mem_ctx
, fname
, PTR_DIFF(sname
, fname
));
8107 NT_STATUS_HAVE_NO_MEMORY(base
);
8112 stype
= strchr_m(sname
, ':');
8114 if (stype
== NULL
) {
8115 sname
= talloc_strdup(mem_ctx
, sname
);
8119 if (strcasecmp_m(stype
, ":$DATA") != 0) {
8121 * If there is an explicit stream type, so far we only
8122 * allow $DATA. Is there anything else allowed? -- vl
8124 DEBUG(10, ("[%s] is an invalid stream type\n", stype
));
8126 return NT_STATUS_OBJECT_NAME_INVALID
;
8128 sname
= talloc_strndup(mem_ctx
, sname
, PTR_DIFF(stype
, sname
));
8132 if (sname
== NULL
) {
8134 return NT_STATUS_NO_MEMORY
;
8137 if (sname
[0] == '\0') {
8139 * no stream name, so no stream
8144 if (pstream
!= NULL
) {
8145 stream
= talloc_asprintf(mem_ctx
, "%s:%s", sname
, stype
);
8146 if (stream
== NULL
) {
8149 return NT_STATUS_NO_MEMORY
;
8152 * upper-case the type field
8154 strupper_m(strchr_m(stream
, ':')+1);
8158 if (pbase
!= NULL
) {
8161 if (pstream
!= NULL
) {
8164 return NT_STATUS_OK
;
8167 static bool test_stream_name(const char *fname
, const char *expected_base
,
8168 const char *expected_stream
,
8169 NTSTATUS expected_status
)
8173 char *stream
= NULL
;
8175 status
= split_ntfs_stream_name(talloc_tos(), fname
, &base
, &stream
);
8176 if (!NT_STATUS_EQUAL(status
, expected_status
)) {
8180 if (!NT_STATUS_IS_OK(status
)) {
8184 if (base
== NULL
) goto error
;
8186 if (strcmp(expected_base
, base
) != 0) goto error
;
8188 if ((expected_stream
!= NULL
) && (stream
== NULL
)) goto error
;
8189 if ((expected_stream
== NULL
) && (stream
!= NULL
)) goto error
;
8191 if ((stream
!= NULL
) && (strcmp(expected_stream
, stream
) != 0))
8195 TALLOC_FREE(stream
);
8199 d_fprintf(stderr
, "Do test_stream(%s, %s, %s, %s)\n",
8200 fname
, expected_base
? expected_base
: "<NULL>",
8201 expected_stream
? expected_stream
: "<NULL>",
8202 nt_errstr(expected_status
));
8203 d_fprintf(stderr
, "-> base=%s, stream=%s, status=%s\n",
8204 base
? base
: "<NULL>", stream
? stream
: "<NULL>",
8207 TALLOC_FREE(stream
);
8211 static bool run_local_stream_name(int dummy
)
8215 ret
&= test_stream_name(
8216 "bla", "bla", NULL
, NT_STATUS_OK
);
8217 ret
&= test_stream_name(
8218 "bla::$DATA", "bla", NULL
, NT_STATUS_OK
);
8219 ret
&= test_stream_name(
8220 "bla:blub:", "bla", NULL
, NT_STATUS_OBJECT_NAME_INVALID
);
8221 ret
&= test_stream_name(
8222 "bla::", NULL
, NULL
, NT_STATUS_OBJECT_NAME_INVALID
);
8223 ret
&= test_stream_name(
8224 "bla::123", "bla", NULL
, NT_STATUS_OBJECT_NAME_INVALID
);
8225 ret
&= test_stream_name(
8226 "bla:$DATA", "bla", "$DATA:$DATA", NT_STATUS_OK
);
8227 ret
&= test_stream_name(
8228 "bla:x:$DATA", "bla", "x:$DATA", NT_STATUS_OK
);
8229 ret
&= test_stream_name(
8230 "bla:x", "bla", "x:$DATA", NT_STATUS_OK
);
8235 static bool data_blob_equal(DATA_BLOB a
, DATA_BLOB b
)
8237 if (a
.length
!= b
.length
) {
8238 printf("a.length=%d != b.length=%d\n",
8239 (int)a
.length
, (int)b
.length
);
8242 if (memcmp(a
.data
, b
.data
, a
.length
) != 0) {
8243 printf("a.data and b.data differ\n");
8249 static bool run_local_memcache(int dummy
)
8251 struct memcache
*cache
;
8253 DATA_BLOB d1
, d2
, d3
;
8254 DATA_BLOB v1
, v2
, v3
;
8256 TALLOC_CTX
*mem_ctx
;
8258 size_t size1
, size2
;
8261 cache
= memcache_init(NULL
, 100);
8263 if (cache
== NULL
) {
8264 printf("memcache_init failed\n");
8268 d1
= data_blob_const("d1", 2);
8269 d2
= data_blob_const("d2", 2);
8270 d3
= data_blob_const("d3", 2);
8272 k1
= data_blob_const("d1", 2);
8273 k2
= data_blob_const("d2", 2);
8275 memcache_add(cache
, STAT_CACHE
, k1
, d1
);
8276 memcache_add(cache
, GETWD_CACHE
, k2
, d2
);
8278 if (!memcache_lookup(cache
, STAT_CACHE
, k1
, &v1
)) {
8279 printf("could not find k1\n");
8282 if (!data_blob_equal(d1
, v1
)) {
8286 if (!memcache_lookup(cache
, GETWD_CACHE
, k2
, &v2
)) {
8287 printf("could not find k2\n");
8290 if (!data_blob_equal(d2
, v2
)) {
8294 memcache_add(cache
, STAT_CACHE
, k1
, d3
);
8296 if (!memcache_lookup(cache
, STAT_CACHE
, k1
, &v3
)) {
8297 printf("could not find replaced k1\n");
8300 if (!data_blob_equal(d3
, v3
)) {
8304 memcache_add(cache
, GETWD_CACHE
, k1
, d1
);
8306 if (memcache_lookup(cache
, GETWD_CACHE
, k2
, &v2
)) {
8307 printf("Did find k2, should have been purged\n");
8313 cache
= memcache_init(NULL
, 0);
8315 mem_ctx
= talloc_init("foo");
8317 str1
= talloc_strdup(mem_ctx
, "string1");
8318 str2
= talloc_strdup(mem_ctx
, "string2");
8320 memcache_add_talloc(cache
, SINGLETON_CACHE_TALLOC
,
8321 data_blob_string_const("torture"), &str1
);
8322 size1
= talloc_total_size(cache
);
8324 memcache_add_talloc(cache
, SINGLETON_CACHE_TALLOC
,
8325 data_blob_string_const("torture"), &str2
);
8326 size2
= talloc_total_size(cache
);
8328 printf("size1=%d, size2=%d\n", (int)size1
, (int)size2
);
8330 if (size2
> size1
) {
8331 printf("memcache leaks memory!\n");
8341 static void wbclient_done(struct tevent_req
*req
)
8344 struct winbindd_response
*wb_resp
;
8345 int *i
= (int *)tevent_req_callback_data_void(req
);
8347 wbc_err
= wb_trans_recv(req
, req
, &wb_resp
);
8350 d_printf("wb_trans_recv %d returned %s\n", *i
, wbcErrorString(wbc_err
));
8353 static bool run_local_wbclient(int dummy
)
8355 struct event_context
*ev
;
8356 struct wb_context
**wb_ctx
;
8357 struct winbindd_request wb_req
;
8358 bool result
= false;
8361 BlockSignals(True
, SIGPIPE
);
8363 ev
= tevent_context_init_byname(talloc_tos(), "epoll");
8368 wb_ctx
= talloc_array(ev
, struct wb_context
*, nprocs
);
8369 if (wb_ctx
== NULL
) {
8373 ZERO_STRUCT(wb_req
);
8374 wb_req
.cmd
= WINBINDD_PING
;
8376 d_printf("nprocs=%d, numops=%d\n", (int)nprocs
, (int)torture_numops
);
8378 for (i
=0; i
<nprocs
; i
++) {
8379 wb_ctx
[i
] = wb_context_init(ev
, NULL
);
8380 if (wb_ctx
[i
] == NULL
) {
8383 for (j
=0; j
<torture_numops
; j
++) {
8384 struct tevent_req
*req
;
8385 req
= wb_trans_send(ev
, ev
, wb_ctx
[i
],
8386 (j
% 2) == 0, &wb_req
);
8390 tevent_req_set_callback(req
, wbclient_done
, &i
);
8396 while (i
< nprocs
* torture_numops
) {
8397 event_loop_once(ev
);
8406 static void getaddrinfo_finished(struct tevent_req
*req
)
8408 char *name
= (char *)tevent_req_callback_data_void(req
);
8409 struct addrinfo
*ainfo
;
8412 res
= getaddrinfo_recv(req
, &ainfo
);
8414 d_printf("gai(%s) returned %s\n", name
, gai_strerror(res
));
8417 d_printf("gai(%s) succeeded\n", name
);
8418 freeaddrinfo(ainfo
);
8421 static bool run_getaddrinfo_send(int dummy
)
8423 TALLOC_CTX
*frame
= talloc_stackframe();
8424 struct fncall_context
*ctx
;
8425 struct tevent_context
*ev
;
8426 bool result
= false;
8427 const char *names
[4] = { "www.samba.org", "notfound.samba.org",
8428 "www.slashdot.org", "heise.de" };
8429 struct tevent_req
*reqs
[4];
8432 ev
= event_context_init(frame
);
8437 ctx
= fncall_context_init(frame
, 4);
8439 for (i
=0; i
<ARRAY_SIZE(names
); i
++) {
8440 reqs
[i
] = getaddrinfo_send(frame
, ev
, ctx
, names
[i
], NULL
,
8442 if (reqs
[i
] == NULL
) {
8445 tevent_req_set_callback(reqs
[i
], getaddrinfo_finished
,
8446 discard_const_p(void, names
[i
]));
8449 for (i
=0; i
<ARRAY_SIZE(reqs
); i
++) {
8450 tevent_loop_once(ev
);
8459 static bool dbtrans_inc(struct db_context
*db
)
8461 struct db_record
*rec
;
8466 rec
= db
->fetch_locked(db
, db
, string_term_tdb_data("transtest"));
8468 printf(__location__
"fetch_lock failed\n");
8472 if (rec
->value
.dsize
!= sizeof(uint32_t)) {
8473 printf(__location__
"value.dsize = %d\n",
8474 (int)rec
->value
.dsize
);
8478 val
= (uint32_t *)rec
->value
.dptr
;
8481 status
= rec
->store(rec
, make_tdb_data((uint8_t *)val
,
8484 if (!NT_STATUS_IS_OK(status
)) {
8485 printf(__location__
"store failed: %s\n",
8496 static bool run_local_dbtrans(int dummy
)
8498 struct db_context
*db
;
8499 struct db_record
*rec
;
8504 db
= db_open(talloc_tos(), "transtest.tdb", 0, TDB_DEFAULT
,
8505 O_RDWR
|O_CREAT
, 0600);
8507 printf("Could not open transtest.db\n");
8511 res
= db
->transaction_start(db
);
8513 printf(__location__
"transaction_start failed\n");
8517 rec
= db
->fetch_locked(db
, db
, string_term_tdb_data("transtest"));
8519 printf(__location__
"fetch_lock failed\n");
8523 if (rec
->value
.dptr
== NULL
) {
8525 status
= rec
->store(
8526 rec
, make_tdb_data((uint8_t *)&initial
,
8529 if (!NT_STATUS_IS_OK(status
)) {
8530 printf(__location__
"store returned %s\n",
8538 res
= db
->transaction_commit(db
);
8540 printf(__location__
"transaction_commit failed\n");
8548 res
= db
->transaction_start(db
);
8550 printf(__location__
"transaction_start failed\n");
8554 if (!dbwrap_fetch_uint32(db
, "transtest", &val
)) {
8555 printf(__location__
"dbwrap_fetch_uint32 failed\n");
8559 for (i
=0; i
<10; i
++) {
8560 if (!dbtrans_inc(db
)) {
8565 if (!dbwrap_fetch_uint32(db
, "transtest", &val2
)) {
8566 printf(__location__
"dbwrap_fetch_uint32 failed\n");
8570 if (val2
!= val
+ 10) {
8571 printf(__location__
"val=%d, val2=%d\n",
8572 (int)val
, (int)val2
);
8576 printf("val2=%d\r", val2
);
8578 res
= db
->transaction_commit(db
);
8580 printf(__location__
"transaction_commit failed\n");
8590 * Just a dummy test to be run under a debugger. There's no real way
8591 * to inspect the tevent_select specific function from outside of
8595 static bool run_local_tevent_select(int dummy
)
8597 struct tevent_context
*ev
;
8598 struct tevent_fd
*fd1
, *fd2
;
8599 bool result
= false;
8601 ev
= tevent_context_init_byname(NULL
, "select");
8603 d_fprintf(stderr
, "tevent_context_init_byname failed\n");
8607 fd1
= tevent_add_fd(ev
, ev
, 2, 0, NULL
, NULL
);
8609 d_fprintf(stderr
, "tevent_add_fd failed\n");
8612 fd2
= tevent_add_fd(ev
, ev
, 3, 0, NULL
, NULL
);
8614 d_fprintf(stderr
, "tevent_add_fd failed\n");
8619 fd2
= tevent_add_fd(ev
, ev
, 1, 0, NULL
, NULL
);
8621 d_fprintf(stderr
, "tevent_add_fd failed\n");
8631 static double create_procs(bool (*fn
)(int), bool *result
)
8634 volatile pid_t
*child_status
;
8635 volatile bool *child_status_out
;
8638 struct timeval start
;
8642 child_status
= (volatile pid_t
*)shm_setup(sizeof(pid_t
)*nprocs
);
8643 if (!child_status
) {
8644 printf("Failed to setup shared memory\n");
8648 child_status_out
= (volatile bool *)shm_setup(sizeof(bool)*nprocs
);
8649 if (!child_status_out
) {
8650 printf("Failed to setup result status shared memory\n");
8654 for (i
= 0; i
< nprocs
; i
++) {
8655 child_status
[i
] = 0;
8656 child_status_out
[i
] = True
;
8659 start
= timeval_current();
8661 for (i
=0;i
<nprocs
;i
++) {
8664 pid_t mypid
= getpid();
8665 sys_srandom(((int)mypid
) ^ ((int)time(NULL
)));
8667 slprintf(myname
,sizeof(myname
),"CLIENT%d", i
);
8670 if (torture_open_connection(¤t_cli
, i
)) break;
8672 printf("pid %d failed to start\n", (int)getpid());
8678 child_status
[i
] = getpid();
8680 while (child_status
[i
] && timeval_elapsed(&start
) < 5) smb_msleep(2);
8682 child_status_out
[i
] = fn(i
);
8689 for (i
=0;i
<nprocs
;i
++) {
8690 if (child_status
[i
]) synccount
++;
8692 if (synccount
== nprocs
) break;
8694 } while (timeval_elapsed(&start
) < 30);
8696 if (synccount
!= nprocs
) {
8697 printf("FAILED TO START %d CLIENTS (started %d)\n", nprocs
, synccount
);
8699 return timeval_elapsed(&start
);
8702 /* start the client load */
8703 start
= timeval_current();
8705 for (i
=0;i
<nprocs
;i
++) {
8706 child_status
[i
] = 0;
8709 printf("%d clients started\n", nprocs
);
8711 for (i
=0;i
<nprocs
;i
++) {
8712 while (waitpid(0, &status
, 0) == -1 && errno
== EINTR
) /* noop */ ;
8717 for (i
=0;i
<nprocs
;i
++) {
8718 if (!child_status_out
[i
]) {
8722 return timeval_elapsed(&start
);
8725 #define FLAG_MULTIPROC 1
8732 {"FDPASS", run_fdpasstest
, 0},
8733 {"LOCK1", run_locktest1
, 0},
8734 {"LOCK2", run_locktest2
, 0},
8735 {"LOCK3", run_locktest3
, 0},
8736 {"LOCK4", run_locktest4
, 0},
8737 {"LOCK5", run_locktest5
, 0},
8738 {"LOCK6", run_locktest6
, 0},
8739 {"LOCK7", run_locktest7
, 0},
8740 {"LOCK8", run_locktest8
, 0},
8741 {"LOCK9", run_locktest9
, 0},
8742 {"UNLINK", run_unlinktest
, 0},
8743 {"BROWSE", run_browsetest
, 0},
8744 {"ATTR", run_attrtest
, 0},
8745 {"TRANS2", run_trans2test
, 0},
8746 {"MAXFID", run_maxfidtest
, FLAG_MULTIPROC
},
8747 {"TORTURE",run_torture
, FLAG_MULTIPROC
},
8748 {"RANDOMIPC", run_randomipc
, 0},
8749 {"NEGNOWAIT", run_negprot_nowait
, 0},
8750 {"NBENCH", run_nbench
, 0},
8751 {"NBENCH2", run_nbench2
, 0},
8752 {"OPLOCK1", run_oplock1
, 0},
8753 {"OPLOCK2", run_oplock2
, 0},
8754 {"OPLOCK4", run_oplock4
, 0},
8755 {"DIR", run_dirtest
, 0},
8756 {"DIR1", run_dirtest1
, 0},
8757 {"DIR-CREATETIME", run_dir_createtime
, 0},
8758 {"DENY1", torture_denytest1
, 0},
8759 {"DENY2", torture_denytest2
, 0},
8760 {"TCON", run_tcon_test
, 0},
8761 {"TCONDEV", run_tcon_devtype_test
, 0},
8762 {"RW1", run_readwritetest
, 0},
8763 {"RW2", run_readwritemulti
, FLAG_MULTIPROC
},
8764 {"RW3", run_readwritelarge
, 0},
8765 {"RW-SIGNING", run_readwritelarge_signtest
, 0},
8766 {"OPEN", run_opentest
, 0},
8767 {"POSIX", run_simple_posix_open_test
, 0},
8768 {"POSIX-APPEND", run_posix_append
, 0},
8769 {"CASE-INSENSITIVE-CREATE", run_case_insensitive_create
, 0},
8770 {"ASYNC-ECHO", run_async_echo
, 0},
8771 { "UID-REGRESSION-TEST", run_uid_regression_test
, 0},
8772 { "SHORTNAME-TEST", run_shortname_test
, 0},
8773 { "ADDRCHANGE", run_addrchange
, 0},
8775 {"OPENATTR", run_openattrtest
, 0},
8777 {"XCOPY", run_xcopy
, 0},
8778 {"RENAME", run_rename
, 0},
8779 {"DELETE", run_deletetest
, 0},
8780 {"DELETE-LN", run_deletetest_ln
, 0},
8781 {"PROPERTIES", run_properties
, 0},
8782 {"MANGLE", torture_mangle
, 0},
8783 {"MANGLE1", run_mangle1
, 0},
8784 {"W2K", run_w2ktest
, 0},
8785 {"TRANS2SCAN", torture_trans2_scan
, 0},
8786 {"NTTRANSSCAN", torture_nttrans_scan
, 0},
8787 {"UTABLE", torture_utable
, 0},
8788 {"CASETABLE", torture_casetable
, 0},
8789 {"ERRMAPEXTRACT", run_error_map_extract
, 0},
8790 {"PIPE_NUMBER", run_pipe_number
, 0},
8791 {"TCON2", run_tcon2_test
, 0},
8792 {"IOCTL", torture_ioctl_test
, 0},
8793 {"CHKPATH", torture_chkpath_test
, 0},
8794 {"FDSESS", run_fdsesstest
, 0},
8795 { "EATEST", run_eatest
, 0},
8796 { "SESSSETUP_BENCH", run_sesssetup_bench
, 0},
8797 { "CHAIN1", run_chain1
, 0},
8798 { "CHAIN2", run_chain2
, 0},
8799 { "WINDOWS-WRITE", run_windows_write
, 0},
8800 { "NTTRANS-CREATE", run_nttrans_create
, 0},
8801 { "CLI_ECHO", run_cli_echo
, 0},
8802 { "GETADDRINFO", run_getaddrinfo_send
, 0},
8803 { "TLDAP", run_tldap
},
8804 { "STREAMERROR", run_streamerror
},
8805 { "NOTIFY-BENCH", run_notify_bench
},
8806 { "BAD-NBT-SESSION", run_bad_nbt_session
},
8807 { "SMB-ANY-CONNECT", run_smb_any_connect
},
8808 { "NOTIFY-ONLINE", run_notify_online
},
8809 { "SMB2-BASIC", run_smb2_basic
},
8810 { "LOCAL-SUBSTITUTE", run_local_substitute
, 0},
8811 { "LOCAL-GENCACHE", run_local_gencache
, 0},
8812 { "LOCAL-TALLOC-DICT", run_local_talloc_dict
, 0},
8813 { "LOCAL-BASE64", run_local_base64
, 0},
8814 { "LOCAL-RBTREE", run_local_rbtree
, 0},
8815 { "LOCAL-MEMCACHE", run_local_memcache
, 0},
8816 { "LOCAL-STREAM-NAME", run_local_stream_name
, 0},
8817 { "LOCAL-WBCLIENT", run_local_wbclient
, 0},
8818 { "LOCAL-string_to_sid", run_local_string_to_sid
, 0},
8819 { "LOCAL-binary_to_sid", run_local_binary_to_sid
, 0},
8820 { "LOCAL-DBTRANS", run_local_dbtrans
, 0},
8821 { "LOCAL-TEVENT-SELECT", run_local_tevent_select
, 0},
8822 { "LOCAL-CONVERT-STRING", run_local_convert_string
, 0},
8827 /****************************************************************************
8828 run a specified test or "ALL"
8829 ****************************************************************************/
8830 static bool run_test(const char *name
)
8837 if (strequal(name
,"ALL")) {
8838 for (i
=0;torture_ops
[i
].name
;i
++) {
8839 run_test(torture_ops
[i
].name
);
8844 for (i
=0;torture_ops
[i
].name
;i
++) {
8845 fstr_sprintf(randomfname
, "\\XX%x",
8846 (unsigned)random());
8848 if (strequal(name
, torture_ops
[i
].name
)) {
8850 printf("Running %s\n", name
);
8851 if (torture_ops
[i
].flags
& FLAG_MULTIPROC
) {
8852 t
= create_procs(torture_ops
[i
].fn
, &result
);
8855 printf("TEST %s FAILED!\n", name
);
8858 struct timeval start
;
8859 start
= timeval_current();
8860 if (!torture_ops
[i
].fn(0)) {
8862 printf("TEST %s FAILED!\n", name
);
8864 t
= timeval_elapsed(&start
);
8866 printf("%s took %g secs\n\n", name
, t
);
8871 printf("Did not find a test named %s\n", name
);
8879 static void usage(void)
8883 printf("WARNING samba4 test suite is much more complete nowadays.\n");
8884 printf("Please use samba4 torture.\n\n");
8886 printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
8888 printf("\t-d debuglevel\n");
8889 printf("\t-U user%%pass\n");
8890 printf("\t-k use kerberos\n");
8891 printf("\t-N numprocs\n");
8892 printf("\t-n my_netbios_name\n");
8893 printf("\t-W workgroup\n");
8894 printf("\t-o num_operations\n");
8895 printf("\t-O socket_options\n");
8896 printf("\t-m maximum protocol\n");
8897 printf("\t-L use oplocks\n");
8898 printf("\t-c CLIENT.TXT specify client load file for NBENCH\n");
8899 printf("\t-A showall\n");
8900 printf("\t-p port\n");
8901 printf("\t-s seed\n");
8902 printf("\t-b unclist_filename specify multiple shares for multiple connections\n");
8903 printf("\t-f filename filename to test\n");
8906 printf("tests are:");
8907 for (i
=0;torture_ops
[i
].name
;i
++) {
8908 printf(" %s", torture_ops
[i
].name
);
8912 printf("default test is ALL\n");
8917 /****************************************************************************
8919 ****************************************************************************/
8920 int main(int argc
,char *argv
[])
8926 bool correct
= True
;
8927 TALLOC_CTX
*frame
= talloc_stackframe();
8928 int seed
= time(NULL
);
8930 #ifdef HAVE_SETBUFFER
8931 setbuffer(stdout
, NULL
, 0);
8934 setup_logging("smbtorture", DEBUG_STDOUT
);
8938 if (is_default_dyn_CONFIGFILE()) {
8939 if(getenv("SMB_CONF_PATH")) {
8940 set_dyn_CONFIGFILE(getenv("SMB_CONF_PATH"));
8943 lp_load(get_dyn_CONFIGFILE(),True
,False
,False
,True
);
8950 for(p
= argv
[1]; *p
; p
++)
8954 if (strncmp(argv
[1], "//", 2)) {
8958 fstrcpy(host
, &argv
[1][2]);
8959 p
= strchr_m(&host
[2],'/');
8964 fstrcpy(share
, p
+1);
8966 fstrcpy(myname
, get_myname(talloc_tos()));
8968 fprintf(stderr
, "Failed to get my hostname.\n");
8972 if (*username
== 0 && getenv("LOGNAME")) {
8973 fstrcpy(username
,getenv("LOGNAME"));
8979 fstrcpy(workgroup
, lp_workgroup());
8981 while ((opt
= getopt(argc
, argv
, "p:hW:U:n:N:O:o:m:Ll:d:Aec:ks:b:B:f:"))
8985 port_to_use
= atoi(optarg
);
8988 seed
= atoi(optarg
);
8991 fstrcpy(workgroup
,optarg
);
8994 max_protocol
= interpret_protocol(optarg
, max_protocol
);
8997 nprocs
= atoi(optarg
);
9000 torture_numops
= atoi(optarg
);
9003 lp_set_cmdline("log level", optarg
);
9012 local_path
= optarg
;
9015 torture_showall
= True
;
9018 fstrcpy(myname
, optarg
);
9021 client_txt
= optarg
;
9028 use_kerberos
= True
;
9030 d_printf("No kerberos support compiled in\n");
9036 fstrcpy(username
,optarg
);
9037 p
= strchr_m(username
,'%');
9040 fstrcpy(password
, p
+1);
9045 fstrcpy(multishare_conn_fname
, optarg
);
9046 use_multishare_conn
= True
;
9049 torture_blocksize
= atoi(optarg
);
9052 test_filename
= SMB_STRDUP(optarg
);
9055 printf("Unknown option %c (%d)\n", (char)opt
, opt
);
9060 d_printf("using seed %d\n", seed
);
9064 if(use_kerberos
&& !gotuser
) gotpass
= True
;
9067 p
= getpass("Password:");
9069 fstrcpy(password
, p
);
9074 printf("host=%s share=%s user=%s myname=%s\n",
9075 host
, share
, username
, myname
);
9077 if (argc
== optind
) {
9078 correct
= run_test("ALL");
9080 for (i
=optind
;i
<argc
;i
++) {
9081 if (!run_test(argv
[i
])) {