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