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