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