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