?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
This changes our handling of invalid service types that the
[Samba/gebeck_regimport.git] / source / torture / torture.c
blobd6ae58c522c0231cb9d27d82a747fe9c8774eef5
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 2 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, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #define NO_SYSLOG
22
23 #include "includes.h"
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 static int procnum; /* records process count number when forking */
32 static struct cli_state *current_cli;
33 static fstring randomfname;
34 static BOOL use_oplocks;
35 static BOOL use_level_II_oplocks;
36 static const char *client_txt = "client_oplocks.txt";
37 static BOOL use_kerberos;
38
39 BOOL torture_showall = False;
40
41 static double create_procs(BOOL (*fn)(int), BOOL *result);
42
43
44 static struct timeval tp1,tp2;
45
46 void start_timer(void)
47 {
48 gettimeofday(&tp1,NULL);
49 }
50
51 double end_timer(void)
52 {
53 gettimeofday(&tp2,NULL);
54 return((tp2.tv_sec - tp1.tv_sec) +
55 (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
56 }
57
58
59 /* return a pointer to a anonymous shared memory segment of size "size"
60 which will persist across fork() but will disappear when all processes
61 exit
62
63 The memory is not zeroed
64
65 This function uses system5 shared memory. It takes advantage of a property
66 that the memory is not destroyed if it is attached when the id is removed
67 */
68 void *shm_setup(int size)
69 {
70 int shmid;
71 void *ret;
72
73 shmid = shmget(IPC_PRIVATE, size, SHM_R | SHM_W);
74 if (shmid == -1) {
75 printf("can't get shared memory\n");
76 exit(1);
77 }
78 ret = (void *)shmat(shmid, 0, 0);
79 if (!ret || ret == (void *)-1) {
80 printf("can't attach to shared memory\n");
81 return NULL;
82 }
83 /* the following releases the ipc, but note that this process
84 and all its children will still have access to the memory, its
85 just that the shmid is no longer valid for other shm calls. This
86 means we don't leave behind lots of shm segments after we exit
87
88 See Stevens "advanced programming in unix env" for details
89 */
90 shmctl(shmid, IPC_RMID, 0);
91
92 return ret;
93 }
94
95
96 static BOOL open_nbt_connection(struct cli_state *c)
97 {
98 struct nmb_name called, calling;
99 struct in_addr ip;
100
101 ZERO_STRUCTP(c);
102
103 make_nmb_name(&calling, myname, 0x0);
104 make_nmb_name(&called , host, 0x20);
105
106 zero_ip(&ip);
107
108 if (!cli_initialise(c)) {
109 printf("Failed initialize cli_struct to connect with %s\n", host);
110 return False;
111 }
112
113 c->port = port_to_use;
114
115 if (!cli_connect(c, host, &ip)) {
116 printf("Failed to connect with %s\n", host);
117 return False;
118 }
119
120 c->use_kerberos = use_kerberos;
121
122 c->timeout = 120000; /* set a really long timeout (2 minutes) */
123 if (use_oplocks) c->use_oplocks = True;
124 if (use_level_II_oplocks) c->use_level_II_oplocks = True;
125
126 if (!cli_session_request(c, &calling, &called)) {
127 /*
128 * Well, that failed, try *SMBSERVER ...
129 * However, we must reconnect as well ...
130 */
131 if (!cli_connect(c, host, &ip)) {
132 printf("Failed to connect with %s\n", host);
133 return False;
134 }
135
136 make_nmb_name(&called, "*SMBSERVER", 0x20);
137 if (!cli_session_request(c, &calling, &called)) {
138 printf("%s rejected the session\n",host);
139 printf("We tried with a called name of %s & %s\n",
140 host, "*SMBSERVER");
141 cli_shutdown(c);
142 return False;
143 }
144 }
145
146 return True;
147 }
148
149 BOOL torture_open_connection(struct cli_state **c)
150 {
151 BOOL retry;
152 int flags = 0;
153 NTSTATUS status;
154
155 if (use_kerberos)
156 flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
157
158 status = cli_full_connection(c, myname,
159 host, NULL, port_to_use,
160 share, "?????",
161 username, workgroup,
162 password, flags, &retry);
163 if (!NT_STATUS_IS_OK(status)) {
164 return False;
165 }
166
167 if (use_oplocks) (*c)->use_oplocks = True;
168 if (use_level_II_oplocks) (*c)->use_level_II_oplocks = True;
169 (*c)->timeout = 120000; /* set a really long timeout (2 minutes) */
170
171 return True;
172 }
173
174
175 BOOL torture_close_connection(struct cli_state *c)
176 {
177 BOOL ret = True;
178 if (!cli_tdis(c)) {
179 printf("tdis failed (%s)\n", cli_errstr(c));
180 ret = False;
181 }
182
183 cli_shutdown(c);
184
185 return ret;
186 }
187
188
189 /* check if the server produced the expected error code */
190 static BOOL check_error(int line, struct cli_state *c,
191 uint8 eclass, uint32 ecode, NTSTATUS nterr)
192 {
193 if (cli_is_dos_error(c)) {
194 uint8 class;
195 uint32 num;
196
197 /* Check DOS error */
198
199 cli_dos_error(c, &class, &num);
200
201 if (eclass != class || ecode != num) {
202 printf("unexpected error code class=%d code=%d\n",
203 (int)class, (int)num);
204 printf(" expected %d/%d %s (line=%d)\n",
205 (int)eclass, (int)ecode, nt_errstr(nterr), line);
206 return False;
207 }
208
209 } else {
210 NTSTATUS status;
211
212 /* Check NT error */
213
214 status = cli_nt_error(c);
215
216 if (NT_STATUS_V(nterr) != NT_STATUS_V(status)) {
217 printf("unexpected error code %s\n", nt_errstr(status));
218 printf(" expected %s (line=%d)\n", nt_errstr(nterr), line);
219 return False;
220 }
221 }
222
223 return True;
224 }
225
226
227 static BOOL wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len)
228 {
229 while (!cli_lock(c, fnum, offset, len, -1, WRITE_LOCK)) {
230 if (!check_error(__LINE__, c, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
231 }
232 return True;
233 }
234
235
236 static BOOL rw_torture(struct cli_state *c)
237 {
238 const char *lockfname = "\\torture.lck";
239 fstring fname;
240 int fnum;
241 int fnum2;
242 pid_t pid2, pid = getpid();
243 int i, j;
244 char buf[1024];
245 BOOL correct = True;
246
247 fnum2 = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
248 DENY_NONE);
249 if (fnum2 == -1)
250 fnum2 = cli_open(c, lockfname, O_RDWR, DENY_NONE);
251 if (fnum2 == -1) {
252 printf("open of %s failed (%s)\n", lockfname, cli_errstr(c));
253 return False;
254 }
255
256
257 for (i=0;i<torture_numops;i++) {
258 unsigned n = (unsigned)sys_random()%10;
259 if (i % 10 == 0) {
260 printf("%d\r", i); fflush(stdout);
261 }
262 slprintf(fname, sizeof(fstring) - 1, "\\torture.%u", n);
263
264 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
265 return False;
266 }
267
268 fnum = cli_open(c, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL);
269 if (fnum == -1) {
270 printf("open failed (%s)\n", cli_errstr(c));
271 correct = False;
272 break;
273 }
274
275 if (cli_write(c, fnum, 0, (char *)&pid, 0, sizeof(pid)) != sizeof(pid)) {
276 printf("write failed (%s)\n", cli_errstr(c));
277 correct = False;
278 }
279
280 for (j=0;j<50;j++) {
281 if (cli_write(c, fnum, 0, (char *)buf,
282 sizeof(pid)+(j*sizeof(buf)),
283 sizeof(buf)) != sizeof(buf)) {
284 printf("write failed (%s)\n", cli_errstr(c));
285 correct = False;
286 }
287 }
288
289 pid2 = 0;
290
291 if (cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid)) != sizeof(pid)) {
292 printf("read failed (%s)\n", cli_errstr(c));
293 correct = False;
294 }
295
296 if (pid2 != pid) {
297 printf("data corruption!\n");
298 correct = False;
299 }
300
301 if (!cli_close(c, fnum)) {
302 printf("close failed (%s)\n", cli_errstr(c));
303 correct = False;
304 }
305
306 if (!cli_unlink(c, fname)) {
307 printf("unlink failed (%s)\n", cli_errstr(c));
308 correct = False;
309 }
310
311 if (!cli_unlock(c, fnum2, n*sizeof(int), sizeof(int))) {
312 printf("unlock failed (%s)\n", cli_errstr(c));
313 correct = False;
314 }
315 }
316
317 cli_close(c, fnum2);
318 cli_unlink(c, lockfname);
319
320 printf("%d\n", i);
321
322 return correct;
323 }
324
325 static BOOL run_torture(int dummy)
326 {
327 struct cli_state *cli;
328 BOOL ret;
329
330 cli = current_cli;
331
332 cli_sockopt(cli, sockops);
333
334 ret = rw_torture(cli);
335
336 if (!torture_close_connection(cli)) {
337 ret = False;
338 }
339
340 return ret;
341 }
342
343 static BOOL rw_torture3(struct cli_state *c, char *lockfname)
344 {
345 int fnum = -1;
346 unsigned int i = 0;
347 char buf[131072];
348 char buf_rd[131072];
349 unsigned count;
350 unsigned countprev = 0;
351 ssize_t sent = 0;
352 BOOL correct = True;
353
354 srandom(1);
355 for (i = 0; i < sizeof(buf); i += sizeof(uint32))
356 {
357 SIVAL(buf, i, sys_random());
358 }
359
360 if (procnum == 0)
361 {
362 fnum = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
363 DENY_NONE);
364 if (fnum == -1) {
365 printf("first open read/write of %s failed (%s)\n",
366 lockfname, cli_errstr(c));
367 return False;
368 }
369 }
370 else
371 {
372 for (i = 0; i < 500 && fnum == -1; i++)
373 {
374 fnum = cli_open(c, lockfname, O_RDONLY,
375 DENY_NONE);
376 msleep(10);
377 }
378 if (fnum == -1) {
379 printf("second open read-only of %s failed (%s)\n",
380 lockfname, cli_errstr(c));
381 return False;
382 }
383 }
384
385 i = 0;
386 for (count = 0; count < sizeof(buf); count += sent)
387 {
388 if (count >= countprev) {
389 printf("%d %8d\r", i, count);
390 fflush(stdout);
391 i++;
392 countprev += (sizeof(buf) / 20);
393 }
394
395 if (procnum == 0)
396 {
397 sent = ((unsigned)sys_random()%(20))+ 1;
398 if (sent > sizeof(buf) - count)
399 {
400 sent = sizeof(buf) - count;
401 }
402
403 if (cli_write(c, fnum, 0, buf+count, count, (size_t)sent) != sent) {
404 printf("write failed (%s)\n", cli_errstr(c));
405 correct = False;
406 }
407 }
408 else
409 {
410 sent = cli_read(c, fnum, buf_rd+count, count,
411 sizeof(buf)-count);
412 if (sent < 0)
413 {
414 printf("read failed offset:%d size:%d (%s)\n",
415 count, sizeof(buf)-count,
416 cli_errstr(c));
417 correct = False;
418 sent = 0;
419 }
420 if (sent > 0)
421 {
422 if (memcmp(buf_rd+count, buf+count, sent) != 0)
423 {
424 printf("read/write compare failed\n");
425 printf("offset: %d req %d recvd %d\n",
426 count, sizeof(buf)-count, sent);
427 correct = False;
428 break;
429 }
430 }
431 }
432
433 }
434
435 if (!cli_close(c, fnum)) {
436 printf("close failed (%s)\n", cli_errstr(c));
437 correct = False;
438 }
439
440 return correct;
441 }
442
443 static BOOL rw_torture2(struct cli_state *c1, struct cli_state *c2)
444 {
445 const char *lockfname = "\\torture2.lck";
446 int fnum1;
447 int fnum2;
448 int i;
449 uchar buf[131072];
450 uchar buf_rd[131072];
451 BOOL correct = True;
452 ssize_t bytes_read;
453
454 if (!cli_unlink(c1, lockfname)) {
455 printf("unlink failed (%s) (normal, this file should not exist)\n", cli_errstr(c1));
456 }
457
458 fnum1 = cli_open(c1, lockfname, O_RDWR | O_CREAT | O_EXCL,
459 DENY_NONE);
460 if (fnum1 == -1) {
461 printf("first open read/write of %s failed (%s)\n",
462 lockfname, cli_errstr(c1));
463 return False;
464 }
465 fnum2 = cli_open(c2, lockfname, O_RDONLY,
466 DENY_NONE);
467 if (fnum2 == -1) {
468 printf("second open read-only of %s failed (%s)\n",
469 lockfname, cli_errstr(c2));
470 cli_close(c1, fnum1);
471 return False;
472 }
473
474 for (i=0;i<torture_numops;i++)
475 {
476 size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
477 if (i % 10 == 0) {
478 printf("%d\r", i); fflush(stdout);
479 }
480
481 generate_random_buffer(buf, buf_size, False);
482
483 if (cli_write(c1, fnum1, 0, buf, 0, buf_size) != buf_size) {
484 printf("write failed (%s)\n", cli_errstr(c1));
485 correct = False;
486 }
487
488 if ((bytes_read = cli_read(c2, fnum2, buf_rd, 0, buf_size)) != buf_size) {
489 printf("read failed (%s)\n", cli_errstr(c2));
490 printf("read %d, expected %d\n", bytes_read, buf_size);
491 correct = False;
492 }
493
494 if (memcmp(buf_rd, buf, buf_size) != 0)
495 {
496 printf("read/write compare failed\n");
497 correct = False;
498 }
499 }
500
501 if (!cli_close(c2, fnum2)) {
502 printf("close failed (%s)\n", cli_errstr(c2));
503 correct = False;
504 }
505 if (!cli_close(c1, fnum1)) {
506 printf("close failed (%s)\n", cli_errstr(c1));
507 correct = False;
508 }
509
510 if (!cli_unlink(c1, lockfname)) {
511 printf("unlink failed (%s)\n", cli_errstr(c1));
512 correct = False;
513 }
514
515 return correct;
516 }
517
518 static BOOL run_readwritetest(int dummy)
519 {
520 static struct cli_state *cli1, *cli2;
521 BOOL test1, test2;
522
523 if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
524 return False;
525 }
526 cli_sockopt(cli1, sockops);
527 cli_sockopt(cli2, sockops);
528
529 printf("starting readwritetest\n");
530
531 test1 = rw_torture2(cli1, cli2);
532 printf("Passed readwritetest v1: %s\n", BOOLSTR(test1));
533
534 test2 = rw_torture2(cli1, cli1);
535 printf("Passed readwritetest v2: %s\n", BOOLSTR(test2));
536
537 if (!torture_close_connection(cli1)) {
538 test1 = False;
539 }
540
541 if (!torture_close_connection(cli2)) {
542 test2 = False;
543 }
544
545 return (test1 && test2);
546 }
547
548 static BOOL run_readwritemulti(int dummy)
549 {
550 struct cli_state *cli;
551 BOOL test;
552
553 cli = current_cli;
554
555 cli_sockopt(&cli, sockops);
556
557 printf("run_readwritemulti: fname %s\n", randomfname);
558 test = rw_torture3(&cli, randomfname);
559
560 if (!torture_close_connection(&cli)) {
561 test = False;
562 }
563
564 return test;
565 }
566
567 static BOOL run_readwritelarge(int dummy)
568 {
569 static struct cli_state *cli1;
570 int fnum1;
571 const char *lockfname = "\\large.dat";
572 size_t fsize;
573 char buf[126*1024];
574 BOOL correct = True;
575
576 if (!torture_open_connection(&cli1)) {
577 return False;
578 }
579 cli_sockopt(cli1, sockops);
580 memset(buf,'\0',sizeof(buf));
581
582 cli1->max_xmit = 128*1024;
583
584 printf("starting readwritelarge\n");
585
586 cli_unlink(cli1, lockfname);
587
588 fnum1 = cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE);
589 if (fnum1 == -1) {
590 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
591 return False;
592 }
593
594 cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf));
595
596 if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
597 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
598 correct = False;
599 }
600
601 if (fsize == sizeof(buf))
602 printf("readwritelarge test 1 succeeded (size = %x)\n", fsize);
603 else {
604 printf("readwritelarge test 1 failed (size = %x)\n", fsize);
605 correct = False;
606 }
607
608 if (!cli_close(cli1, fnum1)) {
609 printf("close failed (%s)\n", cli_errstr(cli1));
610 correct = False;
611 }
612
613 if (!cli_unlink(cli1, lockfname)) {
614 printf("unlink failed (%s)\n", cli_errstr(cli1));
615 correct = False;
616 }
617
618 fnum1 = cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE);
619 if (fnum1 == -1) {
620 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
621 return False;
622 }
623
624 cli1->max_xmit = 4*1024;
625
626 cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf));
627
628 if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
629 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
630 correct = False;
631 }
632
633 if (fsize == sizeof(buf))
634 printf("readwritelarge test 2 succeeded (size = %x)\n", fsize);
635 else {
636 printf("readwritelarge test 2 failed (size = %x)\n", fsize);
637 correct = False;
638 }
639
640 #if 0
641 /* ToDo - set allocation. JRA */
642 if(!cli_set_allocation_size(cli1, fnum1, 0)) {
643 printf("set allocation size to zero failed (%s)\n", cli_errstr(&cli1));
644 return False;
645 }
646 if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
647 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
648 correct = False;
649 }
650 if (fsize != 0)
651 printf("readwritelarge test 3 (truncate test) succeeded (size = %x)\n", fsize);
652 #endif
653
654 if (!cli_close(cli1, fnum1)) {
655 printf("close failed (%s)\n", cli_errstr(cli1));
656 correct = False;
657 }
658
659 if (!torture_close_connection(cli1)) {
660 correct = False;
661 }
662 return correct;
663 }
664
665 int line_count = 0;
666 int nbio_id;
667
668 #define ival(s) strtol(s, NULL, 0)
669
670 /* run a test that simulates an approximate netbench client load */
671 static BOOL run_netbench(int client)
672 {
673 struct cli_state *cli;
674 int i;
675 fstring fname;
676 pstring line;
677 char cname[20];
678 FILE *f;
679 char *params[20];
680 BOOL correct = True;
681
682 cli = current_cli;
683
684 nbio_id = client;
685
686 cli_sockopt(cli, sockops);
687
688 nb_setup(cli);
689
690 slprintf(cname,sizeof(fname), "client%d", client);
691
692 f = fopen(client_txt, "r");
693
694 if (!f) {
695 perror(client_txt);
696 return False;
697 }
698
699 while (fgets(line, sizeof(line)-1, f)) {
700 line_count++;
701
702 line[strlen(line)-1] = 0;
703
704 /* printf("[%d] %s\n", line_count, line); */
705
706 all_string_sub(line,"client1", cname, sizeof(line));
707
708 /* parse the command parameters */
709 params[0] = strtok(line," ");
710 i = 0;
711 while (params[i]) params[++i] = strtok(NULL," ");
712
713 params[i] = "";
714
715 if (i < 2) continue;
716
717 if (!strncmp(params[0],"SMB", 3)) {
718 printf("ERROR: You are using a dbench 1 load file\n");
719 exit(1);
720 }
721
722 if (!strcmp(params[0],"NTCreateX")) {
723 nb_createx(params[1], ival(params[2]), ival(params[3]),
724 ival(params[4]));
725 } else if (!strcmp(params[0],"Close")) {
726 nb_close(ival(params[1]));
727 } else if (!strcmp(params[0],"Rename")) {
728 nb_rename(params[1], params[2]);
729 } else if (!strcmp(params[0],"Unlink")) {
730 nb_unlink(params[1]);
731 } else if (!strcmp(params[0],"Deltree")) {
732 nb_deltree(params[1]);
733 } else if (!strcmp(params[0],"Rmdir")) {
734 nb_rmdir(params[1]);
735 } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
736 nb_qpathinfo(params[1]);
737 } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
738 nb_qfileinfo(ival(params[1]));
739 } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
740 nb_qfsinfo(ival(params[1]));
741 } else if (!strcmp(params[0],"FIND_FIRST")) {
742 nb_findfirst(params[1]);
743 } else if (!strcmp(params[0],"WriteX")) {
744 nb_writex(ival(params[1]),
745 ival(params[2]), ival(params[3]), ival(params[4]));
746 } else if (!strcmp(params[0],"ReadX")) {
747 nb_readx(ival(params[1]),
748 ival(params[2]), ival(params[3]), ival(params[4]));
749 } else if (!strcmp(params[0],"Flush")) {
750 nb_flush(ival(params[1]));
751 } else {
752 printf("Unknown operation %s\n", params[0]);
753 exit(1);
754 }
755 }
756 fclose(f);
757
758 nb_cleanup();
759
760 if (!torture_close_connection(cli)) {
761 correct = False;
762 }
763
764 return correct;
765 }
766
767
768 /* run a test that simulates an approximate netbench client load */
769 static BOOL run_nbench(int dummy)
770 {
771 double t;
772 BOOL correct = True;
773
774 nbio_shmem(nprocs);
775
776 nbio_id = -1;
777
778 signal(SIGALRM, nb_alarm);
779 alarm(1);
780 t = create_procs(run_netbench, &correct);
781 alarm(0);
782
783 printf("\nThroughput %g MB/sec\n",
784 1.0e-6 * nbio_total() / t);
785 return correct;
786 }
787
788
789 /*
790 This test checks for two things:
791
792 1) correct support for retaining locks over a close (ie. the server
793 must not use posix semantics)
794 2) support for lock timeouts
795 */
796 static BOOL run_locktest1(int dummy)
797 {
798 struct cli_state *cli1, *cli2;
799 const char *fname = "\\lockt1.lck";
800 int fnum1, fnum2, fnum3;
801 time_t t1, t2;
802 unsigned lock_timeout;
803
804 if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
805 return False;
806 }
807 cli_sockopt(cli1, sockops);
808 cli_sockopt(cli2, sockops);
809
810 printf("starting locktest1\n");
811
812 cli_unlink(cli1, fname);
813
814 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
815 if (fnum1 == -1) {
816 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
817 return False;
818 }
819 fnum2 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
820 if (fnum2 == -1) {
821 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli1));
822 return False;
823 }
824 fnum3 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
825 if (fnum3 == -1) {
826 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli2));
827 return False;
828 }
829
830 if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
831 printf("lock1 failed (%s)\n", cli_errstr(cli1));
832 return False;
833 }
834
835
836 if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
837 printf("lock2 succeeded! This is a locking bug\n");
838 return False;
839 } else {
840 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
841 NT_STATUS_LOCK_NOT_GRANTED)) return False;
842 }
843
844
845 lock_timeout = (1 + (random() % 20));
846 printf("Testing lock timeout with timeout=%u\n", lock_timeout);
847 t1 = time(NULL);
848 if (cli_lock(cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK)) {
849 printf("lock3 succeeded! This is a locking bug\n");
850 return False;
851 } else {
852 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
853 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
854 }
855 t2 = time(NULL);
856
857 if (t2 - t1 < 5) {
858 printf("error: This server appears not to support timed lock requests\n");
859 }
860 printf("server slept for %u seconds for a %u second timeout\n",
861 (unsigned int)(t2-t1), lock_timeout);
862
863 if (!cli_close(cli1, fnum2)) {
864 printf("close1 failed (%s)\n", cli_errstr(cli1));
865 return False;
866 }
867
868 if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
869 printf("lock4 succeeded! This is a locking bug\n");
870 return False;
871 } else {
872 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
873 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
874 }
875
876 if (!cli_close(cli1, fnum1)) {
877 printf("close2 failed (%s)\n", cli_errstr(cli1));
878 return False;
879 }
880
881 if (!cli_close(cli2, fnum3)) {
882 printf("close3 failed (%s)\n", cli_errstr(cli2));
883 return False;
884 }
885
886 if (!cli_unlink(cli1, fname)) {
887 printf("unlink failed (%s)\n", cli_errstr(cli1));
888 return False;
889 }
890
891
892 if (!torture_close_connection(cli1)) {
893 return False;
894 }
895
896 if (!torture_close_connection(cli2)) {
897 return False;
898 }
899
900 printf("Passed locktest1\n");
901 return True;
902 }
903
904 /*
905 this checks to see if a secondary tconx can use open files from an
906 earlier tconx
907 */
908 static BOOL run_tcon_test(int dummy)
909 {
910 static struct cli_state *cli;
911 const char *fname = "\\tcontest.tmp";
912 int fnum1;
913 uint16 cnum1, cnum2, cnum3;
914 uint16 vuid1, vuid2;
915 char buf[4];
916 BOOL ret = True;
917
918 if (!torture_open_connection(&cli)) {
919 return False;
920 }
921 cli_sockopt(cli, sockops);
922
923 printf("starting tcontest\n");
924
925 cli_unlink(cli, fname);
926
927 fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
928 if (fnum1 == -1) {
929 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
930 return False;
931 }
932
933 cnum1 = cli->cnum;
934 vuid1 = cli->vuid;
935
936 if (cli_write(cli, fnum1, 0, buf, 130, 4) != 4) {
937 printf("initial write failed (%s)", cli_errstr(cli));
938 return False;
939 }
940
941 if (!cli_send_tconX(cli, share, "?????",
942 password, strlen(password)+1)) {
943 printf("%s refused 2nd tree connect (%s)\n", host,
944 cli_errstr(cli));
945 cli_shutdown(cli);
946 return False;
947 }
948
949 cnum2 = cli->cnum;
950 cnum3 = MAX(cnum1, cnum2) + 1; /* any invalid number */
951 vuid2 = cli->vuid + 1;
952
953 /* try a write with the wrong tid */
954 cli->cnum = cnum2;
955
956 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
957 printf("server allows write with wrong TID\n");
958 } else {
959 printf("* server fails write with wrong TID : %s\n", cli_errstr(cli));
960 ret = False;
961 }
962
963
964 /* try a write with an invalid tid */
965 cli->cnum = cnum3;
966
967 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
968 printf("server allows write with invalid TID\n");
969 } else {
970 printf("* server fails write with invalid TID : %s\n", cli_errstr(cli));
971 ret = False;
972 }
973
974 /* try a write with an invalid vuid */
975 cli->vuid = vuid2;
976 cli->cnum = cnum1;
977
978 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
979 printf("server allows write with invalid VUID\n");
980 } else {
981 printf("* server fails write with invalid VUID : %s\n", cli_errstr(cli));
982 ret = False;
983 }
984
985 cli->cnum = cnum1;
986 cli->vuid = vuid1;
987
988 if (!cli_close(cli, fnum1)) {
989 printf("close failed (%s)\n", cli_errstr(cli));
990 return False;
991 }
992
993 cli->cnum = cnum2;
994
995 if (!cli_tdis(cli)) {
996 printf("secondary tdis failed (%s)\n", cli_errstr(cli));
997 return False;
998 }
999
1000 cli->cnum = cnum1;
1001
1002 if (!torture_close_connection(cli)) {
1003 return False;
1004 }
1005
1006 return ret;
1007 }
1008
1009
1010 /*
1011 checks for old style tcon support
1012 */
1013 static BOOL run_tcon2_test(int dummy)
1014 {
1015 static struct cli_state *cli;
1016 uint16 cnum, max_xmit;
1017 char *service;
1018 NTSTATUS status;
1019
1020 if (!torture_open_connection(&cli)) {
1021 return False;
1022 }
1023 cli_sockopt(cli, sockops);
1024
1025 printf("starting tcon2 test\n");
1026
1027 asprintf(&service, "\\\\%s\\%s", host, share);
1028
1029 status = cli_raw_tcon(cli, service, password, "?????", &max_xmit, &cnum);
1030
1031 if (!NT_STATUS_IS_OK(status)) {
1032 printf("tcon2 failed : %s\n", cli_errstr(cli));
1033 } else {
1034 printf("tcon OK : max_xmit=%d cnum=%d tid=%d\n",
1035 (int)max_xmit, (int)cnum, SVAL(cli->inbuf, smb_tid));
1036 }
1037
1038 if (!torture_close_connection(cli)) {
1039 return False;
1040 }
1041
1042 printf("Passed tcon2 test\n");
1043 return True;
1044 }
1045
1046 static BOOL tcon_devtest(struct cli_state *cli,
1047 const char *myshare, const char *devtype,
1048 NTSTATUS expected_error)
1049 {
1050 BOOL status;
1051 BOOL ret;
1052
1053 status = cli_send_tconX(cli, myshare, devtype,
1054 password, strlen(password)+1);
1055
1056 if (NT_STATUS_IS_OK(expected_error)) {
1057 if (status) {
1058 ret = True;
1059 } else {
1060 printf("tconX to share %s with type %s "
1061 "should have succeeded but failed\n",
1062 myshare, devtype);
1063 ret = False;
1064 }
1065 cli_tdis(cli);
1066 } else {
1067 if (status) {
1068 printf("tconx to share %s with type %s "
1069 "should have failed but succeeded\n",
1070 myshare, devtype);
1071 ret = False;
1072 } else {
1073 if (NT_STATUS_EQUAL(cli_nt_error(cli),
1074 expected_error)) {
1075 ret = True;
1076 } else {
1077 printf("Returned unexpected error\n");
1078 ret = False;
1079 }
1080 }
1081 }
1082 return ret;
1083 }
1084
1085 /*
1086 checks for correct tconX support
1087 */
1088 static BOOL run_tcon_devtype_test(int dummy)
1089 {
1090 static struct cli_state *cli1 = NULL;
1091 BOOL retry;
1092 int flags = 0;
1093 NTSTATUS status;
1094 BOOL ret;
1095
1096 status = cli_full_connection(&cli1, myname,
1097 host, NULL, port_to_use,
1098 NULL, NULL,
1099 username, workgroup,
1100 password, flags, &retry);
1101
1102 if (!NT_STATUS_IS_OK(status)) {
1103 printf("could not open connection\n");
1104 return False;
1105 }
1106
1107 if (!tcon_devtest(cli1, "IPC$", "A:", NT_STATUS_BAD_DEVICE_TYPE))
1108 ret = False;
1109
1110 if (!tcon_devtest(cli1, "IPC$", "?????", NT_STATUS_OK))
1111 ret = False;
1112
1113 if (!tcon_devtest(cli1, "IPC$", "LPT:", NT_STATUS_BAD_DEVICE_TYPE))
1114 ret = False;
1115
1116 if (!tcon_devtest(cli1, "IPC$", "IPC", NT_STATUS_OK))
1117 ret = False;
1118
1119 if (!tcon_devtest(cli1, "IPC$", "FOOBA", NT_STATUS_BAD_DEVICE_TYPE))
1120 ret = False;
1121
1122 if (!tcon_devtest(cli1, share, "A:", NT_STATUS_OK))
1123 ret = False;
1124
1125 if (!tcon_devtest(cli1, share, "?????", NT_STATUS_OK))
1126 ret = False;
1127
1128 if (!tcon_devtest(cli1, share, "LPT:", NT_STATUS_BAD_DEVICE_TYPE))
1129 ret = False;
1130
1131 if (!tcon_devtest(cli1, share, "IPC", NT_STATUS_BAD_DEVICE_TYPE))
1132 ret = False;
1133
1134 if (!tcon_devtest(cli1, share, "FOOBA", NT_STATUS_BAD_DEVICE_TYPE))
1135 ret = False;
1136
1137 cli_shutdown(cli1);
1138
1139 if (ret)
1140 printf("Passed tcondevtest\n");
1141
1142 return ret;
1143 }
1144
1145
1146 /*
1147 This test checks that
1148
1149 1) the server supports multiple locking contexts on the one SMB
1150 connection, distinguished by PID.
1151
1152 2) the server correctly fails overlapping locks made by the same PID (this
1153 goes against POSIX behaviour, which is why it is tricky to implement)
1154
1155 3) the server denies unlock requests by an incorrect client PID
1156 */
1157 static BOOL run_locktest2(int dummy)
1158 {
1159 static struct cli_state *cli;
1160 const char *fname = "\\lockt2.lck";
1161 int fnum1, fnum2, fnum3;
1162 BOOL correct = True;
1163
1164 if (!torture_open_connection(&cli)) {
1165 return False;
1166 }
1167
1168 cli_sockopt(cli, sockops);
1169
1170 printf("starting locktest2\n");
1171
1172 cli_unlink(cli, fname);
1173
1174 cli_setpid(cli, 1);
1175
1176 fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1177 if (fnum1 == -1) {
1178 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1179 return False;
1180 }
1181
1182 fnum2 = cli_open(cli, fname, O_RDWR, DENY_NONE);
1183 if (fnum2 == -1) {
1184 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli));
1185 return False;
1186 }
1187
1188 cli_setpid(cli, 2);
1189
1190 fnum3 = cli_open(cli, fname, O_RDWR, DENY_NONE);
1191 if (fnum3 == -1) {
1192 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli));
1193 return False;
1194 }
1195
1196 cli_setpid(cli, 1);
1197
1198 if (!cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1199 printf("lock1 failed (%s)\n", cli_errstr(cli));
1200 return False;
1201 }
1202
1203 if (cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1204 printf("WRITE lock1 succeeded! This is a locking bug\n");
1205 correct = False;
1206 } else {
1207 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1208 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1209 }
1210
1211 if (cli_lock(cli, fnum2, 0, 4, 0, WRITE_LOCK)) {
1212 printf("WRITE lock2 succeeded! This is a locking bug\n");
1213 correct = False;
1214 } else {
1215 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1216 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1217 }
1218
1219 if (cli_lock(cli, fnum2, 0, 4, 0, READ_LOCK)) {
1220 printf("READ lock2 succeeded! This is a locking bug\n");
1221 correct = False;
1222 } else {
1223 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1224 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1225 }
1226
1227 if (!cli_lock(cli, fnum1, 100, 4, 0, WRITE_LOCK)) {
1228 printf("lock at 100 failed (%s)\n", cli_errstr(cli));
1229 }
1230 cli_setpid(cli, 2);
1231 if (cli_unlock(cli, fnum1, 100, 4)) {
1232 printf("unlock at 100 succeeded! This is a locking bug\n");
1233 correct = False;
1234 }
1235
1236 if (cli_unlock(cli, fnum1, 0, 4)) {
1237 printf("unlock1 succeeded! This is a locking bug\n");
1238 correct = False;
1239 } else {
1240 if (!check_error(__LINE__, cli,
1241 ERRDOS, ERRlock,
1242 NT_STATUS_RANGE_NOT_LOCKED)) return False;
1243 }
1244
1245 if (cli_unlock(cli, fnum1, 0, 8)) {
1246 printf("unlock2 succeeded! This is a locking bug\n");
1247 correct = False;
1248 } else {
1249 if (!check_error(__LINE__, cli,
1250 ERRDOS, ERRlock,
1251 NT_STATUS_RANGE_NOT_LOCKED)) return False;
1252 }
1253
1254 if (cli_lock(cli, fnum3, 0, 4, 0, WRITE_LOCK)) {
1255 printf("lock3 succeeded! This is a locking bug\n");
1256 correct = False;
1257 } else {
1258 if (!check_error(__LINE__, cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
1259 }
1260
1261 cli_setpid(cli, 1);
1262
1263 if (!cli_close(cli, fnum1)) {
1264 printf("close1 failed (%s)\n", cli_errstr(cli));
1265 return False;
1266 }
1267
1268 if (!cli_close(cli, fnum2)) {
1269 printf("close2 failed (%s)\n", cli_errstr(cli));
1270 return False;
1271 }
1272
1273 if (!cli_close(cli, fnum3)) {
1274 printf("close3 failed (%s)\n", cli_errstr(cli));
1275 return False;
1276 }
1277
1278 if (!torture_close_connection(cli)) {
1279 correct = False;
1280 }
1281
1282 printf("locktest2 finished\n");
1283
1284 return correct;
1285 }
1286
1287
1288 /*
1289 This test checks that
1290
1291 1) the server supports the full offset range in lock requests
1292 */
1293 static BOOL run_locktest3(int dummy)
1294 {
1295 static struct cli_state *cli1, *cli2;
1296 const char *fname = "\\lockt3.lck";
1297 int fnum1, fnum2, i;
1298 uint32 offset;
1299 BOOL correct = True;
1300
1301 #define NEXT_OFFSET offset += (~(uint32)0) / torture_numops
1302
1303 if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
1304 return False;
1305 }
1306 cli_sockopt(cli1, sockops);
1307 cli_sockopt(cli2, sockops);
1308
1309 printf("starting locktest3\n");
1310
1311 cli_unlink(cli1, fname);
1312
1313 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1314 if (fnum1 == -1) {
1315 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1316 return False;
1317 }
1318 fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1319 if (fnum2 == -1) {
1320 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli2));
1321 return False;
1322 }
1323
1324 for (offset=i=0;i<torture_numops;i++) {
1325 NEXT_OFFSET;
1326 if (!cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1327 printf("lock1 %d failed (%s)\n",
1328 i,
1329 cli_errstr(cli1));
1330 return False;
1331 }
1332
1333 if (!cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1334 printf("lock2 %d failed (%s)\n",
1335 i,
1336 cli_errstr(cli1));
1337 return False;
1338 }
1339 }
1340
1341 for (offset=i=0;i<torture_numops;i++) {
1342 NEXT_OFFSET;
1343
1344 if (cli_lock(cli1, fnum1, offset-2, 1, 0, WRITE_LOCK)) {
1345 printf("error: lock1 %d succeeded!\n", i);
1346 return False;
1347 }
1348
1349 if (cli_lock(cli2, fnum2, offset-1, 1, 0, WRITE_LOCK)) {
1350 printf("error: lock2 %d succeeded!\n", i);
1351 return False;
1352 }
1353
1354 if (cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1355 printf("error: lock3 %d succeeded!\n", i);
1356 return False;
1357 }
1358
1359 if (cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1360 printf("error: lock4 %d succeeded!\n", i);
1361 return False;
1362 }
1363 }
1364
1365 for (offset=i=0;i<torture_numops;i++) {
1366 NEXT_OFFSET;
1367
1368 if (!cli_unlock(cli1, fnum1, offset-1, 1)) {
1369 printf("unlock1 %d failed (%s)\n",
1370 i,
1371 cli_errstr(cli1));
1372 return False;
1373 }
1374
1375 if (!cli_unlock(cli2, fnum2, offset-2, 1)) {
1376 printf("unlock2 %d failed (%s)\n",
1377 i,
1378 cli_errstr(cli1));
1379 return False;
1380 }
1381 }
1382
1383 if (!cli_close(cli1, fnum1)) {
1384 printf("close1 failed (%s)\n", cli_errstr(cli1));
1385 return False;
1386 }
1387
1388 if (!cli_close(cli2, fnum2)) {
1389 printf("close2 failed (%s)\n", cli_errstr(cli2));
1390 return False;
1391 }
1392
1393 if (!cli_unlink(cli1, fname)) {
1394 printf("unlink failed (%s)\n", cli_errstr(cli1));
1395 return False;
1396 }
1397
1398 if (!torture_close_connection(cli1)) {
1399 correct = False;
1400 }
1401
1402 if (!torture_close_connection(cli2)) {
1403 correct = False;
1404 }
1405
1406 printf("finished locktest3\n");
1407
1408 return correct;
1409 }
1410
1411 #define EXPECTED(ret, v) if ((ret) != (v)) { \
1412 printf("** "); correct = False; \
1413 }
1414
1415 /*
1416 looks at overlapping locks
1417 */
1418 static BOOL run_locktest4(int dummy)
1419 {
1420 static struct cli_state *cli1, *cli2;
1421 const char *fname = "\\lockt4.lck";
1422 int fnum1, fnum2, f;
1423 BOOL ret;
1424 char buf[1000];
1425 BOOL correct = True;
1426
1427 if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
1428 return False;
1429 }
1430
1431 cli_sockopt(cli1, sockops);
1432 cli_sockopt(cli2, sockops);
1433
1434 printf("starting locktest4\n");
1435
1436 cli_unlink(cli1, fname);
1437
1438 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1439 fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1440
1441 memset(buf, 0, sizeof(buf));
1442
1443 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1444 printf("Failed to create file\n");
1445 correct = False;
1446 goto fail;
1447 }
1448
1449 ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1450 cli_lock(cli1, fnum1, 2, 4, 0, WRITE_LOCK);
1451 EXPECTED(ret, False);
1452 printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
1453
1454 ret = cli_lock(cli1, fnum1, 10, 4, 0, READ_LOCK) &&
1455 cli_lock(cli1, fnum1, 12, 4, 0, READ_LOCK);
1456 EXPECTED(ret, True);
1457 printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
1458
1459 ret = cli_lock(cli1, fnum1, 20, 4, 0, WRITE_LOCK) &&
1460 cli_lock(cli2, fnum2, 22, 4, 0, WRITE_LOCK);
1461 EXPECTED(ret, False);
1462 printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
1463
1464 ret = cli_lock(cli1, fnum1, 30, 4, 0, READ_LOCK) &&
1465 cli_lock(cli2, fnum2, 32, 4, 0, READ_LOCK);
1466 EXPECTED(ret, True);
1467 printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
1468
1469 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 40, 4, 0, WRITE_LOCK)) &&
1470 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 42, 4, 0, WRITE_LOCK));
1471 EXPECTED(ret, False);
1472 printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
1473
1474 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 50, 4, 0, READ_LOCK)) &&
1475 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 52, 4, 0, READ_LOCK));
1476 EXPECTED(ret, True);
1477 printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
1478
1479 ret = cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK) &&
1480 cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK);
1481 EXPECTED(ret, True);
1482 printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
1483
1484 ret = cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK) &&
1485 cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK);
1486 EXPECTED(ret, False);
1487 printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
1488
1489 ret = cli_lock(cli1, fnum1, 80, 4, 0, READ_LOCK) &&
1490 cli_lock(cli1, fnum1, 80, 4, 0, WRITE_LOCK);
1491 EXPECTED(ret, False);
1492 printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
1493
1494 ret = cli_lock(cli1, fnum1, 90, 4, 0, WRITE_LOCK) &&
1495 cli_lock(cli1, fnum1, 90, 4, 0, READ_LOCK);
1496 EXPECTED(ret, True);
1497 printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1498
1499 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 100, 4, 0, WRITE_LOCK)) &&
1500 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 100, 4, 0, READ_LOCK));
1501 EXPECTED(ret, False);
1502 printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1503
1504 ret = cli_lock(cli1, fnum1, 110, 4, 0, READ_LOCK) &&
1505 cli_lock(cli1, fnum1, 112, 4, 0, READ_LOCK) &&
1506 cli_unlock(cli1, fnum1, 110, 6);
1507 EXPECTED(ret, False);
1508 printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
1509
1510
1511 ret = cli_lock(cli1, fnum1, 120, 4, 0, WRITE_LOCK) &&
1512 (cli_read(cli2, fnum2, buf, 120, 4) == 4);
1513 EXPECTED(ret, False);
1514 printf("this server %s strict write locking\n", ret?"doesn't do":"does");
1515
1516 ret = cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK) &&
1517 (cli_write(cli2, fnum2, 0, buf, 130, 4) == 4);
1518 EXPECTED(ret, False);
1519 printf("this server %s strict read locking\n", ret?"doesn't do":"does");
1520
1521
1522 ret = cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1523 cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1524 cli_unlock(cli1, fnum1, 140, 4) &&
1525 cli_unlock(cli1, fnum1, 140, 4);
1526 EXPECTED(ret, True);
1527 printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
1528
1529
1530 ret = cli_lock(cli1, fnum1, 150, 4, 0, WRITE_LOCK) &&
1531 cli_lock(cli1, fnum1, 150, 4, 0, READ_LOCK) &&
1532 cli_unlock(cli1, fnum1, 150, 4) &&
1533 (cli_read(cli2, fnum2, buf, 150, 4) == 4) &&
1534 !(cli_write(cli2, fnum2, 0, buf, 150, 4) == 4) &&
1535 cli_unlock(cli1, fnum1, 150, 4);
1536 EXPECTED(ret, True);
1537 printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
1538
1539 ret = cli_lock(cli1, fnum1, 160, 4, 0, READ_LOCK) &&
1540 cli_unlock(cli1, fnum1, 160, 4) &&
1541 (cli_write(cli2, fnum2, 0, buf, 160, 4) == 4) &&
1542 (cli_read(cli2, fnum2, buf, 160, 4) == 4);
1543 EXPECTED(ret, True);
1544 printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
1545
1546 ret = cli_lock(cli1, fnum1, 170, 4, 0, WRITE_LOCK) &&
1547 cli_unlock(cli1, fnum1, 170, 4) &&
1548 (cli_write(cli2, fnum2, 0, buf, 170, 4) == 4) &&
1549 (cli_read(cli2, fnum2, buf, 170, 4) == 4);
1550 EXPECTED(ret, True);
1551 printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
1552
1553 ret = cli_lock(cli1, fnum1, 190, 4, 0, WRITE_LOCK) &&
1554 cli_lock(cli1, fnum1, 190, 4, 0, READ_LOCK) &&
1555 cli_unlock(cli1, fnum1, 190, 4) &&
1556 !(cli_write(cli2, fnum2, 0, buf, 190, 4) == 4) &&
1557 (cli_read(cli2, fnum2, buf, 190, 4) == 4);
1558 EXPECTED(ret, True);
1559 printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
1560
1561 cli_close(cli1, fnum1);
1562 cli_close(cli2, fnum2);
1563 fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1564 f = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1565 ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1566 cli_lock(cli1, f, 0, 1, 0, READ_LOCK) &&
1567 cli_close(cli1, fnum1) &&
1568 ((fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE)) != -1) &&
1569 cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1570 cli_close(cli1, f);
1571 cli_close(cli1, fnum1);
1572 EXPECTED(ret, True);
1573 printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
1574
1575 fail:
1576 cli_close(cli1, fnum1);
1577 cli_close(cli2, fnum2);
1578 cli_unlink(cli1, fname);
1579 torture_close_connection(cli1);
1580 torture_close_connection(cli2);
1581
1582 printf("finished locktest4\n");
1583 return correct;
1584 }
1585
1586 /*
1587 looks at lock upgrade/downgrade.
1588 */
1589 static BOOL run_locktest5(int dummy)
1590 {
1591 static struct cli_state *cli1, *cli2;
1592 const char *fname = "\\lockt5.lck";
1593 int fnum1, fnum2, fnum3;
1594 BOOL ret;
1595 char buf[1000];
1596 BOOL correct = True;
1597
1598 if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
1599 return False;
1600 }
1601
1602 cli_sockopt(cli1, sockops);
1603 cli_sockopt(cli2, sockops);
1604
1605 printf("starting locktest5\n");
1606
1607 cli_unlink(cli1, fname);
1608
1609 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1610 fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1611 fnum3 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1612
1613 memset(buf, 0, sizeof(buf));
1614
1615 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1616 printf("Failed to create file\n");
1617 correct = False;
1618 goto fail;
1619 }
1620
1621 /* Check for NT bug... */
1622 ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1623 cli_lock(cli1, fnum3, 0, 1, 0, READ_LOCK);
1624 cli_close(cli1, fnum1);
1625 fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1626 ret = cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1627 EXPECTED(ret, True);
1628 printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
1629 cli_close(cli1, fnum1);
1630 fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1631 cli_unlock(cli1, fnum3, 0, 1);
1632
1633 ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1634 cli_lock(cli1, fnum1, 1, 1, 0, READ_LOCK);
1635 EXPECTED(ret, True);
1636 printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
1637
1638 ret = cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1639 EXPECTED(ret, False);
1640
1641 printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
1642
1643 /* Unlock the process 2 lock. */
1644 cli_unlock(cli2, fnum2, 0, 4);
1645
1646 ret = cli_lock(cli1, fnum3, 0, 4, 0, READ_LOCK);
1647 EXPECTED(ret, False);
1648
1649 printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
1650
1651 /* Unlock the process 1 fnum3 lock. */
1652 cli_unlock(cli1, fnum3, 0, 4);
1653
1654 /* Stack 2 more locks here. */
1655 ret = cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK) &&
1656 cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK);
1657
1658 EXPECTED(ret, True);
1659 printf("the same process %s stack read locks\n", ret?"can":"cannot");
1660
1661 /* Unlock the first process lock, then check this was the WRITE lock that was
1662 removed. */
1663
1664 ret = cli_unlock(cli1, fnum1, 0, 4) &&
1665 cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1666
1667 EXPECTED(ret, True);
1668 printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
1669
1670 /* Unlock the process 2 lock. */
1671 cli_unlock(cli2, fnum2, 0, 4);
1672
1673 /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
1674
1675 ret = cli_unlock(cli1, fnum1, 1, 1) &&
1676 cli_unlock(cli1, fnum1, 0, 4) &&
1677 cli_unlock(cli1, fnum1, 0, 4);
1678
1679 EXPECTED(ret, True);
1680 printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
1681
1682 /* Ensure the next unlock fails. */
1683 ret = cli_unlock(cli1, fnum1, 0, 4);
1684 EXPECTED(ret, False);
1685 printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
1686
1687 /* Ensure connection 2 can get a write lock. */
1688 ret = cli_lock(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
1689 EXPECTED(ret, True);
1690
1691 printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
1692
1693
1694 fail:
1695 cli_close(cli1, fnum1);
1696 cli_close(cli2, fnum2);
1697 cli_unlink(cli1, fname);
1698 if (!torture_close_connection(cli1)) {
1699 correct = False;
1700 }
1701 if (!torture_close_connection(cli2)) {
1702 correct = False;
1703 }
1704
1705 printf("finished locktest5\n");
1706
1707 return correct;
1708 }
1709
1710 /*
1711 tries the unusual lockingX locktype bits
1712 */
1713 static BOOL run_locktest6(int dummy)
1714 {
1715 static struct cli_state *cli;
1716 const char *fname[1] = { "\\lock6.txt" };
1717 int i;
1718 int fnum;
1719 NTSTATUS status;
1720
1721 if (!torture_open_connection(&cli)) {
1722 return False;
1723 }
1724
1725 cli_sockopt(cli, sockops);
1726
1727 printf("starting locktest6\n");
1728
1729 for (i=0;i<1;i++) {
1730 printf("Testing %s\n", fname[i]);
1731
1732 cli_unlink(cli, fname[i]);
1733
1734 fnum = cli_open(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1735 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
1736 cli_close(cli, fnum);
1737 printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
1738
1739 fnum = cli_open(cli, fname[i], O_RDWR, DENY_NONE);
1740 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
1741 cli_close(cli, fnum);
1742 printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
1743
1744 cli_unlink(cli, fname[i]);
1745 }
1746
1747 torture_close_connection(cli);
1748
1749 printf("finished locktest6\n");
1750 return True;
1751 }
1752
1753 static BOOL run_locktest7(int dummy)
1754 {
1755 struct cli_state *cli1;
1756 const char *fname = "\\lockt7.lck";
1757 int fnum1;
1758 char buf[200];
1759 BOOL correct = False;
1760
1761 if (!torture_open_connection(&cli1)) {
1762 return False;
1763 }
1764
1765 cli_sockopt(cli1, sockops);
1766
1767 printf("starting locktest7\n");
1768
1769 cli_unlink(cli1, fname);
1770
1771 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1772
1773 memset(buf, 0, sizeof(buf));
1774
1775 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1776 printf("Failed to create file\n");
1777 goto fail;
1778 }
1779
1780 cli_setpid(cli1, 1);
1781
1782 if (!cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK)) {
1783 printf("Unable to apply read lock on range 130:4, error was %s\n", cli_errstr(cli1));
1784 goto fail;
1785 } else {
1786 printf("pid1 successfully locked range 130:4 for READ\n");
1787 }
1788
1789 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
1790 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
1791 goto fail;
1792 } else {
1793 printf("pid1 successfully read the range 130:4\n");
1794 }
1795
1796 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
1797 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
1798 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
1799 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
1800 goto fail;
1801 }
1802 } else {
1803 printf("pid1 successfully wrote to the range 130:4 (should be denied)\n");
1804 goto fail;
1805 }
1806
1807 cli_setpid(cli1, 2);
1808
1809 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
1810 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
1811 } else {
1812 printf("pid2 successfully read the range 130:4\n");
1813 }
1814
1815 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
1816 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
1817 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
1818 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
1819 goto fail;
1820 }
1821 } else {
1822 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
1823 goto fail;
1824 }
1825
1826 cli_setpid(cli1, 1);
1827 cli_unlock(cli1, fnum1, 130, 4);
1828
1829 if (!cli_lock(cli1, fnum1, 130, 4, 0, WRITE_LOCK)) {
1830 printf("Unable to apply write lock on range 130:4, error was %s\n", cli_errstr(cli1));
1831 goto fail;
1832 } else {
1833 printf("pid1 successfully locked range 130:4 for WRITE\n");
1834 }
1835
1836 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
1837 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
1838 goto fail;
1839 } else {
1840 printf("pid1 successfully read the range 130:4\n");
1841 }
1842
1843 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
1844 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
1845 goto fail;
1846 } else {
1847 printf("pid1 successfully wrote to the range 130:4\n");
1848 }
1849
1850 cli_setpid(cli1, 2);
1851
1852 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
1853 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
1854 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
1855 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
1856 goto fail;
1857 }
1858 } else {
1859 printf("pid2 successfully read the range 130:4 (should be denied)\n");
1860 goto fail;
1861 }
1862
1863 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
1864 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
1865 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
1866 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
1867 goto fail;
1868 }
1869 } else {
1870 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
1871 goto fail;
1872 }
1873
1874 cli_unlock(cli1, fnum1, 130, 0);
1875 correct = True;
1876
1877 fail:
1878 cli_close(cli1, fnum1);
1879 cli_unlink(cli1, fname);
1880 torture_close_connection(cli1);
1881
1882 printf("finished locktest7\n");
1883 return correct;
1884 }
1885
1886 /*
1887 test whether fnums and tids open on one VC are available on another (a major
1888 security hole)
1889 */
1890 static BOOL run_fdpasstest(int dummy)
1891 {
1892 struct cli_state *cli1, *cli2;
1893 const char *fname = "\\fdpass.tst";
1894 int fnum1;
1895 pstring buf;
1896
1897 if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
1898 return False;
1899 }
1900 cli_sockopt(cli1, sockops);
1901 cli_sockopt(cli2, sockops);
1902
1903 printf("starting fdpasstest\n");
1904
1905 cli_unlink(cli1, fname);
1906
1907 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1908 if (fnum1 == -1) {
1909 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1910 return False;
1911 }
1912
1913 if (cli_write(cli1, fnum1, 0, "hello world\n", 0, 13) != 13) {
1914 printf("write failed (%s)\n", cli_errstr(cli1));
1915 return False;
1916 }
1917
1918 cli2->vuid = cli1->vuid;
1919 cli2->cnum = cli1->cnum;
1920 cli2->pid = cli1->pid;
1921
1922 if (cli_read(cli2, fnum1, buf, 0, 13) == 13) {
1923 printf("read succeeded! nasty security hole [%s]\n",
1924 buf);
1925 return False;
1926 }
1927
1928 cli_close(cli1, fnum1);
1929 cli_unlink(cli1, fname);
1930
1931 torture_close_connection(cli1);
1932 torture_close_connection(cli2);
1933
1934 printf("finished fdpasstest\n");
1935 return True;
1936 }
1937
1938
1939 /*
1940 This test checks that
1941
1942 1) the server does not allow an unlink on a file that is open
1943 */
1944 static BOOL run_unlinktest(int dummy)
1945 {
1946 struct cli_state *cli;
1947 const char *fname = "\\unlink.tst";
1948 int fnum;
1949 BOOL correct = True;
1950
1951 if (!torture_open_connection(&cli)) {
1952 return False;
1953 }
1954
1955 cli_sockopt(cli, sockops);
1956
1957 printf("starting unlink test\n");
1958
1959 cli_unlink(cli, fname);
1960
1961 cli_setpid(cli, 1);
1962
1963 fnum = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1964 if (fnum == -1) {
1965 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1966 return False;
1967 }
1968
1969 if (cli_unlink(cli, fname)) {
1970 printf("error: server allowed unlink on an open file\n");
1971 correct = False;
1972 } else {
1973 correct = check_error(__LINE__, cli, ERRDOS, ERRbadshare,
1974 NT_STATUS_SHARING_VIOLATION);
1975 }
1976
1977 cli_close(cli, fnum);
1978 cli_unlink(cli, fname);
1979
1980 if (!torture_close_connection(cli)) {
1981 correct = False;
1982 }
1983
1984 printf("unlink test finished\n");
1985
1986 return correct;
1987 }
1988
1989
1990 /*
1991 test how many open files this server supports on the one socket
1992 */
1993 static BOOL run_maxfidtest(int dummy)
1994 {
1995 struct cli_state *cli;
1996 const char *template = "\\maxfid.%d.%d";
1997 fstring fname;
1998 int fnums[0x11000], i;
1999 int retries=4;
2000 BOOL correct = True;
2001
2002 cli = current_cli;
2003
2004 if (retries <= 0) {
2005 printf("failed to connect\n");
2006 return False;
2007 }
2008
2009 cli_sockopt(cli, sockops);
2010
2011 for (i=0; i<0x11000; i++) {
2012 slprintf(fname,sizeof(fname)-1,template, i,(int)getpid());
2013 if ((fnums[i] = cli_open(cli, fname,
2014 O_RDWR|O_CREAT|O_TRUNC, DENY_NONE)) ==
2015 -1) {
2016 printf("open of %s failed (%s)\n",
2017 fname, cli_errstr(cli));
2018 printf("maximum fnum is %d\n", i);
2019 break;
2020 }
2021 printf("%6d\r", i);
2022 }
2023 printf("%6d\n", i);
2024 i--;
2025
2026 printf("cleaning up\n");
2027 for (;i>=0;i--) {
2028 slprintf(fname,sizeof(fname)-1,template, i,(int)getpid());
2029 cli_close(cli, fnums[i]);
2030 if (!cli_unlink(cli, fname)) {
2031 printf("unlink of %s failed (%s)\n",
2032 fname, cli_errstr(cli));
2033 correct = False;
2034 }
2035 printf("%6d\r", i);
2036 }
2037 printf("%6d\n", 0);
2038
2039 printf("maxfid test finished\n");
2040 if (!torture_close_connection(cli)) {
2041 correct = False;
2042 }
2043 return correct;
2044 }
2045
2046 /* generate a random buffer */
2047 static void rand_buf(char *buf, int len)
2048 {
2049 while (len--) {
2050 *buf = (char)sys_random();
2051 buf++;
2052 }
2053 }
2054
2055 /* send smb negprot commands, not reading the response */
2056 static BOOL run_negprot_nowait(int dummy)
2057 {
2058 int i;
2059 static struct cli_state cli;
2060 BOOL correct = True;
2061
2062 printf("starting negprot nowait test\n");
2063
2064 if (!open_nbt_connection(&cli)) {
2065 return False;
2066 }
2067
2068 for (i=0;i<50000;i++) {
2069 cli_negprot_send(&cli);
2070 }
2071
2072 if (!torture_close_connection(&cli)) {
2073 correct = False;
2074 }
2075
2076 printf("finished negprot nowait test\n");
2077
2078 return correct;
2079 }
2080
2081
2082 /* send random IPC commands */
2083 static BOOL run_randomipc(int dummy)
2084 {
2085 char *rparam = NULL;
2086 char *rdata = NULL;
2087 int rdrcnt,rprcnt;
2088 pstring param;
2089 int api, param_len, i;
2090 struct cli_state *cli;
2091 BOOL correct = True;
2092 int count = 50000;
2093
2094 printf("starting random ipc test\n");
2095
2096 if (!torture_open_connection(&cli)) {
2097 return False;
2098 }
2099
2100 for (i=0;i<count;i++) {
2101 api = sys_random() % 500;
2102 param_len = (sys_random() % 64);
2103
2104 rand_buf(param, param_len);
2105
2106 SSVAL(param,0,api);
2107
2108 cli_api(cli,
2109 param, param_len, 8,
2110 NULL, 0, BUFFER_SIZE,
2111 &rparam, &rprcnt,
2112 &rdata, &rdrcnt);
2113 if (i % 100 == 0) {
2114 printf("%d/%d\r", i,count);
2115 }
2116 }
2117 printf("%d/%d\n", i, count);
2118
2119 if (!torture_close_connection(cli)) {
2120 correct = False;
2121 }
2122
2123 printf("finished random ipc test\n");
2124
2125 return correct;
2126 }
2127
2128
2129
2130 static void browse_callback(const char *sname, uint32 stype,
2131 const char *comment, void *state)
2132 {
2133 printf("\t%20.20s %08x %s\n", sname, stype, comment);
2134 }
2135
2136
2137
2138 /*
2139 This test checks the browse list code
2140
2141 */
2142 static BOOL run_browsetest(int dummy)
2143 {
2144 static struct cli_state *cli;
2145 BOOL correct = True;
2146
2147 printf("starting browse test\n");
2148
2149 if (!torture_open_connection(&cli)) {
2150 return False;
2151 }
2152
2153 printf("domain list:\n");
2154 cli_NetServerEnum(cli, cli->server_domain,
2155 SV_TYPE_DOMAIN_ENUM,
2156 browse_callback, NULL);
2157
2158 printf("machine list:\n");
2159 cli_NetServerEnum(cli, cli->server_domain,
2160 SV_TYPE_ALL,
2161 browse_callback, NULL);
2162
2163 if (!torture_close_connection(cli)) {
2164 correct = False;
2165 }
2166
2167 printf("browse test finished\n");
2168
2169 return correct;
2170
2171 }
2172
2173
2174 /*
2175 This checks how the getatr calls works
2176 */
2177 static BOOL run_attrtest(int dummy)
2178 {
2179 struct cli_state *cli;
2180 int fnum;
2181 time_t t, t2;
2182 const char *fname = "\\attrib.tst";
2183 BOOL correct = True;
2184
2185 printf("starting attrib test\n");
2186
2187 if (!torture_open_connection(&cli)) {
2188 return False;
2189 }
2190
2191 cli_unlink(cli, fname);
2192 fnum = cli_open(cli, fname,
2193 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2194 cli_close(cli, fnum);
2195 if (!cli_getatr(cli, fname, NULL, NULL, &t)) {
2196 printf("getatr failed (%s)\n", cli_errstr(cli));
2197 correct = False;
2198 }
2199
2200 if (abs(t - time(NULL)) > 60*60*24*10) {
2201 printf("ERROR: SMBgetatr bug. time is %s",
2202 ctime(&t));
2203 t = time(NULL);
2204 correct = True;
2205 }
2206
2207 t2 = t-60*60*24; /* 1 day ago */
2208
2209 if (!cli_setatr(cli, fname, 0, t2)) {
2210 printf("setatr failed (%s)\n", cli_errstr(cli));
2211 correct = True;
2212 }
2213
2214 if (!cli_getatr(cli, fname, NULL, NULL, &t)) {
2215 printf("getatr failed (%s)\n", cli_errstr(cli));
2216 correct = True;
2217 }
2218
2219 if (t != t2) {
2220 printf("ERROR: getatr/setatr bug. times are\n%s",
2221 ctime(&t));
2222 printf("%s", ctime(&t2));
2223 correct = True;
2224 }
2225
2226 cli_unlink(cli, fname);
2227
2228 if (!torture_close_connection(cli)) {
2229 correct = False;
2230 }
2231
2232 printf("attrib test finished\n");
2233
2234 return correct;
2235 }
2236
2237
2238 /*
2239 This checks a couple of trans2 calls
2240 */
2241 static BOOL run_trans2test(int dummy)
2242 {
2243 struct cli_state *cli;
2244 int fnum;
2245 size_t size;
2246 time_t c_time, a_time, m_time, w_time, m_time2;
2247 const char *fname = "\\trans2.tst";
2248 const char *dname = "\\trans2";
2249 const char *fname2 = "\\trans2\\trans2.tst";
2250 pstring pname;
2251 BOOL correct = True;
2252
2253 printf("starting trans2 test\n");
2254
2255 if (!torture_open_connection(&cli)) {
2256 return False;
2257 }
2258
2259 cli_unlink(cli, fname);
2260 fnum = cli_open(cli, fname,
2261 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2262 if (!cli_qfileinfo(cli, fnum, NULL, &size, &c_time, &a_time, &m_time,
2263 NULL, NULL)) {
2264 printf("ERROR: qfileinfo failed (%s)\n", cli_errstr(cli));
2265 correct = False;
2266 }
2267
2268 if (!cli_qfilename(cli, fnum, pname)) {
2269 printf("ERROR: qfilename failed (%s)\n", cli_errstr(cli));
2270 correct = False;
2271 }
2272
2273 if (strcmp(pname, fname)) {
2274 printf("qfilename gave different name? [%s] [%s]\n",
2275 fname, pname);
2276 correct = False;
2277 }
2278
2279 cli_close(cli, fnum);
2280
2281 sleep(2);
2282
2283 cli_unlink(cli, fname);
2284 fnum = cli_open(cli, fname,
2285 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2286 if (fnum == -1) {
2287 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2288 return False;
2289 }
2290 cli_close(cli, fnum);
2291
2292 if (!cli_qpathinfo(cli, fname, &c_time, &a_time, &m_time, &size, NULL)) {
2293 printf("ERROR: qpathinfo failed (%s)\n", cli_errstr(cli));
2294 correct = False;
2295 } else {
2296 if (c_time != m_time) {
2297 printf("create time=%s", ctime(&c_time));
2298 printf("modify time=%s", ctime(&m_time));
2299 printf("This system appears to have sticky create times\n");
2300 }
2301 if (a_time % (60*60) == 0) {
2302 printf("access time=%s", ctime(&a_time));
2303 printf("This system appears to set a midnight access time\n");
2304 correct = False;
2305 }
2306
2307 if (abs(m_time - time(NULL)) > 60*60*24*7) {
2308 printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
2309 correct = False;
2310 }
2311 }
2312
2313
2314 cli_unlink(cli, fname);
2315 fnum = cli_open(cli, fname,
2316 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2317 cli_close(cli, fnum);
2318 if (!cli_qpathinfo2(cli, fname, &c_time, &a_time, &m_time,
2319 &w_time, &size, NULL, NULL)) {
2320 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2321 correct = False;
2322 } else {
2323 if (w_time < 60*60*24*2) {
2324 printf("write time=%s", ctime(&w_time));
2325 printf("This system appears to set a initial 0 write time\n");
2326 correct = False;
2327 }
2328 }
2329
2330 cli_unlink(cli, fname);
2331
2332
2333 /* check if the server updates the directory modification time
2334 when creating a new file */
2335 if (!cli_mkdir(cli, dname)) {
2336 printf("ERROR: mkdir failed (%s)\n", cli_errstr(cli));
2337 correct = False;
2338 }
2339 sleep(3);
2340 if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time, &a_time, &m_time,
2341 &w_time, &size, NULL, NULL)) {
2342 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2343 correct = False;
2344 }
2345
2346 fnum = cli_open(cli, fname2,
2347 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2348 cli_write(cli, fnum, 0, (char *)&fnum, 0, sizeof(fnum));
2349 cli_close(cli, fnum);
2350 if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time, &a_time, &m_time2,
2351 &w_time, &size, NULL, NULL)) {
2352 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2353 correct = False;
2354 } else {
2355 if (m_time2 == m_time) {
2356 printf("This system does not update directory modification times\n");
2357 correct = False;
2358 }
2359 }
2360 cli_unlink(cli, fname2);
2361 cli_rmdir(cli, dname);
2362
2363 if (!torture_close_connection(cli)) {
2364 correct = False;
2365 }
2366
2367 printf("trans2 test finished\n");
2368
2369 return correct;
2370 }
2371
2372 /*
2373 This checks new W2K calls.
2374 */
2375
2376 static BOOL new_trans(struct cli_state *pcli, int fnum, int level)
2377 {
2378 char buf[4096];
2379 BOOL correct = True;
2380
2381 memset(buf, 0xff, sizeof(buf));
2382
2383 if (!cli_qfileinfo_test(pcli, fnum, level, buf)) {
2384 printf("ERROR: qfileinfo (%d) failed (%s)\n", level, cli_errstr(pcli));
2385 correct = False;
2386 } else {
2387 printf("qfileinfo: level %d\n", level);
2388 dump_data(0, buf, 256);
2389 printf("\n");
2390 }
2391 return correct;
2392 }
2393
2394 static BOOL run_w2ktest(int dummy)
2395 {
2396 struct cli_state *cli;
2397 int fnum;
2398 const char *fname = "\\w2ktest\\w2k.tst";
2399 int level;
2400 BOOL correct = True;
2401
2402 printf("starting w2k test\n");
2403
2404 if (!torture_open_connection(&cli)) {
2405 return False;
2406 }
2407
2408 fnum = cli_open(cli, fname,
2409 O_RDWR | O_CREAT , DENY_NONE);
2410
2411 for (level = 1004; level < 1040; level++) {
2412 new_trans(cli, fnum, level);
2413 }
2414
2415 cli_close(cli, fnum);
2416
2417 if (!torture_close_connection(cli)) {
2418 correct = False;
2419 }
2420
2421 printf("w2k test finished\n");
2422
2423 return correct;
2424 }
2425
2426
2427 /*
2428 this is a harness for some oplock tests
2429 */
2430 static BOOL run_oplock1(int dummy)
2431 {
2432 struct cli_state *cli1;
2433 const char *fname = "\\lockt1.lck";
2434 int fnum1;
2435 BOOL correct = True;
2436
2437 printf("starting oplock test 1\n");
2438
2439 if (!torture_open_connection(&cli1)) {
2440 return False;
2441 }
2442
2443 cli_unlink(cli1, fname);
2444
2445 cli_sockopt(cli1, sockops);
2446
2447 cli1->use_oplocks = True;
2448
2449 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2450 if (fnum1 == -1) {
2451 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2452 return False;
2453 }
2454
2455 cli1->use_oplocks = False;
2456
2457 cli_unlink(cli1, fname);
2458 cli_unlink(cli1, fname);
2459
2460 if (!cli_close(cli1, fnum1)) {
2461 printf("close2 failed (%s)\n", cli_errstr(cli1));
2462 return False;
2463 }
2464
2465 if (!cli_unlink(cli1, fname)) {
2466 printf("unlink failed (%s)\n", cli_errstr(cli1));
2467 return False;
2468 }
2469
2470 if (!torture_close_connection(cli1)) {
2471 correct = False;
2472 }
2473
2474 printf("finished oplock test 1\n");
2475
2476 return correct;
2477 }
2478
2479 static BOOL run_oplock2(int dummy)
2480 {
2481 struct cli_state *cli1, *cli2;
2482 const char *fname = "\\lockt2.lck";
2483 int fnum1, fnum2;
2484 int saved_use_oplocks = use_oplocks;
2485 char buf[4];
2486 BOOL correct = True;
2487 volatile BOOL *shared_correct;
2488
2489 shared_correct = (volatile BOOL *)shm_setup(sizeof(BOOL));
2490 *shared_correct = True;
2491
2492 use_level_II_oplocks = True;
2493 use_oplocks = True;
2494
2495 printf("starting oplock test 2\n");
2496
2497 if (!torture_open_connection(&cli1)) {
2498 use_level_II_oplocks = False;
2499 use_oplocks = saved_use_oplocks;
2500 return False;
2501 }
2502
2503 cli1->use_oplocks = True;
2504 cli1->use_level_II_oplocks = True;
2505
2506 if (!torture_open_connection(&cli2)) {
2507 use_level_II_oplocks = False;
2508 use_oplocks = saved_use_oplocks;
2509 return False;
2510 }
2511
2512 cli2->use_oplocks = True;
2513 cli2->use_level_II_oplocks = True;
2514
2515 cli_unlink(cli1, fname);
2516
2517 cli_sockopt(cli1, sockops);
2518 cli_sockopt(cli2, sockops);
2519
2520 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2521 if (fnum1 == -1) {
2522 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2523 return False;
2524 }
2525
2526 /* Don't need the globals any more. */
2527 use_level_II_oplocks = False;
2528 use_oplocks = saved_use_oplocks;
2529
2530 if (fork() == 0) {
2531 /* Child code */
2532 fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
2533 if (fnum2 == -1) {
2534 printf("second open of %s failed (%s)\n", fname, cli_errstr(cli1));
2535 *shared_correct = False;
2536 exit(0);
2537 }
2538
2539 sleep(2);
2540
2541 if (!cli_close(cli2, fnum2)) {
2542 printf("close2 failed (%s)\n", cli_errstr(cli1));
2543 *shared_correct = False;
2544 }
2545
2546 exit(0);
2547 }
2548
2549 sleep(2);
2550
2551 /* Ensure cli1 processes the break. */
2552
2553 if (cli_read(cli1, fnum1, buf, 0, 4) != 4) {
2554 printf("read on fnum1 failed (%s)\n", cli_errstr(cli1));
2555 correct = False;
2556 }
2557
2558 /* Should now be at level II. */
2559 /* Test if sending a write locks causes a break to none. */
2560
2561 if (!cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK)) {
2562 printf("lock failed (%s)\n", cli_errstr(cli1));
2563 correct = False;
2564 }
2565
2566 cli_unlock(cli1, fnum1, 0, 4);
2567
2568 sleep(2);
2569
2570 if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
2571 printf("lock failed (%s)\n", cli_errstr(cli1));
2572 correct = False;
2573 }
2574
2575 cli_unlock(cli1, fnum1, 0, 4);
2576
2577 sleep(2);
2578
2579 cli_read(cli1, fnum1, buf, 0, 4);
2580
2581 #if 0
2582 if (cli_write(cli1, fnum1, 0, buf, 0, 4) != 4) {
2583 printf("write on fnum1 failed (%s)\n", cli_errstr(cli1));
2584 correct = False;
2585 }
2586 #endif
2587
2588 if (!cli_close(cli1, fnum1)) {
2589 printf("close1 failed (%s)\n", cli_errstr(cli1));
2590 correct = False;
2591 }
2592
2593 sleep(4);
2594
2595 if (!cli_unlink(cli1, fname)) {
2596 printf("unlink failed (%s)\n", cli_errstr(cli1));
2597 correct = False;
2598 }
2599
2600 if (!torture_close_connection(cli1)) {
2601 correct = False;
2602 }
2603
2604 if (!*shared_correct) {
2605 correct = False;
2606 }
2607
2608 printf("finished oplock test 2\n");
2609
2610 return correct;
2611 }
2612
2613 /* handler for oplock 3 tests */
2614 static BOOL oplock3_handler(struct cli_state *cli, int fnum, unsigned char level)
2615 {
2616 printf("got oplock break fnum=%d level=%d\n",
2617 fnum, level);
2618 return cli_oplock_ack(cli, fnum, level);
2619 }
2620
2621 static BOOL run_oplock3(int dummy)
2622 {
2623 struct cli_state *cli;
2624 const char *fname = "\\oplockt3.dat";
2625 int fnum;
2626 char buf[4] = "abcd";
2627 BOOL correct = True;
2628 volatile BOOL *shared_correct;
2629
2630 shared_correct = (volatile BOOL *)shm_setup(sizeof(BOOL));
2631 *shared_correct = True;
2632
2633 printf("starting oplock test 3\n");
2634
2635 if (fork() == 0) {
2636 /* Child code */
2637 use_oplocks = True;
2638 use_level_II_oplocks = True;
2639 if (!torture_open_connection(&cli)) {
2640 *shared_correct = False;
2641 exit(0);
2642 }
2643 sleep(2);
2644 /* try to trigger a oplock break in parent */
2645 fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
2646 cli_write(cli, fnum, 0, buf, 0, 4);
2647 exit(0);
2648 }
2649
2650 /* parent code */
2651 use_oplocks = True;
2652 use_level_II_oplocks = True;
2653 if (!torture_open_connection(&cli)) {
2654 return False;
2655 }
2656 cli_oplock_handler(cli, oplock3_handler);
2657 fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
2658 cli_write(cli, fnum, 0, buf, 0, 4);
2659 cli_close(cli, fnum);
2660 fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
2661 cli->timeout = 20000;
2662 cli_receive_smb(cli);
2663 printf("finished oplock test 3\n");
2664
2665 return (correct && *shared_correct);
2666
2667 /* What are we looking for here? What's sucess and what's FAILURE? */
2668 }
2669
2670
2671
2672 /*
2673 Test delete on close semantics.
2674 */
2675 static BOOL run_deletetest(int dummy)
2676 {
2677 struct cli_state *cli1;
2678 struct cli_state *cli2;
2679 const char *fname = "\\delete.file";
2680 int fnum1 = -1;
2681 int fnum2 = -1;
2682 BOOL correct = True;
2683
2684 printf("starting delete test\n");
2685
2686 if (!torture_open_connection(&cli1)) {
2687 return False;
2688 }
2689
2690 cli_sockopt(cli1, sockops);
2691
2692 /* Test 1 - this should delete the file on close. */
2693
2694 cli_setatr(cli1, fname, 0, 0);
2695 cli_unlink(cli1, fname);
2696
2697 fnum1 = cli_nt_create_full(cli1, fname, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
2698 FILE_SHARE_DELETE, FILE_OVERWRITE_IF,
2699 FILE_DELETE_ON_CLOSE);
2700
2701 if (fnum1 == -1) {
2702 printf("[1] open of %s failed (%s)\n", fname, cli_errstr(cli1));
2703 correct = False;
2704 goto fail;
2705 }
2706
2707 if (!cli_close(cli1, fnum1)) {
2708 printf("[1] close failed (%s)\n", cli_errstr(cli1));
2709 correct = False;
2710 goto fail;
2711 }
2712
2713 fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
2714 if (fnum1 != -1) {
2715 printf("[1] open of %s succeeded (should fail)\n", fname);
2716 correct = False;
2717 goto fail;
2718 }
2719
2720 printf("first delete on close test succeeded.\n");
2721
2722 /* Test 2 - this should delete the file on close. */
2723
2724 cli_setatr(cli1, fname, 0, 0);
2725 cli_unlink(cli1, fname);
2726
2727 fnum1 = cli_nt_create_full(cli1, fname, GENERIC_ALL_ACCESS,
2728 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
2729 FILE_OVERWRITE_IF, 0);
2730
2731 if (fnum1 == -1) {
2732 printf("[2] open of %s failed (%s)\n", fname, cli_errstr(cli1));
2733 correct = False;
2734 goto fail;
2735 }
2736
2737 if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
2738 printf("[2] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
2739 correct = False;
2740 goto fail;
2741 }
2742
2743 if (!cli_close(cli1, fnum1)) {
2744 printf("[2] close failed (%s)\n", cli_errstr(cli1));
2745 correct = False;
2746 goto fail;
2747 }
2748
2749 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
2750 if (fnum1 != -1) {
2751 printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
2752 if (!cli_close(cli1, fnum1)) {
2753 printf("[2] close failed (%s)\n", cli_errstr(cli1));
2754 correct = False;
2755 goto fail;
2756 }
2757 cli_unlink(cli1, fname);
2758 } else
2759 printf("second delete on close test succeeded.\n");
2760
2761 /* Test 3 - ... */
2762 cli_setatr(cli1, fname, 0, 0);
2763 cli_unlink(cli1, fname);
2764
2765 fnum1 = cli_nt_create_full(cli1, fname, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
2766 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0);
2767
2768 if (fnum1 == -1) {
2769 printf("[3] open - 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
2770 correct = False;
2771 goto fail;
2772 }
2773
2774 /* This should fail with a sharing violation - open for delete is only compatible
2775 with SHARE_DELETE. */
2776
2777 fnum2 = cli_nt_create_full(cli1, fname, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
2778 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0);
2779
2780 if (fnum2 != -1) {
2781 printf("[3] open - 2 of %s succeeded - should have failed.\n", fname);
2782 correct = False;
2783 goto fail;
2784 }
2785
2786 /* This should succeed. */
2787
2788 fnum2 = cli_nt_create_full(cli1, fname, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
2789 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0);
2790
2791 if (fnum2 == -1) {
2792 printf("[3] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
2793 correct = False;
2794 goto fail;
2795 }
2796
2797 if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
2798 printf("[3] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
2799 correct = False;
2800 goto fail;
2801 }
2802
2803 if (!cli_close(cli1, fnum1)) {
2804 printf("[3] close 1 failed (%s)\n", cli_errstr(cli1));
2805 correct = False;
2806 goto fail;
2807 }
2808
2809 if (!cli_close(cli1, fnum2)) {
2810 printf("[3] close 2 failed (%s)\n", cli_errstr(cli1));
2811 correct = False;
2812 goto fail;
2813 }
2814
2815 /* This should fail - file should no longer be there. */
2816
2817 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
2818 if (fnum1 != -1) {
2819 printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
2820 if (!cli_close(cli1, fnum1)) {
2821 printf("[3] close failed (%s)\n", cli_errstr(cli1));
2822 }
2823 cli_unlink(cli1, fname);
2824 correct = False;
2825 goto fail;
2826 } else
2827 printf("third delete on close test succeeded.\n");
2828
2829 /* Test 4 ... */
2830 cli_setatr(cli1, fname, 0, 0);
2831 cli_unlink(cli1, fname);
2832
2833 fnum1 = cli_nt_create_full(cli1, fname, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
2834 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0);
2835
2836 if (fnum1 == -1) {
2837 printf("[4] open of %s failed (%s)\n", fname, cli_errstr(cli1));
2838 correct = False;
2839 goto fail;
2840 }
2841
2842 /* This should succeed. */
2843 fnum2 = cli_nt_create_full(cli1, fname, GENERIC_READ_ACCESS,
2844 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0);
2845 if (fnum2 == -1) {
2846 printf("[4] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
2847 correct = False;
2848 goto fail;
2849 }
2850
2851 if (!cli_close(cli1, fnum2)) {
2852 printf("[4] close - 1 failed (%s)\n", cli_errstr(cli1));
2853 correct = False;
2854 goto fail;
2855 }
2856
2857 if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
2858 printf("[4] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
2859 correct = False;
2860 goto fail;
2861 }
2862
2863 /* This should fail - no more opens once delete on close set. */
2864 fnum2 = cli_nt_create_full(cli1, fname, GENERIC_READ_ACCESS,
2865 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0);
2866 if (fnum2 != -1) {
2867 printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname );
2868 correct = False;
2869 goto fail;
2870 } else
2871 printf("fourth delete on close test succeeded.\n");
2872
2873 if (!cli_close(cli1, fnum1)) {
2874 printf("[4] close - 2 failed (%s)\n", cli_errstr(cli1));
2875 correct = False;
2876 goto fail;
2877 }
2878
2879 /* Test 5 ... */
2880 cli_setatr(cli1, fname, 0, 0);
2881 cli_unlink(cli1, fname);
2882
2883 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT, DENY_NONE);
2884 if (fnum1 == -1) {
2885 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
2886 correct = False;
2887 goto fail;
2888 }
2889
2890 /* This should fail - only allowed on NT opens with DELETE access. */
2891
2892 if (cli_nt_delete_on_close(cli1, fnum1, True)) {
2893 printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
2894 correct = False;
2895 goto fail;
2896 }
2897
2898 if (!cli_close(cli1, fnum1)) {
2899 printf("[5] close - 2 failed (%s)\n", cli_errstr(cli1));
2900 correct = False;
2901 goto fail;
2902 }
2903
2904 printf("fifth delete on close test succeeded.\n");
2905
2906 /* Test 6 ... */
2907 cli_setatr(cli1, fname, 0, 0);
2908 cli_unlink(cli1, fname);
2909
2910 fnum1 = cli_nt_create_full(cli1, fname, FILE_READ_DATA|FILE_WRITE_DATA,
2911 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
2912 FILE_OVERWRITE_IF, 0);
2913
2914 if (fnum1 == -1) {
2915 printf("[6] open of %s failed (%s)\n", fname, cli_errstr(cli1));
2916 correct = False;
2917 goto fail;
2918 }
2919
2920 /* This should fail - only allowed on NT opens with DELETE access. */
2921
2922 if (cli_nt_delete_on_close(cli1, fnum1, True)) {
2923 printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
2924 correct = False;
2925 goto fail;
2926 }
2927
2928 if (!cli_close(cli1, fnum1)) {
2929 printf("[6] close - 2 failed (%s)\n", cli_errstr(cli1));
2930 correct = False;
2931 goto fail;
2932 }
2933
2934 printf("sixth delete on close test succeeded.\n");
2935
2936 /* Test 7 ... */
2937 cli_setatr(cli1, fname, 0, 0);
2938 cli_unlink(cli1, fname);
2939
2940 fnum1 = cli_nt_create_full(cli1, fname, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
2941 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0);
2942
2943 if (fnum1 == -1) {
2944 printf("[7] open of %s failed (%s)\n", fname, cli_errstr(cli1));
2945 correct = False;
2946 goto fail;
2947 }
2948
2949 if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
2950 printf("[7] setting delete_on_close on file failed !\n");
2951 correct = False;
2952 goto fail;
2953 }
2954
2955 if (!cli_nt_delete_on_close(cli1, fnum1, False)) {
2956 printf("[7] unsetting delete_on_close on file failed !\n");
2957 correct = False;
2958 goto fail;
2959 }
2960
2961 if (!cli_close(cli1, fnum1)) {
2962 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
2963 correct = False;
2964 goto fail;
2965 }
2966
2967 /* This next open should succeed - we reset the flag. */
2968
2969 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
2970 if (fnum1 == -1) {
2971 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
2972 correct = False;
2973 goto fail;
2974 }
2975
2976 if (!cli_close(cli1, fnum1)) {
2977 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
2978 correct = False;
2979 goto fail;
2980 }
2981
2982 printf("seventh delete on close test succeeded.\n");
2983
2984 /* Test 7 ... */
2985 cli_setatr(cli1, fname, 0, 0);
2986 cli_unlink(cli1, fname);
2987
2988 if (!torture_open_connection(&cli2)) {
2989 printf("[8] failed to open second connection.\n");
2990 correct = False;
2991 goto fail;
2992 }
2993
2994 cli_sockopt(cli1, sockops);
2995
2996 fnum1 = cli_nt_create_full(cli1, fname, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
2997 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0);
2998
2999 if (fnum1 == -1) {
3000 printf("[8] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3001 correct = False;
3002 goto fail;
3003 }
3004
3005 fnum2 = cli_nt_create_full(cli2, fname, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3006 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0);
3007
3008 if (fnum2 == -1) {
3009 printf("[8] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3010 correct = False;
3011 goto fail;
3012 }
3013
3014 if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3015 printf("[8] setting delete_on_close on file failed !\n");
3016 correct = False;
3017 goto fail;
3018 }
3019
3020 if (!cli_close(cli1, fnum1)) {
3021 printf("[8] close - 1 failed (%s)\n", cli_errstr(cli1));
3022 correct = False;
3023 goto fail;
3024 }
3025
3026 if (!cli_close(cli2, fnum2)) {
3027 printf("[8] close - 2 failed (%s)\n", cli_errstr(cli2));
3028 correct = False;
3029 goto fail;
3030 }
3031
3032 /* This should fail.. */
3033 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3034 if (fnum1 != -1) {
3035 printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
3036 goto fail;
3037 correct = False;
3038 } else
3039 printf("eighth delete on close test succeeded.\n");
3040
3041 /* This should fail - we need to set DELETE_ACCESS. */
3042 fnum1 = cli_nt_create_full(cli1, fname, FILE_READ_DATA|FILE_WRITE_DATA,
3043 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE);
3044
3045 if (fnum1 != -1) {
3046 printf("[9] open of %s succeeded should have failed!\n", fname);
3047 correct = False;
3048 goto fail;
3049 }
3050
3051 printf("ninth delete on close test succeeded.\n");
3052
3053 fnum1 = cli_nt_create_full(cli1, fname, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3054 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE);
3055 if (fnum1 == -1) {
3056 printf("[10] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3057 correct = False;
3058 goto fail;
3059 }
3060
3061 /* This should delete the file. */
3062 if (!cli_close(cli1, fnum1)) {
3063 printf("[10] close failed (%s)\n", cli_errstr(cli1));
3064 correct = False;
3065 goto fail;
3066 }
3067
3068 /* This should fail.. */
3069 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3070 if (fnum1 != -1) {
3071 printf("[10] open of %s succeeded should have been deleted on close !\n", fname);
3072 goto fail;
3073 correct = False;
3074 } else
3075 printf("tenth delete on close test succeeded.\n");
3076 printf("finished delete test\n");
3077
3078 fail:
3079 /* FIXME: This will crash if we aborted before cli2 got
3080 * intialized, because these functions don't handle
3081 * uninitialized connections. */
3082
3083 cli_close(cli1, fnum1);
3084 cli_close(cli1, fnum2);
3085 cli_setatr(cli1, fname, 0, 0);
3086 cli_unlink(cli1, fname);
3087
3088 if (!torture_close_connection(cli1)) {
3089 correct = False;
3090 }
3091 if (!torture_close_connection(cli2)) {
3092 correct = False;
3093 }
3094 return correct;
3095 }
3096
3097
3098 /*
3099 print out server properties
3100 */
3101 static BOOL run_properties(int dummy)
3102 {
3103 static struct cli_state *cli;
3104 BOOL correct = True;
3105
3106 printf("starting properties test\n");
3107
3108 ZERO_STRUCT(cli);
3109
3110 if (!torture_open_connection(&cli)) {
3111 return False;
3112 }
3113
3114 cli_sockopt(cli, sockops);
3115
3116 d_printf("Capabilities 0x%08x\n", cli->capabilities);
3117
3118 if (!torture_close_connection(cli)) {
3119 correct = False;
3120 }
3121
3122 return correct;
3123 }
3124
3125
3126
3127 /* FIRST_DESIRED_ACCESS 0xf019f */
3128 #define FIRST_DESIRED_ACCESS FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\
3129 FILE_READ_EA| /* 0xf */ \
3130 FILE_WRITE_EA|FILE_READ_ATTRIBUTES| /* 0x90 */ \
3131 FILE_WRITE_ATTRIBUTES| /* 0x100 */ \
3132 DELETE_ACCESS|READ_CONTROL_ACCESS|\
3133 WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS /* 0xf0000 */
3134 /* SECOND_DESIRED_ACCESS 0xe0080 */
3135 #define SECOND_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
3136 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
3137 WRITE_OWNER_ACCESS /* 0xe0000 */
3138
3139 #if 0
3140 #define THIRD_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
3141 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
3142 FILE_READ_DATA|\
3143 WRITE_OWNER_ACCESS /* */
3144 #endif
3145
3146 /*
3147 Test ntcreate calls made by xcopy
3148 */
3149 static BOOL run_xcopy(int dummy)
3150 {
3151 static struct cli_state *cli1;
3152 const char *fname = "\\test.txt";
3153 BOOL correct = True;
3154 int fnum1, fnum2;
3155
3156 printf("starting xcopy test\n");
3157
3158 if (!torture_open_connection(&cli1)) {
3159 return False;
3160 }
3161
3162 fnum1 = cli_nt_create_full(cli1, fname,
3163 FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
3164 FILE_SHARE_NONE, FILE_OVERWRITE_IF,
3165 0x4044);
3166
3167 if (fnum1 == -1) {
3168 printf("First open failed - %s\n", cli_errstr(cli1));
3169 return False;
3170 }
3171
3172 fnum2 = cli_nt_create_full(cli1, fname,
3173 SECOND_DESIRED_ACCESS, 0,
3174 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN,
3175 0x200000);
3176 if (fnum2 == -1) {
3177 printf("second open failed - %s\n", cli_errstr(cli1));
3178 return False;
3179 }
3180
3181 if (!torture_close_connection(cli1)) {
3182 correct = False;
3183 }
3184
3185 return correct;
3186 }
3187
3188 /*
3189 Test rename on files open with share delete and no share delete.
3190 */
3191 static BOOL run_rename(int dummy)
3192 {
3193 static struct cli_state *cli1;
3194 const char *fname = "\\test.txt";
3195 const char *fname1 = "\\test1.txt";
3196 BOOL correct = True;
3197 int fnum1;
3198
3199 printf("starting rename test\n");
3200
3201 if (!torture_open_connection(&cli1)) {
3202 return False;
3203 }
3204
3205 cli_unlink(cli1, fname);
3206 cli_unlink(cli1, fname1);
3207 fnum1 = cli_nt_create_full(cli1, fname, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3208 FILE_SHARE_READ, FILE_OVERWRITE_IF, 0);
3209
3210 if (fnum1 == -1) {
3211 printf("First open failed - %s\n", cli_errstr(cli1));
3212 return False;
3213 }
3214
3215 if (!cli_rename(cli1, fname, fname1)) {
3216 printf("First rename failed (this is correct) - %s\n", cli_errstr(cli1));
3217 } else {
3218 printf("First rename succeeded - this should have failed !\n");
3219 correct = False;
3220 }
3221
3222 if (!cli_close(cli1, fnum1)) {
3223 printf("close - 1 failed (%s)\n", cli_errstr(cli1));
3224 return False;
3225 }
3226
3227 cli_unlink(cli1, fname);
3228 cli_unlink(cli1, fname1);
3229 fnum1 = cli_nt_create_full(cli1, fname,GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3230 #if 0
3231 FILE_SHARE_DELETE|FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0);
3232 #else
3233 FILE_SHARE_DELETE|FILE_SHARE_READ, FILE_OVERWRITE_IF, 0);
3234 #endif
3235
3236 if (fnum1 == -1) {
3237 printf("Second open failed - %s\n", cli_errstr(cli1));
3238 return False;
3239 }
3240
3241 if (!cli_rename(cli1, fname, fname1)) {
3242 printf("Second rename failed - this should have succeeded - %s\n", cli_errstr(cli1));
3243 correct = False;
3244 } else {
3245 printf("Second rename succeeded\n");
3246 }
3247
3248 if (!cli_close(cli1, fnum1)) {
3249 printf("close - 2 failed (%s)\n", cli_errstr(cli1));
3250 return False;
3251 }
3252
3253 cli_unlink(cli1, fname);
3254 cli_unlink(cli1, fname1);
3255
3256 fnum1 = cli_nt_create_full(cli1, fname,READ_CONTROL_ACCESS, FILE_ATTRIBUTE_NORMAL,
3257 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0);
3258
3259 if (fnum1 == -1) {
3260 printf("Third open failed - %s\n", cli_errstr(cli1));
3261 return False;
3262 }
3263
3264
3265 #if 0
3266 {
3267 int fnum2;
3268
3269 fnum2 = cli_nt_create_full(cli1, fname,DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
3270 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0);
3271
3272 if (fnum2 == -1) {
3273 printf("Fourth open failed - %s\n", cli_errstr(cli1));
3274 return False;
3275 }
3276 if (!cli_nt_delete_on_close(cli1, fnum2, True)) {
3277 printf("[8] setting delete_on_close on file failed !\n");
3278 return False;
3279 }
3280
3281 if (!cli_close(cli1, fnum2)) {
3282 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
3283 return False;
3284 }
3285 }
3286 #endif
3287
3288 if (!cli_rename(cli1, fname, fname1)) {
3289 printf("Third rename failed - this should have succeeded - %s\n", cli_errstr(cli1));
3290 correct = False;
3291 } else {
3292 printf("Third rename succeeded\n");
3293 }
3294
3295 if (!cli_close(cli1, fnum1)) {
3296 printf("close - 3 failed (%s)\n", cli_errstr(cli1));
3297 return False;
3298 }
3299
3300 cli_unlink(cli1, fname);
3301 cli_unlink(cli1, fname1);
3302
3303 if (!torture_close_connection(cli1)) {
3304 correct = False;
3305 }
3306
3307 return correct;
3308 }
3309
3310 static BOOL run_pipe_number(int dummy)
3311 {
3312 struct cli_state *cli1;
3313 const char *pipe_name = "\\SPOOLSS";
3314 int fnum;
3315 int num_pipes = 0;
3316
3317 printf("starting pipenumber test\n");
3318 if (!torture_open_connection(&cli1)) {
3319 return False;
3320 }
3321
3322 cli_sockopt(cli1, sockops);
3323 while(1) {
3324 fnum = cli_nt_create_full(cli1, pipe_name,FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
3325 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF, 0);
3326
3327 if (fnum == -1) {
3328 printf("Open of pipe %s failed with error (%s)\n", pipe_name, cli_errstr(cli1));
3329 break;
3330 }
3331 num_pipes++;
3332 }
3333
3334 printf("pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
3335 torture_close_connection(cli1);
3336 return True;
3337 }
3338
3339 /*
3340 Test open mode returns on read-only files.
3341 */
3342 static BOOL run_opentest(int dummy)
3343 {
3344 static struct cli_state *cli1;
3345 static struct cli_state *cli2;
3346 const char *fname = "\\readonly.file";
3347 int fnum1, fnum2;
3348 char buf[20];
3349 size_t fsize;
3350 BOOL correct = True;
3351 char *tmp_path;
3352
3353 printf("starting open test\n");
3354
3355 if (!torture_open_connection(&cli1)) {
3356 return False;
3357 }
3358
3359 cli_setatr(cli1, fname, 0, 0);
3360 cli_unlink(cli1, fname);
3361
3362 cli_sockopt(cli1, sockops);
3363
3364 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
3365 if (fnum1 == -1) {
3366 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3367 return False;
3368 }
3369
3370 if (!cli_close(cli1, fnum1)) {
3371 printf("close2 failed (%s)\n", cli_errstr(cli1));
3372 return False;
3373 }
3374
3375 if (!cli_setatr(cli1, fname, aRONLY, 0)) {
3376 printf("cli_setatr failed (%s)\n", cli_errstr(cli1));
3377 return False;
3378 }
3379
3380 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_WRITE);
3381 if (fnum1 == -1) {
3382 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3383 return False;
3384 }
3385
3386 /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
3387 fnum2 = cli_open(cli1, fname, O_RDWR, DENY_ALL);
3388
3389 if (check_error(__LINE__, cli1, ERRDOS, ERRnoaccess,
3390 NT_STATUS_ACCESS_DENIED)) {
3391 printf("correct error code ERRDOS/ERRnoaccess returned\n");
3392 }
3393
3394 printf("finished open test 1\n");
3395
3396 cli_close(cli1, fnum1);
3397
3398 /* Now try not readonly and ensure ERRbadshare is returned. */
3399
3400 cli_setatr(cli1, fname, 0, 0);
3401
3402 fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_WRITE);
3403 if (fnum1 == -1) {
3404 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3405 return False;
3406 }
3407
3408 /* This will fail - but the error should be ERRshare. */
3409 fnum2 = cli_open(cli1, fname, O_RDWR, DENY_ALL);
3410
3411 if (check_error(__LINE__, cli1, ERRDOS, ERRbadshare,
3412 NT_STATUS_SHARING_VIOLATION)) {
3413 printf("correct error code ERRDOS/ERRbadshare returned\n");
3414 }
3415
3416 if (!cli_close(cli1, fnum1)) {
3417 printf("close2 failed (%s)\n", cli_errstr(cli1));
3418 return False;
3419 }
3420
3421 cli_unlink(cli1, fname);
3422
3423 printf("finished open test 2\n");
3424
3425 /* Test truncate open disposition on file opened for read. */
3426
3427 fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
3428 if (fnum1 == -1) {
3429 printf("(3) open (1) of %s failed (%s)\n", fname, cli_errstr(cli1));
3430 return False;
3431 }
3432
3433 /* write 20 bytes. */
3434
3435 memset(buf, '\0', 20);
3436
3437 if (cli_write(cli1, fnum1, 0, buf, 0, 20) != 20) {
3438 printf("write failed (%s)\n", cli_errstr(cli1));
3439 correct = False;
3440 }
3441
3442 if (!cli_close(cli1, fnum1)) {
3443 printf("(3) close1 failed (%s)\n", cli_errstr(cli1));
3444 return False;
3445 }
3446
3447 /* Ensure size == 20. */
3448 if (!cli_getatr(cli1, fname, NULL, &fsize, NULL)) {
3449 printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
3450 return False;
3451 }
3452
3453 if (fsize != 20) {
3454 printf("(3) file size != 20\n");
3455 return False;
3456 }
3457
3458 /* Now test if we can truncate a file opened for readonly. */
3459
3460 fnum1 = cli_open(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE);
3461 if (fnum1 == -1) {
3462 printf("(3) open (2) of %s failed (%s)\n", fname, cli_errstr(cli1));
3463 return False;
3464 }
3465
3466 if (!cli_close(cli1, fnum1)) {
3467 printf("close2 failed (%s)\n", cli_errstr(cli1));
3468 return False;
3469 }
3470
3471 /* Ensure size == 0. */
3472 if (!cli_getatr(cli1, fname, NULL, &fsize, NULL)) {
3473 printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
3474 return False;
3475 }
3476
3477 if (fsize != 0) {
3478 printf("(3) file size != 0\n");
3479 return False;
3480 }
3481 printf("finished open test 3\n");
3482
3483 cli_unlink(cli1, fname);
3484
3485
3486 printf("testing ctemp\n");
3487 fnum1 = cli_ctemp(cli1, "\\", &tmp_path);
3488 if (fnum1 == -1) {
3489 printf("ctemp failed (%s)\n", cli_errstr(cli1));
3490 return False;
3491 }
3492 printf("ctemp gave path %s\n", tmp_path);
3493 if (!cli_close(cli1, fnum1)) {
3494 printf("close of temp failed (%s)\n", cli_errstr(cli1));
3495 }
3496 if (!cli_unlink(cli1, tmp_path)) {
3497 printf("unlink of temp failed (%s)\n", cli_errstr(cli1));
3498 }
3499
3500 /* Test the non-io opens... */
3501
3502 if (!torture_open_connection(&cli2)) {
3503 return False;
3504 }
3505
3506 cli_setatr(cli2, fname, 0, 0);
3507 cli_unlink(cli2, fname);
3508
3509 cli_sockopt(cli2, sockops);
3510
3511 printf("TEST #1 testing 2 non-io opens (no delete)\n");
3512
3513 fnum1 = cli_nt_create_full(cli1, fname,FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3514 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0);
3515
3516 if (fnum1 == -1) {
3517 printf("test 1 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3518 return False;
3519 }
3520
3521 fnum2 = cli_nt_create_full(cli2, fname,FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3522 FILE_SHARE_NONE, FILE_OPEN_IF, 0);
3523
3524 if (fnum2 == -1) {
3525 printf("test 1 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3526 return False;
3527 }
3528
3529 if (!cli_close(cli1, fnum1)) {
3530 printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3531 return False;
3532 }
3533 if (!cli_close(cli2, fnum2)) {
3534 printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3535 return False;
3536 }
3537
3538 printf("non-io open test #1 passed.\n");
3539
3540 cli_unlink(cli1, fname);
3541
3542 printf("TEST #2 testing 2 non-io opens (first with delete)\n");
3543
3544 fnum1 = cli_nt_create_full(cli1, fname,DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3545 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0);
3546
3547 if (fnum1 == -1) {
3548 printf("test 2 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3549 return False;
3550 }
3551
3552 fnum2 = cli_nt_create_full(cli2, fname,FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3553 FILE_SHARE_NONE, FILE_OPEN_IF, 0);
3554
3555 if (fnum2 == -1) {
3556 printf("test 2 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3557 return False;
3558 }
3559
3560 if (!cli_close(cli1, fnum1)) {
3561 printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3562 return False;
3563 }
3564 if (!cli_close(cli2, fnum2)) {
3565 printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3566 return False;
3567 }
3568
3569 printf("non-io open test #2 passed.\n");
3570
3571 cli_unlink(cli1, fname);
3572
3573 printf("TEST #3 testing 2 non-io opens (second with delete)\n");
3574
3575 fnum1 = cli_nt_create_full(cli1, fname,FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3576 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0);
3577
3578 if (fnum1 == -1) {
3579 printf("test 3 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3580 return False;
3581 }
3582
3583 fnum2 = cli_nt_create_full(cli2, fname,DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3584 FILE_SHARE_NONE, FILE_OPEN_IF, 0);
3585
3586 if (fnum2 == -1) {
3587 printf("test 3 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3588 return False;
3589 }
3590
3591 if (!cli_close(cli1, fnum1)) {
3592 printf("test 3 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3593 return False;
3594 }
3595 if (!cli_close(cli2, fnum2)) {
3596 printf("test 3 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3597 return False;
3598 }
3599
3600 printf("non-io open test #3 passed.\n");
3601
3602 cli_unlink(cli1, fname);
3603
3604 printf("TEST #4 testing 2 non-io opens (both with delete)\n");
3605
3606 fnum1 = cli_nt_create_full(cli1, fname,DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3607 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0);
3608
3609 if (fnum1 == -1) {
3610 printf("test 4 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3611 return False;
3612 }
3613
3614 fnum2 = cli_nt_create_full(cli2, fname,DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3615 FILE_SHARE_NONE, FILE_OPEN_IF, 0);
3616
3617 if (fnum2 != -1) {
3618 printf("test 4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
3619 return False;
3620 }
3621
3622 printf("test 3 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
3623
3624 if (!cli_close(cli1, fnum1)) {
3625 printf("test 4 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3626 return False;
3627 }
3628
3629 printf("non-io open test #4 passed.\n");
3630
3631 cli_unlink(cli1, fname);
3632
3633 printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
3634
3635 fnum1 = cli_nt_create_full(cli1, fname,DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3636 FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0);
3637
3638 if (fnum1 == -1) {
3639 printf("test 5 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3640 return False;
3641 }
3642
3643 fnum2 = cli_nt_create_full(cli2, fname,DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3644 FILE_SHARE_DELETE, FILE_OPEN_IF, 0);
3645
3646 if (fnum2 == -1) {
3647 printf("test 5 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3648 return False;
3649 }
3650
3651 if (!cli_close(cli1, fnum1)) {
3652 printf("test 5 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3653 return False;
3654 }
3655
3656 if (!cli_close(cli2, fnum2)) {
3657 printf("test 5 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3658 return False;
3659 }
3660
3661 printf("non-io open test #5 passed.\n");
3662
3663 printf("TEST #6 testing 1 non-io open, one io open\n");
3664
3665 cli_unlink(cli1, fname);
3666
3667 fnum1 = cli_nt_create_full(cli1, fname,FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
3668 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0);
3669
3670 if (fnum1 == -1) {
3671 printf("test 6 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3672 return False;
3673 }
3674
3675 fnum2 = cli_nt_create_full(cli2, fname,FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3676 FILE_SHARE_READ, FILE_OPEN_IF, 0);
3677
3678 if (fnum2 == -1) {
3679 printf("test 6 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3680 return False;
3681 }
3682
3683 if (!cli_close(cli1, fnum1)) {
3684 printf("test 6 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3685 return False;
3686 }
3687
3688 if (!cli_close(cli2, fnum2)) {
3689 printf("test 6 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3690 return False;
3691 }
3692
3693 printf("non-io open test #6 passed.\n");
3694
3695 printf("TEST #7 testing 1 non-io open, one io open with delete\n");
3696
3697 cli_unlink(cli1, fname);
3698
3699 fnum1 = cli_nt_create_full(cli1, fname,FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
3700 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0);
3701
3702 if (fnum1 == -1) {
3703 printf("test 7 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3704 return False;
3705 }
3706
3707 fnum2 = cli_nt_create_full(cli2, fname,DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3708 FILE_SHARE_READ|FILE_SHARE_DELETE, FILE_OPEN_IF, 0);
3709
3710 if (fnum2 != -1) {
3711 printf("test 7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
3712 return False;
3713 }
3714
3715 printf("test 7 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
3716
3717 if (!cli_close(cli1, fnum1)) {
3718 printf("test 7 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3719 return False;
3720 }
3721
3722 printf("non-io open test #7 passed.\n");
3723
3724 cli_unlink(cli1, fname);
3725
3726 if (!torture_close_connection(cli1)) {
3727 correct = False;
3728 }
3729 if (!torture_close_connection(cli2)) {
3730 correct = False;
3731 }
3732
3733 return correct;
3734 }
3735
3736 static uint32 open_attrs_table[] = {
3737 FILE_ATTRIBUTE_NORMAL,
3738 FILE_ATTRIBUTE_ARCHIVE,
3739 FILE_ATTRIBUTE_READONLY,
3740 FILE_ATTRIBUTE_HIDDEN,
3741 FILE_ATTRIBUTE_SYSTEM,
3742
3743 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY,
3744 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN,
3745 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,
3746 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
3747 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
3748 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
3749
3750 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
3751 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
3752 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
3753 FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM,
3754 };
3755
3756 struct trunc_open_results {
3757 unsigned int num;
3758 uint32 init_attr;
3759 uint32 trunc_attr;
3760 uint32 result_attr;
3761 };
3762
3763 static struct trunc_open_results attr_results[] = {
3764 { 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
3765 { 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
3766 { 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
3767 { 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
3768 { 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
3769 { 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
3770 { 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
3771 { 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
3772 { 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
3773 { 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
3774 { 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
3775 { 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
3776 { 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
3777 { 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
3778 { 104, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
3779 { 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
3780 { 119, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
3781 { 121, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
3782 { 170, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN },
3783 { 173, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM },
3784 { 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
3785 { 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
3786 { 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
3787 { 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
3788 { 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
3789 { 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
3790 };
3791
3792 static BOOL run_openattrtest(int dummy)
3793 {
3794 static struct cli_state *cli1;
3795 const char *fname = "\\openattr.file";
3796 int fnum1;
3797 BOOL correct = True;
3798 uint16 attr;
3799 unsigned int i, j, k, l;
3800
3801 printf("starting open attr test\n");
3802
3803 if (!torture_open_connection(&cli1)) {
3804 return False;
3805 }
3806
3807 cli_sockopt(cli1, sockops);
3808
3809 for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32); i++) {
3810 cli_setatr(cli1, fname, 0, 0);
3811 cli_unlink(cli1, fname);
3812 fnum1 = cli_nt_create_full(cli1, fname,FILE_WRITE_DATA, open_attrs_table[i],
3813 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0);
3814
3815 if (fnum1 == -1) {
3816 printf("open %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
3817 return False;
3818 }
3819
3820 if (!cli_close(cli1, fnum1)) {
3821 printf("close %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
3822 return False;
3823 }
3824
3825 for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32); j++) {
3826 fnum1 = cli_nt_create_full(cli1, fname,FILE_READ_DATA|FILE_WRITE_DATA, open_attrs_table[j],
3827 FILE_SHARE_NONE, FILE_OVERWRITE, 0);
3828
3829 if (fnum1 == -1) {
3830 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
3831 if (attr_results[l].num == k) {
3832 printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
3833 k, open_attrs_table[i],
3834 open_attrs_table[j],
3835 fname, NT_STATUS_V(cli_nt_error(cli1)), cli_errstr(cli1));
3836 correct = False;
3837 }
3838 }
3839 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_ACCESS_DENIED)) {
3840 printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n",
3841 k, open_attrs_table[i], open_attrs_table[j],
3842 cli_errstr(cli1));
3843 correct = False;
3844 }
3845 #if 0
3846 printf("[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]);
3847 #endif
3848 k++;
3849 continue;
3850 }
3851
3852 if (!cli_close(cli1, fnum1)) {
3853 printf("close %d (2) of %s failed (%s)\n", j, fname, cli_errstr(cli1));
3854 return False;
3855 }
3856
3857 if (!cli_getatr(cli1, fname, &attr, NULL, NULL)) {
3858 printf("getatr(2) failed (%s)\n", cli_errstr(cli1));
3859 return False;
3860 }
3861
3862 #if 0
3863 printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
3864 k, open_attrs_table[i], open_attrs_table[j], attr );
3865 #endif
3866
3867 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
3868 if (attr_results[l].num == k) {
3869 if (attr != attr_results[l].result_attr ||
3870 open_attrs_table[i] != attr_results[l].init_attr ||
3871 open_attrs_table[j] != attr_results[l].trunc_attr) {
3872 printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
3873 open_attrs_table[i],
3874 open_attrs_table[j],
3875 (unsigned int)attr,
3876 attr_results[l].result_attr);
3877 correct = False;
3878 }
3879 break;
3880 }
3881 }
3882 k++;
3883 }
3884 }
3885
3886 cli_setatr(cli1, fname, 0, 0);
3887 cli_unlink(cli1, fname);
3888
3889 printf("open attr test %s.\n", correct ? "passed" : "failed");
3890
3891 if (!torture_close_connection(cli1)) {
3892 correct = False;
3893 }
3894 return correct;
3895 }
3896
3897 static void list_fn(file_info *finfo, const char *name, void *state)
3898 {
3899
3900 }
3901
3902 /*
3903 test directory listing speed
3904 */
3905 static BOOL run_dirtest(int dummy)
3906 {
3907 int i;
3908 static struct cli_state *cli;
3909 int fnum;
3910 double t1;
3911 BOOL correct = True;
3912
3913 printf("starting directory test\n");
3914
3915 if (!torture_open_connection(&cli)) {
3916 return False;
3917 }
3918
3919 cli_sockopt(cli, sockops);
3920
3921 srandom(0);
3922 for (i=0;i<torture_numops;i++) {
3923 fstring fname;
3924 slprintf(fname, sizeof(fname), "\\%x", (int)random());
3925 fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
3926 if (fnum == -1) {
3927 fprintf(stderr,"Failed to open %s\n", fname);
3928 return False;
3929 }
3930 cli_close(cli, fnum);
3931 }
3932
3933 t1 = end_timer();
3934
3935 printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
3936 printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
3937 printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
3938
3939 printf("dirtest core %g seconds\n", end_timer() - t1);
3940
3941 srandom(0);
3942 for (i=0;i<torture_numops;i++) {
3943 fstring fname;
3944 slprintf(fname, sizeof(fname), "\\%x", (int)random());
3945 cli_unlink(cli, fname);
3946 }
3947
3948 if (!torture_close_connection(cli)) {
3949 correct = False;
3950 }
3951
3952 printf("finished dirtest\n");
3953
3954 return correct;
3955 }
3956
3957 static void del_fn(file_info *finfo, const char *mask, void *state)
3958 {
3959 struct cli_state *pcli = (struct cli_state *)state;
3960 fstring fname;
3961 slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name);
3962
3963 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
3964 return;
3965
3966 if (finfo->mode & aDIR) {
3967 if (!cli_rmdir(pcli, fname))
3968 printf("del_fn: failed to rmdir %s\n,", fname );
3969 } else {
3970 if (!cli_unlink(pcli, fname))
3971 printf("del_fn: failed to unlink %s\n,", fname );
3972 }
3973 }
3974
3975
3976 /*
3977 sees what IOCTLs are supported
3978 */
3979 BOOL torture_ioctl_test(int dummy)
3980 {
3981 static struct cli_state *cli;
3982 uint16 device, function;
3983 int fnum;
3984 const char *fname = "\\ioctl.dat";
3985 DATA_BLOB blob;
3986 NTSTATUS status;
3987
3988 if (!torture_open_connection(&cli)) {
3989 return False;
3990 }
3991
3992 printf("starting ioctl test\n");
3993
3994 cli_unlink(cli, fname);
3995
3996 fnum = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
3997 if (fnum == -1) {
3998 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
3999 return False;
4000 }
4001
4002 status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob);
4003 printf("ioctl device info: %s\n", cli_errstr(cli));
4004
4005 status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob);
4006 printf("ioctl job info: %s\n", cli_errstr(cli));
4007
4008 for (device=0;device<0x100;device++) {
4009 printf("testing device=0x%x\n", device);
4010 for (function=0;function<0x100;function++) {
4011 uint32 code = (device<<16) | function;
4012
4013 status = cli_raw_ioctl(cli, fnum, code, &blob);
4014
4015 if (NT_STATUS_IS_OK(status)) {
4016 printf("ioctl 0x%x OK : %d bytes\n", code, blob.length);
4017 data_blob_free(&blob);
4018 }
4019 }
4020 }
4021
4022 if (!torture_close_connection(cli)) {
4023 return False;
4024 }
4025
4026 return True;
4027 }
4028
4029
4030 /*
4031 tries varients of chkpath
4032 */
4033 BOOL torture_chkpath_test(int dummy)
4034 {
4035 static struct cli_state *cli;
4036 int fnum;
4037 BOOL ret;
4038
4039 if (!torture_open_connection(&cli)) {
4040 return False;
4041 }
4042
4043 printf("starting chkpath test\n");
4044
4045 /* cleanup from an old run */
4046 cli_rmdir(cli, "\\chkpath.dir\\dir2");
4047 cli_unlink(cli, "\\chkpath.dir\\*");
4048 cli_rmdir(cli, "\\chkpath.dir");
4049
4050 if (!cli_mkdir(cli, "\\chkpath.dir")) {
4051 printf("mkdir1 failed : %s\n", cli_errstr(cli));
4052 return False;
4053 }
4054
4055 if (!cli_mkdir(cli, "\\chkpath.dir\\dir2")) {
4056 printf("mkdir2 failed : %s\n", cli_errstr(cli));
4057 return False;
4058 }
4059
4060 fnum = cli_open(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
4061 if (fnum == -1) {
4062 printf("open1 failed (%s)\n", cli_errstr(cli));
4063 return False;
4064 }
4065 cli_close(cli, fnum);
4066
4067 if (!cli_chkpath(cli, "\\chkpath.dir")) {
4068 printf("chkpath1 failed: %s\n", cli_errstr(cli));
4069 ret = False;
4070 }
4071
4072 if (!cli_chkpath(cli, "\\chkpath.dir\\dir2")) {
4073 printf("chkpath2 failed: %s\n", cli_errstr(cli));
4074 ret = False;
4075 }
4076
4077 if (!cli_chkpath(cli, "\\chkpath.dir\\foo.txt")) {
4078 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
4079 NT_STATUS_NOT_A_DIRECTORY);
4080 } else {
4081 printf("* chkpath on a file should fail\n");
4082 ret = False;
4083 }
4084
4085 if (!cli_chkpath(cli, "\\chkpath.dir\\bar.txt")) {
4086 ret = check_error(__LINE__, cli, ERRDOS, ERRbadfile,
4087 NT_STATUS_OBJECT_NAME_NOT_FOUND);
4088 } else {
4089 printf("* chkpath on a non existant file should fail\n");
4090 ret = False;
4091 }
4092
4093 if (!cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt")) {
4094 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
4095 NT_STATUS_OBJECT_PATH_NOT_FOUND);
4096 } else {
4097 printf("* chkpath on a non existent component should fail\n");
4098 ret = False;
4099 }
4100
4101 cli_rmdir(cli, "\\chkpath.dir\\dir2");
4102 cli_unlink(cli, "\\chkpath.dir\\*");
4103 cli_rmdir(cli, "\\chkpath.dir");
4104
4105 if (!torture_close_connection(cli)) {
4106 return False;
4107 }
4108
4109 return ret;
4110 }
4111
4112
4113
4114
4115 static BOOL run_dirtest1(int dummy)
4116 {
4117 int i;
4118 static struct cli_state *cli;
4119 int fnum, num_seen;
4120 BOOL correct = True;
4121
4122 printf("starting directory test\n");
4123
4124 if (!torture_open_connection(&cli)) {
4125 return False;
4126 }
4127
4128 cli_sockopt(cli, sockops);
4129
4130 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
4131 cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
4132 cli_rmdir(cli, "\\LISTDIR");
4133 cli_mkdir(cli, "\\LISTDIR");
4134
4135 /* Create 1000 files and 1000 directories. */
4136 for (i=0;i<1000;i++) {
4137 fstring fname;
4138 slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i);
4139 fnum = cli_nt_create_full(cli, fname, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
4140 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0);
4141 if (fnum == -1) {
4142 fprintf(stderr,"Failed to open %s\n", fname);
4143 return False;
4144 }
4145 cli_close(cli, fnum);
4146 }
4147 for (i=0;i<1000;i++) {
4148 fstring fname;
4149 slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i);
4150 if (!cli_mkdir(cli, fname)) {
4151 fprintf(stderr,"Failed to open %s\n", fname);
4152 return False;
4153 }
4154 }
4155
4156 /* Now ensure that doing an old list sees both files and directories. */
4157 num_seen = cli_list_old(cli, "\\LISTDIR\\*", aDIR, list_fn, NULL);
4158 printf("num_seen = %d\n", num_seen );
4159 /* We should see 100 files + 1000 directories + . and .. */
4160 if (num_seen != 2002)
4161 correct = False;
4162
4163 /* Ensure if we have the "must have" bits we only see the
4164 * relevent entries.
4165 */
4166 num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aDIR<<8)|aDIR, list_fn, NULL);
4167 printf("num_seen = %d\n", num_seen );
4168 if (num_seen != 1002)
4169 correct = False;
4170
4171 num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aARCH<<8)|aDIR, list_fn, NULL);
4172 printf("num_seen = %d\n", num_seen );
4173 if (num_seen != 1000)
4174 correct = False;
4175
4176 /* Delete everything. */
4177 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
4178 cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
4179 cli_rmdir(cli, "\\LISTDIR");
4180
4181 #if 0
4182 printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
4183 printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
4184 printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
4185 #endif
4186
4187 if (!torture_close_connection(cli)) {
4188 correct = False;
4189 }
4190
4191 printf("finished dirtest1\n");
4192
4193 return correct;
4194 }
4195
4196 static BOOL run_error_map_extract(int dummy) {
4197
4198 static struct cli_state c_dos;
4199 static struct cli_state c_nt;
4200
4201 uint32 error;
4202
4203 uint32 flgs2, errnum;
4204 uint8 errclass;
4205
4206 NTSTATUS nt_status;
4207
4208 fstring user;
4209
4210 /* NT-Error connection */
4211
4212 if (!open_nbt_connection(&c_nt)) {
4213 return False;
4214 }
4215
4216 c_nt.use_spnego = False;
4217
4218 if (!cli_negprot(&c_nt)) {
4219 printf("%s rejected the NT-error negprot (%s)\n",host, cli_errstr(&c_nt));
4220 cli_shutdown(&c_nt);
4221 return False;
4222 }
4223
4224 if (!cli_session_setup(&c_nt, "", "", 0, "", 0,
4225 workgroup)) {
4226 printf("%s rejected the NT-error initial session setup (%s)\n",host, cli_errstr(&c_nt));
4227 return False;
4228 }
4229
4230 /* DOS-Error connection */
4231
4232 if (!open_nbt_connection(&c_dos)) {
4233 return False;
4234 }
4235
4236 c_dos.use_spnego = False;
4237 c_dos.force_dos_errors = True;
4238
4239 if (!cli_negprot(&c_dos)) {
4240 printf("%s rejected the DOS-error negprot (%s)\n",host, cli_errstr(&c_dos));
4241 cli_shutdown(&c_dos);
4242 return False;
4243 }
4244
4245 if (!cli_session_setup(&c_dos, "", "", 0, "", 0,
4246 workgroup)) {
4247 printf("%s rejected the DOS-error initial session setup (%s)\n",host, cli_errstr(&c_dos));
4248 return False;
4249 }
4250
4251 for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) {
4252 snprintf(user, sizeof(user), "%X", error);
4253
4254 if (cli_session_setup(&c_nt, user,
4255 password, strlen(password),
4256 password, strlen(password),
4257 workgroup)) {
4258 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
4259 }
4260
4261 flgs2 = SVAL(c_nt.inbuf,smb_flg2);
4262
4263 /* Case #1: 32-bit NT errors */
4264 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
4265 nt_status = NT_STATUS(IVAL(c_nt.inbuf,smb_rcls));
4266 } else {
4267 printf("/** Dos error on NT connection! (%s) */\n",
4268 cli_errstr(&c_nt));
4269 nt_status = NT_STATUS(0xc0000000);
4270 }
4271
4272 if (cli_session_setup(&c_dos, user,
4273 password, strlen(password),
4274 password, strlen(password),
4275 workgroup)) {
4276 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
4277 }
4278 flgs2 = SVAL(c_dos.inbuf,smb_flg2), errnum;
4279
4280 /* Case #1: 32-bit NT errors */
4281 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
4282 printf("/** NT error on DOS connection! (%s) */\n",
4283 cli_errstr(&c_nt));
4284 errnum = errclass = 0;
4285 } else {
4286 cli_dos_error(&c_dos, &errclass, &errnum);
4287 }
4288
4289 if (NT_STATUS_V(nt_status) != error) {
4290 printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n",
4291 get_nt_error_c_code(NT_STATUS(error)),
4292 get_nt_error_c_code(nt_status));
4293 }
4294
4295 printf("\t{%s,\t%s,\t%s},\n",
4296 smb_dos_err_class(errclass),
4297 smb_dos_err_name(errclass, errnum),
4298 get_nt_error_c_code(NT_STATUS(error)));
4299 }
4300 return True;
4301 }
4302
4303 static double create_procs(BOOL (*fn)(int), BOOL *result)
4304 {
4305 int i, status;
4306 volatile pid_t *child_status;
4307 volatile BOOL *child_status_out;
4308 int synccount;
4309 int tries = 8;
4310
4311 synccount = 0;
4312
4313 child_status = (volatile pid_t *)shm_setup(sizeof(pid_t)*nprocs);
4314 if (!child_status) {
4315 printf("Failed to setup shared memory\n");
4316 return -1;
4317 }
4318
4319 child_status_out = (volatile BOOL *)shm_setup(sizeof(BOOL)*nprocs);
4320 if (!child_status_out) {
4321 printf("Failed to setup result status shared memory\n");
4322 return -1;
4323 }
4324
4325 for (i = 0; i < nprocs; i++) {
4326 child_status[i] = 0;
4327 child_status_out[i] = True;
4328 }
4329
4330 start_timer();
4331
4332 for (i=0;i<nprocs;i++) {
4333 procnum = i;
4334 if (fork() == 0) {
4335 pid_t mypid = getpid();
4336 sys_srandom(((int)mypid) ^ ((int)time(NULL)));
4337
4338 slprintf(myname,sizeof(myname),"CLIENT%d", i);
4339
4340 while (1) {
4341 if (torture_open_connection(&current_cli)) break;
4342 if (tries-- == 0) {
4343 printf("pid %d failed to start\n", (int)getpid());
4344 _exit(1);
4345 }
4346 msleep(10);
4347 }
4348
4349 child_status[i] = getpid();
4350
4351 while (child_status[i] && end_timer() < 5) msleep(2);
4352
4353 child_status_out[i] = fn(i);
4354 _exit(0);
4355 }
4356 }
4357
4358 do {
4359 synccount = 0;
4360 for (i=0;i<nprocs;i++) {
4361 if (child_status[i]) synccount++;
4362 }
4363 if (synccount == nprocs) break;
4364 msleep(10);
4365 } while (end_timer() < 30);
4366
4367 if (synccount != nprocs) {
4368 printf("FAILED TO START %d CLIENTS (started %d)\n", nprocs, synccount);
4369 *result = False;
4370 return end_timer();
4371 }
4372
4373 /* start the client load */
4374 start_timer();
4375
4376 for (i=0;i<nprocs;i++) {
4377 child_status[i] = 0;
4378 }
4379
4380 printf("%d clients started\n", nprocs);
4381
4382 for (i=0;i<nprocs;i++) {
4383 while (waitpid(0, &status, 0) == -1 && errno == EINTR) /* noop */ ;
4384 }
4385
4386 printf("\n");
4387
4388 for (i=0;i<nprocs;i++) {
4389 if (!child_status_out[i]) {
4390 *result = False;
4391 }
4392 }
4393 return end_timer();
4394 }
4395
4396 #define FLAG_MULTIPROC 1
4397
4398 static struct {
4399 const char *name;
4400 BOOL (*fn)(int);
4401 unsigned flags;
4402 } torture_ops[] = {
4403 {"FDPASS", run_fdpasstest, 0},
4404 {"LOCK1", run_locktest1, 0},
4405 {"LOCK2", run_locktest2, 0},
4406 {"LOCK3", run_locktest3, 0},
4407 {"LOCK4", run_locktest4, 0},
4408 {"LOCK5", run_locktest5, 0},
4409 {"LOCK6", run_locktest6, 0},
4410 {"LOCK7", run_locktest7, 0},
4411 {"UNLINK", run_unlinktest, 0},
4412 {"BROWSE", run_browsetest, 0},
4413 {"ATTR", run_attrtest, 0},
4414 {"TRANS2", run_trans2test, 0},
4415 {"MAXFID", run_maxfidtest, FLAG_MULTIPROC},
4416 {"TORTURE",run_torture, FLAG_MULTIPROC},
4417 {"RANDOMIPC", run_randomipc, 0},
4418 {"NEGNOWAIT", run_negprot_nowait, 0},
4419 {"NBENCH", run_nbench, 0},
4420 {"OPLOCK1", run_oplock1, 0},
4421 {"OPLOCK2", run_oplock2, 0},
4422 {"OPLOCK3", run_oplock3, 0},
4423 {"DIR", run_dirtest, 0},
4424 {"DIR1", run_dirtest1, 0},
4425 {"DENY1", torture_denytest1, 0},
4426 {"DENY2", torture_denytest2, 0},
4427 {"TCON", run_tcon_test, 0},
4428 {"TCONDEV", run_tcon_devtype_test, 0},
4429 {"RW1", run_readwritetest, 0},
4430 {"RW2", run_readwritemulti, FLAG_MULTIPROC},
4431 {"RW3", run_readwritelarge, 0},
4432 {"OPEN", run_opentest, 0},
4433 #if 1
4434 {"OPENATTR", run_openattrtest, 0},
4435 #endif
4436 {"XCOPY", run_xcopy, 0},
4437 {"RENAME", run_rename, 0},
4438 {"DELETE", run_deletetest, 0},
4439 {"PROPERTIES", run_properties, 0},
4440 {"MANGLE", torture_mangle, 0},
4441 {"W2K", run_w2ktest, 0},
4442 {"TRANS2SCAN", torture_trans2_scan, 0},
4443 {"NTTRANSSCAN", torture_nttrans_scan, 0},
4444 {"UTABLE", torture_utable, 0},
4445 {"CASETABLE", torture_casetable, 0},
4446 {"ERRMAPEXTRACT", run_error_map_extract, 0},
4447 {"PIPE_NUMBER", run_pipe_number, 0},
4448 {"TCON2", run_tcon2_test, 0},
4449 {"IOCTL", torture_ioctl_test, 0},
4450 {"CHKPATH", torture_chkpath_test, 0},
4451 {NULL, NULL, 0}};
4452
4453
4454
4455 /****************************************************************************
4456 run a specified test or "ALL"
4457 ****************************************************************************/
4458 static BOOL run_test(const char *name)
4459 {
4460 BOOL ret = True;
4461 BOOL result = True;
4462 int i;
4463 double t;
4464 if (strequal(name,"ALL")) {
4465 for (i=0;torture_ops[i].name;i++) {
4466 run_test(torture_ops[i].name);
4467 }
4468 }
4469
4470 for (i=0;torture_ops[i].name;i++) {
4471 snprintf(randomfname, sizeof(randomfname), "\\XX%x",
4472 (unsigned)random());
4473
4474 if (strequal(name, torture_ops[i].name)) {
4475 printf("Running %s\n", name);
4476 if (torture_ops[i].flags & FLAG_MULTIPROC) {
4477 t = create_procs(torture_ops[i].fn, &result);
4478 if (!result) {
4479 ret = False;
4480 printf("TEST %s FAILED!\n", name);
4481 }
4482
4483 } else {
4484 start_timer();
4485 if (!torture_ops[i].fn(0)) {
4486 ret = False;
4487 printf("TEST %s FAILED!\n", name);
4488 }
4489 t = end_timer();
4490 }
4491 printf("%s took %g secs\n\n", name, t);
4492 }
4493 }
4494 return ret;
4495 }
4496
4497
4498 static void usage(void)
4499 {
4500 int i;
4501
4502 printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
4503
4504 printf("\t-d debuglevel\n");
4505 printf("\t-U user%%pass\n");
4506 printf("\t-k use kerberos\n");
4507 printf("\t-N numprocs\n");
4508 printf("\t-n my_netbios_name\n");
4509 printf("\t-W workgroup\n");
4510 printf("\t-o num_operations\n");
4511 printf("\t-O socket_options\n");
4512 printf("\t-m maximum protocol\n");
4513 printf("\t-L use oplocks\n");
4514 printf("\t-c CLIENT.TXT specify client load file for NBENCH\n");
4515 printf("\t-A showall\n");
4516 printf("\t-p port\n");
4517 printf("\t-s seed\n");
4518 printf("\n\n");
4519
4520 printf("tests are:");
4521 for (i=0;torture_ops[i].name;i++) {
4522 printf(" %s", torture_ops[i].name);
4523 }
4524 printf("\n");
4525
4526 printf("default test is ALL\n");
4527
4528 exit(1);
4529 }
4530
4531 /****************************************************************************
4532 main program
4533 ****************************************************************************/
4534 int main(int argc,char *argv[])
4535 {
4536 int opt, i;
4537 char *p;
4538 int gotuser = 0;
4539 int gotpass = 0;
4540 extern char *optarg;
4541 extern int optind;
4542 BOOL correct = True;
4543
4544 dbf = x_stdout;
4545
4546 #ifdef HAVE_SETBUFFER
4547 setbuffer(stdout, NULL, 0);
4548 #endif
4549
4550 lp_load(dyn_CONFIGFILE,True,False,False);
4551 load_interfaces();
4552
4553 if (argc < 2) {
4554 usage();
4555 }
4556
4557 for(p = argv[1]; *p; p++)
4558 if(*p == '\\')
4559 *p = '/';
4560
4561 if (strncmp(argv[1], "//", 2)) {
4562 usage();
4563 }
4564
4565 fstrcpy(host, &argv[1][2]);
4566 p = strchr_m(&host[2],'/');
4567 if (!p) {
4568 usage();
4569 }
4570 *p = 0;
4571 fstrcpy(share, p+1);
4572
4573 get_myname(myname);
4574
4575 if (*username == 0 && getenv("LOGNAME")) {
4576 fstrcpy(username,getenv("LOGNAME"));
4577 }
4578
4579 argc--;
4580 argv++;
4581
4582 srandom(time(NULL));
4583
4584 fstrcpy(workgroup, lp_workgroup());
4585
4586 while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ld:Ac:ks:")) != EOF) {
4587 switch (opt) {
4588 case 'p':
4589 port_to_use = atoi(optarg);
4590 break;
4591 case 's':
4592 srandom(atoi(optarg));
4593 break;
4594 case 'W':
4595 fstrcpy(workgroup,optarg);
4596 break;
4597 case 'm':
4598 max_protocol = interpret_protocol(optarg, max_protocol);
4599 break;
4600 case 'N':
4601 nprocs = atoi(optarg);
4602 break;
4603 case 'o':
4604 torture_numops = atoi(optarg);
4605 break;
4606 case 'd':
4607 DEBUGLEVEL = atoi(optarg);
4608 break;
4609 case 'O':
4610 sockops = optarg;
4611 break;
4612 case 'L':
4613 use_oplocks = True;
4614 break;
4615 case 'A':
4616 torture_showall = True;
4617 break;
4618 case 'n':
4619 fstrcpy(myname, optarg);
4620 break;
4621 case 'c':
4622 client_txt = optarg;
4623 break;
4624 case 'k':
4625 #ifdef HAVE_KRB5
4626 use_kerberos = True;
4627 #else
4628 d_printf("No kerberos support compiled in\n");
4629 exit(1);
4630 #endif
4631 break;
4632 case 'U':
4633 gotuser = 1;
4634 fstrcpy(username,optarg);
4635 p = strchr_m(username,'%');
4636 if (p) {
4637 *p = 0;
4638 fstrcpy(password, p+1);
4639 gotpass = 1;
4640 }
4641 break;
4642 default:
4643 printf("Unknown option %c (%d)\n", (char)opt, opt);
4644 usage();
4645 }
4646 }
4647
4648 if(use_kerberos && !gotuser) gotpass = True;
4649
4650 while (!gotpass) {
4651 p = getpass("Password:");
4652 if (p) {
4653 fstrcpy(password, p);
4654 gotpass = 1;
4655 }
4656 }
4657
4658 printf("host=%s share=%s user=%s myname=%s\n",
4659 host, share, username, myname);
4660
4661 if (argc == 1) {
4662 correct = run_test("ALL");
4663 } else {
4664 for (i=1;i<argc;i++) {
4665 if (!run_test(argv[i])) {
4666 correct = False;
4667 }
4668 }
4669 }
4670
4671 if (correct) {
4672 return(0);
4673 } else {
4674 return(1);
4675 }
4676 }
reg import