?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-torture: run_locktest4(): replace cli_read_old() with cli_read()
[Samba/gebeck_regimport.git] / source3 / torture / torture.c
blobc2bc6d24812f4ec2c1da844526e3e52b71748cbc
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_t old_vuid = cli_state_get_uid(cli);
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_state_set_uid(cli, 0);
440 ret = NT_STATUS_IS_OK(cli_session_setup(cli, username,
441 password, passlen,
442 password, passlen,
443 workgroup));
444 *new_vuid = cli_state_get_uid(cli);
445 cli_state_set_uid(cli, 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_state_get_uid(cli);
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_state_get_uid(cli) + 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_state_set_uid(cli, 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_state_set_uid(cli, 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 static bool test_cli_read(struct cli_state *cli, uint16_t fnum,
1909 char *buf, off_t offset, size_t size,
1910 size_t *nread, size_t expect)
1911 {
1912 NTSTATUS status;
1913 size_t l_nread;
1914
1915 status = cli_read(cli, fnum, buf, offset, size, &l_nread);
1916
1917 if(!NT_STATUS_IS_OK(status)) {
1918 return false;
1919 } else if (l_nread != expect) {
1920 return false;
1921 }
1922
1923 if (nread) {
1924 *nread = l_nread;
1925 }
1926
1927 return true;
1928 }
1929
1930 #define EXPECTED(ret, v) if ((ret) != (v)) { \
1931 printf("** "); correct = False; \
1932 }
1933
1934 /*
1935 looks at overlapping locks
1936 */
1937 static bool run_locktest4(int dummy)
1938 {
1939 static struct cli_state *cli1, *cli2;
1940 const char *fname = "\\lockt4.lck";
1941 uint16_t fnum1, fnum2, f;
1942 bool ret;
1943 char buf[1000];
1944 bool correct = True;
1945 NTSTATUS status;
1946
1947 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1948 return False;
1949 }
1950
1951 cli_sockopt(cli1, sockops);
1952 cli_sockopt(cli2, sockops);
1953
1954 printf("starting locktest4\n");
1955
1956 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1957
1958 cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1959 cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1960
1961 memset(buf, 0, sizeof(buf));
1962
1963 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf),
1964 NULL);
1965 if (!NT_STATUS_IS_OK(status)) {
1966 printf("Failed to create file: %s\n", nt_errstr(status));
1967 correct = False;
1968 goto fail;
1969 }
1970
1971 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) &&
1972 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 2, 4, 0, WRITE_LOCK));
1973 EXPECTED(ret, False);
1974 printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
1975
1976 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 10, 4, 0, READ_LOCK)) &&
1977 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 12, 4, 0, READ_LOCK));
1978 EXPECTED(ret, True);
1979 printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
1980
1981 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 20, 4, 0, WRITE_LOCK)) &&
1982 NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 22, 4, 0, WRITE_LOCK));
1983 EXPECTED(ret, False);
1984 printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
1985
1986 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 30, 4, 0, READ_LOCK)) &&
1987 NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 32, 4, 0, READ_LOCK));
1988 EXPECTED(ret, True);
1989 printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
1990
1991 ret = (cli_setpid(cli1, 1),
1992 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 40, 4, 0, WRITE_LOCK))) &&
1993 (cli_setpid(cli1, 2),
1994 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 42, 4, 0, WRITE_LOCK)));
1995 EXPECTED(ret, False);
1996 printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
1997
1998 ret = (cli_setpid(cli1, 1),
1999 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 50, 4, 0, READ_LOCK))) &&
2000 (cli_setpid(cli1, 2),
2001 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 52, 4, 0, READ_LOCK)));
2002 EXPECTED(ret, True);
2003 printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
2004
2005 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 60, 4, 0, READ_LOCK)) &&
2006 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 60, 4, 0, READ_LOCK));
2007 EXPECTED(ret, True);
2008 printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
2009
2010 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 70, 4, 0, WRITE_LOCK)) &&
2011 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 70, 4, 0, WRITE_LOCK));
2012 EXPECTED(ret, False);
2013 printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
2014
2015 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 80, 4, 0, READ_LOCK)) &&
2016 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 80, 4, 0, WRITE_LOCK));
2017 EXPECTED(ret, False);
2018 printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
2019
2020 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 90, 4, 0, WRITE_LOCK)) &&
2021 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 90, 4, 0, READ_LOCK));
2022 EXPECTED(ret, True);
2023 printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
2024
2025 ret = (cli_setpid(cli1, 1),
2026 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 100, 4, 0, WRITE_LOCK))) &&
2027 (cli_setpid(cli1, 2),
2028 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 100, 4, 0, READ_LOCK)));
2029 EXPECTED(ret, False);
2030 printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
2031
2032 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 110, 4, 0, READ_LOCK)) &&
2033 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 112, 4, 0, READ_LOCK)) &&
2034 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 110, 6));
2035 EXPECTED(ret, False);
2036 printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
2037
2038
2039 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 120, 4, 0, WRITE_LOCK)) &&
2040 test_cli_read(cli2, fnum2, buf, 120, 4, NULL, 4);
2041 EXPECTED(ret, False);
2042 printf("this server %s strict write locking\n", ret?"doesn't do":"does");
2043
2044 status = cli_lock32(cli1, fnum1, 130, 4, 0, READ_LOCK);
2045 ret = NT_STATUS_IS_OK(status);
2046 if (ret) {
2047 status = cli_writeall(cli2, fnum2, 0, (uint8_t *)buf, 130, 4,
2048 NULL);
2049 ret = NT_STATUS_IS_OK(status);
2050 }
2051 EXPECTED(ret, False);
2052 printf("this server %s strict read locking\n", ret?"doesn't do":"does");
2053
2054
2055 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 140, 4, 0, READ_LOCK)) &&
2056 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 140, 4, 0, READ_LOCK)) &&
2057 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4)) &&
2058 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4));
2059 EXPECTED(ret, True);
2060 printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
2061
2062
2063 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 150, 4, 0, WRITE_LOCK)) &&
2064 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 150, 4, 0, READ_LOCK)) &&
2065 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4)) &&
2066 test_cli_read(cli2, fnum2, buf, 150, 4, NULL, 4) &&
2067 !(NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2068 150, 4, NULL))) &&
2069 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4));
2070 EXPECTED(ret, True);
2071 printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
2072
2073 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 160, 4, 0, READ_LOCK)) &&
2074 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 160, 4)) &&
2075 NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2076 160, 4, NULL)) &&
2077 test_cli_read(cli2, fnum2, buf, 160, 4, NULL, 4);
2078 EXPECTED(ret, True);
2079 printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
2080
2081 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 170, 4, 0, WRITE_LOCK)) &&
2082 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 170, 4)) &&
2083 NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2084 170, 4, NULL)) &&
2085 test_cli_read(cli2, fnum2, buf, 170, 4, NULL, 4);
2086 EXPECTED(ret, True);
2087 printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
2088
2089 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 190, 4, 0, WRITE_LOCK)) &&
2090 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 190, 4, 0, READ_LOCK)) &&
2091 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 190, 4)) &&
2092 !NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2093 190, 4, NULL)) &&
2094 test_cli_read(cli2, fnum2, buf, 190, 4, NULL, 4);
2095 EXPECTED(ret, True);
2096 printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
2097
2098 cli_close(cli1, fnum1);
2099 cli_close(cli2, fnum2);
2100 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2101 cli_open(cli1, fname, O_RDWR, DENY_NONE, &f);
2102 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 8, 0, READ_LOCK)) &&
2103 NT_STATUS_IS_OK(cli_lock32(cli1, f, 0, 1, 0, READ_LOCK)) &&
2104 NT_STATUS_IS_OK(cli_close(cli1, fnum1)) &&
2105 NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1)) &&
2106 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 7, 1, 0, WRITE_LOCK));
2107 cli_close(cli1, f);
2108 cli_close(cli1, fnum1);
2109 EXPECTED(ret, True);
2110 printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
2111
2112 fail:
2113 cli_close(cli1, fnum1);
2114 cli_close(cli2, fnum2);
2115 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2116 torture_close_connection(cli1);
2117 torture_close_connection(cli2);
2118
2119 printf("finished locktest4\n");
2120 return correct;
2121 }
2122
2123 /*
2124 looks at lock upgrade/downgrade.
2125 */
2126 static bool run_locktest5(int dummy)
2127 {
2128 static struct cli_state *cli1, *cli2;
2129 const char *fname = "\\lockt5.lck";
2130 uint16_t fnum1, fnum2, fnum3;
2131 bool ret;
2132 char buf[1000];
2133 bool correct = True;
2134 NTSTATUS status;
2135
2136 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2137 return False;
2138 }
2139
2140 cli_sockopt(cli1, sockops);
2141 cli_sockopt(cli2, sockops);
2142
2143 printf("starting locktest5\n");
2144
2145 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2146
2147 cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2148 cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
2149 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum3);
2150
2151 memset(buf, 0, sizeof(buf));
2152
2153 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf),
2154 NULL);
2155 if (!NT_STATUS_IS_OK(status)) {
2156 printf("Failed to create file: %s\n", nt_errstr(status));
2157 correct = False;
2158 goto fail;
2159 }
2160
2161 /* Check for NT bug... */
2162 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 8, 0, READ_LOCK)) &&
2163 NT_STATUS_IS_OK(cli_lock32(cli1, fnum3, 0, 1, 0, READ_LOCK));
2164 cli_close(cli1, fnum1);
2165 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2166 status = cli_lock32(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
2167 ret = NT_STATUS_IS_OK(status);
2168 EXPECTED(ret, True);
2169 printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
2170 cli_close(cli1, fnum1);
2171 cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2172 cli_unlock(cli1, fnum3, 0, 1);
2173
2174 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) &&
2175 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 1, 1, 0, READ_LOCK));
2176 EXPECTED(ret, True);
2177 printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
2178
2179 status = cli_lock32(cli2, fnum2, 0, 4, 0, READ_LOCK);
2180 ret = NT_STATUS_IS_OK(status);
2181 EXPECTED(ret, False);
2182
2183 printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
2184
2185 /* Unlock the process 2 lock. */
2186 cli_unlock(cli2, fnum2, 0, 4);
2187
2188 status = cli_lock32(cli1, fnum3, 0, 4, 0, READ_LOCK);
2189 ret = NT_STATUS_IS_OK(status);
2190 EXPECTED(ret, False);
2191
2192 printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
2193
2194 /* Unlock the process 1 fnum3 lock. */
2195 cli_unlock(cli1, fnum3, 0, 4);
2196
2197 /* Stack 2 more locks here. */
2198 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK)) &&
2199 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK));
2200
2201 EXPECTED(ret, True);
2202 printf("the same process %s stack read locks\n", ret?"can":"cannot");
2203
2204 /* Unlock the first process lock, then check this was the WRITE lock that was
2205 removed. */
2206
2207 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
2208 NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 0, 4, 0, READ_LOCK));
2209
2210 EXPECTED(ret, True);
2211 printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
2212
2213 /* Unlock the process 2 lock. */
2214 cli_unlock(cli2, fnum2, 0, 4);
2215
2216 /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
2217
2218 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 1, 1)) &&
2219 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
2220 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
2221
2222 EXPECTED(ret, True);
2223 printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
2224
2225 /* Ensure the next unlock fails. */
2226 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
2227 EXPECTED(ret, False);
2228 printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
2229
2230 /* Ensure connection 2 can get a write lock. */
2231 status = cli_lock32(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
2232 ret = NT_STATUS_IS_OK(status);
2233 EXPECTED(ret, True);
2234
2235 printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
2236
2237
2238 fail:
2239 cli_close(cli1, fnum1);
2240 cli_close(cli2, fnum2);
2241 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2242 if (!torture_close_connection(cli1)) {
2243 correct = False;
2244 }
2245 if (!torture_close_connection(cli2)) {
2246 correct = False;
2247 }
2248
2249 printf("finished locktest5\n");
2250
2251 return correct;
2252 }
2253
2254 /*
2255 tries the unusual lockingX locktype bits
2256 */
2257 static bool run_locktest6(int dummy)
2258 {
2259 static struct cli_state *cli;
2260 const char *fname[1] = { "\\lock6.txt" };
2261 int i;
2262 uint16_t fnum;
2263 NTSTATUS status;
2264
2265 if (!torture_open_connection(&cli, 0)) {
2266 return False;
2267 }
2268
2269 cli_sockopt(cli, sockops);
2270
2271 printf("starting locktest6\n");
2272
2273 for (i=0;i<1;i++) {
2274 printf("Testing %s\n", fname[i]);
2275
2276 cli_unlink(cli, fname[i], FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2277
2278 cli_open(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
2279 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
2280 cli_close(cli, fnum);
2281 printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
2282
2283 cli_open(cli, fname[i], O_RDWR, DENY_NONE, &fnum);
2284 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
2285 cli_close(cli, fnum);
2286 printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
2287
2288 cli_unlink(cli, fname[i], FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2289 }
2290
2291 torture_close_connection(cli);
2292
2293 printf("finished locktest6\n");
2294 return True;
2295 }
2296
2297 static bool run_locktest7(int dummy)
2298 {
2299 struct cli_state *cli1;
2300 const char *fname = "\\lockt7.lck";
2301 uint16_t fnum1;
2302 char buf[200];
2303 bool correct = False;
2304 NTSTATUS status;
2305
2306 if (!torture_open_connection(&cli1, 0)) {
2307 return False;
2308 }
2309
2310 cli_sockopt(cli1, sockops);
2311
2312 printf("starting locktest7\n");
2313
2314 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2315
2316 cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2317
2318 memset(buf, 0, sizeof(buf));
2319
2320 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf),
2321 NULL);
2322 if (!NT_STATUS_IS_OK(status)) {
2323 printf("Failed to create file: %s\n", nt_errstr(status));
2324 goto fail;
2325 }
2326
2327 cli_setpid(cli1, 1);
2328
2329 status = cli_lock32(cli1, fnum1, 130, 4, 0, READ_LOCK);
2330 if (!NT_STATUS_IS_OK(status)) {
2331 printf("Unable to apply read lock on range 130:4, error was %s\n", nt_errstr(status));
2332 goto fail;
2333 } else {
2334 printf("pid1 successfully locked range 130:4 for READ\n");
2335 }
2336
2337 if (cli_read_old(cli1, fnum1, buf, 130, 4) != 4) {
2338 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2339 goto fail;
2340 } else {
2341 printf("pid1 successfully read the range 130:4\n");
2342 }
2343
2344 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2345 if (!NT_STATUS_IS_OK(status)) {
2346 printf("pid1 unable to write to the range 130:4, error was "
2347 "%s\n", nt_errstr(status));
2348 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2349 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2350 goto fail;
2351 }
2352 } else {
2353 printf("pid1 successfully wrote to the range 130:4 (should be denied)\n");
2354 goto fail;
2355 }
2356
2357 cli_setpid(cli1, 2);
2358
2359 if (cli_read_old(cli1, fnum1, buf, 130, 4) != 4) {
2360 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2361 } else {
2362 printf("pid2 successfully read the range 130:4\n");
2363 }
2364
2365 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2366 if (!NT_STATUS_IS_OK(status)) {
2367 printf("pid2 unable to write to the range 130:4, error was "
2368 "%s\n", nt_errstr(status));
2369 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2370 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2371 goto fail;
2372 }
2373 } else {
2374 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2375 goto fail;
2376 }
2377
2378 cli_setpid(cli1, 1);
2379 cli_unlock(cli1, fnum1, 130, 4);
2380
2381 status = cli_lock32(cli1, fnum1, 130, 4, 0, WRITE_LOCK);
2382 if (!NT_STATUS_IS_OK(status)) {
2383 printf("Unable to apply write lock on range 130:4, error was %s\n", nt_errstr(status));
2384 goto fail;
2385 } else {
2386 printf("pid1 successfully locked range 130:4 for WRITE\n");
2387 }
2388
2389 if (cli_read_old(cli1, fnum1, buf, 130, 4) != 4) {
2390 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2391 goto fail;
2392 } else {
2393 printf("pid1 successfully read the range 130:4\n");
2394 }
2395
2396 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2397 if (!NT_STATUS_IS_OK(status)) {
2398 printf("pid1 unable to write to the range 130:4, error was "
2399 "%s\n", nt_errstr(status));
2400 goto fail;
2401 } else {
2402 printf("pid1 successfully wrote to the range 130:4\n");
2403 }
2404
2405 cli_setpid(cli1, 2);
2406
2407 if (cli_read_old(cli1, fnum1, buf, 130, 4) != 4) {
2408 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2409 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2410 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2411 goto fail;
2412 }
2413 } else {
2414 printf("pid2 successfully read the range 130:4 (should be denied)\n");
2415 goto fail;
2416 }
2417
2418 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2419 if (!NT_STATUS_IS_OK(status)) {
2420 printf("pid2 unable to write to the range 130:4, error was "
2421 "%s\n", nt_errstr(status));
2422 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2423 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2424 goto fail;
2425 }
2426 } else {
2427 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2428 goto fail;
2429 }
2430
2431 cli_unlock(cli1, fnum1, 130, 0);
2432 correct = True;
2433
2434 fail:
2435 cli_close(cli1, fnum1);
2436 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2437 torture_close_connection(cli1);
2438
2439 printf("finished locktest7\n");
2440 return correct;
2441 }
2442
2443 /*
2444 * This demonstrates a problem with our use of GPFS share modes: A file
2445 * descriptor sitting in the pending close queue holding a GPFS share mode
2446 * blocks opening a file another time. Happens with Word 2007 temp files.
2447 * With "posix locking = yes" and "gpfs:sharemodes = yes" enabled, the third
2448 * open is denied with NT_STATUS_SHARING_VIOLATION.
2449 */
2450
2451 static bool run_locktest8(int dummy)
2452 {
2453 struct cli_state *cli1;
2454 const char *fname = "\\lockt8.lck";
2455 uint16_t fnum1, fnum2;
2456 char buf[200];
2457 bool correct = False;
2458 NTSTATUS status;
2459
2460 if (!torture_open_connection(&cli1, 0)) {
2461 return False;
2462 }
2463
2464 cli_sockopt(cli1, sockops);
2465
2466 printf("starting locktest8\n");
2467
2468 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2469
2470 status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_WRITE,
2471 &fnum1);
2472 if (!NT_STATUS_IS_OK(status)) {
2473 d_fprintf(stderr, "cli_open returned %s\n", nt_errstr(status));
2474 return false;
2475 }
2476
2477 memset(buf, 0, sizeof(buf));
2478
2479 status = cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum2);
2480 if (!NT_STATUS_IS_OK(status)) {
2481 d_fprintf(stderr, "cli_open second time returned %s\n",
2482 nt_errstr(status));
2483 goto fail;
2484 }
2485
2486 status = cli_lock32(cli1, fnum2, 1, 1, 0, READ_LOCK);
2487 if (!NT_STATUS_IS_OK(status)) {
2488 printf("Unable to apply read lock on range 1:1, error was "
2489 "%s\n", nt_errstr(status));
2490 goto fail;
2491 }
2492
2493 status = cli_close(cli1, fnum1);
2494 if (!NT_STATUS_IS_OK(status)) {
2495 d_fprintf(stderr, "cli_close(fnum1) %s\n", nt_errstr(status));
2496 goto fail;
2497 }
2498
2499 status = cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2500 if (!NT_STATUS_IS_OK(status)) {
2501 d_fprintf(stderr, "cli_open third time returned %s\n",
2502 nt_errstr(status));
2503 goto fail;
2504 }
2505
2506 correct = true;
2507
2508 fail:
2509 cli_close(cli1, fnum1);
2510 cli_close(cli1, fnum2);
2511 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2512 torture_close_connection(cli1);
2513
2514 printf("finished locktest8\n");
2515 return correct;
2516 }
2517
2518 /*
2519 * This test is designed to be run in conjunction with
2520 * external NFS or POSIX locks taken in the filesystem.
2521 * It checks that the smbd server will block until the
2522 * lock is released and then acquire it. JRA.
2523 */
2524
2525 static bool got_alarm;
2526 static struct cli_state *alarm_cli;
2527
2528 static void alarm_handler(int dummy)
2529 {
2530 got_alarm = True;
2531 }
2532
2533 static void alarm_handler_parent(int dummy)
2534 {
2535 cli_state_disconnect(alarm_cli);
2536 }
2537
2538 static void do_local_lock(int read_fd, int write_fd)
2539 {
2540 int fd;
2541 char c = '\0';
2542 struct flock lock;
2543 const char *local_pathname = NULL;
2544 int ret;
2545
2546 local_pathname = talloc_asprintf(talloc_tos(),
2547 "%s/lockt9.lck", local_path);
2548 if (!local_pathname) {
2549 printf("child: alloc fail\n");
2550 exit(1);
2551 }
2552
2553 unlink(local_pathname);
2554 fd = open(local_pathname, O_RDWR|O_CREAT, 0666);
2555 if (fd == -1) {
2556 printf("child: open of %s failed %s.\n",
2557 local_pathname, strerror(errno));
2558 exit(1);
2559 }
2560
2561 /* Now take a fcntl lock. */
2562 lock.l_type = F_WRLCK;
2563 lock.l_whence = SEEK_SET;
2564 lock.l_start = 0;
2565 lock.l_len = 4;
2566 lock.l_pid = getpid();
2567
2568 ret = fcntl(fd,F_SETLK,&lock);
2569 if (ret == -1) {
2570 printf("child: failed to get lock 0:4 on file %s. Error %s\n",
2571 local_pathname, strerror(errno));
2572 exit(1);
2573 } else {
2574 printf("child: got lock 0:4 on file %s.\n",
2575 local_pathname );
2576 fflush(stdout);
2577 }
2578
2579 CatchSignal(SIGALRM, alarm_handler);
2580 alarm(5);
2581 /* Signal the parent. */
2582 if (write(write_fd, &c, 1) != 1) {
2583 printf("child: start signal fail %s.\n",
2584 strerror(errno));
2585 exit(1);
2586 }
2587 alarm(0);
2588
2589 alarm(10);
2590 /* Wait for the parent to be ready. */
2591 if (read(read_fd, &c, 1) != 1) {
2592 printf("child: reply signal fail %s.\n",
2593 strerror(errno));
2594 exit(1);
2595 }
2596 alarm(0);
2597
2598 sleep(5);
2599 close(fd);
2600 printf("child: released lock 0:4 on file %s.\n",
2601 local_pathname );
2602 fflush(stdout);
2603 exit(0);
2604 }
2605
2606 static bool run_locktest9(int dummy)
2607 {
2608 struct cli_state *cli1;
2609 const char *fname = "\\lockt9.lck";
2610 uint16_t fnum;
2611 bool correct = False;
2612 int pipe_in[2], pipe_out[2];
2613 pid_t child_pid;
2614 char c = '\0';
2615 int ret;
2616 struct timeval start;
2617 double seconds;
2618 NTSTATUS status;
2619
2620 printf("starting locktest9\n");
2621
2622 if (local_path == NULL) {
2623 d_fprintf(stderr, "locktest9 must be given a local path via -l <localpath>\n");
2624 return false;
2625 }
2626
2627 if (pipe(pipe_in) == -1 || pipe(pipe_out) == -1) {
2628 return false;
2629 }
2630
2631 child_pid = fork();
2632 if (child_pid == -1) {
2633 return false;
2634 }
2635
2636 if (child_pid == 0) {
2637 /* Child. */
2638 do_local_lock(pipe_out[0], pipe_in[1]);
2639 exit(0);
2640 }
2641
2642 close(pipe_out[0]);
2643 close(pipe_in[1]);
2644 pipe_out[0] = -1;
2645 pipe_in[1] = -1;
2646
2647 /* Parent. */
2648 ret = read(pipe_in[0], &c, 1);
2649 if (ret != 1) {
2650 d_fprintf(stderr, "failed to read start signal from child. %s\n",
2651 strerror(errno));
2652 return false;
2653 }
2654
2655 if (!torture_open_connection(&cli1, 0)) {
2656 return false;
2657 }
2658
2659 cli_sockopt(cli1, sockops);
2660
2661 status = cli_open(cli1, fname, O_RDWR, DENY_NONE,
2662 &fnum);
2663 if (!NT_STATUS_IS_OK(status)) {
2664 d_fprintf(stderr, "cli_open returned %s\n", nt_errstr(status));
2665 return false;
2666 }
2667
2668 /* Ensure the child has the lock. */
2669 status = cli_lock32(cli1, fnum, 0, 4, 0, WRITE_LOCK);
2670 if (NT_STATUS_IS_OK(status)) {
2671 d_fprintf(stderr, "Got the lock on range 0:4 - this should not happen !\n");
2672 goto fail;
2673 } else {
2674 d_printf("Child has the lock.\n");
2675 }
2676
2677 /* Tell the child to wait 5 seconds then exit. */
2678 ret = write(pipe_out[1], &c, 1);
2679 if (ret != 1) {
2680 d_fprintf(stderr, "failed to send exit signal to child. %s\n",
2681 strerror(errno));
2682 goto fail;
2683 }
2684
2685 /* Wait 20 seconds for the lock. */
2686 alarm_cli = cli1;
2687 CatchSignal(SIGALRM, alarm_handler_parent);
2688 alarm(20);
2689
2690 start = timeval_current();
2691
2692 status = cli_lock32(cli1, fnum, 0, 4, -1, WRITE_LOCK);
2693 if (!NT_STATUS_IS_OK(status)) {
2694 d_fprintf(stderr, "Unable to apply write lock on range 0:4, error was "
2695 "%s\n", nt_errstr(status));
2696 goto fail_nofd;
2697 }
2698 alarm(0);
2699
2700 seconds = timeval_elapsed(&start);
2701
2702 printf("Parent got the lock after %.2f seconds.\n",
2703 seconds);
2704
2705 status = cli_close(cli1, fnum);
2706 if (!NT_STATUS_IS_OK(status)) {
2707 d_fprintf(stderr, "cli_close(fnum1) %s\n", nt_errstr(status));
2708 goto fail;
2709 }
2710
2711 correct = true;
2712
2713 fail:
2714 cli_close(cli1, fnum);
2715 torture_close_connection(cli1);
2716
2717 fail_nofd:
2718
2719 printf("finished locktest9\n");
2720 return correct;
2721 }
2722
2723 /*
2724 test whether fnums and tids open on one VC are available on another (a major
2725 security hole)
2726 */
2727 static bool run_fdpasstest(int dummy)
2728 {
2729 struct cli_state *cli1, *cli2;
2730 const char *fname = "\\fdpass.tst";
2731 uint16_t fnum1;
2732 char buf[1024];
2733 NTSTATUS status;
2734
2735 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2736 return False;
2737 }
2738 cli_sockopt(cli1, sockops);
2739 cli_sockopt(cli2, sockops);
2740
2741 printf("starting fdpasstest\n");
2742
2743 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2744
2745 status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
2746 &fnum1);
2747 if (!NT_STATUS_IS_OK(status)) {
2748 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
2749 return False;
2750 }
2751
2752 status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"hello world\n", 0,
2753 13, NULL);
2754 if (!NT_STATUS_IS_OK(status)) {
2755 printf("write failed (%s)\n", nt_errstr(status));
2756 return False;
2757 }
2758
2759 cli_state_set_uid(cli2, cli_state_get_uid(cli1));
2760 cli_state_set_tid(cli2, cli_state_get_tid(cli1));
2761 cli_setpid(cli2, cli_getpid(cli1));
2762
2763 if (cli_read_old(cli2, fnum1, buf, 0, 13) == 13) {
2764 printf("read succeeded! nasty security hole [%s]\n",
2765 buf);
2766 return False;
2767 }
2768
2769 cli_close(cli1, fnum1);
2770 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2771
2772 torture_close_connection(cli1);
2773 torture_close_connection(cli2);
2774
2775 printf("finished fdpasstest\n");
2776 return True;
2777 }
2778
2779 static bool run_fdsesstest(int dummy)
2780 {
2781 struct cli_state *cli;
2782 uint16 new_vuid;
2783 uint16 saved_vuid;
2784 uint16 new_cnum;
2785 uint16 saved_cnum;
2786 const char *fname = "\\fdsess.tst";
2787 const char *fname1 = "\\fdsess1.tst";
2788 uint16_t fnum1;
2789 uint16_t fnum2;
2790 char buf[1024];
2791 bool ret = True;
2792 NTSTATUS status;
2793
2794 if (!torture_open_connection(&cli, 0))
2795 return False;
2796 cli_sockopt(cli, sockops);
2797
2798 if (!torture_cli_session_setup2(cli, &new_vuid))
2799 return False;
2800
2801 saved_cnum = cli_state_get_tid(cli);
2802 if (!NT_STATUS_IS_OK(cli_tcon_andx(cli, share, "?????", "", 1)))
2803 return False;
2804 new_cnum = cli_state_get_tid(cli);
2805 cli_state_set_tid(cli, saved_cnum);
2806
2807 printf("starting fdsesstest\n");
2808
2809 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2810 cli_unlink(cli, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2811
2812 status = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2813 if (!NT_STATUS_IS_OK(status)) {
2814 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
2815 return False;
2816 }
2817
2818 status = cli_writeall(cli, fnum1, 0, (const uint8_t *)"hello world\n", 0, 13,
2819 NULL);
2820 if (!NT_STATUS_IS_OK(status)) {
2821 printf("write failed (%s)\n", nt_errstr(status));
2822 return False;
2823 }
2824
2825 saved_vuid = cli_state_get_uid(cli);
2826 cli_state_set_uid(cli, new_vuid);
2827
2828 if (cli_read_old(cli, fnum1, buf, 0, 13) == 13) {
2829 printf("read succeeded with different vuid! nasty security hole [%s]\n",
2830 buf);
2831 ret = False;
2832 }
2833 /* Try to open a file with different vuid, samba cnum. */
2834 if (NT_STATUS_IS_OK(cli_open(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum2))) {
2835 printf("create with different vuid, same cnum succeeded.\n");
2836 cli_close(cli, fnum2);
2837 cli_unlink(cli, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2838 } else {
2839 printf("create with different vuid, same cnum failed.\n");
2840 printf("This will cause problems with service clients.\n");
2841 ret = False;
2842 }
2843
2844 cli_state_set_uid(cli, saved_vuid);
2845
2846 /* Try with same vuid, different cnum. */
2847 cli_state_set_tid(cli, new_cnum);
2848
2849 if (cli_read_old(cli, fnum1, buf, 0, 13) == 13) {
2850 printf("read succeeded with different cnum![%s]\n",
2851 buf);
2852 ret = False;
2853 }
2854
2855 cli_state_set_tid(cli, saved_cnum);
2856 cli_close(cli, fnum1);
2857 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2858
2859 torture_close_connection(cli);
2860
2861 printf("finished fdsesstest\n");
2862 return ret;
2863 }
2864
2865 /*
2866 This test checks that
2867
2868 1) the server does not allow an unlink on a file that is open
2869 */
2870 static bool run_unlinktest(int dummy)
2871 {
2872 struct cli_state *cli;
2873 const char *fname = "\\unlink.tst";
2874 uint16_t fnum;
2875 bool correct = True;
2876 NTSTATUS status;
2877
2878 if (!torture_open_connection(&cli, 0)) {
2879 return False;
2880 }
2881
2882 cli_sockopt(cli, sockops);
2883
2884 printf("starting unlink test\n");
2885
2886 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2887
2888 cli_setpid(cli, 1);
2889
2890 status = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
2891 if (!NT_STATUS_IS_OK(status)) {
2892 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
2893 return False;
2894 }
2895
2896 status = cli_unlink(cli, fname,
2897 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2898 if (NT_STATUS_IS_OK(status)) {
2899 printf("error: server allowed unlink on an open file\n");
2900 correct = False;
2901 } else {
2902 correct = check_error(__LINE__, cli, ERRDOS, ERRbadshare,
2903 NT_STATUS_SHARING_VIOLATION);
2904 }
2905
2906 cli_close(cli, fnum);
2907 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2908
2909 if (!torture_close_connection(cli)) {
2910 correct = False;
2911 }
2912
2913 printf("unlink test finished\n");
2914
2915 return correct;
2916 }
2917
2918
2919 /*
2920 test how many open files this server supports on the one socket
2921 */
2922 static bool run_maxfidtest(int dummy)
2923 {
2924 struct cli_state *cli;
2925 fstring fname;
2926 uint16_t fnums[0x11000];
2927 int i;
2928 int retries=4;
2929 bool correct = True;
2930 NTSTATUS status;
2931
2932 cli = current_cli;
2933
2934 if (retries <= 0) {
2935 printf("failed to connect\n");
2936 return False;
2937 }
2938
2939 cli_sockopt(cli, sockops);
2940
2941 for (i=0; i<0x11000; i++) {
2942 slprintf(fname,sizeof(fname)-1,"\\maxfid.%d.%d", i,(int)getpid());
2943 status = cli_open(cli, fname, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE,
2944 &fnums[i]);
2945 if (!NT_STATUS_IS_OK(status)) {
2946 printf("open of %s failed (%s)\n",
2947 fname, nt_errstr(status));
2948 printf("maximum fnum is %d\n", i);
2949 break;
2950 }
2951 printf("%6d\r", i);
2952 }
2953 printf("%6d\n", i);
2954 i--;
2955
2956 printf("cleaning up\n");
2957 for (;i>=0;i--) {
2958 slprintf(fname,sizeof(fname)-1,"\\maxfid.%d.%d", i,(int)getpid());
2959 cli_close(cli, fnums[i]);
2960
2961 status = cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2962 if (!NT_STATUS_IS_OK(status)) {
2963 printf("unlink of %s failed (%s)\n",
2964 fname, nt_errstr(status));
2965 correct = False;
2966 }
2967 printf("%6d\r", i);
2968 }
2969 printf("%6d\n", 0);
2970
2971 printf("maxfid test finished\n");
2972 if (!torture_close_connection(cli)) {
2973 correct = False;
2974 }
2975 return correct;
2976 }
2977
2978 /* generate a random buffer */
2979 static void rand_buf(char *buf, int len)
2980 {
2981 while (len--) {
2982 *buf = (char)sys_random();
2983 buf++;
2984 }
2985 }
2986
2987 /* send smb negprot commands, not reading the response */
2988 static bool run_negprot_nowait(int dummy)
2989 {
2990 struct tevent_context *ev;
2991 int i;
2992 struct cli_state *cli;
2993 bool correct = True;
2994
2995 printf("starting negprot nowait test\n");
2996
2997 ev = tevent_context_init(talloc_tos());
2998 if (ev == NULL) {
2999 return false;
3000 }
3001
3002 if (!(cli = open_nbt_connection())) {
3003 TALLOC_FREE(ev);
3004 return False;
3005 }
3006
3007 for (i=0;i<50000;i++) {
3008 struct tevent_req *req;
3009
3010 req = cli_negprot_send(ev, ev, cli);
3011 if (req == NULL) {
3012 TALLOC_FREE(ev);
3013 return false;
3014 }
3015 if (!tevent_req_poll(req, ev)) {
3016 d_fprintf(stderr, "tevent_req_poll failed: %s\n",
3017 strerror(errno));
3018 TALLOC_FREE(ev);
3019 return false;
3020 }
3021 TALLOC_FREE(req);
3022 }
3023
3024 if (torture_close_connection(cli)) {
3025 correct = False;
3026 }
3027
3028 printf("finished negprot nowait test\n");
3029
3030 return correct;
3031 }
3032
3033 /* send smb negprot commands, not reading the response */
3034 static bool run_bad_nbt_session(int dummy)
3035 {
3036 struct nmb_name called, calling;
3037 struct sockaddr_storage ss;
3038 NTSTATUS status;
3039 int fd;
3040 bool ret;
3041
3042 printf("starting bad nbt session test\n");
3043
3044 make_nmb_name(&calling, myname, 0x0);
3045 make_nmb_name(&called , host, 0x20);
3046
3047 if (!resolve_name(host, &ss, 0x20, true)) {
3048 d_fprintf(stderr, "Could not resolve name %s\n", host);
3049 return false;
3050 }
3051
3052 status = open_socket_out(&ss, 139, 10000, &fd);
3053 if (!NT_STATUS_IS_OK(status)) {
3054 d_fprintf(stderr, "open_socket_out failed: %s\n",
3055 nt_errstr(status));
3056 return false;
3057 }
3058
3059 ret = cli_bad_session_request(fd, &calling, &called);
3060 close(fd);
3061 if (!ret) {
3062 d_fprintf(stderr, "open_socket_out failed: %s\n",
3063 nt_errstr(status));
3064 return false;
3065 }
3066
3067 printf("finished bad nbt session test\n");
3068 return true;
3069 }
3070
3071 /* send random IPC commands */
3072 static bool run_randomipc(int dummy)
3073 {
3074 char *rparam = NULL;
3075 char *rdata = NULL;
3076 unsigned int rdrcnt,rprcnt;
3077 char param[1024];
3078 int api, param_len, i;
3079 struct cli_state *cli;
3080 bool correct = True;
3081 int count = 50000;
3082
3083 printf("starting random ipc test\n");
3084
3085 if (!torture_open_connection(&cli, 0)) {
3086 return False;
3087 }
3088
3089 for (i=0;i<count;i++) {
3090 api = sys_random() % 500;
3091 param_len = (sys_random() % 64);
3092
3093 rand_buf(param, param_len);
3094
3095 SSVAL(param,0,api);
3096
3097 cli_api(cli,
3098 param, param_len, 8,
3099 NULL, 0, BUFFER_SIZE,
3100 &rparam, &rprcnt,
3101 &rdata, &rdrcnt);
3102 if (i % 100 == 0) {
3103 printf("%d/%d\r", i,count);
3104 }
3105 }
3106 printf("%d/%d\n", i, count);
3107
3108 if (!torture_close_connection(cli)) {
3109 correct = False;
3110 }
3111
3112 printf("finished random ipc test\n");
3113
3114 return correct;
3115 }
3116
3117
3118
3119 static void browse_callback(const char *sname, uint32 stype,
3120 const char *comment, void *state)
3121 {
3122 printf("\t%20.20s %08x %s\n", sname, stype, comment);
3123 }
3124
3125
3126
3127 /*
3128 This test checks the browse list code
3129
3130 */
3131 static bool run_browsetest(int dummy)
3132 {
3133 static struct cli_state *cli;
3134 bool correct = True;
3135
3136 printf("starting browse test\n");
3137
3138 if (!torture_open_connection(&cli, 0)) {
3139 return False;
3140 }
3141
3142 printf("domain list:\n");
3143 cli_NetServerEnum(cli, cli->server_domain,
3144 SV_TYPE_DOMAIN_ENUM,
3145 browse_callback, NULL);
3146
3147 printf("machine list:\n");
3148 cli_NetServerEnum(cli, cli->server_domain,
3149 SV_TYPE_ALL,
3150 browse_callback, NULL);
3151
3152 if (!torture_close_connection(cli)) {
3153 correct = False;
3154 }
3155
3156 printf("browse test finished\n");
3157
3158 return correct;
3159
3160 }
3161
3162
3163 /*
3164 This checks how the getatr calls works
3165 */
3166 static bool run_attrtest(int dummy)
3167 {
3168 struct cli_state *cli;
3169 uint16_t fnum;
3170 time_t t, t2;
3171 const char *fname = "\\attrib123456789.tst";
3172 bool correct = True;
3173 NTSTATUS status;
3174
3175 printf("starting attrib test\n");
3176
3177 if (!torture_open_connection(&cli, 0)) {
3178 return False;
3179 }
3180
3181 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3182 cli_open(cli, fname,
3183 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3184 cli_close(cli, fnum);
3185
3186 status = cli_getatr(cli, fname, NULL, NULL, &t);
3187 if (!NT_STATUS_IS_OK(status)) {
3188 printf("getatr failed (%s)\n", nt_errstr(status));
3189 correct = False;
3190 }
3191
3192 if (abs(t - time(NULL)) > 60*60*24*10) {
3193 printf("ERROR: SMBgetatr bug. time is %s",
3194 ctime(&t));
3195 t = time(NULL);
3196 correct = True;
3197 }
3198
3199 t2 = t-60*60*24; /* 1 day ago */
3200
3201 status = cli_setatr(cli, fname, 0, t2);
3202 if (!NT_STATUS_IS_OK(status)) {
3203 printf("setatr failed (%s)\n", nt_errstr(status));
3204 correct = True;
3205 }
3206
3207 status = cli_getatr(cli, fname, NULL, NULL, &t);
3208 if (!NT_STATUS_IS_OK(status)) {
3209 printf("getatr failed (%s)\n", nt_errstr(status));
3210 correct = True;
3211 }
3212
3213 if (t != t2) {
3214 printf("ERROR: getatr/setatr bug. times are\n%s",
3215 ctime(&t));
3216 printf("%s", ctime(&t2));
3217 correct = True;
3218 }
3219
3220 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3221
3222 if (!torture_close_connection(cli)) {
3223 correct = False;
3224 }
3225
3226 printf("attrib test finished\n");
3227
3228 return correct;
3229 }
3230
3231
3232 /*
3233 This checks a couple of trans2 calls
3234 */
3235 static bool run_trans2test(int dummy)
3236 {
3237 struct cli_state *cli;
3238 uint16_t fnum;
3239 SMB_OFF_T size;
3240 time_t c_time, a_time, m_time;
3241 struct timespec c_time_ts, a_time_ts, m_time_ts, w_time_ts, m_time2_ts;
3242 const char *fname = "\\trans2.tst";
3243 const char *dname = "\\trans2";
3244 const char *fname2 = "\\trans2\\trans2.tst";
3245 char *pname;
3246 bool correct = True;
3247 NTSTATUS status;
3248 uint32_t fs_attr;
3249
3250 printf("starting trans2 test\n");
3251
3252 if (!torture_open_connection(&cli, 0)) {
3253 return False;
3254 }
3255
3256 status = cli_get_fs_attr_info(cli, &fs_attr);
3257 if (!NT_STATUS_IS_OK(status)) {
3258 printf("ERROR: cli_get_fs_attr_info returned %s\n",
3259 nt_errstr(status));
3260 correct = false;
3261 }
3262
3263 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3264 cli_open(cli, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3265 status = cli_qfileinfo_basic(cli, fnum, NULL, &size, &c_time_ts,
3266 &a_time_ts, &w_time_ts, &m_time_ts, NULL);
3267 if (!NT_STATUS_IS_OK(status)) {
3268 printf("ERROR: qfileinfo failed (%s)\n", nt_errstr(status));
3269 correct = False;
3270 }
3271
3272 status = cli_qfilename(cli, fnum, talloc_tos(), &pname);
3273 if (!NT_STATUS_IS_OK(status)) {
3274 printf("ERROR: qfilename failed (%s)\n", nt_errstr(status));
3275 correct = False;
3276 }
3277
3278 if (strcmp(pname, fname)) {
3279 printf("qfilename gave different name? [%s] [%s]\n",
3280 fname, pname);
3281 correct = False;
3282 }
3283
3284 cli_close(cli, fnum);
3285
3286 sleep(2);
3287
3288 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3289 status = cli_open(cli, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE,
3290 &fnum);
3291 if (!NT_STATUS_IS_OK(status)) {
3292 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3293 return False;
3294 }
3295 cli_close(cli, fnum);
3296
3297 status = cli_qpathinfo1(cli, fname, &c_time, &a_time, &m_time, &size,
3298 NULL);
3299 if (!NT_STATUS_IS_OK(status)) {
3300 printf("ERROR: qpathinfo failed (%s)\n", nt_errstr(status));
3301 correct = False;
3302 } else {
3303 if (c_time != m_time) {
3304 printf("create time=%s", ctime(&c_time));
3305 printf("modify time=%s", ctime(&m_time));
3306 printf("This system appears to have sticky create times\n");
3307 }
3308 if (a_time % (60*60) == 0) {
3309 printf("access time=%s", ctime(&a_time));
3310 printf("This system appears to set a midnight access time\n");
3311 correct = False;
3312 }
3313
3314 if (abs(m_time - time(NULL)) > 60*60*24*7) {
3315 printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
3316 correct = False;
3317 }
3318 }
3319
3320
3321 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3322 cli_open(cli, fname,
3323 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3324 cli_close(cli, fnum);
3325 status = cli_qpathinfo2(cli, fname, &c_time_ts, &a_time_ts, &w_time_ts,
3326 &m_time_ts, &size, NULL, NULL);
3327 if (!NT_STATUS_IS_OK(status)) {
3328 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
3329 correct = False;
3330 } else {
3331 if (w_time_ts.tv_sec < 60*60*24*2) {
3332 printf("write time=%s", ctime(&w_time_ts.tv_sec));
3333 printf("This system appears to set a initial 0 write time\n");
3334 correct = False;
3335 }
3336 }
3337
3338 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3339
3340
3341 /* check if the server updates the directory modification time
3342 when creating a new file */
3343 status = cli_mkdir(cli, dname);
3344 if (!NT_STATUS_IS_OK(status)) {
3345 printf("ERROR: mkdir failed (%s)\n", nt_errstr(status));
3346 correct = False;
3347 }
3348 sleep(3);
3349 status = cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts,
3350 &w_time_ts, &m_time_ts, &size, NULL, NULL);
3351 if (!NT_STATUS_IS_OK(status)) {
3352 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
3353 correct = False;
3354 }
3355
3356 cli_open(cli, fname2,
3357 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3358 cli_writeall(cli, fnum, 0, (uint8_t *)&fnum, 0, sizeof(fnum), NULL);
3359 cli_close(cli, fnum);
3360 status = cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts,
3361 &w_time_ts, &m_time2_ts, &size, NULL, NULL);
3362 if (!NT_STATUS_IS_OK(status)) {
3363 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
3364 correct = False;
3365 } else {
3366 if (memcmp(&m_time_ts, &m_time2_ts, sizeof(struct timespec))
3367 == 0) {
3368 printf("This system does not update directory modification times\n");
3369 correct = False;
3370 }
3371 }
3372 cli_unlink(cli, fname2, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3373 cli_rmdir(cli, dname);
3374
3375 if (!torture_close_connection(cli)) {
3376 correct = False;
3377 }
3378
3379 printf("trans2 test finished\n");
3380
3381 return correct;
3382 }
3383
3384 /*
3385 This checks new W2K calls.
3386 */
3387
3388 static NTSTATUS new_trans(struct cli_state *pcli, int fnum, int level)
3389 {
3390 uint8_t *buf = NULL;
3391 uint32 len;
3392 NTSTATUS status;
3393
3394 status = cli_qfileinfo(talloc_tos(), pcli, fnum, level, 0,
3395 pcli->max_xmit, NULL, &buf, &len);
3396 if (!NT_STATUS_IS_OK(status)) {
3397 printf("ERROR: qfileinfo (%d) failed (%s)\n", level,
3398 nt_errstr(status));
3399 } else {
3400 printf("qfileinfo: level %d, len = %u\n", level, len);
3401 dump_data(0, (uint8 *)buf, len);
3402 printf("\n");
3403 }
3404 TALLOC_FREE(buf);
3405 return status;
3406 }
3407
3408 static bool run_w2ktest(int dummy)
3409 {
3410 struct cli_state *cli;
3411 uint16_t fnum;
3412 const char *fname = "\\w2ktest\\w2k.tst";
3413 int level;
3414 bool correct = True;
3415
3416 printf("starting w2k test\n");
3417
3418 if (!torture_open_connection(&cli, 0)) {
3419 return False;
3420 }
3421
3422 cli_open(cli, fname,
3423 O_RDWR | O_CREAT , DENY_NONE, &fnum);
3424
3425 for (level = 1004; level < 1040; level++) {
3426 new_trans(cli, fnum, level);
3427 }
3428
3429 cli_close(cli, fnum);
3430
3431 if (!torture_close_connection(cli)) {
3432 correct = False;
3433 }
3434
3435 printf("w2k test finished\n");
3436
3437 return correct;
3438 }
3439
3440
3441 /*
3442 this is a harness for some oplock tests
3443 */
3444 static bool run_oplock1(int dummy)
3445 {
3446 struct cli_state *cli1;
3447 const char *fname = "\\lockt1.lck";
3448 uint16_t fnum1;
3449 bool correct = True;
3450 NTSTATUS status;
3451
3452 printf("starting oplock test 1\n");
3453
3454 if (!torture_open_connection(&cli1, 0)) {
3455 return False;
3456 }
3457
3458 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3459
3460 cli_sockopt(cli1, sockops);
3461
3462 cli1->use_oplocks = True;
3463
3464 status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
3465 &fnum1);
3466 if (!NT_STATUS_IS_OK(status)) {
3467 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3468 return False;
3469 }
3470
3471 cli1->use_oplocks = False;
3472
3473 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3474 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3475
3476 status = cli_close(cli1, fnum1);
3477 if (!NT_STATUS_IS_OK(status)) {
3478 printf("close2 failed (%s)\n", nt_errstr(status));
3479 return False;
3480 }
3481
3482 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3483 if (!NT_STATUS_IS_OK(status)) {
3484 printf("unlink failed (%s)\n", nt_errstr(status));
3485 return False;
3486 }
3487
3488 if (!torture_close_connection(cli1)) {
3489 correct = False;
3490 }
3491
3492 printf("finished oplock test 1\n");
3493
3494 return correct;
3495 }
3496
3497 static bool run_oplock2(int dummy)
3498 {
3499 struct cli_state *cli1, *cli2;
3500 const char *fname = "\\lockt2.lck";
3501 uint16_t fnum1, fnum2;
3502 int saved_use_oplocks = use_oplocks;
3503 char buf[4];
3504 bool correct = True;
3505 volatile bool *shared_correct;
3506 NTSTATUS status;
3507
3508 shared_correct = (volatile bool *)shm_setup(sizeof(bool));
3509 *shared_correct = True;
3510
3511 use_level_II_oplocks = True;
3512 use_oplocks = True;
3513
3514 printf("starting oplock test 2\n");
3515
3516 if (!torture_open_connection(&cli1, 0)) {
3517 use_level_II_oplocks = False;
3518 use_oplocks = saved_use_oplocks;
3519 return False;
3520 }
3521
3522 cli1->use_oplocks = True;
3523 cli1->use_level_II_oplocks = True;
3524
3525 if (!torture_open_connection(&cli2, 1)) {
3526 use_level_II_oplocks = False;
3527 use_oplocks = saved_use_oplocks;
3528 return False;
3529 }
3530
3531 cli2->use_oplocks = True;
3532 cli2->use_level_II_oplocks = True;
3533
3534 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3535
3536 cli_sockopt(cli1, sockops);
3537 cli_sockopt(cli2, sockops);
3538
3539 status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
3540 &fnum1);
3541 if (!NT_STATUS_IS_OK(status)) {
3542 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3543 return False;
3544 }
3545
3546 /* Don't need the globals any more. */
3547 use_level_II_oplocks = False;
3548 use_oplocks = saved_use_oplocks;
3549
3550 if (fork() == 0) {
3551 /* Child code */
3552 status = cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
3553 if (!NT_STATUS_IS_OK(status)) {
3554 printf("second open of %s failed (%s)\n", fname, nt_errstr(status));
3555 *shared_correct = False;
3556 exit(0);
3557 }
3558
3559 sleep(2);
3560
3561 status = cli_close(cli2, fnum2);
3562 if (!NT_STATUS_IS_OK(status)) {
3563 printf("close2 failed (%s)\n", nt_errstr(status));
3564 *shared_correct = False;
3565 }
3566
3567 exit(0);
3568 }
3569
3570 sleep(2);
3571
3572 /* Ensure cli1 processes the break. Empty file should always return 0
3573 * bytes. */
3574
3575 if (cli_read_old(cli1, fnum1, buf, 0, 4) != 0) {
3576 printf("read on fnum1 failed (%s)\n", cli_errstr(cli1));
3577 correct = False;
3578 }
3579
3580 /* Should now be at level II. */
3581 /* Test if sending a write locks causes a break to none. */
3582 status = cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK);
3583 if (!NT_STATUS_IS_OK(status)) {
3584 printf("lock failed (%s)\n", nt_errstr(status));
3585 correct = False;
3586 }
3587
3588 cli_unlock(cli1, fnum1, 0, 4);
3589
3590 sleep(2);
3591
3592 status = cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK);
3593 if (!NT_STATUS_IS_OK(status)) {
3594 printf("lock failed (%s)\n", nt_errstr(status));
3595 correct = False;
3596 }
3597
3598 cli_unlock(cli1, fnum1, 0, 4);
3599
3600 sleep(2);
3601
3602 cli_read_old(cli1, fnum1, buf, 0, 4);
3603
3604 status = cli_close(cli1, fnum1);
3605 if (!NT_STATUS_IS_OK(status)) {
3606 printf("close1 failed (%s)\n", nt_errstr(status));
3607 correct = False;
3608 }
3609
3610 sleep(4);
3611
3612 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3613 if (!NT_STATUS_IS_OK(status)) {
3614 printf("unlink failed (%s)\n", nt_errstr(status));
3615 correct = False;
3616 }
3617
3618 if (!torture_close_connection(cli1)) {
3619 correct = False;
3620 }
3621
3622 if (!*shared_correct) {
3623 correct = False;
3624 }
3625
3626 printf("finished oplock test 2\n");
3627
3628 return correct;
3629 }
3630
3631 struct oplock4_state {
3632 struct tevent_context *ev;
3633 struct cli_state *cli;
3634 bool *got_break;
3635 uint16_t *fnum2;
3636 };
3637
3638 static void oplock4_got_break(struct tevent_req *req);
3639 static void oplock4_got_open(struct tevent_req *req);
3640
3641 static bool run_oplock4(int dummy)
3642 {
3643 struct tevent_context *ev;
3644 struct cli_state *cli1, *cli2;
3645 struct tevent_req *oplock_req, *open_req;
3646 const char *fname = "\\lockt4.lck";
3647 const char *fname_ln = "\\lockt4_ln.lck";
3648 uint16_t fnum1, fnum2;
3649 int saved_use_oplocks = use_oplocks;
3650 NTSTATUS status;
3651 bool correct = true;
3652
3653 bool got_break;
3654
3655 struct oplock4_state *state;
3656
3657 printf("starting oplock test 4\n");
3658
3659 if (!torture_open_connection(&cli1, 0)) {
3660 use_level_II_oplocks = false;
3661 use_oplocks = saved_use_oplocks;
3662 return false;
3663 }
3664
3665 if (!torture_open_connection(&cli2, 1)) {
3666 use_level_II_oplocks = false;
3667 use_oplocks = saved_use_oplocks;
3668 return false;
3669 }
3670
3671 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3672 cli_unlink(cli1, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3673
3674 cli_sockopt(cli1, sockops);
3675 cli_sockopt(cli2, sockops);
3676
3677 /* Create the file. */
3678 status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
3679 &fnum1);
3680 if (!NT_STATUS_IS_OK(status)) {
3681 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3682 return false;
3683 }
3684
3685 status = cli_close(cli1, fnum1);
3686 if (!NT_STATUS_IS_OK(status)) {
3687 printf("close1 failed (%s)\n", nt_errstr(status));
3688 return false;
3689 }
3690
3691 /* Now create a hardlink. */
3692 status = cli_nt_hardlink(cli1, fname, fname_ln);
3693 if (!NT_STATUS_IS_OK(status)) {
3694 printf("nt hardlink failed (%s)\n", nt_errstr(status));
3695 return false;
3696 }
3697
3698 /* Prove that opening hardlinks cause deny modes to conflict. */
3699 status = cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum1);
3700 if (!NT_STATUS_IS_OK(status)) {
3701 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3702 return false;
3703 }
3704
3705 status = cli_open(cli1, fname_ln, O_RDWR, DENY_NONE, &fnum2);
3706 if (NT_STATUS_IS_OK(status)) {
3707 printf("open of %s succeeded - should fail with sharing violation.\n",
3708 fname_ln);
3709 return false;
3710 }
3711
3712 if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
3713 printf("open of %s should fail with sharing violation. Got %s\n",
3714 fname_ln, nt_errstr(status));
3715 return false;
3716 }
3717
3718 status = cli_close(cli1, fnum1);
3719 if (!NT_STATUS_IS_OK(status)) {
3720 printf("close1 failed (%s)\n", nt_errstr(status));
3721 return false;
3722 }
3723
3724 cli1->use_oplocks = true;
3725 cli1->use_level_II_oplocks = true;
3726
3727 cli2->use_oplocks = true;
3728 cli2->use_level_II_oplocks = true;
3729
3730 status = cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
3731 if (!NT_STATUS_IS_OK(status)) {
3732 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3733 return false;
3734 }
3735
3736 ev = tevent_context_init(talloc_tos());
3737 if (ev == NULL) {
3738 printf("tevent_req_create failed\n");
3739 return false;
3740 }
3741
3742 state = talloc(ev, struct oplock4_state);
3743 if (state == NULL) {
3744 printf("talloc failed\n");
3745 return false;
3746 }
3747 state->ev = ev;
3748 state->cli = cli1;
3749 state->got_break = &got_break;
3750 state->fnum2 = &fnum2;
3751
3752 oplock_req = cli_smb_oplock_break_waiter_send(
3753 talloc_tos(), ev, cli1);
3754 if (oplock_req == NULL) {
3755 printf("cli_smb_oplock_break_waiter_send failed\n");
3756 return false;
3757 }
3758 tevent_req_set_callback(oplock_req, oplock4_got_break, state);
3759
3760 open_req = cli_open_send(
3761 talloc_tos(), ev, cli2, fname_ln, O_RDWR, DENY_NONE);
3762 if (oplock_req == NULL) {
3763 printf("cli_open_send failed\n");
3764 return false;
3765 }
3766 tevent_req_set_callback(open_req, oplock4_got_open, state);
3767
3768 got_break = false;
3769 fnum2 = 0xffff;
3770
3771 while (!got_break || fnum2 == 0xffff) {
3772 int ret;
3773 ret = tevent_loop_once(ev);
3774 if (ret == -1) {
3775 printf("tevent_loop_once failed: %s\n",
3776 strerror(errno));
3777 return false;
3778 }
3779 }
3780
3781 status = cli_close(cli2, fnum2);
3782 if (!NT_STATUS_IS_OK(status)) {
3783 printf("close2 failed (%s)\n", nt_errstr(status));
3784 correct = false;
3785 }
3786
3787 status = cli_close(cli1, fnum1);
3788 if (!NT_STATUS_IS_OK(status)) {
3789 printf("close1 failed (%s)\n", nt_errstr(status));
3790 correct = false;
3791 }
3792
3793 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3794 if (!NT_STATUS_IS_OK(status)) {
3795 printf("unlink failed (%s)\n", nt_errstr(status));
3796 correct = false;
3797 }
3798
3799 status = cli_unlink(cli1, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3800 if (!NT_STATUS_IS_OK(status)) {
3801 printf("unlink failed (%s)\n", nt_errstr(status));
3802 correct = false;
3803 }
3804
3805 if (!torture_close_connection(cli1)) {
3806 correct = false;
3807 }
3808
3809 if (!got_break) {
3810 correct = false;
3811 }
3812
3813 printf("finished oplock test 4\n");
3814
3815 return correct;
3816 }
3817
3818 static void oplock4_got_break(struct tevent_req *req)
3819 {
3820 struct oplock4_state *state = tevent_req_callback_data(
3821 req, struct oplock4_state);
3822 uint16_t fnum;
3823 uint8_t level;
3824 NTSTATUS status;
3825
3826 status = cli_smb_oplock_break_waiter_recv(req, &fnum, &level);
3827 TALLOC_FREE(req);
3828 if (!NT_STATUS_IS_OK(status)) {
3829 printf("cli_smb_oplock_break_waiter_recv returned %s\n",
3830 nt_errstr(status));
3831 return;
3832 }
3833 *state->got_break = true;
3834
3835 req = cli_oplock_ack_send(state, state->ev, state->cli, fnum,
3836 NO_OPLOCK);
3837 if (req == NULL) {
3838 printf("cli_oplock_ack_send failed\n");
3839 return;
3840 }
3841 }
3842
3843 static void oplock4_got_open(struct tevent_req *req)
3844 {
3845 struct oplock4_state *state = tevent_req_callback_data(
3846 req, struct oplock4_state);
3847 NTSTATUS status;
3848
3849 status = cli_open_recv(req, state->fnum2);
3850 if (!NT_STATUS_IS_OK(status)) {
3851 printf("cli_open_recv returned %s\n", nt_errstr(status));
3852 *state->fnum2 = 0xffff;
3853 }
3854 }
3855
3856 /*
3857 Test delete on close semantics.
3858 */
3859 static bool run_deletetest(int dummy)
3860 {
3861 struct cli_state *cli1 = NULL;
3862 struct cli_state *cli2 = NULL;
3863 const char *fname = "\\delete.file";
3864 uint16_t fnum1 = (uint16_t)-1;
3865 uint16_t fnum2 = (uint16_t)-1;
3866 bool correct = True;
3867 NTSTATUS status;
3868
3869 printf("starting delete test\n");
3870
3871 if (!torture_open_connection(&cli1, 0)) {
3872 return False;
3873 }
3874
3875 cli_sockopt(cli1, sockops);
3876
3877 /* Test 1 - this should delete the file on close. */
3878
3879 cli_setatr(cli1, fname, 0, 0);
3880 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3881
3882 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
3883 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
3884 FILE_DELETE_ON_CLOSE, 0, &fnum1);
3885 if (!NT_STATUS_IS_OK(status)) {
3886 printf("[1] open of %s failed (%s)\n", fname, nt_errstr(status));
3887 correct = False;
3888 goto fail;
3889 }
3890
3891 status = cli_close(cli1, fnum1);
3892 if (!NT_STATUS_IS_OK(status)) {
3893 printf("[1] close failed (%s)\n", nt_errstr(status));
3894 correct = False;
3895 goto fail;
3896 }
3897
3898 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1))) {
3899 printf("[1] open of %s succeeded (should fail)\n", fname);
3900 correct = False;
3901 goto fail;
3902 }
3903
3904 printf("first delete on close test succeeded.\n");
3905
3906 /* Test 2 - this should delete the file on close. */
3907
3908 cli_setatr(cli1, fname, 0, 0);
3909 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3910
3911 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
3912 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
3913 FILE_OVERWRITE_IF, 0, 0, &fnum1);
3914 if (!NT_STATUS_IS_OK(status)) {
3915 printf("[2] open of %s failed (%s)\n", fname, nt_errstr(status));
3916 correct = False;
3917 goto fail;
3918 }
3919
3920 status = cli_nt_delete_on_close(cli1, fnum1, true);
3921 if (!NT_STATUS_IS_OK(status)) {
3922 printf("[2] setting delete_on_close failed (%s)\n", nt_errstr(status));
3923 correct = False;
3924 goto fail;
3925 }
3926
3927 status = cli_close(cli1, fnum1);
3928 if (!NT_STATUS_IS_OK(status)) {
3929 printf("[2] close failed (%s)\n", nt_errstr(status));
3930 correct = False;
3931 goto fail;
3932 }
3933
3934 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3935 printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
3936 status = cli_close(cli1, fnum1);
3937 if (!NT_STATUS_IS_OK(status)) {
3938 printf("[2] close failed (%s)\n", nt_errstr(status));
3939 correct = False;
3940 goto fail;
3941 }
3942 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3943 } else
3944 printf("second delete on close test succeeded.\n");
3945
3946 /* Test 3 - ... */
3947 cli_setatr(cli1, fname, 0, 0);
3948 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3949
3950 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
3951 FILE_ATTRIBUTE_NORMAL,
3952 FILE_SHARE_READ|FILE_SHARE_WRITE,
3953 FILE_OVERWRITE_IF, 0, 0, &fnum1);
3954 if (!NT_STATUS_IS_OK(status)) {
3955 printf("[3] open - 1 of %s failed (%s)\n", fname, nt_errstr(status));
3956 correct = False;
3957 goto fail;
3958 }
3959
3960 /* This should fail with a sharing violation - open for delete is only compatible
3961 with SHARE_DELETE. */
3962
3963 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3964 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0, 0, &fnum2))) {
3965 printf("[3] open - 2 of %s succeeded - should have failed.\n", fname);
3966 correct = False;
3967 goto fail;
3968 }
3969
3970 /* This should succeed. */
3971 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
3972 FILE_ATTRIBUTE_NORMAL,
3973 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3974 FILE_OPEN, 0, 0, &fnum2);
3975 if (!NT_STATUS_IS_OK(status)) {
3976 printf("[3] open - 2 of %s failed (%s)\n", fname, nt_errstr(status));
3977 correct = False;
3978 goto fail;
3979 }
3980
3981 status = cli_nt_delete_on_close(cli1, fnum1, true);
3982 if (!NT_STATUS_IS_OK(status)) {
3983 printf("[3] setting delete_on_close failed (%s)\n", nt_errstr(status));
3984 correct = False;
3985 goto fail;
3986 }
3987
3988 status = cli_close(cli1, fnum1);
3989 if (!NT_STATUS_IS_OK(status)) {
3990 printf("[3] close 1 failed (%s)\n", nt_errstr(status));
3991 correct = False;
3992 goto fail;
3993 }
3994
3995 status = cli_close(cli1, fnum2);
3996 if (!NT_STATUS_IS_OK(status)) {
3997 printf("[3] close 2 failed (%s)\n", nt_errstr(status));
3998 correct = False;
3999 goto fail;
4000 }
4001
4002 /* This should fail - file should no longer be there. */
4003
4004 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
4005 printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
4006 status = cli_close(cli1, fnum1);
4007 if (!NT_STATUS_IS_OK(status)) {
4008 printf("[3] close failed (%s)\n", nt_errstr(status));
4009 }
4010 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4011 correct = False;
4012 goto fail;
4013 } else
4014 printf("third delete on close test succeeded.\n");
4015
4016 /* Test 4 ... */
4017 cli_setatr(cli1, fname, 0, 0);
4018 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4019
4020 status = cli_ntcreate(cli1, fname, 0,
4021 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4022 FILE_ATTRIBUTE_NORMAL,
4023 FILE_SHARE_READ|FILE_SHARE_WRITE,
4024 FILE_OVERWRITE_IF, 0, 0, &fnum1);
4025 if (!NT_STATUS_IS_OK(status)) {
4026 printf("[4] open of %s failed (%s)\n", fname, nt_errstr(status));
4027 correct = False;
4028 goto fail;
4029 }
4030
4031 /* This should succeed. */
4032 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4033 FILE_ATTRIBUTE_NORMAL,
4034 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4035 FILE_OPEN, 0, 0, &fnum2);
4036 if (!NT_STATUS_IS_OK(status)) {
4037 printf("[4] open - 2 of %s failed (%s)\n", fname, nt_errstr(status));
4038 correct = False;
4039 goto fail;
4040 }
4041
4042 status = cli_close(cli1, fnum2);
4043 if (!NT_STATUS_IS_OK(status)) {
4044 printf("[4] close - 1 failed (%s)\n", nt_errstr(status));
4045 correct = False;
4046 goto fail;
4047 }
4048
4049 status = cli_nt_delete_on_close(cli1, fnum1, true);
4050 if (!NT_STATUS_IS_OK(status)) {
4051 printf("[4] setting delete_on_close failed (%s)\n", nt_errstr(status));
4052 correct = False;
4053 goto fail;
4054 }
4055
4056 /* This should fail - no more opens once delete on close set. */
4057 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4058 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4059 FILE_OPEN, 0, 0, &fnum2))) {
4060 printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname );
4061 correct = False;
4062 goto fail;
4063 } else
4064 printf("fourth delete on close test succeeded.\n");
4065
4066 status = cli_close(cli1, fnum1);
4067 if (!NT_STATUS_IS_OK(status)) {
4068 printf("[4] close - 2 failed (%s)\n", nt_errstr(status));
4069 correct = False;
4070 goto fail;
4071 }
4072
4073 /* Test 5 ... */
4074 cli_setatr(cli1, fname, 0, 0);
4075 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4076
4077 status = cli_open(cli1, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum1);
4078 if (!NT_STATUS_IS_OK(status)) {
4079 printf("[5] open of %s failed (%s)\n", fname, nt_errstr(status));
4080 correct = False;
4081 goto fail;
4082 }
4083
4084 /* This should fail - only allowed on NT opens with DELETE access. */
4085
4086 if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
4087 printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
4088 correct = False;
4089 goto fail;
4090 }
4091
4092 status = cli_close(cli1, fnum1);
4093 if (!NT_STATUS_IS_OK(status)) {
4094 printf("[5] close - 2 failed (%s)\n", nt_errstr(status));
4095 correct = False;
4096 goto fail;
4097 }
4098
4099 printf("fifth delete on close test succeeded.\n");
4100
4101 /* Test 6 ... */
4102 cli_setatr(cli1, fname, 0, 0);
4103 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4104
4105 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
4106 FILE_ATTRIBUTE_NORMAL,
4107 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4108 FILE_OVERWRITE_IF, 0, 0, &fnum1);
4109 if (!NT_STATUS_IS_OK(status)) {
4110 printf("[6] open of %s failed (%s)\n", fname,
4111 nt_errstr(status));
4112 correct = False;
4113 goto fail;
4114 }
4115
4116 /* This should fail - only allowed on NT opens with DELETE access. */
4117
4118 if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
4119 printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
4120 correct = False;
4121 goto fail;
4122 }
4123
4124 status = cli_close(cli1, fnum1);
4125 if (!NT_STATUS_IS_OK(status)) {
4126 printf("[6] close - 2 failed (%s)\n", nt_errstr(status));
4127 correct = False;
4128 goto fail;
4129 }
4130
4131 printf("sixth delete on close test succeeded.\n");
4132
4133 /* Test 7 ... */
4134 cli_setatr(cli1, fname, 0, 0);
4135 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4136
4137 status = cli_ntcreate(cli1, fname, 0,
4138 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4139 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
4140 0, 0, &fnum1);
4141 if (!NT_STATUS_IS_OK(status)) {
4142 printf("[7] open of %s failed (%s)\n", fname, nt_errstr(status));
4143 correct = False;
4144 goto fail;
4145 }
4146
4147 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
4148 printf("[7] setting delete_on_close on file failed !\n");
4149 correct = False;
4150 goto fail;
4151 }
4152
4153 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, false))) {
4154 printf("[7] unsetting delete_on_close on file failed !\n");
4155 correct = False;
4156 goto fail;
4157 }
4158
4159 status = cli_close(cli1, fnum1);
4160 if (!NT_STATUS_IS_OK(status)) {
4161 printf("[7] close - 2 failed (%s)\n", nt_errstr(status));
4162 correct = False;
4163 goto fail;
4164 }
4165
4166 /* This next open should succeed - we reset the flag. */
4167 status = cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
4168 if (!NT_STATUS_IS_OK(status)) {
4169 printf("[5] open of %s failed (%s)\n", fname, nt_errstr(status));
4170 correct = False;
4171 goto fail;
4172 }
4173
4174 status = cli_close(cli1, fnum1);
4175 if (!NT_STATUS_IS_OK(status)) {
4176 printf("[7] close - 2 failed (%s)\n", nt_errstr(status));
4177 correct = False;
4178 goto fail;
4179 }
4180
4181 printf("seventh delete on close test succeeded.\n");
4182
4183 /* Test 7 ... */
4184 cli_setatr(cli1, fname, 0, 0);
4185 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4186
4187 if (!torture_open_connection(&cli2, 1)) {
4188 printf("[8] failed to open second connection.\n");
4189 correct = False;
4190 goto fail;
4191 }
4192
4193 cli_sockopt(cli1, sockops);
4194
4195 status = cli_ntcreate(cli1, fname, 0,
4196 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4197 FILE_ATTRIBUTE_NORMAL,
4198 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4199 FILE_OVERWRITE_IF, 0, 0, &fnum1);
4200 if (!NT_STATUS_IS_OK(status)) {
4201 printf("[8] open 1 of %s failed (%s)\n", fname, nt_errstr(status));
4202 correct = False;
4203 goto fail;
4204 }
4205
4206 status = cli_ntcreate(cli2, fname, 0,
4207 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4208 FILE_ATTRIBUTE_NORMAL,
4209 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4210 FILE_OPEN, 0, 0, &fnum2);
4211 if (!NT_STATUS_IS_OK(status)) {
4212 printf("[8] open 2 of %s failed (%s)\n", fname, nt_errstr(status));
4213 correct = False;
4214 goto fail;
4215 }
4216
4217 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
4218 printf("[8] setting delete_on_close on file failed !\n");
4219 correct = False;
4220 goto fail;
4221 }
4222
4223 status = cli_close(cli1, fnum1);
4224 if (!NT_STATUS_IS_OK(status)) {
4225 printf("[8] close - 1 failed (%s)\n", nt_errstr(status));
4226 correct = False;
4227 goto fail;
4228 }
4229
4230 status = cli_close(cli2, fnum2);
4231 if (!NT_STATUS_IS_OK(status)) {
4232 printf("[8] close - 2 failed (%s)\n", nt_errstr(status));
4233 correct = False;
4234 goto fail;
4235 }
4236
4237 /* This should fail.. */
4238 status = cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
4239 if (NT_STATUS_IS_OK(status)) {
4240 printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
4241 goto fail;
4242 correct = False;
4243 } else
4244 printf("eighth delete on close test succeeded.\n");
4245
4246 /* This should fail - we need to set DELETE_ACCESS. */
4247 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,FILE_READ_DATA|FILE_WRITE_DATA,
4248 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
4249 printf("[9] open of %s succeeded should have failed!\n", fname);
4250 correct = False;
4251 goto fail;
4252 }
4253
4254 printf("ninth delete on close test succeeded.\n");
4255
4256 status = cli_ntcreate(cli1, fname, 0,
4257 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4258 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
4259 FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE,
4260 0, &fnum1);
4261 if (!NT_STATUS_IS_OK(status)) {
4262 printf("[10] open of %s failed (%s)\n", fname, nt_errstr(status));
4263 correct = False;
4264 goto fail;
4265 }
4266
4267 /* This should delete the file. */
4268 status = cli_close(cli1, fnum1);
4269 if (!NT_STATUS_IS_OK(status)) {
4270 printf("[10] close failed (%s)\n", nt_errstr(status));
4271 correct = False;
4272 goto fail;
4273 }
4274
4275 /* This should fail.. */
4276 if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
4277 printf("[10] open of %s succeeded should have been deleted on close !\n", fname);
4278 goto fail;
4279 correct = False;
4280 } else
4281 printf("tenth delete on close test succeeded.\n");
4282
4283 cli_setatr(cli1, fname, 0, 0);
4284 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4285
4286 /* What error do we get when attempting to open a read-only file with
4287 delete access ? */
4288
4289 /* Create a readonly file. */
4290 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
4291 FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE,
4292 FILE_OVERWRITE_IF, 0, 0, &fnum1);
4293 if (!NT_STATUS_IS_OK(status)) {
4294 printf("[11] open of %s failed (%s)\n", fname, nt_errstr(status));
4295 correct = False;
4296 goto fail;
4297 }
4298
4299 status = cli_close(cli1, fnum1);
4300 if (!NT_STATUS_IS_OK(status)) {
4301 printf("[11] close failed (%s)\n", nt_errstr(status));
4302 correct = False;
4303 goto fail;
4304 }
4305
4306 /* Now try open for delete access. */
4307 if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES|DELETE_ACCESS,
4308 0, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4309 FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4310 printf("[11] open of %s succeeded should have been denied with ACCESS_DENIED!\n", fname);
4311 cli_close(cli1, fnum1);
4312 goto fail;
4313 correct = False;
4314 } else {
4315 NTSTATUS nterr = cli_nt_error(cli1);
4316 if (!NT_STATUS_EQUAL(nterr,NT_STATUS_ACCESS_DENIED)) {
4317 printf("[11] open of %s should have been denied with ACCESS_DENIED! Got error %s\n", fname, nt_errstr(nterr));
4318 goto fail;
4319 correct = False;
4320 } else {
4321 printf("eleventh delete on close test succeeded.\n");
4322 }
4323 }
4324
4325 printf("finished delete test\n");
4326
4327 fail:
4328 /* FIXME: This will crash if we aborted before cli2 got
4329 * intialized, because these functions don't handle
4330 * uninitialized connections. */
4331
4332 if (fnum1 != (uint16_t)-1) cli_close(cli1, fnum1);
4333 if (fnum2 != (uint16_t)-1) cli_close(cli1, fnum2);
4334 cli_setatr(cli1, fname, 0, 0);
4335 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4336
4337 if (cli1 && !torture_close_connection(cli1)) {
4338 correct = False;
4339 }
4340 if (cli2 && !torture_close_connection(cli2)) {
4341 correct = False;
4342 }
4343 return correct;
4344 }
4345
4346 static bool run_deletetest_ln(int dummy)
4347 {
4348 struct cli_state *cli;
4349 const char *fname = "\\delete1";
4350 const char *fname_ln = "\\delete1_ln";
4351 uint16_t fnum;
4352 uint16_t fnum1;
4353 NTSTATUS status;
4354 bool correct = true;
4355 time_t t;
4356
4357 printf("starting deletetest-ln\n");
4358
4359 if (!torture_open_connection(&cli, 0)) {
4360 return false;
4361 }
4362
4363 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4364 cli_unlink(cli, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4365
4366 cli_sockopt(cli, sockops);
4367
4368 /* Create the file. */
4369 status = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
4370 if (!NT_STATUS_IS_OK(status)) {
4371 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4372 return false;
4373 }
4374
4375 status = cli_close(cli, fnum);
4376 if (!NT_STATUS_IS_OK(status)) {
4377 printf("close1 failed (%s)\n", nt_errstr(status));
4378 return false;
4379 }
4380
4381 /* Now create a hardlink. */
4382 status = cli_nt_hardlink(cli, fname, fname_ln);
4383 if (!NT_STATUS_IS_OK(status)) {
4384 printf("nt hardlink failed (%s)\n", nt_errstr(status));
4385 return false;
4386 }
4387
4388 /* Open the original file. */
4389 status = cli_ntcreate(cli, fname, 0, FILE_READ_DATA,
4390 FILE_ATTRIBUTE_NORMAL,
4391 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4392 FILE_OPEN_IF, 0, 0, &fnum);
4393 if (!NT_STATUS_IS_OK(status)) {
4394 printf("ntcreate of %s failed (%s)\n", fname, nt_errstr(status));
4395 return false;
4396 }
4397
4398 /* Unlink the hard link path. */
4399 status = cli_ntcreate(cli, fname_ln, 0, DELETE_ACCESS,
4400 FILE_ATTRIBUTE_NORMAL,
4401 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4402 FILE_OPEN_IF, 0, 0, &fnum1);
4403 if (!NT_STATUS_IS_OK(status)) {
4404 printf("ntcreate of %s failed (%s)\n", fname_ln, nt_errstr(status));
4405 return false;
4406 }
4407 status = cli_nt_delete_on_close(cli, fnum1, true);
4408 if (!NT_STATUS_IS_OK(status)) {
4409 d_printf("(%s) failed to set delete_on_close %s: %s\n",
4410 __location__, fname_ln, nt_errstr(status));
4411 return false;
4412 }
4413
4414 status = cli_close(cli, fnum1);
4415 if (!NT_STATUS_IS_OK(status)) {
4416 printf("close %s failed (%s)\n",
4417 fname_ln, nt_errstr(status));
4418 return false;
4419 }
4420
4421 status = cli_close(cli, fnum);
4422 if (!NT_STATUS_IS_OK(status)) {
4423 printf("close %s failed (%s)\n",
4424 fname, nt_errstr(status));
4425 return false;
4426 }
4427
4428 /* Ensure the original file is still there. */
4429 status = cli_getatr(cli, fname, NULL, NULL, &t);
4430 if (!NT_STATUS_IS_OK(status)) {
4431 printf("%s getatr on file %s failed (%s)\n",
4432 __location__,
4433 fname,
4434 nt_errstr(status));
4435 correct = False;
4436 }
4437
4438 /* Ensure the link path is gone. */
4439 status = cli_getatr(cli, fname_ln, NULL, NULL, &t);
4440 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
4441 printf("%s, getatr for file %s returned wrong error code %s "
4442 "- should have been deleted\n",
4443 __location__,
4444 fname_ln, nt_errstr(status));
4445 correct = False;
4446 }
4447
4448 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4449 cli_unlink(cli, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4450
4451 if (!torture_close_connection(cli)) {
4452 correct = false;
4453 }
4454
4455 printf("finished deletetest-ln\n");
4456
4457 return correct;
4458 }
4459
4460 /*
4461 print out server properties
4462 */
4463 static bool run_properties(int dummy)
4464 {
4465 struct cli_state *cli;
4466 bool correct = True;
4467
4468 printf("starting properties test\n");
4469
4470 ZERO_STRUCT(cli);
4471
4472 if (!torture_open_connection(&cli, 0)) {
4473 return False;
4474 }
4475
4476 cli_sockopt(cli, sockops);
4477
4478 d_printf("Capabilities 0x%08x\n", cli->capabilities);
4479
4480 if (!torture_close_connection(cli)) {
4481 correct = False;
4482 }
4483
4484 return correct;
4485 }
4486
4487
4488
4489 /* FIRST_DESIRED_ACCESS 0xf019f */
4490 #define FIRST_DESIRED_ACCESS FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\
4491 FILE_READ_EA| /* 0xf */ \
4492 FILE_WRITE_EA|FILE_READ_ATTRIBUTES| /* 0x90 */ \
4493 FILE_WRITE_ATTRIBUTES| /* 0x100 */ \
4494 DELETE_ACCESS|READ_CONTROL_ACCESS|\
4495 WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS /* 0xf0000 */
4496 /* SECOND_DESIRED_ACCESS 0xe0080 */
4497 #define SECOND_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
4498 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
4499 WRITE_OWNER_ACCESS /* 0xe0000 */
4500
4501 #if 0
4502 #define THIRD_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
4503 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
4504 FILE_READ_DATA|\
4505 WRITE_OWNER_ACCESS /* */
4506 #endif
4507
4508 /*
4509 Test ntcreate calls made by xcopy
4510 */
4511 static bool run_xcopy(int dummy)
4512 {
4513 static struct cli_state *cli1;
4514 const char *fname = "\\test.txt";
4515 bool correct = True;
4516 uint16_t fnum1, fnum2;
4517 NTSTATUS status;
4518
4519 printf("starting xcopy test\n");
4520
4521 if (!torture_open_connection(&cli1, 0)) {
4522 return False;
4523 }
4524
4525 status = cli_ntcreate(cli1, fname, 0, FIRST_DESIRED_ACCESS,
4526 FILE_ATTRIBUTE_ARCHIVE, FILE_SHARE_NONE,
4527 FILE_OVERWRITE_IF, 0x4044, 0, &fnum1);
4528 if (!NT_STATUS_IS_OK(status)) {
4529 printf("First open failed - %s\n", nt_errstr(status));
4530 return False;
4531 }
4532
4533 status = cli_ntcreate(cli1, fname, 0, SECOND_DESIRED_ACCESS, 0,
4534 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4535 FILE_OPEN, 0x200000, 0, &fnum2);
4536 if (!NT_STATUS_IS_OK(status)) {
4537 printf("second open failed - %s\n", nt_errstr(status));
4538 return False;
4539 }
4540
4541 if (!torture_close_connection(cli1)) {
4542 correct = False;
4543 }
4544
4545 return correct;
4546 }
4547
4548 /*
4549 Test rename on files open with share delete and no share delete.
4550 */
4551 static bool run_rename(int dummy)
4552 {
4553 static struct cli_state *cli1;
4554 const char *fname = "\\test.txt";
4555 const char *fname1 = "\\test1.txt";
4556 bool correct = True;
4557 uint16_t fnum1;
4558 uint16_t attr;
4559 NTSTATUS status;
4560
4561 printf("starting rename test\n");
4562
4563 if (!torture_open_connection(&cli1, 0)) {
4564 return False;
4565 }
4566
4567 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4568 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4569
4570 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4571 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
4572 FILE_OVERWRITE_IF, 0, 0, &fnum1);
4573 if (!NT_STATUS_IS_OK(status)) {
4574 printf("First open failed - %s\n", nt_errstr(status));
4575 return False;
4576 }
4577
4578 status = cli_rename(cli1, fname, fname1);
4579 if (!NT_STATUS_IS_OK(status)) {
4580 printf("First rename failed (SHARE_READ) (this is correct) - %s\n", nt_errstr(status));
4581 } else {
4582 printf("First rename succeeded (SHARE_READ) - this should have failed !\n");
4583 correct = False;
4584 }
4585
4586 status = cli_close(cli1, fnum1);
4587 if (!NT_STATUS_IS_OK(status)) {
4588 printf("close - 1 failed (%s)\n", nt_errstr(status));
4589 return False;
4590 }
4591
4592 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4593 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4594 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4595 #if 0
4596 FILE_SHARE_DELETE|FILE_SHARE_NONE,
4597 #else
4598 FILE_SHARE_DELETE|FILE_SHARE_READ,
4599 #endif
4600 FILE_OVERWRITE_IF, 0, 0, &fnum1);
4601 if (!NT_STATUS_IS_OK(status)) {
4602 printf("Second open failed - %s\n", nt_errstr(status));
4603 return False;
4604 }
4605
4606 status = cli_rename(cli1, fname, fname1);
4607 if (!NT_STATUS_IS_OK(status)) {
4608 printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", nt_errstr(status));
4609 correct = False;
4610 } else {
4611 printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n");
4612 }
4613
4614 status = cli_close(cli1, fnum1);
4615 if (!NT_STATUS_IS_OK(status)) {
4616 printf("close - 2 failed (%s)\n", nt_errstr(status));
4617 return False;
4618 }
4619
4620 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4621 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4622
4623 status = cli_ntcreate(cli1, fname, 0, READ_CONTROL_ACCESS,
4624 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
4625 FILE_OVERWRITE_IF, 0, 0, &fnum1);
4626 if (!NT_STATUS_IS_OK(status)) {
4627 printf("Third open failed - %s\n", nt_errstr(status));
4628 return False;
4629 }
4630
4631
4632 #if 0
4633 {
4634 uint16_t fnum2;
4635
4636 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
4637 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
4638 printf("Fourth open failed - %s\n", cli_errstr(cli1));
4639 return False;
4640 }
4641 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum2, true))) {
4642 printf("[8] setting delete_on_close on file failed !\n");
4643 return False;
4644 }
4645
4646 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
4647 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
4648 return False;
4649 }
4650 }
4651 #endif
4652
4653 status = cli_rename(cli1, fname, fname1);
4654 if (!NT_STATUS_IS_OK(status)) {
4655 printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", nt_errstr(status));
4656 correct = False;
4657 } else {
4658 printf("Third rename succeeded (SHARE_NONE)\n");
4659 }
4660
4661 status = cli_close(cli1, fnum1);
4662 if (!NT_STATUS_IS_OK(status)) {
4663 printf("close - 3 failed (%s)\n", nt_errstr(status));
4664 return False;
4665 }
4666
4667 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4668 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4669
4670 /*----*/
4671
4672 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4673 FILE_ATTRIBUTE_NORMAL,
4674 FILE_SHARE_READ | FILE_SHARE_WRITE,
4675 FILE_OVERWRITE_IF, 0, 0, &fnum1);
4676 if (!NT_STATUS_IS_OK(status)) {
4677 printf("Fourth open failed - %s\n", nt_errstr(status));
4678 return False;
4679 }
4680
4681 status = cli_rename(cli1, fname, fname1);
4682 if (!NT_STATUS_IS_OK(status)) {
4683 printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", nt_errstr(status));
4684 } else {
4685 printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n");
4686 correct = False;
4687 }
4688
4689 status = cli_close(cli1, fnum1);
4690 if (!NT_STATUS_IS_OK(status)) {
4691 printf("close - 4 failed (%s)\n", nt_errstr(status));
4692 return False;
4693 }
4694
4695 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4696 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4697
4698 /*--*/
4699
4700 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4701 FILE_ATTRIBUTE_NORMAL,
4702 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
4703 FILE_OVERWRITE_IF, 0, 0, &fnum1);
4704 if (!NT_STATUS_IS_OK(status)) {
4705 printf("Fifth open failed - %s\n", nt_errstr(status));
4706 return False;
4707 }
4708
4709 status = cli_rename(cli1, fname, fname1);
4710 if (!NT_STATUS_IS_OK(status)) {
4711 printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n", nt_errstr(status));
4712 correct = False;
4713 } else {
4714 printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", nt_errstr(status));
4715 }
4716
4717 /*
4718 * Now check if the first name still exists ...
4719 */
4720
4721 /* if (!NT_STATUS_OP(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4722 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
4723 printf("Opening original file after rename of open file fails: %s\n",
4724 cli_errstr(cli1));
4725 }
4726 else {
4727 printf("Opening original file after rename of open file works ...\n");
4728 (void)cli_close(cli1, fnum2);
4729 } */
4730
4731 /*--*/
4732 status = cli_close(cli1, fnum1);
4733 if (!NT_STATUS_IS_OK(status)) {
4734 printf("close - 5 failed (%s)\n", nt_errstr(status));
4735 return False;
4736 }
4737
4738 /* Check that the renamed file has FILE_ATTRIBUTE_ARCHIVE. */
4739 status = cli_getatr(cli1, fname1, &attr, NULL, NULL);
4740 if (!NT_STATUS_IS_OK(status)) {
4741 printf("getatr on file %s failed - %s ! \n",
4742 fname1, nt_errstr(status));
4743 correct = False;
4744 } else {
4745 if (attr != FILE_ATTRIBUTE_ARCHIVE) {
4746 printf("Renamed file %s has wrong attr 0x%x "
4747 "(should be 0x%x)\n",
4748 fname1,
4749 attr,
4750 (unsigned int)FILE_ATTRIBUTE_ARCHIVE);
4751 correct = False;
4752 } else {
4753 printf("Renamed file %s has archive bit set\n", fname1);
4754 }
4755 }
4756
4757 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4758 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4759
4760 if (!torture_close_connection(cli1)) {
4761 correct = False;
4762 }
4763
4764 return correct;
4765 }
4766
4767 static bool run_pipe_number(int dummy)
4768 {
4769 struct cli_state *cli1;
4770 const char *pipe_name = "\\SPOOLSS";
4771 uint16_t fnum;
4772 int num_pipes = 0;
4773 NTSTATUS status;
4774
4775 printf("starting pipenumber test\n");
4776 if (!torture_open_connection(&cli1, 0)) {
4777 return False;
4778 }
4779
4780 cli_sockopt(cli1, sockops);
4781 while(1) {
4782 status = cli_ntcreate(cli1, pipe_name, 0, FILE_READ_DATA,
4783 FILE_ATTRIBUTE_NORMAL,
4784 FILE_SHARE_READ|FILE_SHARE_WRITE,
4785 FILE_OPEN_IF, 0, 0, &fnum);
4786 if (!NT_STATUS_IS_OK(status)) {
4787 printf("Open of pipe %s failed with error (%s)\n", pipe_name, nt_errstr(status));
4788 break;
4789 }
4790 num_pipes++;
4791 printf("\r%6d", num_pipes);
4792 }
4793
4794 printf("pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
4795 torture_close_connection(cli1);
4796 return True;
4797 }
4798
4799 /*
4800 Test open mode returns on read-only files.
4801 */
4802 static bool run_opentest(int dummy)
4803 {
4804 static struct cli_state *cli1;
4805 static struct cli_state *cli2;
4806 const char *fname = "\\readonly.file";
4807 uint16_t fnum1, fnum2;
4808 char buf[20];
4809 SMB_OFF_T fsize;
4810 bool correct = True;
4811 char *tmp_path;
4812 NTSTATUS status;
4813
4814 printf("starting open test\n");
4815
4816 if (!torture_open_connection(&cli1, 0)) {
4817 return False;
4818 }
4819
4820 cli_setatr(cli1, fname, 0, 0);
4821 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4822
4823 cli_sockopt(cli1, sockops);
4824
4825 status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
4826 if (!NT_STATUS_IS_OK(status)) {
4827 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4828 return False;
4829 }
4830
4831 status = cli_close(cli1, fnum1);
4832 if (!NT_STATUS_IS_OK(status)) {
4833 printf("close2 failed (%s)\n", nt_errstr(status));
4834 return False;
4835 }
4836
4837 status = cli_setatr(cli1, fname, FILE_ATTRIBUTE_READONLY, 0);
4838 if (!NT_STATUS_IS_OK(status)) {
4839 printf("cli_setatr failed (%s)\n", nt_errstr(status));
4840 return False;
4841 }
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 ERRnoaccess, not ERRbadshare. */
4850 cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
4851
4852 if (check_error(__LINE__, cli1, ERRDOS, ERRnoaccess,
4853 NT_STATUS_ACCESS_DENIED)) {
4854 printf("correct error code ERRDOS/ERRnoaccess returned\n");
4855 }
4856
4857 printf("finished open test 1\n");
4858
4859 cli_close(cli1, fnum1);
4860
4861 /* Now try not readonly and ensure ERRbadshare is returned. */
4862
4863 cli_setatr(cli1, fname, 0, 0);
4864
4865 status = cli_open(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1);
4866 if (!NT_STATUS_IS_OK(status)) {
4867 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4868 return False;
4869 }
4870
4871 /* This will fail - but the error should be ERRshare. */
4872 cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
4873
4874 if (check_error(__LINE__, cli1, ERRDOS, ERRbadshare,
4875 NT_STATUS_SHARING_VIOLATION)) {
4876 printf("correct error code ERRDOS/ERRbadshare returned\n");
4877 }
4878
4879 status = cli_close(cli1, fnum1);
4880 if (!NT_STATUS_IS_OK(status)) {
4881 printf("close2 failed (%s)\n", nt_errstr(status));
4882 return False;
4883 }
4884
4885 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4886
4887 printf("finished open test 2\n");
4888
4889 /* Test truncate open disposition on file opened for read. */
4890 status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
4891 if (!NT_STATUS_IS_OK(status)) {
4892 printf("(3) open (1) of %s failed (%s)\n", fname, nt_errstr(status));
4893 return False;
4894 }
4895
4896 /* write 20 bytes. */
4897
4898 memset(buf, '\0', 20);
4899
4900 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, 20, NULL);
4901 if (!NT_STATUS_IS_OK(status)) {
4902 printf("write failed (%s)\n", nt_errstr(status));
4903 correct = False;
4904 }
4905
4906 status = cli_close(cli1, fnum1);
4907 if (!NT_STATUS_IS_OK(status)) {
4908 printf("(3) close1 failed (%s)\n", nt_errstr(status));
4909 return False;
4910 }
4911
4912 /* Ensure size == 20. */
4913 status = cli_getatr(cli1, fname, NULL, &fsize, NULL);
4914 if (!NT_STATUS_IS_OK(status)) {
4915 printf("(3) getatr failed (%s)\n", nt_errstr(status));
4916 return False;
4917 }
4918
4919 if (fsize != 20) {
4920 printf("(3) file size != 20\n");
4921 return False;
4922 }
4923
4924 /* Now test if we can truncate a file opened for readonly. */
4925 status = cli_open(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE, &fnum1);
4926 if (!NT_STATUS_IS_OK(status)) {
4927 printf("(3) open (2) of %s failed (%s)\n", fname, nt_errstr(status));
4928 return False;
4929 }
4930
4931 status = cli_close(cli1, fnum1);
4932 if (!NT_STATUS_IS_OK(status)) {
4933 printf("close2 failed (%s)\n", nt_errstr(status));
4934 return False;
4935 }
4936
4937 /* Ensure size == 0. */
4938 status = cli_getatr(cli1, fname, NULL, &fsize, NULL);
4939 if (!NT_STATUS_IS_OK(status)) {
4940 printf("(3) getatr failed (%s)\n", nt_errstr(status));
4941 return False;
4942 }
4943
4944 if (fsize != 0) {
4945 printf("(3) file size != 0\n");
4946 return False;
4947 }
4948 printf("finished open test 3\n");
4949
4950 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4951
4952 printf("Do ctemp tests\n");
4953 status = cli_ctemp(cli1, talloc_tos(), "\\", &fnum1, &tmp_path);
4954 if (!NT_STATUS_IS_OK(status)) {
4955 printf("ctemp failed (%s)\n", nt_errstr(status));
4956 return False;
4957 }
4958
4959 printf("ctemp gave path %s\n", tmp_path);
4960 status = cli_close(cli1, fnum1);
4961 if (!NT_STATUS_IS_OK(status)) {
4962 printf("close of temp failed (%s)\n", nt_errstr(status));
4963 }
4964
4965 status = cli_unlink(cli1, tmp_path, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4966 if (!NT_STATUS_IS_OK(status)) {
4967 printf("unlink of temp failed (%s)\n", nt_errstr(status));
4968 }
4969
4970 /* Test the non-io opens... */
4971
4972 if (!torture_open_connection(&cli2, 1)) {
4973 return False;
4974 }
4975
4976 cli_setatr(cli2, fname, 0, 0);
4977 cli_unlink(cli2, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4978
4979 cli_sockopt(cli2, sockops);
4980
4981 printf("TEST #1 testing 2 non-io opens (no delete)\n");
4982 status = cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES,
4983 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
4984 FILE_OVERWRITE_IF, 0, 0, &fnum1);
4985 if (!NT_STATUS_IS_OK(status)) {
4986 printf("TEST #1 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
4987 return False;
4988 }
4989
4990 status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
4991 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
4992 FILE_OPEN_IF, 0, 0, &fnum2);
4993 if (!NT_STATUS_IS_OK(status)) {
4994 printf("TEST #1 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
4995 return False;
4996 }
4997
4998 status = cli_close(cli1, fnum1);
4999 if (!NT_STATUS_IS_OK(status)) {
5000 printf("TEST #1 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5001 return False;
5002 }
5003
5004 status = cli_close(cli2, fnum2);
5005 if (!NT_STATUS_IS_OK(status)) {
5006 printf("TEST #1 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5007 return False;
5008 }
5009
5010 printf("non-io open test #1 passed.\n");
5011
5012 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5013
5014 printf("TEST #2 testing 2 non-io opens (first with delete)\n");
5015
5016 status = cli_ntcreate(cli1, fname, 0,
5017 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5018 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5019 FILE_OVERWRITE_IF, 0, 0, &fnum1);
5020 if (!NT_STATUS_IS_OK(status)) {
5021 printf("TEST #2 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5022 return False;
5023 }
5024
5025 status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
5026 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5027 FILE_OPEN_IF, 0, 0, &fnum2);
5028 if (!NT_STATUS_IS_OK(status)) {
5029 printf("TEST #2 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5030 return False;
5031 }
5032
5033 status = cli_close(cli1, fnum1);
5034 if (!NT_STATUS_IS_OK(status)) {
5035 printf("TEST #2 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5036 return False;
5037 }
5038
5039 status = cli_close(cli2, fnum2);
5040 if (!NT_STATUS_IS_OK(status)) {
5041 printf("TEST #2 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5042 return False;
5043 }
5044
5045 printf("non-io open test #2 passed.\n");
5046
5047 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5048
5049 printf("TEST #3 testing 2 non-io opens (second with delete)\n");
5050
5051 status = cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES,
5052 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5053 FILE_OVERWRITE_IF, 0, 0, &fnum1);
5054 if (!NT_STATUS_IS_OK(status)) {
5055 printf("TEST #3 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5056 return False;
5057 }
5058
5059 status = cli_ntcreate(cli2, fname, 0,
5060 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5061 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5062 FILE_OPEN_IF, 0, 0, &fnum2);
5063 if (!NT_STATUS_IS_OK(status)) {
5064 printf("TEST #3 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5065 return False;
5066 }
5067
5068 status = cli_close(cli1, fnum1);
5069 if (!NT_STATUS_IS_OK(status)) {
5070 printf("TEST #3 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5071 return False;
5072 }
5073
5074 status = cli_close(cli2, fnum2);
5075 if (!NT_STATUS_IS_OK(status)) {
5076 printf("TEST #3 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5077 return False;
5078 }
5079
5080 printf("non-io open test #3 passed.\n");
5081
5082 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5083
5084 printf("TEST #4 testing 2 non-io opens (both with delete)\n");
5085
5086 status = cli_ntcreate(cli1, fname, 0,
5087 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5088 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5089 FILE_OVERWRITE_IF, 0, 0, &fnum1);
5090 if (!NT_STATUS_IS_OK(status)) {
5091 printf("TEST #4 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5092 return False;
5093 }
5094
5095 status = cli_ntcreate(cli2, fname, 0,
5096 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5097 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5098 FILE_OPEN_IF, 0, 0, &fnum2);
5099 if (NT_STATUS_IS_OK(status)) {
5100 printf("TEST #4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, nt_errstr(status));
5101 return False;
5102 }
5103
5104 printf("TEST #4 open 2 of %s gave %s (correct error should be %s)\n", fname, nt_errstr(status), "sharing violation");
5105
5106 status = cli_close(cli1, fnum1);
5107 if (!NT_STATUS_IS_OK(status)) {
5108 printf("TEST #4 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5109 return False;
5110 }
5111
5112 printf("non-io open test #4 passed.\n");
5113
5114 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5115
5116 printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
5117
5118 status = cli_ntcreate(cli1, fname, 0,
5119 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5120 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE,
5121 FILE_OVERWRITE_IF, 0, 0, &fnum1);
5122 if (!NT_STATUS_IS_OK(status)) {
5123 printf("TEST #5 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5124 return False;
5125 }
5126
5127 status = cli_ntcreate(cli2, fname, 0,
5128 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5129 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE,
5130 FILE_OPEN_IF, 0, 0, &fnum2);
5131 if (!NT_STATUS_IS_OK(status)) {
5132 printf("TEST #5 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5133 return False;
5134 }
5135
5136 status = cli_close(cli1, fnum1);
5137 if (!NT_STATUS_IS_OK(status)) {
5138 printf("TEST #5 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5139 return False;
5140 }
5141
5142 status = cli_close(cli2, fnum2);
5143 if (!NT_STATUS_IS_OK(status)) {
5144 printf("TEST #5 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5145 return False;
5146 }
5147
5148 printf("non-io open test #5 passed.\n");
5149
5150 printf("TEST #6 testing 1 non-io open, one io open\n");
5151
5152 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5153
5154 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA,
5155 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5156 FILE_OVERWRITE_IF, 0, 0, &fnum1);
5157 if (!NT_STATUS_IS_OK(status)) {
5158 printf("TEST #6 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5159 return False;
5160 }
5161
5162 status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
5163 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
5164 FILE_OPEN_IF, 0, 0, &fnum2);
5165 if (!NT_STATUS_IS_OK(status)) {
5166 printf("TEST #6 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5167 return False;
5168 }
5169
5170 status = cli_close(cli1, fnum1);
5171 if (!NT_STATUS_IS_OK(status)) {
5172 printf("TEST #6 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5173 return False;
5174 }
5175
5176 status = cli_close(cli2, fnum2);
5177 if (!NT_STATUS_IS_OK(status)) {
5178 printf("TEST #6 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5179 return False;
5180 }
5181
5182 printf("non-io open test #6 passed.\n");
5183
5184 printf("TEST #7 testing 1 non-io open, one io open with delete\n");
5185
5186 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5187
5188 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA,
5189 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5190 FILE_OVERWRITE_IF, 0, 0, &fnum1);
5191 if (!NT_STATUS_IS_OK(status)) {
5192 printf("TEST #7 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5193 return False;
5194 }
5195
5196 status = cli_ntcreate(cli2, fname, 0,
5197 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5198 FILE_ATTRIBUTE_NORMAL,
5199 FILE_SHARE_READ|FILE_SHARE_DELETE,
5200 FILE_OPEN_IF, 0, 0, &fnum2);
5201 if (NT_STATUS_IS_OK(status)) {
5202 printf("TEST #7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, nt_errstr(status));
5203 return False;
5204 }
5205
5206 printf("TEST #7 open 2 of %s gave %s (correct error should be %s)\n", fname, nt_errstr(status), "sharing violation");
5207
5208 status = cli_close(cli1, fnum1);
5209 if (!NT_STATUS_IS_OK(status)) {
5210 printf("TEST #7 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5211 return False;
5212 }
5213
5214 printf("non-io open test #7 passed.\n");
5215
5216 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5217
5218 printf("TEST #8 testing open without WRITE_ATTRIBUTES, updating close write time.\n");
5219 status = cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA, FILE_ATTRIBUTE_NORMAL,
5220 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5221 FILE_OVERWRITE_IF, 0, 0, &fnum1);
5222 if (!NT_STATUS_IS_OK(status)) {
5223 printf("TEST #8 open of %s failed (%s)\n", fname, nt_errstr(status));
5224 correct = false;
5225 goto out;
5226 }
5227
5228 /* Write to ensure we have to update the file time. */
5229 status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
5230 NULL);
5231 if (!NT_STATUS_IS_OK(status)) {
5232 printf("TEST #8 cli_write failed: %s\n", nt_errstr(status));
5233 correct = false;
5234 goto out;
5235 }
5236
5237 status = cli_close(cli1, fnum1);
5238 if (!NT_STATUS_IS_OK(status)) {
5239 printf("TEST #8 close of %s failed (%s)\n", fname, nt_errstr(status));
5240 correct = false;
5241 }
5242
5243 out:
5244
5245 if (!torture_close_connection(cli1)) {
5246 correct = False;
5247 }
5248 if (!torture_close_connection(cli2)) {
5249 correct = False;
5250 }
5251
5252 return correct;
5253 }
5254
5255 NTSTATUS torture_setup_unix_extensions(struct cli_state *cli)
5256 {
5257 uint16 major, minor;
5258 uint32 caplow, caphigh;
5259 NTSTATUS status;
5260
5261 if (!SERVER_HAS_UNIX_CIFS(cli)) {
5262 printf("Server doesn't support UNIX CIFS extensions.\n");
5263 return NT_STATUS_NOT_SUPPORTED;
5264 }
5265
5266 status = cli_unix_extensions_version(cli, &major, &minor, &caplow,
5267 &caphigh);
5268 if (!NT_STATUS_IS_OK(status)) {
5269 printf("Server didn't return UNIX CIFS extensions: %s\n",
5270 nt_errstr(status));
5271 return status;
5272 }
5273
5274 status = cli_set_unix_extensions_capabilities(cli, major, minor,
5275 caplow, caphigh);
5276 if (!NT_STATUS_IS_OK(status)) {
5277 printf("Server doesn't support setting UNIX CIFS extensions: "
5278 "%s.\n", nt_errstr(status));
5279 return status;
5280 }
5281
5282 return NT_STATUS_OK;
5283 }
5284
5285 /*
5286 Test POSIX open /mkdir calls.
5287 */
5288 static bool run_simple_posix_open_test(int dummy)
5289 {
5290 static struct cli_state *cli1;
5291 const char *fname = "posix:file";
5292 const char *hname = "posix:hlink";
5293 const char *sname = "posix:symlink";
5294 const char *dname = "posix:dir";
5295 char buf[10];
5296 char namebuf[11];
5297 uint16_t fnum1 = (uint16_t)-1;
5298 SMB_STRUCT_STAT sbuf;
5299 bool correct = false;
5300 NTSTATUS status;
5301 size_t nread;
5302
5303 printf("Starting simple POSIX open test\n");
5304
5305 if (!torture_open_connection(&cli1, 0)) {
5306 return false;
5307 }
5308
5309 cli_sockopt(cli1, sockops);
5310
5311 status = torture_setup_unix_extensions(cli1);
5312 if (!NT_STATUS_IS_OK(status)) {
5313 return false;
5314 }
5315
5316 cli_setatr(cli1, fname, 0, 0);
5317 cli_posix_unlink(cli1, fname);
5318 cli_setatr(cli1, dname, 0, 0);
5319 cli_posix_rmdir(cli1, dname);
5320 cli_setatr(cli1, hname, 0, 0);
5321 cli_posix_unlink(cli1, hname);
5322 cli_setatr(cli1, sname, 0, 0);
5323 cli_posix_unlink(cli1, sname);
5324
5325 /* Create a directory. */
5326 status = cli_posix_mkdir(cli1, dname, 0777);
5327 if (!NT_STATUS_IS_OK(status)) {
5328 printf("POSIX mkdir of %s failed (%s)\n", dname, nt_errstr(status));
5329 goto out;
5330 }
5331
5332 status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL,
5333 0600, &fnum1);
5334 if (!NT_STATUS_IS_OK(status)) {
5335 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5336 goto out;
5337 }
5338
5339 /* Test ftruncate - set file size. */
5340 status = cli_ftruncate(cli1, fnum1, 1000);
5341 if (!NT_STATUS_IS_OK(status)) {
5342 printf("ftruncate failed (%s)\n", nt_errstr(status));
5343 goto out;
5344 }
5345
5346 /* Ensure st_size == 1000 */
5347 status = cli_posix_stat(cli1, fname, &sbuf);
5348 if (!NT_STATUS_IS_OK(status)) {
5349 printf("stat failed (%s)\n", nt_errstr(status));
5350 goto out;
5351 }
5352
5353 if (sbuf.st_ex_size != 1000) {
5354 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
5355 goto out;
5356 }
5357
5358 /* Test ftruncate - set file size back to zero. */
5359 status = cli_ftruncate(cli1, fnum1, 0);
5360 if (!NT_STATUS_IS_OK(status)) {
5361 printf("ftruncate failed (%s)\n", nt_errstr(status));
5362 goto out;
5363 }
5364
5365 status = cli_close(cli1, fnum1);
5366 if (!NT_STATUS_IS_OK(status)) {
5367 printf("close failed (%s)\n", nt_errstr(status));
5368 goto out;
5369 }
5370
5371 /* Now open the file again for read only. */
5372 status = cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1);
5373 if (!NT_STATUS_IS_OK(status)) {
5374 printf("POSIX open of %s failed (%s)\n", fname, nt_errstr(status));
5375 goto out;
5376 }
5377
5378 /* Now unlink while open. */
5379 status = cli_posix_unlink(cli1, fname);
5380 if (!NT_STATUS_IS_OK(status)) {
5381 printf("POSIX unlink of %s failed (%s)\n", fname, nt_errstr(status));
5382 goto out;
5383 }
5384
5385 status = cli_close(cli1, fnum1);
5386 if (!NT_STATUS_IS_OK(status)) {
5387 printf("close(2) failed (%s)\n", nt_errstr(status));
5388 goto out;
5389 }
5390
5391 /* Ensure the file has gone. */
5392 status = cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1);
5393 if (NT_STATUS_IS_OK(status)) {
5394 printf("POSIX open of %s succeeded, should have been deleted.\n", fname);
5395 goto out;
5396 }
5397
5398 /* Create again to test open with O_TRUNC. */
5399 status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1);
5400 if (!NT_STATUS_IS_OK(status)) {
5401 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5402 goto out;
5403 }
5404
5405 /* Test ftruncate - set file size. */
5406 status = cli_ftruncate(cli1, fnum1, 1000);
5407 if (!NT_STATUS_IS_OK(status)) {
5408 printf("ftruncate failed (%s)\n", nt_errstr(status));
5409 goto out;
5410 }
5411
5412 /* Ensure st_size == 1000 */
5413 status = cli_posix_stat(cli1, fname, &sbuf);
5414 if (!NT_STATUS_IS_OK(status)) {
5415 printf("stat failed (%s)\n", nt_errstr(status));
5416 goto out;
5417 }
5418
5419 if (sbuf.st_ex_size != 1000) {
5420 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
5421 goto out;
5422 }
5423
5424 status = cli_close(cli1, fnum1);
5425 if (!NT_STATUS_IS_OK(status)) {
5426 printf("close(2) failed (%s)\n", nt_errstr(status));
5427 goto out;
5428 }
5429
5430 /* Re-open with O_TRUNC. */
5431 status = cli_posix_open(cli1, fname, O_WRONLY|O_TRUNC, 0600, &fnum1);
5432 if (!NT_STATUS_IS_OK(status)) {
5433 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5434 goto out;
5435 }
5436
5437 /* Ensure st_size == 0 */
5438 status = cli_posix_stat(cli1, fname, &sbuf);
5439 if (!NT_STATUS_IS_OK(status)) {
5440 printf("stat failed (%s)\n", nt_errstr(status));
5441 goto out;
5442 }
5443
5444 if (sbuf.st_ex_size != 0) {
5445 printf("O_TRUNC - stat size (%u) != 0\n", (unsigned int)sbuf.st_ex_size);
5446 goto out;
5447 }
5448
5449 status = cli_close(cli1, fnum1);
5450 if (!NT_STATUS_IS_OK(status)) {
5451 printf("close failed (%s)\n", nt_errstr(status));
5452 goto out;
5453 }
5454
5455 status = cli_posix_unlink(cli1, fname);
5456 if (!NT_STATUS_IS_OK(status)) {
5457 printf("POSIX unlink of %s failed (%s)\n", fname, nt_errstr(status));
5458 goto out;
5459 }
5460
5461 status = cli_posix_open(cli1, dname, O_RDONLY, 0, &fnum1);
5462 if (!NT_STATUS_IS_OK(status)) {
5463 printf("POSIX open directory O_RDONLY of %s failed (%s)\n",
5464 dname, nt_errstr(status));
5465 goto out;
5466 }
5467
5468 cli_close(cli1, fnum1);
5469
5470 /* What happens when we try and POSIX open a directory for write ? */
5471 status = cli_posix_open(cli1, dname, O_RDWR, 0, &fnum1);
5472 if (NT_STATUS_IS_OK(status)) {
5473 printf("POSIX open of directory %s succeeded, should have failed.\n", fname);
5474 goto out;
5475 } else {
5476 if (!check_both_error(__LINE__, status, ERRDOS, EISDIR,
5477 NT_STATUS_FILE_IS_A_DIRECTORY)) {
5478 goto out;
5479 }
5480 }
5481
5482 /* Create the file. */
5483 status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL,
5484 0600, &fnum1);
5485 if (!NT_STATUS_IS_OK(status)) {
5486 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5487 goto out;
5488 }
5489
5490 /* Write some data into it. */
5491 status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
5492 NULL);
5493 if (!NT_STATUS_IS_OK(status)) {
5494 printf("cli_write failed: %s\n", nt_errstr(status));
5495 goto out;
5496 }
5497
5498 cli_close(cli1, fnum1);
5499
5500 /* Now create a hardlink. */
5501 status = cli_posix_hardlink(cli1, fname, hname);
5502 if (!NT_STATUS_IS_OK(status)) {
5503 printf("POSIX hardlink of %s failed (%s)\n", hname, nt_errstr(status));
5504 goto out;
5505 }
5506
5507 /* Now create a symlink. */
5508 status = cli_posix_symlink(cli1, fname, sname);
5509 if (!NT_STATUS_IS_OK(status)) {
5510 printf("POSIX symlink of %s failed (%s)\n", sname, nt_errstr(status));
5511 goto out;
5512 }
5513
5514 /* Open the hardlink for read. */
5515 status = cli_posix_open(cli1, hname, O_RDONLY, 0, &fnum1);
5516 if (!NT_STATUS_IS_OK(status)) {
5517 printf("POSIX open of %s failed (%s)\n", hname, nt_errstr(status));
5518 goto out;
5519 }
5520
5521 status = cli_read(cli1, fnum1, buf, 0, 10, &nread);
5522 if (!NT_STATUS_IS_OK(status)) {
5523 printf("POSIX read of %s failed (%s)\n", hname,
5524 nt_errstr(status));
5525 goto out;
5526 } else if (nread != 10) {
5527 printf("POSIX read of %s failed. Received %ld, expected %d\n",
5528 hname, (unsigned long)nread, 10);
5529 goto out;
5530 }
5531
5532 if (memcmp(buf, "TEST DATA\n", 10)) {
5533 printf("invalid data read from hardlink\n");
5534 goto out;
5535 }
5536
5537 /* Do a POSIX lock/unlock. */
5538 status = cli_posix_lock(cli1, fnum1, 0, 100, true, READ_LOCK);
5539 if (!NT_STATUS_IS_OK(status)) {
5540 printf("POSIX lock failed %s\n", nt_errstr(status));
5541 goto out;
5542 }
5543
5544 /* Punch a hole in the locked area. */
5545 status = cli_posix_unlock(cli1, fnum1, 10, 80);
5546 if (!NT_STATUS_IS_OK(status)) {
5547 printf("POSIX unlock failed %s\n", nt_errstr(status));
5548 goto out;
5549 }
5550
5551 cli_close(cli1, fnum1);
5552
5553 /* Open the symlink for read - this should fail. A POSIX
5554 client should not be doing opens on a symlink. */
5555 status = cli_posix_open(cli1, sname, O_RDONLY, 0, &fnum1);
5556 if (NT_STATUS_IS_OK(status)) {
5557 printf("POSIX open of %s succeeded (should have failed)\n", sname);
5558 goto out;
5559 } else {
5560 if (!check_both_error(__LINE__, status, ERRDOS, ERRbadpath,
5561 NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
5562 printf("POSIX open of %s should have failed "
5563 "with NT_STATUS_OBJECT_PATH_NOT_FOUND, "
5564 "failed with %s instead.\n",
5565 sname, nt_errstr(status));
5566 goto out;
5567 }
5568 }
5569
5570 status = cli_posix_readlink(cli1, sname, namebuf, sizeof(namebuf));
5571 if (!NT_STATUS_IS_OK(status)) {
5572 printf("POSIX readlink on %s failed (%s)\n", sname, nt_errstr(status));
5573 goto out;
5574 }
5575
5576 if (strcmp(namebuf, fname) != 0) {
5577 printf("POSIX readlink on %s failed to match name %s (read %s)\n",
5578 sname, fname, namebuf);
5579 goto out;
5580 }
5581
5582 status = cli_posix_rmdir(cli1, dname);
5583 if (!NT_STATUS_IS_OK(status)) {
5584 printf("POSIX rmdir failed (%s)\n", nt_errstr(status));
5585 goto out;
5586 }
5587
5588 printf("Simple POSIX open test passed\n");
5589 correct = true;
5590
5591 out:
5592
5593 if (fnum1 != (uint16_t)-1) {
5594 cli_close(cli1, fnum1);
5595 fnum1 = (uint16_t)-1;
5596 }
5597
5598 cli_setatr(cli1, sname, 0, 0);
5599 cli_posix_unlink(cli1, sname);
5600 cli_setatr(cli1, hname, 0, 0);
5601 cli_posix_unlink(cli1, hname);
5602 cli_setatr(cli1, fname, 0, 0);
5603 cli_posix_unlink(cli1, fname);
5604 cli_setatr(cli1, dname, 0, 0);
5605 cli_posix_rmdir(cli1, dname);
5606
5607 if (!torture_close_connection(cli1)) {
5608 correct = false;
5609 }
5610
5611 return correct;
5612 }
5613
5614
5615 static uint32 open_attrs_table[] = {
5616 FILE_ATTRIBUTE_NORMAL,
5617 FILE_ATTRIBUTE_ARCHIVE,
5618 FILE_ATTRIBUTE_READONLY,
5619 FILE_ATTRIBUTE_HIDDEN,
5620 FILE_ATTRIBUTE_SYSTEM,
5621
5622 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY,
5623 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN,
5624 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,
5625 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
5626 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
5627 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
5628
5629 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
5630 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
5631 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
5632 FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM,
5633 };
5634
5635 struct trunc_open_results {
5636 unsigned int num;
5637 uint32 init_attr;
5638 uint32 trunc_attr;
5639 uint32 result_attr;
5640 };
5641
5642 static struct trunc_open_results attr_results[] = {
5643 { 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
5644 { 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
5645 { 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
5646 { 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
5647 { 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
5648 { 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
5649 { 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5650 { 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5651 { 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
5652 { 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5653 { 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5654 { 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
5655 { 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5656 { 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5657 { 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 },
5658 { 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5659 { 119, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5660 { 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 },
5661 { 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 },
5662 { 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 },
5663 { 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5664 { 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5665 { 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
5666 { 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5667 { 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5668 { 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
5669 };
5670
5671 static bool run_openattrtest(int dummy)
5672 {
5673 static struct cli_state *cli1;
5674 const char *fname = "\\openattr.file";
5675 uint16_t fnum1;
5676 bool correct = True;
5677 uint16 attr;
5678 unsigned int i, j, k, l;
5679 NTSTATUS status;
5680
5681 printf("starting open attr test\n");
5682
5683 if (!torture_open_connection(&cli1, 0)) {
5684 return False;
5685 }
5686
5687 cli_sockopt(cli1, sockops);
5688
5689 for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32); i++) {
5690 cli_setatr(cli1, fname, 0, 0);
5691 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5692
5693 status = cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA,
5694 open_attrs_table[i], FILE_SHARE_NONE,
5695 FILE_OVERWRITE_IF, 0, 0, &fnum1);
5696 if (!NT_STATUS_IS_OK(status)) {
5697 printf("open %d (1) of %s failed (%s)\n", i, fname, nt_errstr(status));
5698 return False;
5699 }
5700
5701 status = cli_close(cli1, fnum1);
5702 if (!NT_STATUS_IS_OK(status)) {
5703 printf("close %d (1) of %s failed (%s)\n", i, fname, nt_errstr(status));
5704 return False;
5705 }
5706
5707 for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32); j++) {
5708 status = cli_ntcreate(cli1, fname, 0,
5709 FILE_READ_DATA|FILE_WRITE_DATA,
5710 open_attrs_table[j],
5711 FILE_SHARE_NONE, FILE_OVERWRITE,
5712 0, 0, &fnum1);
5713 if (!NT_STATUS_IS_OK(status)) {
5714 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
5715 if (attr_results[l].num == k) {
5716 printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
5717 k, open_attrs_table[i],
5718 open_attrs_table[j],
5719 fname, NT_STATUS_V(status), nt_errstr(status));
5720 correct = False;
5721 }
5722 }
5723
5724 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
5725 printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n",
5726 k, open_attrs_table[i], open_attrs_table[j],
5727 nt_errstr(status));
5728 correct = False;
5729 }
5730 #if 0
5731 printf("[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]);
5732 #endif
5733 k++;
5734 continue;
5735 }
5736
5737 status = cli_close(cli1, fnum1);
5738 if (!NT_STATUS_IS_OK(status)) {
5739 printf("close %d (2) of %s failed (%s)\n", j, fname, nt_errstr(status));
5740 return False;
5741 }
5742
5743 status = cli_getatr(cli1, fname, &attr, NULL, NULL);
5744 if (!NT_STATUS_IS_OK(status)) {
5745 printf("getatr(2) failed (%s)\n", nt_errstr(status));
5746 return False;
5747 }
5748
5749 #if 0
5750 printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
5751 k, open_attrs_table[i], open_attrs_table[j], attr );
5752 #endif
5753
5754 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
5755 if (attr_results[l].num == k) {
5756 if (attr != attr_results[l].result_attr ||
5757 open_attrs_table[i] != attr_results[l].init_attr ||
5758 open_attrs_table[j] != attr_results[l].trunc_attr) {
5759 printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
5760 open_attrs_table[i],
5761 open_attrs_table[j],
5762 (unsigned int)attr,
5763 attr_results[l].result_attr);
5764 correct = False;
5765 }
5766 break;
5767 }
5768 }
5769 k++;
5770 }
5771 }
5772
5773 cli_setatr(cli1, fname, 0, 0);
5774 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5775
5776 printf("open attr test %s.\n", correct ? "passed" : "failed");
5777
5778 if (!torture_close_connection(cli1)) {
5779 correct = False;
5780 }
5781 return correct;
5782 }
5783
5784 static NTSTATUS list_fn(const char *mnt, struct file_info *finfo,
5785 const char *name, void *state)
5786 {
5787 int *matched = (int *)state;
5788 if (matched != NULL) {
5789 *matched += 1;
5790 }
5791 return NT_STATUS_OK;
5792 }
5793
5794 /*
5795 test directory listing speed
5796 */
5797 static bool run_dirtest(int dummy)
5798 {
5799 int i;
5800 static struct cli_state *cli;
5801 uint16_t fnum;
5802 struct timeval core_start;
5803 bool correct = True;
5804 int matched;
5805
5806 printf("starting directory test\n");
5807
5808 if (!torture_open_connection(&cli, 0)) {
5809 return False;
5810 }
5811
5812 cli_sockopt(cli, sockops);
5813
5814 srandom(0);
5815 for (i=0;i<torture_numops;i++) {
5816 fstring fname;
5817 slprintf(fname, sizeof(fname), "\\%x", (int)random());
5818 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum))) {
5819 fprintf(stderr,"Failed to open %s\n", fname);
5820 return False;
5821 }
5822 cli_close(cli, fnum);
5823 }
5824
5825 core_start = timeval_current();
5826
5827 matched = 0;
5828 cli_list(cli, "a*.*", 0, list_fn, &matched);
5829 printf("Matched %d\n", matched);
5830
5831 matched = 0;
5832 cli_list(cli, "b*.*", 0, list_fn, &matched);
5833 printf("Matched %d\n", matched);
5834
5835 matched = 0;
5836 cli_list(cli, "xyzabc", 0, list_fn, &matched);
5837 printf("Matched %d\n", matched);
5838
5839 printf("dirtest core %g seconds\n", timeval_elapsed(&core_start));
5840
5841 srandom(0);
5842 for (i=0;i<torture_numops;i++) {
5843 fstring fname;
5844 slprintf(fname, sizeof(fname), "\\%x", (int)random());
5845 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5846 }
5847
5848 if (!torture_close_connection(cli)) {
5849 correct = False;
5850 }
5851
5852 printf("finished dirtest\n");
5853
5854 return correct;
5855 }
5856
5857 static NTSTATUS del_fn(const char *mnt, struct file_info *finfo, const char *mask,
5858 void *state)
5859 {
5860 struct cli_state *pcli = (struct cli_state *)state;
5861 fstring fname;
5862 slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name);
5863
5864 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
5865 return NT_STATUS_OK;
5866
5867 if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
5868 if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname)))
5869 printf("del_fn: failed to rmdir %s\n,", fname );
5870 } else {
5871 if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN)))
5872 printf("del_fn: failed to unlink %s\n,", fname );
5873 }
5874 return NT_STATUS_OK;
5875 }
5876
5877
5878 /*
5879 sees what IOCTLs are supported
5880 */
5881 bool torture_ioctl_test(int dummy)
5882 {
5883 static struct cli_state *cli;
5884 uint16_t device, function;
5885 uint16_t fnum;
5886 const char *fname = "\\ioctl.dat";
5887 DATA_BLOB blob;
5888 NTSTATUS status;
5889
5890 if (!torture_open_connection(&cli, 0)) {
5891 return False;
5892 }
5893
5894 printf("starting ioctl test\n");
5895
5896 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5897
5898 status = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
5899 if (!NT_STATUS_IS_OK(status)) {
5900 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
5901 return False;
5902 }
5903
5904 status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob);
5905 printf("ioctl device info: %s\n", nt_errstr(status));
5906
5907 status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob);
5908 printf("ioctl job info: %s\n", nt_errstr(status));
5909
5910 for (device=0;device<0x100;device++) {
5911 printf("ioctl test with device = 0x%x\n", device);
5912 for (function=0;function<0x100;function++) {
5913 uint32 code = (device<<16) | function;
5914
5915 status = cli_raw_ioctl(cli, fnum, code, &blob);
5916
5917 if (NT_STATUS_IS_OK(status)) {
5918 printf("ioctl 0x%x OK : %d bytes\n", (int)code,
5919 (int)blob.length);
5920 data_blob_free(&blob);
5921 }
5922 }
5923 }
5924
5925 if (!torture_close_connection(cli)) {
5926 return False;
5927 }
5928
5929 return True;
5930 }
5931
5932
5933 /*
5934 tries varients of chkpath
5935 */
5936 bool torture_chkpath_test(int dummy)
5937 {
5938 static struct cli_state *cli;
5939 uint16_t fnum;
5940 bool ret;
5941 NTSTATUS status;
5942
5943 if (!torture_open_connection(&cli, 0)) {
5944 return False;
5945 }
5946
5947 printf("starting chkpath test\n");
5948
5949 /* cleanup from an old run */
5950 cli_rmdir(cli, "\\chkpath.dir\\dir2");
5951 cli_unlink(cli, "\\chkpath.dir\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5952 cli_rmdir(cli, "\\chkpath.dir");
5953
5954 status = cli_mkdir(cli, "\\chkpath.dir");
5955 if (!NT_STATUS_IS_OK(status)) {
5956 printf("mkdir1 failed : %s\n", nt_errstr(status));
5957 return False;
5958 }
5959
5960 status = cli_mkdir(cli, "\\chkpath.dir\\dir2");
5961 if (!NT_STATUS_IS_OK(status)) {
5962 printf("mkdir2 failed : %s\n", nt_errstr(status));
5963 return False;
5964 }
5965
5966 status = cli_open(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL,
5967 DENY_NONE, &fnum);
5968 if (!NT_STATUS_IS_OK(status)) {
5969 printf("open1 failed (%s)\n", nt_errstr(status));
5970 return False;
5971 }
5972 cli_close(cli, fnum);
5973
5974 status = cli_chkpath(cli, "\\chkpath.dir");
5975 if (!NT_STATUS_IS_OK(status)) {
5976 printf("chkpath1 failed: %s\n", nt_errstr(status));
5977 ret = False;
5978 }
5979
5980 status = cli_chkpath(cli, "\\chkpath.dir\\dir2");
5981 if (!NT_STATUS_IS_OK(status)) {
5982 printf("chkpath2 failed: %s\n", nt_errstr(status));
5983 ret = False;
5984 }
5985
5986 status = cli_chkpath(cli, "\\chkpath.dir\\foo.txt");
5987 if (!NT_STATUS_IS_OK(status)) {
5988 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
5989 NT_STATUS_NOT_A_DIRECTORY);
5990 } else {
5991 printf("* chkpath on a file should fail\n");
5992 ret = False;
5993 }
5994
5995 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\bar.txt"))) {
5996 ret = check_error(__LINE__, cli, ERRDOS, ERRbadfile,
5997 NT_STATUS_OBJECT_NAME_NOT_FOUND);
5998 } else {
5999 printf("* chkpath on a non existant file should fail\n");
6000 ret = False;
6001 }
6002
6003 if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt"))) {
6004 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
6005 NT_STATUS_OBJECT_PATH_NOT_FOUND);
6006 } else {
6007 printf("* chkpath on a non existent component should fail\n");
6008 ret = False;
6009 }
6010
6011 cli_rmdir(cli, "\\chkpath.dir\\dir2");
6012 cli_unlink(cli, "\\chkpath.dir\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6013 cli_rmdir(cli, "\\chkpath.dir");
6014
6015 if (!torture_close_connection(cli)) {
6016 return False;
6017 }
6018
6019 return ret;
6020 }
6021
6022 static bool run_eatest(int dummy)
6023 {
6024 static struct cli_state *cli;
6025 const char *fname = "\\eatest.txt";
6026 bool correct = True;
6027 uint16_t fnum;
6028 int i;
6029 size_t num_eas;
6030 struct ea_struct *ea_list = NULL;
6031 TALLOC_CTX *mem_ctx = talloc_init("eatest");
6032 NTSTATUS status;
6033
6034 printf("starting eatest\n");
6035
6036 if (!torture_open_connection(&cli, 0)) {
6037 talloc_destroy(mem_ctx);
6038 return False;
6039 }
6040
6041 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6042
6043 status = cli_ntcreate(cli, fname, 0,
6044 FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
6045 FILE_SHARE_NONE, FILE_OVERWRITE_IF,
6046 0x4044, 0, &fnum);
6047 if (!NT_STATUS_IS_OK(status)) {
6048 printf("open failed - %s\n", nt_errstr(status));
6049 talloc_destroy(mem_ctx);
6050 return False;
6051 }
6052
6053 for (i = 0; i < 10; i++) {
6054 fstring ea_name, ea_val;
6055
6056 slprintf(ea_name, sizeof(ea_name), "EA_%d", i);
6057 memset(ea_val, (char)i+1, i+1);
6058 status = cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1);
6059 if (!NT_STATUS_IS_OK(status)) {
6060 printf("ea_set of name %s failed - %s\n", ea_name,
6061 nt_errstr(status));
6062 talloc_destroy(mem_ctx);
6063 return False;
6064 }
6065 }
6066
6067 cli_close(cli, fnum);
6068 for (i = 0; i < 10; i++) {
6069 fstring ea_name, ea_val;
6070
6071 slprintf(ea_name, sizeof(ea_name), "EA_%d", i+10);
6072 memset(ea_val, (char)i+1, i+1);
6073 status = cli_set_ea_path(cli, fname, ea_name, ea_val, i+1);
6074 if (!NT_STATUS_IS_OK(status)) {
6075 printf("ea_set of name %s failed - %s\n", ea_name,
6076 nt_errstr(status));
6077 talloc_destroy(mem_ctx);
6078 return False;
6079 }
6080 }
6081
6082 status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
6083 if (!NT_STATUS_IS_OK(status)) {
6084 printf("ea_get list failed - %s\n", nt_errstr(status));
6085 correct = False;
6086 }
6087
6088 printf("num_eas = %d\n", (int)num_eas);
6089
6090 if (num_eas != 20) {
6091 printf("Should be 20 EA's stored... failing.\n");
6092 correct = False;
6093 }
6094
6095 for (i = 0; i < num_eas; i++) {
6096 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
6097 dump_data(0, ea_list[i].value.data,
6098 ea_list[i].value.length);
6099 }
6100
6101 /* Setting EA's to zero length deletes them. Test this */
6102 printf("Now deleting all EA's - case indepenent....\n");
6103
6104 #if 1
6105 cli_set_ea_path(cli, fname, "", "", 0);
6106 #else
6107 for (i = 0; i < 20; i++) {
6108 fstring ea_name;
6109 slprintf(ea_name, sizeof(ea_name), "ea_%d", i);
6110 status = cli_set_ea_path(cli, fname, ea_name, "", 0);
6111 if (!NT_STATUS_IS_OK(status)) {
6112 printf("ea_set of name %s failed - %s\n", ea_name,
6113 nt_errstr(status));
6114 talloc_destroy(mem_ctx);
6115 return False;
6116 }
6117 }
6118 #endif
6119
6120 status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
6121 if (!NT_STATUS_IS_OK(status)) {
6122 printf("ea_get list failed - %s\n", nt_errstr(status));
6123 correct = False;
6124 }
6125
6126 printf("num_eas = %d\n", (int)num_eas);
6127 for (i = 0; i < num_eas; i++) {
6128 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
6129 dump_data(0, ea_list[i].value.data,
6130 ea_list[i].value.length);
6131 }
6132
6133 if (num_eas != 0) {
6134 printf("deleting EA's failed.\n");
6135 correct = False;
6136 }
6137
6138 /* Try and delete a non existant EA. */
6139 status = cli_set_ea_path(cli, fname, "foo", "", 0);
6140 if (!NT_STATUS_IS_OK(status)) {
6141 printf("deleting non-existant EA 'foo' should succeed. %s\n",
6142 nt_errstr(status));
6143 correct = False;
6144 }
6145
6146 talloc_destroy(mem_ctx);
6147 if (!torture_close_connection(cli)) {
6148 correct = False;
6149 }
6150
6151 return correct;
6152 }
6153
6154 static bool run_dirtest1(int dummy)
6155 {
6156 int i;
6157 static struct cli_state *cli;
6158 uint16_t fnum;
6159 int num_seen;
6160 bool correct = True;
6161
6162 printf("starting directory test\n");
6163
6164 if (!torture_open_connection(&cli, 0)) {
6165 return False;
6166 }
6167
6168 cli_sockopt(cli, sockops);
6169
6170 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
6171 cli_list(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, del_fn, cli);
6172 cli_rmdir(cli, "\\LISTDIR");
6173 cli_mkdir(cli, "\\LISTDIR");
6174
6175 /* Create 1000 files and 1000 directories. */
6176 for (i=0;i<1000;i++) {
6177 fstring fname;
6178 slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i);
6179 if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
6180 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum))) {
6181 fprintf(stderr,"Failed to open %s\n", fname);
6182 return False;
6183 }
6184 cli_close(cli, fnum);
6185 }
6186 for (i=0;i<1000;i++) {
6187 fstring fname;
6188 slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i);
6189 if (!NT_STATUS_IS_OK(cli_mkdir(cli, fname))) {
6190 fprintf(stderr,"Failed to open %s\n", fname);
6191 return False;
6192 }
6193 }
6194
6195 /* Now ensure that doing an old list sees both files and directories. */
6196 num_seen = 0;
6197 cli_list_old(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
6198 printf("num_seen = %d\n", num_seen );
6199 /* We should see 100 files + 1000 directories + . and .. */
6200 if (num_seen != 2002)
6201 correct = False;
6202
6203 /* Ensure if we have the "must have" bits we only see the
6204 * relevent entries.
6205 */
6206 num_seen = 0;
6207 cli_list_old(cli, "\\LISTDIR\\*", (FILE_ATTRIBUTE_DIRECTORY<<8)|FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
6208 printf("num_seen = %d\n", num_seen );
6209 if (num_seen != 1002)
6210 correct = False;
6211
6212 num_seen = 0;
6213 cli_list_old(cli, "\\LISTDIR\\*", (FILE_ATTRIBUTE_ARCHIVE<<8)|FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
6214 printf("num_seen = %d\n", num_seen );
6215 if (num_seen != 1000)
6216 correct = False;
6217
6218 /* Delete everything. */
6219 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
6220 cli_list(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, del_fn, cli);
6221 cli_rmdir(cli, "\\LISTDIR");
6222
6223 #if 0
6224 printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
6225 printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
6226 printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
6227 #endif
6228
6229 if (!torture_close_connection(cli)) {
6230 correct = False;
6231 }
6232
6233 printf("finished dirtest1\n");
6234
6235 return correct;
6236 }
6237
6238 static bool run_error_map_extract(int dummy) {
6239
6240 static struct cli_state *c_dos;
6241 static struct cli_state *c_nt;
6242 NTSTATUS status;
6243
6244 uint32 error;
6245
6246 uint32 errnum;
6247 uint8 errclass;
6248
6249 NTSTATUS nt_status;
6250
6251 fstring user;
6252
6253 /* NT-Error connection */
6254
6255 if (!(c_nt = open_nbt_connection())) {
6256 return False;
6257 }
6258
6259 c_nt->use_spnego = False;
6260
6261 status = cli_negprot(c_nt);
6262
6263 if (!NT_STATUS_IS_OK(status)) {
6264 printf("%s rejected the NT-error negprot (%s)\n", host,
6265 nt_errstr(status));
6266 cli_shutdown(c_nt);
6267 return False;
6268 }
6269
6270 status = cli_session_setup(c_nt, "", "", 0, "", 0, workgroup);
6271 if (!NT_STATUS_IS_OK(status)) {
6272 printf("%s rejected the NT-error initial session setup (%s)\n",host, nt_errstr(status));
6273 return False;
6274 }
6275
6276 /* DOS-Error connection */
6277
6278 if (!(c_dos = open_nbt_connection())) {
6279 return False;
6280 }
6281
6282 c_dos->use_spnego = False;
6283 c_dos->force_dos_errors = True;
6284
6285 status = cli_negprot(c_dos);
6286 if (!NT_STATUS_IS_OK(status)) {
6287 printf("%s rejected the DOS-error negprot (%s)\n", host,
6288 nt_errstr(status));
6289 cli_shutdown(c_dos);
6290 return False;
6291 }
6292
6293 status = cli_session_setup(c_dos, "", "", 0, "", 0, workgroup);
6294 if (!NT_STATUS_IS_OK(status)) {
6295 printf("%s rejected the DOS-error initial session setup (%s)\n",
6296 host, nt_errstr(status));
6297 return False;
6298 }
6299
6300 for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) {
6301 fstr_sprintf(user, "%X", error);
6302
6303 status = cli_session_setup(c_nt, user,
6304 password, strlen(password),
6305 password, strlen(password),
6306 workgroup);
6307 if (NT_STATUS_IS_OK(status)) {
6308 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
6309 }
6310
6311 /* Case #1: 32-bit NT errors */
6312 if (cli_is_nt_error(c_nt)) {
6313 nt_status = cli_nt_error(c_nt);
6314 } else {
6315 printf("/** Dos error on NT connection! (%s) */\n",
6316 cli_errstr(c_nt));
6317 nt_status = NT_STATUS(0xc0000000);
6318 }
6319
6320 status = cli_session_setup(c_dos, user,
6321 password, strlen(password),
6322 password, strlen(password),
6323 workgroup);
6324 if (NT_STATUS_IS_OK(status)) {
6325 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
6326 }
6327
6328 /* Case #1: 32-bit NT errors */
6329 if (!cli_is_dos_error(c_dos)) {
6330 printf("/** NT error on DOS connection! (%s) */\n",
6331 cli_errstr(c_dos));
6332 errnum = errclass = 0;
6333 } else {
6334 cli_dos_error(c_dos, &errclass, &errnum);
6335 }
6336
6337 if (NT_STATUS_V(nt_status) != error) {
6338 printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n",
6339 get_nt_error_c_code(talloc_tos(), NT_STATUS(error)),
6340 get_nt_error_c_code(talloc_tos(), nt_status));
6341 }
6342
6343 printf("\t{%s,\t%s,\t%s},\n",
6344 smb_dos_err_class(errclass),
6345 smb_dos_err_name(errclass, errnum),
6346 get_nt_error_c_code(talloc_tos(), NT_STATUS(error)));
6347 }
6348 return True;
6349 }
6350
6351 static bool run_sesssetup_bench(int dummy)
6352 {
6353 static struct cli_state *c;
6354 const char *fname = "\\file.dat";
6355 uint16_t fnum;
6356 NTSTATUS status;
6357 int i;
6358
6359 if (!torture_open_connection(&c, 0)) {
6360 return false;
6361 }
6362
6363 status = cli_ntcreate(c, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
6364 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
6365 FILE_DELETE_ON_CLOSE, 0, &fnum);
6366 if (!NT_STATUS_IS_OK(status)) {
6367 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
6368 return false;
6369 }
6370
6371 for (i=0; i<torture_numops; i++) {
6372 status = cli_session_setup(
6373 c, username,
6374 password, strlen(password),
6375 password, strlen(password),
6376 workgroup);
6377 if (!NT_STATUS_IS_OK(status)) {
6378 d_printf("(%s) cli_session_setup failed: %s\n",
6379 __location__, nt_errstr(status));
6380 return false;
6381 }
6382
6383 d_printf("\r%d ", (int)cli_state_get_uid(c));
6384
6385 status = cli_ulogoff(c);
6386 if (!NT_STATUS_IS_OK(status)) {
6387 d_printf("(%s) cli_ulogoff failed: %s\n",
6388 __location__, nt_errstr(status));
6389 return false;
6390 }
6391 }
6392
6393 return true;
6394 }
6395
6396 static bool subst_test(const char *str, const char *user, const char *domain,
6397 uid_t uid, gid_t gid, const char *expected)
6398 {
6399 char *subst;
6400 bool result = true;
6401
6402 subst = talloc_sub_specified(talloc_tos(), str, user, domain, uid, gid);
6403
6404 if (strcmp(subst, expected) != 0) {
6405 printf("sub_specified(%s, %s, %s, %d, %d) returned [%s], expected "
6406 "[%s]\n", str, user, domain, (int)uid, (int)gid, subst,
6407 expected);
6408 result = false;
6409 }
6410
6411 TALLOC_FREE(subst);
6412 return result;
6413 }
6414
6415 static void chain1_open_completion(struct tevent_req *req)
6416 {
6417 uint16_t fnum;
6418 NTSTATUS status;
6419 status = cli_open_recv(req, &fnum);
6420 TALLOC_FREE(req);
6421
6422 d_printf("cli_open_recv returned %s: %d\n",
6423 nt_errstr(status),
6424 NT_STATUS_IS_OK(status) ? fnum : -1);
6425 }
6426
6427 static void chain1_write_completion(struct tevent_req *req)
6428 {
6429 size_t written;
6430 NTSTATUS status;
6431 status = cli_write_andx_recv(req, &written);
6432 TALLOC_FREE(req);
6433
6434 d_printf("cli_write_andx_recv returned %s: %d\n",
6435 nt_errstr(status),
6436 NT_STATUS_IS_OK(status) ? (int)written : -1);
6437 }
6438
6439 static void chain1_close_completion(struct tevent_req *req)
6440 {
6441 NTSTATUS status;
6442 bool *done = (bool *)tevent_req_callback_data_void(req);
6443
6444 status = cli_close_recv(req);
6445 *done = true;
6446
6447 TALLOC_FREE(req);
6448
6449 d_printf("cli_close returned %s\n", nt_errstr(status));
6450 }
6451
6452 static bool run_chain1(int dummy)
6453 {
6454 struct cli_state *cli1;
6455 struct event_context *evt = event_context_init(NULL);
6456 struct tevent_req *reqs[3], *smbreqs[3];
6457 bool done = false;
6458 const char *str = "foobar";
6459 NTSTATUS status;
6460
6461 printf("starting chain1 test\n");
6462 if (!torture_open_connection(&cli1, 0)) {
6463 return False;
6464 }
6465
6466 cli_sockopt(cli1, sockops);
6467
6468 reqs[0] = cli_open_create(talloc_tos(), evt, cli1, "\\test",
6469 O_CREAT|O_RDWR, 0, &smbreqs[0]);
6470 if (reqs[0] == NULL) return false;
6471 tevent_req_set_callback(reqs[0], chain1_open_completion, NULL);
6472
6473
6474 reqs[1] = cli_write_andx_create(talloc_tos(), evt, cli1, 0, 0,
6475 (const uint8_t *)str, 0, strlen(str)+1,
6476 smbreqs, 1, &smbreqs[1]);
6477 if (reqs[1] == NULL) return false;
6478 tevent_req_set_callback(reqs[1], chain1_write_completion, NULL);
6479
6480 reqs[2] = cli_close_create(talloc_tos(), evt, cli1, 0, &smbreqs[2]);
6481 if (reqs[2] == NULL) return false;
6482 tevent_req_set_callback(reqs[2], chain1_close_completion, &done);
6483
6484 status = cli_smb_chain_send(smbreqs, ARRAY_SIZE(smbreqs));
6485 if (!NT_STATUS_IS_OK(status)) {
6486 return false;
6487 }
6488
6489 while (!done) {
6490 event_loop_once(evt);
6491 }
6492
6493 torture_close_connection(cli1);
6494 return True;
6495 }
6496
6497 static void chain2_sesssetup_completion(struct tevent_req *req)
6498 {
6499 NTSTATUS status;
6500 status = cli_session_setup_guest_recv(req);
6501 d_printf("sesssetup returned %s\n", nt_errstr(status));
6502 }
6503
6504 static void chain2_tcon_completion(struct tevent_req *req)
6505 {
6506 bool *done = (bool *)tevent_req_callback_data_void(req);
6507 NTSTATUS status;
6508 status = cli_tcon_andx_recv(req);
6509 d_printf("tcon_and_x returned %s\n", nt_errstr(status));
6510 *done = true;
6511 }
6512
6513 static bool run_chain2(int dummy)
6514 {
6515 struct cli_state *cli1;
6516 struct event_context *evt = event_context_init(NULL);
6517 struct tevent_req *reqs[2], *smbreqs[2];
6518 bool done = false;
6519 NTSTATUS status;
6520
6521 printf("starting chain2 test\n");
6522 status = cli_start_connection(&cli1, lp_netbios_name(), host, NULL,
6523 port_to_use, Undefined, 0);
6524 if (!NT_STATUS_IS_OK(status)) {
6525 return False;
6526 }
6527
6528 cli_sockopt(cli1, sockops);
6529
6530 reqs[0] = cli_session_setup_guest_create(talloc_tos(), evt, cli1,
6531 &smbreqs[0]);
6532 if (reqs[0] == NULL) return false;
6533 tevent_req_set_callback(reqs[0], chain2_sesssetup_completion, NULL);
6534
6535 reqs[1] = cli_tcon_andx_create(talloc_tos(), evt, cli1, "IPC$",
6536 "?????", NULL, 0, &smbreqs[1]);
6537 if (reqs[1] == NULL) return false;
6538 tevent_req_set_callback(reqs[1], chain2_tcon_completion, &done);
6539
6540 status = cli_smb_chain_send(smbreqs, ARRAY_SIZE(smbreqs));
6541 if (!NT_STATUS_IS_OK(status)) {
6542 return false;
6543 }
6544
6545 while (!done) {
6546 event_loop_once(evt);
6547 }
6548
6549 torture_close_connection(cli1);
6550 return True;
6551 }
6552
6553
6554 struct torture_createdel_state {
6555 struct tevent_context *ev;
6556 struct cli_state *cli;
6557 };
6558
6559 static void torture_createdel_created(struct tevent_req *subreq);
6560 static void torture_createdel_closed(struct tevent_req *subreq);
6561
6562 static struct tevent_req *torture_createdel_send(TALLOC_CTX *mem_ctx,
6563 struct tevent_context *ev,
6564 struct cli_state *cli,
6565 const char *name)
6566 {
6567 struct tevent_req *req, *subreq;
6568 struct torture_createdel_state *state;
6569
6570 req = tevent_req_create(mem_ctx, &state,
6571 struct torture_createdel_state);
6572 if (req == NULL) {
6573 return NULL;
6574 }
6575 state->ev = ev;
6576 state->cli = cli;
6577
6578 subreq = cli_ntcreate_send(
6579 state, ev, cli, name, 0,
6580 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
6581 FILE_ATTRIBUTE_NORMAL,
6582 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
6583 FILE_OPEN_IF, FILE_DELETE_ON_CLOSE, 0);
6584
6585 if (tevent_req_nomem(subreq, req)) {
6586 return tevent_req_post(req, ev);
6587 }
6588 tevent_req_set_callback(subreq, torture_createdel_created, req);
6589 return req;
6590 }
6591
6592 static void torture_createdel_created(struct tevent_req *subreq)
6593 {
6594 struct tevent_req *req = tevent_req_callback_data(
6595 subreq, struct tevent_req);
6596 struct torture_createdel_state *state = tevent_req_data(
6597 req, struct torture_createdel_state);
6598 NTSTATUS status;
6599 uint16_t fnum;
6600
6601 status = cli_ntcreate_recv(subreq, &fnum);
6602 TALLOC_FREE(subreq);
6603 if (!NT_STATUS_IS_OK(status)) {
6604 DEBUG(10, ("cli_ntcreate_recv returned %s\n",
6605 nt_errstr(status)));
6606 tevent_req_nterror(req, status);
6607 return;
6608 }
6609
6610 subreq = cli_close_send(state, state->ev, state->cli, fnum);
6611 if (tevent_req_nomem(subreq, req)) {
6612 return;
6613 }
6614 tevent_req_set_callback(subreq, torture_createdel_closed, req);
6615 }
6616
6617 static void torture_createdel_closed(struct tevent_req *subreq)
6618 {
6619 struct tevent_req *req = tevent_req_callback_data(
6620 subreq, struct tevent_req);
6621 NTSTATUS status;
6622
6623 status = cli_close_recv(subreq);
6624 if (!NT_STATUS_IS_OK(status)) {
6625 DEBUG(10, ("cli_close_recv returned %s\n", nt_errstr(status)));
6626 tevent_req_nterror(req, status);
6627 return;
6628 }
6629 tevent_req_done(req);
6630 }
6631
6632 static NTSTATUS torture_createdel_recv(struct tevent_req *req)
6633 {
6634 return tevent_req_simple_recv_ntstatus(req);
6635 }
6636
6637 struct torture_createdels_state {
6638 struct tevent_context *ev;
6639 struct cli_state *cli;
6640 const char *base_name;
6641 int sent;
6642 int received;
6643 int num_files;
6644 struct tevent_req **reqs;
6645 };
6646
6647 static void torture_createdels_done(struct tevent_req *subreq);
6648
6649 static struct tevent_req *torture_createdels_send(TALLOC_CTX *mem_ctx,
6650 struct tevent_context *ev,
6651 struct cli_state *cli,
6652 const char *base_name,
6653 int num_parallel,
6654 int num_files)
6655 {
6656 struct tevent_req *req;
6657 struct torture_createdels_state *state;
6658 int i;
6659
6660 req = tevent_req_create(mem_ctx, &state,
6661 struct torture_createdels_state);
6662 if (req == NULL) {
6663 return NULL;
6664 }
6665 state->ev = ev;
6666 state->cli = cli;
6667 state->base_name = talloc_strdup(state, base_name);
6668 if (tevent_req_nomem(state->base_name, req)) {
6669 return tevent_req_post(req, ev);
6670 }
6671 state->num_files = MAX(num_parallel, num_files);
6672 state->sent = 0;
6673 state->received = 0;
6674
6675 state->reqs = talloc_array(state, struct tevent_req *, num_parallel);
6676 if (tevent_req_nomem(state->reqs, req)) {
6677 return tevent_req_post(req, ev);
6678 }
6679
6680 for (i=0; i<num_parallel; i++) {
6681 char *name;
6682
6683 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
6684 state->sent);
6685 if (tevent_req_nomem(name, req)) {
6686 return tevent_req_post(req, ev);
6687 }
6688 state->reqs[i] = torture_createdel_send(
6689 state->reqs, state->ev, state->cli, name);
6690 if (tevent_req_nomem(state->reqs[i], req)) {
6691 return tevent_req_post(req, ev);
6692 }
6693 name = talloc_move(state->reqs[i], &name);
6694 tevent_req_set_callback(state->reqs[i],
6695 torture_createdels_done, req);
6696 state->sent += 1;
6697 }
6698 return req;
6699 }
6700
6701 static void torture_createdels_done(struct tevent_req *subreq)
6702 {
6703 struct tevent_req *req = tevent_req_callback_data(
6704 subreq, struct tevent_req);
6705 struct torture_createdels_state *state = tevent_req_data(
6706 req, struct torture_createdels_state);
6707 size_t num_parallel = talloc_array_length(state->reqs);
6708 NTSTATUS status;
6709 char *name;
6710 int i;
6711
6712 status = torture_createdel_recv(subreq);
6713 if (!NT_STATUS_IS_OK(status)){
6714 DEBUG(10, ("torture_createdel_recv returned %s\n",
6715 nt_errstr(status)));
6716 TALLOC_FREE(subreq);
6717 tevent_req_nterror(req, status);
6718 return;
6719 }
6720
6721 for (i=0; i<num_parallel; i++) {
6722 if (subreq == state->reqs[i]) {
6723 break;
6724 }
6725 }
6726 if (i == num_parallel) {
6727 DEBUG(10, ("received something we did not send\n"));
6728 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
6729 return;
6730 }
6731 TALLOC_FREE(state->reqs[i]);
6732
6733 if (state->sent >= state->num_files) {
6734 tevent_req_done(req);
6735 return;
6736 }
6737
6738 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
6739 state->sent);
6740 if (tevent_req_nomem(name, req)) {
6741 return;
6742 }
6743 state->reqs[i] = torture_createdel_send(state->reqs, state->ev,
6744 state->cli, name);
6745 if (tevent_req_nomem(state->reqs[i], req)) {
6746 return;
6747 }
6748 name = talloc_move(state->reqs[i], &name);
6749 tevent_req_set_callback(state->reqs[i], torture_createdels_done, req);
6750 state->sent += 1;
6751 }
6752
6753 static NTSTATUS torture_createdels_recv(struct tevent_req *req)
6754 {
6755 return tevent_req_simple_recv_ntstatus(req);
6756 }
6757
6758 struct swallow_notify_state {
6759 struct tevent_context *ev;
6760 struct cli_state *cli;
6761 uint16_t fnum;
6762 uint32_t completion_filter;
6763 bool recursive;
6764 bool (*fn)(uint32_t action, const char *name, void *priv);
6765 void *priv;
6766 };
6767
6768 static void swallow_notify_done(struct tevent_req *subreq);
6769
6770 static struct tevent_req *swallow_notify_send(TALLOC_CTX *mem_ctx,
6771 struct tevent_context *ev,
6772 struct cli_state *cli,
6773 uint16_t fnum,
6774 uint32_t completion_filter,
6775 bool recursive,
6776 bool (*fn)(uint32_t action,
6777 const char *name,
6778 void *priv),
6779 void *priv)
6780 {
6781 struct tevent_req *req, *subreq;
6782 struct swallow_notify_state *state;
6783
6784 req = tevent_req_create(mem_ctx, &state,
6785 struct swallow_notify_state);
6786 if (req == NULL) {
6787 return NULL;
6788 }
6789 state->ev = ev;
6790 state->cli = cli;
6791 state->fnum = fnum;
6792 state->completion_filter = completion_filter;
6793 state->recursive = recursive;
6794 state->fn = fn;
6795 state->priv = priv;
6796
6797 subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
6798 0xffff, state->completion_filter,
6799 state->recursive);
6800 if (tevent_req_nomem(subreq, req)) {
6801 return tevent_req_post(req, ev);
6802 }
6803 tevent_req_set_callback(subreq, swallow_notify_done, req);
6804 return req;
6805 }
6806
6807 static void swallow_notify_done(struct tevent_req *subreq)
6808 {
6809 struct tevent_req *req = tevent_req_callback_data(
6810 subreq, struct tevent_req);
6811 struct swallow_notify_state *state = tevent_req_data(
6812 req, struct swallow_notify_state);
6813 NTSTATUS status;
6814 uint32_t i, num_changes;
6815 struct notify_change *changes;
6816
6817 status = cli_notify_recv(subreq, state, &num_changes, &changes);
6818 TALLOC_FREE(subreq);
6819 if (!NT_STATUS_IS_OK(status)) {
6820 DEBUG(10, ("cli_notify_recv returned %s\n",
6821 nt_errstr(status)));
6822 tevent_req_nterror(req, status);
6823 return;
6824 }
6825
6826 for (i=0; i<num_changes; i++) {
6827 state->fn(changes[i].action, changes[i].name, state->priv);
6828 }
6829 TALLOC_FREE(changes);
6830
6831 subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
6832 0xffff, state->completion_filter,
6833 state->recursive);
6834 if (tevent_req_nomem(subreq, req)) {
6835 return;
6836 }
6837 tevent_req_set_callback(subreq, swallow_notify_done, req);
6838 }
6839
6840 static bool print_notifies(uint32_t action, const char *name, void *priv)
6841 {
6842 if (DEBUGLEVEL > 5) {
6843 d_printf("%d %s\n", (int)action, name);
6844 }
6845 return true;
6846 }
6847
6848 static void notify_bench_done(struct tevent_req *req)
6849 {
6850 int *num_finished = (int *)tevent_req_callback_data_void(req);
6851 *num_finished += 1;
6852 }
6853
6854 static bool run_notify_bench(int dummy)
6855 {
6856 const char *dname = "\\notify-bench";
6857 struct tevent_context *ev;
6858 NTSTATUS status;
6859 uint16_t dnum;
6860 struct tevent_req *req1;
6861 struct tevent_req *req2 = NULL;
6862 int i, num_unc_names;
6863 int num_finished = 0;
6864
6865 printf("starting notify-bench test\n");
6866
6867 if (use_multishare_conn) {
6868 char **unc_list;
6869 unc_list = file_lines_load(multishare_conn_fname,
6870 &num_unc_names, 0, NULL);
6871 if (!unc_list || num_unc_names <= 0) {
6872 d_printf("Failed to load unc names list from '%s'\n",
6873 multishare_conn_fname);
6874 return false;
6875 }
6876 TALLOC_FREE(unc_list);
6877 } else {
6878 num_unc_names = 1;
6879 }
6880
6881 ev = tevent_context_init(talloc_tos());
6882 if (ev == NULL) {
6883 d_printf("tevent_context_init failed\n");
6884 return false;
6885 }
6886
6887 for (i=0; i<num_unc_names; i++) {
6888 struct cli_state *cli;
6889 char *base_fname;
6890
6891 base_fname = talloc_asprintf(talloc_tos(), "%s\\file%3.3d.",
6892 dname, i);
6893 if (base_fname == NULL) {
6894 return false;
6895 }
6896
6897 if (!torture_open_connection(&cli, i)) {
6898 return false;
6899 }
6900
6901 status = cli_ntcreate(cli, dname, 0,
6902 MAXIMUM_ALLOWED_ACCESS,
6903 0, FILE_SHARE_READ|FILE_SHARE_WRITE|
6904 FILE_SHARE_DELETE,
6905 FILE_OPEN_IF, FILE_DIRECTORY_FILE, 0,
6906 &dnum);
6907
6908 if (!NT_STATUS_IS_OK(status)) {
6909 d_printf("Could not create %s: %s\n", dname,
6910 nt_errstr(status));
6911 return false;
6912 }
6913
6914 req1 = swallow_notify_send(talloc_tos(), ev, cli, dnum,
6915 FILE_NOTIFY_CHANGE_FILE_NAME |
6916 FILE_NOTIFY_CHANGE_DIR_NAME |
6917 FILE_NOTIFY_CHANGE_ATTRIBUTES |
6918 FILE_NOTIFY_CHANGE_LAST_WRITE,
6919 false, print_notifies, NULL);
6920 if (req1 == NULL) {
6921 d_printf("Could not create notify request\n");
6922 return false;
6923 }
6924
6925 req2 = torture_createdels_send(talloc_tos(), ev, cli,
6926 base_fname, 10, torture_numops);
6927 if (req2 == NULL) {
6928 d_printf("Could not create createdels request\n");
6929 return false;
6930 }
6931 TALLOC_FREE(base_fname);
6932
6933 tevent_req_set_callback(req2, notify_bench_done,
6934 &num_finished);
6935 }
6936
6937 while (num_finished < num_unc_names) {
6938 int ret;
6939 ret = tevent_loop_once(ev);
6940 if (ret != 0) {
6941 d_printf("tevent_loop_once failed\n");
6942 return false;
6943 }
6944 }
6945
6946 if (!tevent_req_poll(req2, ev)) {
6947 d_printf("tevent_req_poll failed\n");
6948 }
6949
6950 status = torture_createdels_recv(req2);
6951 d_printf("torture_createdels_recv returned %s\n", nt_errstr(status));
6952
6953 return true;
6954 }
6955
6956 static bool run_mangle1(int dummy)
6957 {
6958 struct cli_state *cli;
6959 const char *fname = "this_is_a_long_fname_to_be_mangled.txt";
6960 uint16_t fnum;
6961 fstring alt_name;
6962 NTSTATUS status;
6963 time_t change_time, access_time, write_time;
6964 SMB_OFF_T size;
6965 uint16_t mode;
6966
6967 printf("starting mangle1 test\n");
6968 if (!torture_open_connection(&cli, 0)) {
6969 return False;
6970 }
6971
6972 cli_sockopt(cli, sockops);
6973
6974 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
6975 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
6976 0, 0, &fnum);
6977 if (!NT_STATUS_IS_OK(status)) {
6978 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
6979 return false;
6980 }
6981 cli_close(cli, fnum);
6982
6983 status = cli_qpathinfo_alt_name(cli, fname, alt_name);
6984 if (!NT_STATUS_IS_OK(status)) {
6985 d_printf("cli_qpathinfo_alt_name failed: %s\n",
6986 nt_errstr(status));
6987 return false;
6988 }
6989 d_printf("alt_name: %s\n", alt_name);
6990
6991 status = cli_open(cli, alt_name, O_RDONLY, DENY_NONE, &fnum);
6992 if (!NT_STATUS_IS_OK(status)) {
6993 d_printf("cli_open(%s) failed: %s\n", alt_name,
6994 nt_errstr(status));
6995 return false;
6996 }
6997 cli_close(cli, fnum);
6998
6999 status = cli_qpathinfo1(cli, alt_name, &change_time, &access_time,
7000 &write_time, &size, &mode);
7001 if (!NT_STATUS_IS_OK(status)) {
7002 d_printf("cli_qpathinfo1(%s) failed: %s\n", alt_name,
7003 nt_errstr(status));
7004 return false;
7005 }
7006
7007 return true;
7008 }
7009
7010 static size_t null_source(uint8_t *buf, size_t n, void *priv)
7011 {
7012 size_t *to_pull = (size_t *)priv;
7013 size_t thistime = *to_pull;
7014
7015 thistime = MIN(thistime, n);
7016 if (thistime == 0) {
7017 return 0;
7018 }
7019
7020 memset(buf, 0, thistime);
7021 *to_pull -= thistime;
7022 return thistime;
7023 }
7024
7025 static bool run_windows_write(int dummy)
7026 {
7027 struct cli_state *cli1;
7028 uint16_t fnum;
7029 int i;
7030 bool ret = false;
7031 const char *fname = "\\writetest.txt";
7032 struct timeval start_time;
7033 double seconds;
7034 double kbytes;
7035 NTSTATUS status;
7036
7037 printf("starting windows_write test\n");
7038 if (!torture_open_connection(&cli1, 0)) {
7039 return False;
7040 }
7041
7042 status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
7043 if (!NT_STATUS_IS_OK(status)) {
7044 printf("open failed (%s)\n", nt_errstr(status));
7045 return False;
7046 }
7047
7048 cli_sockopt(cli1, sockops);
7049
7050 start_time = timeval_current();
7051
7052 for (i=0; i<torture_numops; i++) {
7053 uint8_t c = 0;
7054 off_t start = i * torture_blocksize;
7055 size_t to_pull = torture_blocksize - 1;
7056
7057 status = cli_writeall(cli1, fnum, 0, &c,
7058 start + torture_blocksize - 1, 1, NULL);
7059 if (!NT_STATUS_IS_OK(status)) {
7060 printf("cli_write failed: %s\n", nt_errstr(status));
7061 goto fail;
7062 }
7063
7064 status = cli_push(cli1, fnum, 0, i * torture_blocksize, torture_blocksize,
7065 null_source, &to_pull);
7066 if (!NT_STATUS_IS_OK(status)) {
7067 printf("cli_push returned: %s\n", nt_errstr(status));
7068 goto fail;
7069 }
7070 }
7071
7072 seconds = timeval_elapsed(&start_time);
7073 kbytes = (double)torture_blocksize * torture_numops;
7074 kbytes /= 1024;
7075
7076 printf("Wrote %d kbytes in %.2f seconds: %d kb/sec\n", (int)kbytes,
7077 (double)seconds, (int)(kbytes/seconds));
7078
7079 ret = true;
7080 fail:
7081 cli_close(cli1, fnum);
7082 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7083 torture_close_connection(cli1);
7084 return ret;
7085 }
7086
7087 static bool run_cli_echo(int dummy)
7088 {
7089 struct cli_state *cli;
7090 NTSTATUS status;
7091
7092 printf("starting cli_echo test\n");
7093 if (!torture_open_connection(&cli, 0)) {
7094 return false;
7095 }
7096 cli_sockopt(cli, sockops);
7097
7098 status = cli_echo(cli, 5, data_blob_const("hello", 5));
7099
7100 d_printf("cli_echo returned %s\n", nt_errstr(status));
7101
7102 torture_close_connection(cli);
7103 return NT_STATUS_IS_OK(status);
7104 }
7105
7106 static bool run_uid_regression_test(int dummy)
7107 {
7108 static struct cli_state *cli;
7109 int16_t old_vuid;
7110 int16_t old_cnum;
7111 bool correct = True;
7112 NTSTATUS status;
7113
7114 printf("starting uid regression test\n");
7115
7116 if (!torture_open_connection(&cli, 0)) {
7117 return False;
7118 }
7119
7120 cli_sockopt(cli, sockops);
7121
7122 /* Ok - now save then logoff our current user. */
7123 old_vuid = cli_state_get_uid(cli);
7124
7125 status = cli_ulogoff(cli);
7126 if (!NT_STATUS_IS_OK(status)) {
7127 d_printf("(%s) cli_ulogoff failed: %s\n",
7128 __location__, nt_errstr(status));
7129 correct = false;
7130 goto out;
7131 }
7132
7133 cli_state_set_uid(cli, old_vuid);
7134
7135 /* Try an operation. */
7136 status = cli_mkdir(cli, "\\uid_reg_test");
7137 if (NT_STATUS_IS_OK(status)) {
7138 d_printf("(%s) cli_mkdir succeeded\n",
7139 __location__);
7140 correct = false;
7141 goto out;
7142 } else {
7143 /* Should be bad uid. */
7144 if (!check_error(__LINE__, cli, ERRSRV, ERRbaduid,
7145 NT_STATUS_USER_SESSION_DELETED)) {
7146 correct = false;
7147 goto out;
7148 }
7149 }
7150
7151 old_cnum = cli_state_get_tid(cli);
7152
7153 /* Now try a SMBtdis with the invald vuid set to zero. */
7154 cli_state_set_uid(cli, 0);
7155
7156 /* This should succeed. */
7157 status = cli_tdis(cli);
7158
7159 if (NT_STATUS_IS_OK(status)) {
7160 d_printf("First tdis with invalid vuid should succeed.\n");
7161 } else {
7162 d_printf("First tdis failed (%s)\n", nt_errstr(status));
7163 correct = false;
7164 goto out;
7165 }
7166
7167 cli_state_set_uid(cli, old_vuid);
7168 cli_state_set_tid(cli, old_cnum);
7169
7170 /* This should fail. */
7171 status = cli_tdis(cli);
7172 if (NT_STATUS_IS_OK(status)) {
7173 d_printf("Second tdis with invalid vuid should fail - succeeded instead !.\n");
7174 correct = false;
7175 goto out;
7176 } else {
7177 /* Should be bad tid. */
7178 if (!check_error(__LINE__, cli, ERRSRV, ERRinvnid,
7179 NT_STATUS_NETWORK_NAME_DELETED)) {
7180 correct = false;
7181 goto out;
7182 }
7183 }
7184
7185 cli_rmdir(cli, "\\uid_reg_test");
7186
7187 out:
7188
7189 cli_shutdown(cli);
7190 return correct;
7191 }
7192
7193
7194 static const char *illegal_chars = "*\\/?<>|\":";
7195 static char force_shortname_chars[] = " +,.[];=\177";
7196
7197 static NTSTATUS shortname_del_fn(const char *mnt, struct file_info *finfo,
7198 const char *mask, void *state)
7199 {
7200 struct cli_state *pcli = (struct cli_state *)state;
7201 fstring fname;
7202 NTSTATUS status = NT_STATUS_OK;
7203
7204 slprintf(fname, sizeof(fname), "\\shortname\\%s", finfo->name);
7205
7206 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
7207 return NT_STATUS_OK;
7208
7209 if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
7210 status = cli_rmdir(pcli, fname);
7211 if (!NT_STATUS_IS_OK(status)) {
7212 printf("del_fn: failed to rmdir %s\n,", fname );
7213 }
7214 } else {
7215 status = cli_unlink(pcli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7216 if (!NT_STATUS_IS_OK(status)) {
7217 printf("del_fn: failed to unlink %s\n,", fname );
7218 }
7219 }
7220 return status;
7221 }
7222
7223 struct sn_state {
7224 int matched;
7225 int i;
7226 bool val;
7227 };
7228
7229 static NTSTATUS shortname_list_fn(const char *mnt, struct file_info *finfo,
7230 const char *name, void *state)
7231 {
7232 struct sn_state *s = (struct sn_state *)state;
7233 int i = s->i;
7234
7235 #if 0
7236 printf("shortname list: i = %d, name = |%s|, shortname = |%s|\n",
7237 i, finfo->name, finfo->short_name);
7238 #endif
7239
7240 if (strchr(force_shortname_chars, i)) {
7241 if (!finfo->short_name) {
7242 /* Shortname not created when it should be. */
7243 d_printf("(%s) ERROR: Shortname was not created for file %s containing %d\n",
7244 __location__, finfo->name, i);
7245 s->val = true;
7246 }
7247 } else if (finfo->short_name){
7248 /* Shortname created when it should not be. */
7249 d_printf("(%s) ERROR: Shortname %s was created for file %s\n",
7250 __location__, finfo->short_name, finfo->name);
7251 s->val = true;
7252 }
7253 s->matched += 1;
7254 return NT_STATUS_OK;
7255 }
7256
7257 static bool run_shortname_test(int dummy)
7258 {
7259 static struct cli_state *cli;
7260 bool correct = True;
7261 int i;
7262 struct sn_state s;
7263 char fname[20];
7264 NTSTATUS status;
7265
7266 printf("starting shortname test\n");
7267
7268 if (!torture_open_connection(&cli, 0)) {
7269 return False;
7270 }
7271
7272 cli_sockopt(cli, sockops);
7273
7274 cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
7275 cli_list(cli, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY, shortname_del_fn, cli);
7276 cli_rmdir(cli, "\\shortname");
7277
7278 status = cli_mkdir(cli, "\\shortname");
7279 if (!NT_STATUS_IS_OK(status)) {
7280 d_printf("(%s) cli_mkdir of \\shortname failed: %s\n",
7281 __location__, nt_errstr(status));
7282 correct = false;
7283 goto out;
7284 }
7285
7286 strlcpy(fname, "\\shortname\\", sizeof(fname));
7287 strlcat(fname, "test .txt", sizeof(fname));
7288
7289 s.val = false;
7290
7291 for (i = 32; i < 128; i++) {
7292 uint16_t fnum = (uint16_t)-1;
7293
7294 s.i = i;
7295
7296 if (strchr(illegal_chars, i)) {
7297 continue;
7298 }
7299 fname[15] = i;
7300
7301 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
7302 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum);
7303 if (!NT_STATUS_IS_OK(status)) {
7304 d_printf("(%s) cli_nt_create of %s failed: %s\n",
7305 __location__, fname, nt_errstr(status));
7306 correct = false;
7307 goto out;
7308 }
7309 cli_close(cli, fnum);
7310
7311 s.matched = 0;
7312 status = cli_list(cli, "\\shortname\\test*.*", 0,
7313 shortname_list_fn, &s);
7314 if (s.matched != 1) {
7315 d_printf("(%s) failed to list %s: %s\n",
7316 __location__, fname, nt_errstr(status));
7317 correct = false;
7318 goto out;
7319 }
7320
7321 status = cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7322 if (!NT_STATUS_IS_OK(status)) {
7323 d_printf("(%s) failed to delete %s: %s\n",
7324 __location__, fname, nt_errstr(status));
7325 correct = false;
7326 goto out;
7327 }
7328
7329 if (s.val) {
7330 correct = false;
7331 goto out;
7332 }
7333 }
7334
7335 out:
7336
7337 cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
7338 cli_list(cli, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY, shortname_del_fn, cli);
7339 cli_rmdir(cli, "\\shortname");
7340 torture_close_connection(cli);
7341 return correct;
7342 }
7343
7344 static void pagedsearch_cb(struct tevent_req *req)
7345 {
7346 int rc;
7347 struct tldap_message *msg;
7348 char *dn;
7349
7350 rc = tldap_search_paged_recv(req, talloc_tos(), &msg);
7351 if (rc != TLDAP_SUCCESS) {
7352 d_printf("tldap_search_paged_recv failed: %s\n",
7353 tldap_err2string(rc));
7354 return;
7355 }
7356 if (tldap_msg_type(msg) != TLDAP_RES_SEARCH_ENTRY) {
7357 TALLOC_FREE(msg);
7358 return;
7359 }
7360 if (!tldap_entry_dn(msg, &dn)) {
7361 d_printf("tldap_entry_dn failed\n");
7362 return;
7363 }
7364 d_printf("%s\n", dn);
7365 TALLOC_FREE(msg);
7366 }
7367
7368 static bool run_tldap(int dummy)
7369 {
7370 struct tldap_context *ld;
7371 int fd, rc;
7372 NTSTATUS status;
7373 struct sockaddr_storage addr;
7374 struct tevent_context *ev;
7375 struct tevent_req *req;
7376 char *basedn;
7377 const char *filter;
7378
7379 if (!resolve_name(host, &addr, 0, false)) {
7380 d_printf("could not find host %s\n", host);
7381 return false;
7382 }
7383 status = open_socket_out(&addr, 389, 9999, &fd);
7384 if (!NT_STATUS_IS_OK(status)) {
7385 d_printf("open_socket_out failed: %s\n", nt_errstr(status));
7386 return false;
7387 }
7388
7389 ld = tldap_context_create(talloc_tos(), fd);
7390 if (ld == NULL) {
7391 close(fd);
7392 d_printf("tldap_context_create failed\n");
7393 return false;
7394 }
7395
7396 rc = tldap_fetch_rootdse(ld);
7397 if (rc != TLDAP_SUCCESS) {
7398 d_printf("tldap_fetch_rootdse failed: %s\n",
7399 tldap_errstr(talloc_tos(), ld, rc));
7400 return false;
7401 }
7402
7403 basedn = tldap_talloc_single_attribute(
7404 tldap_rootdse(ld), "defaultNamingContext", talloc_tos());
7405 if (basedn == NULL) {
7406 d_printf("no defaultNamingContext\n");
7407 return false;
7408 }
7409 d_printf("defaultNamingContext: %s\n", basedn);
7410
7411 ev = tevent_context_init(talloc_tos());
7412 if (ev == NULL) {
7413 d_printf("tevent_context_init failed\n");
7414 return false;
7415 }
7416
7417 req = tldap_search_paged_send(talloc_tos(), ev, ld, basedn,
7418 TLDAP_SCOPE_SUB, "(objectclass=*)",
7419 NULL, 0, 0,
7420 NULL, 0, NULL, 0, 0, 0, 0, 5);
7421 if (req == NULL) {
7422 d_printf("tldap_search_paged_send failed\n");
7423 return false;
7424 }
7425 tevent_req_set_callback(req, pagedsearch_cb, NULL);
7426
7427 tevent_req_poll(req, ev);
7428
7429 TALLOC_FREE(req);
7430
7431 /* test search filters against rootDSE */
7432 filter = "(&(|(name=samba)(nextRid<=10000000)(usnChanged>=10)(samba~=ambas)(!(name=s*m*a)))"
7433 "(|(name:=samba)(name:dn:2.5.13.5:=samba)(:dn:2.5.13.5:=samba)(!(name=*samba))))";
7434
7435 rc = tldap_search(ld, "", TLDAP_SCOPE_BASE, filter,
7436 NULL, 0, 0, NULL, 0, NULL, 0, 0, 0, 0,
7437 talloc_tos(), NULL, NULL);
7438 if (rc != TLDAP_SUCCESS) {
7439 d_printf("tldap_search with complex filter failed: %s\n",
7440 tldap_errstr(talloc_tos(), ld, rc));
7441 return false;
7442 }
7443
7444 TALLOC_FREE(ld);
7445 return true;
7446 }
7447
7448 /* Torture test to ensure no regression of :
7449 https://bugzilla.samba.org/show_bug.cgi?id=7084
7450 */
7451
7452 static bool run_dir_createtime(int dummy)
7453 {
7454 struct cli_state *cli;
7455 const char *dname = "\\testdir";
7456 const char *fname = "\\testdir\\testfile";
7457 NTSTATUS status;
7458 struct timespec create_time;
7459 struct timespec create_time1;
7460 uint16_t fnum;
7461 bool ret = false;
7462
7463 if (!torture_open_connection(&cli, 0)) {
7464 return false;
7465 }
7466
7467 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7468 cli_rmdir(cli, dname);
7469
7470 status = cli_mkdir(cli, dname);
7471 if (!NT_STATUS_IS_OK(status)) {
7472 printf("mkdir failed: %s\n", nt_errstr(status));
7473 goto out;
7474 }
7475
7476 status = cli_qpathinfo2(cli, dname, &create_time, NULL, NULL, NULL,
7477 NULL, NULL, NULL);
7478 if (!NT_STATUS_IS_OK(status)) {
7479 printf("cli_qpathinfo2 returned %s\n",
7480 nt_errstr(status));
7481 goto out;
7482 }
7483
7484 /* Sleep 3 seconds, then create a file. */
7485 sleep(3);
7486
7487 status = cli_open(cli, fname, O_RDWR | O_CREAT | O_EXCL,
7488 DENY_NONE, &fnum);
7489 if (!NT_STATUS_IS_OK(status)) {
7490 printf("cli_open failed: %s\n", nt_errstr(status));
7491 goto out;
7492 }
7493
7494 status = cli_qpathinfo2(cli, dname, &create_time1, NULL, NULL, NULL,
7495 NULL, NULL, NULL);
7496 if (!NT_STATUS_IS_OK(status)) {
7497 printf("cli_qpathinfo2 (2) returned %s\n",
7498 nt_errstr(status));
7499 goto out;
7500 }
7501
7502 if (timespec_compare(&create_time1, &create_time)) {
7503 printf("run_dir_createtime: create time was updated (error)\n");
7504 } else {
7505 printf("run_dir_createtime: create time was not updated (correct)\n");
7506 ret = true;
7507 }
7508
7509 out:
7510
7511 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7512 cli_rmdir(cli, dname);
7513 if (!torture_close_connection(cli)) {
7514 ret = false;
7515 }
7516 return ret;
7517 }
7518
7519
7520 static bool run_streamerror(int dummy)
7521 {
7522 struct cli_state *cli;
7523 const char *dname = "\\testdir";
7524 const char *streamname =
7525 "testdir:{4c8cc155-6c1e-11d1-8e41-00c04fb9386d}:$DATA";
7526 NTSTATUS status;
7527 time_t change_time, access_time, write_time;
7528 SMB_OFF_T size;
7529 uint16_t mode, fnum;
7530 bool ret = true;
7531
7532 if (!torture_open_connection(&cli, 0)) {
7533 return false;
7534 }
7535
7536 cli_unlink(cli, "\\testdir\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7537 cli_rmdir(cli, dname);
7538
7539 status = cli_mkdir(cli, dname);
7540 if (!NT_STATUS_IS_OK(status)) {
7541 printf("mkdir failed: %s\n", nt_errstr(status));
7542 return false;
7543 }
7544
7545 cli_qpathinfo1(cli, streamname, &change_time, &access_time, &write_time,
7546 &size, &mode);
7547 status = cli_nt_error(cli);
7548
7549 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
7550 printf("pathinfo returned %s, expected "
7551 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
7552 nt_errstr(status));
7553 ret = false;
7554 }
7555
7556 status = cli_ntcreate(cli, streamname, 0x16,
7557 FILE_READ_DATA|FILE_READ_EA|
7558 FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS,
7559 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
7560 FILE_OPEN, 0, 0, &fnum);
7561
7562 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
7563 printf("ntcreate returned %s, expected "
7564 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
7565 nt_errstr(status));
7566 ret = false;
7567 }
7568
7569
7570 cli_rmdir(cli, dname);
7571 return ret;
7572 }
7573
7574 static bool run_local_substitute(int dummy)
7575 {
7576 bool ok = true;
7577
7578 ok &= subst_test("%U", "bla", "", -1, -1, "bla");
7579 ok &= subst_test("%u%U", "bla", "", -1, -1, "blabla");
7580 ok &= subst_test("%g", "", "", -1, -1, "NO_GROUP");
7581 ok &= subst_test("%G", "", "", -1, -1, "NO_GROUP");
7582 ok &= subst_test("%g", "", "", -1, 0, gidtoname(0));
7583 ok &= subst_test("%G", "", "", -1, 0, gidtoname(0));
7584 ok &= subst_test("%D%u", "u", "dom", -1, 0, "domu");
7585 ok &= subst_test("%i %I", "", "", -1, -1, "0.0.0.0 0.0.0.0");
7586
7587 /* Different captialization rules in sub_basic... */
7588
7589 ok &= (strcmp(talloc_sub_basic(talloc_tos(), "BLA", "dom", "%U%D"),
7590 "blaDOM") == 0);
7591
7592 return ok;
7593 }
7594
7595 static bool run_local_base64(int dummy)
7596 {
7597 int i;
7598 bool ret = true;
7599
7600 for (i=1; i<2000; i++) {
7601 DATA_BLOB blob1, blob2;
7602 char *b64;
7603
7604 blob1.data = talloc_array(talloc_tos(), uint8_t, i);
7605 blob1.length = i;
7606 generate_random_buffer(blob1.data, blob1.length);
7607
7608 b64 = base64_encode_data_blob(talloc_tos(), blob1);
7609 if (b64 == NULL) {
7610 d_fprintf(stderr, "base64_encode_data_blob failed "
7611 "for %d bytes\n", i);
7612 ret = false;
7613 }
7614 blob2 = base64_decode_data_blob(b64);
7615 TALLOC_FREE(b64);
7616
7617 if (data_blob_cmp(&blob1, &blob2)) {
7618 d_fprintf(stderr, "data_blob_cmp failed for %d "
7619 "bytes\n", i);
7620 ret = false;
7621 }
7622 TALLOC_FREE(blob1.data);
7623 data_blob_free(&blob2);
7624 }
7625 return ret;
7626 }
7627
7628 static bool run_local_gencache(int dummy)
7629 {
7630 char *val;
7631 time_t tm;
7632 DATA_BLOB blob;
7633
7634 if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
7635 d_printf("%s: gencache_set() failed\n", __location__);
7636 return False;
7637 }
7638
7639 if (!gencache_get("foo", NULL, NULL)) {
7640 d_printf("%s: gencache_get() failed\n", __location__);
7641 return False;
7642 }
7643
7644 if (!gencache_get("foo", &val, &tm)) {
7645 d_printf("%s: gencache_get() failed\n", __location__);
7646 return False;
7647 }
7648
7649 if (strcmp(val, "bar") != 0) {
7650 d_printf("%s: gencache_get() returned %s, expected %s\n",
7651 __location__, val, "bar");
7652 SAFE_FREE(val);
7653 return False;
7654 }
7655
7656 SAFE_FREE(val);
7657
7658 if (!gencache_del("foo")) {
7659 d_printf("%s: gencache_del() failed\n", __location__);
7660 return False;
7661 }
7662 if (gencache_del("foo")) {
7663 d_printf("%s: second gencache_del() succeeded\n",
7664 __location__);
7665 return False;
7666 }
7667
7668 if (gencache_get("foo", &val, &tm)) {
7669 d_printf("%s: gencache_get() on deleted entry "
7670 "succeeded\n", __location__);
7671 return False;
7672 }
7673
7674 blob = data_blob_string_const_null("bar");
7675 tm = time(NULL) + 60;
7676
7677 if (!gencache_set_data_blob("foo", &blob, tm)) {
7678 d_printf("%s: gencache_set_data_blob() failed\n", __location__);
7679 return False;
7680 }
7681
7682 if (!gencache_get_data_blob("foo", &blob, NULL, NULL)) {
7683 d_printf("%s: gencache_get_data_blob() failed\n", __location__);
7684 return False;
7685 }
7686
7687 if (strcmp((const char *)blob.data, "bar") != 0) {
7688 d_printf("%s: gencache_get_data_blob() returned %s, expected %s\n",
7689 __location__, (const char *)blob.data, "bar");
7690 data_blob_free(&blob);
7691 return False;
7692 }
7693
7694 data_blob_free(&blob);
7695
7696 if (!gencache_del("foo")) {
7697 d_printf("%s: gencache_del() failed\n", __location__);
7698 return False;
7699 }
7700 if (gencache_del("foo")) {
7701 d_printf("%s: second gencache_del() succeeded\n",
7702 __location__);
7703 return False;
7704 }
7705
7706 if (gencache_get_data_blob("foo", &blob, NULL, NULL)) {
7707 d_printf("%s: gencache_get_data_blob() on deleted entry "
7708 "succeeded\n", __location__);
7709 return False;
7710 }
7711
7712 return True;
7713 }
7714
7715 static bool rbt_testval(struct db_context *db, const char *key,
7716 const char *value)
7717 {
7718 struct db_record *rec;
7719 TDB_DATA data = string_tdb_data(value);
7720 bool ret = false;
7721 NTSTATUS status;
7722
7723 rec = db->fetch_locked(db, db, string_tdb_data(key));
7724 if (rec == NULL) {
7725 d_fprintf(stderr, "fetch_locked failed\n");
7726 goto done;
7727 }
7728 status = rec->store(rec, data, 0);
7729 if (!NT_STATUS_IS_OK(status)) {
7730 d_fprintf(stderr, "store failed: %s\n", nt_errstr(status));
7731 goto done;
7732 }
7733 TALLOC_FREE(rec);
7734
7735 rec = db->fetch_locked(db, db, string_tdb_data(key));
7736 if (rec == NULL) {
7737 d_fprintf(stderr, "second fetch_locked failed\n");
7738 goto done;
7739 }
7740 if ((rec->value.dsize != data.dsize)
7741 || (memcmp(rec->value.dptr, data.dptr, data.dsize) != 0)) {
7742 d_fprintf(stderr, "Got wrong data back\n");
7743 goto done;
7744 }
7745
7746 ret = true;
7747 done:
7748 TALLOC_FREE(rec);
7749 return ret;
7750 }
7751
7752 static bool run_local_rbtree(int dummy)
7753 {
7754 struct db_context *db;
7755 bool ret = false;
7756 int i;
7757
7758 db = db_open_rbt(NULL);
7759
7760 if (db == NULL) {
7761 d_fprintf(stderr, "db_open_rbt failed\n");
7762 return false;
7763 }
7764
7765 for (i=0; i<1000; i++) {
7766 char *key, *value;
7767
7768 if (asprintf(&key, "key%ld", random()) == -1) {
7769 goto done;
7770 }
7771 if (asprintf(&value, "value%ld", random()) == -1) {
7772 SAFE_FREE(key);
7773 goto done;
7774 }
7775
7776 if (!rbt_testval(db, key, value)) {
7777 SAFE_FREE(key);
7778 SAFE_FREE(value);
7779 goto done;
7780 }
7781
7782 SAFE_FREE(value);
7783 if (asprintf(&value, "value%ld", random()) == -1) {
7784 SAFE_FREE(key);
7785 goto done;
7786 }
7787
7788 if (!rbt_testval(db, key, value)) {
7789 SAFE_FREE(key);
7790 SAFE_FREE(value);
7791 goto done;
7792 }
7793
7794 SAFE_FREE(key);
7795 SAFE_FREE(value);
7796 }
7797
7798 ret = true;
7799
7800 done:
7801 TALLOC_FREE(db);
7802 return ret;
7803 }
7804
7805
7806 /*
7807 local test for character set functions
7808
7809 This is a very simple test for the functionality in convert_string_error()
7810 */
7811 static bool run_local_convert_string(int dummy)
7812 {
7813 TALLOC_CTX *tmp_ctx = talloc_new(NULL);
7814 const char *test_strings[2] = { "March", "M\303\244rz" };
7815 char dst[7];
7816 int i;
7817
7818 for (i=0; i<2; i++) {
7819 const char *str = test_strings[i];
7820 int len = strlen(str);
7821 size_t converted_size;
7822 bool ret;
7823
7824 memset(dst, 'X', sizeof(dst));
7825
7826 /* first try with real source length */
7827 ret = convert_string_error(CH_UNIX, CH_UTF8,
7828 str, len,
7829 dst, sizeof(dst),
7830 &converted_size);
7831 if (ret != true) {
7832 d_fprintf(stderr, "Failed to convert '%s' to CH_DISPLAY\n", str);
7833 goto failed;
7834 }
7835
7836 if (converted_size != len) {
7837 d_fprintf(stderr, "Converted size of '%s' should be %d - got %d\n",
7838 str, len, (int)converted_size);
7839 goto failed;
7840 }
7841
7842 if (strncmp(str, dst, converted_size) != 0) {
7843 d_fprintf(stderr, "Expected '%s' to match '%s'\n", str, dst);
7844 goto failed;
7845 }
7846
7847 if (strlen(str) != converted_size) {
7848 d_fprintf(stderr, "Expected '%s' length %d - got %d\n", str,
7849 (int)strlen(str), (int)converted_size);
7850 goto failed;
7851 }
7852
7853 if (dst[converted_size] != 'X') {
7854 d_fprintf(stderr, "Expected no termination of '%s'\n", dst);
7855 goto failed;
7856 }
7857
7858 /* now with srclen==-1, this causes the nul to be
7859 * converted too */
7860 ret = convert_string_error(CH_UNIX, CH_UTF8,
7861 str, -1,
7862 dst, sizeof(dst),
7863 &converted_size);
7864 if (ret != true) {
7865 d_fprintf(stderr, "Failed to convert '%s' to CH_DISPLAY\n", str);
7866 goto failed;
7867 }
7868
7869 if (converted_size != len+1) {
7870 d_fprintf(stderr, "Converted size of '%s' should be %d - got %d\n",
7871 str, len, (int)converted_size);
7872 goto failed;
7873 }
7874
7875 if (strncmp(str, dst, converted_size) != 0) {
7876 d_fprintf(stderr, "Expected '%s' to match '%s'\n", str, dst);
7877 goto failed;
7878 }
7879
7880 if (len+1 != converted_size) {
7881 d_fprintf(stderr, "Expected '%s' length %d - got %d\n", str,
7882 len+1, (int)converted_size);
7883 goto failed;
7884 }
7885
7886 if (dst[converted_size] != 'X') {
7887 d_fprintf(stderr, "Expected no termination of '%s'\n", dst);
7888 goto failed;
7889 }
7890
7891 }
7892
7893
7894 TALLOC_FREE(tmp_ctx);
7895 return true;
7896 failed:
7897 TALLOC_FREE(tmp_ctx);
7898 return false;
7899 }
7900
7901
7902 struct talloc_dict_test {
7903 int content;
7904 };
7905
7906 static int talloc_dict_traverse_fn(DATA_BLOB key, void *data, void *priv)
7907 {
7908 int *count = (int *)priv;
7909 *count += 1;
7910 return 0;
7911 }
7912
7913 static bool run_local_talloc_dict(int dummy)
7914 {
7915 struct talloc_dict *dict;
7916 struct talloc_dict_test *t;
7917 int key, count;
7918
7919 dict = talloc_dict_init(talloc_tos());
7920 if (dict == NULL) {
7921 return false;
7922 }
7923
7924 t = talloc(talloc_tos(), struct talloc_dict_test);
7925 if (t == NULL) {
7926 return false;
7927 }
7928
7929 key = 1;
7930 t->content = 1;
7931 if (!talloc_dict_set(dict, data_blob_const(&key, sizeof(key)), t)) {
7932 return false;
7933 }
7934
7935 count = 0;
7936 if (talloc_dict_traverse(dict, talloc_dict_traverse_fn, &count) != 0) {
7937 return false;
7938 }
7939
7940 if (count != 1) {
7941 return false;
7942 }
7943
7944 TALLOC_FREE(dict);
7945
7946 return true;
7947 }
7948
7949 static bool run_local_string_to_sid(int dummy) {
7950 struct dom_sid sid;
7951
7952 if (string_to_sid(&sid, "S--1-5-32-545")) {
7953 printf("allowing S--1-5-32-545\n");
7954 return false;
7955 }
7956 if (string_to_sid(&sid, "S-1-5-32-+545")) {
7957 printf("allowing S-1-5-32-+545\n");
7958 return false;
7959 }
7960 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")) {
7961 printf("allowing S-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0\n");
7962 return false;
7963 }
7964 if (string_to_sid(&sid, "S-1-5-32-545-abc")) {
7965 printf("allowing S-1-5-32-545-abc\n");
7966 return false;
7967 }
7968 if (!string_to_sid(&sid, "S-1-5-32-545")) {
7969 printf("could not parse S-1-5-32-545\n");
7970 return false;
7971 }
7972 if (!dom_sid_equal(&sid, &global_sid_Builtin_Users)) {
7973 printf("mis-parsed S-1-5-32-545 as %s\n",
7974 sid_string_tos(&sid));
7975 return false;
7976 }
7977 return true;
7978 }
7979
7980 static bool run_local_binary_to_sid(int dummy) {
7981 struct dom_sid *sid = talloc(NULL, struct dom_sid);
7982 static const char good_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 };
8002
8003 static const char long_binary_sid[] = {
8004 0x1, /* revision number */
8005 15, /* num auths */
8006 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
8007 0x1, 0x1, 0x1, 0x1, /* auth[0] */
8008 0x1, 0x1, 0x1, 0x1, /* auth[1] */
8009 0x1, 0x1, 0x1, 0x1, /* auth[2] */
8010 0x1, 0x1, 0x1, 0x1, /* auth[3] */
8011 0x1, 0x1, 0x1, 0x1, /* auth[4] */
8012 0x1, 0x1, 0x1, 0x1, /* auth[5] */
8013 0x1, 0x1, 0x1, 0x1, /* auth[6] */
8014 0x1, 0x1, 0x1, 0x1, /* auth[7] */
8015 0x1, 0x1, 0x1, 0x1, /* auth[8] */
8016 0x1, 0x1, 0x1, 0x1, /* auth[9] */
8017 0x1, 0x1, 0x1, 0x1, /* auth[10] */
8018 0x1, 0x1, 0x1, 0x1, /* auth[11] */
8019 0x1, 0x1, 0x1, 0x1, /* auth[12] */
8020 0x1, 0x1, 0x1, 0x1, /* auth[13] */
8021 0x1, 0x1, 0x1, 0x1, /* auth[14] */
8022 0x1, 0x1, 0x1, 0x1, /* auth[15] */
8023 0x1, 0x1, 0x1, 0x1, /* auth[16] */
8024 0x1, 0x1, 0x1, 0x1, /* auth[17] */
8025 };
8026
8027 static const char long_binary_sid2[] = {
8028 0x1, /* revision number */
8029 32, /* num auths */
8030 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
8031 0x1, 0x1, 0x1, 0x1, /* auth[0] */
8032 0x1, 0x1, 0x1, 0x1, /* auth[1] */
8033 0x1, 0x1, 0x1, 0x1, /* auth[2] */
8034 0x1, 0x1, 0x1, 0x1, /* auth[3] */
8035 0x1, 0x1, 0x1, 0x1, /* auth[4] */
8036 0x1, 0x1, 0x1, 0x1, /* auth[5] */
8037 0x1, 0x1, 0x1, 0x1, /* auth[6] */
8038 0x1, 0x1, 0x1, 0x1, /* auth[7] */
8039 0x1, 0x1, 0x1, 0x1, /* auth[8] */
8040 0x1, 0x1, 0x1, 0x1, /* auth[9] */
8041 0x1, 0x1, 0x1, 0x1, /* auth[10] */
8042 0x1, 0x1, 0x1, 0x1, /* auth[11] */
8043 0x1, 0x1, 0x1, 0x1, /* auth[12] */
8044 0x1, 0x1, 0x1, 0x1, /* auth[13] */
8045 0x1, 0x1, 0x1, 0x1, /* auth[14] */
8046 0x1, 0x1, 0x1, 0x1, /* auth[15] */
8047 0x1, 0x1, 0x1, 0x1, /* auth[16] */
8048 0x1, 0x1, 0x1, 0x1, /* auth[17] */
8049 0x1, 0x1, 0x1, 0x1, /* auth[18] */
8050 0x1, 0x1, 0x1, 0x1, /* auth[19] */
8051 0x1, 0x1, 0x1, 0x1, /* auth[20] */
8052 0x1, 0x1, 0x1, 0x1, /* auth[21] */
8053 0x1, 0x1, 0x1, 0x1, /* auth[22] */
8054 0x1, 0x1, 0x1, 0x1, /* auth[23] */
8055 0x1, 0x1, 0x1, 0x1, /* auth[24] */
8056 0x1, 0x1, 0x1, 0x1, /* auth[25] */
8057 0x1, 0x1, 0x1, 0x1, /* auth[26] */
8058 0x1, 0x1, 0x1, 0x1, /* auth[27] */
8059 0x1, 0x1, 0x1, 0x1, /* auth[28] */
8060 0x1, 0x1, 0x1, 0x1, /* auth[29] */
8061 0x1, 0x1, 0x1, 0x1, /* auth[30] */
8062 0x1, 0x1, 0x1, 0x1, /* auth[31] */
8063 };
8064
8065 if (!sid_parse(good_binary_sid, sizeof(good_binary_sid), sid)) {
8066 return false;
8067 }
8068 if (sid_parse(long_binary_sid2, sizeof(long_binary_sid2), sid)) {
8069 return false;
8070 }
8071 if (sid_parse(long_binary_sid, sizeof(long_binary_sid), sid)) {
8072 return false;
8073 }
8074 return true;
8075 }
8076
8077 /* Split a path name into filename and stream name components. Canonicalise
8078 * such that an implicit $DATA token is always explicit.
8079 *
8080 * The "specification" of this function can be found in the
8081 * run_local_stream_name() function in torture.c, I've tried those
8082 * combinations against a W2k3 server.
8083 */
8084
8085 static NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
8086 char **pbase, char **pstream)
8087 {
8088 char *base = NULL;
8089 char *stream = NULL;
8090 char *sname; /* stream name */
8091 const char *stype; /* stream type */
8092
8093 DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
8094
8095 sname = strchr_m(fname, ':');
8096
8097 if (lp_posix_pathnames() || (sname == NULL)) {
8098 if (pbase != NULL) {
8099 base = talloc_strdup(mem_ctx, fname);
8100 NT_STATUS_HAVE_NO_MEMORY(base);
8101 }
8102 goto done;
8103 }
8104
8105 if (pbase != NULL) {
8106 base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
8107 NT_STATUS_HAVE_NO_MEMORY(base);
8108 }
8109
8110 sname += 1;
8111
8112 stype = strchr_m(sname, ':');
8113
8114 if (stype == NULL) {
8115 sname = talloc_strdup(mem_ctx, sname);
8116 stype = "$DATA";
8117 }
8118 else {
8119 if (strcasecmp_m(stype, ":$DATA") != 0) {
8120 /*
8121 * If there is an explicit stream type, so far we only
8122 * allow $DATA. Is there anything else allowed? -- vl
8123 */
8124 DEBUG(10, ("[%s] is an invalid stream type\n", stype));
8125 TALLOC_FREE(base);
8126 return NT_STATUS_OBJECT_NAME_INVALID;
8127 }
8128 sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
8129 stype += 1;
8130 }
8131
8132 if (sname == NULL) {
8133 TALLOC_FREE(base);
8134 return NT_STATUS_NO_MEMORY;
8135 }
8136
8137 if (sname[0] == '\0') {
8138 /*
8139 * no stream name, so no stream
8140 */
8141 goto done;
8142 }
8143
8144 if (pstream != NULL) {
8145 stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
8146 if (stream == NULL) {
8147 TALLOC_FREE(sname);
8148 TALLOC_FREE(base);
8149 return NT_STATUS_NO_MEMORY;
8150 }
8151 /*
8152 * upper-case the type field
8153 */
8154 strupper_m(strchr_m(stream, ':')+1);
8155 }
8156
8157 done:
8158 if (pbase != NULL) {
8159 *pbase = base;
8160 }
8161 if (pstream != NULL) {
8162 *pstream = stream;
8163 }
8164 return NT_STATUS_OK;
8165 }
8166
8167 static bool test_stream_name(const char *fname, const char *expected_base,
8168 const char *expected_stream,
8169 NTSTATUS expected_status)
8170 {
8171 NTSTATUS status;
8172 char *base = NULL;
8173 char *stream = NULL;
8174
8175 status = split_ntfs_stream_name(talloc_tos(), fname, &base, &stream);
8176 if (!NT_STATUS_EQUAL(status, expected_status)) {
8177 goto error;
8178 }
8179
8180 if (!NT_STATUS_IS_OK(status)) {
8181 return true;
8182 }
8183
8184 if (base == NULL) goto error;
8185
8186 if (strcmp(expected_base, base) != 0) goto error;
8187
8188 if ((expected_stream != NULL) && (stream == NULL)) goto error;
8189 if ((expected_stream == NULL) && (stream != NULL)) goto error;
8190
8191 if ((stream != NULL) && (strcmp(expected_stream, stream) != 0))
8192 goto error;
8193
8194 TALLOC_FREE(base);
8195 TALLOC_FREE(stream);
8196 return true;
8197
8198 error:
8199 d_fprintf(stderr, "Do test_stream(%s, %s, %s, %s)\n",
8200 fname, expected_base ? expected_base : "<NULL>",
8201 expected_stream ? expected_stream : "<NULL>",
8202 nt_errstr(expected_status));
8203 d_fprintf(stderr, "-> base=%s, stream=%s, status=%s\n",
8204 base ? base : "<NULL>", stream ? stream : "<NULL>",
8205 nt_errstr(status));
8206 TALLOC_FREE(base);
8207 TALLOC_FREE(stream);
8208 return false;
8209 }
8210
8211 static bool run_local_stream_name(int dummy)
8212 {
8213 bool ret = true;
8214
8215 ret &= test_stream_name(
8216 "bla", "bla", NULL, NT_STATUS_OK);
8217 ret &= test_stream_name(
8218 "bla::$DATA", "bla", NULL, NT_STATUS_OK);
8219 ret &= test_stream_name(
8220 "bla:blub:", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
8221 ret &= test_stream_name(
8222 "bla::", NULL, NULL, NT_STATUS_OBJECT_NAME_INVALID);
8223 ret &= test_stream_name(
8224 "bla::123", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
8225 ret &= test_stream_name(
8226 "bla:$DATA", "bla", "$DATA:$DATA", NT_STATUS_OK);
8227 ret &= test_stream_name(
8228 "bla:x:$DATA", "bla", "x:$DATA", NT_STATUS_OK);
8229 ret &= test_stream_name(
8230 "bla:x", "bla", "x:$DATA", NT_STATUS_OK);
8231
8232 return ret;
8233 }
8234
8235 static bool data_blob_equal(DATA_BLOB a, DATA_BLOB b)
8236 {
8237 if (a.length != b.length) {
8238 printf("a.length=%d != b.length=%d\n",
8239 (int)a.length, (int)b.length);
8240 return false;
8241 }
8242 if (memcmp(a.data, b.data, a.length) != 0) {
8243 printf("a.data and b.data differ\n");
8244 return false;
8245 }
8246 return true;
8247 }
8248
8249 static bool run_local_memcache(int dummy)
8250 {
8251 struct memcache *cache;
8252 DATA_BLOB k1, k2;
8253 DATA_BLOB d1, d2, d3;
8254 DATA_BLOB v1, v2, v3;
8255
8256 TALLOC_CTX *mem_ctx;
8257 char *str1, *str2;
8258 size_t size1, size2;
8259 bool ret = false;
8260
8261 cache = memcache_init(NULL, 100);
8262
8263 if (cache == NULL) {
8264 printf("memcache_init failed\n");
8265 return false;
8266 }
8267
8268 d1 = data_blob_const("d1", 2);
8269 d2 = data_blob_const("d2", 2);
8270 d3 = data_blob_const("d3", 2);
8271
8272 k1 = data_blob_const("d1", 2);
8273 k2 = data_blob_const("d2", 2);
8274
8275 memcache_add(cache, STAT_CACHE, k1, d1);
8276 memcache_add(cache, GETWD_CACHE, k2, d2);
8277
8278 if (!memcache_lookup(cache, STAT_CACHE, k1, &v1)) {
8279 printf("could not find k1\n");
8280 return false;
8281 }
8282 if (!data_blob_equal(d1, v1)) {
8283 return false;
8284 }
8285
8286 if (!memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
8287 printf("could not find k2\n");
8288 return false;
8289 }
8290 if (!data_blob_equal(d2, v2)) {
8291 return false;
8292 }
8293
8294 memcache_add(cache, STAT_CACHE, k1, d3);
8295
8296 if (!memcache_lookup(cache, STAT_CACHE, k1, &v3)) {
8297 printf("could not find replaced k1\n");
8298 return false;
8299 }
8300 if (!data_blob_equal(d3, v3)) {
8301 return false;
8302 }
8303
8304 memcache_add(cache, GETWD_CACHE, k1, d1);
8305
8306 if (memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
8307 printf("Did find k2, should have been purged\n");
8308 return false;
8309 }
8310
8311 TALLOC_FREE(cache);
8312
8313 cache = memcache_init(NULL, 0);
8314
8315 mem_ctx = talloc_init("foo");
8316
8317 str1 = talloc_strdup(mem_ctx, "string1");
8318 str2 = talloc_strdup(mem_ctx, "string2");
8319
8320 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
8321 data_blob_string_const("torture"), &str1);
8322 size1 = talloc_total_size(cache);
8323
8324 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
8325 data_blob_string_const("torture"), &str2);
8326 size2 = talloc_total_size(cache);
8327
8328 printf("size1=%d, size2=%d\n", (int)size1, (int)size2);
8329
8330 if (size2 > size1) {
8331 printf("memcache leaks memory!\n");
8332 goto fail;
8333 }
8334
8335 ret = true;
8336 fail:
8337 TALLOC_FREE(cache);
8338 return ret;
8339 }
8340
8341 static void wbclient_done(struct tevent_req *req)
8342 {
8343 wbcErr wbc_err;
8344 struct winbindd_response *wb_resp;
8345 int *i = (int *)tevent_req_callback_data_void(req);
8346
8347 wbc_err = wb_trans_recv(req, req, &wb_resp);
8348 TALLOC_FREE(req);
8349 *i += 1;
8350 d_printf("wb_trans_recv %d returned %s\n", *i, wbcErrorString(wbc_err));
8351 }
8352
8353 static bool run_local_wbclient(int dummy)
8354 {
8355 struct event_context *ev;
8356 struct wb_context **wb_ctx;
8357 struct winbindd_request wb_req;
8358 bool result = false;
8359 int i, j;
8360
8361 BlockSignals(True, SIGPIPE);
8362
8363 ev = tevent_context_init_byname(talloc_tos(), "epoll");
8364 if (ev == NULL) {
8365 goto fail;
8366 }
8367
8368 wb_ctx = talloc_array(ev, struct wb_context *, nprocs);
8369 if (wb_ctx == NULL) {
8370 goto fail;
8371 }
8372
8373 ZERO_STRUCT(wb_req);
8374 wb_req.cmd = WINBINDD_PING;
8375
8376 d_printf("nprocs=%d, numops=%d\n", (int)nprocs, (int)torture_numops);
8377
8378 for (i=0; i<nprocs; i++) {
8379 wb_ctx[i] = wb_context_init(ev, NULL);
8380 if (wb_ctx[i] == NULL) {
8381 goto fail;
8382 }
8383 for (j=0; j<torture_numops; j++) {
8384 struct tevent_req *req;
8385 req = wb_trans_send(ev, ev, wb_ctx[i],
8386 (j % 2) == 0, &wb_req);
8387 if (req == NULL) {
8388 goto fail;
8389 }
8390 tevent_req_set_callback(req, wbclient_done, &i);
8391 }
8392 }
8393
8394 i = 0;
8395
8396 while (i < nprocs * torture_numops) {
8397 event_loop_once(ev);
8398 }
8399
8400 result = true;
8401 fail:
8402 TALLOC_FREE(ev);
8403 return result;
8404 }
8405
8406 static void getaddrinfo_finished(struct tevent_req *req)
8407 {
8408 char *name = (char *)tevent_req_callback_data_void(req);
8409 struct addrinfo *ainfo;
8410 int res;
8411
8412 res = getaddrinfo_recv(req, &ainfo);
8413 if (res != 0) {
8414 d_printf("gai(%s) returned %s\n", name, gai_strerror(res));
8415 return;
8416 }
8417 d_printf("gai(%s) succeeded\n", name);
8418 freeaddrinfo(ainfo);
8419 }
8420
8421 static bool run_getaddrinfo_send(int dummy)
8422 {
8423 TALLOC_CTX *frame = talloc_stackframe();
8424 struct fncall_context *ctx;
8425 struct tevent_context *ev;
8426 bool result = false;
8427 const char *names[4] = { "www.samba.org", "notfound.samba.org",
8428 "www.slashdot.org", "heise.de" };
8429 struct tevent_req *reqs[4];
8430 int i;
8431
8432 ev = event_context_init(frame);
8433 if (ev == NULL) {
8434 goto fail;
8435 }
8436
8437 ctx = fncall_context_init(frame, 4);
8438
8439 for (i=0; i<ARRAY_SIZE(names); i++) {
8440 reqs[i] = getaddrinfo_send(frame, ev, ctx, names[i], NULL,
8441 NULL);
8442 if (reqs[i] == NULL) {
8443 goto fail;
8444 }
8445 tevent_req_set_callback(reqs[i], getaddrinfo_finished,
8446 discard_const_p(void, names[i]));
8447 }
8448
8449 for (i=0; i<ARRAY_SIZE(reqs); i++) {
8450 tevent_loop_once(ev);
8451 }
8452
8453 result = true;
8454 fail:
8455 TALLOC_FREE(frame);
8456 return result;
8457 }
8458
8459 static bool dbtrans_inc(struct db_context *db)
8460 {
8461 struct db_record *rec;
8462 uint32_t *val;
8463 bool ret = false;
8464 NTSTATUS status;
8465
8466 rec = db->fetch_locked(db, db, string_term_tdb_data("transtest"));
8467 if (rec == NULL) {
8468 printf(__location__ "fetch_lock failed\n");
8469 return false;
8470 }
8471
8472 if (rec->value.dsize != sizeof(uint32_t)) {
8473 printf(__location__ "value.dsize = %d\n",
8474 (int)rec->value.dsize);
8475 goto fail;
8476 }
8477
8478 val = (uint32_t *)rec->value.dptr;
8479 *val += 1;
8480
8481 status = rec->store(rec, make_tdb_data((uint8_t *)val,
8482 sizeof(uint32_t)),
8483 0);
8484 if (!NT_STATUS_IS_OK(status)) {
8485 printf(__location__ "store failed: %s\n",
8486 nt_errstr(status));
8487 goto fail;
8488 }
8489
8490 ret = true;
8491 fail:
8492 TALLOC_FREE(rec);
8493 return ret;
8494 }
8495
8496 static bool run_local_dbtrans(int dummy)
8497 {
8498 struct db_context *db;
8499 struct db_record *rec;
8500 NTSTATUS status;
8501 uint32_t initial;
8502 int res;
8503
8504 db = db_open(talloc_tos(), "transtest.tdb", 0, TDB_DEFAULT,
8505 O_RDWR|O_CREAT, 0600);
8506 if (db == NULL) {
8507 printf("Could not open transtest.db\n");
8508 return false;
8509 }
8510
8511 res = db->transaction_start(db);
8512 if (res != 0) {
8513 printf(__location__ "transaction_start failed\n");
8514 return false;
8515 }
8516
8517 rec = db->fetch_locked(db, db, string_term_tdb_data("transtest"));
8518 if (rec == NULL) {
8519 printf(__location__ "fetch_lock failed\n");
8520 return false;
8521 }
8522
8523 if (rec->value.dptr == NULL) {
8524 initial = 0;
8525 status = rec->store(
8526 rec, make_tdb_data((uint8_t *)&initial,
8527 sizeof(initial)),
8528 0);
8529 if (!NT_STATUS_IS_OK(status)) {
8530 printf(__location__ "store returned %s\n",
8531 nt_errstr(status));
8532 return false;
8533 }
8534 }
8535
8536 TALLOC_FREE(rec);
8537
8538 res = db->transaction_commit(db);
8539 if (res != 0) {
8540 printf(__location__ "transaction_commit failed\n");
8541 return false;
8542 }
8543
8544 while (true) {
8545 uint32_t val, val2;
8546 int i;
8547
8548 res = db->transaction_start(db);
8549 if (res != 0) {
8550 printf(__location__ "transaction_start failed\n");
8551 break;
8552 }
8553
8554 if (!dbwrap_fetch_uint32(db, "transtest", &val)) {
8555 printf(__location__ "dbwrap_fetch_uint32 failed\n");
8556 break;
8557 }
8558
8559 for (i=0; i<10; i++) {
8560 if (!dbtrans_inc(db)) {
8561 return false;
8562 }
8563 }
8564
8565 if (!dbwrap_fetch_uint32(db, "transtest", &val2)) {
8566 printf(__location__ "dbwrap_fetch_uint32 failed\n");
8567 break;
8568 }
8569
8570 if (val2 != val + 10) {
8571 printf(__location__ "val=%d, val2=%d\n",
8572 (int)val, (int)val2);
8573 break;
8574 }
8575
8576 printf("val2=%d\r", val2);
8577
8578 res = db->transaction_commit(db);
8579 if (res != 0) {
8580 printf(__location__ "transaction_commit failed\n");
8581 break;
8582 }
8583 }
8584
8585 TALLOC_FREE(db);
8586 return true;
8587 }
8588
8589 /*
8590 * Just a dummy test to be run under a debugger. There's no real way
8591 * to inspect the tevent_select specific function from outside of
8592 * tevent_select.c.
8593 */
8594
8595 static bool run_local_tevent_select(int dummy)
8596 {
8597 struct tevent_context *ev;
8598 struct tevent_fd *fd1, *fd2;
8599 bool result = false;
8600
8601 ev = tevent_context_init_byname(NULL, "select");
8602 if (ev == NULL) {
8603 d_fprintf(stderr, "tevent_context_init_byname failed\n");
8604 goto fail;
8605 }
8606
8607 fd1 = tevent_add_fd(ev, ev, 2, 0, NULL, NULL);
8608 if (fd1 == NULL) {
8609 d_fprintf(stderr, "tevent_add_fd failed\n");
8610 goto fail;
8611 }
8612 fd2 = tevent_add_fd(ev, ev, 3, 0, NULL, NULL);
8613 if (fd2 == NULL) {
8614 d_fprintf(stderr, "tevent_add_fd failed\n");
8615 goto fail;
8616 }
8617 TALLOC_FREE(fd2);
8618
8619 fd2 = tevent_add_fd(ev, ev, 1, 0, NULL, NULL);
8620 if (fd2 == NULL) {
8621 d_fprintf(stderr, "tevent_add_fd failed\n");
8622 goto fail;
8623 }
8624
8625 result = true;
8626 fail:
8627 TALLOC_FREE(ev);
8628 return result;
8629 }
8630
8631 static double create_procs(bool (*fn)(int), bool *result)
8632 {
8633 int i, status;
8634 volatile pid_t *child_status;
8635 volatile bool *child_status_out;
8636 int synccount;
8637 int tries = 8;
8638 struct timeval start;
8639
8640 synccount = 0;
8641
8642 child_status = (volatile pid_t *)shm_setup(sizeof(pid_t)*nprocs);
8643 if (!child_status) {
8644 printf("Failed to setup shared memory\n");
8645 return -1;
8646 }
8647
8648 child_status_out = (volatile bool *)shm_setup(sizeof(bool)*nprocs);
8649 if (!child_status_out) {
8650 printf("Failed to setup result status shared memory\n");
8651 return -1;
8652 }
8653
8654 for (i = 0; i < nprocs; i++) {
8655 child_status[i] = 0;
8656 child_status_out[i] = True;
8657 }
8658
8659 start = timeval_current();
8660
8661 for (i=0;i<nprocs;i++) {
8662 procnum = i;
8663 if (fork() == 0) {
8664 pid_t mypid = getpid();
8665 sys_srandom(((int)mypid) ^ ((int)time(NULL)));
8666
8667 slprintf(myname,sizeof(myname),"CLIENT%d", i);
8668
8669 while (1) {
8670 if (torture_open_connection(&current_cli, i)) break;
8671 if (tries-- == 0) {
8672 printf("pid %d failed to start\n", (int)getpid());
8673 _exit(1);
8674 }
8675 smb_msleep(10);
8676 }
8677
8678 child_status[i] = getpid();
8679
8680 while (child_status[i] && timeval_elapsed(&start) < 5) smb_msleep(2);
8681
8682 child_status_out[i] = fn(i);
8683 _exit(0);
8684 }
8685 }
8686
8687 do {
8688 synccount = 0;
8689 for (i=0;i<nprocs;i++) {
8690 if (child_status[i]) synccount++;
8691 }
8692 if (synccount == nprocs) break;
8693 smb_msleep(10);
8694 } while (timeval_elapsed(&start) < 30);
8695
8696 if (synccount != nprocs) {
8697 printf("FAILED TO START %d CLIENTS (started %d)\n", nprocs, synccount);
8698 *result = False;
8699 return timeval_elapsed(&start);
8700 }
8701
8702 /* start the client load */
8703 start = timeval_current();
8704
8705 for (i=0;i<nprocs;i++) {
8706 child_status[i] = 0;
8707 }
8708
8709 printf("%d clients started\n", nprocs);
8710
8711 for (i=0;i<nprocs;i++) {
8712 while (waitpid(0, &status, 0) == -1 && errno == EINTR) /* noop */ ;
8713 }
8714
8715 printf("\n");
8716
8717 for (i=0;i<nprocs;i++) {
8718 if (!child_status_out[i]) {
8719 *result = False;
8720 }
8721 }
8722 return timeval_elapsed(&start);
8723 }
8724
8725 #define FLAG_MULTIPROC 1
8726
8727 static struct {
8728 const char *name;
8729 bool (*fn)(int);
8730 unsigned flags;
8731 } torture_ops[] = {
8732 {"FDPASS", run_fdpasstest, 0},
8733 {"LOCK1", run_locktest1, 0},
8734 {"LOCK2", run_locktest2, 0},
8735 {"LOCK3", run_locktest3, 0},
8736 {"LOCK4", run_locktest4, 0},
8737 {"LOCK5", run_locktest5, 0},
8738 {"LOCK6", run_locktest6, 0},
8739 {"LOCK7", run_locktest7, 0},
8740 {"LOCK8", run_locktest8, 0},
8741 {"LOCK9", run_locktest9, 0},
8742 {"UNLINK", run_unlinktest, 0},
8743 {"BROWSE", run_browsetest, 0},
8744 {"ATTR", run_attrtest, 0},
8745 {"TRANS2", run_trans2test, 0},
8746 {"MAXFID", run_maxfidtest, FLAG_MULTIPROC},
8747 {"TORTURE",run_torture, FLAG_MULTIPROC},
8748 {"RANDOMIPC", run_randomipc, 0},
8749 {"NEGNOWAIT", run_negprot_nowait, 0},
8750 {"NBENCH", run_nbench, 0},
8751 {"NBENCH2", run_nbench2, 0},
8752 {"OPLOCK1", run_oplock1, 0},
8753 {"OPLOCK2", run_oplock2, 0},
8754 {"OPLOCK4", run_oplock4, 0},
8755 {"DIR", run_dirtest, 0},
8756 {"DIR1", run_dirtest1, 0},
8757 {"DIR-CREATETIME", run_dir_createtime, 0},
8758 {"DENY1", torture_denytest1, 0},
8759 {"DENY2", torture_denytest2, 0},
8760 {"TCON", run_tcon_test, 0},
8761 {"TCONDEV", run_tcon_devtype_test, 0},
8762 {"RW1", run_readwritetest, 0},
8763 {"RW2", run_readwritemulti, FLAG_MULTIPROC},
8764 {"RW3", run_readwritelarge, 0},
8765 {"RW-SIGNING", run_readwritelarge_signtest, 0},
8766 {"OPEN", run_opentest, 0},
8767 {"POSIX", run_simple_posix_open_test, 0},
8768 {"POSIX-APPEND", run_posix_append, 0},
8769 {"CASE-INSENSITIVE-CREATE", run_case_insensitive_create, 0},
8770 {"ASYNC-ECHO", run_async_echo, 0},
8771 { "UID-REGRESSION-TEST", run_uid_regression_test, 0},
8772 { "SHORTNAME-TEST", run_shortname_test, 0},
8773 { "ADDRCHANGE", run_addrchange, 0},
8774 #if 1
8775 {"OPENATTR", run_openattrtest, 0},
8776 #endif
8777 {"XCOPY", run_xcopy, 0},
8778 {"RENAME", run_rename, 0},
8779 {"DELETE", run_deletetest, 0},
8780 {"DELETE-LN", run_deletetest_ln, 0},
8781 {"PROPERTIES", run_properties, 0},
8782 {"MANGLE", torture_mangle, 0},
8783 {"MANGLE1", run_mangle1, 0},
8784 {"W2K", run_w2ktest, 0},
8785 {"TRANS2SCAN", torture_trans2_scan, 0},
8786 {"NTTRANSSCAN", torture_nttrans_scan, 0},
8787 {"UTABLE", torture_utable, 0},
8788 {"CASETABLE", torture_casetable, 0},
8789 {"ERRMAPEXTRACT", run_error_map_extract, 0},
8790 {"PIPE_NUMBER", run_pipe_number, 0},
8791 {"TCON2", run_tcon2_test, 0},
8792 {"IOCTL", torture_ioctl_test, 0},
8793 {"CHKPATH", torture_chkpath_test, 0},
8794 {"FDSESS", run_fdsesstest, 0},
8795 { "EATEST", run_eatest, 0},
8796 { "SESSSETUP_BENCH", run_sesssetup_bench, 0},
8797 { "CHAIN1", run_chain1, 0},
8798 { "CHAIN2", run_chain2, 0},
8799 { "WINDOWS-WRITE", run_windows_write, 0},
8800 { "NTTRANS-CREATE", run_nttrans_create, 0},
8801 { "CLI_ECHO", run_cli_echo, 0},
8802 { "GETADDRINFO", run_getaddrinfo_send, 0},
8803 { "TLDAP", run_tldap },
8804 { "STREAMERROR", run_streamerror },
8805 { "NOTIFY-BENCH", run_notify_bench },
8806 { "BAD-NBT-SESSION", run_bad_nbt_session },
8807 { "SMB-ANY-CONNECT", run_smb_any_connect },
8808 { "NOTIFY-ONLINE", run_notify_online },
8809 { "SMB2-BASIC", run_smb2_basic },
8810 { "LOCAL-SUBSTITUTE", run_local_substitute, 0},
8811 { "LOCAL-GENCACHE", run_local_gencache, 0},
8812 { "LOCAL-TALLOC-DICT", run_local_talloc_dict, 0},
8813 { "LOCAL-BASE64", run_local_base64, 0},
8814 { "LOCAL-RBTREE", run_local_rbtree, 0},
8815 { "LOCAL-MEMCACHE", run_local_memcache, 0},
8816 { "LOCAL-STREAM-NAME", run_local_stream_name, 0},
8817 { "LOCAL-WBCLIENT", run_local_wbclient, 0},
8818 { "LOCAL-string_to_sid", run_local_string_to_sid, 0},
8819 { "LOCAL-binary_to_sid", run_local_binary_to_sid, 0},
8820 { "LOCAL-DBTRANS", run_local_dbtrans, 0},
8821 { "LOCAL-TEVENT-SELECT", run_local_tevent_select, 0},
8822 { "LOCAL-CONVERT-STRING", run_local_convert_string, 0},
8823 {NULL, NULL, 0}};
8824
8825
8826
8827 /****************************************************************************
8828 run a specified test or "ALL"
8829 ****************************************************************************/
8830 static bool run_test(const char *name)
8831 {
8832 bool ret = True;
8833 bool result = True;
8834 bool found = False;
8835 int i;
8836 double t;
8837 if (strequal(name,"ALL")) {
8838 for (i=0;torture_ops[i].name;i++) {
8839 run_test(torture_ops[i].name);
8840 }
8841 found = True;
8842 }
8843
8844 for (i=0;torture_ops[i].name;i++) {
8845 fstr_sprintf(randomfname, "\\XX%x",
8846 (unsigned)random());
8847
8848 if (strequal(name, torture_ops[i].name)) {
8849 found = True;
8850 printf("Running %s\n", name);
8851 if (torture_ops[i].flags & FLAG_MULTIPROC) {
8852 t = create_procs(torture_ops[i].fn, &result);
8853 if (!result) {
8854 ret = False;
8855 printf("TEST %s FAILED!\n", name);
8856 }
8857 } else {
8858 struct timeval start;
8859 start = timeval_current();
8860 if (!torture_ops[i].fn(0)) {
8861 ret = False;
8862 printf("TEST %s FAILED!\n", name);
8863 }
8864 t = timeval_elapsed(&start);
8865 }
8866 printf("%s took %g secs\n\n", name, t);
8867 }
8868 }
8869
8870 if (!found) {
8871 printf("Did not find a test named %s\n", name);
8872 ret = False;
8873 }
8874
8875 return ret;
8876 }
8877
8878
8879 static void usage(void)
8880 {
8881 int i;
8882
8883 printf("WARNING samba4 test suite is much more complete nowadays.\n");
8884 printf("Please use samba4 torture.\n\n");
8885
8886 printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
8887
8888 printf("\t-d debuglevel\n");
8889 printf("\t-U user%%pass\n");
8890 printf("\t-k use kerberos\n");
8891 printf("\t-N numprocs\n");
8892 printf("\t-n my_netbios_name\n");
8893 printf("\t-W workgroup\n");
8894 printf("\t-o num_operations\n");
8895 printf("\t-O socket_options\n");
8896 printf("\t-m maximum protocol\n");
8897 printf("\t-L use oplocks\n");
8898 printf("\t-c CLIENT.TXT specify client load file for NBENCH\n");
8899 printf("\t-A showall\n");
8900 printf("\t-p port\n");
8901 printf("\t-s seed\n");
8902 printf("\t-b unclist_filename specify multiple shares for multiple connections\n");
8903 printf("\t-f filename filename to test\n");
8904 printf("\n\n");
8905
8906 printf("tests are:");
8907 for (i=0;torture_ops[i].name;i++) {
8908 printf(" %s", torture_ops[i].name);
8909 }
8910 printf("\n");
8911
8912 printf("default test is ALL\n");
8913
8914 exit(1);
8915 }
8916
8917 /****************************************************************************
8918 main program
8919 ****************************************************************************/
8920 int main(int argc,char *argv[])
8921 {
8922 int opt, i;
8923 char *p;
8924 int gotuser = 0;
8925 int gotpass = 0;
8926 bool correct = True;
8927 TALLOC_CTX *frame = talloc_stackframe();
8928 int seed = time(NULL);
8929
8930 #ifdef HAVE_SETBUFFER
8931 setbuffer(stdout, NULL, 0);
8932 #endif
8933
8934 setup_logging("smbtorture", DEBUG_STDOUT);
8935
8936 load_case_tables();
8937
8938 if (is_default_dyn_CONFIGFILE()) {
8939 if(getenv("SMB_CONF_PATH")) {
8940 set_dyn_CONFIGFILE(getenv("SMB_CONF_PATH"));
8941 }
8942 }
8943 lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
8944 load_interfaces();
8945
8946 if (argc < 2) {
8947 usage();
8948 }
8949
8950 for(p = argv[1]; *p; p++)
8951 if(*p == '\\')
8952 *p = '/';
8953
8954 if (strncmp(argv[1], "//", 2)) {
8955 usage();
8956 }
8957
8958 fstrcpy(host, &argv[1][2]);
8959 p = strchr_m(&host[2],'/');
8960 if (!p) {
8961 usage();
8962 }
8963 *p = 0;
8964 fstrcpy(share, p+1);
8965
8966 fstrcpy(myname, get_myname(talloc_tos()));
8967 if (!*myname) {
8968 fprintf(stderr, "Failed to get my hostname.\n");
8969 return 1;
8970 }
8971
8972 if (*username == 0 && getenv("LOGNAME")) {
8973 fstrcpy(username,getenv("LOGNAME"));
8974 }
8975
8976 argc--;
8977 argv++;
8978
8979 fstrcpy(workgroup, lp_workgroup());
8980
8981 while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ll:d:Aec:ks:b:B:f:"))
8982 != EOF) {
8983 switch (opt) {
8984 case 'p':
8985 port_to_use = atoi(optarg);
8986 break;
8987 case 's':
8988 seed = atoi(optarg);
8989 break;
8990 case 'W':
8991 fstrcpy(workgroup,optarg);
8992 break;
8993 case 'm':
8994 max_protocol = interpret_protocol(optarg, max_protocol);
8995 break;
8996 case 'N':
8997 nprocs = atoi(optarg);
8998 break;
8999 case 'o':
9000 torture_numops = atoi(optarg);
9001 break;
9002 case 'd':
9003 lp_set_cmdline("log level", optarg);
9004 break;
9005 case 'O':
9006 sockops = optarg;
9007 break;
9008 case 'L':
9009 use_oplocks = True;
9010 break;
9011 case 'l':
9012 local_path = optarg;
9013 break;
9014 case 'A':
9015 torture_showall = True;
9016 break;
9017 case 'n':
9018 fstrcpy(myname, optarg);
9019 break;
9020 case 'c':
9021 client_txt = optarg;
9022 break;
9023 case 'e':
9024 do_encrypt = true;
9025 break;
9026 case 'k':
9027 #ifdef HAVE_KRB5
9028 use_kerberos = True;
9029 #else
9030 d_printf("No kerberos support compiled in\n");
9031 exit(1);
9032 #endif
9033 break;
9034 case 'U':
9035 gotuser = 1;
9036 fstrcpy(username,optarg);
9037 p = strchr_m(username,'%');
9038 if (p) {
9039 *p = 0;
9040 fstrcpy(password, p+1);
9041 gotpass = 1;
9042 }
9043 break;
9044 case 'b':
9045 fstrcpy(multishare_conn_fname, optarg);
9046 use_multishare_conn = True;
9047 break;
9048 case 'B':
9049 torture_blocksize = atoi(optarg);
9050 break;
9051 case 'f':
9052 test_filename = SMB_STRDUP(optarg);
9053 break;
9054 default:
9055 printf("Unknown option %c (%d)\n", (char)opt, opt);
9056 usage();
9057 }
9058 }
9059
9060 d_printf("using seed %d\n", seed);
9061
9062 srandom(seed);
9063
9064 if(use_kerberos && !gotuser) gotpass = True;
9065
9066 while (!gotpass) {
9067 p = getpass("Password:");
9068 if (p) {
9069 fstrcpy(password, p);
9070 gotpass = 1;
9071 }
9072 }
9073
9074 printf("host=%s share=%s user=%s myname=%s\n",
9075 host, share, username, myname);
9076
9077 if (argc == optind) {
9078 correct = run_test("ALL");
9079 } else {
9080 for (i=optind;i<argc;i++) {
9081 if (!run_test(argv[i])) {
9082 correct = False;
9083 }
9084 }
9085 }
9086
9087 TALLOC_FREE(frame);
9088
9089 if (correct) {
9090 return(0);
9091 } else {
9092 return(1);
9093 }
9094 }
reg import