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