2
Unix SMB/CIFS implementation.
4
Copyright (C) Andrew Tridgell 1997-1998
6
This program is free software; you can redistribute it and/or modify
7
it under the terms of the GNU General Public License as published by
8
the Free Software Foundation; either version 2 of the License, or
9
(at your option) any later version.
11
This program is distributed in the hope that it will be useful,
12
but WITHOUT ANY WARRANTY; without even the implied warranty of
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
GNU General Public License for more details.
16
You should have received a copy of the GNU General Public License
17
along with this program; if not, write to the Free Software
18
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26
static fstring host, workgroup, share, password, username, myname;
27
static int max_protocol = PROTOCOL_NT1;
28
static const char *sockops="TCP_NODELAY";
30
static int port_to_use=0;
31
int torture_numops=100;
32
static int procnum; /* records process count number when forking */
33
static struct cli_state *current_cli;
34
static fstring randomfname;
35
static BOOL use_oplocks;
36
static BOOL use_level_II_oplocks;
37
static const char *client_txt = "client_oplocks.txt";
38
static BOOL use_kerberos;
40
BOOL torture_showall = False;
42
static double create_procs(BOOL (*fn)(int), BOOL *result);
45
static struct timeval tp1,tp2;
47
void start_timer(void)
52
double end_timer(void)
55
return((tp2.tv_sec - tp1.tv_sec) +
56
(tp2.tv_usec - tp1.tv_usec)*1.0e-6);
60
/* return a pointer to a anonymous shared memory segment of size "size"
61
which will persist across fork() but will disappear when all processes
64
The memory is not zeroed
66
This function uses system5 shared memory. It takes advantage of a property
67
that the memory is not destroyed if it is attached when the id is removed
69
void *shm_setup(int size)
74
shmid = shmget(IPC_PRIVATE, size, S_IRUSR | S_IWUSR);
76
printf("can't get shared memory\n");
79
ret = (void *)shmat(shmid, 0, 0);
80
if (!ret || ret == (void *)-1) {
81
printf("can't attach to shared memory\n");
84
/* the following releases the ipc, but note that this process
85
and all its children will still have access to the memory, its
86
just that the shmid is no longer valid for other shm calls. This
87
means we don't leave behind lots of shm segments after we exit
89
See Stevens "advanced programming in unix env" for details
91
shmctl(shmid, IPC_RMID, 0);
97
static struct cli_state *open_nbt_connection(void)
99
struct nmb_name called, calling;
103
make_nmb_name(&calling, myname, 0x0);
104
make_nmb_name(&called , host, 0x20);
108
if (!(c = cli_initialise())) {
109
printf("Failed initialize cli_struct to connect with %s\n", host);
113
c->port = port_to_use;
115
if (!cli_connect(c, host, &ip)) {
116
printf("Failed to connect with %s\n", host);
120
c->use_kerberos = use_kerberos;
122
c->timeout = 120000; /* set a really long timeout (2 minutes) */
123
if (use_oplocks) c->use_oplocks = True;
124
if (use_level_II_oplocks) c->use_level_II_oplocks = True;
126
if (!cli_session_request(c, &calling, &called)) {
128
* Well, that failed, try *SMBSERVER ...
129
* However, we must reconnect as well ...
131
if (!cli_connect(c, host, &ip)) {
132
printf("Failed to connect with %s\n", host);
136
make_nmb_name(&called, "*SMBSERVER", 0x20);
137
if (!cli_session_request(c, &calling, &called)) {
138
printf("%s rejected the session\n",host);
139
printf("We tried with a called name of %s & %s\n",
149
BOOL torture_open_connection(struct cli_state **c)
156
flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
158
status = cli_full_connection(c, myname,
159
host, NULL, port_to_use,
162
password, flags, Undefined, &retry);
163
if (!NT_STATUS_IS_OK(status)) {
167
if (use_oplocks) (*c)->use_oplocks = True;
168
if (use_level_II_oplocks) (*c)->use_level_II_oplocks = True;
169
(*c)->timeout = 120000; /* set a really long timeout (2 minutes) */
174
BOOL torture_cli_session_setup2(struct cli_state *cli, uint16 *new_vuid)
176
uint16 old_vuid = cli->vuid;
177
fstring old_user_name;
178
size_t passlen = strlen(password);
181
fstrcpy(old_user_name, cli->user_name);
183
ret = cli_session_setup(cli, username, password, passlen, password, passlen, workgroup);
184
*new_vuid = cli->vuid;
185
cli->vuid = old_vuid;
186
fstrcpy(cli->user_name, old_user_name);
191
BOOL torture_close_connection(struct cli_state *c)
195
printf("tdis failed (%s)\n", cli_errstr(c));
205
/* check if the server produced the expected error code */
206
static BOOL check_error(int line, struct cli_state *c,
207
uint8 eclass, uint32 ecode, NTSTATUS nterr)
209
if (cli_is_dos_error(c)) {
213
/* Check DOS error */
215
cli_dos_error(c, &cclass, &num);
217
if (eclass != cclass || ecode != num) {
218
printf("unexpected error code class=%d code=%d\n",
219
(int)cclass, (int)num);
220
printf(" expected %d/%d %s (line=%d)\n",
221
(int)eclass, (int)ecode, nt_errstr(nterr), line);
230
status = cli_nt_error(c);
232
if (NT_STATUS_V(nterr) != NT_STATUS_V(status)) {
233
printf("unexpected error code %s\n", nt_errstr(status));
234
printf(" expected %s (line=%d)\n", nt_errstr(nterr), line);
243
static BOOL wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len)
245
while (!cli_lock(c, fnum, offset, len, -1, WRITE_LOCK)) {
246
if (!check_error(__LINE__, c, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
252
static BOOL rw_torture(struct cli_state *c)
254
const char *lockfname = "\\torture.lck";
258
pid_t pid2, pid = getpid();
263
fnum2 = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
266
fnum2 = cli_open(c, lockfname, O_RDWR, DENY_NONE);
268
printf("open of %s failed (%s)\n", lockfname, cli_errstr(c));
273
for (i=0;i<torture_numops;i++) {
274
unsigned n = (unsigned)sys_random()%10;
276
printf("%d\r", i); fflush(stdout);
278
slprintf(fname, sizeof(fstring) - 1, "\\torture.%u", n);
280
if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
284
fnum = cli_open(c, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL);
286
printf("open failed (%s)\n", cli_errstr(c));
291
if (cli_write(c, fnum, 0, (char *)&pid, 0, sizeof(pid)) != sizeof(pid)) {
292
printf("write failed (%s)\n", cli_errstr(c));
297
if (cli_write(c, fnum, 0, (char *)buf,
298
sizeof(pid)+(j*sizeof(buf)),
299
sizeof(buf)) != sizeof(buf)) {
300
printf("write failed (%s)\n", cli_errstr(c));
307
if (cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid)) != sizeof(pid)) {
308
printf("read failed (%s)\n", cli_errstr(c));
313
printf("data corruption!\n");
317
if (!cli_close(c, fnum)) {
318
printf("close failed (%s)\n", cli_errstr(c));
322
if (!cli_unlink(c, fname)) {
323
printf("unlink failed (%s)\n", cli_errstr(c));
327
if (!cli_unlock(c, fnum2, n*sizeof(int), sizeof(int))) {
328
printf("unlock failed (%s)\n", cli_errstr(c));
334
cli_unlink(c, lockfname);
341
static BOOL run_torture(int dummy)
343
struct cli_state *cli;
348
cli_sockopt(cli, sockops);
350
ret = rw_torture(cli);
352
if (!torture_close_connection(cli)) {
359
static BOOL rw_torture3(struct cli_state *c, char *lockfname)
366
unsigned countprev = 0;
371
for (i = 0; i < sizeof(buf); i += sizeof(uint32))
373
SIVAL(buf, i, sys_random());
378
fnum = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
381
printf("first open read/write of %s failed (%s)\n",
382
lockfname, cli_errstr(c));
388
for (i = 0; i < 500 && fnum == -1; i++)
390
fnum = cli_open(c, lockfname, O_RDONLY,
395
printf("second open read-only of %s failed (%s)\n",
396
lockfname, cli_errstr(c));
402
for (count = 0; count < sizeof(buf); count += sent)
404
if (count >= countprev) {
405
printf("%d %8d\r", i, count);
408
countprev += (sizeof(buf) / 20);
413
sent = ((unsigned)sys_random()%(20))+ 1;
414
if (sent > sizeof(buf) - count)
416
sent = sizeof(buf) - count;
419
if (cli_write(c, fnum, 0, buf+count, count, (size_t)sent) != sent) {
420
printf("write failed (%s)\n", cli_errstr(c));
426
sent = cli_read(c, fnum, buf_rd+count, count,
430
printf("read failed offset:%d size:%ld (%s)\n",
431
count, (unsigned long)sizeof(buf)-count,
438
if (memcmp(buf_rd+count, buf+count, sent) != 0)
440
printf("read/write compare failed\n");
441
printf("offset: %d req %ld recvd %ld\n", count, (unsigned long)sizeof(buf)-count, (unsigned long)sent);
450
if (!cli_close(c, fnum)) {
451
printf("close failed (%s)\n", cli_errstr(c));
458
static BOOL rw_torture2(struct cli_state *c1, struct cli_state *c2)
460
const char *lockfname = "\\torture2.lck";
469
if (!cli_unlink(c1, lockfname)) {
470
printf("unlink failed (%s) (normal, this file should not exist)\n", cli_errstr(c1));
473
fnum1 = cli_open(c1, lockfname, O_RDWR | O_CREAT | O_EXCL,
476
printf("first open read/write of %s failed (%s)\n",
477
lockfname, cli_errstr(c1));
480
fnum2 = cli_open(c2, lockfname, O_RDONLY,
483
printf("second open read-only of %s failed (%s)\n",
484
lockfname, cli_errstr(c2));
485
cli_close(c1, fnum1);
489
for (i=0;i<torture_numops;i++)
491
size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
493
printf("%d\r", i); fflush(stdout);
496
generate_random_buffer((unsigned char *)buf, buf_size);
498
if (cli_write(c1, fnum1, 0, buf, 0, buf_size) != buf_size) {
499
printf("write failed (%s)\n", cli_errstr(c1));
504
if ((bytes_read = cli_read(c2, fnum2, buf_rd, 0, buf_size)) != buf_size) {
505
printf("read failed (%s)\n", cli_errstr(c2));
506
printf("read %d, expected %ld\n", (int)bytes_read,
507
(unsigned long)buf_size);
512
if (memcmp(buf_rd, buf, buf_size) != 0)
514
printf("read/write compare failed\n");
520
if (!cli_close(c2, fnum2)) {
521
printf("close failed (%s)\n", cli_errstr(c2));
524
if (!cli_close(c1, fnum1)) {
525
printf("close failed (%s)\n", cli_errstr(c1));
529
if (!cli_unlink(c1, lockfname)) {
530
printf("unlink failed (%s)\n", cli_errstr(c1));
537
static BOOL run_readwritetest(int dummy)
539
static struct cli_state *cli1, *cli2;
540
BOOL test1, test2 = False;
542
if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
545
cli_sockopt(cli1, sockops);
546
cli_sockopt(cli2, sockops);
548
printf("starting readwritetest\n");
550
test1 = rw_torture2(cli1, cli2);
551
printf("Passed readwritetest v1: %s\n", BOOLSTR(test1));
554
test2 = rw_torture2(cli1, cli1);
555
printf("Passed readwritetest v2: %s\n", BOOLSTR(test2));
558
if (!torture_close_connection(cli1)) {
562
if (!torture_close_connection(cli2)) {
566
return (test1 && test2);
569
static BOOL run_readwritemulti(int dummy)
571
struct cli_state *cli;
576
cli_sockopt(cli, sockops);
578
printf("run_readwritemulti: fname %s\n", randomfname);
579
test = rw_torture3(cli, randomfname);
581
if (!torture_close_connection(cli)) {
588
static BOOL run_readwritelarge(int dummy)
590
static struct cli_state *cli1;
592
const char *lockfname = "\\large.dat";
597
if (!torture_open_connection(&cli1)) {
600
cli_sockopt(cli1, sockops);
601
memset(buf,'\0',sizeof(buf));
603
cli1->max_xmit = 128*1024;
605
printf("starting readwritelarge\n");
607
cli_unlink(cli1, lockfname);
609
fnum1 = cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE);
611
printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
615
cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf));
617
if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
618
printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
622
if (fsize == sizeof(buf))
623
printf("readwritelarge test 1 succeeded (size = %lx)\n",
624
(unsigned long)fsize);
626
printf("readwritelarge test 1 failed (size = %lx)\n",
627
(unsigned long)fsize);
631
if (!cli_close(cli1, fnum1)) {
632
printf("close failed (%s)\n", cli_errstr(cli1));
636
if (!cli_unlink(cli1, lockfname)) {
637
printf("unlink failed (%s)\n", cli_errstr(cli1));
641
fnum1 = cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE);
643
printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
647
cli1->max_xmit = 4*1024;
649
cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf));
651
if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
652
printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
656
if (fsize == sizeof(buf))
657
printf("readwritelarge test 2 succeeded (size = %lx)\n",
658
(unsigned long)fsize);
660
printf("readwritelarge test 2 failed (size = %lx)\n",
661
(unsigned long)fsize);
666
/* ToDo - set allocation. JRA */
667
if(!cli_set_allocation_size(cli1, fnum1, 0)) {
668
printf("set allocation size to zero failed (%s)\n", cli_errstr(&cli1));
671
if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
672
printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
676
printf("readwritelarge test 3 (truncate test) succeeded (size = %x)\n", fsize);
679
if (!cli_close(cli1, fnum1)) {
680
printf("close failed (%s)\n", cli_errstr(cli1));
684
if (!torture_close_connection(cli1)) {
693
#define ival(s) strtol(s, NULL, 0)
695
/* run a test that simulates an approximate netbench client load */
696
static BOOL run_netbench(int client)
698
struct cli_state *cli;
703
const char *params[20];
710
cli_sockopt(cli, sockops);
714
slprintf(cname,sizeof(cname)-1, "client%d", client);
716
f = fopen(client_txt, "r");
723
while (fgets(line, sizeof(line)-1, f)) {
726
line[strlen(line)-1] = 0;
728
/* printf("[%d] %s\n", line_count, line); */
730
all_string_sub(line,"client1", cname, sizeof(line));
732
/* parse the command parameters */
733
params[0] = strtok(line," ");
735
while (params[i]) params[++i] = strtok(NULL," ");
741
if (!strncmp(params[0],"SMB", 3)) {
742
printf("ERROR: You are using a dbench 1 load file\n");
746
if (!strcmp(params[0],"NTCreateX")) {
747
nb_createx(params[1], ival(params[2]), ival(params[3]),
749
} else if (!strcmp(params[0],"Close")) {
750
nb_close(ival(params[1]));
751
} else if (!strcmp(params[0],"Rename")) {
752
nb_rename(params[1], params[2]);
753
} else if (!strcmp(params[0],"Unlink")) {
754
nb_unlink(params[1]);
755
} else if (!strcmp(params[0],"Deltree")) {
756
nb_deltree(params[1]);
757
} else if (!strcmp(params[0],"Rmdir")) {
759
} else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
760
nb_qpathinfo(params[1]);
761
} else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
762
nb_qfileinfo(ival(params[1]));
763
} else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
764
nb_qfsinfo(ival(params[1]));
765
} else if (!strcmp(params[0],"FIND_FIRST")) {
766
nb_findfirst(params[1]);
767
} else if (!strcmp(params[0],"WriteX")) {
768
nb_writex(ival(params[1]),
769
ival(params[2]), ival(params[3]), ival(params[4]));
770
} else if (!strcmp(params[0],"ReadX")) {
771
nb_readx(ival(params[1]),
772
ival(params[2]), ival(params[3]), ival(params[4]));
773
} else if (!strcmp(params[0],"Flush")) {
774
nb_flush(ival(params[1]));
776
printf("Unknown operation %s\n", params[0]);
784
if (!torture_close_connection(cli)) {
792
/* run a test that simulates an approximate netbench client load */
793
static BOOL run_nbench(int dummy)
802
signal(SIGALRM, nb_alarm);
804
t = create_procs(run_netbench, &correct);
807
printf("\nThroughput %g MB/sec\n",
808
1.0e-6 * nbio_total() / t);
814
This test checks for two things:
816
1) correct support for retaining locks over a close (ie. the server
817
must not use posix semantics)
818
2) support for lock timeouts
820
static BOOL run_locktest1(int dummy)
822
struct cli_state *cli1, *cli2;
823
const char *fname = "\\lockt1.lck";
824
int fnum1, fnum2, fnum3;
826
unsigned lock_timeout;
828
if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
831
cli_sockopt(cli1, sockops);
832
cli_sockopt(cli2, sockops);
834
printf("starting locktest1\n");
836
cli_unlink(cli1, fname);
838
fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
840
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
843
fnum2 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
845
printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli1));
848
fnum3 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
850
printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli2));
854
if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
855
printf("lock1 failed (%s)\n", cli_errstr(cli1));
860
if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
861
printf("lock2 succeeded! This is a locking bug\n");
864
if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
865
NT_STATUS_LOCK_NOT_GRANTED)) return False;
869
lock_timeout = (1 + (random() % 20));
870
printf("Testing lock timeout with timeout=%u\n", lock_timeout);
872
if (cli_lock(cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK)) {
873
printf("lock3 succeeded! This is a locking bug\n");
876
if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
877
NT_STATUS_FILE_LOCK_CONFLICT)) return False;
881
if (ABS(t2 - t1) < lock_timeout-1) {
882
printf("error: This server appears not to support timed lock requests\n");
885
printf("server slept for %u seconds for a %u second timeout\n",
886
(unsigned int)(t2-t1), lock_timeout);
888
if (!cli_close(cli1, fnum2)) {
889
printf("close1 failed (%s)\n", cli_errstr(cli1));
893
if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
894
printf("lock4 succeeded! This is a locking bug\n");
897
if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
898
NT_STATUS_FILE_LOCK_CONFLICT)) return False;
901
if (!cli_close(cli1, fnum1)) {
902
printf("close2 failed (%s)\n", cli_errstr(cli1));
906
if (!cli_close(cli2, fnum3)) {
907
printf("close3 failed (%s)\n", cli_errstr(cli2));
911
if (!cli_unlink(cli1, fname)) {
912
printf("unlink failed (%s)\n", cli_errstr(cli1));
917
if (!torture_close_connection(cli1)) {
921
if (!torture_close_connection(cli2)) {
925
printf("Passed locktest1\n");
930
this checks to see if a secondary tconx can use open files from an
933
static BOOL run_tcon_test(int dummy)
935
static struct cli_state *cli;
936
const char *fname = "\\tcontest.tmp";
938
uint16 cnum1, cnum2, cnum3;
943
if (!torture_open_connection(&cli)) {
946
cli_sockopt(cli, sockops);
948
printf("starting tcontest\n");
950
cli_unlink(cli, fname);
952
fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
954
printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
961
if (cli_write(cli, fnum1, 0, buf, 130, 4) != 4) {
962
printf("initial write failed (%s)", cli_errstr(cli));
966
if (!cli_send_tconX(cli, share, "?????",
967
password, strlen(password)+1)) {
968
printf("%s refused 2nd tree connect (%s)\n", host,
975
cnum3 = MAX(cnum1, cnum2) + 1; /* any invalid number */
976
vuid2 = cli->vuid + 1;
978
/* try a write with the wrong tid */
981
if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
982
printf("* server allows write with wrong TID\n");
985
printf("server fails write with wrong TID : %s\n", cli_errstr(cli));
989
/* try a write with an invalid tid */
992
if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
993
printf("* server allows write with invalid TID\n");
996
printf("server fails write with invalid TID : %s\n", cli_errstr(cli));
999
/* try a write with an invalid vuid */
1003
if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1004
printf("* server allows write with invalid VUID\n");
1007
printf("server fails write with invalid VUID : %s\n", cli_errstr(cli));
1013
if (!cli_close(cli, fnum1)) {
1014
printf("close failed (%s)\n", cli_errstr(cli));
1020
if (!cli_tdis(cli)) {
1021
printf("secondary tdis failed (%s)\n", cli_errstr(cli));
1027
if (!torture_close_connection(cli)) {
1036
checks for old style tcon support
1038
static BOOL run_tcon2_test(int dummy)
1040
static struct cli_state *cli;
1041
uint16 cnum, max_xmit;
1045
if (!torture_open_connection(&cli)) {
1048
cli_sockopt(cli, sockops);
1050
printf("starting tcon2 test\n");
1052
asprintf(&service, "\\\\%s\\%s", host, share);
1054
status = cli_raw_tcon(cli, service, password, "?????", &max_xmit, &cnum);
1056
if (!NT_STATUS_IS_OK(status)) {
1057
printf("tcon2 failed : %s\n", cli_errstr(cli));
1059
printf("tcon OK : max_xmit=%d cnum=%d tid=%d\n",
1060
(int)max_xmit, (int)cnum, SVAL(cli->inbuf, smb_tid));
1063
if (!torture_close_connection(cli)) {
1067
printf("Passed tcon2 test\n");
1071
static BOOL tcon_devtest(struct cli_state *cli,
1072
const char *myshare, const char *devtype,
1073
const char *return_devtype,
1074
NTSTATUS expected_error)
1079
status = cli_send_tconX(cli, myshare, devtype,
1080
password, strlen(password)+1);
1082
if (NT_STATUS_IS_OK(expected_error)) {
1084
if (strcmp(cli->dev, return_devtype) == 0) {
1087
printf("tconX to share %s with type %s "
1088
"succeeded but returned the wrong "
1089
"device type (got [%s] but should have got [%s])\n",
1090
myshare, devtype, cli->dev, return_devtype);
1094
printf("tconX to share %s with type %s "
1095
"should have succeeded but failed\n",
1102
printf("tconx to share %s with type %s "
1103
"should have failed but succeeded\n",
1107
if (NT_STATUS_EQUAL(cli_nt_error(cli),
1111
printf("Returned unexpected error\n");
1120
checks for correct tconX support
1122
static BOOL run_tcon_devtype_test(int dummy)
1124
static struct cli_state *cli1 = NULL;
1130
status = cli_full_connection(&cli1, myname,
1131
host, NULL, port_to_use,
1133
username, workgroup,
1134
password, flags, Undefined, &retry);
1136
if (!NT_STATUS_IS_OK(status)) {
1137
printf("could not open connection\n");
1141
if (!tcon_devtest(cli1, "IPC$", "A:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1144
if (!tcon_devtest(cli1, "IPC$", "?????", "IPC", NT_STATUS_OK))
1147
if (!tcon_devtest(cli1, "IPC$", "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1150
if (!tcon_devtest(cli1, "IPC$", "IPC", "IPC", NT_STATUS_OK))
1153
if (!tcon_devtest(cli1, "IPC$", "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1156
if (!tcon_devtest(cli1, share, "A:", "A:", NT_STATUS_OK))
1159
if (!tcon_devtest(cli1, share, "?????", "A:", NT_STATUS_OK))
1162
if (!tcon_devtest(cli1, share, "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1165
if (!tcon_devtest(cli1, share, "IPC", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1168
if (!tcon_devtest(cli1, share, "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1174
printf("Passed tcondevtest\n");
1181
This test checks that
1183
1) the server supports multiple locking contexts on the one SMB
1184
connection, distinguished by PID.
1186
2) the server correctly fails overlapping locks made by the same PID (this
1187
goes against POSIX behaviour, which is why it is tricky to implement)
1189
3) the server denies unlock requests by an incorrect client PID
1191
static BOOL run_locktest2(int dummy)
1193
static struct cli_state *cli;
1194
const char *fname = "\\lockt2.lck";
1195
int fnum1, fnum2, fnum3;
1196
BOOL correct = True;
1198
if (!torture_open_connection(&cli)) {
1202
cli_sockopt(cli, sockops);
1204
printf("starting locktest2\n");
1206
cli_unlink(cli, fname);
1210
fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1212
printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1216
fnum2 = cli_open(cli, fname, O_RDWR, DENY_NONE);
1218
printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli));
1224
fnum3 = cli_open(cli, fname, O_RDWR, DENY_NONE);
1226
printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli));
1232
if (!cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1233
printf("lock1 failed (%s)\n", cli_errstr(cli));
1237
if (cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1238
printf("WRITE lock1 succeeded! This is a locking bug\n");
1241
if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1242
NT_STATUS_LOCK_NOT_GRANTED)) return False;
1245
if (cli_lock(cli, fnum2, 0, 4, 0, WRITE_LOCK)) {
1246
printf("WRITE lock2 succeeded! This is a locking bug\n");
1249
if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1250
NT_STATUS_LOCK_NOT_GRANTED)) return False;
1253
if (cli_lock(cli, fnum2, 0, 4, 0, READ_LOCK)) {
1254
printf("READ lock2 succeeded! This is a locking bug\n");
1257
if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1258
NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1261
if (!cli_lock(cli, fnum1, 100, 4, 0, WRITE_LOCK)) {
1262
printf("lock at 100 failed (%s)\n", cli_errstr(cli));
1265
if (cli_unlock(cli, fnum1, 100, 4)) {
1266
printf("unlock at 100 succeeded! This is a locking bug\n");
1270
if (cli_unlock(cli, fnum1, 0, 4)) {
1271
printf("unlock1 succeeded! This is a locking bug\n");
1274
if (!check_error(__LINE__, cli,
1276
NT_STATUS_RANGE_NOT_LOCKED)) return False;
1279
if (cli_unlock(cli, fnum1, 0, 8)) {
1280
printf("unlock2 succeeded! This is a locking bug\n");
1283
if (!check_error(__LINE__, cli,
1285
NT_STATUS_RANGE_NOT_LOCKED)) return False;
1288
if (cli_lock(cli, fnum3, 0, 4, 0, WRITE_LOCK)) {
1289
printf("lock3 succeeded! This is a locking bug\n");
1292
if (!check_error(__LINE__, cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
1297
if (!cli_close(cli, fnum1)) {
1298
printf("close1 failed (%s)\n", cli_errstr(cli));
1302
if (!cli_close(cli, fnum2)) {
1303
printf("close2 failed (%s)\n", cli_errstr(cli));
1307
if (!cli_close(cli, fnum3)) {
1308
printf("close3 failed (%s)\n", cli_errstr(cli));
1312
if (!torture_close_connection(cli)) {
1316
printf("locktest2 finished\n");
1323
This test checks that
1325
1) the server supports the full offset range in lock requests
1327
static BOOL run_locktest3(int dummy)
1329
static struct cli_state *cli1, *cli2;
1330
const char *fname = "\\lockt3.lck";
1331
int fnum1, fnum2, i;
1333
BOOL correct = True;
1335
#define NEXT_OFFSET offset += (~(uint32)0) / torture_numops
1337
if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
1340
cli_sockopt(cli1, sockops);
1341
cli_sockopt(cli2, sockops);
1343
printf("starting locktest3\n");
1345
cli_unlink(cli1, fname);
1347
fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1349
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1352
fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1354
printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli2));
1358
for (offset=i=0;i<torture_numops;i++) {
1360
if (!cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1361
printf("lock1 %d failed (%s)\n",
1367
if (!cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1368
printf("lock2 %d failed (%s)\n",
1375
for (offset=i=0;i<torture_numops;i++) {
1378
if (cli_lock(cli1, fnum1, offset-2, 1, 0, WRITE_LOCK)) {
1379
printf("error: lock1 %d succeeded!\n", i);
1383
if (cli_lock(cli2, fnum2, offset-1, 1, 0, WRITE_LOCK)) {
1384
printf("error: lock2 %d succeeded!\n", i);
1388
if (cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1389
printf("error: lock3 %d succeeded!\n", i);
1393
if (cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1394
printf("error: lock4 %d succeeded!\n", i);
1399
for (offset=i=0;i<torture_numops;i++) {
1402
if (!cli_unlock(cli1, fnum1, offset-1, 1)) {
1403
printf("unlock1 %d failed (%s)\n",
1409
if (!cli_unlock(cli2, fnum2, offset-2, 1)) {
1410
printf("unlock2 %d failed (%s)\n",
1417
if (!cli_close(cli1, fnum1)) {
1418
printf("close1 failed (%s)\n", cli_errstr(cli1));
1422
if (!cli_close(cli2, fnum2)) {
1423
printf("close2 failed (%s)\n", cli_errstr(cli2));
1427
if (!cli_unlink(cli1, fname)) {
1428
printf("unlink failed (%s)\n", cli_errstr(cli1));
1432
if (!torture_close_connection(cli1)) {
1436
if (!torture_close_connection(cli2)) {
1440
printf("finished locktest3\n");
1445
#define EXPECTED(ret, v) if ((ret) != (v)) { \
1446
printf("** "); correct = False; \
1450
looks at overlapping locks
1452
static BOOL run_locktest4(int dummy)
1454
static struct cli_state *cli1, *cli2;
1455
const char *fname = "\\lockt4.lck";
1456
int fnum1, fnum2, f;
1459
BOOL correct = True;
1461
if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
1465
cli_sockopt(cli1, sockops);
1466
cli_sockopt(cli2, sockops);
1468
printf("starting locktest4\n");
1470
cli_unlink(cli1, fname);
1472
fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1473
fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1475
memset(buf, 0, sizeof(buf));
1477
if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1478
printf("Failed to create file\n");
1483
ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1484
cli_lock(cli1, fnum1, 2, 4, 0, WRITE_LOCK);
1485
EXPECTED(ret, False);
1486
printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
1488
ret = cli_lock(cli1, fnum1, 10, 4, 0, READ_LOCK) &&
1489
cli_lock(cli1, fnum1, 12, 4, 0, READ_LOCK);
1490
EXPECTED(ret, True);
1491
printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
1493
ret = cli_lock(cli1, fnum1, 20, 4, 0, WRITE_LOCK) &&
1494
cli_lock(cli2, fnum2, 22, 4, 0, WRITE_LOCK);
1495
EXPECTED(ret, False);
1496
printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
1498
ret = cli_lock(cli1, fnum1, 30, 4, 0, READ_LOCK) &&
1499
cli_lock(cli2, fnum2, 32, 4, 0, READ_LOCK);
1500
EXPECTED(ret, True);
1501
printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
1503
ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 40, 4, 0, WRITE_LOCK)) &&
1504
(cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 42, 4, 0, WRITE_LOCK));
1505
EXPECTED(ret, False);
1506
printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
1508
ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 50, 4, 0, READ_LOCK)) &&
1509
(cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 52, 4, 0, READ_LOCK));
1510
EXPECTED(ret, True);
1511
printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
1513
ret = cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK) &&
1514
cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK);
1515
EXPECTED(ret, True);
1516
printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
1518
ret = cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK) &&
1519
cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK);
1520
EXPECTED(ret, False);
1521
printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
1523
ret = cli_lock(cli1, fnum1, 80, 4, 0, READ_LOCK) &&
1524
cli_lock(cli1, fnum1, 80, 4, 0, WRITE_LOCK);
1525
EXPECTED(ret, False);
1526
printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
1528
ret = cli_lock(cli1, fnum1, 90, 4, 0, WRITE_LOCK) &&
1529
cli_lock(cli1, fnum1, 90, 4, 0, READ_LOCK);
1530
EXPECTED(ret, True);
1531
printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1533
ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 100, 4, 0, WRITE_LOCK)) &&
1534
(cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 100, 4, 0, READ_LOCK));
1535
EXPECTED(ret, False);
1536
printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1538
ret = cli_lock(cli1, fnum1, 110, 4, 0, READ_LOCK) &&
1539
cli_lock(cli1, fnum1, 112, 4, 0, READ_LOCK) &&
1540
cli_unlock(cli1, fnum1, 110, 6);
1541
EXPECTED(ret, False);
1542
printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
1545
ret = cli_lock(cli1, fnum1, 120, 4, 0, WRITE_LOCK) &&
1546
(cli_read(cli2, fnum2, buf, 120, 4) == 4);
1547
EXPECTED(ret, False);
1548
printf("this server %s strict write locking\n", ret?"doesn't do":"does");
1550
ret = cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK) &&
1551
(cli_write(cli2, fnum2, 0, buf, 130, 4) == 4);
1552
EXPECTED(ret, False);
1553
printf("this server %s strict read locking\n", ret?"doesn't do":"does");
1556
ret = cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1557
cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1558
cli_unlock(cli1, fnum1, 140, 4) &&
1559
cli_unlock(cli1, fnum1, 140, 4);
1560
EXPECTED(ret, True);
1561
printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
1564
ret = cli_lock(cli1, fnum1, 150, 4, 0, WRITE_LOCK) &&
1565
cli_lock(cli1, fnum1, 150, 4, 0, READ_LOCK) &&
1566
cli_unlock(cli1, fnum1, 150, 4) &&
1567
(cli_read(cli2, fnum2, buf, 150, 4) == 4) &&
1568
!(cli_write(cli2, fnum2, 0, buf, 150, 4) == 4) &&
1569
cli_unlock(cli1, fnum1, 150, 4);
1570
EXPECTED(ret, True);
1571
printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
1573
ret = cli_lock(cli1, fnum1, 160, 4, 0, READ_LOCK) &&
1574
cli_unlock(cli1, fnum1, 160, 4) &&
1575
(cli_write(cli2, fnum2, 0, buf, 160, 4) == 4) &&
1576
(cli_read(cli2, fnum2, buf, 160, 4) == 4);
1577
EXPECTED(ret, True);
1578
printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
1580
ret = cli_lock(cli1, fnum1, 170, 4, 0, WRITE_LOCK) &&
1581
cli_unlock(cli1, fnum1, 170, 4) &&
1582
(cli_write(cli2, fnum2, 0, buf, 170, 4) == 4) &&
1583
(cli_read(cli2, fnum2, buf, 170, 4) == 4);
1584
EXPECTED(ret, True);
1585
printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
1587
ret = cli_lock(cli1, fnum1, 190, 4, 0, WRITE_LOCK) &&
1588
cli_lock(cli1, fnum1, 190, 4, 0, READ_LOCK) &&
1589
cli_unlock(cli1, fnum1, 190, 4) &&
1590
!(cli_write(cli2, fnum2, 0, buf, 190, 4) == 4) &&
1591
(cli_read(cli2, fnum2, buf, 190, 4) == 4);
1592
EXPECTED(ret, True);
1593
printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
1595
cli_close(cli1, fnum1);
1596
cli_close(cli2, fnum2);
1597
fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1598
f = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1599
ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1600
cli_lock(cli1, f, 0, 1, 0, READ_LOCK) &&
1601
cli_close(cli1, fnum1) &&
1602
((fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE)) != -1) &&
1603
cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1605
cli_close(cli1, fnum1);
1606
EXPECTED(ret, True);
1607
printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
1610
cli_close(cli1, fnum1);
1611
cli_close(cli2, fnum2);
1612
cli_unlink(cli1, fname);
1613
torture_close_connection(cli1);
1614
torture_close_connection(cli2);
1616
printf("finished locktest4\n");
1621
looks at lock upgrade/downgrade.
1623
static BOOL run_locktest5(int dummy)
1625
static struct cli_state *cli1, *cli2;
1626
const char *fname = "\\lockt5.lck";
1627
int fnum1, fnum2, fnum3;
1630
BOOL correct = True;
1632
if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
1636
cli_sockopt(cli1, sockops);
1637
cli_sockopt(cli2, sockops);
1639
printf("starting locktest5\n");
1641
cli_unlink(cli1, fname);
1643
fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1644
fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1645
fnum3 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1647
memset(buf, 0, sizeof(buf));
1649
if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1650
printf("Failed to create file\n");
1655
/* Check for NT bug... */
1656
ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1657
cli_lock(cli1, fnum3, 0, 1, 0, READ_LOCK);
1658
cli_close(cli1, fnum1);
1659
fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1660
ret = cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1661
EXPECTED(ret, True);
1662
printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
1663
cli_close(cli1, fnum1);
1664
fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1665
cli_unlock(cli1, fnum3, 0, 1);
1667
ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1668
cli_lock(cli1, fnum1, 1, 1, 0, READ_LOCK);
1669
EXPECTED(ret, True);
1670
printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
1672
ret = cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1673
EXPECTED(ret, False);
1675
printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
1677
/* Unlock the process 2 lock. */
1678
cli_unlock(cli2, fnum2, 0, 4);
1680
ret = cli_lock(cli1, fnum3, 0, 4, 0, READ_LOCK);
1681
EXPECTED(ret, False);
1683
printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
1685
/* Unlock the process 1 fnum3 lock. */
1686
cli_unlock(cli1, fnum3, 0, 4);
1688
/* Stack 2 more locks here. */
1689
ret = cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK) &&
1690
cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK);
1692
EXPECTED(ret, True);
1693
printf("the same process %s stack read locks\n", ret?"can":"cannot");
1695
/* Unlock the first process lock, then check this was the WRITE lock that was
1698
ret = cli_unlock(cli1, fnum1, 0, 4) &&
1699
cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1701
EXPECTED(ret, True);
1702
printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
1704
/* Unlock the process 2 lock. */
1705
cli_unlock(cli2, fnum2, 0, 4);
1707
/* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
1709
ret = cli_unlock(cli1, fnum1, 1, 1) &&
1710
cli_unlock(cli1, fnum1, 0, 4) &&
1711
cli_unlock(cli1, fnum1, 0, 4);
1713
EXPECTED(ret, True);
1714
printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
1716
/* Ensure the next unlock fails. */
1717
ret = cli_unlock(cli1, fnum1, 0, 4);
1718
EXPECTED(ret, False);
1719
printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
1721
/* Ensure connection 2 can get a write lock. */
1722
ret = cli_lock(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
1723
EXPECTED(ret, True);
1725
printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
1729
cli_close(cli1, fnum1);
1730
cli_close(cli2, fnum2);
1731
cli_unlink(cli1, fname);
1732
if (!torture_close_connection(cli1)) {
1735
if (!torture_close_connection(cli2)) {
1739
printf("finished locktest5\n");
1745
tries the unusual lockingX locktype bits
1747
static BOOL run_locktest6(int dummy)
1749
static struct cli_state *cli;
1750
const char *fname[1] = { "\\lock6.txt" };
1755
if (!torture_open_connection(&cli)) {
1759
cli_sockopt(cli, sockops);
1761
printf("starting locktest6\n");
1764
printf("Testing %s\n", fname[i]);
1766
cli_unlink(cli, fname[i]);
1768
fnum = cli_open(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1769
status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
1770
cli_close(cli, fnum);
1771
printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
1773
fnum = cli_open(cli, fname[i], O_RDWR, DENY_NONE);
1774
status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
1775
cli_close(cli, fnum);
1776
printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
1778
cli_unlink(cli, fname[i]);
1781
torture_close_connection(cli);
1783
printf("finished locktest6\n");
1787
static BOOL run_locktest7(int dummy)
1789
struct cli_state *cli1;
1790
const char *fname = "\\lockt7.lck";
1793
BOOL correct = False;
1795
if (!torture_open_connection(&cli1)) {
1799
cli_sockopt(cli1, sockops);
1801
printf("starting locktest7\n");
1803
cli_unlink(cli1, fname);
1805
fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1807
memset(buf, 0, sizeof(buf));
1809
if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1810
printf("Failed to create file\n");
1814
cli_setpid(cli1, 1);
1816
if (!cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK)) {
1817
printf("Unable to apply read lock on range 130:4, error was %s\n", cli_errstr(cli1));
1820
printf("pid1 successfully locked range 130:4 for READ\n");
1823
if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
1824
printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
1827
printf("pid1 successfully read the range 130:4\n");
1830
if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
1831
printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
1832
if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
1833
printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
1837
printf("pid1 successfully wrote to the range 130:4 (should be denied)\n");
1841
cli_setpid(cli1, 2);
1843
if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
1844
printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
1846
printf("pid2 successfully read the range 130:4\n");
1849
if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
1850
printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
1851
if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
1852
printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
1856
printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
1860
cli_setpid(cli1, 1);
1861
cli_unlock(cli1, fnum1, 130, 4);
1863
if (!cli_lock(cli1, fnum1, 130, 4, 0, WRITE_LOCK)) {
1864
printf("Unable to apply write lock on range 130:4, error was %s\n", cli_errstr(cli1));
1867
printf("pid1 successfully locked range 130:4 for WRITE\n");
1870
if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
1871
printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
1874
printf("pid1 successfully read the range 130:4\n");
1877
if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
1878
printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
1881
printf("pid1 successfully wrote to the range 130:4\n");
1884
cli_setpid(cli1, 2);
1886
if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
1887
printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
1888
if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
1889
printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
1893
printf("pid2 successfully read the range 130:4 (should be denied)\n");
1897
if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
1898
printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
1899
if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
1900
printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
1904
printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
1908
cli_unlock(cli1, fnum1, 130, 0);
1912
cli_close(cli1, fnum1);
1913
cli_unlink(cli1, fname);
1914
torture_close_connection(cli1);
1916
printf("finished locktest7\n");
1921
test whether fnums and tids open on one VC are available on another (a major
1924
static BOOL run_fdpasstest(int dummy)
1926
struct cli_state *cli1, *cli2;
1927
const char *fname = "\\fdpass.tst";
1931
if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
1934
cli_sockopt(cli1, sockops);
1935
cli_sockopt(cli2, sockops);
1937
printf("starting fdpasstest\n");
1939
cli_unlink(cli1, fname);
1941
fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1943
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1947
if (cli_write(cli1, fnum1, 0, "hello world\n", 0, 13) != 13) {
1948
printf("write failed (%s)\n", cli_errstr(cli1));
1952
cli2->vuid = cli1->vuid;
1953
cli2->cnum = cli1->cnum;
1954
cli2->pid = cli1->pid;
1956
if (cli_read(cli2, fnum1, buf, 0, 13) == 13) {
1957
printf("read succeeded! nasty security hole [%s]\n",
1962
cli_close(cli1, fnum1);
1963
cli_unlink(cli1, fname);
1965
torture_close_connection(cli1);
1966
torture_close_connection(cli2);
1968
printf("finished fdpasstest\n");
1972
static BOOL run_fdsesstest(int dummy)
1974
struct cli_state *cli;
1979
const char *fname = "\\fdsess.tst";
1980
const char *fname1 = "\\fdsess1.tst";
1986
if (!torture_open_connection(&cli))
1988
cli_sockopt(cli, sockops);
1990
if (!torture_cli_session_setup2(cli, &new_vuid))
1993
saved_cnum = cli->cnum;
1994
if (!cli_send_tconX(cli, share, "?????", "", 1))
1996
new_cnum = cli->cnum;
1997
cli->cnum = saved_cnum;
1999
printf("starting fdsesstest\n");
2001
cli_unlink(cli, fname);
2002
cli_unlink(cli, fname1);
2004
fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2006
printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2010
if (cli_write(cli, fnum1, 0, "hello world\n", 0, 13) != 13) {
2011
printf("write failed (%s)\n", cli_errstr(cli));
2015
saved_vuid = cli->vuid;
2016
cli->vuid = new_vuid;
2018
if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2019
printf("read succeeded with different vuid! nasty security hole [%s]\n",
2023
/* Try to open a file with different vuid, samba cnum. */
2024
fnum2 = cli_open(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2026
printf("create with different vuid, same cnum succeeded.\n");
2027
cli_close(cli, fnum2);
2028
cli_unlink(cli, fname1);
2030
printf("create with different vuid, same cnum failed.\n");
2031
printf("This will cause problems with service clients.\n");
2035
cli->vuid = saved_vuid;
2037
/* Try with same vuid, different cnum. */
2038
cli->cnum = new_cnum;
2040
if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2041
printf("read succeeded with different cnum![%s]\n",
2046
cli->cnum = saved_cnum;
2047
cli_close(cli, fnum1);
2048
cli_unlink(cli, fname);
2050
torture_close_connection(cli);
2052
printf("finished fdsesstest\n");
2057
This test checks that
2059
1) the server does not allow an unlink on a file that is open
2061
static BOOL run_unlinktest(int dummy)
2063
struct cli_state *cli;
2064
const char *fname = "\\unlink.tst";
2066
BOOL correct = True;
2068
if (!torture_open_connection(&cli)) {
2072
cli_sockopt(cli, sockops);
2074
printf("starting unlink test\n");
2076
cli_unlink(cli, fname);
2080
fnum = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2082
printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2086
if (cli_unlink(cli, fname)) {
2087
printf("error: server allowed unlink on an open file\n");
2090
correct = check_error(__LINE__, cli, ERRDOS, ERRbadshare,
2091
NT_STATUS_SHARING_VIOLATION);
2094
cli_close(cli, fnum);
2095
cli_unlink(cli, fname);
2097
if (!torture_close_connection(cli)) {
2101
printf("unlink test finished\n");
2108
test how many open files this server supports on the one socket
2110
static BOOL run_maxfidtest(int dummy)
2112
struct cli_state *cli;
2113
const char *ftemplate = "\\maxfid.%d.%d";
2115
int fnums[0x11000], i;
2117
BOOL correct = True;
2122
printf("failed to connect\n");
2126
cli_sockopt(cli, sockops);
2128
for (i=0; i<0x11000; i++) {
2129
slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2130
if ((fnums[i] = cli_open(cli, fname,
2131
O_RDWR|O_CREAT|O_TRUNC, DENY_NONE)) ==
2133
printf("open of %s failed (%s)\n",
2134
fname, cli_errstr(cli));
2135
printf("maximum fnum is %d\n", i);
2143
printf("cleaning up\n");
2145
slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2146
cli_close(cli, fnums[i]);
2147
if (!cli_unlink(cli, fname)) {
2148
printf("unlink of %s failed (%s)\n",
2149
fname, cli_errstr(cli));
2156
printf("maxfid test finished\n");
2157
if (!torture_close_connection(cli)) {
2163
/* generate a random buffer */
2164
static void rand_buf(char *buf, int len)
2167
*buf = (char)sys_random();
2172
/* send smb negprot commands, not reading the response */
2173
static BOOL run_negprot_nowait(int dummy)
2176
static struct cli_state *cli;
2177
BOOL correct = True;
2179
printf("starting negprot nowait test\n");
2181
if (!(cli = open_nbt_connection())) {
2185
for (i=0;i<50000;i++) {
2186
cli_negprot_send(cli);
2189
if (!torture_close_connection(cli)) {
2193
printf("finished negprot nowait test\n");
2199
/* send random IPC commands */
2200
static BOOL run_randomipc(int dummy)
2202
char *rparam = NULL;
2204
unsigned int rdrcnt,rprcnt;
2206
int api, param_len, i;
2207
struct cli_state *cli;
2208
BOOL correct = True;
2211
printf("starting random ipc test\n");
2213
if (!torture_open_connection(&cli)) {
2217
for (i=0;i<count;i++) {
2218
api = sys_random() % 500;
2219
param_len = (sys_random() % 64);
2221
rand_buf(param, param_len);
2226
param, param_len, 8,
2227
NULL, 0, BUFFER_SIZE,
2231
printf("%d/%d\r", i,count);
2234
printf("%d/%d\n", i, count);
2236
if (!torture_close_connection(cli)) {
2240
printf("finished random ipc test\n");
2247
static void browse_callback(const char *sname, uint32 stype,
2248
const char *comment, void *state)
2250
printf("\t%20.20s %08x %s\n", sname, stype, comment);
2256
This test checks the browse list code
2259
static BOOL run_browsetest(int dummy)
2261
static struct cli_state *cli;
2262
BOOL correct = True;
2264
printf("starting browse test\n");
2266
if (!torture_open_connection(&cli)) {
2270
printf("domain list:\n");
2271
cli_NetServerEnum(cli, cli->server_domain,
2272
SV_TYPE_DOMAIN_ENUM,
2273
browse_callback, NULL);
2275
printf("machine list:\n");
2276
cli_NetServerEnum(cli, cli->server_domain,
2278
browse_callback, NULL);
2280
if (!torture_close_connection(cli)) {
2284
printf("browse test finished\n");
2292
This checks how the getatr calls works
2294
static BOOL run_attrtest(int dummy)
2296
struct cli_state *cli;
2299
const char *fname = "\\attrib123456789.tst";
2300
BOOL correct = True;
2302
printf("starting attrib test\n");
2304
if (!torture_open_connection(&cli)) {
2308
cli_unlink(cli, fname);
2309
fnum = cli_open(cli, fname,
2310
O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2311
cli_close(cli, fnum);
2312
if (!cli_getatr(cli, fname, NULL, NULL, &t)) {
2313
printf("getatr failed (%s)\n", cli_errstr(cli));
2317
if (abs(t - time(NULL)) > 60*60*24*10) {
2318
printf("ERROR: SMBgetatr bug. time is %s",
2324
t2 = t-60*60*24; /* 1 day ago */
2326
if (!cli_setatr(cli, fname, 0, t2)) {
2327
printf("setatr failed (%s)\n", cli_errstr(cli));
2331
if (!cli_getatr(cli, fname, NULL, NULL, &t)) {
2332
printf("getatr failed (%s)\n", cli_errstr(cli));
2337
printf("ERROR: getatr/setatr bug. times are\n%s",
2339
printf("%s", ctime(&t2));
2343
cli_unlink(cli, fname);
2345
if (!torture_close_connection(cli)) {
2349
printf("attrib test finished\n");
2356
This checks a couple of trans2 calls
2358
static BOOL run_trans2test(int dummy)
2360
struct cli_state *cli;
2363
time_t c_time, a_time, m_time, w_time, m_time2;
2364
const char *fname = "\\trans2.tst";
2365
const char *dname = "\\trans2";
2366
const char *fname2 = "\\trans2\\trans2.tst";
2368
BOOL correct = True;
2370
printf("starting trans2 test\n");
2372
if (!torture_open_connection(&cli)) {
2376
cli_unlink(cli, fname);
2377
fnum = cli_open(cli, fname,
2378
O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2379
if (!cli_qfileinfo(cli, fnum, NULL, &size, &c_time, &a_time, &m_time,
2381
printf("ERROR: qfileinfo failed (%s)\n", cli_errstr(cli));
2385
if (!cli_qfilename(cli, fnum, pname)) {
2386
printf("ERROR: qfilename failed (%s)\n", cli_errstr(cli));
2390
if (strcmp(pname, fname)) {
2391
printf("qfilename gave different name? [%s] [%s]\n",
2396
cli_close(cli, fnum);
2400
cli_unlink(cli, fname);
2401
fnum = cli_open(cli, fname,
2402
O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2404
printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2407
cli_close(cli, fnum);
2409
if (!cli_qpathinfo(cli, fname, &c_time, &a_time, &m_time, &size, NULL)) {
2410
printf("ERROR: qpathinfo failed (%s)\n", cli_errstr(cli));
2413
if (c_time != m_time) {
2414
printf("create time=%s", ctime(&c_time));
2415
printf("modify time=%s", ctime(&m_time));
2416
printf("This system appears to have sticky create times\n");
2418
if (a_time % (60*60) == 0) {
2419
printf("access time=%s", ctime(&a_time));
2420
printf("This system appears to set a midnight access time\n");
2424
if (abs(m_time - time(NULL)) > 60*60*24*7) {
2425
printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
2431
cli_unlink(cli, fname);
2432
fnum = cli_open(cli, fname,
2433
O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2434
cli_close(cli, fnum);
2435
if (!cli_qpathinfo2(cli, fname, &c_time, &a_time, &m_time,
2436
&w_time, &size, NULL, NULL)) {
2437
printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2440
if (w_time < 60*60*24*2) {
2441
printf("write time=%s", ctime(&w_time));
2442
printf("This system appears to set a initial 0 write time\n");
2447
cli_unlink(cli, fname);
2450
/* check if the server updates the directory modification time
2451
when creating a new file */
2452
if (!cli_mkdir(cli, dname)) {
2453
printf("ERROR: mkdir failed (%s)\n", cli_errstr(cli));
2457
if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time, &a_time, &m_time,
2458
&w_time, &size, NULL, NULL)) {
2459
printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2463
fnum = cli_open(cli, fname2,
2464
O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2465
cli_write(cli, fnum, 0, (char *)&fnum, 0, sizeof(fnum));
2466
cli_close(cli, fnum);
2467
if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time, &a_time, &m_time2,
2468
&w_time, &size, NULL, NULL)) {
2469
printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2472
if (m_time2 == m_time) {
2473
printf("This system does not update directory modification times\n");
2477
cli_unlink(cli, fname2);
2478
cli_rmdir(cli, dname);
2480
if (!torture_close_connection(cli)) {
2484
printf("trans2 test finished\n");
2490
This checks new W2K calls.
2493
static BOOL new_trans(struct cli_state *pcli, int fnum, int level)
2497
BOOL correct = True;
2499
if (!cli_qfileinfo_test(pcli, fnum, level, &buf, &len)) {
2500
printf("ERROR: qfileinfo (%d) failed (%s)\n", level, cli_errstr(pcli));
2503
printf("qfileinfo: level %d, len = %u\n", level, len);
2504
dump_data(0, buf, len);
2511
static BOOL run_w2ktest(int dummy)
2513
struct cli_state *cli;
2515
const char *fname = "\\w2ktest\\w2k.tst";
2517
BOOL correct = True;
2519
printf("starting w2k test\n");
2521
if (!torture_open_connection(&cli)) {
2525
fnum = cli_open(cli, fname,
2526
O_RDWR | O_CREAT , DENY_NONE);
2528
for (level = 1004; level < 1040; level++) {
2529
new_trans(cli, fnum, level);
2532
cli_close(cli, fnum);
2534
if (!torture_close_connection(cli)) {
2538
printf("w2k test finished\n");
2545
this is a harness for some oplock tests
2547
static BOOL run_oplock1(int dummy)
2549
struct cli_state *cli1;
2550
const char *fname = "\\lockt1.lck";
2552
BOOL correct = True;
2554
printf("starting oplock test 1\n");
2556
if (!torture_open_connection(&cli1)) {
2560
cli_unlink(cli1, fname);
2562
cli_sockopt(cli1, sockops);
2564
cli1->use_oplocks = True;
2566
fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2568
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2572
cli1->use_oplocks = False;
2574
cli_unlink(cli1, fname);
2575
cli_unlink(cli1, fname);
2577
if (!cli_close(cli1, fnum1)) {
2578
printf("close2 failed (%s)\n", cli_errstr(cli1));
2582
if (!cli_unlink(cli1, fname)) {
2583
printf("unlink failed (%s)\n", cli_errstr(cli1));
2587
if (!torture_close_connection(cli1)) {
2591
printf("finished oplock test 1\n");
2596
static BOOL run_oplock2(int dummy)
2598
struct cli_state *cli1, *cli2;
2599
const char *fname = "\\lockt2.lck";
2601
int saved_use_oplocks = use_oplocks;
2603
BOOL correct = True;
2604
volatile BOOL *shared_correct;
2606
shared_correct = (volatile BOOL *)shm_setup(sizeof(BOOL));
2607
*shared_correct = True;
2609
use_level_II_oplocks = True;
2612
printf("starting oplock test 2\n");
2614
if (!torture_open_connection(&cli1)) {
2615
use_level_II_oplocks = False;
2616
use_oplocks = saved_use_oplocks;
2620
cli1->use_oplocks = True;
2621
cli1->use_level_II_oplocks = True;
2623
if (!torture_open_connection(&cli2)) {
2624
use_level_II_oplocks = False;
2625
use_oplocks = saved_use_oplocks;
2629
cli2->use_oplocks = True;
2630
cli2->use_level_II_oplocks = True;
2632
cli_unlink(cli1, fname);
2634
cli_sockopt(cli1, sockops);
2635
cli_sockopt(cli2, sockops);
2637
fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2639
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2643
/* Don't need the globals any more. */
2644
use_level_II_oplocks = False;
2645
use_oplocks = saved_use_oplocks;
2649
fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
2651
printf("second open of %s failed (%s)\n", fname, cli_errstr(cli1));
2652
*shared_correct = False;
2658
if (!cli_close(cli2, fnum2)) {
2659
printf("close2 failed (%s)\n", cli_errstr(cli1));
2660
*shared_correct = False;
2668
/* Ensure cli1 processes the break. Empty file should always return 0
2671
if (cli_read(cli1, fnum1, buf, 0, 4) != 0) {
2672
printf("read on fnum1 failed (%s)\n", cli_errstr(cli1));
2676
/* Should now be at level II. */
2677
/* Test if sending a write locks causes a break to none. */
2679
if (!cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK)) {
2680
printf("lock failed (%s)\n", cli_errstr(cli1));
2684
cli_unlock(cli1, fnum1, 0, 4);
2688
if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
2689
printf("lock failed (%s)\n", cli_errstr(cli1));
2693
cli_unlock(cli1, fnum1, 0, 4);
2697
cli_read(cli1, fnum1, buf, 0, 4);
2700
if (cli_write(cli1, fnum1, 0, buf, 0, 4) != 4) {
2701
printf("write on fnum1 failed (%s)\n", cli_errstr(cli1));
2706
if (!cli_close(cli1, fnum1)) {
2707
printf("close1 failed (%s)\n", cli_errstr(cli1));
2713
if (!cli_unlink(cli1, fname)) {
2714
printf("unlink failed (%s)\n", cli_errstr(cli1));
2718
if (!torture_close_connection(cli1)) {
2722
if (!*shared_correct) {
2726
printf("finished oplock test 2\n");
2731
/* handler for oplock 3 tests */
2732
static BOOL oplock3_handler(struct cli_state *cli, int fnum, unsigned char level)
2734
printf("got oplock break fnum=%d level=%d\n",
2736
return cli_oplock_ack(cli, fnum, level);
2739
static BOOL run_oplock3(int dummy)
2741
struct cli_state *cli;
2742
const char *fname = "\\oplockt3.dat";
2744
char buf[4] = "abcd";
2745
BOOL correct = True;
2746
volatile BOOL *shared_correct;
2748
shared_correct = (volatile BOOL *)shm_setup(sizeof(BOOL));
2749
*shared_correct = True;
2751
printf("starting oplock test 3\n");
2756
use_level_II_oplocks = True;
2757
if (!torture_open_connection(&cli)) {
2758
*shared_correct = False;
2762
/* try to trigger a oplock break in parent */
2763
fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
2764
cli_write(cli, fnum, 0, buf, 0, 4);
2770
use_level_II_oplocks = True;
2771
if (!torture_open_connection(&cli)) {
2774
cli_oplock_handler(cli, oplock3_handler);
2775
fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
2776
cli_write(cli, fnum, 0, buf, 0, 4);
2777
cli_close(cli, fnum);
2778
fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
2779
cli->timeout = 20000;
2780
cli_receive_smb(cli);
2781
printf("finished oplock test 3\n");
2783
return (correct && *shared_correct);
2785
/* What are we looking for here? What's sucess and what's FAILURE? */
2791
Test delete on close semantics.
2793
static BOOL run_deletetest(int dummy)
2795
struct cli_state *cli1 = NULL;
2796
struct cli_state *cli2 = NULL;
2797
const char *fname = "\\delete.file";
2800
BOOL correct = True;
2802
printf("starting delete test\n");
2804
if (!torture_open_connection(&cli1)) {
2808
cli_sockopt(cli1, sockops);
2810
/* Test 1 - this should delete the file on close. */
2812
cli_setatr(cli1, fname, 0, 0);
2813
cli_unlink(cli1, fname);
2815
fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
2816
0, FILE_OVERWRITE_IF,
2817
FILE_DELETE_ON_CLOSE, 0);
2820
printf("[1] open of %s failed (%s)\n", fname, cli_errstr(cli1));
2827
uint32 *accinfo = NULL;
2829
cli_qfileinfo_test(cli1, fnum1, SMB_FILE_ACCESS_INFORMATION, (char **)&accinfo, &len);
2831
printf("access mode = 0x%lx\n", *accinfo);
2836
if (!cli_close(cli1, fnum1)) {
2837
printf("[1] close failed (%s)\n", cli_errstr(cli1));
2842
fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
2844
printf("[1] open of %s succeeded (should fail)\n", fname);
2849
printf("first delete on close test succeeded.\n");
2851
/* Test 2 - this should delete the file on close. */
2853
cli_setatr(cli1, fname, 0, 0);
2854
cli_unlink(cli1, fname);
2856
fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_ALL_ACCESS,
2857
FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
2858
FILE_OVERWRITE_IF, 0, 0);
2861
printf("[2] open of %s failed (%s)\n", fname, cli_errstr(cli1));
2866
if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
2867
printf("[2] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
2872
if (!cli_close(cli1, fnum1)) {
2873
printf("[2] close failed (%s)\n", cli_errstr(cli1));
2878
fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
2880
printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
2881
if (!cli_close(cli1, fnum1)) {
2882
printf("[2] close failed (%s)\n", cli_errstr(cli1));
2886
cli_unlink(cli1, fname);
2888
printf("second delete on close test succeeded.\n");
2891
cli_setatr(cli1, fname, 0, 0);
2892
cli_unlink(cli1, fname);
2894
fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
2895
FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
2898
printf("[3] open - 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
2903
/* This should fail with a sharing violation - open for delete is only compatible
2904
with SHARE_DELETE. */
2906
fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
2907
FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0, 0);
2910
printf("[3] open - 2 of %s succeeded - should have failed.\n", fname);
2915
/* This should succeed. */
2917
fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
2918
FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0);
2921
printf("[3] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
2926
if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
2927
printf("[3] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
2932
if (!cli_close(cli1, fnum1)) {
2933
printf("[3] close 1 failed (%s)\n", cli_errstr(cli1));
2938
if (!cli_close(cli1, fnum2)) {
2939
printf("[3] close 2 failed (%s)\n", cli_errstr(cli1));
2944
/* This should fail - file should no longer be there. */
2946
fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
2948
printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
2949
if (!cli_close(cli1, fnum1)) {
2950
printf("[3] close failed (%s)\n", cli_errstr(cli1));
2952
cli_unlink(cli1, fname);
2956
printf("third delete on close test succeeded.\n");
2959
cli_setatr(cli1, fname, 0, 0);
2960
cli_unlink(cli1, fname);
2962
fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
2963
FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
2966
printf("[4] open of %s failed (%s)\n", fname, cli_errstr(cli1));
2971
/* This should succeed. */
2972
fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS,
2973
FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0);
2975
printf("[4] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
2980
if (!cli_close(cli1, fnum2)) {
2981
printf("[4] close - 1 failed (%s)\n", cli_errstr(cli1));
2986
if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
2987
printf("[4] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
2992
/* This should fail - no more opens once delete on close set. */
2993
fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS,
2994
FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
2997
printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname );
3001
printf("fourth delete on close test succeeded.\n");
3003
if (!cli_close(cli1, fnum1)) {
3004
printf("[4] close - 2 failed (%s)\n", cli_errstr(cli1));
3010
cli_setatr(cli1, fname, 0, 0);
3011
cli_unlink(cli1, fname);
3013
fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT, DENY_NONE);
3015
printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3020
/* This should fail - only allowed on NT opens with DELETE access. */
3022
if (cli_nt_delete_on_close(cli1, fnum1, True)) {
3023
printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
3028
if (!cli_close(cli1, fnum1)) {
3029
printf("[5] close - 2 failed (%s)\n", cli_errstr(cli1));
3034
printf("fifth delete on close test succeeded.\n");
3037
cli_setatr(cli1, fname, 0, 0);
3038
cli_unlink(cli1, fname);
3040
fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
3041
FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3042
FILE_OVERWRITE_IF, 0, 0);
3045
printf("[6] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3050
/* This should fail - only allowed on NT opens with DELETE access. */
3052
if (cli_nt_delete_on_close(cli1, fnum1, True)) {
3053
printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
3058
if (!cli_close(cli1, fnum1)) {
3059
printf("[6] close - 2 failed (%s)\n", cli_errstr(cli1));
3064
printf("sixth delete on close test succeeded.\n");
3067
cli_setatr(cli1, fname, 0, 0);
3068
cli_unlink(cli1, fname);
3070
fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3071
FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0);
3074
printf("[7] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3079
if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3080
printf("[7] setting delete_on_close on file failed !\n");
3085
if (!cli_nt_delete_on_close(cli1, fnum1, False)) {
3086
printf("[7] unsetting delete_on_close on file failed !\n");
3091
if (!cli_close(cli1, fnum1)) {
3092
printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3097
/* This next open should succeed - we reset the flag. */
3099
fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3101
printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3106
if (!cli_close(cli1, fnum1)) {
3107
printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3112
printf("seventh delete on close test succeeded.\n");
3115
cli_setatr(cli1, fname, 0, 0);
3116
cli_unlink(cli1, fname);
3118
if (!torture_open_connection(&cli2)) {
3119
printf("[8] failed to open second connection.\n");
3124
cli_sockopt(cli1, sockops);
3126
fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3127
FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3128
FILE_OVERWRITE_IF, 0, 0);
3131
printf("[8] open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3136
fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3137
FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3141
printf("[8] open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3146
if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3147
printf("[8] setting delete_on_close on file failed !\n");
3152
if (!cli_close(cli1, fnum1)) {
3153
printf("[8] close - 1 failed (%s)\n", cli_errstr(cli1));
3158
if (!cli_close(cli2, fnum2)) {
3159
printf("[8] close - 2 failed (%s)\n", cli_errstr(cli2));
3164
/* This should fail.. */
3165
fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3167
printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
3171
printf("eighth delete on close test succeeded.\n");
3173
/* This should fail - we need to set DELETE_ACCESS. */
3174
fnum1 = cli_nt_create_full(cli1, fname, 0,FILE_READ_DATA|FILE_WRITE_DATA,
3175
FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0);
3178
printf("[9] open of %s succeeded should have failed!\n", fname);
3183
printf("ninth delete on close test succeeded.\n");
3185
fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3186
FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0);
3188
printf("[10] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3193
/* This should delete the file. */
3194
if (!cli_close(cli1, fnum1)) {
3195
printf("[10] close failed (%s)\n", cli_errstr(cli1));
3200
/* This should fail.. */
3201
fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3203
printf("[10] open of %s succeeded should have been deleted on close !\n", fname);
3207
printf("tenth delete on close test succeeded.\n");
3209
cli_setatr(cli1, fname, 0, 0);
3210
cli_unlink(cli1, fname);
3212
/* What error do we get when attempting to open a read-only file with
3215
/* Create a readonly file. */
3216
fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
3217
FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3219
printf("[11] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3224
if (!cli_close(cli1, fnum1)) {
3225
printf("[11] close failed (%s)\n", cli_errstr(cli1));
3230
/* Now try open for delete access. */
3231
fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_ATTRIBUTES|DELETE_ACCESS,
3232
0, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3233
FILE_OVERWRITE_IF, 0, 0);
3236
printf("[11] open of %s succeeded should have been denied with ACCESS_DENIED!\n", fname);
3237
cli_close(cli1, fnum1);
3241
NTSTATUS nterr = cli_nt_error(cli1);
3242
if (!NT_STATUS_EQUAL(nterr,NT_STATUS_ACCESS_DENIED)) {
3243
printf("[11] open of %s should have been denied with ACCESS_DENIED! Got error %s\n", fname, nt_errstr(nterr));
3247
printf("eleventh delete on close test succeeded.\n");
3251
printf("finished delete test\n");
3254
/* FIXME: This will crash if we aborted before cli2 got
3255
* intialized, because these functions don't handle
3256
* uninitialized connections. */
3258
if (fnum1 != -1) cli_close(cli1, fnum1);
3259
if (fnum2 != -1) cli_close(cli1, fnum2);
3260
cli_setatr(cli1, fname, 0, 0);
3261
cli_unlink(cli1, fname);
3263
if (cli1 && !torture_close_connection(cli1)) {
3266
if (cli2 && !torture_close_connection(cli2)) {
3274
print out server properties
3276
static BOOL run_properties(int dummy)
3278
static struct cli_state *cli;
3279
BOOL correct = True;
3281
printf("starting properties test\n");
3285
if (!torture_open_connection(&cli)) {
3289
cli_sockopt(cli, sockops);
3291
d_printf("Capabilities 0x%08x\n", cli->capabilities);
3293
if (!torture_close_connection(cli)) {
3302
/* FIRST_DESIRED_ACCESS 0xf019f */
3303
#define FIRST_DESIRED_ACCESS FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\
3304
FILE_READ_EA| /* 0xf */ \
3305
FILE_WRITE_EA|FILE_READ_ATTRIBUTES| /* 0x90 */ \
3306
FILE_WRITE_ATTRIBUTES| /* 0x100 */ \
3307
DELETE_ACCESS|READ_CONTROL_ACCESS|\
3308
WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS /* 0xf0000 */
3309
/* SECOND_DESIRED_ACCESS 0xe0080 */
3310
#define SECOND_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
3311
READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
3312
WRITE_OWNER_ACCESS /* 0xe0000 */
3315
#define THIRD_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
3316
READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
3318
WRITE_OWNER_ACCESS /* */
3322
Test ntcreate calls made by xcopy
3324
static BOOL run_xcopy(int dummy)
3326
static struct cli_state *cli1;
3327
const char *fname = "\\test.txt";
3328
BOOL correct = True;
3331
printf("starting xcopy test\n");
3333
if (!torture_open_connection(&cli1)) {
3337
fnum1 = cli_nt_create_full(cli1, fname, 0,
3338
FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
3339
FILE_SHARE_NONE, FILE_OVERWRITE_IF,
3343
printf("First open failed - %s\n", cli_errstr(cli1));
3347
fnum2 = cli_nt_create_full(cli1, fname, 0,
3348
SECOND_DESIRED_ACCESS, 0,
3349
FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN,
3352
printf("second open failed - %s\n", cli_errstr(cli1));
3356
if (!torture_close_connection(cli1)) {
3364
Test rename on files open with share delete and no share delete.
3366
static BOOL run_rename(int dummy)
3368
static struct cli_state *cli1;
3369
const char *fname = "\\test.txt";
3370
const char *fname1 = "\\test1.txt";
3371
BOOL correct = True;
3374
printf("starting rename test\n");
3376
if (!torture_open_connection(&cli1)) {
3380
cli_unlink(cli1, fname);
3381
cli_unlink(cli1, fname1);
3382
fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3383
FILE_SHARE_READ, FILE_OVERWRITE_IF, 0, 0);
3386
printf("First open failed - %s\n", cli_errstr(cli1));
3390
if (!cli_rename(cli1, fname, fname1)) {
3391
printf("First rename failed (SHARE_READ) (this is correct) - %s\n", cli_errstr(cli1));
3393
printf("First rename succeeded (SHARE_READ) - this should have failed !\n");
3397
if (!cli_close(cli1, fnum1)) {
3398
printf("close - 1 failed (%s)\n", cli_errstr(cli1));
3402
cli_unlink(cli1, fname);
3403
cli_unlink(cli1, fname1);
3404
fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3406
FILE_SHARE_DELETE|FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3408
FILE_SHARE_DELETE|FILE_SHARE_READ, FILE_OVERWRITE_IF, 0, 0);
3412
printf("Second open failed - %s\n", cli_errstr(cli1));
3416
if (!cli_rename(cli1, fname, fname1)) {
3417
printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", cli_errstr(cli1));
3420
printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n");
3423
if (!cli_close(cli1, fnum1)) {
3424
printf("close - 2 failed (%s)\n", cli_errstr(cli1));
3428
cli_unlink(cli1, fname);
3429
cli_unlink(cli1, fname1);
3431
fnum1 = cli_nt_create_full(cli1, fname, 0, READ_CONTROL_ACCESS, FILE_ATTRIBUTE_NORMAL,
3432
FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3435
printf("Third open failed - %s\n", cli_errstr(cli1));
3444
fnum2 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
3445
FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3448
printf("Fourth open failed - %s\n", cli_errstr(cli1));
3451
if (!cli_nt_delete_on_close(cli1, fnum2, True)) {
3452
printf("[8] setting delete_on_close on file failed !\n");
3456
if (!cli_close(cli1, fnum2)) {
3457
printf("close - 4 failed (%s)\n", cli_errstr(cli1));
3463
if (!cli_rename(cli1, fname, fname1)) {
3464
printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", cli_errstr(cli1));
3467
printf("Third rename succeeded (SHARE_NONE)\n");
3470
if (!cli_close(cli1, fnum1)) {
3471
printf("close - 3 failed (%s)\n", cli_errstr(cli1));
3475
cli_unlink(cli1, fname);
3476
cli_unlink(cli1, fname1);
3480
fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3481
FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
3484
printf("Fourth open failed - %s\n", cli_errstr(cli1));
3488
if (!cli_rename(cli1, fname, fname1)) {
3489
printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", cli_errstr(cli1));
3491
printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n");
3495
if (!cli_close(cli1, fnum1)) {
3496
printf("close - 4 failed (%s)\n", cli_errstr(cli1));
3500
cli_unlink(cli1, fname);
3501
cli_unlink(cli1, fname1);
3505
fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3506
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0);
3509
printf("Fifth open failed - %s\n", cli_errstr(cli1));
3513
if (!cli_rename(cli1, fname, fname1)) {
3514
printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have failed ! \n");
3517
printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", cli_errstr(cli1));
3521
* Now check if the first name still exists ...
3524
/*fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3525
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0);
3528
printf("Opening original file after rename of open file fails: %s\n",
3532
printf("Opening original file after rename of open file works ...\n");
3533
(void)cli_close(cli1, fnum2);
3539
if (!cli_close(cli1, fnum1)) {
3540
printf("close - 5 failed (%s)\n", cli_errstr(cli1));
3544
cli_unlink(cli1, fname);
3545
cli_unlink(cli1, fname1);
3547
if (!torture_close_connection(cli1)) {
3554
static BOOL run_pipe_number(int dummy)
3556
struct cli_state *cli1;
3557
const char *pipe_name = "\\SPOOLSS";
3561
printf("starting pipenumber test\n");
3562
if (!torture_open_connection(&cli1)) {
3566
cli_sockopt(cli1, sockops);
3568
fnum = cli_nt_create_full(cli1, pipe_name, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
3569
FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF, 0, 0);
3572
printf("Open of pipe %s failed with error (%s)\n", pipe_name, cli_errstr(cli1));
3578
printf("pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
3579
torture_close_connection(cli1);
3584
Test open mode returns on read-only files.
3586
static BOOL run_opentest(int dummy)
3588
static struct cli_state *cli1;
3589
static struct cli_state *cli2;
3590
const char *fname = "\\readonly.file";
3594
BOOL correct = True;
3597
printf("starting open test\n");
3599
if (!torture_open_connection(&cli1)) {
3603
cli_setatr(cli1, fname, 0, 0);
3604
cli_unlink(cli1, fname);
3606
cli_sockopt(cli1, sockops);
3608
fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
3610
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3614
if (!cli_close(cli1, fnum1)) {
3615
printf("close2 failed (%s)\n", cli_errstr(cli1));
3619
if (!cli_setatr(cli1, fname, aRONLY, 0)) {
3620
printf("cli_setatr failed (%s)\n", cli_errstr(cli1));
3624
fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_WRITE);
3626
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3630
/* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
3631
fnum2 = cli_open(cli1, fname, O_RDWR, DENY_ALL);
3633
if (check_error(__LINE__, cli1, ERRDOS, ERRnoaccess,
3634
NT_STATUS_ACCESS_DENIED)) {
3635
printf("correct error code ERRDOS/ERRnoaccess returned\n");
3638
printf("finished open test 1\n");
3640
cli_close(cli1, fnum1);
3642
/* Now try not readonly and ensure ERRbadshare is returned. */
3644
cli_setatr(cli1, fname, 0, 0);
3646
fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_WRITE);
3648
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3652
/* This will fail - but the error should be ERRshare. */
3653
fnum2 = cli_open(cli1, fname, O_RDWR, DENY_ALL);
3655
if (check_error(__LINE__, cli1, ERRDOS, ERRbadshare,
3656
NT_STATUS_SHARING_VIOLATION)) {
3657
printf("correct error code ERRDOS/ERRbadshare returned\n");
3660
if (!cli_close(cli1, fnum1)) {
3661
printf("close2 failed (%s)\n", cli_errstr(cli1));
3665
cli_unlink(cli1, fname);
3667
printf("finished open test 2\n");
3669
/* Test truncate open disposition on file opened for read. */
3671
fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
3673
printf("(3) open (1) of %s failed (%s)\n", fname, cli_errstr(cli1));
3677
/* write 20 bytes. */
3679
memset(buf, '\0', 20);
3681
if (cli_write(cli1, fnum1, 0, buf, 0, 20) != 20) {
3682
printf("write failed (%s)\n", cli_errstr(cli1));
3686
if (!cli_close(cli1, fnum1)) {
3687
printf("(3) close1 failed (%s)\n", cli_errstr(cli1));
3691
/* Ensure size == 20. */
3692
if (!cli_getatr(cli1, fname, NULL, &fsize, NULL)) {
3693
printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
3698
printf("(3) file size != 20\n");
3702
/* Now test if we can truncate a file opened for readonly. */
3704
fnum1 = cli_open(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE);
3706
printf("(3) open (2) of %s failed (%s)\n", fname, cli_errstr(cli1));
3710
if (!cli_close(cli1, fnum1)) {
3711
printf("close2 failed (%s)\n", cli_errstr(cli1));
3715
/* Ensure size == 0. */
3716
if (!cli_getatr(cli1, fname, NULL, &fsize, NULL)) {
3717
printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
3722
printf("(3) file size != 0\n");
3725
printf("finished open test 3\n");
3727
cli_unlink(cli1, fname);
3730
printf("testing ctemp\n");
3731
fnum1 = cli_ctemp(cli1, "\\", &tmp_path);
3733
printf("ctemp failed (%s)\n", cli_errstr(cli1));
3736
printf("ctemp gave path %s\n", tmp_path);
3737
if (!cli_close(cli1, fnum1)) {
3738
printf("close of temp failed (%s)\n", cli_errstr(cli1));
3740
if (!cli_unlink(cli1, tmp_path)) {
3741
printf("unlink of temp failed (%s)\n", cli_errstr(cli1));
3744
/* Test the non-io opens... */
3746
if (!torture_open_connection(&cli2)) {
3750
cli_setatr(cli2, fname, 0, 0);
3751
cli_unlink(cli2, fname);
3753
cli_sockopt(cli2, sockops);
3755
printf("TEST #1 testing 2 non-io opens (no delete)\n");
3757
fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3758
FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3761
printf("test 1 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3765
fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3766
FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
3769
printf("test 1 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3773
if (!cli_close(cli1, fnum1)) {
3774
printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3777
if (!cli_close(cli2, fnum2)) {
3778
printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3782
printf("non-io open test #1 passed.\n");
3784
cli_unlink(cli1, fname);
3786
printf("TEST #2 testing 2 non-io opens (first with delete)\n");
3788
fnum1 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3789
FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3792
printf("test 2 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3796
fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3797
FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
3800
printf("test 2 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3804
if (!cli_close(cli1, fnum1)) {
3805
printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3808
if (!cli_close(cli2, fnum2)) {
3809
printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3813
printf("non-io open test #2 passed.\n");
3815
cli_unlink(cli1, fname);
3817
printf("TEST #3 testing 2 non-io opens (second with delete)\n");
3819
fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3820
FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3823
printf("test 3 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3827
fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3828
FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
3831
printf("test 3 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3835
if (!cli_close(cli1, fnum1)) {
3836
printf("test 3 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3839
if (!cli_close(cli2, fnum2)) {
3840
printf("test 3 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3844
printf("non-io open test #3 passed.\n");
3846
cli_unlink(cli1, fname);
3848
printf("TEST #4 testing 2 non-io opens (both with delete)\n");
3850
fnum1 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3851
FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3854
printf("test 4 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3858
fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3859
FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
3862
printf("test 4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
3866
printf("test 3 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
3868
if (!cli_close(cli1, fnum1)) {
3869
printf("test 4 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3873
printf("non-io open test #4 passed.\n");
3875
cli_unlink(cli1, fname);
3877
printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
3879
fnum1 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3880
FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0);
3883
printf("test 5 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3887
fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3888
FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0);
3891
printf("test 5 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3895
if (!cli_close(cli1, fnum1)) {
3896
printf("test 5 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3900
if (!cli_close(cli2, fnum2)) {
3901
printf("test 5 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3905
printf("non-io open test #5 passed.\n");
3907
printf("TEST #6 testing 1 non-io open, one io open\n");
3909
cli_unlink(cli1, fname);
3911
fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
3912
FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3915
printf("test 6 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3919
fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3920
FILE_SHARE_READ, FILE_OPEN_IF, 0, 0);
3923
printf("test 6 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3927
if (!cli_close(cli1, fnum1)) {
3928
printf("test 6 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3932
if (!cli_close(cli2, fnum2)) {
3933
printf("test 6 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3937
printf("non-io open test #6 passed.\n");
3939
printf("TEST #7 testing 1 non-io open, one io open with delete\n");
3941
cli_unlink(cli1, fname);
3943
fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
3944
FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3947
printf("test 7 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3951
fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3952
FILE_SHARE_READ|FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0);
3955
printf("test 7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
3959
printf("test 7 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
3961
if (!cli_close(cli1, fnum1)) {
3962
printf("test 7 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3966
printf("non-io open test #7 passed.\n");
3968
cli_unlink(cli1, fname);
3970
if (!torture_close_connection(cli1)) {
3973
if (!torture_close_connection(cli2)) {
3980
static uint32 open_attrs_table[] = {
3981
FILE_ATTRIBUTE_NORMAL,
3982
FILE_ATTRIBUTE_ARCHIVE,
3983
FILE_ATTRIBUTE_READONLY,
3984
FILE_ATTRIBUTE_HIDDEN,
3985
FILE_ATTRIBUTE_SYSTEM,
3987
FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY,
3988
FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN,
3989
FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,
3990
FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
3991
FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
3992
FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
3994
FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
3995
FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
3996
FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
3997
FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM,
4000
struct trunc_open_results {
4007
static struct trunc_open_results attr_results[] = {
4008
{ 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
4009
{ 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
4010
{ 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
4011
{ 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
4012
{ 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
4013
{ 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
4014
{ 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4015
{ 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4016
{ 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
4017
{ 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4018
{ 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4019
{ 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
4020
{ 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4021
{ 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4022
{ 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 },
4023
{ 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4024
{ 119, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4025
{ 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 },
4026
{ 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 },
4027
{ 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 },
4028
{ 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4029
{ 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4030
{ 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
4031
{ 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4032
{ 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4033
{ 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
4036
static BOOL run_openattrtest(int dummy)
4038
static struct cli_state *cli1;
4039
const char *fname = "\\openattr.file";
4041
BOOL correct = True;
4043
unsigned int i, j, k, l;
4045
printf("starting open attr test\n");
4047
if (!torture_open_connection(&cli1)) {
4051
cli_sockopt(cli1, sockops);
4053
for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32); i++) {
4054
cli_setatr(cli1, fname, 0, 0);
4055
cli_unlink(cli1, fname);
4056
fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_WRITE_DATA, open_attrs_table[i],
4057
FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
4060
printf("open %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
4064
if (!cli_close(cli1, fnum1)) {
4065
printf("close %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
4069
for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32); j++) {
4070
fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA, open_attrs_table[j],
4071
FILE_SHARE_NONE, FILE_OVERWRITE, 0, 0);
4074
for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
4075
if (attr_results[l].num == k) {
4076
printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
4077
k, open_attrs_table[i],
4078
open_attrs_table[j],
4079
fname, NT_STATUS_V(cli_nt_error(cli1)), cli_errstr(cli1));
4083
if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_ACCESS_DENIED)) {
4084
printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n",
4085
k, open_attrs_table[i], open_attrs_table[j],
4090
printf("[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]);
4096
if (!cli_close(cli1, fnum1)) {
4097
printf("close %d (2) of %s failed (%s)\n", j, fname, cli_errstr(cli1));
4101
if (!cli_getatr(cli1, fname, &attr, NULL, NULL)) {
4102
printf("getatr(2) failed (%s)\n", cli_errstr(cli1));
4107
printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
4108
k, open_attrs_table[i], open_attrs_table[j], attr );
4111
for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
4112
if (attr_results[l].num == k) {
4113
if (attr != attr_results[l].result_attr ||
4114
open_attrs_table[i] != attr_results[l].init_attr ||
4115
open_attrs_table[j] != attr_results[l].trunc_attr) {
4116
printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
4117
open_attrs_table[i],
4118
open_attrs_table[j],
4120
attr_results[l].result_attr);
4130
cli_setatr(cli1, fname, 0, 0);
4131
cli_unlink(cli1, fname);
4133
printf("open attr test %s.\n", correct ? "passed" : "failed");
4135
if (!torture_close_connection(cli1)) {
4141
static void list_fn(const char *mnt, file_info *finfo, const char *name, void *state)
4147
test directory listing speed
4149
static BOOL run_dirtest(int dummy)
4152
static struct cli_state *cli;
4155
BOOL correct = True;
4157
printf("starting directory test\n");
4159
if (!torture_open_connection(&cli)) {
4163
cli_sockopt(cli, sockops);
4166
for (i=0;i<torture_numops;i++) {
4168
slprintf(fname, sizeof(fname), "\\%x", (int)random());
4169
fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
4171
fprintf(stderr,"Failed to open %s\n", fname);
4174
cli_close(cli, fnum);
4179
printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
4180
printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
4181
printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
4183
printf("dirtest core %g seconds\n", end_timer() - t1);
4186
for (i=0;i<torture_numops;i++) {
4188
slprintf(fname, sizeof(fname), "\\%x", (int)random());
4189
cli_unlink(cli, fname);
4192
if (!torture_close_connection(cli)) {
4196
printf("finished dirtest\n");
4201
static void del_fn(const char *mnt, file_info *finfo, const char *mask, void *state)
4203
struct cli_state *pcli = (struct cli_state *)state;
4205
slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name);
4207
if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
4210
if (finfo->mode & aDIR) {
4211
if (!cli_rmdir(pcli, fname))
4212
printf("del_fn: failed to rmdir %s\n,", fname );
4214
if (!cli_unlink(pcli, fname))
4215
printf("del_fn: failed to unlink %s\n,", fname );
4221
sees what IOCTLs are supported
4223
BOOL torture_ioctl_test(int dummy)
4225
static struct cli_state *cli;
4226
uint16 device, function;
4228
const char *fname = "\\ioctl.dat";
4232
if (!torture_open_connection(&cli)) {
4236
printf("starting ioctl test\n");
4238
cli_unlink(cli, fname);
4240
fnum = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
4242
printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
4246
status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob);
4247
printf("ioctl device info: %s\n", cli_errstr(cli));
4249
status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob);
4250
printf("ioctl job info: %s\n", cli_errstr(cli));
4252
for (device=0;device<0x100;device++) {
4253
printf("testing device=0x%x\n", device);
4254
for (function=0;function<0x100;function++) {
4255
uint32 code = (device<<16) | function;
4257
status = cli_raw_ioctl(cli, fnum, code, &blob);
4259
if (NT_STATUS_IS_OK(status)) {
4260
printf("ioctl 0x%x OK : %d bytes\n", (int)code,
4262
data_blob_free(&blob);
4267
if (!torture_close_connection(cli)) {
4276
tries varients of chkpath
4278
BOOL torture_chkpath_test(int dummy)
4280
static struct cli_state *cli;
4284
if (!torture_open_connection(&cli)) {
4288
printf("starting chkpath test\n");
4290
/* cleanup from an old run */
4291
cli_rmdir(cli, "\\chkpath.dir\\dir2");
4292
cli_unlink(cli, "\\chkpath.dir\\*");
4293
cli_rmdir(cli, "\\chkpath.dir");
4295
if (!cli_mkdir(cli, "\\chkpath.dir")) {
4296
printf("mkdir1 failed : %s\n", cli_errstr(cli));
4300
if (!cli_mkdir(cli, "\\chkpath.dir\\dir2")) {
4301
printf("mkdir2 failed : %s\n", cli_errstr(cli));
4305
fnum = cli_open(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
4307
printf("open1 failed (%s)\n", cli_errstr(cli));
4310
cli_close(cli, fnum);
4312
if (!cli_chkpath(cli, "\\chkpath.dir")) {
4313
printf("chkpath1 failed: %s\n", cli_errstr(cli));
4317
if (!cli_chkpath(cli, "\\chkpath.dir\\dir2")) {
4318
printf("chkpath2 failed: %s\n", cli_errstr(cli));
4322
if (!cli_chkpath(cli, "\\chkpath.dir\\foo.txt")) {
4323
ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
4324
NT_STATUS_NOT_A_DIRECTORY);
4326
printf("* chkpath on a file should fail\n");
4330
if (!cli_chkpath(cli, "\\chkpath.dir\\bar.txt")) {
4331
ret = check_error(__LINE__, cli, ERRDOS, ERRbadfile,
4332
NT_STATUS_OBJECT_NAME_NOT_FOUND);
4334
printf("* chkpath on a non existant file should fail\n");
4338
if (!cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt")) {
4339
ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
4340
NT_STATUS_OBJECT_PATH_NOT_FOUND);
4342
printf("* chkpath on a non existent component should fail\n");
4346
cli_rmdir(cli, "\\chkpath.dir\\dir2");
4347
cli_unlink(cli, "\\chkpath.dir\\*");
4348
cli_rmdir(cli, "\\chkpath.dir");
4350
if (!torture_close_connection(cli)) {
4357
static BOOL run_eatest(int dummy)
4359
static struct cli_state *cli;
4360
const char *fname = "\\eatest.txt";
4361
BOOL correct = True;
4364
struct ea_struct *ea_list = NULL;
4365
TALLOC_CTX *mem_ctx = talloc_init("eatest");
4367
printf("starting eatest\n");
4369
if (!torture_open_connection(&cli)) {
4373
cli_unlink(cli, fname);
4374
fnum = cli_nt_create_full(cli, fname, 0,
4375
FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
4376
FILE_SHARE_NONE, FILE_OVERWRITE_IF,
4380
printf("open failed - %s\n", cli_errstr(cli));
4384
for (i = 0; i < 10; i++) {
4385
fstring ea_name, ea_val;
4387
slprintf(ea_name, sizeof(ea_name), "EA_%d", i);
4388
memset(ea_val, (char)i+1, i+1);
4389
if (!cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1)) {
4390
printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
4395
cli_close(cli, fnum);
4396
for (i = 0; i < 10; i++) {
4397
fstring ea_name, ea_val;
4399
slprintf(ea_name, sizeof(ea_name), "EA_%d", i+10);
4400
memset(ea_val, (char)i+1, i+1);
4401
if (!cli_set_ea_path(cli, fname, ea_name, ea_val, i+1)) {
4402
printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
4407
if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list)) {
4408
printf("ea_get list failed - %s\n", cli_errstr(cli));
4412
printf("num_eas = %d\n", (int)num_eas);
4414
if (num_eas != 20) {
4415
printf("Should be 20 EA's stored... failing.\n");
4419
for (i = 0; i < num_eas; i++) {
4420
printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
4421
dump_data(0, (char *)ea_list[i].value.data,
4422
ea_list[i].value.length);
4425
/* Setting EA's to zero length deletes them. Test this */
4426
printf("Now deleting all EA's - case indepenent....\n");
4429
cli_set_ea_path(cli, fname, "", "", 0);
4431
for (i = 0; i < 20; i++) {
4433
slprintf(ea_name, sizeof(ea_name), "ea_%d", i);
4434
if (!cli_set_ea_path(cli, fname, ea_name, "", 0)) {
4435
printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
4441
if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list)) {
4442
printf("ea_get list failed - %s\n", cli_errstr(cli));
4446
printf("num_eas = %d\n", (int)num_eas);
4447
for (i = 0; i < num_eas; i++) {
4448
printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
4449
dump_data(0, (char *)ea_list[i].value.data,
4450
ea_list[i].value.length);
4454
printf("deleting EA's failed.\n");
4458
/* Try and delete a non existant EA. */
4459
if (!cli_set_ea_path(cli, fname, "foo", "", 0)) {
4460
printf("deleting non-existant EA 'foo' should succeed. %s\n", cli_errstr(cli));
4464
talloc_destroy(mem_ctx);
4465
if (!torture_close_connection(cli)) {
4472
static BOOL run_dirtest1(int dummy)
4475
static struct cli_state *cli;
4477
BOOL correct = True;
4479
printf("starting directory test\n");
4481
if (!torture_open_connection(&cli)) {
4485
cli_sockopt(cli, sockops);
4487
cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
4488
cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
4489
cli_rmdir(cli, "\\LISTDIR");
4490
cli_mkdir(cli, "\\LISTDIR");
4492
/* Create 1000 files and 1000 directories. */
4493
for (i=0;i<1000;i++) {
4495
slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i);
4496
fnum = cli_nt_create_full(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
4497
FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
4499
fprintf(stderr,"Failed to open %s\n", fname);
4502
cli_close(cli, fnum);
4504
for (i=0;i<1000;i++) {
4506
slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i);
4507
if (!cli_mkdir(cli, fname)) {
4508
fprintf(stderr,"Failed to open %s\n", fname);
4513
/* Now ensure that doing an old list sees both files and directories. */
4514
num_seen = cli_list_old(cli, "\\LISTDIR\\*", aDIR, list_fn, NULL);
4515
printf("num_seen = %d\n", num_seen );
4516
/* We should see 100 files + 1000 directories + . and .. */
4517
if (num_seen != 2002)
4520
/* Ensure if we have the "must have" bits we only see the
4523
num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aDIR<<8)|aDIR, list_fn, NULL);
4524
printf("num_seen = %d\n", num_seen );
4525
if (num_seen != 1002)
4528
num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aARCH<<8)|aDIR, list_fn, NULL);
4529
printf("num_seen = %d\n", num_seen );
4530
if (num_seen != 1000)
4533
/* Delete everything. */
4534
cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
4535
cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
4536
cli_rmdir(cli, "\\LISTDIR");
4539
printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
4540
printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
4541
printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
4544
if (!torture_close_connection(cli)) {
4548
printf("finished dirtest1\n");
4553
static BOOL run_error_map_extract(int dummy) {
4555
static struct cli_state *c_dos;
4556
static struct cli_state *c_nt;
4560
uint32 flgs2, errnum;
4567
/* NT-Error connection */
4569
if (!(c_nt = open_nbt_connection())) {
4573
c_nt->use_spnego = False;
4575
if (!cli_negprot(c_nt)) {
4576
printf("%s rejected the NT-error negprot (%s)\n",host, cli_errstr(c_nt));
4581
if (!cli_session_setup(c_nt, "", "", 0, "", 0,
4583
printf("%s rejected the NT-error initial session setup (%s)\n",host, cli_errstr(c_nt));
4587
/* DOS-Error connection */
4589
if (!(c_dos = open_nbt_connection())) {
4593
c_dos->use_spnego = False;
4594
c_dos->force_dos_errors = True;
4596
if (!cli_negprot(c_dos)) {
4597
printf("%s rejected the DOS-error negprot (%s)\n",host, cli_errstr(c_dos));
4598
cli_shutdown(c_dos);
4602
if (!cli_session_setup(c_dos, "", "", 0, "", 0,
4604
printf("%s rejected the DOS-error initial session setup (%s)\n",host, cli_errstr(c_dos));
4608
for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) {
4609
fstr_sprintf(user, "%X", error);
4611
if (cli_session_setup(c_nt, user,
4612
password, strlen(password),
4613
password, strlen(password),
4615
printf("/** Session setup succeeded. This shouldn't happen...*/\n");
4618
flgs2 = SVAL(c_nt->inbuf,smb_flg2);
4620
/* Case #1: 32-bit NT errors */
4621
if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
4622
nt_status = NT_STATUS(IVAL(c_nt->inbuf,smb_rcls));
4624
printf("/** Dos error on NT connection! (%s) */\n",
4626
nt_status = NT_STATUS(0xc0000000);
4629
if (cli_session_setup(c_dos, user,
4630
password, strlen(password),
4631
password, strlen(password),
4633
printf("/** Session setup succeeded. This shouldn't happen...*/\n");
4635
flgs2 = SVAL(c_dos->inbuf,smb_flg2), errnum;
4637
/* Case #1: 32-bit NT errors */
4638
if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
4639
printf("/** NT error on DOS connection! (%s) */\n",
4641
errnum = errclass = 0;
4643
cli_dos_error(c_dos, &errclass, &errnum);
4646
if (NT_STATUS_V(nt_status) != error) {
4647
printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n",
4648
get_nt_error_c_code(NT_STATUS(error)),
4649
get_nt_error_c_code(nt_status));
4652
printf("\t{%s,\t%s,\t%s},\n",
4653
smb_dos_err_class(errclass),
4654
smb_dos_err_name(errclass, errnum),
4655
get_nt_error_c_code(NT_STATUS(error)));
4660
static BOOL run_local_substitute(int dummy)
4662
TALLOC_CTX *mem_ctx;
4665
if ((mem_ctx = talloc_init("run_local_subst")) == NULL) {
4666
printf("talloc_init failed\n");
4670
diff |= strcmp(talloc_sub_specified(mem_ctx, "%U", "bla", "", -1, -1),
4672
diff |= strcmp(talloc_sub_specified(mem_ctx, "%u%U", "bla", "", -1, -1),
4674
diff |= strcmp(talloc_sub_specified(mem_ctx, "%g", "", "", -1, -1),
4676
diff |= strcmp(talloc_sub_specified(mem_ctx, "%G", "", "", -1, -1),
4678
diff |= strcmp(talloc_sub_specified(mem_ctx, "%g", "", "", -1, 0),
4680
diff |= strcmp(talloc_sub_specified(mem_ctx, "%G", "", "", -1, 0),
4682
diff |= strcmp(talloc_sub_specified(mem_ctx, "%D%u", "u", "dom", -1, 0),
4684
diff |= strcmp(talloc_sub_specified(mem_ctx, "%i %I", "", "", -1, -1),
4687
/* Different captialization rules in sub_basic... */
4689
diff |= strcmp(talloc_sub_basic(mem_ctx, "BLA", "dom", "%U%D"),
4692
TALLOC_FREE(mem_ctx);
4696
static double create_procs(BOOL (*fn)(int), BOOL *result)
4699
volatile pid_t *child_status;
4700
volatile BOOL *child_status_out;
4706
child_status = (volatile pid_t *)shm_setup(sizeof(pid_t)*nprocs);
4707
if (!child_status) {
4708
printf("Failed to setup shared memory\n");
4712
child_status_out = (volatile BOOL *)shm_setup(sizeof(BOOL)*nprocs);
4713
if (!child_status_out) {
4714
printf("Failed to setup result status shared memory\n");
4718
for (i = 0; i < nprocs; i++) {
4719
child_status[i] = 0;
4720
child_status_out[i] = True;
4725
for (i=0;i<nprocs;i++) {
4728
pid_t mypid = getpid();
4729
sys_srandom(((int)mypid) ^ ((int)time(NULL)));
4731
slprintf(myname,sizeof(myname),"CLIENT%d", i);
4734
if (torture_open_connection(¤t_cli)) break;
4736
printf("pid %d failed to start\n", (int)getpid());
4742
child_status[i] = getpid();
4744
while (child_status[i] && end_timer() < 5) smb_msleep(2);
4746
child_status_out[i] = fn(i);
4753
for (i=0;i<nprocs;i++) {
4754
if (child_status[i]) synccount++;
4756
if (synccount == nprocs) break;
4758
} while (end_timer() < 30);
4760
if (synccount != nprocs) {
4761
printf("FAILED TO START %d CLIENTS (started %d)\n", nprocs, synccount);
4766
/* start the client load */
4769
for (i=0;i<nprocs;i++) {
4770
child_status[i] = 0;
4773
printf("%d clients started\n", nprocs);
4775
for (i=0;i<nprocs;i++) {
4776
while (waitpid(0, &status, 0) == -1 && errno == EINTR) /* noop */ ;
4781
for (i=0;i<nprocs;i++) {
4782
if (!child_status_out[i]) {
4789
#define FLAG_MULTIPROC 1
4796
{"FDPASS", run_fdpasstest, 0},
4797
{"LOCK1", run_locktest1, 0},
4798
{"LOCK2", run_locktest2, 0},
4799
{"LOCK3", run_locktest3, 0},
4800
{"LOCK4", run_locktest4, 0},
4801
{"LOCK5", run_locktest5, 0},
4802
{"LOCK6", run_locktest6, 0},
4803
{"LOCK7", run_locktest7, 0},
4804
{"UNLINK", run_unlinktest, 0},
4805
{"BROWSE", run_browsetest, 0},
4806
{"ATTR", run_attrtest, 0},
4807
{"TRANS2", run_trans2test, 0},
4808
{"MAXFID", run_maxfidtest, FLAG_MULTIPROC},
4809
{"TORTURE",run_torture, FLAG_MULTIPROC},
4810
{"RANDOMIPC", run_randomipc, 0},
4811
{"NEGNOWAIT", run_negprot_nowait, 0},
4812
{"NBENCH", run_nbench, 0},
4813
{"OPLOCK1", run_oplock1, 0},
4814
{"OPLOCK2", run_oplock2, 0},
4815
{"OPLOCK3", run_oplock3, 0},
4816
{"DIR", run_dirtest, 0},
4817
{"DIR1", run_dirtest1, 0},
4818
{"DENY1", torture_denytest1, 0},
4819
{"DENY2", torture_denytest2, 0},
4820
{"TCON", run_tcon_test, 0},
4821
{"TCONDEV", run_tcon_devtype_test, 0},
4822
{"RW1", run_readwritetest, 0},
4823
{"RW2", run_readwritemulti, FLAG_MULTIPROC},
4824
{"RW3", run_readwritelarge, 0},
4825
{"OPEN", run_opentest, 0},
4827
{"OPENATTR", run_openattrtest, 0},
4829
{"XCOPY", run_xcopy, 0},
4830
{"RENAME", run_rename, 0},
4831
{"DELETE", run_deletetest, 0},
4832
{"PROPERTIES", run_properties, 0},
4833
{"MANGLE", torture_mangle, 0},
4834
{"W2K", run_w2ktest, 0},
4835
{"TRANS2SCAN", torture_trans2_scan, 0},
4836
{"NTTRANSSCAN", torture_nttrans_scan, 0},
4837
{"UTABLE", torture_utable, 0},
4838
{"CASETABLE", torture_casetable, 0},
4839
{"ERRMAPEXTRACT", run_error_map_extract, 0},
4840
{"PIPE_NUMBER", run_pipe_number, 0},
4841
{"TCON2", run_tcon2_test, 0},
4842
{"IOCTL", torture_ioctl_test, 0},
4843
{"CHKPATH", torture_chkpath_test, 0},
4844
{"FDSESS", run_fdsesstest, 0},
4845
{ "EATEST", run_eatest, 0},
4846
{ "LOCAL-SUBSTITUTE", run_local_substitute, 0},
4851
/****************************************************************************
4852
run a specified test or "ALL"
4853
****************************************************************************/
4854
static BOOL run_test(const char *name)
4861
if (strequal(name,"ALL")) {
4862
for (i=0;torture_ops[i].name;i++) {
4863
run_test(torture_ops[i].name);
4868
for (i=0;torture_ops[i].name;i++) {
4869
fstr_sprintf(randomfname, "\\XX%x",
4870
(unsigned)random());
4872
if (strequal(name, torture_ops[i].name)) {
4874
printf("Running %s\n", name);
4875
if (torture_ops[i].flags & FLAG_MULTIPROC) {
4876
t = create_procs(torture_ops[i].fn, &result);
4879
printf("TEST %s FAILED!\n", name);
4884
if (!torture_ops[i].fn(0)) {
4886
printf("TEST %s FAILED!\n", name);
4890
printf("%s took %g secs\n\n", name, t);
4895
printf("Did not find a test named %s\n", name);
4903
static void usage(void)
4907
printf("WARNING samba4 test suite is much more complete nowadays.\n");
4908
printf("Please use samba4 torture.\n\n");
4910
printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
4912
printf("\t-d debuglevel\n");
4913
printf("\t-U user%%pass\n");
4914
printf("\t-k use kerberos\n");
4915
printf("\t-N numprocs\n");
4916
printf("\t-n my_netbios_name\n");
4917
printf("\t-W workgroup\n");
4918
printf("\t-o num_operations\n");
4919
printf("\t-O socket_options\n");
4920
printf("\t-m maximum protocol\n");
4921
printf("\t-L use oplocks\n");
4922
printf("\t-c CLIENT.TXT specify client load file for NBENCH\n");
4923
printf("\t-A showall\n");
4924
printf("\t-p port\n");
4925
printf("\t-s seed\n");
4928
printf("tests are:");
4929
for (i=0;torture_ops[i].name;i++) {
4930
printf(" %s", torture_ops[i].name);
4934
printf("default test is ALL\n");
4939
/****************************************************************************
4941
****************************************************************************/
4942
int main(int argc,char *argv[])
4948
BOOL correct = True;
4952
#ifdef HAVE_SETBUFFER
4953
setbuffer(stdout, NULL, 0);
4958
lp_load(dyn_CONFIGFILE,True,False,False,True);
4965
for(p = argv[1]; *p; p++)
4969
if (strncmp(argv[1], "//", 2)) {
4973
fstrcpy(host, &argv[1][2]);
4974
p = strchr_m(&host[2],'/');
4979
fstrcpy(share, p+1);
4983
if (*username == 0 && getenv("LOGNAME")) {
4984
fstrcpy(username,getenv("LOGNAME"));
4990
srandom(time(NULL));
4992
fstrcpy(workgroup, lp_workgroup());
4994
while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ld:Ac:ks:")) != EOF) {
4997
port_to_use = atoi(optarg);
5000
srandom(atoi(optarg));
5003
fstrcpy(workgroup,optarg);
5006
max_protocol = interpret_protocol(optarg, max_protocol);
5009
nprocs = atoi(optarg);
5012
torture_numops = atoi(optarg);
5015
DEBUGLEVEL = atoi(optarg);
5024
torture_showall = True;
5027
fstrcpy(myname, optarg);
5030
client_txt = optarg;
5034
use_kerberos = True;
5036
d_printf("No kerberos support compiled in\n");
5042
fstrcpy(username,optarg);
5043
p = strchr_m(username,'%');
5046
fstrcpy(password, p+1);
5051
printf("Unknown option %c (%d)\n", (char)opt, opt);
5056
if(use_kerberos && !gotuser) gotpass = True;
5059
p = getpass("Password:");
5061
fstrcpy(password, p);
5066
printf("host=%s share=%s user=%s myname=%s\n",
5067
host, share, username, myname);
5069
if (argc == optind) {
5070
correct = run_test("ALL");
5072
for (i=optind;i<argc;i++) {
5073
if (!run_test(argv[i])) {
added
removed
source/torture/torture.c
