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