?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:fix the merged build of bin/smbtorture4
[Samba/ekacnet.git] / source3 / torture / torture.c
blob5407f3c20eeb98d1619f12c92c10a252d34820b3
1 /*
2 Unix SMB/CIFS implementation.
3 SMB torture tester
4 Copyright (C) Andrew Tridgell 1997-1998
5 Copyright (C) Jeremy Allison 2009
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "nsswitch/libwbclient/wbc_async.h"
23 #include "torture/proto.h"
24
25 extern char *optarg;
26 extern int optind;
27
28 static fstring host, workgroup, share, password, username, myname;
29 static int max_protocol = PROTOCOL_NT1;
30 static const char *sockops="TCP_NODELAY";
31 static int nprocs=1;
32 static int port_to_use=0;
33 int torture_numops=100;
34 int torture_blocksize=1024*1024;
35 static int procnum; /* records process count number when forking */
36 static struct cli_state *current_cli;
37 static fstring randomfname;
38 static bool use_oplocks;
39 static bool use_level_II_oplocks;
40 static const char *client_txt = "client_oplocks.txt";
41 static bool use_kerberos;
42 static fstring multishare_conn_fname;
43 static bool use_multishare_conn = False;
44 static bool do_encrypt;
45 static const char *local_path = NULL;
46
47 bool torture_showall = False;
48
49 static double create_procs(bool (*fn)(int), bool *result);
50
51
52 static struct timeval tp1,tp2;
53
54
55 void start_timer(void)
56 {
57 GetTimeOfDay(&tp1);
58 }
59
60 double end_timer(void)
61 {
62 GetTimeOfDay(&tp2);
63 return((tp2.tv_sec - tp1.tv_sec) +
64 (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
65 }
66
67
68 /* return a pointer to a anonymous shared memory segment of size "size"
69 which will persist across fork() but will disappear when all processes
70 exit
71
72 The memory is not zeroed
73
74 This function uses system5 shared memory. It takes advantage of a property
75 that the memory is not destroyed if it is attached when the id is removed
76 */
77 void *shm_setup(int size)
78 {
79 int shmid;
80 void *ret;
81
82 #ifdef __QNXNTO__
83 shmid = shm_open("private", O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
84 if (shmid == -1) {
85 printf("can't get shared memory\n");
86 exit(1);
87 }
88 shm_unlink("private");
89 if (ftruncate(shmid, size) == -1) {
90 printf("can't set shared memory size\n");
91 exit(1);
92 }
93 ret = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, shmid, 0);
94 if (ret == MAP_FAILED) {
95 printf("can't map shared memory\n");
96 exit(1);
97 }
98 #else
99 shmid = shmget(IPC_PRIVATE, size, S_IRUSR | S_IWUSR);
100 if (shmid == -1) {
101 printf("can't get shared memory\n");
102 exit(1);
103 }
104 ret = (void *)shmat(shmid, 0, 0);
105 if (!ret || ret == (void *)-1) {
106 printf("can't attach to shared memory\n");
107 return NULL;
108 }
109 /* the following releases the ipc, but note that this process
110 and all its children will still have access to the memory, its
111 just that the shmid is no longer valid for other shm calls. This
112 means we don't leave behind lots of shm segments after we exit
113
114 See Stevens "advanced programming in unix env" for details
115 */
116 shmctl(shmid, IPC_RMID, 0);
117 #endif
118
119 return ret;
120 }
121
122 /********************************************************************
123 Ensure a connection is encrypted.
124 ********************************************************************/
125
126 static bool force_cli_encryption(struct cli_state *c,
127 const char *sharename)
128 {
129 uint16 major, minor;
130 uint32 caplow, caphigh;
131 NTSTATUS status;
132
133 if (!SERVER_HAS_UNIX_CIFS(c)) {
134 d_printf("Encryption required and "
135 "server that doesn't support "
136 "UNIX extensions - failing connect\n");
137 return false;
138 }
139
140 status = cli_unix_extensions_version(c, &major, &minor, &caplow,
141 &caphigh);
142 if (!NT_STATUS_IS_OK(status)) {
143 d_printf("Encryption required and "
144 "can't get UNIX CIFS extensions "
145 "version from server: %s\n", nt_errstr(status));
146 return false;
147 }
148
149 if (!(caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)) {
150 d_printf("Encryption required and "
151 "share %s doesn't support "
152 "encryption.\n", sharename);
153 return false;
154 }
155
156 if (c->use_kerberos) {
157 status = cli_gss_smb_encryption_start(c);
158 } else {
159 status = cli_raw_ntlm_smb_encryption_start(c,
160 username,
161 password,
162 workgroup);
163 }
164
165 if (!NT_STATUS_IS_OK(status)) {
166 d_printf("Encryption required and "
167 "setup failed with error %s.\n",
168 nt_errstr(status));
169 return false;
170 }
171
172 return true;
173 }
174
175
176 static struct cli_state *open_nbt_connection(void)
177 {
178 struct nmb_name called, calling;
179 struct sockaddr_storage ss;
180 struct cli_state *c;
181 NTSTATUS status;
182
183 make_nmb_name(&calling, myname, 0x0);
184 make_nmb_name(&called , host, 0x20);
185
186 zero_sockaddr(&ss);
187
188 if (!(c = cli_initialise())) {
189 printf("Failed initialize cli_struct to connect with %s\n", host);
190 return NULL;
191 }
192
193 c->port = port_to_use;
194
195 status = cli_connect(c, host, &ss);
196 if (!NT_STATUS_IS_OK(status)) {
197 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
198 return NULL;
199 }
200
201 c->use_kerberos = use_kerberos;
202
203 c->timeout = 120000; /* set a really long timeout (2 minutes) */
204 if (use_oplocks) c->use_oplocks = True;
205 if (use_level_II_oplocks) c->use_level_II_oplocks = True;
206
207 if (!cli_session_request(c, &calling, &called)) {
208 /*
209 * Well, that failed, try *SMBSERVER ...
210 * However, we must reconnect as well ...
211 */
212 status = cli_connect(c, host, &ss);
213 if (!NT_STATUS_IS_OK(status)) {
214 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
215 return NULL;
216 }
217
218 make_nmb_name(&called, "*SMBSERVER", 0x20);
219 if (!cli_session_request(c, &calling, &called)) {
220 printf("%s rejected the session\n",host);
221 printf("We tried with a called name of %s & %s\n",
222 host, "*SMBSERVER");
223 cli_shutdown(c);
224 return NULL;
225 }
226 }
227
228 return c;
229 }
230
231 /* Insert a NULL at the first separator of the given path and return a pointer
232 * to the remainder of the string.
233 */
234 static char *
235 terminate_path_at_separator(char * path)
236 {
237 char * p;
238
239 if (!path) {
240 return NULL;
241 }
242
243 if ((p = strchr_m(path, '/'))) {
244 *p = '\0';
245 return p + 1;
246 }
247
248 if ((p = strchr_m(path, '\\'))) {
249 *p = '\0';
250 return p + 1;
251 }
252
253 /* No separator. */
254 return NULL;
255 }
256
257 /*
258 parse a //server/share type UNC name
259 */
260 bool smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
261 char **hostname, char **sharename)
262 {
263 char *p;
264
265 *hostname = *sharename = NULL;
266
267 if (strncmp(unc_name, "\\\\", 2) &&
268 strncmp(unc_name, "//", 2)) {
269 return False;
270 }
271
272 *hostname = talloc_strdup(mem_ctx, &unc_name[2]);
273 p = terminate_path_at_separator(*hostname);
274
275 if (p && *p) {
276 *sharename = talloc_strdup(mem_ctx, p);
277 terminate_path_at_separator(*sharename);
278 }
279
280 if (*hostname && *sharename) {
281 return True;
282 }
283
284 TALLOC_FREE(*hostname);
285 TALLOC_FREE(*sharename);
286 return False;
287 }
288
289 static bool torture_open_connection_share(struct cli_state **c,
290 const char *hostname,
291 const char *sharename)
292 {
293 bool retry;
294 int flags = 0;
295 NTSTATUS status;
296
297 if (use_kerberos)
298 flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
299 if (use_oplocks)
300 flags |= CLI_FULL_CONNECTION_OPLOCKS;
301 if (use_level_II_oplocks)
302 flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS;
303
304 status = cli_full_connection(c, myname,
305 hostname, NULL, port_to_use,
306 sharename, "?????",
307 username, workgroup,
308 password, flags, Undefined, &retry);
309 if (!NT_STATUS_IS_OK(status)) {
310 printf("failed to open share connection: //%s/%s port:%d - %s\n",
311 hostname, sharename, port_to_use, nt_errstr(status));
312 return False;
313 }
314
315 (*c)->timeout = 120000; /* set a really long timeout (2 minutes) */
316
317 if (do_encrypt) {
318 return force_cli_encryption(*c,
319 sharename);
320 }
321 return True;
322 }
323
324 bool torture_open_connection(struct cli_state **c, int conn_index)
325 {
326 char **unc_list = NULL;
327 int num_unc_names = 0;
328 bool result;
329
330 if (use_multishare_conn==True) {
331 char *h, *s;
332 unc_list = file_lines_load(multishare_conn_fname, &num_unc_names, 0, NULL);
333 if (!unc_list || num_unc_names <= 0) {
334 printf("Failed to load unc names list from '%s'\n", multishare_conn_fname);
335 exit(1);
336 }
337
338 if (!smbcli_parse_unc(unc_list[conn_index % num_unc_names],
339 NULL, &h, &s)) {
340 printf("Failed to parse UNC name %s\n",
341 unc_list[conn_index % num_unc_names]);
342 TALLOC_FREE(unc_list);
343 exit(1);
344 }
345
346 result = torture_open_connection_share(c, h, s);
347
348 /* h, s were copied earlier */
349 TALLOC_FREE(unc_list);
350 return result;
351 }
352
353 return torture_open_connection_share(c, host, share);
354 }
355
356 bool torture_cli_session_setup2(struct cli_state *cli, uint16 *new_vuid)
357 {
358 uint16 old_vuid = cli->vuid;
359 fstring old_user_name;
360 size_t passlen = strlen(password);
361 NTSTATUS status;
362 bool ret;
363
364 fstrcpy(old_user_name, cli->user_name);
365 cli->vuid = 0;
366 ret = NT_STATUS_IS_OK(cli_session_setup(cli, username,
367 password, passlen,
368 password, passlen,
369 workgroup));
370 *new_vuid = cli->vuid;
371 cli->vuid = old_vuid;
372 status = cli_set_username(cli, old_user_name);
373 if (!NT_STATUS_IS_OK(status)) {
374 return false;
375 }
376 return ret;
377 }
378
379
380 bool torture_close_connection(struct cli_state *c)
381 {
382 bool ret = True;
383 if (!cli_tdis(c)) {
384 printf("tdis failed (%s)\n", cli_errstr(c));
385 ret = False;
386 }
387
388 cli_shutdown(c);
389
390 return ret;
391 }
392
393
394 /* check if the server produced the expected error code */
395 static bool check_error(int line, struct cli_state *c,
396 uint8 eclass, uint32 ecode, NTSTATUS nterr)
397 {
398 if (cli_is_dos_error(c)) {
399 uint8 cclass;
400 uint32 num;
401
402 /* Check DOS error */
403
404 cli_dos_error(c, &cclass, &num);
405
406 if (eclass != cclass || ecode != num) {
407 printf("unexpected error code class=%d code=%d\n",
408 (int)cclass, (int)num);
409 printf(" expected %d/%d %s (line=%d)\n",
410 (int)eclass, (int)ecode, nt_errstr(nterr), line);
411 return False;
412 }
413
414 } else {
415 NTSTATUS status;
416
417 /* Check NT error */
418
419 status = cli_nt_error(c);
420
421 if (NT_STATUS_V(nterr) != NT_STATUS_V(status)) {
422 printf("unexpected error code %s\n", nt_errstr(status));
423 printf(" expected %s (line=%d)\n", nt_errstr(nterr), line);
424 return False;
425 }
426 }
427
428 return True;
429 }
430
431
432 static bool wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len)
433 {
434 while (!cli_lock(c, fnum, offset, len, -1, WRITE_LOCK)) {
435 if (!check_error(__LINE__, c, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
436 }
437 return True;
438 }
439
440
441 static bool rw_torture(struct cli_state *c)
442 {
443 const char *lockfname = "\\torture.lck";
444 fstring fname;
445 uint16_t fnum;
446 uint16_t fnum2;
447 pid_t pid2, pid = getpid();
448 int i, j;
449 char buf[1024];
450 bool correct = True;
451 NTSTATUS status;
452
453 memset(buf, '\0', sizeof(buf));
454
455 status = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
456 DENY_NONE, &fnum2);
457 if (!NT_STATUS_IS_OK(status)) {
458 status = cli_open(c, lockfname, O_RDWR, DENY_NONE, &fnum2);
459 }
460 if (!NT_STATUS_IS_OK(status)) {
461 printf("open of %s failed (%s)\n", lockfname, cli_errstr(c));
462 return False;
463 }
464
465 for (i=0;i<torture_numops;i++) {
466 unsigned n = (unsigned)sys_random()%10;
467 if (i % 10 == 0) {
468 printf("%d\r", i); fflush(stdout);
469 }
470 slprintf(fname, sizeof(fstring) - 1, "\\torture.%u", n);
471
472 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
473 return False;
474 }
475
476 if (!NT_STATUS_IS_OK(cli_open(c, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL, &fnum))) {
477 printf("open failed (%s)\n", cli_errstr(c));
478 correct = False;
479 break;
480 }
481
482 if (cli_write(c, fnum, 0, (char *)&pid, 0, sizeof(pid)) != sizeof(pid)) {
483 printf("write failed (%s)\n", cli_errstr(c));
484 correct = False;
485 }
486
487 for (j=0;j<50;j++) {
488 if (cli_write(c, fnum, 0, (char *)buf,
489 sizeof(pid)+(j*sizeof(buf)),
490 sizeof(buf)) != sizeof(buf)) {
491 printf("write failed (%s)\n", cli_errstr(c));
492 correct = False;
493 }
494 }
495
496 pid2 = 0;
497
498 if (cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid)) != sizeof(pid)) {
499 printf("read failed (%s)\n", cli_errstr(c));
500 correct = False;
501 }
502
503 if (pid2 != pid) {
504 printf("data corruption!\n");
505 correct = False;
506 }
507
508 if (!NT_STATUS_IS_OK(cli_close(c, fnum))) {
509 printf("close failed (%s)\n", cli_errstr(c));
510 correct = False;
511 }
512
513 if (!NT_STATUS_IS_OK(cli_unlink(c, fname, aSYSTEM | aHIDDEN))) {
514 printf("unlink failed (%s)\n", cli_errstr(c));
515 correct = False;
516 }
517
518 if (!NT_STATUS_IS_OK(cli_unlock(c, fnum2, n*sizeof(int), sizeof(int)))) {
519 printf("unlock failed (%s)\n", cli_errstr(c));
520 correct = False;
521 }
522 }
523
524 cli_close(c, fnum2);
525 cli_unlink(c, lockfname, aSYSTEM | aHIDDEN);
526
527 printf("%d\n", i);
528
529 return correct;
530 }
531
532 static bool run_torture(int dummy)
533 {
534 struct cli_state *cli;
535 bool ret;
536
537 cli = current_cli;
538
539 cli_sockopt(cli, sockops);
540
541 ret = rw_torture(cli);
542
543 if (!torture_close_connection(cli)) {
544 ret = False;
545 }
546
547 return ret;
548 }
549
550 static bool rw_torture3(struct cli_state *c, char *lockfname)
551 {
552 uint16_t fnum = (uint16_t)-1;
553 unsigned int i = 0;
554 char buf[131072];
555 char buf_rd[131072];
556 unsigned count;
557 unsigned countprev = 0;
558 ssize_t sent = 0;
559 bool correct = True;
560 NTSTATUS status;
561
562 srandom(1);
563 for (i = 0; i < sizeof(buf); i += sizeof(uint32))
564 {
565 SIVAL(buf, i, sys_random());
566 }
567
568 if (procnum == 0)
569 {
570 if (!NT_STATUS_IS_OK(cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
571 DENY_NONE, &fnum))) {
572 printf("first open read/write of %s failed (%s)\n",
573 lockfname, cli_errstr(c));
574 return False;
575 }
576 }
577 else
578 {
579 for (i = 0; i < 500 && fnum == (uint16_t)-1; i++)
580 {
581 status = cli_open(c, lockfname, O_RDONLY,
582 DENY_NONE, &fnum);
583 if (!NT_STATUS_IS_OK(status)) {
584 break;
585 }
586 smb_msleep(10);
587 }
588 if (!NT_STATUS_IS_OK(status)) {
589 printf("second open read-only of %s failed (%s)\n",
590 lockfname, cli_errstr(c));
591 return False;
592 }
593 }
594
595 i = 0;
596 for (count = 0; count < sizeof(buf); count += sent)
597 {
598 if (count >= countprev) {
599 printf("%d %8d\r", i, count);
600 fflush(stdout);
601 i++;
602 countprev += (sizeof(buf) / 20);
603 }
604
605 if (procnum == 0)
606 {
607 sent = ((unsigned)sys_random()%(20))+ 1;
608 if (sent > sizeof(buf) - count)
609 {
610 sent = sizeof(buf) - count;
611 }
612
613 if (cli_write(c, fnum, 0, buf+count, count, (size_t)sent) != sent) {
614 printf("write failed (%s)\n", cli_errstr(c));
615 correct = False;
616 }
617 }
618 else
619 {
620 sent = cli_read(c, fnum, buf_rd+count, count,
621 sizeof(buf)-count);
622 if (sent < 0)
623 {
624 printf("read failed offset:%d size:%ld (%s)\n",
625 count, (unsigned long)sizeof(buf)-count,
626 cli_errstr(c));
627 correct = False;
628 sent = 0;
629 }
630 if (sent > 0)
631 {
632 if (memcmp(buf_rd+count, buf+count, sent) != 0)
633 {
634 printf("read/write compare failed\n");
635 printf("offset: %d req %ld recvd %ld\n", count, (unsigned long)sizeof(buf)-count, (unsigned long)sent);
636 correct = False;
637 break;
638 }
639 }
640 }
641
642 }
643
644 if (!NT_STATUS_IS_OK(cli_close(c, fnum))) {
645 printf("close failed (%s)\n", cli_errstr(c));
646 correct = False;
647 }
648
649 return correct;
650 }
651
652 static bool rw_torture2(struct cli_state *c1, struct cli_state *c2)
653 {
654 const char *lockfname = "\\torture2.lck";
655 uint16_t fnum1;
656 uint16_t fnum2;
657 int i;
658 char buf[131072];
659 char buf_rd[131072];
660 bool correct = True;
661 ssize_t bytes_read;
662
663 if (!NT_STATUS_IS_OK(cli_unlink(c1, lockfname, aSYSTEM | aHIDDEN))) {
664 printf("unlink failed (%s) (normal, this file should not exist)\n", cli_errstr(c1));
665 }
666
667 if (!NT_STATUS_IS_OK(cli_open(c1, lockfname, O_RDWR | O_CREAT | O_EXCL,
668 DENY_NONE, &fnum1))) {
669 printf("first open read/write of %s failed (%s)\n",
670 lockfname, cli_errstr(c1));
671 return False;
672 }
673 if (!NT_STATUS_IS_OK(cli_open(c2, lockfname, O_RDONLY,
674 DENY_NONE, &fnum2))) {
675 printf("second open read-only of %s failed (%s)\n",
676 lockfname, cli_errstr(c2));
677 cli_close(c1, fnum1);
678 return False;
679 }
680
681 for (i=0;i<torture_numops;i++)
682 {
683 size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
684 if (i % 10 == 0) {
685 printf("%d\r", i); fflush(stdout);
686 }
687
688 generate_random_buffer((unsigned char *)buf, buf_size);
689
690 if (cli_write(c1, fnum1, 0, buf, 0, buf_size) != buf_size) {
691 printf("write failed (%s)\n", cli_errstr(c1));
692 correct = False;
693 break;
694 }
695
696 if ((bytes_read = cli_read(c2, fnum2, buf_rd, 0, buf_size)) != buf_size) {
697 printf("read failed (%s)\n", cli_errstr(c2));
698 printf("read %d, expected %ld\n", (int)bytes_read,
699 (unsigned long)buf_size);
700 correct = False;
701 break;
702 }
703
704 if (memcmp(buf_rd, buf, buf_size) != 0)
705 {
706 printf("read/write compare failed\n");
707 correct = False;
708 break;
709 }
710 }
711
712 if (!NT_STATUS_IS_OK(cli_close(c2, fnum2))) {
713 printf("close failed (%s)\n", cli_errstr(c2));
714 correct = False;
715 }
716 if (!NT_STATUS_IS_OK(cli_close(c1, fnum1))) {
717 printf("close failed (%s)\n", cli_errstr(c1));
718 correct = False;
719 }
720
721 if (!NT_STATUS_IS_OK(cli_unlink(c1, lockfname, aSYSTEM | aHIDDEN))) {
722 printf("unlink failed (%s)\n", cli_errstr(c1));
723 correct = False;
724 }
725
726 return correct;
727 }
728
729 static bool run_readwritetest(int dummy)
730 {
731 struct cli_state *cli1, *cli2;
732 bool test1, test2 = False;
733
734 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
735 return False;
736 }
737 cli_sockopt(cli1, sockops);
738 cli_sockopt(cli2, sockops);
739
740 printf("starting readwritetest\n");
741
742 test1 = rw_torture2(cli1, cli2);
743 printf("Passed readwritetest v1: %s\n", BOOLSTR(test1));
744
745 if (test1) {
746 test2 = rw_torture2(cli1, cli1);
747 printf("Passed readwritetest v2: %s\n", BOOLSTR(test2));
748 }
749
750 if (!torture_close_connection(cli1)) {
751 test1 = False;
752 }
753
754 if (!torture_close_connection(cli2)) {
755 test2 = False;
756 }
757
758 return (test1 && test2);
759 }
760
761 static bool run_readwritemulti(int dummy)
762 {
763 struct cli_state *cli;
764 bool test;
765
766 cli = current_cli;
767
768 cli_sockopt(cli, sockops);
769
770 printf("run_readwritemulti: fname %s\n", randomfname);
771 test = rw_torture3(cli, randomfname);
772
773 if (!torture_close_connection(cli)) {
774 test = False;
775 }
776
777 return test;
778 }
779
780 static bool run_readwritelarge(int dummy)
781 {
782 static struct cli_state *cli1;
783 uint16_t fnum1;
784 const char *lockfname = "\\large.dat";
785 SMB_OFF_T fsize;
786 char buf[126*1024];
787 bool correct = True;
788
789 if (!torture_open_connection(&cli1, 0)) {
790 return False;
791 }
792 cli_sockopt(cli1, sockops);
793 memset(buf,'\0',sizeof(buf));
794
795 cli1->max_xmit = 128*1024;
796
797 printf("starting readwritelarge\n");
798
799 cli_unlink(cli1, lockfname, aSYSTEM | aHIDDEN);
800
801 if (!NT_STATUS_IS_OK(cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE, &fnum1))) {
802 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
803 return False;
804 }
805
806 cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf));
807
808 if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
809 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
810 correct = False;
811 }
812
813 if (fsize == sizeof(buf))
814 printf("readwritelarge test 1 succeeded (size = %lx)\n",
815 (unsigned long)fsize);
816 else {
817 printf("readwritelarge test 1 failed (size = %lx)\n",
818 (unsigned long)fsize);
819 correct = False;
820 }
821
822 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
823 printf("close failed (%s)\n", cli_errstr(cli1));
824 correct = False;
825 }
826
827 if (!NT_STATUS_IS_OK(cli_unlink(cli1, lockfname, aSYSTEM | aHIDDEN))) {
828 printf("unlink failed (%s)\n", cli_errstr(cli1));
829 correct = False;
830 }
831
832 if (!NT_STATUS_IS_OK(cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE, &fnum1))) {
833 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
834 return False;
835 }
836
837 cli1->max_xmit = 4*1024;
838
839 cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf));
840
841 if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
842 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
843 correct = False;
844 }
845
846 if (fsize == sizeof(buf))
847 printf("readwritelarge test 2 succeeded (size = %lx)\n",
848 (unsigned long)fsize);
849 else {
850 printf("readwritelarge test 2 failed (size = %lx)\n",
851 (unsigned long)fsize);
852 correct = False;
853 }
854
855 #if 0
856 /* ToDo - set allocation. JRA */
857 if(!cli_set_allocation_size(cli1, fnum1, 0)) {
858 printf("set allocation size to zero failed (%s)\n", cli_errstr(&cli1));
859 return False;
860 }
861 if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
862 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
863 correct = False;
864 }
865 if (fsize != 0)
866 printf("readwritelarge test 3 (truncate test) succeeded (size = %x)\n", fsize);
867 #endif
868
869 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
870 printf("close failed (%s)\n", cli_errstr(cli1));
871 correct = False;
872 }
873
874 if (!torture_close_connection(cli1)) {
875 correct = False;
876 }
877 return correct;
878 }
879
880 int line_count = 0;
881 int nbio_id;
882
883 #define ival(s) strtol(s, NULL, 0)
884
885 /* run a test that simulates an approximate netbench client load */
886 static bool run_netbench(int client)
887 {
888 struct cli_state *cli;
889 int i;
890 char line[1024];
891 char cname[20];
892 FILE *f;
893 const char *params[20];
894 bool correct = True;
895
896 cli = current_cli;
897
898 nbio_id = client;
899
900 cli_sockopt(cli, sockops);
901
902 nb_setup(cli);
903
904 slprintf(cname,sizeof(cname)-1, "client%d", client);
905
906 f = fopen(client_txt, "r");
907
908 if (!f) {
909 perror(client_txt);
910 return False;
911 }
912
913 while (fgets(line, sizeof(line)-1, f)) {
914 char *saveptr;
915 line_count++;
916
917 line[strlen(line)-1] = 0;
918
919 /* printf("[%d] %s\n", line_count, line); */
920
921 all_string_sub(line,"client1", cname, sizeof(line));
922
923 /* parse the command parameters */
924 params[0] = strtok_r(line, " ", &saveptr);
925 i = 0;
926 while (params[i]) params[++i] = strtok_r(NULL, " ", &saveptr);
927
928 params[i] = "";
929
930 if (i < 2) continue;
931
932 if (!strncmp(params[0],"SMB", 3)) {
933 printf("ERROR: You are using a dbench 1 load file\n");
934 exit(1);
935 }
936
937 if (!strcmp(params[0],"NTCreateX")) {
938 nb_createx(params[1], ival(params[2]), ival(params[3]),
939 ival(params[4]));
940 } else if (!strcmp(params[0],"Close")) {
941 nb_close(ival(params[1]));
942 } else if (!strcmp(params[0],"Rename")) {
943 nb_rename(params[1], params[2]);
944 } else if (!strcmp(params[0],"Unlink")) {
945 nb_unlink(params[1]);
946 } else if (!strcmp(params[0],"Deltree")) {
947 nb_deltree(params[1]);
948 } else if (!strcmp(params[0],"Rmdir")) {
949 nb_rmdir(params[1]);
950 } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
951 nb_qpathinfo(params[1]);
952 } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
953 nb_qfileinfo(ival(params[1]));
954 } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
955 nb_qfsinfo(ival(params[1]));
956 } else if (!strcmp(params[0],"FIND_FIRST")) {
957 nb_findfirst(params[1]);
958 } else if (!strcmp(params[0],"WriteX")) {
959 nb_writex(ival(params[1]),
960 ival(params[2]), ival(params[3]), ival(params[4]));
961 } else if (!strcmp(params[0],"ReadX")) {
962 nb_readx(ival(params[1]),
963 ival(params[2]), ival(params[3]), ival(params[4]));
964 } else if (!strcmp(params[0],"Flush")) {
965 nb_flush(ival(params[1]));
966 } else {
967 printf("Unknown operation %s\n", params[0]);
968 exit(1);
969 }
970 }
971 fclose(f);
972
973 nb_cleanup();
974
975 if (!torture_close_connection(cli)) {
976 correct = False;
977 }
978
979 return correct;
980 }
981
982
983 /* run a test that simulates an approximate netbench client load */
984 static bool run_nbench(int dummy)
985 {
986 double t;
987 bool correct = True;
988
989 nbio_shmem(nprocs);
990
991 nbio_id = -1;
992
993 signal(SIGALRM, nb_alarm);
994 alarm(1);
995 t = create_procs(run_netbench, &correct);
996 alarm(0);
997
998 printf("\nThroughput %g MB/sec\n",
999 1.0e-6 * nbio_total() / t);
1000 return correct;
1001 }
1002
1003
1004 /*
1005 This test checks for two things:
1006
1007 1) correct support for retaining locks over a close (ie. the server
1008 must not use posix semantics)
1009 2) support for lock timeouts
1010 */
1011 static bool run_locktest1(int dummy)
1012 {
1013 struct cli_state *cli1, *cli2;
1014 const char *fname = "\\lockt1.lck";
1015 uint16_t fnum1, fnum2, fnum3;
1016 time_t t1, t2;
1017 unsigned lock_timeout;
1018
1019 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1020 return False;
1021 }
1022 cli_sockopt(cli1, sockops);
1023 cli_sockopt(cli2, sockops);
1024
1025 printf("starting locktest1\n");
1026
1027 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1028
1029 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1030 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1031 return False;
1032 }
1033 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum2))) {
1034 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli1));
1035 return False;
1036 }
1037 if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum3))) {
1038 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli2));
1039 return False;
1040 }
1041
1042 if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
1043 printf("lock1 failed (%s)\n", cli_errstr(cli1));
1044 return False;
1045 }
1046
1047
1048 if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
1049 printf("lock2 succeeded! This is a locking bug\n");
1050 return False;
1051 } else {
1052 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1053 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1054 }
1055
1056
1057 lock_timeout = (1 + (random() % 20));
1058 printf("Testing lock timeout with timeout=%u\n", lock_timeout);
1059 t1 = time(NULL);
1060 if (cli_lock(cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK)) {
1061 printf("lock3 succeeded! This is a locking bug\n");
1062 return False;
1063 } else {
1064 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1065 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1066 }
1067 t2 = time(NULL);
1068
1069 if (ABS(t2 - t1) < lock_timeout-1) {
1070 printf("error: This server appears not to support timed lock requests\n");
1071 }
1072
1073 printf("server slept for %u seconds for a %u second timeout\n",
1074 (unsigned int)(t2-t1), lock_timeout);
1075
1076 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
1077 printf("close1 failed (%s)\n", cli_errstr(cli1));
1078 return False;
1079 }
1080
1081 if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
1082 printf("lock4 succeeded! This is a locking bug\n");
1083 return False;
1084 } else {
1085 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1086 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1087 }
1088
1089 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
1090 printf("close2 failed (%s)\n", cli_errstr(cli1));
1091 return False;
1092 }
1093
1094 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum3))) {
1095 printf("close3 failed (%s)\n", cli_errstr(cli2));
1096 return False;
1097 }
1098
1099 if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
1100 printf("unlink failed (%s)\n", cli_errstr(cli1));
1101 return False;
1102 }
1103
1104
1105 if (!torture_close_connection(cli1)) {
1106 return False;
1107 }
1108
1109 if (!torture_close_connection(cli2)) {
1110 return False;
1111 }
1112
1113 printf("Passed locktest1\n");
1114 return True;
1115 }
1116
1117 /*
1118 this checks to see if a secondary tconx can use open files from an
1119 earlier tconx
1120 */
1121 static bool run_tcon_test(int dummy)
1122 {
1123 static struct cli_state *cli;
1124 const char *fname = "\\tcontest.tmp";
1125 uint16 fnum1;
1126 uint16 cnum1, cnum2, cnum3;
1127 uint16 vuid1, vuid2;
1128 char buf[4];
1129 bool ret = True;
1130 NTSTATUS status;
1131
1132 memset(buf, '\0', sizeof(buf));
1133
1134 if (!torture_open_connection(&cli, 0)) {
1135 return False;
1136 }
1137 cli_sockopt(cli, sockops);
1138
1139 printf("starting tcontest\n");
1140
1141 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
1142
1143 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1144 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1145 return False;
1146 }
1147
1148 cnum1 = cli->cnum;
1149 vuid1 = cli->vuid;
1150
1151 if (cli_write(cli, fnum1, 0, buf, 130, 4) != 4) {
1152 printf("initial write failed (%s)", cli_errstr(cli));
1153 return False;
1154 }
1155
1156 status = cli_tcon_andx(cli, share, "?????",
1157 password, strlen(password)+1);
1158 if (!NT_STATUS_IS_OK(status)) {
1159 printf("%s refused 2nd tree connect (%s)\n", host,
1160 nt_errstr(status));
1161 cli_shutdown(cli);
1162 return False;
1163 }
1164
1165 cnum2 = cli->cnum;
1166 cnum3 = MAX(cnum1, cnum2) + 1; /* any invalid number */
1167 vuid2 = cli->vuid + 1;
1168
1169 /* try a write with the wrong tid */
1170 cli->cnum = cnum2;
1171
1172 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1173 printf("* server allows write with wrong TID\n");
1174 ret = False;
1175 } else {
1176 printf("server fails write with wrong TID : %s\n", cli_errstr(cli));
1177 }
1178
1179
1180 /* try a write with an invalid tid */
1181 cli->cnum = cnum3;
1182
1183 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1184 printf("* server allows write with invalid TID\n");
1185 ret = False;
1186 } else {
1187 printf("server fails write with invalid TID : %s\n", cli_errstr(cli));
1188 }
1189
1190 /* try a write with an invalid vuid */
1191 cli->vuid = vuid2;
1192 cli->cnum = cnum1;
1193
1194 if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1195 printf("* server allows write with invalid VUID\n");
1196 ret = False;
1197 } else {
1198 printf("server fails write with invalid VUID : %s\n", cli_errstr(cli));
1199 }
1200
1201 cli->cnum = cnum1;
1202 cli->vuid = vuid1;
1203
1204 if (!NT_STATUS_IS_OK(cli_close(cli, fnum1))) {
1205 printf("close failed (%s)\n", cli_errstr(cli));
1206 return False;
1207 }
1208
1209 cli->cnum = cnum2;
1210
1211 if (!cli_tdis(cli)) {
1212 printf("secondary tdis failed (%s)\n", cli_errstr(cli));
1213 return False;
1214 }
1215
1216 cli->cnum = cnum1;
1217
1218 if (!torture_close_connection(cli)) {
1219 return False;
1220 }
1221
1222 return ret;
1223 }
1224
1225
1226 /*
1227 checks for old style tcon support
1228 */
1229 static bool run_tcon2_test(int dummy)
1230 {
1231 static struct cli_state *cli;
1232 uint16 cnum, max_xmit;
1233 char *service;
1234 NTSTATUS status;
1235
1236 if (!torture_open_connection(&cli, 0)) {
1237 return False;
1238 }
1239 cli_sockopt(cli, sockops);
1240
1241 printf("starting tcon2 test\n");
1242
1243 if (asprintf(&service, "\\\\%s\\%s", host, share) == -1) {
1244 return false;
1245 }
1246
1247 status = cli_raw_tcon(cli, service, password, "?????", &max_xmit, &cnum);
1248
1249 if (!NT_STATUS_IS_OK(status)) {
1250 printf("tcon2 failed : %s\n", cli_errstr(cli));
1251 } else {
1252 printf("tcon OK : max_xmit=%d cnum=%d tid=%d\n",
1253 (int)max_xmit, (int)cnum, SVAL(cli->inbuf, smb_tid));
1254 }
1255
1256 if (!torture_close_connection(cli)) {
1257 return False;
1258 }
1259
1260 printf("Passed tcon2 test\n");
1261 return True;
1262 }
1263
1264 static bool tcon_devtest(struct cli_state *cli,
1265 const char *myshare, const char *devtype,
1266 const char *return_devtype,
1267 NTSTATUS expected_error)
1268 {
1269 NTSTATUS status;
1270 bool ret;
1271
1272 status = cli_tcon_andx(cli, myshare, devtype,
1273 password, strlen(password)+1);
1274
1275 if (NT_STATUS_IS_OK(expected_error)) {
1276 if (NT_STATUS_IS_OK(status)) {
1277 if (strcmp(cli->dev, return_devtype) == 0) {
1278 ret = True;
1279 } else {
1280 printf("tconX to share %s with type %s "
1281 "succeeded but returned the wrong "
1282 "device type (got [%s] but should have got [%s])\n",
1283 myshare, devtype, cli->dev, return_devtype);
1284 ret = False;
1285 }
1286 } else {
1287 printf("tconX to share %s with type %s "
1288 "should have succeeded but failed\n",
1289 myshare, devtype);
1290 ret = False;
1291 }
1292 cli_tdis(cli);
1293 } else {
1294 if (NT_STATUS_IS_OK(status)) {
1295 printf("tconx to share %s with type %s "
1296 "should have failed but succeeded\n",
1297 myshare, devtype);
1298 ret = False;
1299 } else {
1300 if (NT_STATUS_EQUAL(cli_nt_error(cli),
1301 expected_error)) {
1302 ret = True;
1303 } else {
1304 printf("Returned unexpected error\n");
1305 ret = False;
1306 }
1307 }
1308 }
1309 return ret;
1310 }
1311
1312 /*
1313 checks for correct tconX support
1314 */
1315 static bool run_tcon_devtype_test(int dummy)
1316 {
1317 static struct cli_state *cli1 = NULL;
1318 bool retry;
1319 int flags = 0;
1320 NTSTATUS status;
1321 bool ret = True;
1322
1323 status = cli_full_connection(&cli1, myname,
1324 host, NULL, port_to_use,
1325 NULL, NULL,
1326 username, workgroup,
1327 password, flags, Undefined, &retry);
1328
1329 if (!NT_STATUS_IS_OK(status)) {
1330 printf("could not open connection\n");
1331 return False;
1332 }
1333
1334 if (!tcon_devtest(cli1, "IPC$", "A:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1335 ret = False;
1336
1337 if (!tcon_devtest(cli1, "IPC$", "?????", "IPC", NT_STATUS_OK))
1338 ret = False;
1339
1340 if (!tcon_devtest(cli1, "IPC$", "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1341 ret = False;
1342
1343 if (!tcon_devtest(cli1, "IPC$", "IPC", "IPC", NT_STATUS_OK))
1344 ret = False;
1345
1346 if (!tcon_devtest(cli1, "IPC$", "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1347 ret = False;
1348
1349 if (!tcon_devtest(cli1, share, "A:", "A:", NT_STATUS_OK))
1350 ret = False;
1351
1352 if (!tcon_devtest(cli1, share, "?????", "A:", NT_STATUS_OK))
1353 ret = False;
1354
1355 if (!tcon_devtest(cli1, share, "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1356 ret = False;
1357
1358 if (!tcon_devtest(cli1, share, "IPC", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1359 ret = False;
1360
1361 if (!tcon_devtest(cli1, share, "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1362 ret = False;
1363
1364 cli_shutdown(cli1);
1365
1366 if (ret)
1367 printf("Passed tcondevtest\n");
1368
1369 return ret;
1370 }
1371
1372
1373 /*
1374 This test checks that
1375
1376 1) the server supports multiple locking contexts on the one SMB
1377 connection, distinguished by PID.
1378
1379 2) the server correctly fails overlapping locks made by the same PID (this
1380 goes against POSIX behaviour, which is why it is tricky to implement)
1381
1382 3) the server denies unlock requests by an incorrect client PID
1383 */
1384 static bool run_locktest2(int dummy)
1385 {
1386 static struct cli_state *cli;
1387 const char *fname = "\\lockt2.lck";
1388 uint16_t fnum1, fnum2, fnum3;
1389 bool correct = True;
1390
1391 if (!torture_open_connection(&cli, 0)) {
1392 return False;
1393 }
1394
1395 cli_sockopt(cli, sockops);
1396
1397 printf("starting locktest2\n");
1398
1399 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
1400
1401 cli_setpid(cli, 1);
1402
1403 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1404 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1405 return False;
1406 }
1407
1408 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum2))) {
1409 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli));
1410 return False;
1411 }
1412
1413 cli_setpid(cli, 2);
1414
1415 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum3))) {
1416 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli));
1417 return False;
1418 }
1419
1420 cli_setpid(cli, 1);
1421
1422 if (!cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1423 printf("lock1 failed (%s)\n", cli_errstr(cli));
1424 return False;
1425 }
1426
1427 if (cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1428 printf("WRITE lock1 succeeded! This is a locking bug\n");
1429 correct = False;
1430 } else {
1431 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1432 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1433 }
1434
1435 if (cli_lock(cli, fnum2, 0, 4, 0, WRITE_LOCK)) {
1436 printf("WRITE lock2 succeeded! This is a locking bug\n");
1437 correct = False;
1438 } else {
1439 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1440 NT_STATUS_LOCK_NOT_GRANTED)) return False;
1441 }
1442
1443 if (cli_lock(cli, fnum2, 0, 4, 0, READ_LOCK)) {
1444 printf("READ lock2 succeeded! This is a locking bug\n");
1445 correct = False;
1446 } else {
1447 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1448 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1449 }
1450
1451 if (!cli_lock(cli, fnum1, 100, 4, 0, WRITE_LOCK)) {
1452 printf("lock at 100 failed (%s)\n", cli_errstr(cli));
1453 }
1454 cli_setpid(cli, 2);
1455 if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 100, 4))) {
1456 printf("unlock at 100 succeeded! This is a locking bug\n");
1457 correct = False;
1458 }
1459
1460 if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 0, 4))) {
1461 printf("unlock1 succeeded! This is a locking bug\n");
1462 correct = False;
1463 } else {
1464 if (!check_error(__LINE__, cli,
1465 ERRDOS, ERRlock,
1466 NT_STATUS_RANGE_NOT_LOCKED)) return False;
1467 }
1468
1469 if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 0, 8))) {
1470 printf("unlock2 succeeded! This is a locking bug\n");
1471 correct = False;
1472 } else {
1473 if (!check_error(__LINE__, cli,
1474 ERRDOS, ERRlock,
1475 NT_STATUS_RANGE_NOT_LOCKED)) return False;
1476 }
1477
1478 if (cli_lock(cli, fnum3, 0, 4, 0, WRITE_LOCK)) {
1479 printf("lock3 succeeded! This is a locking bug\n");
1480 correct = False;
1481 } else {
1482 if (!check_error(__LINE__, cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
1483 }
1484
1485 cli_setpid(cli, 1);
1486
1487 if (!NT_STATUS_IS_OK(cli_close(cli, fnum1))) {
1488 printf("close1 failed (%s)\n", cli_errstr(cli));
1489 return False;
1490 }
1491
1492 if (!NT_STATUS_IS_OK(cli_close(cli, fnum2))) {
1493 printf("close2 failed (%s)\n", cli_errstr(cli));
1494 return False;
1495 }
1496
1497 if (!NT_STATUS_IS_OK(cli_close(cli, fnum3))) {
1498 printf("close3 failed (%s)\n", cli_errstr(cli));
1499 return False;
1500 }
1501
1502 if (!torture_close_connection(cli)) {
1503 correct = False;
1504 }
1505
1506 printf("locktest2 finished\n");
1507
1508 return correct;
1509 }
1510
1511
1512 /*
1513 This test checks that
1514
1515 1) the server supports the full offset range in lock requests
1516 */
1517 static bool run_locktest3(int dummy)
1518 {
1519 static struct cli_state *cli1, *cli2;
1520 const char *fname = "\\lockt3.lck";
1521 uint16_t fnum1, fnum2;
1522 int i;
1523 uint32 offset;
1524 bool correct = True;
1525
1526 #define NEXT_OFFSET offset += (~(uint32)0) / torture_numops
1527
1528 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1529 return False;
1530 }
1531 cli_sockopt(cli1, sockops);
1532 cli_sockopt(cli2, sockops);
1533
1534 printf("starting locktest3\n");
1535
1536 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1537
1538 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
1539 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1540 return False;
1541 }
1542 if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2))) {
1543 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli2));
1544 return False;
1545 }
1546
1547 for (offset=i=0;i<torture_numops;i++) {
1548 NEXT_OFFSET;
1549 if (!cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1550 printf("lock1 %d failed (%s)\n",
1551 i,
1552 cli_errstr(cli1));
1553 return False;
1554 }
1555
1556 if (!cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1557 printf("lock2 %d failed (%s)\n",
1558 i,
1559 cli_errstr(cli1));
1560 return False;
1561 }
1562 }
1563
1564 for (offset=i=0;i<torture_numops;i++) {
1565 NEXT_OFFSET;
1566
1567 if (cli_lock(cli1, fnum1, offset-2, 1, 0, WRITE_LOCK)) {
1568 printf("error: lock1 %d succeeded!\n", i);
1569 return False;
1570 }
1571
1572 if (cli_lock(cli2, fnum2, offset-1, 1, 0, WRITE_LOCK)) {
1573 printf("error: lock2 %d succeeded!\n", i);
1574 return False;
1575 }
1576
1577 if (cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1578 printf("error: lock3 %d succeeded!\n", i);
1579 return False;
1580 }
1581
1582 if (cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1583 printf("error: lock4 %d succeeded!\n", i);
1584 return False;
1585 }
1586 }
1587
1588 for (offset=i=0;i<torture_numops;i++) {
1589 NEXT_OFFSET;
1590
1591 if (!NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, offset-1, 1))) {
1592 printf("unlock1 %d failed (%s)\n",
1593 i,
1594 cli_errstr(cli1));
1595 return False;
1596 }
1597
1598 if (!NT_STATUS_IS_OK(cli_unlock(cli2, fnum2, offset-2, 1))) {
1599 printf("unlock2 %d failed (%s)\n",
1600 i,
1601 cli_errstr(cli1));
1602 return False;
1603 }
1604 }
1605
1606 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
1607 printf("close1 failed (%s)\n", cli_errstr(cli1));
1608 return False;
1609 }
1610
1611 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
1612 printf("close2 failed (%s)\n", cli_errstr(cli2));
1613 return False;
1614 }
1615
1616 if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
1617 printf("unlink failed (%s)\n", cli_errstr(cli1));
1618 return False;
1619 }
1620
1621 if (!torture_close_connection(cli1)) {
1622 correct = False;
1623 }
1624
1625 if (!torture_close_connection(cli2)) {
1626 correct = False;
1627 }
1628
1629 printf("finished locktest3\n");
1630
1631 return correct;
1632 }
1633
1634 #define EXPECTED(ret, v) if ((ret) != (v)) { \
1635 printf("** "); correct = False; \
1636 }
1637
1638 /*
1639 looks at overlapping locks
1640 */
1641 static bool run_locktest4(int dummy)
1642 {
1643 static struct cli_state *cli1, *cli2;
1644 const char *fname = "\\lockt4.lck";
1645 uint16_t fnum1, fnum2, f;
1646 bool ret;
1647 char buf[1000];
1648 bool correct = True;
1649
1650 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1651 return False;
1652 }
1653
1654 cli_sockopt(cli1, sockops);
1655 cli_sockopt(cli2, sockops);
1656
1657 printf("starting locktest4\n");
1658
1659 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1660
1661 cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1662 cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1663
1664 memset(buf, 0, sizeof(buf));
1665
1666 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1667 printf("Failed to create file\n");
1668 correct = False;
1669 goto fail;
1670 }
1671
1672 ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1673 cli_lock(cli1, fnum1, 2, 4, 0, WRITE_LOCK);
1674 EXPECTED(ret, False);
1675 printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
1676
1677 ret = cli_lock(cli1, fnum1, 10, 4, 0, READ_LOCK) &&
1678 cli_lock(cli1, fnum1, 12, 4, 0, READ_LOCK);
1679 EXPECTED(ret, True);
1680 printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
1681
1682 ret = cli_lock(cli1, fnum1, 20, 4, 0, WRITE_LOCK) &&
1683 cli_lock(cli2, fnum2, 22, 4, 0, WRITE_LOCK);
1684 EXPECTED(ret, False);
1685 printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
1686
1687 ret = cli_lock(cli1, fnum1, 30, 4, 0, READ_LOCK) &&
1688 cli_lock(cli2, fnum2, 32, 4, 0, READ_LOCK);
1689 EXPECTED(ret, True);
1690 printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
1691
1692 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 40, 4, 0, WRITE_LOCK)) &&
1693 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 42, 4, 0, WRITE_LOCK));
1694 EXPECTED(ret, False);
1695 printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
1696
1697 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 50, 4, 0, READ_LOCK)) &&
1698 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 52, 4, 0, READ_LOCK));
1699 EXPECTED(ret, True);
1700 printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
1701
1702 ret = cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK) &&
1703 cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK);
1704 EXPECTED(ret, True);
1705 printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
1706
1707 ret = cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK) &&
1708 cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK);
1709 EXPECTED(ret, False);
1710 printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
1711
1712 ret = cli_lock(cli1, fnum1, 80, 4, 0, READ_LOCK) &&
1713 cli_lock(cli1, fnum1, 80, 4, 0, WRITE_LOCK);
1714 EXPECTED(ret, False);
1715 printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
1716
1717 ret = cli_lock(cli1, fnum1, 90, 4, 0, WRITE_LOCK) &&
1718 cli_lock(cli1, fnum1, 90, 4, 0, READ_LOCK);
1719 EXPECTED(ret, True);
1720 printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1721
1722 ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 100, 4, 0, WRITE_LOCK)) &&
1723 (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 100, 4, 0, READ_LOCK));
1724 EXPECTED(ret, False);
1725 printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1726
1727 ret = cli_lock(cli1, fnum1, 110, 4, 0, READ_LOCK) &&
1728 cli_lock(cli1, fnum1, 112, 4, 0, READ_LOCK) &&
1729 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 110, 6));
1730 EXPECTED(ret, False);
1731 printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
1732
1733
1734 ret = cli_lock(cli1, fnum1, 120, 4, 0, WRITE_LOCK) &&
1735 (cli_read(cli2, fnum2, buf, 120, 4) == 4);
1736 EXPECTED(ret, False);
1737 printf("this server %s strict write locking\n", ret?"doesn't do":"does");
1738
1739 ret = cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK) &&
1740 (cli_write(cli2, fnum2, 0, buf, 130, 4) == 4);
1741 EXPECTED(ret, False);
1742 printf("this server %s strict read locking\n", ret?"doesn't do":"does");
1743
1744
1745 ret = cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1746 cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1747 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4)) &&
1748 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4));
1749 EXPECTED(ret, True);
1750 printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
1751
1752
1753 ret = cli_lock(cli1, fnum1, 150, 4, 0, WRITE_LOCK) &&
1754 cli_lock(cli1, fnum1, 150, 4, 0, READ_LOCK) &&
1755 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4)) &&
1756 (cli_read(cli2, fnum2, buf, 150, 4) == 4) &&
1757 !(cli_write(cli2, fnum2, 0, buf, 150, 4) == 4) &&
1758 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4));
1759 EXPECTED(ret, True);
1760 printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
1761
1762 ret = cli_lock(cli1, fnum1, 160, 4, 0, READ_LOCK) &&
1763 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 160, 4)) &&
1764 (cli_write(cli2, fnum2, 0, buf, 160, 4) == 4) &&
1765 (cli_read(cli2, fnum2, buf, 160, 4) == 4);
1766 EXPECTED(ret, True);
1767 printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
1768
1769 ret = cli_lock(cli1, fnum1, 170, 4, 0, WRITE_LOCK) &&
1770 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 170, 4)) &&
1771 (cli_write(cli2, fnum2, 0, buf, 170, 4) == 4) &&
1772 (cli_read(cli2, fnum2, buf, 170, 4) == 4);
1773 EXPECTED(ret, True);
1774 printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
1775
1776 ret = cli_lock(cli1, fnum1, 190, 4, 0, WRITE_LOCK) &&
1777 cli_lock(cli1, fnum1, 190, 4, 0, READ_LOCK) &&
1778 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 190, 4)) &&
1779 !(cli_write(cli2, fnum2, 0, buf, 190, 4) == 4) &&
1780 (cli_read(cli2, fnum2, buf, 190, 4) == 4);
1781 EXPECTED(ret, True);
1782 printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
1783
1784 cli_close(cli1, fnum1);
1785 cli_close(cli2, fnum2);
1786 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
1787 cli_open(cli1, fname, O_RDWR, DENY_NONE, &f);
1788 ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1789 cli_lock(cli1, f, 0, 1, 0, READ_LOCK) &&
1790 NT_STATUS_IS_OK(cli_close(cli1, fnum1)) &&
1791 NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1)) &&
1792 cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1793 cli_close(cli1, f);
1794 cli_close(cli1, fnum1);
1795 EXPECTED(ret, True);
1796 printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
1797
1798 fail:
1799 cli_close(cli1, fnum1);
1800 cli_close(cli2, fnum2);
1801 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1802 torture_close_connection(cli1);
1803 torture_close_connection(cli2);
1804
1805 printf("finished locktest4\n");
1806 return correct;
1807 }
1808
1809 /*
1810 looks at lock upgrade/downgrade.
1811 */
1812 static bool run_locktest5(int dummy)
1813 {
1814 static struct cli_state *cli1, *cli2;
1815 const char *fname = "\\lockt5.lck";
1816 uint16_t fnum1, fnum2, fnum3;
1817 bool ret;
1818 char buf[1000];
1819 bool correct = True;
1820
1821 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1822 return False;
1823 }
1824
1825 cli_sockopt(cli1, sockops);
1826 cli_sockopt(cli2, sockops);
1827
1828 printf("starting locktest5\n");
1829
1830 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1831
1832 cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1833 cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1834 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum3);
1835
1836 memset(buf, 0, sizeof(buf));
1837
1838 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1839 printf("Failed to create file\n");
1840 correct = False;
1841 goto fail;
1842 }
1843
1844 /* Check for NT bug... */
1845 ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1846 cli_lock(cli1, fnum3, 0, 1, 0, READ_LOCK);
1847 cli_close(cli1, fnum1);
1848 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
1849 ret = cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1850 EXPECTED(ret, True);
1851 printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
1852 cli_close(cli1, fnum1);
1853 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
1854 cli_unlock(cli1, fnum3, 0, 1);
1855
1856 ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1857 cli_lock(cli1, fnum1, 1, 1, 0, READ_LOCK);
1858 EXPECTED(ret, True);
1859 printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
1860
1861 ret = cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1862 EXPECTED(ret, False);
1863
1864 printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
1865
1866 /* Unlock the process 2 lock. */
1867 cli_unlock(cli2, fnum2, 0, 4);
1868
1869 ret = cli_lock(cli1, fnum3, 0, 4, 0, READ_LOCK);
1870 EXPECTED(ret, False);
1871
1872 printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
1873
1874 /* Unlock the process 1 fnum3 lock. */
1875 cli_unlock(cli1, fnum3, 0, 4);
1876
1877 /* Stack 2 more locks here. */
1878 ret = cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK) &&
1879 cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK);
1880
1881 EXPECTED(ret, True);
1882 printf("the same process %s stack read locks\n", ret?"can":"cannot");
1883
1884 /* Unlock the first process lock, then check this was the WRITE lock that was
1885 removed. */
1886
1887 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
1888 cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1889
1890 EXPECTED(ret, True);
1891 printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
1892
1893 /* Unlock the process 2 lock. */
1894 cli_unlock(cli2, fnum2, 0, 4);
1895
1896 /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
1897
1898 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 1, 1)) &&
1899 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
1900 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
1901
1902 EXPECTED(ret, True);
1903 printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
1904
1905 /* Ensure the next unlock fails. */
1906 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
1907 EXPECTED(ret, False);
1908 printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
1909
1910 /* Ensure connection 2 can get a write lock. */
1911 ret = cli_lock(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
1912 EXPECTED(ret, True);
1913
1914 printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
1915
1916
1917 fail:
1918 cli_close(cli1, fnum1);
1919 cli_close(cli2, fnum2);
1920 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1921 if (!torture_close_connection(cli1)) {
1922 correct = False;
1923 }
1924 if (!torture_close_connection(cli2)) {
1925 correct = False;
1926 }
1927
1928 printf("finished locktest5\n");
1929
1930 return correct;
1931 }
1932
1933 /*
1934 tries the unusual lockingX locktype bits
1935 */
1936 static bool run_locktest6(int dummy)
1937 {
1938 static struct cli_state *cli;
1939 const char *fname[1] = { "\\lock6.txt" };
1940 int i;
1941 uint16_t fnum;
1942 NTSTATUS status;
1943
1944 if (!torture_open_connection(&cli, 0)) {
1945 return False;
1946 }
1947
1948 cli_sockopt(cli, sockops);
1949
1950 printf("starting locktest6\n");
1951
1952 for (i=0;i<1;i++) {
1953 printf("Testing %s\n", fname[i]);
1954
1955 cli_unlink(cli, fname[i], aSYSTEM | aHIDDEN);
1956
1957 cli_open(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
1958 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
1959 cli_close(cli, fnum);
1960 printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
1961
1962 cli_open(cli, fname[i], O_RDWR, DENY_NONE, &fnum);
1963 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
1964 cli_close(cli, fnum);
1965 printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
1966
1967 cli_unlink(cli, fname[i], aSYSTEM | aHIDDEN);
1968 }
1969
1970 torture_close_connection(cli);
1971
1972 printf("finished locktest6\n");
1973 return True;
1974 }
1975
1976 static bool run_locktest7(int dummy)
1977 {
1978 struct cli_state *cli1;
1979 const char *fname = "\\lockt7.lck";
1980 uint16_t fnum1;
1981 char buf[200];
1982 bool correct = False;
1983
1984 if (!torture_open_connection(&cli1, 0)) {
1985 return False;
1986 }
1987
1988 cli_sockopt(cli1, sockops);
1989
1990 printf("starting locktest7\n");
1991
1992 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
1993
1994 cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1995
1996 memset(buf, 0, sizeof(buf));
1997
1998 if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1999 printf("Failed to create file\n");
2000 goto fail;
2001 }
2002
2003 cli_setpid(cli1, 1);
2004
2005 if (!cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK)) {
2006 printf("Unable to apply read lock on range 130:4, error was %s\n", cli_errstr(cli1));
2007 goto fail;
2008 } else {
2009 printf("pid1 successfully locked range 130:4 for READ\n");
2010 }
2011
2012 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2013 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2014 goto fail;
2015 } else {
2016 printf("pid1 successfully read the range 130:4\n");
2017 }
2018
2019 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2020 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2021 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2022 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2023 goto fail;
2024 }
2025 } else {
2026 printf("pid1 successfully wrote to the range 130:4 (should be denied)\n");
2027 goto fail;
2028 }
2029
2030 cli_setpid(cli1, 2);
2031
2032 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2033 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2034 } else {
2035 printf("pid2 successfully read the range 130:4\n");
2036 }
2037
2038 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2039 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2040 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2041 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2042 goto fail;
2043 }
2044 } else {
2045 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2046 goto fail;
2047 }
2048
2049 cli_setpid(cli1, 1);
2050 cli_unlock(cli1, fnum1, 130, 4);
2051
2052 if (!cli_lock(cli1, fnum1, 130, 4, 0, WRITE_LOCK)) {
2053 printf("Unable to apply write lock on range 130:4, error was %s\n", cli_errstr(cli1));
2054 goto fail;
2055 } else {
2056 printf("pid1 successfully locked range 130:4 for WRITE\n");
2057 }
2058
2059 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2060 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2061 goto fail;
2062 } else {
2063 printf("pid1 successfully read the range 130:4\n");
2064 }
2065
2066 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2067 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2068 goto fail;
2069 } else {
2070 printf("pid1 successfully wrote to the range 130:4\n");
2071 }
2072
2073 cli_setpid(cli1, 2);
2074
2075 if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2076 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2077 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2078 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2079 goto fail;
2080 }
2081 } else {
2082 printf("pid2 successfully read the range 130:4 (should be denied)\n");
2083 goto fail;
2084 }
2085
2086 if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2087 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2088 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2089 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2090 goto fail;
2091 }
2092 } else {
2093 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2094 goto fail;
2095 }
2096
2097 cli_unlock(cli1, fnum1, 130, 0);
2098 correct = True;
2099
2100 fail:
2101 cli_close(cli1, fnum1);
2102 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2103 torture_close_connection(cli1);
2104
2105 printf("finished locktest7\n");
2106 return correct;
2107 }
2108
2109 /*
2110 * This demonstrates a problem with our use of GPFS share modes: A file
2111 * descriptor sitting in the pending close queue holding a GPFS share mode
2112 * blocks opening a file another time. Happens with Word 2007 temp files.
2113 * With "posix locking = yes" and "gpfs:sharemodes = yes" enabled, the third
2114 * open is denied with NT_STATUS_SHARING_VIOLATION.
2115 */
2116
2117 static bool run_locktest8(int dummy)
2118 {
2119 struct cli_state *cli1;
2120 const char *fname = "\\lockt8.lck";
2121 uint16_t fnum1, fnum2;
2122 char buf[200];
2123 bool correct = False;
2124 NTSTATUS status;
2125
2126 if (!torture_open_connection(&cli1, 0)) {
2127 return False;
2128 }
2129
2130 cli_sockopt(cli1, sockops);
2131
2132 printf("starting locktest8\n");
2133
2134 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2135
2136 status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_WRITE,
2137 &fnum1);
2138 if (!NT_STATUS_IS_OK(status)) {
2139 d_fprintf(stderr, "cli_open returned %s\n", cli_errstr(cli1));
2140 return false;
2141 }
2142
2143 memset(buf, 0, sizeof(buf));
2144
2145 status = cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum2);
2146 if (!NT_STATUS_IS_OK(status)) {
2147 d_fprintf(stderr, "cli_open second time returned %s\n",
2148 cli_errstr(cli1));
2149 goto fail;
2150 }
2151
2152 if (!cli_lock(cli1, fnum2, 1, 1, 0, READ_LOCK)) {
2153 printf("Unable to apply read lock on range 1:1, error was "
2154 "%s\n", cli_errstr(cli1));
2155 goto fail;
2156 }
2157
2158 status = cli_close(cli1, fnum1);
2159 if (!NT_STATUS_IS_OK(status)) {
2160 d_fprintf(stderr, "cli_close(fnum1) %s\n", cli_errstr(cli1));
2161 goto fail;
2162 }
2163
2164 status = cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2165 if (!NT_STATUS_IS_OK(status)) {
2166 d_fprintf(stderr, "cli_open third time returned %s\n",
2167 cli_errstr(cli1));
2168 goto fail;
2169 }
2170
2171 correct = true;
2172
2173 fail:
2174 cli_close(cli1, fnum1);
2175 cli_close(cli1, fnum2);
2176 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2177 torture_close_connection(cli1);
2178
2179 printf("finished locktest8\n");
2180 return correct;
2181 }
2182
2183 /*
2184 * This test is designed to be run in conjunction with
2185 * external NFS or POSIX locks taken in the filesystem.
2186 * It checks that the smbd server will block until the
2187 * lock is released and then acquire it. JRA.
2188 */
2189
2190 static bool got_alarm;
2191 static int alarm_fd;
2192
2193 static void alarm_handler(int dummy)
2194 {
2195 got_alarm = True;
2196 }
2197
2198 static void alarm_handler_parent(int dummy)
2199 {
2200 close(alarm_fd);
2201 }
2202
2203 static void do_local_lock(int read_fd, int write_fd)
2204 {
2205 int fd;
2206 char c = '\0';
2207 struct flock lock;
2208 const char *local_pathname = NULL;
2209 int ret;
2210
2211 local_pathname = talloc_asprintf(talloc_tos(),
2212 "%s/lockt9.lck", local_path);
2213 if (!local_pathname) {
2214 printf("child: alloc fail\n");
2215 exit(1);
2216 }
2217
2218 unlink(local_pathname);
2219 fd = open(local_pathname, O_RDWR|O_CREAT, 0666);
2220 if (fd == -1) {
2221 printf("child: open of %s failed %s.\n",
2222 local_pathname, strerror(errno));
2223 exit(1);
2224 }
2225
2226 /* Now take a fcntl lock. */
2227 lock.l_type = F_WRLCK;
2228 lock.l_whence = SEEK_SET;
2229 lock.l_start = 0;
2230 lock.l_len = 4;
2231 lock.l_pid = getpid();
2232
2233 ret = fcntl(fd,F_SETLK,&lock);
2234 if (ret == -1) {
2235 printf("child: failed to get lock 0:4 on file %s. Error %s\n",
2236 local_pathname, strerror(errno));
2237 exit(1);
2238 } else {
2239 printf("child: got lock 0:4 on file %s.\n",
2240 local_pathname );
2241 fflush(stdout);
2242 }
2243
2244 CatchSignal(SIGALRM, alarm_handler);
2245 alarm(5);
2246 /* Signal the parent. */
2247 if (write(write_fd, &c, 1) != 1) {
2248 printf("child: start signal fail %s.\n",
2249 strerror(errno));
2250 exit(1);
2251 }
2252 alarm(0);
2253
2254 alarm(10);
2255 /* Wait for the parent to be ready. */
2256 if (read(read_fd, &c, 1) != 1) {
2257 printf("child: reply signal fail %s.\n",
2258 strerror(errno));
2259 exit(1);
2260 }
2261 alarm(0);
2262
2263 sleep(5);
2264 close(fd);
2265 printf("child: released lock 0:4 on file %s.\n",
2266 local_pathname );
2267 fflush(stdout);
2268 exit(0);
2269 }
2270
2271 static bool run_locktest9(int dummy)
2272 {
2273 struct cli_state *cli1;
2274 const char *fname = "\\lockt9.lck";
2275 uint16_t fnum;
2276 bool correct = False;
2277 int pipe_in[2], pipe_out[2];
2278 pid_t child_pid;
2279 char c = '\0';
2280 int ret;
2281 double seconds;
2282 NTSTATUS status;
2283
2284 printf("starting locktest9\n");
2285
2286 if (local_path == NULL) {
2287 d_fprintf(stderr, "locktest9 must be given a local path via -l <localpath>\n");
2288 return false;
2289 }
2290
2291 if (pipe(pipe_in) == -1 || pipe(pipe_out) == -1) {
2292 return false;
2293 }
2294
2295 child_pid = fork();
2296 if (child_pid == -1) {
2297 return false;
2298 }
2299
2300 if (child_pid == 0) {
2301 /* Child. */
2302 do_local_lock(pipe_out[0], pipe_in[1]);
2303 exit(0);
2304 }
2305
2306 close(pipe_out[0]);
2307 close(pipe_in[1]);
2308 pipe_out[0] = -1;
2309 pipe_in[1] = -1;
2310
2311 /* Parent. */
2312 ret = read(pipe_in[0], &c, 1);
2313 if (ret != 1) {
2314 d_fprintf(stderr, "failed to read start signal from child. %s\n",
2315 strerror(errno));
2316 return false;
2317 }
2318
2319 if (!torture_open_connection(&cli1, 0)) {
2320 return false;
2321 }
2322
2323 cli_sockopt(cli1, sockops);
2324
2325 status = cli_open(cli1, fname, O_RDWR, DENY_NONE,
2326 &fnum);
2327 if (!NT_STATUS_IS_OK(status)) {
2328 d_fprintf(stderr, "cli_open returned %s\n", cli_errstr(cli1));
2329 return false;
2330 }
2331
2332 /* Ensure the child has the lock. */
2333 if (cli_lock(cli1, fnum, 0, 4, 0, WRITE_LOCK)) {
2334 d_fprintf(stderr, "Got the lock on range 0:4 - this should not happen !\n");
2335 goto fail;
2336 } else {
2337 d_printf("Child has the lock.\n");
2338 }
2339
2340 /* Tell the child to wait 5 seconds then exit. */
2341 ret = write(pipe_out[1], &c, 1);
2342 if (ret != 1) {
2343 d_fprintf(stderr, "failed to send exit signal to child. %s\n",
2344 strerror(errno));
2345 goto fail;
2346 }
2347
2348 /* Wait 20 seconds for the lock. */
2349 alarm_fd = cli1->fd;
2350 CatchSignal(SIGALRM, alarm_handler_parent);
2351 alarm(20);
2352
2353 start_timer();
2354
2355 if (!cli_lock(cli1, fnum, 0, 4, -1, WRITE_LOCK)) {
2356 d_fprintf(stderr, "Unable to apply write lock on range 0:4, error was "
2357 "%s\n", cli_errstr(cli1));
2358 goto fail_nofd;
2359 }
2360 alarm(0);
2361
2362 seconds = end_timer();
2363
2364 printf("Parent got the lock after %.2f seconds.\n",
2365 seconds);
2366
2367 status = cli_close(cli1, fnum);
2368 if (!NT_STATUS_IS_OK(status)) {
2369 d_fprintf(stderr, "cli_close(fnum1) %s\n", cli_errstr(cli1));
2370 goto fail;
2371 }
2372
2373 correct = true;
2374
2375 fail:
2376 cli_close(cli1, fnum);
2377 torture_close_connection(cli1);
2378
2379 fail_nofd:
2380
2381 printf("finished locktest9\n");
2382 return correct;
2383 }
2384
2385 /*
2386 test whether fnums and tids open on one VC are available on another (a major
2387 security hole)
2388 */
2389 static bool run_fdpasstest(int dummy)
2390 {
2391 struct cli_state *cli1, *cli2;
2392 const char *fname = "\\fdpass.tst";
2393 uint16_t fnum1;
2394 char buf[1024];
2395
2396 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2397 return False;
2398 }
2399 cli_sockopt(cli1, sockops);
2400 cli_sockopt(cli2, sockops);
2401
2402 printf("starting fdpasstest\n");
2403
2404 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2405
2406 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
2407 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2408 return False;
2409 }
2410
2411 if (cli_write(cli1, fnum1, 0, "hello world\n", 0, 13) != 13) {
2412 printf("write failed (%s)\n", cli_errstr(cli1));
2413 return False;
2414 }
2415
2416 cli2->vuid = cli1->vuid;
2417 cli2->cnum = cli1->cnum;
2418 cli2->pid = cli1->pid;
2419
2420 if (cli_read(cli2, fnum1, buf, 0, 13) == 13) {
2421 printf("read succeeded! nasty security hole [%s]\n",
2422 buf);
2423 return False;
2424 }
2425
2426 cli_close(cli1, fnum1);
2427 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
2428
2429 torture_close_connection(cli1);
2430 torture_close_connection(cli2);
2431
2432 printf("finished fdpasstest\n");
2433 return True;
2434 }
2435
2436 static bool run_fdsesstest(int dummy)
2437 {
2438 struct cli_state *cli;
2439 uint16 new_vuid;
2440 uint16 saved_vuid;
2441 uint16 new_cnum;
2442 uint16 saved_cnum;
2443 const char *fname = "\\fdsess.tst";
2444 const char *fname1 = "\\fdsess1.tst";
2445 uint16_t fnum1;
2446 uint16_t fnum2;
2447 char buf[1024];
2448 bool ret = True;
2449
2450 if (!torture_open_connection(&cli, 0))
2451 return False;
2452 cli_sockopt(cli, sockops);
2453
2454 if (!torture_cli_session_setup2(cli, &new_vuid))
2455 return False;
2456
2457 saved_cnum = cli->cnum;
2458 if (!NT_STATUS_IS_OK(cli_tcon_andx(cli, share, "?????", "", 1)))
2459 return False;
2460 new_cnum = cli->cnum;
2461 cli->cnum = saved_cnum;
2462
2463 printf("starting fdsesstest\n");
2464
2465 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2466 cli_unlink(cli, fname1, aSYSTEM | aHIDDEN);
2467
2468 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
2469 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2470 return False;
2471 }
2472
2473 if (cli_write(cli, fnum1, 0, "hello world\n", 0, 13) != 13) {
2474 printf("write failed (%s)\n", cli_errstr(cli));
2475 return False;
2476 }
2477
2478 saved_vuid = cli->vuid;
2479 cli->vuid = new_vuid;
2480
2481 if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2482 printf("read succeeded with different vuid! nasty security hole [%s]\n",
2483 buf);
2484 ret = False;
2485 }
2486 /* Try to open a file with different vuid, samba cnum. */
2487 if (NT_STATUS_IS_OK(cli_open(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum2))) {
2488 printf("create with different vuid, same cnum succeeded.\n");
2489 cli_close(cli, fnum2);
2490 cli_unlink(cli, fname1, aSYSTEM | aHIDDEN);
2491 } else {
2492 printf("create with different vuid, same cnum failed.\n");
2493 printf("This will cause problems with service clients.\n");
2494 ret = False;
2495 }
2496
2497 cli->vuid = saved_vuid;
2498
2499 /* Try with same vuid, different cnum. */
2500 cli->cnum = new_cnum;
2501
2502 if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2503 printf("read succeeded with different cnum![%s]\n",
2504 buf);
2505 ret = False;
2506 }
2507
2508 cli->cnum = saved_cnum;
2509 cli_close(cli, fnum1);
2510 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2511
2512 torture_close_connection(cli);
2513
2514 printf("finished fdsesstest\n");
2515 return ret;
2516 }
2517
2518 /*
2519 This test checks that
2520
2521 1) the server does not allow an unlink on a file that is open
2522 */
2523 static bool run_unlinktest(int dummy)
2524 {
2525 struct cli_state *cli;
2526 const char *fname = "\\unlink.tst";
2527 uint16_t fnum;
2528 bool correct = True;
2529
2530 if (!torture_open_connection(&cli, 0)) {
2531 return False;
2532 }
2533
2534 cli_sockopt(cli, sockops);
2535
2536 printf("starting unlink test\n");
2537
2538 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2539
2540 cli_setpid(cli, 1);
2541
2542 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
2543 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2544 return False;
2545 }
2546
2547 if (NT_STATUS_IS_OK(cli_unlink(cli, fname, aSYSTEM | aHIDDEN))) {
2548 printf("error: server allowed unlink on an open file\n");
2549 correct = False;
2550 } else {
2551 correct = check_error(__LINE__, cli, ERRDOS, ERRbadshare,
2552 NT_STATUS_SHARING_VIOLATION);
2553 }
2554
2555 cli_close(cli, fnum);
2556 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2557
2558 if (!torture_close_connection(cli)) {
2559 correct = False;
2560 }
2561
2562 printf("unlink test finished\n");
2563
2564 return correct;
2565 }
2566
2567
2568 /*
2569 test how many open files this server supports on the one socket
2570 */
2571 static bool run_maxfidtest(int dummy)
2572 {
2573 struct cli_state *cli;
2574 const char *ftemplate = "\\maxfid.%d.%d";
2575 fstring fname;
2576 uint16_t fnums[0x11000];
2577 int i;
2578 int retries=4;
2579 bool correct = True;
2580
2581 cli = current_cli;
2582
2583 if (retries <= 0) {
2584 printf("failed to connect\n");
2585 return False;
2586 }
2587
2588 cli_sockopt(cli, sockops);
2589
2590 for (i=0; i<0x11000; i++) {
2591 slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2592 if (!NT_STATUS_IS_OK(cli_open(cli, fname,
2593 O_RDWR|O_CREAT|O_TRUNC, DENY_NONE, &fnums[i]))) {
2594 printf("open of %s failed (%s)\n",
2595 fname, cli_errstr(cli));
2596 printf("maximum fnum is %d\n", i);
2597 break;
2598 }
2599 printf("%6d\r", i);
2600 }
2601 printf("%6d\n", i);
2602 i--;
2603
2604 printf("cleaning up\n");
2605 for (;i>=0;i--) {
2606 slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2607 cli_close(cli, fnums[i]);
2608 if (!NT_STATUS_IS_OK(cli_unlink(cli, fname, aSYSTEM | aHIDDEN))) {
2609 printf("unlink of %s failed (%s)\n",
2610 fname, cli_errstr(cli));
2611 correct = False;
2612 }
2613 printf("%6d\r", i);
2614 }
2615 printf("%6d\n", 0);
2616
2617 printf("maxfid test finished\n");
2618 if (!torture_close_connection(cli)) {
2619 correct = False;
2620 }
2621 return correct;
2622 }
2623
2624 /* generate a random buffer */
2625 static void rand_buf(char *buf, int len)
2626 {
2627 while (len--) {
2628 *buf = (char)sys_random();
2629 buf++;
2630 }
2631 }
2632
2633 /* send smb negprot commands, not reading the response */
2634 static bool run_negprot_nowait(int dummy)
2635 {
2636 int i;
2637 static struct cli_state *cli;
2638 bool correct = True;
2639
2640 printf("starting negprot nowait test\n");
2641
2642 if (!(cli = open_nbt_connection())) {
2643 return False;
2644 }
2645
2646 for (i=0;i<50000;i++) {
2647 cli_negprot_sendsync(cli);
2648 }
2649
2650 if (!torture_close_connection(cli)) {
2651 correct = False;
2652 }
2653
2654 printf("finished negprot nowait test\n");
2655
2656 return correct;
2657 }
2658
2659
2660 /* send random IPC commands */
2661 static bool run_randomipc(int dummy)
2662 {
2663 char *rparam = NULL;
2664 char *rdata = NULL;
2665 unsigned int rdrcnt,rprcnt;
2666 char param[1024];
2667 int api, param_len, i;
2668 struct cli_state *cli;
2669 bool correct = True;
2670 int count = 50000;
2671
2672 printf("starting random ipc test\n");
2673
2674 if (!torture_open_connection(&cli, 0)) {
2675 return False;
2676 }
2677
2678 for (i=0;i<count;i++) {
2679 api = sys_random() % 500;
2680 param_len = (sys_random() % 64);
2681
2682 rand_buf(param, param_len);
2683
2684 SSVAL(param,0,api);
2685
2686 cli_api(cli,
2687 param, param_len, 8,
2688 NULL, 0, BUFFER_SIZE,
2689 &rparam, &rprcnt,
2690 &rdata, &rdrcnt);
2691 if (i % 100 == 0) {
2692 printf("%d/%d\r", i,count);
2693 }
2694 }
2695 printf("%d/%d\n", i, count);
2696
2697 if (!torture_close_connection(cli)) {
2698 correct = False;
2699 }
2700
2701 printf("finished random ipc test\n");
2702
2703 return correct;
2704 }
2705
2706
2707
2708 static void browse_callback(const char *sname, uint32 stype,
2709 const char *comment, void *state)
2710 {
2711 printf("\t%20.20s %08x %s\n", sname, stype, comment);
2712 }
2713
2714
2715
2716 /*
2717 This test checks the browse list code
2718
2719 */
2720 static bool run_browsetest(int dummy)
2721 {
2722 static struct cli_state *cli;
2723 bool correct = True;
2724
2725 printf("starting browse test\n");
2726
2727 if (!torture_open_connection(&cli, 0)) {
2728 return False;
2729 }
2730
2731 printf("domain list:\n");
2732 cli_NetServerEnum(cli, cli->server_domain,
2733 SV_TYPE_DOMAIN_ENUM,
2734 browse_callback, NULL);
2735
2736 printf("machine list:\n");
2737 cli_NetServerEnum(cli, cli->server_domain,
2738 SV_TYPE_ALL,
2739 browse_callback, NULL);
2740
2741 if (!torture_close_connection(cli)) {
2742 correct = False;
2743 }
2744
2745 printf("browse test finished\n");
2746
2747 return correct;
2748
2749 }
2750
2751
2752 /*
2753 This checks how the getatr calls works
2754 */
2755 static bool run_attrtest(int dummy)
2756 {
2757 struct cli_state *cli;
2758 uint16_t fnum;
2759 time_t t, t2;
2760 const char *fname = "\\attrib123456789.tst";
2761 bool correct = True;
2762
2763 printf("starting attrib test\n");
2764
2765 if (!torture_open_connection(&cli, 0)) {
2766 return False;
2767 }
2768
2769 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2770 cli_open(cli, fname,
2771 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
2772 cli_close(cli, fnum);
2773 if (!NT_STATUS_IS_OK(cli_getatr(cli, fname, NULL, NULL, &t))) {
2774 printf("getatr failed (%s)\n", cli_errstr(cli));
2775 correct = False;
2776 }
2777
2778 if (abs(t - time(NULL)) > 60*60*24*10) {
2779 printf("ERROR: SMBgetatr bug. time is %s",
2780 ctime(&t));
2781 t = time(NULL);
2782 correct = True;
2783 }
2784
2785 t2 = t-60*60*24; /* 1 day ago */
2786
2787 if (!NT_STATUS_IS_OK(cli_setatr(cli, fname, 0, t2))) {
2788 printf("setatr failed (%s)\n", cli_errstr(cli));
2789 correct = True;
2790 }
2791
2792 if (!NT_STATUS_IS_OK(cli_getatr(cli, fname, NULL, NULL, &t))) {
2793 printf("getatr failed (%s)\n", cli_errstr(cli));
2794 correct = True;
2795 }
2796
2797 if (t != t2) {
2798 printf("ERROR: getatr/setatr bug. times are\n%s",
2799 ctime(&t));
2800 printf("%s", ctime(&t2));
2801 correct = True;
2802 }
2803
2804 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2805
2806 if (!torture_close_connection(cli)) {
2807 correct = False;
2808 }
2809
2810 printf("attrib test finished\n");
2811
2812 return correct;
2813 }
2814
2815
2816 /*
2817 This checks a couple of trans2 calls
2818 */
2819 static bool run_trans2test(int dummy)
2820 {
2821 struct cli_state *cli;
2822 uint16_t fnum;
2823 SMB_OFF_T size;
2824 time_t c_time, a_time, m_time;
2825 struct timespec c_time_ts, a_time_ts, m_time_ts, w_time_ts, m_time2_ts;
2826 const char *fname = "\\trans2.tst";
2827 const char *dname = "\\trans2";
2828 const char *fname2 = "\\trans2\\trans2.tst";
2829 char pname[1024];
2830 bool correct = True;
2831 NTSTATUS status;
2832 uint32_t fs_attr;
2833
2834 printf("starting trans2 test\n");
2835
2836 if (!torture_open_connection(&cli, 0)) {
2837 return False;
2838 }
2839
2840 status = cli_get_fs_attr_info(cli, &fs_attr);
2841 if (!NT_STATUS_IS_OK(status)) {
2842 printf("ERROR: cli_get_fs_attr_info returned %s\n",
2843 nt_errstr(status));
2844 correct = false;
2845 }
2846
2847 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2848 cli_open(cli, fname,
2849 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
2850 if (!cli_qfileinfo(cli, fnum, NULL, &size, &c_time_ts, &a_time_ts, &w_time_ts,
2851 &m_time_ts, NULL)) {
2852 printf("ERROR: qfileinfo failed (%s)\n", cli_errstr(cli));
2853 correct = False;
2854 }
2855
2856 if (!cli_qfilename(cli, fnum, pname, sizeof(pname))) {
2857 printf("ERROR: qfilename failed (%s)\n", cli_errstr(cli));
2858 correct = False;
2859 }
2860
2861 if (strcmp(pname, fname)) {
2862 printf("qfilename gave different name? [%s] [%s]\n",
2863 fname, pname);
2864 correct = False;
2865 }
2866
2867 cli_close(cli, fnum);
2868
2869 sleep(2);
2870
2871 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2872 if (!NT_STATUS_IS_OK(cli_open(cli, fname,
2873 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum))) {
2874 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2875 return False;
2876 }
2877 cli_close(cli, fnum);
2878
2879 if (!cli_qpathinfo(cli, fname, &c_time, &a_time, &m_time, &size, NULL)) {
2880 printf("ERROR: qpathinfo failed (%s)\n", cli_errstr(cli));
2881 correct = False;
2882 } else {
2883 if (c_time != m_time) {
2884 printf("create time=%s", ctime(&c_time));
2885 printf("modify time=%s", ctime(&m_time));
2886 printf("This system appears to have sticky create times\n");
2887 }
2888 if (a_time % (60*60) == 0) {
2889 printf("access time=%s", ctime(&a_time));
2890 printf("This system appears to set a midnight access time\n");
2891 correct = False;
2892 }
2893
2894 if (abs(m_time - time(NULL)) > 60*60*24*7) {
2895 printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
2896 correct = False;
2897 }
2898 }
2899
2900
2901 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2902 cli_open(cli, fname,
2903 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
2904 cli_close(cli, fnum);
2905 if (!cli_qpathinfo2(cli, fname, &c_time_ts, &a_time_ts, &w_time_ts,
2906 &m_time_ts, &size, NULL, NULL)) {
2907 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2908 correct = False;
2909 } else {
2910 if (w_time_ts.tv_sec < 60*60*24*2) {
2911 printf("write time=%s", ctime(&w_time_ts.tv_sec));
2912 printf("This system appears to set a initial 0 write time\n");
2913 correct = False;
2914 }
2915 }
2916
2917 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
2918
2919
2920 /* check if the server updates the directory modification time
2921 when creating a new file */
2922 if (!NT_STATUS_IS_OK(cli_mkdir(cli, dname))) {
2923 printf("ERROR: mkdir failed (%s)\n", cli_errstr(cli));
2924 correct = False;
2925 }
2926 sleep(3);
2927 if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts, &w_time_ts,
2928 &m_time_ts, &size, NULL, NULL)) {
2929 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2930 correct = False;
2931 }
2932
2933 cli_open(cli, fname2,
2934 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
2935 cli_write(cli, fnum, 0, (char *)&fnum, 0, sizeof(fnum));
2936 cli_close(cli, fnum);
2937 if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts, &w_time_ts,
2938 &m_time2_ts, &size, NULL, NULL)) {
2939 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2940 correct = False;
2941 } else {
2942 if (memcmp(&m_time_ts, &m_time2_ts, sizeof(struct timespec))
2943 == 0) {
2944 printf("This system does not update directory modification times\n");
2945 correct = False;
2946 }
2947 }
2948 cli_unlink(cli, fname2, aSYSTEM | aHIDDEN);
2949 cli_rmdir(cli, dname);
2950
2951 if (!torture_close_connection(cli)) {
2952 correct = False;
2953 }
2954
2955 printf("trans2 test finished\n");
2956
2957 return correct;
2958 }
2959
2960 /*
2961 This checks new W2K calls.
2962 */
2963
2964 static bool new_trans(struct cli_state *pcli, int fnum, int level)
2965 {
2966 char *buf = NULL;
2967 uint32 len;
2968 bool correct = True;
2969
2970 if (!cli_qfileinfo_test(pcli, fnum, level, &buf, &len)) {
2971 printf("ERROR: qfileinfo (%d) failed (%s)\n", level, cli_errstr(pcli));
2972 correct = False;
2973 } else {
2974 printf("qfileinfo: level %d, len = %u\n", level, len);
2975 dump_data(0, (uint8 *)buf, len);
2976 printf("\n");
2977 }
2978 SAFE_FREE(buf);
2979 return correct;
2980 }
2981
2982 static bool run_w2ktest(int dummy)
2983 {
2984 struct cli_state *cli;
2985 uint16_t fnum;
2986 const char *fname = "\\w2ktest\\w2k.tst";
2987 int level;
2988 bool correct = True;
2989
2990 printf("starting w2k test\n");
2991
2992 if (!torture_open_connection(&cli, 0)) {
2993 return False;
2994 }
2995
2996 cli_open(cli, fname,
2997 O_RDWR | O_CREAT , DENY_NONE, &fnum);
2998
2999 for (level = 1004; level < 1040; level++) {
3000 new_trans(cli, fnum, level);
3001 }
3002
3003 cli_close(cli, fnum);
3004
3005 if (!torture_close_connection(cli)) {
3006 correct = False;
3007 }
3008
3009 printf("w2k test finished\n");
3010
3011 return correct;
3012 }
3013
3014
3015 /*
3016 this is a harness for some oplock tests
3017 */
3018 static bool run_oplock1(int dummy)
3019 {
3020 struct cli_state *cli1;
3021 const char *fname = "\\lockt1.lck";
3022 uint16_t fnum1;
3023 bool correct = True;
3024
3025 printf("starting oplock test 1\n");
3026
3027 if (!torture_open_connection(&cli1, 0)) {
3028 return False;
3029 }
3030
3031 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3032
3033 cli_sockopt(cli1, sockops);
3034
3035 cli1->use_oplocks = True;
3036
3037 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
3038 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3039 return False;
3040 }
3041
3042 cli1->use_oplocks = False;
3043
3044 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3045 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3046
3047 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3048 printf("close2 failed (%s)\n", cli_errstr(cli1));
3049 return False;
3050 }
3051
3052 if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
3053 printf("unlink failed (%s)\n", cli_errstr(cli1));
3054 return False;
3055 }
3056
3057 if (!torture_close_connection(cli1)) {
3058 correct = False;
3059 }
3060
3061 printf("finished oplock test 1\n");
3062
3063 return correct;
3064 }
3065
3066 static bool run_oplock2(int dummy)
3067 {
3068 struct cli_state *cli1, *cli2;
3069 const char *fname = "\\lockt2.lck";
3070 uint16_t fnum1, fnum2;
3071 int saved_use_oplocks = use_oplocks;
3072 char buf[4];
3073 bool correct = True;
3074 volatile bool *shared_correct;
3075
3076 shared_correct = (volatile bool *)shm_setup(sizeof(bool));
3077 *shared_correct = True;
3078
3079 use_level_II_oplocks = True;
3080 use_oplocks = True;
3081
3082 printf("starting oplock test 2\n");
3083
3084 if (!torture_open_connection(&cli1, 0)) {
3085 use_level_II_oplocks = False;
3086 use_oplocks = saved_use_oplocks;
3087 return False;
3088 }
3089
3090 cli1->use_oplocks = True;
3091 cli1->use_level_II_oplocks = True;
3092
3093 if (!torture_open_connection(&cli2, 1)) {
3094 use_level_II_oplocks = False;
3095 use_oplocks = saved_use_oplocks;
3096 return False;
3097 }
3098
3099 cli2->use_oplocks = True;
3100 cli2->use_level_II_oplocks = True;
3101
3102 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3103
3104 cli_sockopt(cli1, sockops);
3105 cli_sockopt(cli2, sockops);
3106
3107 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
3108 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3109 return False;
3110 }
3111
3112 /* Don't need the globals any more. */
3113 use_level_II_oplocks = False;
3114 use_oplocks = saved_use_oplocks;
3115
3116 if (fork() == 0) {
3117 /* Child code */
3118 if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2))) {
3119 printf("second open of %s failed (%s)\n", fname, cli_errstr(cli1));
3120 *shared_correct = False;
3121 exit(0);
3122 }
3123
3124 sleep(2);
3125
3126 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
3127 printf("close2 failed (%s)\n", cli_errstr(cli1));
3128 *shared_correct = False;
3129 }
3130
3131 exit(0);
3132 }
3133
3134 sleep(2);
3135
3136 /* Ensure cli1 processes the break. Empty file should always return 0
3137 * bytes. */
3138
3139 if (cli_read(cli1, fnum1, buf, 0, 4) != 0) {
3140 printf("read on fnum1 failed (%s)\n", cli_errstr(cli1));
3141 correct = False;
3142 }
3143
3144 /* Should now be at level II. */
3145 /* Test if sending a write locks causes a break to none. */
3146
3147 if (!cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK)) {
3148 printf("lock failed (%s)\n", cli_errstr(cli1));
3149 correct = False;
3150 }
3151
3152 cli_unlock(cli1, fnum1, 0, 4);
3153
3154 sleep(2);
3155
3156 if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
3157 printf("lock failed (%s)\n", cli_errstr(cli1));
3158 correct = False;
3159 }
3160
3161 cli_unlock(cli1, fnum1, 0, 4);
3162
3163 sleep(2);
3164
3165 cli_read(cli1, fnum1, buf, 0, 4);
3166
3167 #if 0
3168 if (cli_write(cli1, fnum1, 0, buf, 0, 4) != 4) {
3169 printf("write on fnum1 failed (%s)\n", cli_errstr(cli1));
3170 correct = False;
3171 }
3172 #endif
3173
3174 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3175 printf("close1 failed (%s)\n", cli_errstr(cli1));
3176 correct = False;
3177 }
3178
3179 sleep(4);
3180
3181 if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
3182 printf("unlink failed (%s)\n", cli_errstr(cli1));
3183 correct = False;
3184 }
3185
3186 if (!torture_close_connection(cli1)) {
3187 correct = False;
3188 }
3189
3190 if (!*shared_correct) {
3191 correct = False;
3192 }
3193
3194 printf("finished oplock test 2\n");
3195
3196 return correct;
3197 }
3198
3199 /* handler for oplock 3 tests */
3200 static NTSTATUS oplock3_handler(struct cli_state *cli, uint16_t fnum, unsigned char level)
3201 {
3202 printf("got oplock break fnum=%d level=%d\n",
3203 fnum, level);
3204 return cli_oplock_ack(cli, fnum, level);
3205 }
3206
3207 static bool run_oplock3(int dummy)
3208 {
3209 struct cli_state *cli;
3210 const char *fname = "\\oplockt3.dat";
3211 uint16_t fnum;
3212 char buf[4] = "abcd";
3213 bool correct = True;
3214 volatile bool *shared_correct;
3215
3216 shared_correct = (volatile bool *)shm_setup(sizeof(bool));
3217 *shared_correct = True;
3218
3219 printf("starting oplock test 3\n");
3220
3221 if (fork() == 0) {
3222 /* Child code */
3223 use_oplocks = True;
3224 use_level_II_oplocks = True;
3225 if (!torture_open_connection(&cli, 0)) {
3226 *shared_correct = False;
3227 exit(0);
3228 }
3229 sleep(2);
3230 /* try to trigger a oplock break in parent */
3231 cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum);
3232 cli_write(cli, fnum, 0, buf, 0, 4);
3233 exit(0);
3234 }
3235
3236 /* parent code */
3237 use_oplocks = True;
3238 use_level_II_oplocks = True;
3239 if (!torture_open_connection(&cli, 1)) { /* other is forked */
3240 return False;
3241 }
3242 cli_oplock_handler(cli, oplock3_handler);
3243 cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum);
3244 cli_write(cli, fnum, 0, buf, 0, 4);
3245 cli_close(cli, fnum);
3246 cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum);
3247 cli->timeout = 20000;
3248 cli_receive_smb(cli);
3249 printf("finished oplock test 3\n");
3250
3251 return (correct && *shared_correct);
3252
3253 /* What are we looking for here? What's sucess and what's FAILURE? */
3254 }
3255
3256
3257
3258 /*
3259 Test delete on close semantics.
3260 */
3261 static bool run_deletetest(int dummy)
3262 {
3263 struct cli_state *cli1 = NULL;
3264 struct cli_state *cli2 = NULL;
3265 const char *fname = "\\delete.file";
3266 uint16_t fnum1 = (uint16_t)-1;
3267 uint16_t fnum2 = (uint16_t)-1;
3268 bool correct = True;
3269
3270 printf("starting delete test\n");
3271
3272 if (!torture_open_connection(&cli1, 0)) {
3273 return False;
3274 }
3275
3276 cli_sockopt(cli1, sockops);
3277
3278 /* Test 1 - this should delete the file on close. */
3279
3280 cli_setatr(cli1, fname, 0, 0);
3281 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3282
3283 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
3284 0, FILE_OVERWRITE_IF,
3285 FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
3286 printf("[1] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3287 correct = False;
3288 goto fail;
3289 }
3290
3291 #if 0 /* JRATEST */
3292 {
3293 uint32 *accinfo = NULL;
3294 uint32 len;
3295 cli_qfileinfo_test(cli1, fnum1, SMB_FILE_ACCESS_INFORMATION, (char **)&accinfo, &len);
3296 if (accinfo)
3297 printf("access mode = 0x%lx\n", *accinfo);
3298 SAFE_FREE(accinfo);
3299 }
3300 #endif
3301
3302 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3303 printf("[1] close failed (%s)\n", cli_errstr(cli1));
3304 correct = False;
3305 goto fail;
3306 }
3307
3308 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1))) {
3309 printf("[1] open of %s succeeded (should fail)\n", fname);
3310 correct = False;
3311 goto fail;
3312 }
3313
3314 printf("first delete on close test succeeded.\n");
3315
3316 /* Test 2 - this should delete the file on close. */
3317
3318 cli_setatr(cli1, fname, 0, 0);
3319 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3320
3321 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
3322 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
3323 FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3324 printf("[2] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3325 correct = False;
3326 goto fail;
3327 }
3328
3329 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3330 printf("[2] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3331 correct = False;
3332 goto fail;
3333 }
3334
3335 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3336 printf("[2] close failed (%s)\n", cli_errstr(cli1));
3337 correct = False;
3338 goto fail;
3339 }
3340
3341 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3342 printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
3343 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3344 printf("[2] close failed (%s)\n", cli_errstr(cli1));
3345 correct = False;
3346 goto fail;
3347 }
3348 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3349 } else
3350 printf("second delete on close test succeeded.\n");
3351
3352 /* Test 3 - ... */
3353 cli_setatr(cli1, fname, 0, 0);
3354 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3355
3356 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
3357 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3358 printf("[3] open - 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3359 correct = False;
3360 goto fail;
3361 }
3362
3363 /* This should fail with a sharing violation - open for delete is only compatible
3364 with SHARE_DELETE. */
3365
3366 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3367 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0, 0, &fnum2))) {
3368 printf("[3] open - 2 of %s succeeded - should have failed.\n", fname);
3369 correct = False;
3370 goto fail;
3371 }
3372
3373 /* This should succeed. */
3374
3375 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3376 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0, &fnum2))) {
3377 printf("[3] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3378 correct = False;
3379 goto fail;
3380 }
3381
3382 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3383 printf("[3] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3384 correct = False;
3385 goto fail;
3386 }
3387
3388 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3389 printf("[3] close 1 failed (%s)\n", cli_errstr(cli1));
3390 correct = False;
3391 goto fail;
3392 }
3393
3394 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
3395 printf("[3] close 2 failed (%s)\n", cli_errstr(cli1));
3396 correct = False;
3397 goto fail;
3398 }
3399
3400 /* This should fail - file should no longer be there. */
3401
3402 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3403 printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
3404 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3405 printf("[3] close failed (%s)\n", cli_errstr(cli1));
3406 }
3407 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3408 correct = False;
3409 goto fail;
3410 } else
3411 printf("third delete on close test succeeded.\n");
3412
3413 /* Test 4 ... */
3414 cli_setatr(cli1, fname, 0, 0);
3415 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3416
3417 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3418 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3419 printf("[4] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3420 correct = False;
3421 goto fail;
3422 }
3423
3424 /* This should succeed. */
3425 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
3426 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0, &fnum2))) {
3427 printf("[4] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3428 correct = False;
3429 goto fail;
3430 }
3431
3432 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
3433 printf("[4] close - 1 failed (%s)\n", cli_errstr(cli1));
3434 correct = False;
3435 goto fail;
3436 }
3437
3438 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3439 printf("[4] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3440 correct = False;
3441 goto fail;
3442 }
3443
3444 /* This should fail - no more opens once delete on close set. */
3445 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
3446 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3447 FILE_OPEN, 0, 0, &fnum2))) {
3448 printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname );
3449 correct = False;
3450 goto fail;
3451 } else
3452 printf("fourth delete on close test succeeded.\n");
3453
3454 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3455 printf("[4] close - 2 failed (%s)\n", cli_errstr(cli1));
3456 correct = False;
3457 goto fail;
3458 }
3459
3460 /* Test 5 ... */
3461 cli_setatr(cli1, fname, 0, 0);
3462 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3463
3464 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum1))) {
3465 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3466 correct = False;
3467 goto fail;
3468 }
3469
3470 /* This should fail - only allowed on NT opens with DELETE access. */
3471
3472 if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3473 printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
3474 correct = False;
3475 goto fail;
3476 }
3477
3478 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3479 printf("[5] close - 2 failed (%s)\n", cli_errstr(cli1));
3480 correct = False;
3481 goto fail;
3482 }
3483
3484 printf("fifth delete on close test succeeded.\n");
3485
3486 /* Test 6 ... */
3487 cli_setatr(cli1, fname, 0, 0);
3488 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3489
3490 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
3491 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3492 FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3493 printf("[6] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3494 correct = False;
3495 goto fail;
3496 }
3497
3498 /* This should fail - only allowed on NT opens with DELETE access. */
3499
3500 if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3501 printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
3502 correct = False;
3503 goto fail;
3504 }
3505
3506 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3507 printf("[6] close - 2 failed (%s)\n", cli_errstr(cli1));
3508 correct = False;
3509 goto fail;
3510 }
3511
3512 printf("sixth delete on close test succeeded.\n");
3513
3514 /* Test 7 ... */
3515 cli_setatr(cli1, fname, 0, 0);
3516 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3517
3518 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3519 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3520 printf("[7] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3521 correct = False;
3522 goto fail;
3523 }
3524
3525 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3526 printf("[7] setting delete_on_close on file failed !\n");
3527 correct = False;
3528 goto fail;
3529 }
3530
3531 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, false))) {
3532 printf("[7] unsetting delete_on_close on file failed !\n");
3533 correct = False;
3534 goto fail;
3535 }
3536
3537 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3538 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3539 correct = False;
3540 goto fail;
3541 }
3542
3543 /* This next open should succeed - we reset the flag. */
3544
3545 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3546 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3547 correct = False;
3548 goto fail;
3549 }
3550
3551 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3552 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3553 correct = False;
3554 goto fail;
3555 }
3556
3557 printf("seventh delete on close test succeeded.\n");
3558
3559 /* Test 7 ... */
3560 cli_setatr(cli1, fname, 0, 0);
3561 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3562
3563 if (!torture_open_connection(&cli2, 1)) {
3564 printf("[8] failed to open second connection.\n");
3565 correct = False;
3566 goto fail;
3567 }
3568
3569 cli_sockopt(cli1, sockops);
3570
3571 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3572 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3573 FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3574 printf("[8] open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3575 correct = False;
3576 goto fail;
3577 }
3578
3579 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3580 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3581 FILE_OPEN, 0, 0, &fnum2))) {
3582 printf("[8] open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3583 correct = False;
3584 goto fail;
3585 }
3586
3587 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
3588 printf("[8] setting delete_on_close on file failed !\n");
3589 correct = False;
3590 goto fail;
3591 }
3592
3593 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3594 printf("[8] close - 1 failed (%s)\n", cli_errstr(cli1));
3595 correct = False;
3596 goto fail;
3597 }
3598
3599 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
3600 printf("[8] close - 2 failed (%s)\n", cli_errstr(cli2));
3601 correct = False;
3602 goto fail;
3603 }
3604
3605 /* This should fail.. */
3606 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3607 printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
3608 goto fail;
3609 correct = False;
3610 } else
3611 printf("eighth delete on close test succeeded.\n");
3612
3613 /* This should fail - we need to set DELETE_ACCESS. */
3614 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,FILE_READ_DATA|FILE_WRITE_DATA,
3615 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
3616 printf("[9] open of %s succeeded should have failed!\n", fname);
3617 correct = False;
3618 goto fail;
3619 }
3620
3621 printf("ninth delete on close test succeeded.\n");
3622
3623 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3624 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
3625 printf("[10] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3626 correct = False;
3627 goto fail;
3628 }
3629
3630 /* This should delete the file. */
3631 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3632 printf("[10] close failed (%s)\n", cli_errstr(cli1));
3633 correct = False;
3634 goto fail;
3635 }
3636
3637 /* This should fail.. */
3638 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3639 printf("[10] open of %s succeeded should have been deleted on close !\n", fname);
3640 goto fail;
3641 correct = False;
3642 } else
3643 printf("tenth delete on close test succeeded.\n");
3644
3645 cli_setatr(cli1, fname, 0, 0);
3646 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3647
3648 /* What error do we get when attempting to open a read-only file with
3649 delete access ? */
3650
3651 /* Create a readonly file. */
3652 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
3653 FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3654 printf("[11] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3655 correct = False;
3656 goto fail;
3657 }
3658
3659 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3660 printf("[11] close failed (%s)\n", cli_errstr(cli1));
3661 correct = False;
3662 goto fail;
3663 }
3664
3665 /* Now try open for delete access. */
3666 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES|DELETE_ACCESS,
3667 0, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3668 FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3669 printf("[11] open of %s succeeded should have been denied with ACCESS_DENIED!\n", fname);
3670 cli_close(cli1, fnum1);
3671 goto fail;
3672 correct = False;
3673 } else {
3674 NTSTATUS nterr = cli_nt_error(cli1);
3675 if (!NT_STATUS_EQUAL(nterr,NT_STATUS_ACCESS_DENIED)) {
3676 printf("[11] open of %s should have been denied with ACCESS_DENIED! Got error %s\n", fname, nt_errstr(nterr));
3677 goto fail;
3678 correct = False;
3679 } else {
3680 printf("eleventh delete on close test succeeded.\n");
3681 }
3682 }
3683
3684 printf("finished delete test\n");
3685
3686 fail:
3687 /* FIXME: This will crash if we aborted before cli2 got
3688 * intialized, because these functions don't handle
3689 * uninitialized connections. */
3690
3691 if (fnum1 != (uint16_t)-1) cli_close(cli1, fnum1);
3692 if (fnum2 != (uint16_t)-1) cli_close(cli1, fnum2);
3693 cli_setatr(cli1, fname, 0, 0);
3694 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3695
3696 if (cli1 && !torture_close_connection(cli1)) {
3697 correct = False;
3698 }
3699 if (cli2 && !torture_close_connection(cli2)) {
3700 correct = False;
3701 }
3702 return correct;
3703 }
3704
3705
3706 /*
3707 print out server properties
3708 */
3709 static bool run_properties(int dummy)
3710 {
3711 struct cli_state *cli;
3712 bool correct = True;
3713
3714 printf("starting properties test\n");
3715
3716 ZERO_STRUCT(cli);
3717
3718 if (!torture_open_connection(&cli, 0)) {
3719 return False;
3720 }
3721
3722 cli_sockopt(cli, sockops);
3723
3724 d_printf("Capabilities 0x%08x\n", cli->capabilities);
3725
3726 if (!torture_close_connection(cli)) {
3727 correct = False;
3728 }
3729
3730 return correct;
3731 }
3732
3733
3734
3735 /* FIRST_DESIRED_ACCESS 0xf019f */
3736 #define FIRST_DESIRED_ACCESS FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\
3737 FILE_READ_EA| /* 0xf */ \
3738 FILE_WRITE_EA|FILE_READ_ATTRIBUTES| /* 0x90 */ \
3739 FILE_WRITE_ATTRIBUTES| /* 0x100 */ \
3740 DELETE_ACCESS|READ_CONTROL_ACCESS|\
3741 WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS /* 0xf0000 */
3742 /* SECOND_DESIRED_ACCESS 0xe0080 */
3743 #define SECOND_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
3744 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
3745 WRITE_OWNER_ACCESS /* 0xe0000 */
3746
3747 #if 0
3748 #define THIRD_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
3749 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
3750 FILE_READ_DATA|\
3751 WRITE_OWNER_ACCESS /* */
3752 #endif
3753
3754 /*
3755 Test ntcreate calls made by xcopy
3756 */
3757 static bool run_xcopy(int dummy)
3758 {
3759 static struct cli_state *cli1;
3760 const char *fname = "\\test.txt";
3761 bool correct = True;
3762 uint16_t fnum1, fnum2;
3763
3764 printf("starting xcopy test\n");
3765
3766 if (!torture_open_connection(&cli1, 0)) {
3767 return False;
3768 }
3769
3770 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,
3771 FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
3772 FILE_SHARE_NONE, FILE_OVERWRITE_IF,
3773 0x4044, 0, &fnum1))) {
3774 printf("First open failed - %s\n", cli_errstr(cli1));
3775 return False;
3776 }
3777
3778 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,
3779 SECOND_DESIRED_ACCESS, 0,
3780 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN,
3781 0x200000, 0, &fnum2))) {
3782 printf("second open failed - %s\n", cli_errstr(cli1));
3783 return False;
3784 }
3785
3786 if (!torture_close_connection(cli1)) {
3787 correct = False;
3788 }
3789
3790 return correct;
3791 }
3792
3793 /*
3794 Test rename on files open with share delete and no share delete.
3795 */
3796 static bool run_rename(int dummy)
3797 {
3798 static struct cli_state *cli1;
3799 const char *fname = "\\test.txt";
3800 const char *fname1 = "\\test1.txt";
3801 bool correct = True;
3802 uint16_t fnum1;
3803 NTSTATUS status;
3804
3805 printf("starting rename test\n");
3806
3807 if (!torture_open_connection(&cli1, 0)) {
3808 return False;
3809 }
3810
3811 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3812 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
3813 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3814 FILE_SHARE_READ, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3815 printf("First open failed - %s\n", cli_errstr(cli1));
3816 return False;
3817 }
3818
3819 if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
3820 printf("First rename failed (SHARE_READ) (this is correct) - %s\n", cli_errstr(cli1));
3821 } else {
3822 printf("First rename succeeded (SHARE_READ) - this should have failed !\n");
3823 correct = False;
3824 }
3825
3826 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3827 printf("close - 1 failed (%s)\n", cli_errstr(cli1));
3828 return False;
3829 }
3830
3831 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3832 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
3833 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3834 #if 0
3835 FILE_SHARE_DELETE|FILE_SHARE_NONE,
3836 #else
3837 FILE_SHARE_DELETE|FILE_SHARE_READ,
3838 #endif
3839 FILE_OVERWRITE_IF, 0, 0, &fnum1);
3840 if (!NT_STATUS_IS_OK(status)) {
3841 printf("Second open failed - %s\n", cli_errstr(cli1));
3842 return False;
3843 }
3844
3845 if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
3846 printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", cli_errstr(cli1));
3847 correct = False;
3848 } else {
3849 printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n");
3850 }
3851
3852 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3853 printf("close - 2 failed (%s)\n", cli_errstr(cli1));
3854 return False;
3855 }
3856
3857 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3858 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
3859
3860 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, READ_CONTROL_ACCESS, FILE_ATTRIBUTE_NORMAL,
3861 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3862 printf("Third open failed - %s\n", cli_errstr(cli1));
3863 return False;
3864 }
3865
3866
3867 #if 0
3868 {
3869 uint16_t fnum2;
3870
3871 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
3872 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
3873 printf("Fourth open failed - %s\n", cli_errstr(cli1));
3874 return False;
3875 }
3876 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum2, true))) {
3877 printf("[8] setting delete_on_close on file failed !\n");
3878 return False;
3879 }
3880
3881 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
3882 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
3883 return False;
3884 }
3885 }
3886 #endif
3887
3888 if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
3889 printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", cli_errstr(cli1));
3890 correct = False;
3891 } else {
3892 printf("Third rename succeeded (SHARE_NONE)\n");
3893 }
3894
3895 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3896 printf("close - 3 failed (%s)\n", cli_errstr(cli1));
3897 return False;
3898 }
3899
3900 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3901 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
3902
3903 /*----*/
3904
3905 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3906 FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3907 printf("Fourth open failed - %s\n", cli_errstr(cli1));
3908 return False;
3909 }
3910
3911 if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
3912 printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", cli_errstr(cli1));
3913 } else {
3914 printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n");
3915 correct = False;
3916 }
3917
3918 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3919 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
3920 return False;
3921 }
3922
3923 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3924 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
3925
3926 /*--*/
3927
3928 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3929 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
3930 printf("Fifth open failed - %s\n", cli_errstr(cli1));
3931 return False;
3932 }
3933
3934 if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
3935 printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n",
3936 cli_errstr(cli1));
3937 correct = False;
3938 } else {
3939 printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", cli_errstr(cli1));
3940 }
3941
3942 /*
3943 * Now check if the first name still exists ...
3944 */
3945
3946 /* if (!NT_STATUS_OP(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3947 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
3948 printf("Opening original file after rename of open file fails: %s\n",
3949 cli_errstr(cli1));
3950 }
3951 else {
3952 printf("Opening original file after rename of open file works ...\n");
3953 (void)cli_close(cli1, fnum2);
3954 } */
3955
3956 /*--*/
3957
3958
3959 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
3960 printf("close - 5 failed (%s)\n", cli_errstr(cli1));
3961 return False;
3962 }
3963
3964 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
3965 cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
3966
3967 if (!torture_close_connection(cli1)) {
3968 correct = False;
3969 }
3970
3971 return correct;
3972 }
3973
3974 static bool run_pipe_number(int dummy)
3975 {
3976 struct cli_state *cli1;
3977 const char *pipe_name = "\\SPOOLSS";
3978 uint16_t fnum;
3979 int num_pipes = 0;
3980
3981 printf("starting pipenumber test\n");
3982 if (!torture_open_connection(&cli1, 0)) {
3983 return False;
3984 }
3985
3986 cli_sockopt(cli1, sockops);
3987 while(1) {
3988 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, pipe_name, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
3989 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF, 0, 0, &fnum))) {
3990 printf("Open of pipe %s failed with error (%s)\n", pipe_name, cli_errstr(cli1));
3991 break;
3992 }
3993 num_pipes++;
3994 printf("\r%6d", num_pipes);
3995 }
3996
3997 printf("pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
3998 torture_close_connection(cli1);
3999 return True;
4000 }
4001
4002 /*
4003 Test open mode returns on read-only files.
4004 */
4005 static bool run_opentest(int dummy)
4006 {
4007 static struct cli_state *cli1;
4008 static struct cli_state *cli2;
4009 const char *fname = "\\readonly.file";
4010 uint16_t fnum1, fnum2;
4011 char buf[20];
4012 SMB_OFF_T fsize;
4013 bool correct = True;
4014 char *tmp_path;
4015
4016 printf("starting open test\n");
4017
4018 if (!torture_open_connection(&cli1, 0)) {
4019 return False;
4020 }
4021
4022 cli_setatr(cli1, fname, 0, 0);
4023 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4024
4025 cli_sockopt(cli1, sockops);
4026
4027 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
4028 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
4029 return False;
4030 }
4031
4032 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4033 printf("close2 failed (%s)\n", cli_errstr(cli1));
4034 return False;
4035 }
4036
4037 if (!NT_STATUS_IS_OK(cli_setatr(cli1, fname, aRONLY, 0))) {
4038 printf("cli_setatr failed (%s)\n", cli_errstr(cli1));
4039 return False;
4040 }
4041
4042 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1))) {
4043 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
4044 return False;
4045 }
4046
4047 /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
4048 cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
4049
4050 if (check_error(__LINE__, cli1, ERRDOS, ERRnoaccess,
4051 NT_STATUS_ACCESS_DENIED)) {
4052 printf("correct error code ERRDOS/ERRnoaccess returned\n");
4053 }
4054
4055 printf("finished open test 1\n");
4056
4057 cli_close(cli1, fnum1);
4058
4059 /* Now try not readonly and ensure ERRbadshare is returned. */
4060
4061 cli_setatr(cli1, fname, 0, 0);
4062
4063 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1))) {
4064 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
4065 return False;
4066 }
4067
4068 /* This will fail - but the error should be ERRshare. */
4069 cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
4070
4071 if (check_error(__LINE__, cli1, ERRDOS, ERRbadshare,
4072 NT_STATUS_SHARING_VIOLATION)) {
4073 printf("correct error code ERRDOS/ERRbadshare returned\n");
4074 }
4075
4076 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4077 printf("close2 failed (%s)\n", cli_errstr(cli1));
4078 return False;
4079 }
4080
4081 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4082
4083 printf("finished open test 2\n");
4084
4085 /* Test truncate open disposition on file opened for read. */
4086
4087 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
4088 printf("(3) open (1) of %s failed (%s)\n", fname, cli_errstr(cli1));
4089 return False;
4090 }
4091
4092 /* write 20 bytes. */
4093
4094 memset(buf, '\0', 20);
4095
4096 if (cli_write(cli1, fnum1, 0, buf, 0, 20) != 20) {
4097 printf("write failed (%s)\n", cli_errstr(cli1));
4098 correct = False;
4099 }
4100
4101 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4102 printf("(3) close1 failed (%s)\n", cli_errstr(cli1));
4103 return False;
4104 }
4105
4106 /* Ensure size == 20. */
4107 if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname, NULL, &fsize, NULL))) {
4108 printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
4109 return False;
4110 }
4111
4112 if (fsize != 20) {
4113 printf("(3) file size != 20\n");
4114 return False;
4115 }
4116
4117 /* Now test if we can truncate a file opened for readonly. */
4118
4119 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE, &fnum1))) {
4120 printf("(3) open (2) of %s failed (%s)\n", fname, cli_errstr(cli1));
4121 return False;
4122 }
4123
4124 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4125 printf("close2 failed (%s)\n", cli_errstr(cli1));
4126 return False;
4127 }
4128
4129 /* Ensure size == 0. */
4130 if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname, NULL, &fsize, NULL))) {
4131 printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
4132 return False;
4133 }
4134
4135 if (fsize != 0) {
4136 printf("(3) file size != 0\n");
4137 return False;
4138 }
4139 printf("finished open test 3\n");
4140
4141 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4142
4143
4144 printf("testing ctemp\n");
4145 if (!NT_STATUS_IS_OK(cli_ctemp(cli1, talloc_tos(), "\\", &fnum1, &tmp_path))) {
4146 printf("ctemp failed (%s)\n", cli_errstr(cli1));
4147 return False;
4148 }
4149 printf("ctemp gave path %s\n", tmp_path);
4150 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4151 printf("close of temp failed (%s)\n", cli_errstr(cli1));
4152 }
4153 if (!NT_STATUS_IS_OK(cli_unlink(cli1, tmp_path, aSYSTEM | aHIDDEN))) {
4154 printf("unlink of temp failed (%s)\n", cli_errstr(cli1));
4155 }
4156
4157 /* Test the non-io opens... */
4158
4159 if (!torture_open_connection(&cli2, 1)) {
4160 return False;
4161 }
4162
4163 cli_setatr(cli2, fname, 0, 0);
4164 cli_unlink(cli2, fname, aSYSTEM | aHIDDEN);
4165
4166 cli_sockopt(cli2, sockops);
4167
4168 printf("TEST #1 testing 2 non-io opens (no delete)\n");
4169
4170 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4171 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4172 printf("test 1 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4173 return False;
4174 }
4175
4176 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4177 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4178 printf("test 1 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4179 return False;
4180 }
4181
4182 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4183 printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4184 return False;
4185 }
4186 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
4187 printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4188 return False;
4189 }
4190
4191 printf("non-io open test #1 passed.\n");
4192
4193 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4194
4195 printf("TEST #2 testing 2 non-io opens (first with delete)\n");
4196
4197 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4198 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4199 printf("test 2 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4200 return False;
4201 }
4202
4203 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4204 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4205 printf("test 2 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4206 return False;
4207 }
4208
4209 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4210 printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4211 return False;
4212 }
4213 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
4214 printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
4215 return False;
4216 }
4217
4218 printf("non-io open test #2 passed.\n");
4219
4220 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4221
4222 printf("TEST #3 testing 2 non-io opens (second with delete)\n");
4223
4224 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4225 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4226 printf("test 3 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4227 return False;
4228 }
4229
4230 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4231 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4232 printf("test 3 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4233 return False;
4234 }
4235
4236 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4237 printf("test 3 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4238 return False;
4239 }
4240 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
4241 printf("test 3 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4242 return False;
4243 }
4244
4245 printf("non-io open test #3 passed.\n");
4246
4247 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4248
4249 printf("TEST #4 testing 2 non-io opens (both with delete)\n");
4250
4251 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4252 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4253 printf("test 4 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4254 return False;
4255 }
4256
4257 if (NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4258 FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4259 printf("test 4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
4260 return False;
4261 }
4262
4263 printf("test 3 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
4264
4265 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4266 printf("test 4 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4267 return False;
4268 }
4269
4270 printf("non-io open test #4 passed.\n");
4271
4272 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4273
4274 printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
4275
4276 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4277 FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4278 printf("test 5 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4279 return False;
4280 }
4281
4282 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4283 FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4284 printf("test 5 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4285 return False;
4286 }
4287
4288 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4289 printf("test 5 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4290 return False;
4291 }
4292
4293 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
4294 printf("test 5 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4295 return False;
4296 }
4297
4298 printf("non-io open test #5 passed.\n");
4299
4300 printf("TEST #6 testing 1 non-io open, one io open\n");
4301
4302 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4303
4304 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
4305 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4306 printf("test 6 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4307 return False;
4308 }
4309
4310 if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4311 FILE_SHARE_READ, FILE_OPEN_IF, 0, 0, &fnum2))) {
4312 printf("test 6 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4313 return False;
4314 }
4315
4316 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4317 printf("test 6 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4318 return False;
4319 }
4320
4321 if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
4322 printf("test 6 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4323 return False;
4324 }
4325
4326 printf("non-io open test #6 passed.\n");
4327
4328 printf("TEST #7 testing 1 non-io open, one io open with delete\n");
4329
4330 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4331
4332 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
4333 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4334 printf("test 7 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4335 return False;
4336 }
4337
4338 if (NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4339 FILE_SHARE_READ|FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0, &fnum2))) {
4340 printf("test 7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
4341 return False;
4342 }
4343
4344 printf("test 7 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
4345
4346 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4347 printf("test 7 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4348 return False;
4349 }
4350
4351 printf("non-io open test #7 passed.\n");
4352
4353 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4354
4355 if (!torture_close_connection(cli1)) {
4356 correct = False;
4357 }
4358 if (!torture_close_connection(cli2)) {
4359 correct = False;
4360 }
4361
4362 return correct;
4363 }
4364
4365 /*
4366 Test POSIX open /mkdir calls.
4367 */
4368 static bool run_simple_posix_open_test(int dummy)
4369 {
4370 static struct cli_state *cli1;
4371 const char *fname = "posix:file";
4372 const char *hname = "posix:hlink";
4373 const char *sname = "posix:symlink";
4374 const char *dname = "posix:dir";
4375 char buf[10];
4376 char namebuf[11];
4377 uint16 major, minor;
4378 uint32 caplow, caphigh;
4379 uint16_t fnum1 = (uint16_t)-1;
4380 SMB_STRUCT_STAT sbuf;
4381 bool correct = false;
4382 NTSTATUS status;
4383
4384 printf("Starting simple POSIX open test\n");
4385
4386 if (!torture_open_connection(&cli1, 0)) {
4387 return false;
4388 }
4389
4390 cli_sockopt(cli1, sockops);
4391
4392 if (!SERVER_HAS_UNIX_CIFS(cli1)) {
4393 printf("Server doesn't support UNIX CIFS extensions.\n");
4394 return false;
4395 }
4396
4397 status = cli_unix_extensions_version(cli1, &major, &minor, &caplow,
4398 &caphigh);
4399 if (!NT_STATUS_IS_OK(status)) {
4400 printf("Server didn't return UNIX CIFS extensions: %s\n",
4401 nt_errstr(status));
4402 return false;
4403 }
4404
4405 status = cli_set_unix_extensions_capabilities(cli1, major, minor,
4406 caplow, caphigh);
4407 if (!NT_STATUS_IS_OK(status)) {
4408 printf("Server doesn't support setting UNIX CIFS extensions: "
4409 "%s.\n", nt_errstr(status));
4410 return false;
4411 }
4412
4413 cli_setatr(cli1, fname, 0, 0);
4414 cli_posix_unlink(cli1, fname);
4415 cli_setatr(cli1, dname, 0, 0);
4416 cli_posix_rmdir(cli1, dname);
4417 cli_setatr(cli1, hname, 0, 0);
4418 cli_posix_unlink(cli1, hname);
4419 cli_setatr(cli1, sname, 0, 0);
4420 cli_posix_unlink(cli1, sname);
4421
4422 /* Create a directory. */
4423 if (!NT_STATUS_IS_OK(cli_posix_mkdir(cli1, dname, 0777))) {
4424 printf("POSIX mkdir of %s failed (%s)\n", dname, cli_errstr(cli1));
4425 goto out;
4426 }
4427
4428 if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1))) {
4429 printf("POSIX create of %s failed (%s)\n", fname, cli_errstr(cli1));
4430 goto out;
4431 }
4432
4433 /* Test ftruncate - set file size. */
4434 if (!NT_STATUS_IS_OK(cli_ftruncate(cli1, fnum1, 1000))) {
4435 printf("ftruncate failed (%s)\n", cli_errstr(cli1));
4436 goto out;
4437 }
4438
4439 /* Ensure st_size == 1000 */
4440 if (!NT_STATUS_IS_OK(cli_posix_stat(cli1, fname, &sbuf))) {
4441 printf("stat failed (%s)\n", cli_errstr(cli1));
4442 goto out;
4443 }
4444
4445 if (sbuf.st_ex_size != 1000) {
4446 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
4447 goto out;
4448 }
4449
4450 /* Test ftruncate - set file size back to zero. */
4451 if (!NT_STATUS_IS_OK(cli_ftruncate(cli1, fnum1, 0))) {
4452 printf("ftruncate failed (%s)\n", cli_errstr(cli1));
4453 goto out;
4454 }
4455
4456 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4457 printf("close failed (%s)\n", cli_errstr(cli1));
4458 goto out;
4459 }
4460
4461 /* Now open the file again for read only. */
4462 if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1))) {
4463 printf("POSIX open of %s failed (%s)\n", fname, cli_errstr(cli1));
4464 goto out;
4465 }
4466
4467 /* Now unlink while open. */
4468 if (!NT_STATUS_IS_OK(cli_posix_unlink(cli1, fname))) {
4469 printf("POSIX unlink of %s failed (%s)\n", fname, cli_errstr(cli1));
4470 goto out;
4471 }
4472
4473 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4474 printf("close(2) failed (%s)\n", cli_errstr(cli1));
4475 goto out;
4476 }
4477
4478 /* Ensure the file has gone. */
4479 if (NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1))) {
4480 printf("POSIX open of %s succeeded, should have been deleted.\n", fname);
4481 goto out;
4482 }
4483
4484 /* What happens when we try and POSIX open a directory ? */
4485 if (NT_STATUS_IS_OK(cli_posix_open(cli1, dname, O_RDONLY, 0, &fnum1))) {
4486 printf("POSIX open of directory %s succeeded, should have failed.\n", fname);
4487 goto out;
4488 } else {
4489 if (!check_error(__LINE__, cli1, ERRDOS, EISDIR,
4490 NT_STATUS_FILE_IS_A_DIRECTORY)) {
4491 goto out;
4492 }
4493 }
4494
4495 /* Create the file. */
4496 if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1))) {
4497 printf("POSIX create of %s failed (%s)\n", fname, cli_errstr(cli1));
4498 goto out;
4499 }
4500
4501 /* Write some data into it. */
4502 if (cli_write(cli1, fnum1, 0, "TEST DATA\n", 0, 10) != 10) {
4503 printf("cli_write failed: %s\n", cli_errstr(cli1));
4504 goto out;
4505 }
4506
4507 cli_close(cli1, fnum1);
4508
4509 /* Now create a hardlink. */
4510 if (!NT_STATUS_IS_OK(cli_posix_hardlink(cli1, fname, hname))) {
4511 printf("POSIX hardlink of %s failed (%s)\n", hname, cli_errstr(cli1));
4512 goto out;
4513 }
4514
4515 /* Now create a symlink. */
4516 if (!NT_STATUS_IS_OK(cli_posix_symlink(cli1, fname, sname))) {
4517 printf("POSIX symlink of %s failed (%s)\n", sname, cli_errstr(cli1));
4518 goto out;
4519 }
4520
4521 /* Open the hardlink for read. */
4522 if (!NT_STATUS_IS_OK(cli_posix_open(cli1, hname, O_RDONLY, 0, &fnum1))) {
4523 printf("POSIX open of %s failed (%s)\n", hname, cli_errstr(cli1));
4524 goto out;
4525 }
4526
4527 if (cli_read(cli1, fnum1, buf, 0, 10) != 10) {
4528 printf("POSIX read of %s failed (%s)\n", hname, cli_errstr(cli1));
4529 goto out;
4530 }
4531
4532 if (memcmp(buf, "TEST DATA\n", 10)) {
4533 printf("invalid data read from hardlink\n");
4534 goto out;
4535 }
4536
4537 /* Do a POSIX lock/unlock. */
4538 if (!NT_STATUS_IS_OK(cli_posix_lock(cli1, fnum1, 0, 100, true, READ_LOCK))) {
4539 printf("POSIX lock failed %s\n", cli_errstr(cli1));
4540 goto out;
4541 }
4542
4543 /* Punch a hole in the locked area. */
4544 if (!NT_STATUS_IS_OK(cli_posix_unlock(cli1, fnum1, 10, 80))) {
4545 printf("POSIX unlock failed %s\n", cli_errstr(cli1));
4546 goto out;
4547 }
4548
4549 cli_close(cli1, fnum1);
4550
4551 /* Open the symlink for read - this should fail. A POSIX
4552 client should not be doing opens on a symlink. */
4553 if (NT_STATUS_IS_OK(cli_posix_open(cli1, sname, O_RDONLY, 0, &fnum1))) {
4554 printf("POSIX open of %s succeeded (should have failed)\n", sname);
4555 goto out;
4556 } else {
4557 if (!check_error(__LINE__, cli1, ERRDOS, ERRbadpath,
4558 NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
4559 printf("POSIX open of %s should have failed "
4560 "with NT_STATUS_OBJECT_PATH_NOT_FOUND, "
4561 "failed with %s instead.\n",
4562 sname, cli_errstr(cli1));
4563 goto out;
4564 }
4565 }
4566
4567 if (!NT_STATUS_IS_OK(cli_posix_readlink(cli1, sname, namebuf, sizeof(namebuf)))) {
4568 printf("POSIX readlink on %s failed (%s)\n", sname, cli_errstr(cli1));
4569 goto out;
4570 }
4571
4572 if (strcmp(namebuf, fname) != 0) {
4573 printf("POSIX readlink on %s failed to match name %s (read %s)\n",
4574 sname, fname, namebuf);
4575 goto out;
4576 }
4577
4578 if (!NT_STATUS_IS_OK(cli_posix_rmdir(cli1, dname))) {
4579 printf("POSIX rmdir failed (%s)\n", cli_errstr(cli1));
4580 goto out;
4581 }
4582
4583 printf("Simple POSIX open test passed\n");
4584 correct = true;
4585
4586 out:
4587
4588 if (fnum1 != (uint16_t)-1) {
4589 cli_close(cli1, fnum1);
4590 fnum1 = (uint16_t)-1;
4591 }
4592
4593 cli_setatr(cli1, sname, 0, 0);
4594 cli_posix_unlink(cli1, sname);
4595 cli_setatr(cli1, hname, 0, 0);
4596 cli_posix_unlink(cli1, hname);
4597 cli_setatr(cli1, fname, 0, 0);
4598 cli_posix_unlink(cli1, fname);
4599 cli_setatr(cli1, dname, 0, 0);
4600 cli_posix_rmdir(cli1, dname);
4601
4602 if (!torture_close_connection(cli1)) {
4603 correct = false;
4604 }
4605
4606 return correct;
4607 }
4608
4609
4610 static uint32 open_attrs_table[] = {
4611 FILE_ATTRIBUTE_NORMAL,
4612 FILE_ATTRIBUTE_ARCHIVE,
4613 FILE_ATTRIBUTE_READONLY,
4614 FILE_ATTRIBUTE_HIDDEN,
4615 FILE_ATTRIBUTE_SYSTEM,
4616
4617 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY,
4618 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN,
4619 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,
4620 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
4621 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
4622 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
4623
4624 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
4625 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
4626 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
4627 FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM,
4628 };
4629
4630 struct trunc_open_results {
4631 unsigned int num;
4632 uint32 init_attr;
4633 uint32 trunc_attr;
4634 uint32 result_attr;
4635 };
4636
4637 static struct trunc_open_results attr_results[] = {
4638 { 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
4639 { 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
4640 { 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
4641 { 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
4642 { 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
4643 { 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
4644 { 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4645 { 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4646 { 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
4647 { 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4648 { 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4649 { 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
4650 { 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4651 { 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4652 { 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 },
4653 { 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4654 { 119, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4655 { 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 },
4656 { 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 },
4657 { 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 },
4658 { 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4659 { 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4660 { 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
4661 { 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4662 { 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4663 { 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
4664 };
4665
4666 static bool run_openattrtest(int dummy)
4667 {
4668 static struct cli_state *cli1;
4669 const char *fname = "\\openattr.file";
4670 uint16_t fnum1;
4671 bool correct = True;
4672 uint16 attr;
4673 unsigned int i, j, k, l;
4674
4675 printf("starting open attr test\n");
4676
4677 if (!torture_open_connection(&cli1, 0)) {
4678 return False;
4679 }
4680
4681 cli_sockopt(cli1, sockops);
4682
4683 for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32); i++) {
4684 cli_setatr(cli1, fname, 0, 0);
4685 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4686 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA, open_attrs_table[i],
4687 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4688 printf("open %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
4689 return False;
4690 }
4691
4692 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4693 printf("close %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
4694 return False;
4695 }
4696
4697 for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32); j++) {
4698 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA, open_attrs_table[j],
4699 FILE_SHARE_NONE, FILE_OVERWRITE, 0, 0, &fnum1))) {
4700 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
4701 if (attr_results[l].num == k) {
4702 printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
4703 k, open_attrs_table[i],
4704 open_attrs_table[j],
4705 fname, NT_STATUS_V(cli_nt_error(cli1)), cli_errstr(cli1));
4706 correct = False;
4707 }
4708 }
4709 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_ACCESS_DENIED)) {
4710 printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n",
4711 k, open_attrs_table[i], open_attrs_table[j],
4712 cli_errstr(cli1));
4713 correct = False;
4714 }
4715 #if 0
4716 printf("[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]);
4717 #endif
4718 k++;
4719 continue;
4720 }
4721
4722 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
4723 printf("close %d (2) of %s failed (%s)\n", j, fname, cli_errstr(cli1));
4724 return False;
4725 }
4726
4727 if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname, &attr, NULL, NULL))) {
4728 printf("getatr(2) failed (%s)\n", cli_errstr(cli1));
4729 return False;
4730 }
4731
4732 #if 0
4733 printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
4734 k, open_attrs_table[i], open_attrs_table[j], attr );
4735 #endif
4736
4737 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
4738 if (attr_results[l].num == k) {
4739 if (attr != attr_results[l].result_attr ||
4740 open_attrs_table[i] != attr_results[l].init_attr ||
4741 open_attrs_table[j] != attr_results[l].trunc_attr) {
4742 printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
4743 open_attrs_table[i],
4744 open_attrs_table[j],
4745 (unsigned int)attr,
4746 attr_results[l].result_attr);
4747 correct = False;
4748 }
4749 break;
4750 }
4751 }
4752 k++;
4753 }
4754 }
4755
4756 cli_setatr(cli1, fname, 0, 0);
4757 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
4758
4759 printf("open attr test %s.\n", correct ? "passed" : "failed");
4760
4761 if (!torture_close_connection(cli1)) {
4762 correct = False;
4763 }
4764 return correct;
4765 }
4766
4767 static void list_fn(const char *mnt, file_info *finfo, const char *name, void *state)
4768 {
4769
4770 }
4771
4772 /*
4773 test directory listing speed
4774 */
4775 static bool run_dirtest(int dummy)
4776 {
4777 int i;
4778 static struct cli_state *cli;
4779 uint16_t fnum;
4780 double t1;
4781 bool correct = True;
4782
4783 printf("starting directory test\n");
4784
4785 if (!torture_open_connection(&cli, 0)) {
4786 return False;
4787 }
4788
4789 cli_sockopt(cli, sockops);
4790
4791 srandom(0);
4792 for (i=0;i<torture_numops;i++) {
4793 fstring fname;
4794 slprintf(fname, sizeof(fname), "\\%x", (int)random());
4795 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum))) {
4796 fprintf(stderr,"Failed to open %s\n", fname);
4797 return False;
4798 }
4799 cli_close(cli, fnum);
4800 }
4801
4802 t1 = end_timer();
4803
4804 printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
4805 printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
4806 printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
4807
4808 printf("dirtest core %g seconds\n", end_timer() - t1);
4809
4810 srandom(0);
4811 for (i=0;i<torture_numops;i++) {
4812 fstring fname;
4813 slprintf(fname, sizeof(fname), "\\%x", (int)random());
4814 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
4815 }
4816
4817 if (!torture_close_connection(cli)) {
4818 correct = False;
4819 }
4820
4821 printf("finished dirtest\n");
4822
4823 return correct;
4824 }
4825
4826 static void del_fn(const char *mnt, file_info *finfo, const char *mask, void *state)
4827 {
4828 struct cli_state *pcli = (struct cli_state *)state;
4829 fstring fname;
4830 slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name);
4831
4832 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
4833 return;
4834
4835 if (finfo->mode & aDIR) {
4836 if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname)))
4837 printf("del_fn: failed to rmdir %s\n,", fname );
4838 } else {
4839 if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, aSYSTEM | aHIDDEN)))
4840 printf("del_fn: failed to unlink %s\n,", fname );
4841 }
4842 }
4843
4844
4845 /*
4846 sees what IOCTLs are supported
4847 */
4848 bool torture_ioctl_test(int dummy)
4849 {
4850 static struct cli_state *cli;
4851 uint16_t device, function;
4852 uint16_t fnum;
4853 const char *fname = "\\ioctl.dat";
4854 DATA_BLOB blob;
4855 NTSTATUS status;
4856
4857 if (!torture_open_connection(&cli, 0)) {
4858 return False;
4859 }
4860
4861 printf("starting ioctl test\n");
4862
4863 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
4864
4865 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
4866 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
4867 return False;
4868 }
4869
4870 status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob);
4871 printf("ioctl device info: %s\n", cli_errstr(cli));
4872
4873 status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob);
4874 printf("ioctl job info: %s\n", cli_errstr(cli));
4875
4876 for (device=0;device<0x100;device++) {
4877 printf("testing device=0x%x\n", device);
4878 for (function=0;function<0x100;function++) {
4879 uint32 code = (device<<16) | function;
4880
4881 status = cli_raw_ioctl(cli, fnum, code, &blob);
4882
4883 if (NT_STATUS_IS_OK(status)) {
4884 printf("ioctl 0x%x OK : %d bytes\n", (int)code,
4885 (int)blob.length);
4886 data_blob_free(&blob);
4887 }
4888 }
4889 }
4890
4891 if (!torture_close_connection(cli)) {
4892 return False;
4893 }
4894
4895 return True;
4896 }
4897
4898
4899 /*
4900 tries varients of chkpath
4901 */
4902 bool torture_chkpath_test(int dummy)
4903 {
4904 static struct cli_state *cli;
4905 uint16_t fnum;
4906 bool ret;
4907
4908 if (!torture_open_connection(&cli, 0)) {
4909 return False;
4910 }
4911
4912 printf("starting chkpath test\n");
4913
4914 /* cleanup from an old run */
4915 cli_rmdir(cli, "\\chkpath.dir\\dir2");
4916 cli_unlink(cli, "\\chkpath.dir\\*", aSYSTEM | aHIDDEN);
4917 cli_rmdir(cli, "\\chkpath.dir");
4918
4919 if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\chkpath.dir"))) {
4920 printf("mkdir1 failed : %s\n", cli_errstr(cli));
4921 return False;
4922 }
4923
4924 if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\chkpath.dir\\dir2"))) {
4925 printf("mkdir2 failed : %s\n", cli_errstr(cli));
4926 return False;
4927 }
4928
4929 if (!NT_STATUS_IS_OK(cli_open(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
4930 printf("open1 failed (%s)\n", cli_errstr(cli));
4931 return False;
4932 }
4933 cli_close(cli, fnum);
4934
4935 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir"))) {
4936 printf("chkpath1 failed: %s\n", cli_errstr(cli));
4937 ret = False;
4938 }
4939
4940 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\dir2"))) {
4941 printf("chkpath2 failed: %s\n", cli_errstr(cli));
4942 ret = False;
4943 }
4944
4945 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\foo.txt"))) {
4946 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
4947 NT_STATUS_NOT_A_DIRECTORY);
4948 } else {
4949 printf("* chkpath on a file should fail\n");
4950 ret = False;
4951 }
4952
4953 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\bar.txt"))) {
4954 ret = check_error(__LINE__, cli, ERRDOS, ERRbadfile,
4955 NT_STATUS_OBJECT_NAME_NOT_FOUND);
4956 } else {
4957 printf("* chkpath on a non existant file should fail\n");
4958 ret = False;
4959 }
4960
4961 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt"))) {
4962 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
4963 NT_STATUS_OBJECT_PATH_NOT_FOUND);
4964 } else {
4965 printf("* chkpath on a non existent component should fail\n");
4966 ret = False;
4967 }
4968
4969 cli_rmdir(cli, "\\chkpath.dir\\dir2");
4970 cli_unlink(cli, "\\chkpath.dir\\*", aSYSTEM | aHIDDEN);
4971 cli_rmdir(cli, "\\chkpath.dir");
4972
4973 if (!torture_close_connection(cli)) {
4974 return False;
4975 }
4976
4977 return ret;
4978 }
4979
4980 static bool run_eatest(int dummy)
4981 {
4982 static struct cli_state *cli;
4983 const char *fname = "\\eatest.txt";
4984 bool correct = True;
4985 uint16_t fnum;
4986 int i;
4987 size_t num_eas;
4988 struct ea_struct *ea_list = NULL;
4989 TALLOC_CTX *mem_ctx = talloc_init("eatest");
4990
4991 printf("starting eatest\n");
4992
4993 if (!torture_open_connection(&cli, 0)) {
4994 talloc_destroy(mem_ctx);
4995 return False;
4996 }
4997
4998 cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
4999 if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0,
5000 FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
5001 FILE_SHARE_NONE, FILE_OVERWRITE_IF,
5002 0x4044, 0, &fnum))) {
5003 printf("open failed - %s\n", cli_errstr(cli));
5004 talloc_destroy(mem_ctx);
5005 return False;
5006 }
5007
5008 for (i = 0; i < 10; i++) {
5009 fstring ea_name, ea_val;
5010
5011 slprintf(ea_name, sizeof(ea_name), "EA_%d", i);
5012 memset(ea_val, (char)i+1, i+1);
5013 if (!cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1)) {
5014 printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
5015 talloc_destroy(mem_ctx);
5016 return False;
5017 }
5018 }
5019
5020 cli_close(cli, fnum);
5021 for (i = 0; i < 10; i++) {
5022 fstring ea_name, ea_val;
5023
5024 slprintf(ea_name, sizeof(ea_name), "EA_%d", i+10);
5025 memset(ea_val, (char)i+1, i+1);
5026 if (!cli_set_ea_path(cli, fname, ea_name, ea_val, i+1)) {
5027 printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
5028 talloc_destroy(mem_ctx);
5029 return False;
5030 }
5031 }
5032
5033 if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list)) {
5034 printf("ea_get list failed - %s\n", cli_errstr(cli));
5035 correct = False;
5036 }
5037
5038 printf("num_eas = %d\n", (int)num_eas);
5039
5040 if (num_eas != 20) {
5041 printf("Should be 20 EA's stored... failing.\n");
5042 correct = False;
5043 }
5044
5045 for (i = 0; i < num_eas; i++) {
5046 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
5047 dump_data(0, ea_list[i].value.data,
5048 ea_list[i].value.length);
5049 }
5050
5051 /* Setting EA's to zero length deletes them. Test this */
5052 printf("Now deleting all EA's - case indepenent....\n");
5053
5054 #if 1
5055 cli_set_ea_path(cli, fname, "", "", 0);
5056 #else
5057 for (i = 0; i < 20; i++) {
5058 fstring ea_name;
5059 slprintf(ea_name, sizeof(ea_name), "ea_%d", i);
5060 if (!cli_set_ea_path(cli, fname, ea_name, "", 0)) {
5061 printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
5062 talloc_destroy(mem_ctx);
5063 return False;
5064 }
5065 }
5066 #endif
5067
5068 if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list)) {
5069 printf("ea_get list failed - %s\n", cli_errstr(cli));
5070 correct = False;
5071 }
5072
5073 printf("num_eas = %d\n", (int)num_eas);
5074 for (i = 0; i < num_eas; i++) {
5075 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
5076 dump_data(0, ea_list[i].value.data,
5077 ea_list[i].value.length);
5078 }
5079
5080 if (num_eas != 0) {
5081 printf("deleting EA's failed.\n");
5082 correct = False;
5083 }
5084
5085 /* Try and delete a non existant EA. */
5086 if (!cli_set_ea_path(cli, fname, "foo", "", 0)) {
5087 printf("deleting non-existant EA 'foo' should succeed. %s\n", cli_errstr(cli));
5088 correct = False;
5089 }
5090
5091 talloc_destroy(mem_ctx);
5092 if (!torture_close_connection(cli)) {
5093 correct = False;
5094 }
5095
5096 return correct;
5097 }
5098
5099 static bool run_dirtest1(int dummy)
5100 {
5101 int i;
5102 static struct cli_state *cli;
5103 uint16_t fnum;
5104 int num_seen;
5105 bool correct = True;
5106
5107 printf("starting directory test\n");
5108
5109 if (!torture_open_connection(&cli, 0)) {
5110 return False;
5111 }
5112
5113 cli_sockopt(cli, sockops);
5114
5115 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
5116 cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
5117 cli_rmdir(cli, "\\LISTDIR");
5118 cli_mkdir(cli, "\\LISTDIR");
5119
5120 /* Create 1000 files and 1000 directories. */
5121 for (i=0;i<1000;i++) {
5122 fstring fname;
5123 slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i);
5124 if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
5125 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum))) {
5126 fprintf(stderr,"Failed to open %s\n", fname);
5127 return False;
5128 }
5129 cli_close(cli, fnum);
5130 }
5131 for (i=0;i<1000;i++) {
5132 fstring fname;
5133 slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i);
5134 if (!NT_STATUS_IS_OK(cli_mkdir(cli, fname))) {
5135 fprintf(stderr,"Failed to open %s\n", fname);
5136 return False;
5137 }
5138 }
5139
5140 /* Now ensure that doing an old list sees both files and directories. */
5141 num_seen = cli_list_old(cli, "\\LISTDIR\\*", aDIR, list_fn, NULL);
5142 printf("num_seen = %d\n", num_seen );
5143 /* We should see 100 files + 1000 directories + . and .. */
5144 if (num_seen != 2002)
5145 correct = False;
5146
5147 /* Ensure if we have the "must have" bits we only see the
5148 * relevent entries.
5149 */
5150 num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aDIR<<8)|aDIR, list_fn, NULL);
5151 printf("num_seen = %d\n", num_seen );
5152 if (num_seen != 1002)
5153 correct = False;
5154
5155 num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aARCH<<8)|aDIR, list_fn, NULL);
5156 printf("num_seen = %d\n", num_seen );
5157 if (num_seen != 1000)
5158 correct = False;
5159
5160 /* Delete everything. */
5161 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
5162 cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
5163 cli_rmdir(cli, "\\LISTDIR");
5164
5165 #if 0
5166 printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
5167 printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
5168 printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
5169 #endif
5170
5171 if (!torture_close_connection(cli)) {
5172 correct = False;
5173 }
5174
5175 printf("finished dirtest1\n");
5176
5177 return correct;
5178 }
5179
5180 static bool run_error_map_extract(int dummy) {
5181
5182 static struct cli_state *c_dos;
5183 static struct cli_state *c_nt;
5184 NTSTATUS status;
5185
5186 uint32 error;
5187
5188 uint32 flgs2, errnum;
5189 uint8 errclass;
5190
5191 NTSTATUS nt_status;
5192
5193 fstring user;
5194
5195 /* NT-Error connection */
5196
5197 if (!(c_nt = open_nbt_connection())) {
5198 return False;
5199 }
5200
5201 c_nt->use_spnego = False;
5202
5203 status = cli_negprot(c_nt);
5204
5205 if (!NT_STATUS_IS_OK(status)) {
5206 printf("%s rejected the NT-error negprot (%s)\n", host,
5207 nt_errstr(status));
5208 cli_shutdown(c_nt);
5209 return False;
5210 }
5211
5212 if (!NT_STATUS_IS_OK(cli_session_setup(c_nt, "", "", 0, "", 0,
5213 workgroup))) {
5214 printf("%s rejected the NT-error initial session setup (%s)\n",host, cli_errstr(c_nt));
5215 return False;
5216 }
5217
5218 /* DOS-Error connection */
5219
5220 if (!(c_dos = open_nbt_connection())) {
5221 return False;
5222 }
5223
5224 c_dos->use_spnego = False;
5225 c_dos->force_dos_errors = True;
5226
5227 status = cli_negprot(c_dos);
5228 if (!NT_STATUS_IS_OK(status)) {
5229 printf("%s rejected the DOS-error negprot (%s)\n", host,
5230 nt_errstr(status));
5231 cli_shutdown(c_dos);
5232 return False;
5233 }
5234
5235 if (!NT_STATUS_IS_OK(cli_session_setup(c_dos, "", "", 0, "", 0,
5236 workgroup))) {
5237 printf("%s rejected the DOS-error initial session setup (%s)\n",host, cli_errstr(c_dos));
5238 return False;
5239 }
5240
5241 for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) {
5242 fstr_sprintf(user, "%X", error);
5243
5244 if (NT_STATUS_IS_OK(cli_session_setup(c_nt, user,
5245 password, strlen(password),
5246 password, strlen(password),
5247 workgroup))) {
5248 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
5249 }
5250
5251 flgs2 = SVAL(c_nt->inbuf,smb_flg2);
5252
5253 /* Case #1: 32-bit NT errors */
5254 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
5255 nt_status = NT_STATUS(IVAL(c_nt->inbuf,smb_rcls));
5256 } else {
5257 printf("/** Dos error on NT connection! (%s) */\n",
5258 cli_errstr(c_nt));
5259 nt_status = NT_STATUS(0xc0000000);
5260 }
5261
5262 if (NT_STATUS_IS_OK(cli_session_setup(c_dos, user,
5263 password, strlen(password),
5264 password, strlen(password),
5265 workgroup))) {
5266 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
5267 }
5268 flgs2 = SVAL(c_dos->inbuf,smb_flg2), errnum;
5269
5270 /* Case #1: 32-bit NT errors */
5271 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
5272 printf("/** NT error on DOS connection! (%s) */\n",
5273 cli_errstr(c_nt));
5274 errnum = errclass = 0;
5275 } else {
5276 cli_dos_error(c_dos, &errclass, &errnum);
5277 }
5278
5279 if (NT_STATUS_V(nt_status) != error) {
5280 printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n",
5281 get_nt_error_c_code(NT_STATUS(error)),
5282 get_nt_error_c_code(nt_status));
5283 }
5284
5285 printf("\t{%s,\t%s,\t%s},\n",
5286 smb_dos_err_class(errclass),
5287 smb_dos_err_name(errclass, errnum),
5288 get_nt_error_c_code(NT_STATUS(error)));
5289 }
5290 return True;
5291 }
5292
5293 static bool run_sesssetup_bench(int dummy)
5294 {
5295 static struct cli_state *c;
5296 const char *fname = "\\file.dat";
5297 uint16_t fnum;
5298 NTSTATUS status;
5299 int i;
5300
5301 if (!torture_open_connection(&c, 0)) {
5302 return false;
5303 }
5304
5305 if (!NT_STATUS_IS_OK(cli_ntcreate(
5306 c, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
5307 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
5308 FILE_DELETE_ON_CLOSE, 0, &fnum))) {
5309 d_printf("open %s failed: %s\n", fname, cli_errstr(c));
5310 return false;
5311 }
5312
5313 for (i=0; i<torture_numops; i++) {
5314 status = cli_session_setup(
5315 c, username,
5316 password, strlen(password),
5317 password, strlen(password),
5318 workgroup);
5319 if (!NT_STATUS_IS_OK(status)) {
5320 d_printf("(%s) cli_session_setup failed: %s\n",
5321 __location__, nt_errstr(status));
5322 return false;
5323 }
5324
5325 d_printf("\r%d ", (int)c->vuid);
5326
5327 if (!cli_ulogoff(c)) {
5328 d_printf("(%s) cli_ulogoff failed: %s\n",
5329 __location__, cli_errstr(c));
5330 return false;
5331 }
5332 c->vuid = 0;
5333 }
5334
5335 return true;
5336 }
5337
5338 static bool subst_test(const char *str, const char *user, const char *domain,
5339 uid_t uid, gid_t gid, const char *expected)
5340 {
5341 char *subst;
5342 bool result = true;
5343
5344 subst = talloc_sub_specified(talloc_tos(), str, user, domain, uid, gid);
5345
5346 if (strcmp(subst, expected) != 0) {
5347 printf("sub_specified(%s, %s, %s, %d, %d) returned [%s], expected "
5348 "[%s]\n", str, user, domain, (int)uid, (int)gid, subst,
5349 expected);
5350 result = false;
5351 }
5352
5353 TALLOC_FREE(subst);
5354 return result;
5355 }
5356
5357 static void chain1_open_completion(struct tevent_req *req)
5358 {
5359 uint16_t fnum;
5360 NTSTATUS status;
5361 status = cli_open_recv(req, &fnum);
5362 TALLOC_FREE(req);
5363
5364 d_printf("cli_open_recv returned %s: %d\n",
5365 nt_errstr(status),
5366 NT_STATUS_IS_OK(status) ? fnum : -1);
5367 }
5368
5369 static void chain1_write_completion(struct tevent_req *req)
5370 {
5371 size_t written;
5372 NTSTATUS status;
5373 status = cli_write_andx_recv(req, &written);
5374 TALLOC_FREE(req);
5375
5376 d_printf("cli_write_andx_recv returned %s: %d\n",
5377 nt_errstr(status),
5378 NT_STATUS_IS_OK(status) ? (int)written : -1);
5379 }
5380
5381 static void chain1_close_completion(struct tevent_req *req)
5382 {
5383 NTSTATUS status;
5384 bool *done = (bool *)tevent_req_callback_data_void(req);
5385
5386 status = cli_close_recv(req);
5387 *done = true;
5388
5389 TALLOC_FREE(req);
5390
5391 d_printf("cli_close returned %s\n", nt_errstr(status));
5392 }
5393
5394 static bool run_chain1(int dummy)
5395 {
5396 struct cli_state *cli1;
5397 struct event_context *evt = event_context_init(NULL);
5398 struct tevent_req *reqs[3], *smbreqs[3];
5399 bool done = false;
5400 const char *str = "foobar";
5401 NTSTATUS status;
5402
5403 printf("starting chain1 test\n");
5404 if (!torture_open_connection(&cli1, 0)) {
5405 return False;
5406 }
5407
5408 cli_sockopt(cli1, sockops);
5409
5410 reqs[0] = cli_open_create(talloc_tos(), evt, cli1, "\\test",
5411 O_CREAT|O_RDWR, 0, &smbreqs[0]);
5412 if (reqs[0] == NULL) return false;
5413 tevent_req_set_callback(reqs[0], chain1_open_completion, NULL);
5414
5415
5416 reqs[1] = cli_write_andx_create(talloc_tos(), evt, cli1, 0, 0,
5417 (uint8_t *)str, 0, strlen(str)+1,
5418 smbreqs, 1, &smbreqs[1]);
5419 if (reqs[1] == NULL) return false;
5420 tevent_req_set_callback(reqs[1], chain1_write_completion, NULL);
5421
5422 reqs[2] = cli_close_create(talloc_tos(), evt, cli1, 0, &smbreqs[2]);
5423 if (reqs[2] == NULL) return false;
5424 tevent_req_set_callback(reqs[2], chain1_close_completion, &done);
5425
5426 status = cli_smb_chain_send(smbreqs, ARRAY_SIZE(smbreqs));
5427 if (!NT_STATUS_IS_OK(status)) {
5428 return false;
5429 }
5430
5431 while (!done) {
5432 event_loop_once(evt);
5433 }
5434
5435 torture_close_connection(cli1);
5436 return True;
5437 }
5438
5439 static void chain2_sesssetup_completion(struct tevent_req *req)
5440 {
5441 NTSTATUS status;
5442 status = cli_session_setup_guest_recv(req);
5443 d_printf("sesssetup returned %s\n", nt_errstr(status));
5444 }
5445
5446 static void chain2_tcon_completion(struct tevent_req *req)
5447 {
5448 bool *done = (bool *)tevent_req_callback_data_void(req);
5449 NTSTATUS status;
5450 status = cli_tcon_andx_recv(req);
5451 d_printf("tcon_and_x returned %s\n", nt_errstr(status));
5452 *done = true;
5453 }
5454
5455 static bool run_chain2(int dummy)
5456 {
5457 struct cli_state *cli1;
5458 struct event_context *evt = event_context_init(NULL);
5459 struct tevent_req *reqs[2], *smbreqs[2];
5460 bool done = false;
5461 NTSTATUS status;
5462
5463 printf("starting chain2 test\n");
5464 status = cli_start_connection(&cli1, global_myname(), host, NULL,
5465 port_to_use, Undefined, 0, NULL);
5466 if (!NT_STATUS_IS_OK(status)) {
5467 return False;
5468 }
5469
5470 cli_sockopt(cli1, sockops);
5471
5472 reqs[0] = cli_session_setup_guest_create(talloc_tos(), evt, cli1,
5473 &smbreqs[0]);
5474 if (reqs[0] == NULL) return false;
5475 tevent_req_set_callback(reqs[0], chain2_sesssetup_completion, NULL);
5476
5477 reqs[1] = cli_tcon_andx_create(talloc_tos(), evt, cli1, "IPC$",
5478 "?????", NULL, 0, &smbreqs[1]);
5479 if (reqs[1] == NULL) return false;
5480 tevent_req_set_callback(reqs[1], chain2_tcon_completion, &done);
5481
5482 status = cli_smb_chain_send(smbreqs, ARRAY_SIZE(smbreqs));
5483 if (!NT_STATUS_IS_OK(status)) {
5484 return false;
5485 }
5486
5487 while (!done) {
5488 event_loop_once(evt);
5489 }
5490
5491 torture_close_connection(cli1);
5492 return True;
5493 }
5494
5495
5496 struct torture_createdel_state {
5497 struct tevent_context *ev;
5498 struct cli_state *cli;
5499 };
5500
5501 static void torture_createdel_created(struct tevent_req *subreq);
5502 static void torture_createdel_closed(struct tevent_req *subreq);
5503
5504 static struct tevent_req *torture_createdel_send(TALLOC_CTX *mem_ctx,
5505 struct tevent_context *ev,
5506 struct cli_state *cli,
5507 const char *name)
5508 {
5509 struct tevent_req *req, *subreq;
5510 struct torture_createdel_state *state;
5511
5512 req = tevent_req_create(mem_ctx, &state,
5513 struct torture_createdel_state);
5514 if (req == NULL) {
5515 return NULL;
5516 }
5517 state->ev = ev;
5518 state->cli = cli;
5519
5520 subreq = cli_ntcreate_send(
5521 state, ev, cli, name, 0,
5522 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
5523 FILE_ATTRIBUTE_NORMAL,
5524 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5525 FILE_OPEN_IF, FILE_DELETE_ON_CLOSE, 0);
5526
5527 if (tevent_req_nomem(subreq, req)) {
5528 return tevent_req_post(req, ev);
5529 }
5530 tevent_req_set_callback(subreq, torture_createdel_created, req);
5531 return req;
5532 }
5533
5534 static void torture_createdel_created(struct tevent_req *subreq)
5535 {
5536 struct tevent_req *req = tevent_req_callback_data(
5537 subreq, struct tevent_req);
5538 struct torture_createdel_state *state = tevent_req_data(
5539 req, struct torture_createdel_state);
5540 NTSTATUS status;
5541 uint16_t fnum;
5542
5543 status = cli_ntcreate_recv(subreq, &fnum);
5544 TALLOC_FREE(subreq);
5545 if (!NT_STATUS_IS_OK(status)) {
5546 DEBUG(10, ("cli_ntcreate_recv returned %s\n",
5547 nt_errstr(status)));
5548 tevent_req_nterror(req, status);
5549 return;
5550 }
5551
5552 subreq = cli_close_send(state, state->ev, state->cli, fnum);
5553 if (tevent_req_nomem(subreq, req)) {
5554 return;
5555 }
5556 tevent_req_set_callback(subreq, torture_createdel_closed, req);
5557 }
5558
5559 static void torture_createdel_closed(struct tevent_req *subreq)
5560 {
5561 struct tevent_req *req = tevent_req_callback_data(
5562 subreq, struct tevent_req);
5563 NTSTATUS status;
5564
5565 status = cli_close_recv(subreq);
5566 if (!NT_STATUS_IS_OK(status)) {
5567 DEBUG(10, ("cli_close_recv returned %s\n", nt_errstr(status)));
5568 tevent_req_nterror(req, status);
5569 return;
5570 }
5571 tevent_req_done(req);
5572 }
5573
5574 static NTSTATUS torture_createdel_recv(struct tevent_req *req)
5575 {
5576 return tevent_req_simple_recv_ntstatus(req);
5577 }
5578
5579 struct torture_createdels_state {
5580 struct tevent_context *ev;
5581 struct cli_state *cli;
5582 const char *base_name;
5583 int sent;
5584 int received;
5585 int num_files;
5586 struct tevent_req **reqs;
5587 };
5588
5589 static void torture_createdels_done(struct tevent_req *subreq);
5590
5591 static struct tevent_req *torture_createdels_send(TALLOC_CTX *mem_ctx,
5592 struct tevent_context *ev,
5593 struct cli_state *cli,
5594 const char *base_name,
5595 int num_parallel,
5596 int num_files)
5597 {
5598 struct tevent_req *req;
5599 struct torture_createdels_state *state;
5600 int i;
5601
5602 req = tevent_req_create(mem_ctx, &state,
5603 struct torture_createdels_state);
5604 if (req == NULL) {
5605 return NULL;
5606 }
5607 state->ev = ev;
5608 state->cli = cli;
5609 state->base_name = talloc_strdup(state, base_name);
5610 if (tevent_req_nomem(state->base_name, req)) {
5611 return tevent_req_post(req, ev);
5612 }
5613 state->num_files = MAX(num_parallel, num_files);
5614 state->sent = 0;
5615 state->received = 0;
5616
5617 state->reqs = talloc_array(state, struct tevent_req *, num_parallel);
5618 if (tevent_req_nomem(state->reqs, req)) {
5619 return tevent_req_post(req, ev);
5620 }
5621
5622 for (i=0; i<num_parallel; i++) {
5623 char *name;
5624
5625 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
5626 state->sent);
5627 if (tevent_req_nomem(name, req)) {
5628 return tevent_req_post(req, ev);
5629 }
5630 state->reqs[i] = torture_createdel_send(
5631 state->reqs, state->ev, state->cli, name);
5632 if (tevent_req_nomem(state->reqs[i], req)) {
5633 return tevent_req_post(req, ev);
5634 }
5635 name = talloc_move(state->reqs[i], &name);
5636 tevent_req_set_callback(state->reqs[i],
5637 torture_createdels_done, req);
5638 state->sent += 1;
5639 }
5640 return req;
5641 }
5642
5643 static void torture_createdels_done(struct tevent_req *subreq)
5644 {
5645 struct tevent_req *req = tevent_req_callback_data(
5646 subreq, struct tevent_req);
5647 struct torture_createdels_state *state = tevent_req_data(
5648 req, struct torture_createdels_state);
5649 size_t num_parallel = talloc_array_length(state->reqs);
5650 NTSTATUS status;
5651 char *name;
5652 int i;
5653
5654 status = torture_createdel_recv(subreq);
5655 if (!NT_STATUS_IS_OK(status)){
5656 DEBUG(10, ("torture_createdel_recv returned %s\n",
5657 nt_errstr(status)));
5658 TALLOC_FREE(subreq);
5659 tevent_req_nterror(req, status);
5660 return;
5661 }
5662
5663 for (i=0; i<num_parallel; i++) {
5664 if (subreq == state->reqs[i]) {
5665 break;
5666 }
5667 }
5668 if (i == num_parallel) {
5669 DEBUG(10, ("received something we did not send\n"));
5670 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
5671 return;
5672 }
5673 TALLOC_FREE(state->reqs[i]);
5674
5675 if (state->sent >= state->num_files) {
5676 tevent_req_done(req);
5677 return;
5678 }
5679
5680 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
5681 state->sent);
5682 if (tevent_req_nomem(name, req)) {
5683 return;
5684 }
5685 state->reqs[i] = torture_createdel_send(state->reqs, state->ev,
5686 state->cli, name);
5687 if (tevent_req_nomem(state->reqs[i], req)) {
5688 return;
5689 }
5690 name = talloc_move(state->reqs[i], &name);
5691 tevent_req_set_callback(state->reqs[i], torture_createdels_done, req);
5692 state->sent += 1;
5693 }
5694
5695 static NTSTATUS torture_createdels_recv(struct tevent_req *req)
5696 {
5697 return tevent_req_simple_recv_ntstatus(req);
5698 }
5699
5700 struct swallow_notify_state {
5701 struct tevent_context *ev;
5702 struct cli_state *cli;
5703 uint16_t fnum;
5704 uint32_t completion_filter;
5705 bool recursive;
5706 bool (*fn)(uint32_t action, const char *name, void *priv);
5707 void *priv;
5708 };
5709
5710 static void swallow_notify_done(struct tevent_req *subreq);
5711
5712 static struct tevent_req *swallow_notify_send(TALLOC_CTX *mem_ctx,
5713 struct tevent_context *ev,
5714 struct cli_state *cli,
5715 uint16_t fnum,
5716 uint32_t completion_filter,
5717 bool recursive,
5718 bool (*fn)(uint32_t action,
5719 const char *name,
5720 void *priv),
5721 void *priv)
5722 {
5723 struct tevent_req *req, *subreq;
5724 struct swallow_notify_state *state;
5725
5726 req = tevent_req_create(mem_ctx, &state,
5727 struct swallow_notify_state);
5728 if (req == NULL) {
5729 return NULL;
5730 }
5731 state->ev = ev;
5732 state->cli = cli;
5733 state->fnum = fnum;
5734 state->completion_filter = completion_filter;
5735 state->recursive = recursive;
5736 state->fn = fn;
5737 state->priv = priv;
5738
5739 subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
5740 0xffff, state->completion_filter,
5741 state->recursive);
5742 if (tevent_req_nomem(subreq, req)) {
5743 return tevent_req_post(req, ev);
5744 }
5745 tevent_req_set_callback(subreq, swallow_notify_done, req);
5746 return req;
5747 }
5748
5749 static void swallow_notify_done(struct tevent_req *subreq)
5750 {
5751 struct tevent_req *req = tevent_req_callback_data(
5752 subreq, struct tevent_req);
5753 struct swallow_notify_state *state = tevent_req_data(
5754 req, struct swallow_notify_state);
5755 NTSTATUS status;
5756 uint32_t i, num_changes;
5757 struct notify_change *changes;
5758
5759 status = cli_notify_recv(subreq, state, &num_changes, &changes);
5760 TALLOC_FREE(subreq);
5761 if (!NT_STATUS_IS_OK(status)) {
5762 DEBUG(10, ("cli_notify_recv returned %s\n",
5763 nt_errstr(status)));
5764 tevent_req_nterror(req, status);
5765 return;
5766 }
5767
5768 for (i=0; i<num_changes; i++) {
5769 state->fn(changes[i].action, changes[i].name, state->priv);
5770 }
5771 TALLOC_FREE(changes);
5772
5773 subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
5774 0xffff, state->completion_filter,
5775 state->recursive);
5776 if (tevent_req_nomem(subreq, req)) {
5777 return;
5778 }
5779 tevent_req_set_callback(subreq, swallow_notify_done, req);
5780 }
5781
5782 static bool print_notifies(uint32_t action, const char *name, void *priv)
5783 {
5784 if (DEBUGLEVEL > 5) {
5785 d_printf("%d %s\n", (int)action, name);
5786 }
5787 return true;
5788 }
5789
5790 static void notify_bench_done(struct tevent_req *req)
5791 {
5792 int *num_finished = (int *)tevent_req_callback_data_void(req);
5793 *num_finished += 1;
5794 }
5795
5796 static bool run_notify_bench(int dummy)
5797 {
5798 const char *dname = "\\notify-bench";
5799 struct tevent_context *ev;
5800 NTSTATUS status;
5801 uint16_t dnum;
5802 struct tevent_req *req1, *req2;
5803 int i, num_unc_names;
5804 int num_finished = 0;
5805
5806 printf("starting notify-bench test\n");
5807
5808 if (use_multishare_conn) {
5809 char **unc_list;
5810 unc_list = file_lines_load(multishare_conn_fname,
5811 &num_unc_names, 0, NULL);
5812 if (!unc_list || num_unc_names <= 0) {
5813 d_printf("Failed to load unc names list from '%s'\n",
5814 multishare_conn_fname);
5815 return false;
5816 }
5817 TALLOC_FREE(unc_list);
5818 } else {
5819 num_unc_names = 1;
5820 }
5821
5822 ev = tevent_context_init(talloc_tos());
5823 if (ev == NULL) {
5824 d_printf("tevent_context_init failed\n");
5825 return false;
5826 }
5827
5828 for (i=0; i<num_unc_names; i++) {
5829 struct cli_state *cli;
5830 char *base_fname;
5831
5832 base_fname = talloc_asprintf(talloc_tos(), "%s\\file%3.3d.",
5833 dname, i);
5834 if (base_fname == NULL) {
5835 return false;
5836 }
5837
5838 if (!torture_open_connection(&cli, i)) {
5839 return false;
5840 }
5841
5842 status = cli_ntcreate(cli, dname, 0,
5843 MAXIMUM_ALLOWED_ACCESS,
5844 0, FILE_SHARE_READ|FILE_SHARE_WRITE|
5845 FILE_SHARE_DELETE,
5846 FILE_OPEN_IF, FILE_DIRECTORY_FILE, 0,
5847 &dnum);
5848
5849 if (!NT_STATUS_IS_OK(status)) {
5850 d_printf("Could not create %s: %s\n", dname,
5851 nt_errstr(status));
5852 return false;
5853 }
5854
5855 req1 = swallow_notify_send(talloc_tos(), ev, cli, dnum,
5856 FILE_NOTIFY_CHANGE_FILE_NAME |
5857 FILE_NOTIFY_CHANGE_DIR_NAME |
5858 FILE_NOTIFY_CHANGE_ATTRIBUTES |
5859 FILE_NOTIFY_CHANGE_LAST_WRITE,
5860 false, print_notifies, NULL);
5861 if (req1 == NULL) {
5862 d_printf("Could not create notify request\n");
5863 return false;
5864 }
5865
5866 req2 = torture_createdels_send(talloc_tos(), ev, cli,
5867 base_fname, 10, torture_numops);
5868 if (req2 == NULL) {
5869 d_printf("Could not create createdels request\n");
5870 return false;
5871 }
5872 TALLOC_FREE(base_fname);
5873
5874 tevent_req_set_callback(req2, notify_bench_done,
5875 &num_finished);
5876 }
5877
5878 while (num_finished < num_unc_names) {
5879 int ret;
5880 ret = tevent_loop_once(ev);
5881 if (ret != 0) {
5882 d_printf("tevent_loop_once failed\n");
5883 return false;
5884 }
5885 }
5886
5887 if (!tevent_req_poll(req2, ev)) {
5888 d_printf("tevent_req_poll failed\n");
5889 }
5890
5891 status = torture_createdels_recv(req2);
5892 d_printf("torture_createdels_recv returned %s\n", nt_errstr(status));
5893
5894 return true;
5895 }
5896
5897 static bool run_mangle1(int dummy)
5898 {
5899 struct cli_state *cli;
5900 const char *fname = "this_is_a_long_fname_to_be_mangled.txt";
5901 uint16_t fnum;
5902 fstring alt_name;
5903 NTSTATUS status;
5904 time_t change_time, access_time, write_time;
5905 SMB_OFF_T size;
5906 uint16_t mode;
5907
5908 printf("starting mangle1 test\n");
5909 if (!torture_open_connection(&cli, 0)) {
5910 return False;
5911 }
5912
5913 cli_sockopt(cli, sockops);
5914
5915 if (!NT_STATUS_IS_OK(cli_ntcreate(
5916 cli, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
5917 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0, &fnum))) {
5918 d_printf("open %s failed: %s\n", fname, cli_errstr(cli));
5919 return false;
5920 }
5921 cli_close(cli, fnum);
5922
5923 status = cli_qpathinfo_alt_name(cli, fname, alt_name);
5924 if (!NT_STATUS_IS_OK(status)) {
5925 d_printf("cli_qpathinfo_alt_name failed: %s\n",
5926 nt_errstr(status));
5927 return false;
5928 }
5929 d_printf("alt_name: %s\n", alt_name);
5930
5931 if (!NT_STATUS_IS_OK(cli_open(cli, alt_name, O_RDONLY, DENY_NONE, &fnum))) {
5932 d_printf("cli_open(%s) failed: %s\n", alt_name,
5933 cli_errstr(cli));
5934 return false;
5935 }
5936 cli_close(cli, fnum);
5937
5938 if (!cli_qpathinfo(cli, alt_name, &change_time, &access_time,
5939 &write_time, &size, &mode)) {
5940 d_printf("cli_qpathinfo(%s) failed: %s\n", alt_name,
5941 cli_errstr(cli));
5942 return false;
5943 }
5944
5945 return true;
5946 }
5947
5948 static size_t null_source(uint8_t *buf, size_t n, void *priv)
5949 {
5950 size_t *to_pull = (size_t *)priv;
5951 size_t thistime = *to_pull;
5952
5953 thistime = MIN(thistime, n);
5954 if (thistime == 0) {
5955 return 0;
5956 }
5957
5958 memset(buf, 0, thistime);
5959 *to_pull -= thistime;
5960 return thistime;
5961 }
5962
5963 static bool run_windows_write(int dummy)
5964 {
5965 struct cli_state *cli1;
5966 uint16_t fnum;
5967 int i;
5968 bool ret = false;
5969 const char *fname = "\\writetest.txt";
5970 double seconds;
5971 double kbytes;
5972
5973 printf("starting windows_write test\n");
5974 if (!torture_open_connection(&cli1, 0)) {
5975 return False;
5976 }
5977
5978 if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
5979 printf("open failed (%s)\n", cli_errstr(cli1));
5980 return False;
5981 }
5982
5983 cli_sockopt(cli1, sockops);
5984
5985 start_timer();
5986
5987 for (i=0; i<torture_numops; i++) {
5988 char c = 0;
5989 off_t start = i * torture_blocksize;
5990 NTSTATUS status;
5991 size_t to_pull = torture_blocksize - 1;
5992
5993 if (cli_write(cli1, fnum, 0, &c,
5994 start + torture_blocksize - 1, 1) != 1) {
5995 printf("cli_write failed: %s\n", cli_errstr(cli1));
5996 goto fail;
5997 }
5998
5999 status = cli_push(cli1, fnum, 0, i * torture_blocksize, torture_blocksize,
6000 null_source, &to_pull);
6001 if (!NT_STATUS_IS_OK(status)) {
6002 printf("cli_push returned: %s\n", nt_errstr(status));
6003 goto fail;
6004 }
6005 }
6006
6007 seconds = end_timer();
6008 kbytes = (double)torture_blocksize * torture_numops;
6009 kbytes /= 1024;
6010
6011 printf("Wrote %d kbytes in %.2f seconds: %d kb/sec\n", (int)kbytes,
6012 (double)seconds, (int)(kbytes/seconds));
6013
6014 ret = true;
6015 fail:
6016 cli_close(cli1, fnum);
6017 cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
6018 torture_close_connection(cli1);
6019 return ret;
6020 }
6021
6022 static bool run_cli_echo(int dummy)
6023 {
6024 struct cli_state *cli;
6025 NTSTATUS status;
6026
6027 printf("starting cli_echo test\n");
6028 if (!torture_open_connection(&cli, 0)) {
6029 return false;
6030 }
6031 cli_sockopt(cli, sockops);
6032
6033 status = cli_echo(cli, 5, data_blob_const("hello", 5));
6034
6035 d_printf("cli_echo returned %s\n", nt_errstr(status));
6036
6037 torture_close_connection(cli);
6038 return NT_STATUS_IS_OK(status);
6039 }
6040
6041 static bool run_uid_regression_test(int dummy)
6042 {
6043 static struct cli_state *cli;
6044 int16_t old_vuid;
6045 int16_t old_cnum;
6046 bool correct = True;
6047
6048 printf("starting uid regression test\n");
6049
6050 if (!torture_open_connection(&cli, 0)) {
6051 return False;
6052 }
6053
6054 cli_sockopt(cli, sockops);
6055
6056 /* Ok - now save then logoff our current user. */
6057 old_vuid = cli->vuid;
6058
6059 if (!cli_ulogoff(cli)) {
6060 d_printf("(%s) cli_ulogoff failed: %s\n",
6061 __location__, cli_errstr(cli));
6062 correct = false;
6063 goto out;
6064 }
6065
6066 cli->vuid = old_vuid;
6067
6068 /* Try an operation. */
6069 if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\uid_reg_test"))) {
6070 /* We expect bad uid. */
6071 if (!check_error(__LINE__, cli, ERRSRV, ERRbaduid,
6072 NT_STATUS_NO_SUCH_USER)) {
6073 return False;
6074 }
6075 }
6076
6077 old_cnum = cli->cnum;
6078
6079 /* Now try a SMBtdis with the invald vuid set to zero. */
6080 cli->vuid = 0;
6081
6082 /* This should succeed. */
6083 if (cli_tdis(cli)) {
6084 printf("First tdis with invalid vuid should succeed.\n");
6085 } else {
6086 printf("First tdis failed (%s)\n", cli_errstr(cli));
6087 }
6088
6089 cli->vuid = old_vuid;
6090 cli->cnum = old_cnum;
6091
6092 /* This should fail. */
6093 if (cli_tdis(cli)) {
6094 printf("Second tdis with invalid vuid should fail - succeeded instead !.\n");
6095 } else {
6096 /* Should be bad tid. */
6097 if (!check_error(__LINE__, cli, ERRSRV, ERRinvnid,
6098 NT_STATUS_NETWORK_NAME_DELETED)) {
6099 return False;
6100 }
6101 }
6102
6103 cli_rmdir(cli, "\\uid_reg_test");
6104
6105 out:
6106
6107 cli_shutdown(cli);
6108 return correct;
6109 }
6110
6111
6112 static const char *illegal_chars = "*\\/?<>|\":";
6113 static char force_shortname_chars[] = " +,.[];=\177";
6114
6115 static void shortname_del_fn(const char *mnt, file_info *finfo, const char *mask, void *state)
6116 {
6117 struct cli_state *pcli = (struct cli_state *)state;
6118 fstring fname;
6119 slprintf(fname, sizeof(fname), "\\shortname\\%s", finfo->name);
6120
6121 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
6122 return;
6123
6124 if (finfo->mode & aDIR) {
6125 if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname)))
6126 printf("del_fn: failed to rmdir %s\n,", fname );
6127 } else {
6128 if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, aSYSTEM | aHIDDEN)))
6129 printf("del_fn: failed to unlink %s\n,", fname );
6130 }
6131 }
6132
6133 struct sn_state {
6134 int i;
6135 bool val;
6136 };
6137
6138 static void shortname_list_fn(const char *mnt, file_info *finfo, const char *name, void *state)
6139 {
6140 struct sn_state *s = (struct sn_state *)state;
6141 int i = s->i;
6142
6143 #if 0
6144 printf("shortname list: i = %d, name = |%s|, shortname = |%s|\n",
6145 i, finfo->name, finfo->short_name);
6146 #endif
6147
6148 if (strchr(force_shortname_chars, i)) {
6149 if (!finfo->short_name[0]) {
6150 /* Shortname not created when it should be. */
6151 d_printf("(%s) ERROR: Shortname was not created for file %s containing %d\n",
6152 __location__, finfo->name, i);
6153 s->val = true;
6154 }
6155 } else if (finfo->short_name[0]){
6156 /* Shortname created when it should not be. */
6157 d_printf("(%s) ERROR: Shortname %s was created for file %s\n",
6158 __location__, finfo->short_name, finfo->name);
6159 s->val = true;
6160 }
6161 }
6162
6163 static bool run_shortname_test(int dummy)
6164 {
6165 static struct cli_state *cli;
6166 bool correct = True;
6167 int i;
6168 struct sn_state s;
6169 char fname[20];
6170
6171 printf("starting shortname test\n");
6172
6173 if (!torture_open_connection(&cli, 0)) {
6174 return False;
6175 }
6176
6177 cli_sockopt(cli, sockops);
6178
6179 cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
6180 cli_list(cli, "\\shortname\\*", aDIR, shortname_del_fn, cli);
6181 cli_rmdir(cli, "\\shortname");
6182
6183 if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\shortname"))) {
6184 d_printf("(%s) cli_mkdir of \\shortname failed: %s\n",
6185 __location__, cli_errstr(cli));
6186 correct = false;
6187 goto out;
6188 }
6189
6190 strlcpy(fname, "\\shortname\\", sizeof(fname));
6191 strlcat(fname, "test .txt", sizeof(fname));
6192
6193 s.val = false;
6194
6195 for (i = 32; i < 128; i++) {
6196 NTSTATUS status;
6197 uint16_t fnum = (uint16_t)-1;
6198
6199 s.i = i;
6200
6201 if (strchr(illegal_chars, i)) {
6202 continue;
6203 }
6204 fname[15] = i;
6205
6206 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
6207 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum);
6208 if (!NT_STATUS_IS_OK(status)) {
6209 d_printf("(%s) cli_nt_create of %s failed: %s\n",
6210 __location__, fname, cli_errstr(cli));
6211 correct = false;
6212 goto out;
6213 }
6214 cli_close(cli, fnum);
6215 if (cli_list(cli, "\\shortname\\test*.*", 0, shortname_list_fn, &s) != 1) {
6216 d_printf("(%s) failed to list %s: %s\n",
6217 __location__, fname, cli_errstr(cli));
6218 correct = false;
6219 goto out;
6220 }
6221 if (!NT_STATUS_IS_OK(cli_unlink(cli, fname, aSYSTEM | aHIDDEN))) {
6222 d_printf("(%s) failed to delete %s: %s\n",
6223 __location__, fname, cli_errstr(cli));
6224 correct = false;
6225 goto out;
6226 }
6227
6228 if (s.val) {
6229 correct = false;
6230 goto out;
6231 }
6232 }
6233
6234 out:
6235
6236 cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
6237 cli_list(cli, "\\shortname\\*", aDIR, shortname_del_fn, cli);
6238 cli_rmdir(cli, "\\shortname");
6239 torture_close_connection(cli);
6240 return correct;
6241 }
6242
6243 static void pagedsearch_cb(struct tevent_req *req)
6244 {
6245 int rc;
6246 struct tldap_message *msg;
6247 char *dn;
6248
6249 rc = tldap_search_paged_recv(req, talloc_tos(), &msg);
6250 if (rc != TLDAP_SUCCESS) {
6251 d_printf("tldap_search_paged_recv failed: %s\n",
6252 tldap_err2string(rc));
6253 return;
6254 }
6255 if (tldap_msg_type(msg) != TLDAP_RES_SEARCH_ENTRY) {
6256 TALLOC_FREE(msg);
6257 return;
6258 }
6259 if (!tldap_entry_dn(msg, &dn)) {
6260 d_printf("tldap_entry_dn failed\n");
6261 return;
6262 }
6263 d_printf("%s\n", dn);
6264 TALLOC_FREE(msg);
6265 }
6266
6267 static bool run_tldap(int dummy)
6268 {
6269 struct tldap_context *ld;
6270 int fd, rc;
6271 NTSTATUS status;
6272 struct sockaddr_storage addr;
6273 struct tevent_context *ev;
6274 struct tevent_req *req;
6275 char *basedn;
6276
6277 if (!resolve_name(host, &addr, 0, false)) {
6278 d_printf("could not find host %s\n", host);
6279 return false;
6280 }
6281 status = open_socket_out(&addr, 389, 9999, &fd);
6282 if (!NT_STATUS_IS_OK(status)) {
6283 d_printf("open_socket_out failed: %s\n", nt_errstr(status));
6284 return false;
6285 }
6286
6287 ld = tldap_context_create(talloc_tos(), fd);
6288 if (ld == NULL) {
6289 close(fd);
6290 d_printf("tldap_context_create failed\n");
6291 return false;
6292 }
6293
6294 rc = tldap_fetch_rootdse(ld);
6295 if (rc != TLDAP_SUCCESS) {
6296 d_printf("tldap_fetch_rootdse failed: %s\n",
6297 tldap_errstr(talloc_tos(), ld, rc));
6298 return false;
6299 }
6300
6301 basedn = tldap_talloc_single_attribute(
6302 tldap_rootdse(ld), "defaultNamingContext", talloc_tos());
6303 if (basedn == NULL) {
6304 d_printf("no defaultNamingContext\n");
6305 return false;
6306 }
6307 d_printf("defaultNamingContext: %s\n", basedn);
6308
6309 ev = tevent_context_init(talloc_tos());
6310 if (ev == NULL) {
6311 d_printf("tevent_context_init failed\n");
6312 return false;
6313 }
6314
6315 req = tldap_search_paged_send(talloc_tos(), ev, ld, basedn,
6316 TLDAP_SCOPE_SUB, "(objectclass=*)",
6317 NULL, 0, 0,
6318 NULL, 0, NULL, 0, 0, 0, 0, 5);
6319 if (req == NULL) {
6320 d_printf("tldap_search_paged_send failed\n");
6321 return false;
6322 }
6323 tevent_req_set_callback(req, pagedsearch_cb, NULL);
6324
6325 tevent_req_poll(req, ev);
6326
6327 TALLOC_FREE(req);
6328
6329 TALLOC_FREE(ld);
6330 return true;
6331 }
6332
6333 static bool run_streamerror(int dummy)
6334 {
6335 struct cli_state *cli;
6336 const char *dname = "\\testdir";
6337 const char *streamname =
6338 "testdir:{4c8cc155-6c1e-11d1-8e41-00c04fb9386d}:$DATA";
6339 NTSTATUS status;
6340 time_t change_time, access_time, write_time;
6341 SMB_OFF_T size;
6342 uint16_t mode, fnum;
6343 bool ret = true;
6344
6345 if (!torture_open_connection(&cli, 0)) {
6346 return false;
6347 }
6348
6349 cli_rmdir(cli, dname);
6350
6351 status = cli_mkdir(cli, dname);
6352 if (!NT_STATUS_IS_OK(status)) {
6353 printf("mkdir failed: %s\n", nt_errstr(status));
6354 return false;
6355 }
6356
6357 cli_qpathinfo(cli, streamname, &change_time, &access_time, &write_time,
6358 &size, &mode);
6359 status = cli_nt_error(cli);
6360
6361 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
6362 printf("pathinfo returned %s, expected "
6363 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
6364 nt_errstr(status));
6365 ret = false;
6366 }
6367
6368 status = cli_ntcreate(cli, streamname, 0x16,
6369 FILE_READ_DATA|FILE_READ_EA|
6370 FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS,
6371 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
6372 FILE_OPEN, 0, 0, &fnum);
6373
6374 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
6375 printf("ntcreate returned %s, expected "
6376 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
6377 nt_errstr(status));
6378 ret = false;
6379 }
6380
6381
6382 cli_rmdir(cli, dname);
6383 return ret;
6384 }
6385
6386 static bool run_local_substitute(int dummy)
6387 {
6388 bool ok = true;
6389
6390 ok &= subst_test("%U", "bla", "", -1, -1, "bla");
6391 ok &= subst_test("%u%U", "bla", "", -1, -1, "blabla");
6392 ok &= subst_test("%g", "", "", -1, -1, "NO_GROUP");
6393 ok &= subst_test("%G", "", "", -1, -1, "NO_GROUP");
6394 ok &= subst_test("%g", "", "", -1, 0, gidtoname(0));
6395 ok &= subst_test("%G", "", "", -1, 0, gidtoname(0));
6396 ok &= subst_test("%D%u", "u", "dom", -1, 0, "domu");
6397 ok &= subst_test("%i %I", "", "", -1, -1, "0.0.0.0 0.0.0.0");
6398
6399 /* Different captialization rules in sub_basic... */
6400
6401 ok &= (strcmp(talloc_sub_basic(talloc_tos(), "BLA", "dom", "%U%D"),
6402 "blaDOM") == 0);
6403
6404 return ok;
6405 }
6406
6407 static bool run_local_base64(int dummy)
6408 {
6409 int i;
6410 bool ret = true;
6411
6412 for (i=1; i<2000; i++) {
6413 DATA_BLOB blob1, blob2;
6414 char *b64;
6415
6416 blob1.data = talloc_array(talloc_tos(), uint8_t, i);
6417 blob1.length = i;
6418 generate_random_buffer(blob1.data, blob1.length);
6419
6420 b64 = base64_encode_data_blob(talloc_tos(), blob1);
6421 if (b64 == NULL) {
6422 d_fprintf(stderr, "base64_encode_data_blob failed "
6423 "for %d bytes\n", i);
6424 ret = false;
6425 }
6426 blob2 = base64_decode_data_blob(b64);
6427 TALLOC_FREE(b64);
6428
6429 if (data_blob_cmp(&blob1, &blob2)) {
6430 d_fprintf(stderr, "data_blob_cmp failed for %d "
6431 "bytes\n", i);
6432 ret = false;
6433 }
6434 TALLOC_FREE(blob1.data);
6435 data_blob_free(&blob2);
6436 }
6437 return ret;
6438 }
6439
6440 static bool run_local_gencache(int dummy)
6441 {
6442 char *val;
6443 time_t tm;
6444 DATA_BLOB blob;
6445
6446 if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
6447 d_printf("%s: gencache_set() failed\n", __location__);
6448 return False;
6449 }
6450
6451 if (!gencache_get("foo", NULL, NULL)) {
6452 d_printf("%s: gencache_get() failed\n", __location__);
6453 return False;
6454 }
6455
6456 if (!gencache_get("foo", &val, &tm)) {
6457 d_printf("%s: gencache_get() failed\n", __location__);
6458 return False;
6459 }
6460
6461 if (strcmp(val, "bar") != 0) {
6462 d_printf("%s: gencache_get() returned %s, expected %s\n",
6463 __location__, val, "bar");
6464 SAFE_FREE(val);
6465 return False;
6466 }
6467
6468 SAFE_FREE(val);
6469
6470 if (!gencache_del("foo")) {
6471 d_printf("%s: gencache_del() failed\n", __location__);
6472 return False;
6473 }
6474 if (gencache_del("foo")) {
6475 d_printf("%s: second gencache_del() succeeded\n",
6476 __location__);
6477 return False;
6478 }
6479
6480 if (gencache_get("foo", &val, &tm)) {
6481 d_printf("%s: gencache_get() on deleted entry "
6482 "succeeded\n", __location__);
6483 return False;
6484 }
6485
6486 blob = data_blob_string_const_null("bar");
6487 tm = time(NULL) + 60;
6488
6489 if (!gencache_set_data_blob("foo", &blob, tm)) {
6490 d_printf("%s: gencache_set_data_blob() failed\n", __location__);
6491 return False;
6492 }
6493
6494 if (!gencache_get_data_blob("foo", &blob, NULL, NULL)) {
6495 d_printf("%s: gencache_get_data_blob() failed\n", __location__);
6496 return False;
6497 }
6498
6499 if (strcmp((const char *)blob.data, "bar") != 0) {
6500 d_printf("%s: gencache_get_data_blob() returned %s, expected %s\n",
6501 __location__, (const char *)blob.data, "bar");
6502 data_blob_free(&blob);
6503 return False;
6504 }
6505
6506 data_blob_free(&blob);
6507
6508 if (!gencache_del("foo")) {
6509 d_printf("%s: gencache_del() failed\n", __location__);
6510 return False;
6511 }
6512 if (gencache_del("foo")) {
6513 d_printf("%s: second gencache_del() succeeded\n",
6514 __location__);
6515 return False;
6516 }
6517
6518 if (gencache_get_data_blob("foo", &blob, NULL, NULL)) {
6519 d_printf("%s: gencache_get_data_blob() on deleted entry "
6520 "succeeded\n", __location__);
6521 return False;
6522 }
6523
6524 return True;
6525 }
6526
6527 static bool rbt_testval(struct db_context *db, const char *key,
6528 const char *value)
6529 {
6530 struct db_record *rec;
6531 TDB_DATA data = string_tdb_data(value);
6532 bool ret = false;
6533 NTSTATUS status;
6534
6535 rec = db->fetch_locked(db, db, string_tdb_data(key));
6536 if (rec == NULL) {
6537 d_fprintf(stderr, "fetch_locked failed\n");
6538 goto done;
6539 }
6540 status = rec->store(rec, data, 0);
6541 if (!NT_STATUS_IS_OK(status)) {
6542 d_fprintf(stderr, "store failed: %s\n", nt_errstr(status));
6543 goto done;
6544 }
6545 TALLOC_FREE(rec);
6546
6547 rec = db->fetch_locked(db, db, string_tdb_data(key));
6548 if (rec == NULL) {
6549 d_fprintf(stderr, "second fetch_locked failed\n");
6550 goto done;
6551 }
6552 if ((rec->value.dsize != data.dsize)
6553 || (memcmp(rec->value.dptr, data.dptr, data.dsize) != 0)) {
6554 d_fprintf(stderr, "Got wrong data back\n");
6555 goto done;
6556 }
6557
6558 ret = true;
6559 done:
6560 TALLOC_FREE(rec);
6561 return ret;
6562 }
6563
6564 static bool run_local_rbtree(int dummy)
6565 {
6566 struct db_context *db;
6567 bool ret = false;
6568 int i;
6569
6570 db = db_open_rbt(NULL);
6571
6572 if (db == NULL) {
6573 d_fprintf(stderr, "db_open_rbt failed\n");
6574 return false;
6575 }
6576
6577 for (i=0; i<1000; i++) {
6578 char *key, *value;
6579
6580 if (asprintf(&key, "key%ld", random()) == -1) {
6581 goto done;
6582 }
6583 if (asprintf(&value, "value%ld", random()) == -1) {
6584 SAFE_FREE(key);
6585 goto done;
6586 }
6587
6588 if (!rbt_testval(db, key, value)) {
6589 SAFE_FREE(key);
6590 SAFE_FREE(value);
6591 goto done;
6592 }
6593
6594 SAFE_FREE(value);
6595 if (asprintf(&value, "value%ld", random()) == -1) {
6596 SAFE_FREE(key);
6597 goto done;
6598 }
6599
6600 if (!rbt_testval(db, key, value)) {
6601 SAFE_FREE(key);
6602 SAFE_FREE(value);
6603 goto done;
6604 }
6605
6606 SAFE_FREE(key);
6607 SAFE_FREE(value);
6608 }
6609
6610 ret = true;
6611
6612 done:
6613 TALLOC_FREE(db);
6614 return ret;
6615 }
6616
6617 struct talloc_dict_test {
6618 int content;
6619 };
6620
6621 static int talloc_dict_traverse_fn(DATA_BLOB key, void *data, void *priv)
6622 {
6623 int *count = (int *)priv;
6624 *count += 1;
6625 return 0;
6626 }
6627
6628 static bool run_local_talloc_dict(int dummy)
6629 {
6630 struct talloc_dict *dict;
6631 struct talloc_dict_test *t;
6632 int key, count;
6633
6634 dict = talloc_dict_init(talloc_tos());
6635 if (dict == NULL) {
6636 return false;
6637 }
6638
6639 t = talloc(talloc_tos(), struct talloc_dict_test);
6640 if (t == NULL) {
6641 return false;
6642 }
6643
6644 key = 1;
6645 t->content = 1;
6646 if (!talloc_dict_set(dict, data_blob_const(&key, sizeof(key)), t)) {
6647 return false;
6648 }
6649
6650 count = 0;
6651 if (talloc_dict_traverse(dict, talloc_dict_traverse_fn, &count) != 0) {
6652 return false;
6653 }
6654
6655 if (count != 1) {
6656 return false;
6657 }
6658
6659 TALLOC_FREE(dict);
6660
6661 return true;
6662 }
6663
6664 /* Split a path name into filename and stream name components. Canonicalise
6665 * such that an implicit $DATA token is always explicit.
6666 *
6667 * The "specification" of this function can be found in the
6668 * run_local_stream_name() function in torture.c, I've tried those
6669 * combinations against a W2k3 server.
6670 */
6671
6672 static NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
6673 char **pbase, char **pstream)
6674 {
6675 char *base = NULL;
6676 char *stream = NULL;
6677 char *sname; /* stream name */
6678 const char *stype; /* stream type */
6679
6680 DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
6681
6682 sname = strchr_m(fname, ':');
6683
6684 if (lp_posix_pathnames() || (sname == NULL)) {
6685 if (pbase != NULL) {
6686 base = talloc_strdup(mem_ctx, fname);
6687 NT_STATUS_HAVE_NO_MEMORY(base);
6688 }
6689 goto done;
6690 }
6691
6692 if (pbase != NULL) {
6693 base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
6694 NT_STATUS_HAVE_NO_MEMORY(base);
6695 }
6696
6697 sname += 1;
6698
6699 stype = strchr_m(sname, ':');
6700
6701 if (stype == NULL) {
6702 sname = talloc_strdup(mem_ctx, sname);
6703 stype = "$DATA";
6704 }
6705 else {
6706 if (StrCaseCmp(stype, ":$DATA") != 0) {
6707 /*
6708 * If there is an explicit stream type, so far we only
6709 * allow $DATA. Is there anything else allowed? -- vl
6710 */
6711 DEBUG(10, ("[%s] is an invalid stream type\n", stype));
6712 TALLOC_FREE(base);
6713 return NT_STATUS_OBJECT_NAME_INVALID;
6714 }
6715 sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
6716 stype += 1;
6717 }
6718
6719 if (sname == NULL) {
6720 TALLOC_FREE(base);
6721 return NT_STATUS_NO_MEMORY;
6722 }
6723
6724 if (sname[0] == '\0') {
6725 /*
6726 * no stream name, so no stream
6727 */
6728 goto done;
6729 }
6730
6731 if (pstream != NULL) {
6732 stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
6733 if (stream == NULL) {
6734 TALLOC_FREE(sname);
6735 TALLOC_FREE(base);
6736 return NT_STATUS_NO_MEMORY;
6737 }
6738 /*
6739 * upper-case the type field
6740 */
6741 strupper_m(strchr_m(stream, ':')+1);
6742 }
6743
6744 done:
6745 if (pbase != NULL) {
6746 *pbase = base;
6747 }
6748 if (pstream != NULL) {
6749 *pstream = stream;
6750 }
6751 return NT_STATUS_OK;
6752 }
6753
6754 static bool test_stream_name(const char *fname, const char *expected_base,
6755 const char *expected_stream,
6756 NTSTATUS expected_status)
6757 {
6758 NTSTATUS status;
6759 char *base = NULL;
6760 char *stream = NULL;
6761
6762 status = split_ntfs_stream_name(talloc_tos(), fname, &base, &stream);
6763 if (!NT_STATUS_EQUAL(status, expected_status)) {
6764 goto error;
6765 }
6766
6767 if (!NT_STATUS_IS_OK(status)) {
6768 return true;
6769 }
6770
6771 if (base == NULL) goto error;
6772
6773 if (strcmp(expected_base, base) != 0) goto error;
6774
6775 if ((expected_stream != NULL) && (stream == NULL)) goto error;
6776 if ((expected_stream == NULL) && (stream != NULL)) goto error;
6777
6778 if ((stream != NULL) && (strcmp(expected_stream, stream) != 0))
6779 goto error;
6780
6781 TALLOC_FREE(base);
6782 TALLOC_FREE(stream);
6783 return true;
6784
6785 error:
6786 d_fprintf(stderr, "test_stream(%s, %s, %s, %s)\n",
6787 fname, expected_base ? expected_base : "<NULL>",
6788 expected_stream ? expected_stream : "<NULL>",
6789 nt_errstr(expected_status));
6790 d_fprintf(stderr, "-> base=%s, stream=%s, status=%s\n",
6791 base ? base : "<NULL>", stream ? stream : "<NULL>",
6792 nt_errstr(status));
6793 TALLOC_FREE(base);
6794 TALLOC_FREE(stream);
6795 return false;
6796 }
6797
6798 static bool run_local_stream_name(int dummy)
6799 {
6800 bool ret = true;
6801
6802 ret &= test_stream_name(
6803 "bla", "bla", NULL, NT_STATUS_OK);
6804 ret &= test_stream_name(
6805 "bla::$DATA", "bla", NULL, NT_STATUS_OK);
6806 ret &= test_stream_name(
6807 "bla:blub:", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
6808 ret &= test_stream_name(
6809 "bla::", NULL, NULL, NT_STATUS_OBJECT_NAME_INVALID);
6810 ret &= test_stream_name(
6811 "bla::123", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
6812 ret &= test_stream_name(
6813 "bla:$DATA", "bla", "$DATA:$DATA", NT_STATUS_OK);
6814 ret &= test_stream_name(
6815 "bla:x:$DATA", "bla", "x:$DATA", NT_STATUS_OK);
6816 ret &= test_stream_name(
6817 "bla:x", "bla", "x:$DATA", NT_STATUS_OK);
6818
6819 return ret;
6820 }
6821
6822 static bool data_blob_equal(DATA_BLOB a, DATA_BLOB b)
6823 {
6824 if (a.length != b.length) {
6825 printf("a.length=%d != b.length=%d\n",
6826 (int)a.length, (int)b.length);
6827 return false;
6828 }
6829 if (memcmp(a.data, b.data, a.length) != 0) {
6830 printf("a.data and b.data differ\n");
6831 return false;
6832 }
6833 return true;
6834 }
6835
6836 static bool run_local_memcache(int dummy)
6837 {
6838 struct memcache *cache;
6839 DATA_BLOB k1, k2;
6840 DATA_BLOB d1, d2, d3;
6841 DATA_BLOB v1, v2, v3;
6842
6843 TALLOC_CTX *mem_ctx;
6844 char *str1, *str2;
6845 size_t size1, size2;
6846 bool ret = false;
6847
6848 cache = memcache_init(NULL, 100);
6849
6850 if (cache == NULL) {
6851 printf("memcache_init failed\n");
6852 return false;
6853 }
6854
6855 d1 = data_blob_const("d1", 2);
6856 d2 = data_blob_const("d2", 2);
6857 d3 = data_blob_const("d3", 2);
6858
6859 k1 = data_blob_const("d1", 2);
6860 k2 = data_blob_const("d2", 2);
6861
6862 memcache_add(cache, STAT_CACHE, k1, d1);
6863 memcache_add(cache, GETWD_CACHE, k2, d2);
6864
6865 if (!memcache_lookup(cache, STAT_CACHE, k1, &v1)) {
6866 printf("could not find k1\n");
6867 return false;
6868 }
6869 if (!data_blob_equal(d1, v1)) {
6870 return false;
6871 }
6872
6873 if (!memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
6874 printf("could not find k2\n");
6875 return false;
6876 }
6877 if (!data_blob_equal(d2, v2)) {
6878 return false;
6879 }
6880
6881 memcache_add(cache, STAT_CACHE, k1, d3);
6882
6883 if (!memcache_lookup(cache, STAT_CACHE, k1, &v3)) {
6884 printf("could not find replaced k1\n");
6885 return false;
6886 }
6887 if (!data_blob_equal(d3, v3)) {
6888 return false;
6889 }
6890
6891 memcache_add(cache, GETWD_CACHE, k1, d1);
6892
6893 if (memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
6894 printf("Did find k2, should have been purged\n");
6895 return false;
6896 }
6897
6898 TALLOC_FREE(cache);
6899
6900 cache = memcache_init(NULL, 0);
6901
6902 mem_ctx = talloc_init("foo");
6903
6904 str1 = talloc_strdup(mem_ctx, "string1");
6905 str2 = talloc_strdup(mem_ctx, "string2");
6906
6907 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
6908 data_blob_string_const("torture"), &str1);
6909 size1 = talloc_total_size(cache);
6910
6911 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
6912 data_blob_string_const("torture"), &str2);
6913 size2 = talloc_total_size(cache);
6914
6915 printf("size1=%d, size2=%d\n", (int)size1, (int)size2);
6916
6917 if (size2 > size1) {
6918 printf("memcache leaks memory!\n");
6919 goto fail;
6920 }
6921
6922 ret = true;
6923 fail:
6924 TALLOC_FREE(cache);
6925 return ret;
6926 }
6927
6928 static void wbclient_done(struct tevent_req *req)
6929 {
6930 wbcErr wbc_err;
6931 struct winbindd_response *wb_resp;
6932 int *i = (int *)tevent_req_callback_data_void(req);
6933
6934 wbc_err = wb_trans_recv(req, req, &wb_resp);
6935 TALLOC_FREE(req);
6936 *i += 1;
6937 d_printf("wb_trans_recv %d returned %s\n", *i, wbcErrorString(wbc_err));
6938 }
6939
6940 static bool run_local_wbclient(int dummy)
6941 {
6942 struct event_context *ev;
6943 struct wb_context **wb_ctx;
6944 struct winbindd_request wb_req;
6945 bool result = false;
6946 int i, j;
6947
6948 BlockSignals(True, SIGPIPE);
6949
6950 ev = tevent_context_init_byname(talloc_tos(), "epoll");
6951 if (ev == NULL) {
6952 goto fail;
6953 }
6954
6955 wb_ctx = TALLOC_ARRAY(ev, struct wb_context *, nprocs);
6956 if (wb_ctx == NULL) {
6957 goto fail;
6958 }
6959
6960 ZERO_STRUCT(wb_req);
6961 wb_req.cmd = WINBINDD_PING;
6962
6963 d_printf("nprocs=%d, numops=%d\n", (int)nprocs, (int)torture_numops);
6964
6965 for (i=0; i<nprocs; i++) {
6966 wb_ctx[i] = wb_context_init(ev, NULL);
6967 if (wb_ctx[i] == NULL) {
6968 goto fail;
6969 }
6970 for (j=0; j<torture_numops; j++) {
6971 struct tevent_req *req;
6972 req = wb_trans_send(ev, ev, wb_ctx[i],
6973 (j % 2) == 0, &wb_req);
6974 if (req == NULL) {
6975 goto fail;
6976 }
6977 tevent_req_set_callback(req, wbclient_done, &i);
6978 }
6979 }
6980
6981 i = 0;
6982
6983 while (i < nprocs * torture_numops) {
6984 event_loop_once(ev);
6985 }
6986
6987 result = true;
6988 fail:
6989 TALLOC_FREE(ev);
6990 return result;
6991 }
6992
6993 static void getaddrinfo_finished(struct tevent_req *req)
6994 {
6995 char *name = (char *)tevent_req_callback_data_void(req);
6996 struct addrinfo *ainfo;
6997 int res;
6998
6999 res = getaddrinfo_recv(req, &ainfo);
7000 if (res != 0) {
7001 d_printf("gai(%s) returned %s\n", name, gai_strerror(res));
7002 return;
7003 }
7004 d_printf("gai(%s) succeeded\n", name);
7005 freeaddrinfo(ainfo);
7006 }
7007
7008 static bool run_getaddrinfo_send(int dummy)
7009 {
7010 TALLOC_CTX *frame = talloc_stackframe();
7011 struct fncall_context *ctx;
7012 struct tevent_context *ev;
7013 bool result = false;
7014 const char *names[4] = { "www.samba.org", "notfound.samba.org",
7015 "www.slashdot.org", "heise.de" };
7016 struct tevent_req *reqs[4];
7017 int i;
7018
7019 ev = event_context_init(frame);
7020 if (ev == NULL) {
7021 goto fail;
7022 }
7023
7024 ctx = fncall_context_init(frame, 4);
7025
7026 for (i=0; i<ARRAY_SIZE(names); i++) {
7027 reqs[i] = getaddrinfo_send(frame, ev, ctx, names[i], NULL,
7028 NULL);
7029 if (reqs[i] == NULL) {
7030 goto fail;
7031 }
7032 tevent_req_set_callback(reqs[i], getaddrinfo_finished,
7033 (void *)names[i]);
7034 }
7035
7036 for (i=0; i<ARRAY_SIZE(reqs); i++) {
7037 tevent_loop_once(ev);
7038 }
7039
7040 result = true;
7041 fail:
7042 TALLOC_FREE(frame);
7043 return result;
7044 }
7045
7046
7047 static double create_procs(bool (*fn)(int), bool *result)
7048 {
7049 int i, status;
7050 volatile pid_t *child_status;
7051 volatile bool *child_status_out;
7052 int synccount;
7053 int tries = 8;
7054
7055 synccount = 0;
7056
7057 child_status = (volatile pid_t *)shm_setup(sizeof(pid_t)*nprocs);
7058 if (!child_status) {
7059 printf("Failed to setup shared memory\n");
7060 return -1;
7061 }
7062
7063 child_status_out = (volatile bool *)shm_setup(sizeof(bool)*nprocs);
7064 if (!child_status_out) {
7065 printf("Failed to setup result status shared memory\n");
7066 return -1;
7067 }
7068
7069 for (i = 0; i < nprocs; i++) {
7070 child_status[i] = 0;
7071 child_status_out[i] = True;
7072 }
7073
7074 start_timer();
7075
7076 for (i=0;i<nprocs;i++) {
7077 procnum = i;
7078 if (fork() == 0) {
7079 pid_t mypid = getpid();
7080 sys_srandom(((int)mypid) ^ ((int)time(NULL)));
7081
7082 slprintf(myname,sizeof(myname),"CLIENT%d", i);
7083
7084 while (1) {
7085 if (torture_open_connection(&current_cli, i)) break;
7086 if (tries-- == 0) {
7087 printf("pid %d failed to start\n", (int)getpid());
7088 _exit(1);
7089 }
7090 smb_msleep(10);
7091 }
7092
7093 child_status[i] = getpid();
7094
7095 while (child_status[i] && end_timer() < 5) smb_msleep(2);
7096
7097 child_status_out[i] = fn(i);
7098 _exit(0);
7099 }
7100 }
7101
7102 do {
7103 synccount = 0;
7104 for (i=0;i<nprocs;i++) {
7105 if (child_status[i]) synccount++;
7106 }
7107 if (synccount == nprocs) break;
7108 smb_msleep(10);
7109 } while (end_timer() < 30);
7110
7111 if (synccount != nprocs) {
7112 printf("FAILED TO START %d CLIENTS (started %d)\n", nprocs, synccount);
7113 *result = False;
7114 return end_timer();
7115 }
7116
7117 /* start the client load */
7118 start_timer();
7119
7120 for (i=0;i<nprocs;i++) {
7121 child_status[i] = 0;
7122 }
7123
7124 printf("%d clients started\n", nprocs);
7125
7126 for (i=0;i<nprocs;i++) {
7127 while (waitpid(0, &status, 0) == -1 && errno == EINTR) /* noop */ ;
7128 }
7129
7130 printf("\n");
7131
7132 for (i=0;i<nprocs;i++) {
7133 if (!child_status_out[i]) {
7134 *result = False;
7135 }
7136 }
7137 return end_timer();
7138 }
7139
7140 #define FLAG_MULTIPROC 1
7141
7142 static struct {
7143 const char *name;
7144 bool (*fn)(int);
7145 unsigned flags;
7146 } torture_ops[] = {
7147 {"FDPASS", run_fdpasstest, 0},
7148 {"LOCK1", run_locktest1, 0},
7149 {"LOCK2", run_locktest2, 0},
7150 {"LOCK3", run_locktest3, 0},
7151 {"LOCK4", run_locktest4, 0},
7152 {"LOCK5", run_locktest5, 0},
7153 {"LOCK6", run_locktest6, 0},
7154 {"LOCK7", run_locktest7, 0},
7155 {"LOCK8", run_locktest8, 0},
7156 {"LOCK9", run_locktest9, 0},
7157 {"UNLINK", run_unlinktest, 0},
7158 {"BROWSE", run_browsetest, 0},
7159 {"ATTR", run_attrtest, 0},
7160 {"TRANS2", run_trans2test, 0},
7161 {"MAXFID", run_maxfidtest, FLAG_MULTIPROC},
7162 {"TORTURE",run_torture, FLAG_MULTIPROC},
7163 {"RANDOMIPC", run_randomipc, 0},
7164 {"NEGNOWAIT", run_negprot_nowait, 0},
7165 {"NBENCH", run_nbench, 0},
7166 {"OPLOCK1", run_oplock1, 0},
7167 {"OPLOCK2", run_oplock2, 0},
7168 {"OPLOCK3", run_oplock3, 0},
7169 {"DIR", run_dirtest, 0},
7170 {"DIR1", run_dirtest1, 0},
7171 {"DENY1", torture_denytest1, 0},
7172 {"DENY2", torture_denytest2, 0},
7173 {"TCON", run_tcon_test, 0},
7174 {"TCONDEV", run_tcon_devtype_test, 0},
7175 {"RW1", run_readwritetest, 0},
7176 {"RW2", run_readwritemulti, FLAG_MULTIPROC},
7177 {"RW3", run_readwritelarge, 0},
7178 {"OPEN", run_opentest, 0},
7179 {"POSIX", run_simple_posix_open_test, 0},
7180 { "UID-REGRESSION-TEST", run_uid_regression_test, 0},
7181 { "SHORTNAME-TEST", run_shortname_test, 0},
7182 #if 1
7183 {"OPENATTR", run_openattrtest, 0},
7184 #endif
7185 {"XCOPY", run_xcopy, 0},
7186 {"RENAME", run_rename, 0},
7187 {"DELETE", run_deletetest, 0},
7188 {"PROPERTIES", run_properties, 0},
7189 {"MANGLE", torture_mangle, 0},
7190 {"MANGLE1", run_mangle1, 0},
7191 {"W2K", run_w2ktest, 0},
7192 {"TRANS2SCAN", torture_trans2_scan, 0},
7193 {"NTTRANSSCAN", torture_nttrans_scan, 0},
7194 {"UTABLE", torture_utable, 0},
7195 {"CASETABLE", torture_casetable, 0},
7196 {"ERRMAPEXTRACT", run_error_map_extract, 0},
7197 {"PIPE_NUMBER", run_pipe_number, 0},
7198 {"TCON2", run_tcon2_test, 0},
7199 {"IOCTL", torture_ioctl_test, 0},
7200 {"CHKPATH", torture_chkpath_test, 0},
7201 {"FDSESS", run_fdsesstest, 0},
7202 { "EATEST", run_eatest, 0},
7203 { "SESSSETUP_BENCH", run_sesssetup_bench, 0},
7204 { "CHAIN1", run_chain1, 0},
7205 { "CHAIN2", run_chain2, 0},
7206 { "WINDOWS-WRITE", run_windows_write, 0},
7207 { "CLI_ECHO", run_cli_echo, 0},
7208 { "GETADDRINFO", run_getaddrinfo_send, 0},
7209 { "TLDAP", run_tldap },
7210 { "STREAMERROR", run_streamerror },
7211 { "NOTIFY-BENCH", run_notify_bench },
7212 { "LOCAL-SUBSTITUTE", run_local_substitute, 0},
7213 { "LOCAL-GENCACHE", run_local_gencache, 0},
7214 { "LOCAL-TALLOC-DICT", run_local_talloc_dict, 0},
7215 { "LOCAL-BASE64", run_local_base64, 0},
7216 { "LOCAL-RBTREE", run_local_rbtree, 0},
7217 { "LOCAL-MEMCACHE", run_local_memcache, 0},
7218 { "LOCAL-STREAM-NAME", run_local_stream_name, 0},
7219 { "LOCAL-WBCLIENT", run_local_wbclient, 0},
7220 {NULL, NULL, 0}};
7221
7222
7223
7224 /****************************************************************************
7225 run a specified test or "ALL"
7226 ****************************************************************************/
7227 static bool run_test(const char *name)
7228 {
7229 bool ret = True;
7230 bool result = True;
7231 bool found = False;
7232 int i;
7233 double t;
7234 if (strequal(name,"ALL")) {
7235 for (i=0;torture_ops[i].name;i++) {
7236 run_test(torture_ops[i].name);
7237 }
7238 found = True;
7239 }
7240
7241 for (i=0;torture_ops[i].name;i++) {
7242 fstr_sprintf(randomfname, "\\XX%x",
7243 (unsigned)random());
7244
7245 if (strequal(name, torture_ops[i].name)) {
7246 found = True;
7247 printf("Running %s\n", name);
7248 if (torture_ops[i].flags & FLAG_MULTIPROC) {
7249 t = create_procs(torture_ops[i].fn, &result);
7250 if (!result) {
7251 ret = False;
7252 printf("TEST %s FAILED!\n", name);
7253 }
7254 } else {
7255 start_timer();
7256 if (!torture_ops[i].fn(0)) {
7257 ret = False;
7258 printf("TEST %s FAILED!\n", name);
7259 }
7260 t = end_timer();
7261 }
7262 printf("%s took %g secs\n\n", name, t);
7263 }
7264 }
7265
7266 if (!found) {
7267 printf("Did not find a test named %s\n", name);
7268 ret = False;
7269 }
7270
7271 return ret;
7272 }
7273
7274
7275 static void usage(void)
7276 {
7277 int i;
7278
7279 printf("WARNING samba4 test suite is much more complete nowadays.\n");
7280 printf("Please use samba4 torture.\n\n");
7281
7282 printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
7283
7284 printf("\t-d debuglevel\n");
7285 printf("\t-U user%%pass\n");
7286 printf("\t-k use kerberos\n");
7287 printf("\t-N numprocs\n");
7288 printf("\t-n my_netbios_name\n");
7289 printf("\t-W workgroup\n");
7290 printf("\t-o num_operations\n");
7291 printf("\t-O socket_options\n");
7292 printf("\t-m maximum protocol\n");
7293 printf("\t-L use oplocks\n");
7294 printf("\t-c CLIENT.TXT specify client load file for NBENCH\n");
7295 printf("\t-A showall\n");
7296 printf("\t-p port\n");
7297 printf("\t-s seed\n");
7298 printf("\t-b unclist_filename specify multiple shares for multiple connections\n");
7299 printf("\n\n");
7300
7301 printf("tests are:");
7302 for (i=0;torture_ops[i].name;i++) {
7303 printf(" %s", torture_ops[i].name);
7304 }
7305 printf("\n");
7306
7307 printf("default test is ALL\n");
7308
7309 exit(1);
7310 }
7311
7312 /****************************************************************************
7313 main program
7314 ****************************************************************************/
7315 int main(int argc,char *argv[])
7316 {
7317 int opt, i;
7318 char *p;
7319 int gotuser = 0;
7320 int gotpass = 0;
7321 bool correct = True;
7322 TALLOC_CTX *frame = talloc_stackframe();
7323 int seed = time(NULL);
7324
7325 dbf = x_stdout;
7326
7327 #ifdef HAVE_SETBUFFER
7328 setbuffer(stdout, NULL, 0);
7329 #endif
7330
7331 load_case_tables();
7332
7333 if (is_default_dyn_CONFIGFILE()) {
7334 if(getenv("SMB_CONF_PATH")) {
7335 set_dyn_CONFIGFILE(getenv("SMB_CONF_PATH"));
7336 }
7337 }
7338 lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
7339 load_interfaces();
7340
7341 if (argc < 2) {
7342 usage();
7343 }
7344
7345 for(p = argv[1]; *p; p++)
7346 if(*p == '\\')
7347 *p = '/';
7348
7349 if (strncmp(argv[1], "//", 2)) {
7350 usage();
7351 }
7352
7353 fstrcpy(host, &argv[1][2]);
7354 p = strchr_m(&host[2],'/');
7355 if (!p) {
7356 usage();
7357 }
7358 *p = 0;
7359 fstrcpy(share, p+1);
7360
7361 fstrcpy(myname, get_myname(talloc_tos()));
7362 if (!*myname) {
7363 fprintf(stderr, "Failed to get my hostname.\n");
7364 return 1;
7365 }
7366
7367 if (*username == 0 && getenv("LOGNAME")) {
7368 fstrcpy(username,getenv("LOGNAME"));
7369 }
7370
7371 argc--;
7372 argv++;
7373
7374 fstrcpy(workgroup, lp_workgroup());
7375
7376 while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ll:d:Aec:ks:b:B:")) != EOF) {
7377 switch (opt) {
7378 case 'p':
7379 port_to_use = atoi(optarg);
7380 break;
7381 case 's':
7382 seed = atoi(optarg);
7383 break;
7384 case 'W':
7385 fstrcpy(workgroup,optarg);
7386 break;
7387 case 'm':
7388 max_protocol = interpret_protocol(optarg, max_protocol);
7389 break;
7390 case 'N':
7391 nprocs = atoi(optarg);
7392 break;
7393 case 'o':
7394 torture_numops = atoi(optarg);
7395 break;
7396 case 'd':
7397 DEBUGLEVEL = atoi(optarg);
7398 break;
7399 case 'O':
7400 sockops = optarg;
7401 break;
7402 case 'L':
7403 use_oplocks = True;
7404 break;
7405 case 'l':
7406 local_path = optarg;
7407 break;
7408 case 'A':
7409 torture_showall = True;
7410 break;
7411 case 'n':
7412 fstrcpy(myname, optarg);
7413 break;
7414 case 'c':
7415 client_txt = optarg;
7416 break;
7417 case 'e':
7418 do_encrypt = true;
7419 break;
7420 case 'k':
7421 #ifdef HAVE_KRB5
7422 use_kerberos = True;
7423 #else
7424 d_printf("No kerberos support compiled in\n");
7425 exit(1);
7426 #endif
7427 break;
7428 case 'U':
7429 gotuser = 1;
7430 fstrcpy(username,optarg);
7431 p = strchr_m(username,'%');
7432 if (p) {
7433 *p = 0;
7434 fstrcpy(password, p+1);
7435 gotpass = 1;
7436 }
7437 break;
7438 case 'b':
7439 fstrcpy(multishare_conn_fname, optarg);
7440 use_multishare_conn = True;
7441 break;
7442 case 'B':
7443 torture_blocksize = atoi(optarg);
7444 break;
7445 default:
7446 printf("Unknown option %c (%d)\n", (char)opt, opt);
7447 usage();
7448 }
7449 }
7450
7451 d_printf("using seed %d\n", seed);
7452
7453 srandom(seed);
7454
7455 if(use_kerberos && !gotuser) gotpass = True;
7456
7457 while (!gotpass) {
7458 p = getpass("Password:");
7459 if (p) {
7460 fstrcpy(password, p);
7461 gotpass = 1;
7462 }
7463 }
7464
7465 printf("host=%s share=%s user=%s myname=%s\n",
7466 host, share, username, myname);
7467
7468 if (argc == optind) {
7469 correct = run_test("ALL");
7470 } else {
7471 for (i=optind;i<argc;i++) {
7472 if (!run_test(argv[i])) {
7473 correct = False;
7474 }
7475 }
7476 }
7477
7478 TALLOC_FREE(frame);
7479
7480 if (correct) {
7481 return(0);
7482 } else {
7483 return(1);
7484 }
7485 }