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