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