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