s3: Fix an uninitialized variable warning
[nivanova/samba-autobuild/.git] / source3 / torture / torture.c
1 /* 
2    Unix SMB/CIFS implementation.
3    SMB torture tester
4    Copyright (C) Andrew Tridgell 1997-1998
5    Copyright (C) Jeremy Allison 2009
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "nsswitch/libwbclient/wbc_async.h"
23 #include "torture/proto.h"
24
25 extern char *optarg;
26 extern int optind;
27
28 static fstring host, workgroup, share, password, username, myname;
29 static int max_protocol = PROTOCOL_NT1;
30 static const char *sockops="TCP_NODELAY";
31 static int nprocs=1;
32 static int port_to_use=0;
33 int torture_numops=100;
34 int torture_blocksize=1024*1024;
35 static int procnum; /* records process count number when forking */
36 static struct cli_state *current_cli;
37 static fstring randomfname;
38 static bool use_oplocks;
39 static bool use_level_II_oplocks;
40 static const char *client_txt = "client_oplocks.txt";
41 static bool use_kerberos;
42 static fstring multishare_conn_fname;
43 static bool use_multishare_conn = False;
44 static bool do_encrypt;
45 static const char *local_path = NULL;
46
47 bool torture_showall = False;
48
49 static double create_procs(bool (*fn)(int), bool *result);
50
51
52 /* return a pointer to a anonymous shared memory segment of size "size"
53    which will persist across fork() but will disappear when all processes
54    exit 
55
56    The memory is not zeroed 
57
58    This function uses system5 shared memory. It takes advantage of a property
59    that the memory is not destroyed if it is attached when the id is removed
60    */
61 void *shm_setup(int size)
62 {
63         int shmid;
64         void *ret;
65
66 #ifdef __QNXNTO__
67         shmid = shm_open("private", O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
68         if (shmid == -1) {
69                 printf("can't get shared memory\n");
70                 exit(1);
71         }
72         shm_unlink("private");
73         if (ftruncate(shmid, size) == -1) {
74                 printf("can't set shared memory size\n");
75                 exit(1);
76         }
77         ret = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, shmid, 0);
78         if (ret == MAP_FAILED) {
79                 printf("can't map shared memory\n");
80                 exit(1);
81         }
82 #else
83         shmid = shmget(IPC_PRIVATE, size, S_IRUSR | S_IWUSR);
84         if (shmid == -1) {
85                 printf("can't get shared memory\n");
86                 exit(1);
87         }
88         ret = (void *)shmat(shmid, 0, 0);
89         if (!ret || ret == (void *)-1) {
90                 printf("can't attach to shared memory\n");
91                 return NULL;
92         }
93         /* the following releases the ipc, but note that this process
94            and all its children will still have access to the memory, its
95            just that the shmid is no longer valid for other shm calls. This
96            means we don't leave behind lots of shm segments after we exit 
97
98            See Stevens "advanced programming in unix env" for details
99            */
100         shmctl(shmid, IPC_RMID, 0);
101 #endif
102
103         return ret;
104 }
105
106 /********************************************************************
107  Ensure a connection is encrypted.
108 ********************************************************************/
109
110 static bool force_cli_encryption(struct cli_state *c,
111                         const char *sharename)
112 {
113         uint16 major, minor;
114         uint32 caplow, caphigh;
115         NTSTATUS status;
116
117         if (!SERVER_HAS_UNIX_CIFS(c)) {
118                 d_printf("Encryption required and "
119                         "server that doesn't support "
120                         "UNIX extensions - failing connect\n");
121                         return false;
122         }
123
124         status = cli_unix_extensions_version(c, &major, &minor, &caplow,
125                                              &caphigh);
126         if (!NT_STATUS_IS_OK(status)) {
127                 d_printf("Encryption required and "
128                         "can't get UNIX CIFS extensions "
129                         "version from server: %s\n", nt_errstr(status));
130                 return false;
131         }
132
133         if (!(caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)) {
134                 d_printf("Encryption required and "
135                         "share %s doesn't support "
136                         "encryption.\n", sharename);
137                 return false;
138         }
139
140         if (c->use_kerberos) {
141                 status = cli_gss_smb_encryption_start(c);
142         } else {
143                 status = cli_raw_ntlm_smb_encryption_start(c,
144                                                 username,
145                                                 password,
146                                                 workgroup);
147         }
148
149         if (!NT_STATUS_IS_OK(status)) {
150                 d_printf("Encryption required and "
151                         "setup failed with error %s.\n",
152                         nt_errstr(status));
153                 return false;
154         }
155
156         return true;
157 }
158
159
160 static struct cli_state *open_nbt_connection(void)
161 {
162         struct nmb_name called, calling;
163         struct sockaddr_storage ss;
164         struct cli_state *c;
165         NTSTATUS status;
166
167         make_nmb_name(&calling, myname, 0x0);
168         make_nmb_name(&called , host, 0x20);
169
170         zero_sockaddr(&ss);
171
172         if (!(c = cli_initialise())) {
173                 printf("Failed initialize cli_struct to connect with %s\n", host);
174                 return NULL;
175         }
176
177         c->port = port_to_use;
178
179         status = cli_connect(c, host, &ss);
180         if (!NT_STATUS_IS_OK(status)) {
181                 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
182                 return NULL;
183         }
184
185         c->use_kerberos = use_kerberos;
186
187         c->timeout = 120000; /* set a really long timeout (2 minutes) */
188         if (use_oplocks) c->use_oplocks = True;
189         if (use_level_II_oplocks) c->use_level_II_oplocks = True;
190
191         if (!cli_session_request(c, &calling, &called)) {
192                 /*
193                  * Well, that failed, try *SMBSERVER ...
194                  * However, we must reconnect as well ...
195                  */
196                 status = cli_connect(c, host, &ss);
197                 if (!NT_STATUS_IS_OK(status)) {
198                         printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
199                         return NULL;
200                 }
201
202                 make_nmb_name(&called, "*SMBSERVER", 0x20);
203                 if (!cli_session_request(c, &calling, &called)) {
204                         printf("%s rejected the session\n",host);
205                         printf("We tried with a called name of %s & %s\n",
206                                 host, "*SMBSERVER");
207                         cli_shutdown(c);
208                         return NULL;
209                 }
210         }
211
212         return c;
213 }
214
215 /* Insert a NULL at the first separator of the given path and return a pointer
216  * to the remainder of the string.
217  */
218 static char *
219 terminate_path_at_separator(char * path)
220 {
221         char * p;
222
223         if (!path) {
224                 return NULL;
225         }
226
227         if ((p = strchr_m(path, '/'))) {
228                 *p = '\0';
229                 return p + 1;
230         }
231
232         if ((p = strchr_m(path, '\\'))) {
233                 *p = '\0';
234                 return p + 1;
235         }
236
237         /* No separator. */
238         return NULL;
239 }
240
241 /*
242   parse a //server/share type UNC name
243 */
244 bool smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
245                       char **hostname, char **sharename)
246 {
247         char *p;
248
249         *hostname = *sharename = NULL;
250
251         if (strncmp(unc_name, "\\\\", 2) &&
252             strncmp(unc_name, "//", 2)) {
253                 return False;
254         }
255
256         *hostname = talloc_strdup(mem_ctx, &unc_name[2]);
257         p = terminate_path_at_separator(*hostname);
258
259         if (p && *p) {
260                 *sharename = talloc_strdup(mem_ctx, p);
261                 terminate_path_at_separator(*sharename);
262         }
263
264         if (*hostname && *sharename) {
265                 return True;
266         }
267
268         TALLOC_FREE(*hostname);
269         TALLOC_FREE(*sharename);
270         return False;
271 }
272
273 static bool torture_open_connection_share(struct cli_state **c,
274                                    const char *hostname, 
275                                    const char *sharename)
276 {
277         bool retry;
278         int flags = 0;
279         NTSTATUS status;
280
281         if (use_kerberos)
282                 flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
283         if (use_oplocks)
284                 flags |= CLI_FULL_CONNECTION_OPLOCKS;
285         if (use_level_II_oplocks)
286                 flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS;
287
288         status = cli_full_connection(c, myname,
289                                      hostname, NULL, port_to_use, 
290                                      sharename, "?????", 
291                                      username, workgroup, 
292                                      password, flags, Undefined, &retry);
293         if (!NT_STATUS_IS_OK(status)) {
294                 printf("failed to open share connection: //%s/%s port:%d - %s\n",
295                         hostname, sharename, port_to_use, nt_errstr(status));
296                 return False;
297         }
298
299         (*c)->timeout = 120000; /* set a really long timeout (2 minutes) */
300
301         if (do_encrypt) {
302                 return force_cli_encryption(*c,
303                                         sharename);
304         }
305         return True;
306 }
307
308 bool torture_open_connection(struct cli_state **c, int conn_index)
309 {
310         char **unc_list = NULL;
311         int num_unc_names = 0;
312         bool result;
313
314         if (use_multishare_conn==True) {
315                 char *h, *s;
316                 unc_list = file_lines_load(multishare_conn_fname, &num_unc_names, 0, NULL);
317                 if (!unc_list || num_unc_names <= 0) {
318                         printf("Failed to load unc names list from '%s'\n", multishare_conn_fname);
319                         exit(1);
320                 }
321
322                 if (!smbcli_parse_unc(unc_list[conn_index % num_unc_names],
323                                       NULL, &h, &s)) {
324                         printf("Failed to parse UNC name %s\n",
325                                unc_list[conn_index % num_unc_names]);
326                         TALLOC_FREE(unc_list);
327                         exit(1);
328                 }
329
330                 result = torture_open_connection_share(c, h, s);
331
332                 /* h, s were copied earlier */
333                 TALLOC_FREE(unc_list);
334                 return result;
335         }
336
337         return torture_open_connection_share(c, host, share);
338 }
339
340 bool torture_cli_session_setup2(struct cli_state *cli, uint16 *new_vuid)
341 {
342         uint16 old_vuid = cli->vuid;
343         fstring old_user_name;
344         size_t passlen = strlen(password);
345         NTSTATUS status;
346         bool ret;
347
348         fstrcpy(old_user_name, cli->user_name);
349         cli->vuid = 0;
350         ret = NT_STATUS_IS_OK(cli_session_setup(cli, username,
351                                                 password, passlen,
352                                                 password, passlen,
353                                                 workgroup));
354         *new_vuid = cli->vuid;
355         cli->vuid = old_vuid;
356         status = cli_set_username(cli, old_user_name);
357         if (!NT_STATUS_IS_OK(status)) {
358                 return false;
359         }
360         return ret;
361 }
362
363
364 bool torture_close_connection(struct cli_state *c)
365 {
366         bool ret = True;
367         NTSTATUS status;
368
369         status = cli_tdis(c);
370         if (!NT_STATUS_IS_OK(status)) {
371                 printf("tdis failed (%s)\n", nt_errstr(status));
372                 ret = False;
373         }
374
375         cli_shutdown(c);
376
377         return ret;
378 }
379
380
381 /* check if the server produced the expected error code */
382 static bool check_error(int line, struct cli_state *c, 
383                         uint8 eclass, uint32 ecode, NTSTATUS nterr)
384 {
385         if (cli_is_dos_error(c)) {
386                 uint8 cclass;
387                 uint32 num;
388
389                 /* Check DOS error */
390
391                 cli_dos_error(c, &cclass, &num);
392
393                 if (eclass != cclass || ecode != num) {
394                         printf("unexpected error code class=%d code=%d\n", 
395                                (int)cclass, (int)num);
396                         printf(" expected %d/%d %s (line=%d)\n", 
397                                (int)eclass, (int)ecode, nt_errstr(nterr), line);
398                         return False;
399                 }
400
401         } else {
402                 NTSTATUS status;
403
404                 /* Check NT error */
405
406                 status = cli_nt_error(c);
407
408                 if (NT_STATUS_V(nterr) != NT_STATUS_V(status)) {
409                         printf("unexpected error code %s\n", nt_errstr(status));
410                         printf(" expected %s (line=%d)\n", nt_errstr(nterr), line);
411                         return False;
412                 }
413         }
414
415         return True;
416 }
417
418
419 static bool wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len)
420 {
421         while (!cli_lock(c, fnum, offset, len, -1, WRITE_LOCK)) {
422                 if (!check_error(__LINE__, c, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
423         }
424         return True;
425 }
426
427
428 static bool rw_torture(struct cli_state *c)
429 {
430         const char *lockfname = "\\torture.lck";
431         fstring fname;
432         uint16_t fnum;
433         uint16_t fnum2;
434         pid_t pid2, pid = getpid();
435         int i, j;
436         char buf[1024];
437         bool correct = True;
438         NTSTATUS status;
439
440         memset(buf, '\0', sizeof(buf));
441
442         status = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL, 
443                          DENY_NONE, &fnum2);
444         if (!NT_STATUS_IS_OK(status)) {
445                 status = cli_open(c, lockfname, O_RDWR, DENY_NONE, &fnum2);
446         }
447         if (!NT_STATUS_IS_OK(status)) {
448                 printf("open of %s failed (%s)\n", lockfname, cli_errstr(c));
449                 return False;
450         }
451
452         for (i=0;i<torture_numops;i++) {
453                 unsigned n = (unsigned)sys_random()%10;
454                 if (i % 10 == 0) {
455                         printf("%d\r", i); fflush(stdout);
456                 }
457                 slprintf(fname, sizeof(fstring) - 1, "\\torture.%u", n);
458
459                 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
460                         return False;
461                 }
462
463                 if (!NT_STATUS_IS_OK(cli_open(c, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL, &fnum))) {
464                         printf("open failed (%s)\n", cli_errstr(c));
465                         correct = False;
466                         break;
467                 }
468
469                 if (cli_write(c, fnum, 0, (char *)&pid, 0, sizeof(pid)) != sizeof(pid)) {
470                         printf("write failed (%s)\n", cli_errstr(c));
471                         correct = False;
472                 }
473
474                 for (j=0;j<50;j++) {
475                         if (cli_write(c, fnum, 0, (char *)buf, 
476                                       sizeof(pid)+(j*sizeof(buf)), 
477                                       sizeof(buf)) != sizeof(buf)) {
478                                 printf("write failed (%s)\n", cli_errstr(c));
479                                 correct = False;
480                         }
481                 }
482
483                 pid2 = 0;
484
485                 if (cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid)) != sizeof(pid)) {
486                         printf("read failed (%s)\n", cli_errstr(c));
487                         correct = False;
488                 }
489
490                 if (pid2 != pid) {
491                         printf("data corruption!\n");
492                         correct = False;
493                 }
494
495                 if (!NT_STATUS_IS_OK(cli_close(c, fnum))) {
496                         printf("close failed (%s)\n", cli_errstr(c));
497                         correct = False;
498                 }
499
500                 if (!NT_STATUS_IS_OK(cli_unlink(c, fname, aSYSTEM | aHIDDEN))) {
501                         printf("unlink failed (%s)\n", cli_errstr(c));
502                         correct = False;
503                 }
504
505                 if (!NT_STATUS_IS_OK(cli_unlock(c, fnum2, n*sizeof(int), sizeof(int)))) {
506                         printf("unlock failed (%s)\n", cli_errstr(c));
507                         correct = False;
508                 }
509         }
510
511         cli_close(c, fnum2);
512         cli_unlink(c, lockfname, aSYSTEM | aHIDDEN);
513
514         printf("%d\n", i);
515
516         return correct;
517 }
518
519 static bool run_torture(int dummy)
520 {
521         struct cli_state *cli;
522         bool ret;
523
524         cli = current_cli;
525
526         cli_sockopt(cli, sockops);
527
528         ret = rw_torture(cli);
529
530         if (!torture_close_connection(cli)) {
531                 ret = False;
532         }
533
534         return ret;
535 }
536
537 static bool rw_torture3(struct cli_state *c, char *lockfname)
538 {
539         uint16_t fnum = (uint16_t)-1;
540         unsigned int i = 0;
541         char buf[131072];
542         char buf_rd[131072];
543         unsigned count;
544         unsigned countprev = 0;
545         ssize_t sent = 0;
546         bool correct = True;
547         NTSTATUS status;
548
549         srandom(1);
550         for (i = 0; i < sizeof(buf); i += sizeof(uint32))
551         {
552                 SIVAL(buf, i, sys_random());
553         }
554
555         if (procnum == 0)
556         {
557                 if (!NT_STATUS_IS_OK(cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL, 
558                                  DENY_NONE, &fnum))) {
559                         printf("first open read/write of %s failed (%s)\n",
560                                         lockfname, cli_errstr(c));
561                         return False;
562                 }
563         }
564         else
565         {
566                 for (i = 0; i < 500 && fnum == (uint16_t)-1; i++)
567                 {
568                         status = cli_open(c, lockfname, O_RDONLY, 
569                                          DENY_NONE, &fnum);
570                         if (!NT_STATUS_IS_OK(status)) {
571                                 break;
572                         }
573                         smb_msleep(10);
574                 }
575                 if (!NT_STATUS_IS_OK(status)) {
576                         printf("second open read-only of %s failed (%s)\n",
577                                         lockfname, cli_errstr(c));
578                         return False;
579                 }
580         }
581
582         i = 0;
583         for (count = 0; count < sizeof(buf); count += sent)
584         {
585                 if (count >= countprev) {
586                         printf("%d %8d\r", i, count);
587                         fflush(stdout);
588                         i++;
589                         countprev += (sizeof(buf) / 20);
590                 }
591
592                 if (procnum == 0)
593                 {
594                         sent = ((unsigned)sys_random()%(20))+ 1;
595                         if (sent > sizeof(buf) - count)
596                         {
597                                 sent = sizeof(buf) - count;
598                         }
599
600                         if (cli_write(c, fnum, 0, buf+count, count, (size_t)sent) != sent) {
601                                 printf("write failed (%s)\n", cli_errstr(c));
602                                 correct = False;
603                         }
604                 }
605                 else
606                 {
607                         sent = cli_read(c, fnum, buf_rd+count, count,
608                                                   sizeof(buf)-count);
609                         if (sent < 0)
610                         {
611                                 printf("read failed offset:%d size:%ld (%s)\n",
612                                        count, (unsigned long)sizeof(buf)-count,
613                                        cli_errstr(c));
614                                 correct = False;
615                                 sent = 0;
616                         }
617                         if (sent > 0)
618                         {
619                                 if (memcmp(buf_rd+count, buf+count, sent) != 0)
620                                 {
621                                         printf("read/write compare failed\n");
622                                         printf("offset: %d req %ld recvd %ld\n", count, (unsigned long)sizeof(buf)-count, (unsigned long)sent);
623                                         correct = False;
624                                         break;
625                                 }
626                         }
627                 }
628
629         }
630
631         if (!NT_STATUS_IS_OK(cli_close(c, fnum))) {
632                 printf("close failed (%s)\n", cli_errstr(c));
633                 correct = False;
634         }
635
636         return correct;
637 }
638
639 static bool rw_torture2(struct cli_state *c1, struct cli_state *c2)
640 {
641         const char *lockfname = "\\torture2.lck";
642         uint16_t fnum1;
643         uint16_t fnum2;
644         int i;
645         char buf[131072];
646         char buf_rd[131072];
647         bool correct = True;
648         ssize_t bytes_read;
649
650         if (!NT_STATUS_IS_OK(cli_unlink(c1, lockfname, aSYSTEM | aHIDDEN))) {
651                 printf("unlink failed (%s) (normal, this file should not exist)\n", cli_errstr(c1));
652         }
653
654         if (!NT_STATUS_IS_OK(cli_open(c1, lockfname, O_RDWR | O_CREAT | O_EXCL, 
655                          DENY_NONE, &fnum1))) {
656                 printf("first open read/write of %s failed (%s)\n",
657                                 lockfname, cli_errstr(c1));
658                 return False;
659         }
660         if (!NT_STATUS_IS_OK(cli_open(c2, lockfname, O_RDONLY, 
661                          DENY_NONE, &fnum2))) {
662                 printf("second open read-only of %s failed (%s)\n",
663                                 lockfname, cli_errstr(c2));
664                 cli_close(c1, fnum1);
665                 return False;
666         }
667
668         for (i=0;i<torture_numops;i++)
669         {
670                 size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
671                 if (i % 10 == 0) {
672                         printf("%d\r", i); fflush(stdout);
673                 }
674
675                 generate_random_buffer((unsigned char *)buf, buf_size);
676
677                 if (cli_write(c1, fnum1, 0, buf, 0, buf_size) != buf_size) {
678                         printf("write failed (%s)\n", cli_errstr(c1));
679                         correct = False;
680                         break;
681                 }
682
683                 if ((bytes_read = cli_read(c2, fnum2, buf_rd, 0, buf_size)) != buf_size) {
684                         printf("read failed (%s)\n", cli_errstr(c2));
685                         printf("read %d, expected %ld\n", (int)bytes_read, 
686                                (unsigned long)buf_size); 
687                         correct = False;
688                         break;
689                 }
690
691                 if (memcmp(buf_rd, buf, buf_size) != 0)
692                 {
693                         printf("read/write compare failed\n");
694                         correct = False;
695                         break;
696                 }
697         }
698
699         if (!NT_STATUS_IS_OK(cli_close(c2, fnum2))) {
700                 printf("close failed (%s)\n", cli_errstr(c2));
701                 correct = False;
702         }
703         if (!NT_STATUS_IS_OK(cli_close(c1, fnum1))) {
704                 printf("close failed (%s)\n", cli_errstr(c1));
705                 correct = False;
706         }
707
708         if (!NT_STATUS_IS_OK(cli_unlink(c1, lockfname, aSYSTEM | aHIDDEN))) {
709                 printf("unlink failed (%s)\n", cli_errstr(c1));
710                 correct = False;
711         }
712
713         return correct;
714 }
715
716 static bool run_readwritetest(int dummy)
717 {
718         struct cli_state *cli1, *cli2;
719         bool test1, test2 = False;
720
721         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
722                 return False;
723         }
724         cli_sockopt(cli1, sockops);
725         cli_sockopt(cli2, sockops);
726
727         printf("starting readwritetest\n");
728
729         test1 = rw_torture2(cli1, cli2);
730         printf("Passed readwritetest v1: %s\n", BOOLSTR(test1));
731
732         if (test1) {
733                 test2 = rw_torture2(cli1, cli1);
734                 printf("Passed readwritetest v2: %s\n", BOOLSTR(test2));
735         }
736
737         if (!torture_close_connection(cli1)) {
738                 test1 = False;
739         }
740
741         if (!torture_close_connection(cli2)) {
742                 test2 = False;
743         }
744
745         return (test1 && test2);
746 }
747
748 static bool run_readwritemulti(int dummy)
749 {
750         struct cli_state *cli;
751         bool test;
752
753         cli = current_cli;
754
755         cli_sockopt(cli, sockops);
756
757         printf("run_readwritemulti: fname %s\n", randomfname);
758         test = rw_torture3(cli, randomfname);
759
760         if (!torture_close_connection(cli)) {
761                 test = False;
762         }
763
764         return test;
765 }
766
767 static bool run_readwritelarge(int dummy)
768 {
769         static struct cli_state *cli1;
770         uint16_t fnum1;
771         const char *lockfname = "\\large.dat";
772         SMB_OFF_T fsize;
773         char buf[126*1024];
774         bool correct = True;
775
776         if (!torture_open_connection(&cli1, 0)) {
777                 return False;
778         }
779         cli_sockopt(cli1, sockops);
780         memset(buf,'\0',sizeof(buf));
781
782         cli1->max_xmit = 128*1024;
783
784         printf("starting readwritelarge\n");
785
786         cli_unlink(cli1, lockfname, aSYSTEM | aHIDDEN);
787
788         if (!NT_STATUS_IS_OK(cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE, &fnum1))) {
789                 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
790                 return False;
791         }
792
793         cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf));
794
795         if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
796                 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
797                 correct = False;
798         }
799
800         if (fsize == sizeof(buf))
801                 printf("readwritelarge test 1 succeeded (size = %lx)\n", 
802                        (unsigned long)fsize);
803         else {
804                 printf("readwritelarge test 1 failed (size = %lx)\n", 
805                        (unsigned long)fsize);
806                 correct = False;
807         }
808
809         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
810                 printf("close failed (%s)\n", cli_errstr(cli1));
811                 correct = False;
812         }
813
814         if (!NT_STATUS_IS_OK(cli_unlink(cli1, lockfname, aSYSTEM | aHIDDEN))) {
815                 printf("unlink failed (%s)\n", cli_errstr(cli1));
816                 correct = False;
817         }
818
819         if (!NT_STATUS_IS_OK(cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE, &fnum1))) {
820                 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
821                 return False;
822         }
823
824         cli1->max_xmit = 4*1024;
825
826         cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf));
827
828         if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
829                 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
830                 correct = False;
831         }
832
833         if (fsize == sizeof(buf))
834                 printf("readwritelarge test 2 succeeded (size = %lx)\n", 
835                        (unsigned long)fsize);
836         else {
837                 printf("readwritelarge test 2 failed (size = %lx)\n", 
838                        (unsigned long)fsize);
839                 correct = False;
840         }
841
842 #if 0
843         /* ToDo - set allocation. JRA */
844         if(!cli_set_allocation_size(cli1, fnum1, 0)) {
845                 printf("set allocation size to zero failed (%s)\n", cli_errstr(&cli1));
846                 return False;
847         }
848         if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
849                 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
850                 correct = False;
851         }
852         if (fsize != 0)
853                 printf("readwritelarge test 3 (truncate test) succeeded (size = %x)\n", fsize);
854 #endif
855
856         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
857                 printf("close failed (%s)\n", cli_errstr(cli1));
858                 correct = False;
859         }
860
861         if (!torture_close_connection(cli1)) {
862                 correct = False;
863         }
864         return correct;
865 }
866
867 int line_count = 0;
868 int nbio_id;
869
870 #define ival(s) strtol(s, NULL, 0)
871
872 /* run a test that simulates an approximate netbench client load */
873 static bool run_netbench(int client)
874 {
875         struct cli_state *cli;
876         int i;
877         char line[1024];
878         char cname[20];
879         FILE *f;
880         const char *params[20];
881         bool correct = True;
882
883         cli = current_cli;
884
885         nbio_id = client;
886
887         cli_sockopt(cli, sockops);
888
889         nb_setup(cli);
890
891         slprintf(cname,sizeof(cname)-1, "client%d", client);
892
893         f = fopen(client_txt, "r");
894
895         if (!f) {
896                 perror(client_txt);
897                 return False;
898         }
899
900         while (fgets(line, sizeof(line)-1, f)) {
901                 char *saveptr;
902                 line_count++;
903
904                 line[strlen(line)-1] = 0;
905
906                 /* printf("[%d] %s\n", line_count, line); */
907
908                 all_string_sub(line,"client1", cname, sizeof(line));
909
910                 /* parse the command parameters */
911                 params[0] = strtok_r(line, " ", &saveptr);
912                 i = 0;
913                 while (params[i]) params[++i] = strtok_r(NULL, " ", &saveptr);
914
915                 params[i] = "";
916
917                 if (i < 2) continue;
918
919                 if (!strncmp(params[0],"SMB", 3)) {
920                         printf("ERROR: You are using a dbench 1 load file\n");
921                         exit(1);
922                 }
923
924                 if (!strcmp(params[0],"NTCreateX")) {
925                         nb_createx(params[1], ival(params[2]), ival(params[3]), 
926                                    ival(params[4]));
927                 } else if (!strcmp(params[0],"Close")) {
928                         nb_close(ival(params[1]));
929                 } else if (!strcmp(params[0],"Rename")) {
930                         nb_rename(params[1], params[2]);
931                 } else if (!strcmp(params[0],"Unlink")) {
932                         nb_unlink(params[1]);
933                 } else if (!strcmp(params[0],"Deltree")) {
934                         nb_deltree(params[1]);
935                 } else if (!strcmp(params[0],"Rmdir")) {
936                         nb_rmdir(params[1]);
937                 } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
938                         nb_qpathinfo(params[1]);
939                 } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
940                         nb_qfileinfo(ival(params[1]));
941                 } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
942                         nb_qfsinfo(ival(params[1]));
943                 } else if (!strcmp(params[0],"FIND_FIRST")) {
944                         nb_findfirst(params[1]);
945                 } else if (!strcmp(params[0],"WriteX")) {
946                         nb_writex(ival(params[1]), 
947                                   ival(params[2]), ival(params[3]), ival(params[4]));
948                 } else if (!strcmp(params[0],"ReadX")) {
949                         nb_readx(ival(params[1]), 
950                                   ival(params[2]), ival(params[3]), ival(params[4]));
951                 } else if (!strcmp(params[0],"Flush")) {
952                         nb_flush(ival(params[1]));
953                 } else {
954                         printf("Unknown operation %s\n", params[0]);
955                         exit(1);
956                 }
957         }
958         fclose(f);
959
960         nb_cleanup();
961
962         if (!torture_close_connection(cli)) {
963                 correct = False;
964         }
965
966         return correct;
967 }
968
969
970 /* run a test that simulates an approximate netbench client load */
971 static bool run_nbench(int dummy)
972 {
973         double t;
974         bool correct = True;
975
976         nbio_shmem(nprocs);
977
978         nbio_id = -1;
979
980         signal(SIGALRM, nb_alarm);
981         alarm(1);
982         t = create_procs(run_netbench, &correct);
983         alarm(0);
984
985         printf("\nThroughput %g MB/sec\n", 
986                1.0e-6 * nbio_total() / t);
987         return correct;
988 }
989
990
991 /*
992   This test checks for two things:
993
994   1) correct support for retaining locks over a close (ie. the server
995      must not use posix semantics)
996   2) support for lock timeouts
997  */
998 static bool run_locktest1(int dummy)
999 {
1000         struct cli_state *cli1, *cli2;
1001         const char *fname = "\\lockt1.lck";
1002         uint16_t fnum1, fnum2, fnum3;
1003         time_t t1, t2;
1004         unsigned lock_timeout;
1005
1006         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1007                 return False;
1008         }
1009         cli_sockopt(cli1, sockops);
1010         cli_sockopt(cli2, sockops);
1011
1012         printf("starting locktest1\n");
1013
1014         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1015
1016         if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1017                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1018                 return False;
1019         }
1020         if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum2))) {
1021                 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli1));
1022                 return False;
1023         }
1024         if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum3))) {
1025                 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli2));
1026                 return False;
1027         }
1028
1029         if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
1030                 printf("lock1 failed (%s)\n", cli_errstr(cli1));
1031                 return False;
1032         }
1033
1034
1035         if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
1036                 printf("lock2 succeeded! This is a locking bug\n");
1037                 return False;
1038         } else {
1039                 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock, 
1040                                  NT_STATUS_LOCK_NOT_GRANTED)) return False;
1041         }
1042
1043
1044         lock_timeout = (1 + (random() % 20));
1045         printf("Testing lock timeout with timeout=%u\n", lock_timeout);
1046         t1 = time(NULL);
1047         if (cli_lock(cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK)) {
1048                 printf("lock3 succeeded! This is a locking bug\n");
1049                 return False;
1050         } else {
1051                 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock, 
1052                                  NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1053         }
1054         t2 = time(NULL);
1055
1056         if (ABS(t2 - t1) < lock_timeout-1) {
1057                 printf("error: This server appears not to support timed lock requests\n");
1058         }
1059
1060         printf("server slept for %u seconds for a %u second timeout\n",
1061                (unsigned int)(t2-t1), lock_timeout);
1062
1063         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
1064                 printf("close1 failed (%s)\n", cli_errstr(cli1));
1065                 return False;
1066         }
1067
1068         if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
1069                 printf("lock4 succeeded! This is a locking bug\n");
1070                 return False;
1071         } else {
1072                 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock, 
1073                                  NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1074         }
1075
1076         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
1077                 printf("close2 failed (%s)\n", cli_errstr(cli1));
1078                 return False;
1079         }
1080
1081         if (!NT_STATUS_IS_OK(cli_close(cli2, fnum3))) {
1082                 printf("close3 failed (%s)\n", cli_errstr(cli2));
1083                 return False;
1084         }
1085
1086         if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
1087                 printf("unlink failed (%s)\n", cli_errstr(cli1));
1088                 return False;
1089         }
1090
1091
1092         if (!torture_close_connection(cli1)) {
1093                 return False;
1094         }
1095
1096         if (!torture_close_connection(cli2)) {
1097                 return False;
1098         }
1099
1100         printf("Passed locktest1\n");
1101         return True;
1102 }
1103
1104 /*
1105   this checks to see if a secondary tconx can use open files from an
1106   earlier tconx
1107  */
1108 static bool run_tcon_test(int dummy)
1109 {
1110         static struct cli_state *cli;
1111         const char *fname = "\\tcontest.tmp";
1112         uint16 fnum1;
1113         uint16 cnum1, cnum2, cnum3;
1114         uint16 vuid1, vuid2;
1115         char buf[4];
1116         bool ret = True;
1117         NTSTATUS status;
1118
1119         memset(buf, '\0', sizeof(buf));
1120
1121         if (!torture_open_connection(&cli, 0)) {
1122                 return False;
1123         }
1124         cli_sockopt(cli, sockops);
1125
1126         printf("starting tcontest\n");
1127
1128         cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
1129
1130         if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1131                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1132                 return False;
1133         }
1134
1135         cnum1 = cli->cnum;
1136         vuid1 = cli->vuid;
1137
1138         if (cli_write(cli, fnum1, 0, buf, 130, 4) != 4) {
1139                 printf("initial write failed (%s)", cli_errstr(cli));
1140                 return False;
1141         }
1142
1143         status = cli_tcon_andx(cli, share, "?????",
1144                                password, strlen(password)+1);
1145         if (!NT_STATUS_IS_OK(status)) {
1146                 printf("%s refused 2nd tree connect (%s)\n", host,
1147                        nt_errstr(status));
1148                 cli_shutdown(cli);
1149                 return False;
1150         }
1151
1152         cnum2 = cli->cnum;
1153         cnum3 = MAX(cnum1, cnum2) + 1; /* any invalid number */
1154         vuid2 = cli->vuid + 1;
1155
1156         /* try a write with the wrong tid */
1157         cli->cnum = cnum2;
1158
1159         if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1160                 printf("* server allows write with wrong TID\n");
1161                 ret = False;
1162         } else {
1163                 printf("server fails write with wrong TID : %s\n", cli_errstr(cli));
1164         }
1165
1166
1167         /* try a write with an invalid tid */
1168         cli->cnum = cnum3;
1169
1170         if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1171                 printf("* server allows write with invalid TID\n");
1172                 ret = False;
1173         } else {
1174                 printf("server fails write with invalid TID : %s\n", cli_errstr(cli));
1175         }
1176
1177         /* try a write with an invalid vuid */
1178         cli->vuid = vuid2;
1179         cli->cnum = cnum1;
1180
1181         if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1182                 printf("* server allows write with invalid VUID\n");
1183                 ret = False;
1184         } else {
1185                 printf("server fails write with invalid VUID : %s\n", cli_errstr(cli));
1186         }
1187
1188         cli->cnum = cnum1;
1189         cli->vuid = vuid1;
1190
1191         if (!NT_STATUS_IS_OK(cli_close(cli, fnum1))) {
1192                 printf("close failed (%s)\n", cli_errstr(cli));
1193                 return False;
1194         }
1195
1196         cli->cnum = cnum2;
1197
1198         status = cli_tdis(cli);
1199         if (!NT_STATUS_IS_OK(status)) {
1200                 printf("secondary tdis failed (%s)\n", nt_errstr(status));
1201                 return False;
1202         }
1203
1204         cli->cnum = cnum1;
1205
1206         if (!torture_close_connection(cli)) {
1207                 return False;
1208         }
1209
1210         return ret;
1211 }
1212
1213
1214 /*
1215  checks for old style tcon support
1216  */
1217 static bool run_tcon2_test(int dummy)
1218 {
1219         static struct cli_state *cli;
1220         uint16 cnum, max_xmit;
1221         char *service;
1222         NTSTATUS status;
1223
1224         if (!torture_open_connection(&cli, 0)) {
1225                 return False;
1226         }
1227         cli_sockopt(cli, sockops);
1228
1229         printf("starting tcon2 test\n");
1230
1231         if (asprintf(&service, "\\\\%s\\%s", host, share) == -1) {
1232                 return false;
1233         }
1234
1235         status = cli_raw_tcon(cli, service, password, "?????", &max_xmit, &cnum);
1236
1237         if (!NT_STATUS_IS_OK(status)) {
1238                 printf("tcon2 failed : %s\n", cli_errstr(cli));
1239         } else {
1240                 printf("tcon OK : max_xmit=%d cnum=%d tid=%d\n", 
1241                        (int)max_xmit, (int)cnum, SVAL(cli->inbuf, smb_tid));
1242         }
1243
1244         if (!torture_close_connection(cli)) {
1245                 return False;
1246         }
1247
1248         printf("Passed tcon2 test\n");
1249         return True;
1250 }
1251
1252 static bool tcon_devtest(struct cli_state *cli,
1253                          const char *myshare, const char *devtype,
1254                          const char *return_devtype,
1255                          NTSTATUS expected_error)
1256 {
1257         NTSTATUS status;
1258         bool ret;
1259
1260         status = cli_tcon_andx(cli, myshare, devtype,
1261                                password, strlen(password)+1);
1262
1263         if (NT_STATUS_IS_OK(expected_error)) {
1264                 if (NT_STATUS_IS_OK(status)) {
1265                         if (strcmp(cli->dev, return_devtype) == 0) {
1266                                 ret = True;
1267                         } else { 
1268                                 printf("tconX to share %s with type %s "
1269                                        "succeeded but returned the wrong "
1270                                        "device type (got [%s] but should have got [%s])\n",
1271                                        myshare, devtype, cli->dev, return_devtype);
1272                                 ret = False;
1273                         }
1274                 } else {
1275                         printf("tconX to share %s with type %s "
1276                                "should have succeeded but failed\n",
1277                                myshare, devtype);
1278                         ret = False;
1279                 }
1280                 cli_tdis(cli);
1281         } else {
1282                 if (NT_STATUS_IS_OK(status)) {
1283                         printf("tconx to share %s with type %s "
1284                                "should have failed but succeeded\n",
1285                                myshare, devtype);
1286                         ret = False;
1287                 } else {
1288                         if (NT_STATUS_EQUAL(cli_nt_error(cli),
1289                                             expected_error)) {
1290                                 ret = True;
1291                         } else {
1292                                 printf("Returned unexpected error\n");
1293                                 ret = False;
1294                         }
1295                 }
1296         }
1297         return ret;
1298 }
1299
1300 /*
1301  checks for correct tconX support
1302  */
1303 static bool run_tcon_devtype_test(int dummy)
1304 {
1305         static struct cli_state *cli1 = NULL;
1306         bool retry;
1307         int flags = 0;
1308         NTSTATUS status;
1309         bool ret = True;
1310
1311         status = cli_full_connection(&cli1, myname,
1312                                      host, NULL, port_to_use,
1313                                      NULL, NULL,
1314                                      username, workgroup,
1315                                      password, flags, Undefined, &retry);
1316
1317         if (!NT_STATUS_IS_OK(status)) {
1318                 printf("could not open connection\n");
1319                 return False;
1320         }
1321
1322         if (!tcon_devtest(cli1, "IPC$", "A:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1323                 ret = False;
1324
1325         if (!tcon_devtest(cli1, "IPC$", "?????", "IPC", NT_STATUS_OK))
1326                 ret = False;
1327
1328         if (!tcon_devtest(cli1, "IPC$", "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1329                 ret = False;
1330
1331         if (!tcon_devtest(cli1, "IPC$", "IPC", "IPC", NT_STATUS_OK))
1332                 ret = False;
1333
1334         if (!tcon_devtest(cli1, "IPC$", "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1335                 ret = False;
1336
1337         if (!tcon_devtest(cli1, share, "A:", "A:", NT_STATUS_OK))
1338                 ret = False;
1339
1340         if (!tcon_devtest(cli1, share, "?????", "A:", NT_STATUS_OK))
1341                 ret = False;
1342
1343         if (!tcon_devtest(cli1, share, "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1344                 ret = False;
1345
1346         if (!tcon_devtest(cli1, share, "IPC", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1347                 ret = False;
1348
1349         if (!tcon_devtest(cli1, share, "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1350                 ret = False;
1351
1352         cli_shutdown(cli1);
1353
1354         if (ret)
1355                 printf("Passed tcondevtest\n");
1356
1357         return ret;
1358 }
1359
1360
1361 /*
1362   This test checks that 
1363
1364   1) the server supports multiple locking contexts on the one SMB
1365   connection, distinguished by PID.  
1366
1367   2) the server correctly fails overlapping locks made by the same PID (this
1368      goes against POSIX behaviour, which is why it is tricky to implement)
1369
1370   3) the server denies unlock requests by an incorrect client PID
1371 */
1372 static bool run_locktest2(int dummy)
1373 {
1374         static struct cli_state *cli;
1375         const char *fname = "\\lockt2.lck";
1376         uint16_t fnum1, fnum2, fnum3;
1377         bool correct = True;
1378
1379         if (!torture_open_connection(&cli, 0)) {
1380                 return False;
1381         }
1382
1383         cli_sockopt(cli, sockops);
1384
1385         printf("starting locktest2\n");
1386
1387         cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
1388
1389         cli_setpid(cli, 1);
1390
1391         if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1392                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1393                 return False;
1394         }
1395
1396         if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum2))) {
1397                 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli));
1398                 return False;
1399         }
1400
1401         cli_setpid(cli, 2);
1402
1403         if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum3))) {
1404                 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli));
1405                 return False;
1406         }
1407
1408         cli_setpid(cli, 1);
1409
1410         if (!cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1411                 printf("lock1 failed (%s)\n", cli_errstr(cli));
1412                 return False;
1413         }
1414
1415         if (cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1416                 printf("WRITE lock1 succeeded! This is a locking bug\n");
1417                 correct = False;
1418         } else {
1419                 if (!check_error(__LINE__, cli, ERRDOS, ERRlock, 
1420                                  NT_STATUS_LOCK_NOT_GRANTED)) return False;
1421         }
1422
1423         if (cli_lock(cli, fnum2, 0, 4, 0, WRITE_LOCK)) {
1424                 printf("WRITE lock2 succeeded! This is a locking bug\n");
1425                 correct = False;
1426         } else {
1427                 if (!check_error(__LINE__, cli, ERRDOS, ERRlock, 
1428                                  NT_STATUS_LOCK_NOT_GRANTED)) return False;
1429         }
1430
1431         if (cli_lock(cli, fnum2, 0, 4, 0, READ_LOCK)) {
1432                 printf("READ lock2 succeeded! This is a locking bug\n");
1433                 correct = False;
1434         } else {
1435                 if (!check_error(__LINE__, cli, ERRDOS, ERRlock, 
1436                                  NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1437         }
1438
1439         if (!cli_lock(cli, fnum1, 100, 4, 0, WRITE_LOCK)) {
1440                 printf("lock at 100 failed (%s)\n", cli_errstr(cli));
1441         }
1442         cli_setpid(cli, 2);
1443         if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 100, 4))) {
1444                 printf("unlock at 100 succeeded! This is a locking bug\n");
1445                 correct = False;
1446         }
1447
1448         if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 0, 4))) {
1449                 printf("unlock1 succeeded! This is a locking bug\n");
1450                 correct = False;
1451         } else {
1452                 if (!check_error(__LINE__, cli, 
1453                                  ERRDOS, ERRlock, 
1454                                  NT_STATUS_RANGE_NOT_LOCKED)) return False;
1455         }
1456
1457         if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 0, 8))) {
1458                 printf("unlock2 succeeded! This is a locking bug\n");
1459                 correct = False;
1460         } else {
1461                 if (!check_error(__LINE__, cli, 
1462                                  ERRDOS, ERRlock, 
1463                                  NT_STATUS_RANGE_NOT_LOCKED)) return False;
1464         }
1465
1466         if (cli_lock(cli, fnum3, 0, 4, 0, WRITE_LOCK)) {
1467                 printf("lock3 succeeded! This is a locking bug\n");
1468                 correct = False;
1469         } else {
1470                 if (!check_error(__LINE__, cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
1471         }
1472
1473         cli_setpid(cli, 1);
1474
1475         if (!NT_STATUS_IS_OK(cli_close(cli, fnum1))) {
1476                 printf("close1 failed (%s)\n", cli_errstr(cli));
1477                 return False;
1478         }
1479
1480         if (!NT_STATUS_IS_OK(cli_close(cli, fnum2))) {
1481                 printf("close2 failed (%s)\n", cli_errstr(cli));
1482                 return False;
1483         }
1484
1485         if (!NT_STATUS_IS_OK(cli_close(cli, fnum3))) {
1486                 printf("close3 failed (%s)\n", cli_errstr(cli));
1487                 return False;
1488         }
1489
1490         if (!torture_close_connection(cli)) {
1491                 correct = False;
1492         }
1493
1494         printf("locktest2 finished\n");
1495
1496         return correct;
1497 }
1498
1499
1500 /*
1501   This test checks that 
1502
1503   1) the server supports the full offset range in lock requests
1504 */
1505 static bool run_locktest3(int dummy)
1506 {
1507         static struct cli_state *cli1, *cli2;
1508         const char *fname = "\\lockt3.lck";
1509         uint16_t fnum1, fnum2;
1510         int i;
1511         uint32 offset;
1512         bool correct = True;
1513
1514 #define NEXT_OFFSET offset += (~(uint32)0) / torture_numops
1515
1516         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1517                 return False;
1518         }
1519         cli_sockopt(cli1, sockops);
1520         cli_sockopt(cli2, sockops);
1521
1522         printf("starting locktest3\n");
1523
1524         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1525
1526         if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1527                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1528                 return False;
1529         }
1530         if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2))) {
1531                 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli2));
1532                 return False;
1533         }
1534
1535         for (offset=i=0;i<torture_numops;i++) {
1536                 NEXT_OFFSET;
1537                 if (!cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1538                         printf("lock1 %d failed (%s)\n", 
1539                                i,
1540                                cli_errstr(cli1));
1541                         return False;
1542                 }
1543
1544                 if (!cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1545                         printf("lock2 %d failed (%s)\n", 
1546                                i,
1547                                cli_errstr(cli1));
1548                         return False;
1549                 }
1550         }
1551
1552         for (offset=i=0;i<torture_numops;i++) {
1553                 NEXT_OFFSET;
1554
1555                 if (cli_lock(cli1, fnum1, offset-2, 1, 0, WRITE_LOCK)) {
1556                         printf("error: lock1 %d succeeded!\n", i);
1557                         return False;
1558                 }
1559
1560                 if (cli_lock(cli2, fnum2, offset-1, 1, 0, WRITE_LOCK)) {
1561                         printf("error: lock2 %d succeeded!\n", i);
1562                         return False;
1563                 }
1564
1565                 if (cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1566                         printf("error: lock3 %d succeeded!\n", i);
1567                         return False;
1568                 }
1569
1570                 if (cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1571                         printf("error: lock4 %d succeeded!\n", i);
1572                         return False;
1573                 }
1574         }
1575
1576         for (offset=i=0;i<torture_numops;i++) {
1577                 NEXT_OFFSET;
1578
1579                 if (!NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, offset-1, 1))) {
1580                         printf("unlock1 %d failed (%s)\n", 
1581                                i,
1582                                cli_errstr(cli1));
1583                         return False;
1584                 }
1585
1586                 if (!NT_STATUS_IS_OK(cli_unlock(cli2, fnum2, offset-2, 1))) {
1587                         printf("unlock2 %d failed (%s)\n", 
1588                                i,
1589                                cli_errstr(cli1));
1590                         return False;
1591                 }
1592         }
1593
1594         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
1595                 printf("close1 failed (%s)\n", cli_errstr(cli1));
1596                 return False;
1597         }
1598
1599         if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
1600                 printf("close2 failed (%s)\n", cli_errstr(cli2));
1601                 return False;
1602         }
1603
1604         if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
1605                 printf("unlink failed (%s)\n", cli_errstr(cli1));
1606                 return False;
1607         }
1608
1609         if (!torture_close_connection(cli1)) {
1610                 correct = False;
1611         }
1612
1613         if (!torture_close_connection(cli2)) {
1614                 correct = False;
1615         }
1616
1617         printf("finished locktest3\n");
1618
1619         return correct;
1620 }
1621
1622 #define EXPECTED(ret, v) if ((ret) != (v)) { \
1623         printf("** "); correct = False; \
1624         }
1625
1626 /*
1627   looks at overlapping locks
1628 */
1629 static bool run_locktest4(int dummy)
1630 {
1631         static struct cli_state *cli1, *cli2;
1632         const char *fname = "\\lockt4.lck";
1633         uint16_t fnum1, fnum2, f;
1634         bool ret;
1635         char buf[1000];
1636         bool correct = True;
1637
1638         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1639                 return False;
1640         }
1641
1642         cli_sockopt(cli1, sockops);
1643         cli_sockopt(cli2, sockops);
1644
1645         printf("starting locktest4\n");
1646
1647         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1648
1649         cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1650         cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1651
1652         memset(buf, 0, sizeof(buf));
1653
1654         if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1655                 printf("Failed to create file\n");
1656                 correct = False;
1657                 goto fail;
1658         }
1659
1660         ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1661               cli_lock(cli1, fnum1, 2, 4, 0, WRITE_LOCK);
1662         EXPECTED(ret, False);
1663         printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
1664
1665         ret = cli_lock(cli1, fnum1, 10, 4, 0, READ_LOCK) &&
1666               cli_lock(cli1, fnum1, 12, 4, 0, READ_LOCK);
1667         EXPECTED(ret, True);
1668         printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
1669
1670         ret = cli_lock(cli1, fnum1, 20, 4, 0, WRITE_LOCK) &&
1671               cli_lock(cli2, fnum2, 22, 4, 0, WRITE_LOCK);
1672         EXPECTED(ret, False);
1673         printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
1674
1675         ret = cli_lock(cli1, fnum1, 30, 4, 0, READ_LOCK) &&
1676               cli_lock(cli2, fnum2, 32, 4, 0, READ_LOCK);
1677         EXPECTED(ret, True);
1678         printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
1679
1680         ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 40, 4, 0, WRITE_LOCK)) &&
1681               (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 42, 4, 0, WRITE_LOCK));
1682         EXPECTED(ret, False);
1683         printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
1684
1685         ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 50, 4, 0, READ_LOCK)) &&
1686               (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 52, 4, 0, READ_LOCK));
1687         EXPECTED(ret, True);
1688         printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
1689
1690         ret = cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK) &&
1691               cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK);
1692         EXPECTED(ret, True);
1693         printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
1694
1695         ret = cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK) &&
1696               cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK);
1697         EXPECTED(ret, False);
1698         printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
1699
1700         ret = cli_lock(cli1, fnum1, 80, 4, 0, READ_LOCK) &&
1701               cli_lock(cli1, fnum1, 80, 4, 0, WRITE_LOCK);
1702         EXPECTED(ret, False);
1703         printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
1704
1705         ret = cli_lock(cli1, fnum1, 90, 4, 0, WRITE_LOCK) &&
1706               cli_lock(cli1, fnum1, 90, 4, 0, READ_LOCK);
1707         EXPECTED(ret, True);
1708         printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1709
1710         ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 100, 4, 0, WRITE_LOCK)) &&
1711               (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 100, 4, 0, READ_LOCK));
1712         EXPECTED(ret, False);
1713         printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1714
1715         ret = cli_lock(cli1, fnum1, 110, 4, 0, READ_LOCK) &&
1716               cli_lock(cli1, fnum1, 112, 4, 0, READ_LOCK) &&
1717               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 110, 6));
1718         EXPECTED(ret, False);
1719         printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
1720
1721
1722         ret = cli_lock(cli1, fnum1, 120, 4, 0, WRITE_LOCK) &&
1723               (cli_read(cli2, fnum2, buf, 120, 4) == 4);
1724         EXPECTED(ret, False);
1725         printf("this server %s strict write locking\n", ret?"doesn't do":"does");
1726
1727         ret = cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK) &&
1728               (cli_write(cli2, fnum2, 0, buf, 130, 4) == 4);
1729         EXPECTED(ret, False);
1730         printf("this server %s strict read locking\n", ret?"doesn't do":"does");
1731
1732
1733         ret = cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1734               cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1735               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4)) &&
1736               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4));
1737         EXPECTED(ret, True);
1738         printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
1739
1740
1741         ret = cli_lock(cli1, fnum1, 150, 4, 0, WRITE_LOCK) &&
1742               cli_lock(cli1, fnum1, 150, 4, 0, READ_LOCK) &&
1743               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4)) &&
1744               (cli_read(cli2, fnum2, buf, 150, 4) == 4) &&
1745               !(cli_write(cli2, fnum2, 0, buf, 150, 4) == 4) &&
1746               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4));
1747         EXPECTED(ret, True);
1748         printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
1749
1750         ret = cli_lock(cli1, fnum1, 160, 4, 0, READ_LOCK) &&
1751               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 160, 4)) &&
1752               (cli_write(cli2, fnum2, 0, buf, 160, 4) == 4) &&          
1753               (cli_read(cli2, fnum2, buf, 160, 4) == 4);                
1754         EXPECTED(ret, True);
1755         printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
1756
1757         ret = cli_lock(cli1, fnum1, 170, 4, 0, WRITE_LOCK) &&
1758               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 170, 4)) &&
1759               (cli_write(cli2, fnum2, 0, buf, 170, 4) == 4) &&          
1760               (cli_read(cli2, fnum2, buf, 170, 4) == 4);                
1761         EXPECTED(ret, True);
1762         printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
1763
1764         ret = cli_lock(cli1, fnum1, 190, 4, 0, WRITE_LOCK) &&
1765               cli_lock(cli1, fnum1, 190, 4, 0, READ_LOCK) &&
1766               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 190, 4)) &&
1767               !(cli_write(cli2, fnum2, 0, buf, 190, 4) == 4) &&         
1768               (cli_read(cli2, fnum2, buf, 190, 4) == 4);                
1769         EXPECTED(ret, True);
1770         printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
1771
1772         cli_close(cli1, fnum1);
1773         cli_close(cli2, fnum2);
1774         cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
1775         cli_open(cli1, fname, O_RDWR, DENY_NONE, &f);
1776         ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1777               cli_lock(cli1, f, 0, 1, 0, READ_LOCK) &&
1778               NT_STATUS_IS_OK(cli_close(cli1, fnum1)) &&
1779               NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1)) &&
1780               cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1781         cli_close(cli1, f);
1782         cli_close(cli1, fnum1);
1783         EXPECTED(ret, True);
1784         printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
1785
1786  fail:
1787         cli_close(cli1, fnum1);
1788         cli_close(cli2, fnum2);
1789         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1790         torture_close_connection(cli1);
1791         torture_close_connection(cli2);
1792
1793         printf("finished locktest4\n");
1794         return correct;
1795 }
1796
1797 /*
1798   looks at lock upgrade/downgrade.
1799 */
1800 static bool run_locktest5(int dummy)
1801 {
1802         static struct cli_state *cli1, *cli2;
1803         const char *fname = "\\lockt5.lck";
1804         uint16_t fnum1, fnum2, fnum3;
1805         bool ret;
1806         char buf[1000];
1807         bool correct = True;
1808
1809         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1810                 return False;
1811         }
1812
1813         cli_sockopt(cli1, sockops);
1814         cli_sockopt(cli2, sockops);
1815
1816         printf("starting locktest5\n");
1817
1818         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1819
1820         cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1821         cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1822         cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum3);
1823
1824         memset(buf, 0, sizeof(buf));
1825
1826         if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1827                 printf("Failed to create file\n");
1828                 correct = False;
1829                 goto fail;
1830         }
1831
1832         /* Check for NT bug... */
1833         ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1834                   cli_lock(cli1, fnum3, 0, 1, 0, READ_LOCK);
1835         cli_close(cli1, fnum1);
1836         cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
1837         ret = cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1838         EXPECTED(ret, True);
1839         printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
1840         cli_close(cli1, fnum1);
1841         cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
1842         cli_unlock(cli1, fnum3, 0, 1);
1843
1844         ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1845               cli_lock(cli1, fnum1, 1, 1, 0, READ_LOCK);
1846         EXPECTED(ret, True);
1847         printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
1848
1849         ret = cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1850         EXPECTED(ret, False);
1851
1852         printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
1853
1854         /* Unlock the process 2 lock. */
1855         cli_unlock(cli2, fnum2, 0, 4);
1856
1857         ret = cli_lock(cli1, fnum3, 0, 4, 0, READ_LOCK);
1858         EXPECTED(ret, False);
1859
1860         printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
1861
1862         /* Unlock the process 1 fnum3 lock. */
1863         cli_unlock(cli1, fnum3, 0, 4);
1864
1865         /* Stack 2 more locks here. */
1866         ret = cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK) &&
1867                   cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK);
1868
1869         EXPECTED(ret, True);
1870         printf("the same process %s stack read locks\n", ret?"can":"cannot");
1871
1872         /* Unlock the first process lock, then check this was the WRITE lock that was
1873                 removed. */
1874
1875         ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
1876                         cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1877
1878         EXPECTED(ret, True);
1879         printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
1880
1881         /* Unlock the process 2 lock. */
1882         cli_unlock(cli2, fnum2, 0, 4);
1883
1884         /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
1885
1886         ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 1, 1)) &&
1887                   NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
1888                   NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
1889
1890         EXPECTED(ret, True);
1891         printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot"); 
1892
1893         /* Ensure the next unlock fails. */
1894         ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
1895         EXPECTED(ret, False);
1896         printf("the same process %s count the lock stack\n", !ret?"can":"cannot"); 
1897
1898         /* Ensure connection 2 can get a write lock. */
1899         ret = cli_lock(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
1900         EXPECTED(ret, True);
1901
1902         printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
1903
1904
1905  fail:
1906         cli_close(cli1, fnum1);
1907         cli_close(cli2, fnum2);
1908         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1909         if (!torture_close_connection(cli1)) {
1910                 correct = False;
1911         }
1912         if (!torture_close_connection(cli2)) {
1913                 correct = False;
1914         }
1915
1916         printf("finished locktest5\n");
1917
1918         return correct;
1919 }
1920
1921 /*
1922   tries the unusual lockingX locktype bits
1923 */
1924 static bool run_locktest6(int dummy)
1925 {
1926         static struct cli_state *cli;
1927         const char *fname[1] = { "\\lock6.txt" };
1928         int i;
1929         uint16_t fnum;
1930         NTSTATUS status;
1931
1932         if (!torture_open_connection(&cli, 0)) {
1933                 return False;
1934         }
1935
1936         cli_sockopt(cli, sockops);
1937
1938         printf("starting locktest6\n");
1939
1940         for (i=0;i<1;i++) {
1941                 printf("Testing %s\n", fname[i]);
1942
1943                 cli_unlink(cli, fname[i], aSYSTEM | aHIDDEN);
1944
1945                 cli_open(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
1946                 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
1947                 cli_close(cli, fnum);
1948                 printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
1949
1950                 cli_open(cli, fname[i], O_RDWR, DENY_NONE, &fnum);
1951                 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
1952                 cli_close(cli, fnum);
1953                 printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
1954
1955                 cli_unlink(cli, fname[i], aSYSTEM | aHIDDEN);
1956         }
1957
1958         torture_close_connection(cli);
1959
1960         printf("finished locktest6\n");
1961         return True;
1962 }
1963
1964 static bool run_locktest7(int dummy)
1965 {
1966         struct cli_state *cli1;
1967         const char *fname = "\\lockt7.lck";
1968         uint16_t fnum1;
1969         char buf[200];
1970         bool correct = False;
1971
1972         if (!torture_open_connection(&cli1, 0)) {
1973                 return False;
1974         }
1975
1976         cli_sockopt(cli1, sockops);
1977
1978         printf("starting locktest7\n");
1979
1980         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1981
1982         cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1983
1984         memset(buf, 0, sizeof(buf));
1985
1986         if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1987                 printf("Failed to create file\n");
1988                 goto fail;
1989         }
1990
1991         cli_setpid(cli1, 1);
1992
1993         if (!cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK)) {
1994                 printf("Unable to apply read lock on range 130:4, error was %s\n", cli_errstr(cli1));
1995                 goto fail;
1996         } else {
1997                 printf("pid1 successfully locked range 130:4 for READ\n");
1998         }
1999
2000         if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2001                 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2002                 goto fail;
2003         } else {
2004                 printf("pid1 successfully read the range 130:4\n");
2005         }
2006
2007         if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2008                 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2009                 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2010                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2011                         goto fail;
2012                 }
2013         } else {
2014                 printf("pid1 successfully wrote to the range 130:4 (should be denied)\n");
2015                 goto fail;
2016         }
2017
2018         cli_setpid(cli1, 2);
2019
2020         if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2021                 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2022         } else {
2023                 printf("pid2 successfully read the range 130:4\n");
2024         }
2025
2026         if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2027                 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2028                 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2029                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2030                         goto fail;
2031                 }
2032         } else {
2033                 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2034                 goto fail;
2035         }
2036
2037         cli_setpid(cli1, 1);
2038         cli_unlock(cli1, fnum1, 130, 4);
2039
2040         if (!cli_lock(cli1, fnum1, 130, 4, 0, WRITE_LOCK)) {
2041                 printf("Unable to apply write lock on range 130:4, error was %s\n", cli_errstr(cli1));
2042                 goto fail;
2043         } else {
2044                 printf("pid1 successfully locked range 130:4 for WRITE\n");
2045         }
2046
2047         if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2048                 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2049                 goto fail;
2050         } else {
2051                 printf("pid1 successfully read the range 130:4\n");
2052         }
2053
2054         if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2055                 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2056                 goto fail;
2057         } else {
2058                 printf("pid1 successfully wrote to the range 130:4\n");
2059         }
2060
2061         cli_setpid(cli1, 2);
2062
2063         if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2064                 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2065                 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2066                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2067                         goto fail;
2068                 }
2069         } else {
2070                 printf("pid2 successfully read the range 130:4 (should be denied)\n");
2071                 goto fail;
2072         }
2073
2074         if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2075                 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2076                 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2077                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2078                         goto fail;
2079                 }
2080         } else {
2081                 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2082                 goto fail;
2083         }
2084
2085         cli_unlock(cli1, fnum1, 130, 0);
2086         correct = True;
2087
2088 fail:
2089         cli_close(cli1, fnum1);
2090         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2091         torture_close_connection(cli1);
2092
2093         printf("finished locktest7\n");
2094         return correct;
2095 }
2096
2097 /*
2098  * This demonstrates a problem with our use of GPFS share modes: A file
2099  * descriptor sitting in the pending close queue holding a GPFS share mode
2100  * blocks opening a file another time. Happens with Word 2007 temp files.
2101  * With "posix locking = yes" and "gpfs:sharemodes = yes" enabled, the third
2102  * open is denied with NT_STATUS_SHARING_VIOLATION.
2103  */
2104
2105 static bool run_locktest8(int dummy)
2106 {
2107         struct cli_state *cli1;
2108         const char *fname = "\\lockt8.lck";
2109         uint16_t fnum1, fnum2;
2110         char buf[200];
2111         bool correct = False;
2112         NTSTATUS status;
2113
2114         if (!torture_open_connection(&cli1, 0)) {
2115                 return False;
2116         }
2117
2118         cli_sockopt(cli1, sockops);
2119
2120         printf("starting locktest8\n");
2121
2122         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2123
2124         status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_WRITE,
2125                           &fnum1);
2126         if (!NT_STATUS_IS_OK(status)) {
2127                 d_fprintf(stderr, "cli_open returned %s\n", cli_errstr(cli1));
2128                 return false;
2129         }
2130
2131         memset(buf, 0, sizeof(buf));
2132
2133         status = cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum2);
2134         if (!NT_STATUS_IS_OK(status)) {
2135                 d_fprintf(stderr, "cli_open second time returned %s\n",
2136                           cli_errstr(cli1));
2137                 goto fail;
2138         }
2139
2140         if (!cli_lock(cli1, fnum2, 1, 1, 0, READ_LOCK)) {
2141                 printf("Unable to apply read lock on range 1:1, error was "
2142                        "%s\n", cli_errstr(cli1));
2143                 goto fail;
2144         }
2145
2146         status = cli_close(cli1, fnum1);
2147         if (!NT_STATUS_IS_OK(status)) {
2148                 d_fprintf(stderr, "cli_close(fnum1) %s\n", cli_errstr(cli1));
2149                 goto fail;
2150         }
2151
2152         status = cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2153         if (!NT_STATUS_IS_OK(status)) {
2154                 d_fprintf(stderr, "cli_open third time returned %s\n",
2155                           cli_errstr(cli1));
2156                 goto fail;
2157         }
2158
2159         correct = true;
2160
2161 fail:
2162         cli_close(cli1, fnum1);
2163         cli_close(cli1, fnum2);
2164         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2165         torture_close_connection(cli1);
2166
2167         printf("finished locktest8\n");
2168         return correct;
2169 }
2170
2171 /*
2172  * This test is designed to be run in conjunction with
2173  * external NFS or POSIX locks taken in the filesystem.
2174  * It checks that the smbd server will block until the
2175  * lock is released and then acquire it. JRA.
2176  */
2177
2178 static bool got_alarm;
2179 static int alarm_fd;
2180
2181 static void alarm_handler(int dummy)
2182 {
2183         got_alarm = True;
2184 }
2185
2186 static void alarm_handler_parent(int dummy)
2187 {
2188         close(alarm_fd);
2189 }
2190
2191 static void do_local_lock(int read_fd, int write_fd)
2192 {
2193         int fd;
2194         char c = '\0';
2195         struct flock lock;
2196         const char *local_pathname = NULL;
2197         int ret;
2198
2199         local_pathname = talloc_asprintf(talloc_tos(),
2200                         "%s/lockt9.lck", local_path);
2201         if (!local_pathname) {
2202                 printf("child: alloc fail\n");
2203                 exit(1);
2204         }
2205
2206         unlink(local_pathname);
2207         fd = open(local_pathname, O_RDWR|O_CREAT, 0666);
2208         if (fd == -1) {
2209                 printf("child: open of %s failed %s.\n",
2210                         local_pathname, strerror(errno));
2211                 exit(1);
2212         }
2213
2214         /* Now take a fcntl lock. */
2215         lock.l_type = F_WRLCK;
2216         lock.l_whence = SEEK_SET;
2217         lock.l_start = 0;
2218         lock.l_len = 4;
2219         lock.l_pid = getpid();
2220
2221         ret = fcntl(fd,F_SETLK,&lock);
2222         if (ret == -1) {
2223                 printf("child: failed to get lock 0:4 on file %s. Error %s\n",
2224                         local_pathname, strerror(errno));
2225                 exit(1);
2226         } else {
2227                 printf("child: got lock 0:4 on file %s.\n",
2228                         local_pathname );
2229                 fflush(stdout);
2230         }
2231
2232         CatchSignal(SIGALRM, alarm_handler);
2233         alarm(5);
2234         /* Signal the parent. */
2235         if (write(write_fd, &c, 1) != 1) {
2236                 printf("child: start signal fail %s.\n",
2237                         strerror(errno));
2238                 exit(1);
2239         }
2240         alarm(0);
2241
2242         alarm(10);
2243         /* Wait for the parent to be ready. */
2244         if (read(read_fd, &c, 1) != 1) {
2245                 printf("child: reply signal fail %s.\n",
2246                         strerror(errno));
2247                 exit(1);
2248         }
2249         alarm(0);
2250
2251         sleep(5);
2252         close(fd);
2253         printf("child: released lock 0:4 on file %s.\n",
2254                 local_pathname );
2255         fflush(stdout);
2256         exit(0);
2257 }
2258
2259 static bool run_locktest9(int dummy)
2260 {
2261         struct cli_state *cli1;
2262         const char *fname = "\\lockt9.lck";
2263         uint16_t fnum;
2264         bool correct = False;
2265         int pipe_in[2], pipe_out[2];
2266         pid_t child_pid;
2267         char c = '\0';
2268         int ret;
2269         struct timeval start;
2270         double seconds;
2271         NTSTATUS status;
2272
2273         printf("starting locktest9\n");
2274
2275         if (local_path == NULL) {
2276                 d_fprintf(stderr, "locktest9 must be given a local path via -l <localpath>\n");
2277                 return false;
2278         }
2279
2280         if (pipe(pipe_in) == -1 || pipe(pipe_out) == -1) {
2281                 return false;
2282         }
2283
2284         child_pid = fork();
2285         if (child_pid == -1) {
2286                 return false;
2287         }
2288
2289         if (child_pid == 0) {
2290                 /* Child. */
2291                 do_local_lock(pipe_out[0], pipe_in[1]);
2292                 exit(0);
2293         }
2294
2295         close(pipe_out[0]);
2296         close(pipe_in[1]);
2297         pipe_out[0] = -1;
2298         pipe_in[1] = -1;
2299
2300         /* Parent. */
2301         ret = read(pipe_in[0], &c, 1);
2302         if (ret != 1) {
2303                 d_fprintf(stderr, "failed to read start signal from child. %s\n",
2304                         strerror(errno));
2305                 return false;
2306         }
2307
2308         if (!torture_open_connection(&cli1, 0)) {
2309                 return false;
2310         }
2311
2312         cli_sockopt(cli1, sockops);
2313
2314         status = cli_open(cli1, fname, O_RDWR, DENY_NONE,
2315                           &fnum);
2316         if (!NT_STATUS_IS_OK(status)) {
2317                 d_fprintf(stderr, "cli_open returned %s\n", cli_errstr(cli1));
2318                 return false;
2319         }
2320
2321         /* Ensure the child has the lock. */
2322         if (cli_lock(cli1, fnum, 0, 4, 0, WRITE_LOCK)) {
2323                 d_fprintf(stderr, "Got the lock on range 0:4 - this should not happen !\n");
2324                 goto fail;
2325         } else {
2326                 d_printf("Child has the lock.\n");
2327         }
2328
2329         /* Tell the child to wait 5 seconds then exit. */
2330         ret = write(pipe_out[1], &c, 1);
2331         if (ret != 1) {
2332                 d_fprintf(stderr, "failed to send exit signal to child. %s\n",
2333                         strerror(errno));
2334                 goto fail;
2335         }
2336
2337         /* Wait 20 seconds for the lock. */
2338         alarm_fd = cli1->fd;
2339         CatchSignal(SIGALRM, alarm_handler_parent);
2340         alarm(20);
2341
2342         start = timeval_current();
2343
2344         if (!cli_lock(cli1, fnum, 0, 4, -1, WRITE_LOCK)) {
2345                 d_fprintf(stderr, "Unable to apply write lock on range 0:4, error was "
2346                        "%s\n", cli_errstr(cli1));
2347                 goto fail_nofd;
2348         }
2349         alarm(0);
2350
2351         seconds = timeval_elapsed(&start);
2352
2353         printf("Parent got the lock after %.2f seconds.\n",
2354                 seconds);
2355
2356         status = cli_close(cli1, fnum);
2357         if (!NT_STATUS_IS_OK(status)) {
2358                 d_fprintf(stderr, "cli_close(fnum1) %s\n", cli_errstr(cli1));
2359                 goto fail;
2360         }
2361
2362         correct = true;
2363
2364 fail:
2365         cli_close(cli1, fnum);
2366         torture_close_connection(cli1);
2367
2368 fail_nofd:
2369
2370         printf("finished locktest9\n");
2371         return correct;
2372 }
2373
2374 /*
2375 test whether fnums and tids open on one VC are available on another (a major
2376 security hole)
2377 */
2378 static bool run_fdpasstest(int dummy)
2379 {
2380         struct cli_state *cli1, *cli2;
2381         const char *fname = "\\fdpass.tst";
2382         uint16_t fnum1;
2383         char buf[1024];
2384
2385         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2386                 return False;
2387         }
2388         cli_sockopt(cli1, sockops);
2389         cli_sockopt(cli2, sockops);
2390
2391         printf("starting fdpasstest\n");
2392
2393         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2394
2395         if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
2396                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2397                 return False;
2398         }
2399
2400         if (cli_write(cli1, fnum1, 0, "hello world\n", 0, 13) != 13) {
2401                 printf("write failed (%s)\n", cli_errstr(cli1));
2402                 return False;
2403         }
2404
2405         cli2->vuid = cli1->vuid;
2406         cli2->cnum = cli1->cnum;
2407         cli2->pid = cli1->pid;
2408
2409         if (cli_read(cli2, fnum1, buf, 0, 13) == 13) {
2410                 printf("read succeeded! nasty security hole [%s]\n",
2411                        buf);
2412                 return False;
2413         }
2414
2415         cli_close(cli1, fnum1);
2416         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2417
2418         torture_close_connection(cli1);
2419         torture_close_connection(cli2);
2420
2421         printf("finished fdpasstest\n");
2422         return True;
2423 }
2424
2425 static bool run_fdsesstest(int dummy)
2426 {
2427         struct cli_state *cli;
2428         uint16 new_vuid;
2429         uint16 saved_vuid;
2430         uint16 new_cnum;
2431         uint16 saved_cnum;
2432         const char *fname = "\\fdsess.tst";
2433         const char *fname1 = "\\fdsess1.tst";
2434         uint16_t fnum1;
2435         uint16_t fnum2;
2436         char buf[1024];
2437         bool ret = True;
2438
2439         if (!torture_open_connection(&cli, 0))
2440                 return False;
2441         cli_sockopt(cli, sockops);
2442
2443         if (!torture_cli_session_setup2(cli, &new_vuid))
2444                 return False;
2445
2446         saved_cnum = cli->cnum;
2447         if (!NT_STATUS_IS_OK(cli_tcon_andx(cli, share, "?????", "", 1)))
2448                 return False;
2449         new_cnum = cli->cnum;
2450         cli->cnum = saved_cnum;
2451
2452         printf("starting fdsesstest\n");
2453
2454         cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2455         cli_unlink(cli, fname1, aSYSTEM | aHIDDEN);
2456
2457         if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
2458                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2459                 return False;
2460         }
2461
2462         if (cli_write(cli, fnum1, 0, "hello world\n", 0, 13) != 13) {
2463                 printf("write failed (%s)\n", cli_errstr(cli));
2464                 return False;
2465         }
2466
2467         saved_vuid = cli->vuid;
2468         cli->vuid = new_vuid;
2469
2470         if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2471                 printf("read succeeded with different vuid! nasty security hole [%s]\n",
2472                        buf);
2473                 ret = False;
2474         }
2475         /* Try to open a file with different vuid, samba cnum. */
2476         if (NT_STATUS_IS_OK(cli_open(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum2))) {
2477                 printf("create with different vuid, same cnum succeeded.\n");
2478                 cli_close(cli, fnum2);
2479                 cli_unlink(cli, fname1, aSYSTEM | aHIDDEN);
2480         } else {
2481                 printf("create with different vuid, same cnum failed.\n");
2482                 printf("This will cause problems with service clients.\n");
2483                 ret = False;
2484         }
2485
2486         cli->vuid = saved_vuid;
2487
2488         /* Try with same vuid, different cnum. */
2489         cli->cnum = new_cnum;
2490
2491         if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2492                 printf("read succeeded with different cnum![%s]\n",
2493                        buf);
2494                 ret = False;
2495         }
2496
2497         cli->cnum = saved_cnum;
2498         cli_close(cli, fnum1);
2499         cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2500
2501         torture_close_connection(cli);
2502
2503         printf("finished fdsesstest\n");
2504         return ret;
2505 }
2506
2507 /*
2508   This test checks that 
2509
2510   1) the server does not allow an unlink on a file that is open
2511 */
2512 static bool run_unlinktest(int dummy)
2513 {
2514         struct cli_state *cli;
2515         const char *fname = "\\unlink.tst";
2516         uint16_t fnum;
2517         bool correct = True;
2518
2519         if (!torture_open_connection(&cli, 0)) {
2520                 return False;
2521         }
2522
2523         cli_sockopt(cli, sockops);
2524
2525         printf("starting unlink test\n");
2526
2527         cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2528
2529         cli_setpid(cli, 1);
2530
2531         if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
2532                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2533                 return False;
2534         }
2535
2536         if (NT_STATUS_IS_OK(cli_unlink(cli, fname, aSYSTEM | aHIDDEN))) {
2537                 printf("error: server allowed unlink on an open file\n");
2538                 correct = False;
2539         } else {
2540                 correct = check_error(__LINE__, cli, ERRDOS, ERRbadshare, 
2541                                       NT_STATUS_SHARING_VIOLATION);
2542         }
2543
2544         cli_close(cli, fnum);
2545         cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2546
2547         if (!torture_close_connection(cli)) {
2548                 correct = False;
2549         }
2550
2551         printf("unlink test finished\n");
2552
2553         return correct;
2554 }
2555
2556
2557 /*
2558 test how many open files this server supports on the one socket
2559 */
2560 static bool run_maxfidtest(int dummy)
2561 {
2562         struct cli_state *cli;
2563         const char *ftemplate = "\\maxfid.%d.%d";
2564         fstring fname;
2565         uint16_t fnums[0x11000];
2566         int i;
2567         int retries=4;
2568         bool correct = True;
2569
2570         cli = current_cli;
2571
2572         if (retries <= 0) {
2573                 printf("failed to connect\n");
2574                 return False;
2575         }
2576
2577         cli_sockopt(cli, sockops);
2578
2579         for (i=0; i<0x11000; i++) {
2580                 slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2581                 if (!NT_STATUS_IS_OK(cli_open(cli, fname, 
2582                                         O_RDWR|O_CREAT|O_TRUNC, DENY_NONE, &fnums[i]))) {
2583                         printf("open of %s failed (%s)\n", 
2584                                fname, cli_errstr(cli));
2585                         printf("maximum fnum is %d\n", i);
2586                         break;
2587                 }
2588                 printf("%6d\r", i);
2589         }
2590         printf("%6d\n", i);
2591         i--;
2592
2593         printf("cleaning up\n");
2594         for (;i>=0;i--) {
2595                 slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2596                 cli_close(cli, fnums[i]);
2597                 if (!NT_STATUS_IS_OK(cli_unlink(cli, fname, aSYSTEM | aHIDDEN))) {
2598                         printf("unlink of %s failed (%s)\n", 
2599                                fname, cli_errstr(cli));
2600                         correct = False;
2601                 }
2602                 printf("%6d\r", i);
2603         }
2604         printf("%6d\n", 0);
2605
2606         printf("maxfid test finished\n");
2607         if (!torture_close_connection(cli)) {
2608                 correct = False;
2609         }
2610         return correct;
2611 }
2612
2613 /* generate a random buffer */
2614 static void rand_buf(char *buf, int len)
2615 {
2616         while (len--) {
2617                 *buf = (char)sys_random();
2618                 buf++;
2619         }
2620 }
2621
2622 /* send smb negprot commands, not reading the response */
2623 static bool run_negprot_nowait(int dummy)
2624 {
2625         int i;
2626         static struct cli_state *cli;
2627         bool correct = True;
2628
2629         printf("starting negprot nowait test\n");
2630
2631         if (!(cli = open_nbt_connection())) {
2632                 return False;
2633         }
2634
2635         for (i=0;i<50000;i++) {
2636                 cli_negprot_sendsync(cli);
2637         }
2638
2639         if (!torture_close_connection(cli)) {
2640                 correct = False;
2641         }
2642
2643         printf("finished negprot nowait test\n");
2644
2645         return correct;
2646 }
2647
2648
2649 /* send random IPC commands */
2650 static bool run_randomipc(int dummy)
2651 {
2652         char *rparam = NULL;
2653         char *rdata = NULL;
2654         unsigned int rdrcnt,rprcnt;
2655         char param[1024];
2656         int api, param_len, i;
2657         struct cli_state *cli;
2658         bool correct = True;
2659         int count = 50000;
2660
2661         printf("starting random ipc test\n");
2662
2663         if (!torture_open_connection(&cli, 0)) {
2664                 return False;
2665         }
2666
2667         for (i=0;i<count;i++) {
2668                 api = sys_random() % 500;
2669                 param_len = (sys_random() % 64);
2670
2671                 rand_buf(param, param_len);
2672
2673                 SSVAL(param,0,api); 
2674
2675                 cli_api(cli, 
2676                         param, param_len, 8,  
2677                         NULL, 0, BUFFER_SIZE, 
2678                         &rparam, &rprcnt,     
2679                         &rdata, &rdrcnt);
2680                 if (i % 100 == 0) {
2681                         printf("%d/%d\r", i,count);
2682                 }
2683         }
2684         printf("%d/%d\n", i, count);
2685
2686         if (!torture_close_connection(cli)) {
2687                 correct = False;
2688         }
2689
2690         printf("finished random ipc test\n");
2691
2692         return correct;
2693 }
2694
2695
2696
2697 static void browse_callback(const char *sname, uint32 stype, 
2698                             const char *comment, void *state)
2699 {
2700         printf("\t%20.20s %08x %s\n", sname, stype, comment);
2701 }
2702
2703
2704
2705 /*
2706   This test checks the browse list code
2707
2708 */
2709 static bool run_browsetest(int dummy)
2710 {
2711         static struct cli_state *cli;
2712         bool correct = True;
2713
2714         printf("starting browse test\n");
2715
2716         if (!torture_open_connection(&cli, 0)) {
2717                 return False;
2718         }
2719
2720         printf("domain list:\n");
2721         cli_NetServerEnum(cli, cli->server_domain, 
2722                           SV_TYPE_DOMAIN_ENUM,
2723                           browse_callback, NULL);
2724
2725         printf("machine list:\n");
2726         cli_NetServerEnum(cli, cli->server_domain, 
2727                           SV_TYPE_ALL,
2728                           browse_callback, NULL);
2729
2730         if (!torture_close_connection(cli)) {
2731                 correct = False;
2732         }
2733
2734         printf("browse test finished\n");
2735
2736         return correct;
2737
2738 }
2739
2740
2741 /*
2742   This checks how the getatr calls works
2743 */
2744 static bool run_attrtest(int dummy)
2745 {
2746         struct cli_state *cli;
2747         uint16_t fnum;
2748         time_t t, t2;
2749         const char *fname = "\\attrib123456789.tst";
2750         bool correct = True;
2751
2752         printf("starting attrib test\n");
2753
2754         if (!torture_open_connection(&cli, 0)) {
2755                 return False;
2756         }
2757
2758         cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2759         cli_open(cli, fname, 
2760                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
2761         cli_close(cli, fnum);
2762         if (!NT_STATUS_IS_OK(cli_getatr(cli, fname, NULL, NULL, &t))) {
2763                 printf("getatr failed (%s)\n", cli_errstr(cli));
2764                 correct = False;
2765         }
2766
2767         if (abs(t - time(NULL)) > 60*60*24*10) {
2768                 printf("ERROR: SMBgetatr bug. time is %s",
2769                        ctime(&t));
2770                 t = time(NULL);
2771                 correct = True;
2772         }
2773
2774         t2 = t-60*60*24; /* 1 day ago */
2775
2776         if (!NT_STATUS_IS_OK(cli_setatr(cli, fname, 0, t2))) {
2777                 printf("setatr failed (%s)\n", cli_errstr(cli));
2778                 correct = True;
2779         }
2780
2781         if (!NT_STATUS_IS_OK(cli_getatr(cli, fname, NULL, NULL, &t))) {
2782                 printf("getatr failed (%s)\n", cli_errstr(cli));
2783                 correct = True;
2784         }
2785
2786         if (t != t2) {
2787                 printf("ERROR: getatr/setatr bug. times are\n%s",
2788                        ctime(&t));
2789                 printf("%s", ctime(&t2));
2790                 correct = True;
2791         }
2792
2793         cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2794
2795         if (!torture_close_connection(cli)) {
2796                 correct = False;
2797         }
2798
2799         printf("attrib test finished\n");
2800
2801         return correct;
2802 }
2803
2804
2805 /*
2806   This checks a couple of trans2 calls
2807 */
2808 static bool run_trans2test(int dummy)
2809 {
2810         struct cli_state *cli;
2811         uint16_t fnum;
2812         SMB_OFF_T size;
2813         time_t c_time, a_time, m_time;
2814         struct timespec c_time_ts, a_time_ts, m_time_ts, w_time_ts, m_time2_ts;
2815         const char *fname = "\\trans2.tst";
2816         const char *dname = "\\trans2";
2817         const char *fname2 = "\\trans2\\trans2.tst";
2818         char pname[1024];
2819         bool correct = True;
2820         NTSTATUS status;
2821         uint32_t fs_attr;
2822
2823         printf("starting trans2 test\n");
2824
2825         if (!torture_open_connection(&cli, 0)) {
2826                 return False;
2827         }
2828
2829         status = cli_get_fs_attr_info(cli, &fs_attr);
2830         if (!NT_STATUS_IS_OK(status)) {
2831                 printf("ERROR: cli_get_fs_attr_info returned %s\n",
2832                        nt_errstr(status));
2833                 correct = false;
2834         }
2835
2836         cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2837         cli_open(cli, fname, 
2838                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
2839         if (!cli_qfileinfo(cli, fnum, NULL, &size, &c_time_ts, &a_time_ts, &w_time_ts,
2840                            &m_time_ts, NULL)) {
2841                 printf("ERROR: qfileinfo failed (%s)\n", cli_errstr(cli));
2842                 correct = False;
2843         }
2844
2845         if (!cli_qfilename(cli, fnum, pname, sizeof(pname))) {
2846                 printf("ERROR: qfilename failed (%s)\n", cli_errstr(cli));
2847                 correct = False;
2848         }
2849
2850         if (strcmp(pname, fname)) {
2851                 printf("qfilename gave different name? [%s] [%s]\n",
2852                        fname, pname);
2853                 correct = False;
2854         }
2855
2856         cli_close(cli, fnum);
2857
2858         sleep(2);
2859
2860         cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2861         if (!NT_STATUS_IS_OK(cli_open(cli, fname, 
2862                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum))) {
2863                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2864                 return False;
2865         }
2866         cli_close(cli, fnum);
2867
2868         if (!cli_qpathinfo(cli, fname, &c_time, &a_time, &m_time, &size, NULL)) {
2869                 printf("ERROR: qpathinfo failed (%s)\n", cli_errstr(cli));
2870                 correct = False;
2871         } else {
2872                 if (c_time != m_time) {
2873                         printf("create time=%s", ctime(&c_time));
2874                         printf("modify time=%s", ctime(&m_time));
2875                         printf("This system appears to have sticky create times\n");
2876                 }
2877                 if (a_time % (60*60) == 0) {
2878                         printf("access time=%s", ctime(&a_time));
2879                         printf("This system appears to set a midnight access time\n");
2880                         correct = False;
2881                 }
2882
2883                 if (abs(m_time - time(NULL)) > 60*60*24*7) {
2884                         printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
2885                         correct = False;
2886                 }
2887         }
2888
2889
2890         cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2891         cli_open(cli, fname, 
2892                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
2893         cli_close(cli, fnum);
2894         if (!cli_qpathinfo2(cli, fname, &c_time_ts, &a_time_ts, &w_time_ts, 
2895                             &m_time_ts, &size, NULL, NULL)) {
2896                 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2897                 correct = False;
2898         } else {
2899                 if (w_time_ts.tv_sec < 60*60*24*2) {
2900                         printf("write time=%s", ctime(&w_time_ts.tv_sec));
2901                         printf("This system appears to set a initial 0 write time\n");
2902                         correct = False;
2903                 }
2904         }
2905
2906         cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2907
2908
2909         /* check if the server updates the directory modification time
2910            when creating a new file */
2911         if (!NT_STATUS_IS_OK(cli_mkdir(cli, dname))) {
2912                 printf("ERROR: mkdir failed (%s)\n", cli_errstr(cli));
2913                 correct = False;
2914         }
2915         sleep(3);
2916         if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts, &w_time_ts, 
2917                             &m_time_ts, &size, NULL, NULL)) {
2918                 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2919                 correct = False;
2920         }
2921
2922         cli_open(cli, fname2, 
2923                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
2924         cli_write(cli, fnum,  0, (char *)&fnum, 0, sizeof(fnum));
2925         cli_close(cli, fnum);
2926         if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts, &w_time_ts, 
2927                             &m_time2_ts, &size, NULL, NULL)) {
2928                 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2929                 correct = False;
2930         } else {
2931                 if (memcmp(&m_time_ts, &m_time2_ts, sizeof(struct timespec))
2932                     == 0) {
2933                         printf("This system does not update directory modification times\n");
2934                         correct = False;
2935                 }
2936         }
2937         cli_unlink(cli, fname2, aSYSTEM | aHIDDEN);
2938         cli_rmdir(cli, dname);
2939
2940         if (!torture_close_connection(cli)) {
2941                 correct = False;
2942         }
2943
2944         printf("trans2 test finished\n");
2945
2946         return correct;
2947 }
2948
2949 /*
2950   This checks new W2K calls.
2951 */
2952
2953 static bool new_trans(struct cli_state *pcli, int fnum, int level)
2954 {
2955         char *buf = NULL;
2956         uint32 len;
2957         bool correct = True;
2958
2959         if (!cli_qfileinfo_test(pcli, fnum, level, &buf, &len)) {
2960                 printf("ERROR: qfileinfo (%d) failed (%s)\n", level, cli_errstr(pcli));
2961                 correct = False;
2962         } else {
2963                 printf("qfileinfo: level %d, len = %u\n", level, len);
2964                 dump_data(0, (uint8 *)buf, len);
2965                 printf("\n");
2966         }
2967         SAFE_FREE(buf);
2968         return correct;
2969 }
2970
2971 static bool run_w2ktest(int dummy)
2972 {
2973         struct cli_state *cli;
2974         uint16_t fnum;
2975         const char *fname = "\\w2ktest\\w2k.tst";
2976         int level;
2977         bool correct = True;
2978
2979         printf("starting w2k test\n");
2980
2981         if (!torture_open_connection(&cli, 0)) {
2982                 return False;
2983         }
2984
2985         cli_open(cli, fname, 
2986                         O_RDWR | O_CREAT , DENY_NONE, &fnum);
2987
2988         for (level = 1004; level < 1040; level++) {
2989                 new_trans(cli, fnum, level);
2990         }
2991
2992         cli_close(cli, fnum);
2993
2994         if (!torture_close_connection(cli)) {
2995                 correct = False;
2996         }
2997
2998         printf("w2k test finished\n");
2999
3000         return correct;
3001 }
3002
3003
3004 /*
3005   this is a harness for some oplock tests
3006  */
3007 static bool run_oplock1(int dummy)
3008 {
3009         struct cli_state *cli1;
3010         const char *fname = "\\lockt1.lck";
3011         uint16_t fnum1;
3012         bool correct = True;
3013
3014         printf("starting oplock test 1\n");
3015
3016         if (!torture_open_connection(&cli1, 0)) {
3017                 return False;
3018         }
3019
3020         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3021
3022         cli_sockopt(cli1, sockops);
3023
3024         cli1->use_oplocks = True;
3025
3026         if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
3027                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3028                 return False;
3029         }
3030
3031         cli1->use_oplocks = False;
3032
3033         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3034         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3035
3036         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3037                 printf("close2 failed (%s)\n", cli_errstr(cli1));
3038                 return False;
3039         }
3040
3041         if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
3042                 printf("unlink failed (%s)\n", cli_errstr(cli1));
3043                 return False;
3044         }
3045
3046         if (!torture_close_connection(cli1)) {
3047                 correct = False;
3048         }
3049
3050         printf("finished oplock test 1\n");
3051
3052         return correct;
3053 }
3054
3055 static bool run_oplock2(int dummy)
3056 {
3057         struct cli_state *cli1, *cli2;
3058         const char *fname = "\\lockt2.lck";
3059         uint16_t fnum1, fnum2;
3060         int saved_use_oplocks = use_oplocks;
3061         char buf[4];
3062         bool correct = True;
3063         volatile bool *shared_correct;
3064
3065         shared_correct = (volatile bool *)shm_setup(sizeof(bool));
3066         *shared_correct = True;
3067
3068         use_level_II_oplocks = True;
3069         use_oplocks = True;
3070
3071         printf("starting oplock test 2\n");
3072
3073         if (!torture_open_connection(&cli1, 0)) {
3074                 use_level_II_oplocks = False;
3075                 use_oplocks = saved_use_oplocks;
3076                 return False;
3077         }
3078
3079         cli1->use_oplocks = True;
3080         cli1->use_level_II_oplocks = True;
3081
3082         if (!torture_open_connection(&cli2, 1)) {
3083                 use_level_II_oplocks = False;
3084                 use_oplocks = saved_use_oplocks;
3085                 return False;
3086         }
3087
3088         cli2->use_oplocks = True;
3089         cli2->use_level_II_oplocks = True;
3090
3091         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3092
3093         cli_sockopt(cli1, sockops);
3094         cli_sockopt(cli2, sockops);
3095
3096         if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
3097                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3098                 return False;
3099         }
3100
3101         /* Don't need the globals any more. */
3102         use_level_II_oplocks = False;
3103         use_oplocks = saved_use_oplocks;
3104
3105         if (fork() == 0) {
3106                 /* Child code */
3107                 if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2))) {
3108                         printf("second open of %s failed (%s)\n", fname, cli_errstr(cli1));
3109                         *shared_correct = False;
3110                         exit(0);
3111                 }
3112
3113                 sleep(2);
3114
3115                 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
3116                         printf("close2 failed (%s)\n", cli_errstr(cli1));
3117                         *shared_correct = False;
3118                 }
3119
3120                 exit(0);
3121         }
3122
3123         sleep(2);
3124
3125         /* Ensure cli1 processes the break. Empty file should always return 0
3126          * bytes.  */
3127
3128         if (cli_read(cli1, fnum1, buf, 0, 4) != 0) {
3129                 printf("read on fnum1 failed (%s)\n", cli_errstr(cli1));
3130                 correct = False;
3131         }
3132
3133         /* Should now be at level II. */
3134         /* Test if sending a write locks causes a break to none. */
3135
3136         if (!cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK)) {
3137                 printf("lock failed (%s)\n", cli_errstr(cli1));
3138                 correct = False;
3139         }
3140
3141         cli_unlock(cli1, fnum1, 0, 4);
3142
3143         sleep(2);
3144
3145         if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
3146                 printf("lock failed (%s)\n", cli_errstr(cli1));
3147                 correct = False;
3148         }
3149
3150         cli_unlock(cli1, fnum1, 0, 4);
3151
3152         sleep(2);
3153
3154         cli_read(cli1, fnum1, buf, 0, 4);
3155
3156 #if 0
3157         if (cli_write(cli1, fnum1, 0, buf, 0, 4) != 4) {
3158                 printf("write on fnum1 failed (%s)\n", cli_errstr(cli1));
3159                 correct = False;
3160         }
3161 #endif
3162
3163         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3164                 printf("close1 failed (%s)\n", cli_errstr(cli1));
3165                 correct = False;
3166         }
3167
3168         sleep(4);
3169
3170         if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
3171                 printf("unlink failed (%s)\n", cli_errstr(cli1));
3172                 correct = False;
3173         }
3174
3175         if (!torture_close_connection(cli1)) {
3176                 correct = False;
3177         }
3178
3179         if (!*shared_correct) {
3180                 correct = False;
3181         }
3182
3183         printf("finished oplock test 2\n");
3184
3185         return correct;
3186 }
3187
3188 /* handler for oplock 3 tests */
3189 static NTSTATUS oplock3_handler(struct cli_state *cli, uint16_t fnum, unsigned char level)
3190 {
3191         printf("got oplock break fnum=%d level=%d\n",
3192                fnum, level);
3193         return cli_oplock_ack(cli, fnum, level);
3194 }
3195
3196 static bool run_oplock3(int dummy)
3197 {
3198         struct cli_state *cli;
3199         const char *fname = "\\oplockt3.dat";
3200         uint16_t fnum;
3201         char buf[4] = "abcd";
3202         bool correct = True;
3203         volatile bool *shared_correct;
3204
3205         shared_correct = (volatile bool *)shm_setup(sizeof(bool));
3206         *shared_correct = True;
3207
3208         printf("starting oplock test 3\n");
3209
3210         if (fork() == 0) {
3211                 /* Child code */
3212                 use_oplocks = True;
3213                 use_level_II_oplocks = True;
3214                 if (!torture_open_connection(&cli, 0)) {
3215                         *shared_correct = False;
3216                         exit(0);
3217                 } 
3218                 sleep(2);
3219                 /* try to trigger a oplock break in parent */
3220                 cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum);
3221                 cli_write(cli, fnum, 0, buf, 0, 4);
3222                 exit(0);
3223         }
3224
3225         /* parent code */
3226         use_oplocks = True;
3227         use_level_II_oplocks = True;
3228         if (!torture_open_connection(&cli, 1)) { /* other is forked */
3229                 return False;
3230         }
3231         cli_oplock_handler(cli, oplock3_handler);
3232         cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum);
3233         cli_write(cli, fnum, 0, buf, 0, 4);
3234         cli_close(cli, fnum);
3235         cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum);
3236         cli->timeout = 20000;
3237         cli_receive_smb(cli);
3238         printf("finished oplock test 3\n");
3239
3240         return (correct && *shared_correct);
3241
3242 /* What are we looking for here?  What's sucess and what's FAILURE? */
3243 }
3244
3245
3246
3247 /*
3248   Test delete on close semantics.
3249  */
3250 static bool run_deletetest(int dummy)
3251 {
3252         struct cli_state *cli1 = NULL;
3253         struct cli_state *cli2 = NULL;
3254         const char *fname = "\\delete.file";
3255         uint16_t fnum1 = (uint16_t)-1;
3256         uint16_t fnum2 = (uint16_t)-1;
3257         bool correct = True;
3258
3259         printf("starting delete test\n");
3260
3261         if (!torture_open_connection(&cli1, 0)) {
3262                 return False;
3263         }
3264
3265         cli_sockopt(cli1, sockops);
3266
3267         /* Test 1 - this should delete the file on close. */
3268
3269         cli_setatr(cli1, fname, 0, 0);
3270         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3271
3272         if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
3273                                    0, FILE_OVERWRITE_IF, 
3274                                    FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
3275                 printf("[1] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3276                 correct = False;
3277                 goto fail;
3278         }
3279
3280 #if 0 /* JRATEST */
3281         {
3282                 uint32 *accinfo = NULL;
3283                 uint32 len;
3284                 cli_qfileinfo_test(cli1, fnum1, SMB_FILE_ACCESS_INFORMATION, (char **)&accinfo, &len);
3285                 if (accinfo)
3286                         printf("access mode = 0x%lx\n", *accinfo);
3287                 SAFE_FREE(accinfo);
3288         }
3289 #endif
3290
3291         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3292                 printf("[1] close failed (%s)\n", cli_errstr(cli1));
3293                 correct = False;
3294                 goto fail;
3295         }
3296
3297         if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1))) {
3298                 printf("[1] open of %s succeeded (should fail)\n", fname);
3299                 correct = False;
3300                 goto fail;
3301         }
3302
3303         printf("first delete on close test succeeded.\n");
3304
3305         /* Test 2 - this should delete the file on close. */
3306
3307         cli_setatr(cli1, fname, 0, 0);
3308         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3309
3310         if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
3311                                    FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, 
3312                                    FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3313                 printf("[2] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3314                 correct = False;
3315                 goto fail;
3316         }
3317
3318         if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3319                 printf("[2] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3320                 correct = False;
3321                 goto fail;
3322         }
3323
3324         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3325                 printf("[2] close failed (%s)\n", cli_errstr(cli1));
3326                 correct = False;
3327                 goto fail;
3328         }
3329
3330         if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3331                 printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
3332                 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3333                         printf("[2] close failed (%s)\n", cli_errstr(cli1));
3334                         correct = False;
3335                         goto fail;
3336                 }
3337                 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3338         } else
3339                 printf("second delete on close test succeeded.\n");
3340
3341         /* Test 3 - ... */
3342         cli_setatr(cli1, fname, 0, 0);
3343         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3344
3345         if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
3346                                    FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3347                 printf("[3] open - 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3348                 correct = False;
3349                 goto fail;
3350         }
3351
3352         /* This should fail with a sharing violation - open for delete is only compatible
3353            with SHARE_DELETE. */
3354
3355         if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3356                         FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0, 0, &fnum2))) {
3357                 printf("[3] open  - 2 of %s succeeded - should have failed.\n", fname);
3358                 correct = False;
3359                 goto fail;
3360         }
3361
3362         /* This should succeed. */
3363
3364         if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3365                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0, &fnum2))) {
3366                 printf("[3] open  - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3367                 correct = False;
3368                 goto fail;
3369         }
3370
3371         if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3372                 printf("[3] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3373                 correct = False;
3374                 goto fail;
3375         }
3376
3377         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3378                 printf("[3] close 1 failed (%s)\n", cli_errstr(cli1));
3379                 correct = False;
3380                 goto fail;
3381         }
3382
3383         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
3384                 printf("[3] close 2 failed (%s)\n", cli_errstr(cli1));
3385                 correct = False;
3386                 goto fail;
3387         }
3388
3389         /* This should fail - file should no longer be there. */
3390
3391         if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3392                 printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
3393                 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3394                         printf("[3] close failed (%s)\n", cli_errstr(cli1));
3395                 }
3396                 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3397                 correct = False;
3398                 goto fail;
3399         } else
3400                 printf("third delete on close test succeeded.\n");
3401
3402         /* Test 4 ... */
3403         cli_setatr(cli1, fname, 0, 0);
3404         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3405
3406         if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3407                         FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3408                 printf("[4] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3409                 correct = False;
3410                 goto fail;
3411         }
3412
3413         /* This should succeed. */
3414         if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
3415                         FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0, &fnum2))) {
3416                 printf("[4] open  - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3417                 correct = False;
3418                 goto fail;
3419         }
3420
3421         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
3422                 printf("[4] close - 1 failed (%s)\n", cli_errstr(cli1));
3423                 correct = False;
3424                 goto fail;
3425         }
3426
3427         if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3428                 printf("[4] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3429                 correct = False;
3430                 goto fail;
3431         }
3432
3433         /* This should fail - no more opens once delete on close set. */
3434         if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
3435                                    FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3436                                    FILE_OPEN, 0, 0, &fnum2))) {
3437                 printf("[4] open  - 3 of %s succeeded ! Should have failed.\n", fname );
3438                 correct = False;
3439                 goto fail;
3440         } else
3441                 printf("fourth delete on close test succeeded.\n");
3442
3443         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3444                 printf("[4] close - 2 failed (%s)\n", cli_errstr(cli1));
3445                 correct = False;
3446                 goto fail;
3447         }
3448
3449         /* Test 5 ... */
3450         cli_setatr(cli1, fname, 0, 0);
3451         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3452
3453         if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum1))) {
3454                 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3455                 correct = False;
3456                 goto fail;
3457         }
3458
3459         /* This should fail - only allowed on NT opens with DELETE access. */
3460
3461         if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3462                 printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
3463                 correct = False;
3464                 goto fail;
3465         }
3466
3467         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3468                 printf("[5] close - 2 failed (%s)\n", cli_errstr(cli1));
3469                 correct = False;
3470                 goto fail;
3471         }
3472
3473         printf("fifth delete on close test succeeded.\n");
3474
3475         /* Test 6 ... */
3476         cli_setatr(cli1, fname, 0, 0);
3477         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3478
3479         if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
3480                                    FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3481                                    FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3482                 printf("[6] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3483                 correct = False;
3484                 goto fail;
3485         }
3486
3487         /* This should fail - only allowed on NT opens with DELETE access. */
3488
3489         if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3490                 printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
3491                 correct = False;
3492                 goto fail;
3493         }
3494
3495         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3496                 printf("[6] close - 2 failed (%s)\n", cli_errstr(cli1));
3497                 correct = False;
3498                 goto fail;
3499         }
3500
3501         printf("sixth delete on close test succeeded.\n");
3502
3503         /* Test 7 ... */
3504         cli_setatr(cli1, fname, 0, 0);
3505         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3506
3507         if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3508                                    FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3509                 printf("[7] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3510                 correct = False;
3511                 goto fail;
3512         }
3513
3514         if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3515                 printf("[7] setting delete_on_close on file failed !\n");
3516                 correct = False;
3517                 goto fail;
3518         }
3519
3520         if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, false))) {
3521                 printf("[7] unsetting delete_on_close on file failed !\n");
3522                 correct = False;
3523                 goto fail;
3524         }
3525
3526         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3527                 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3528                 correct = False;
3529                 goto fail;
3530         }
3531
3532         /* This next open should succeed - we reset the flag. */
3533
3534         if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3535                 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3536                 correct = False;
3537                 goto fail;
3538         }
3539
3540         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3541                 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3542                 correct = False;
3543                 goto fail;
3544         }
3545
3546         printf("seventh delete on close test succeeded.\n");
3547
3548         /* Test 7 ... */
3549         cli_setatr(cli1, fname, 0, 0);
3550         cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3551
3552         if (!torture_open_connection(&cli2, 1)) {
3553                 printf("[8] failed to open second connection.\n");
3554                 correct = False;
3555                 goto fail;
3556         }
3557
3558         cli_sockopt(cli1, sockops);
3559
3560         if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3561                                    FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3562                                    FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3563                 printf("[8] open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3564                 correct = False;
3565                 goto fail;
3566         }
3567
3568         if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3569                                    FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3570                                    FILE_OPEN, 0, 0, &fnum2))) {
3571                 printf("[8] open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3572                 correct = False;
3573                 goto fail;
3574         }
3575
3576         if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3577                 printf("[8] setting delete_on_close on file failed !\n");
3578                 correct = False;
3579                 goto fail;
3580         }
3581
3582         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3583                 printf("[8] close - 1 failed (%s)\n", cli_errstr(cli1));
3584                 correct = False;
3585                 goto fail;
3586         }
3587
3588         if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
3589                 printf("[8] close - 2 failed (%s)\n", cli_errstr(cli2));
3590                 correct = False;
3591                 goto fail;
3592         }
3593
3594         /* This should fail.. */
3595         if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3596                 printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
3597                 goto fail;
3598                 correct = False;
3599         } else
3600                 printf("eighth delete on close test succeeded.\n");
3601
3602         /* This should fail - we need to set DELETE_ACCESS. */
3603         if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,FILE_READ_DATA|FILE_WRITE_DATA,
3604                                    FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
3605                 printf("[9] open of %s succeeded should have failed!\n", fname);
3606                 correct = False;
3607                 goto fail;
3608         }
3609
3610         printf("ninth delete on close test succeeded.\n");
3611
3612         if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3613       &n