?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
python: Print the finddcs error message
[Samba.git] / source3 / torture / torture.c
blobae502f280feeafd13702167ec87aaaacd1fc6bf1
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 "../lib/util/memcache.h"
30 #include "nsswitch/winbind_client.h"
31 #include "dbwrap/dbwrap.h"
32 #include "dbwrap/dbwrap_open.h"
33 #include "dbwrap/dbwrap_rbt.h"
34 #include "async_smb.h"
35 #include "libsmb/libsmb.h"
36 #include "libsmb/clirap.h"
37 #include "trans2.h"
38 #include "libsmb/nmblib.h"
39 #include "../lib/util/tevent_ntstatus.h"
40 #include "util_tdb.h"
41 #include "../libcli/smb/read_smb.h"
42 #include "../libcli/smb/smbXcli_base.h"
43 #include "lib/util/sys_rw_data.h"
44 #include "lib/util/base64.h"
45 #include "lib/util/time.h"
46
47 extern char *optarg;
48 extern int optind;
49
50 fstring host, workgroup, share, password, username, myname;
51 struct cli_credentials *torture_creds;
52 static const char *sockops="TCP_NODELAY";
53 int torture_nprocs=1;
54 static int port_to_use=0;
55 int torture_numops=100;
56 int torture_blocksize=1024*1024;
57 static int procnum; /* records process count number when forking */
58 static struct cli_state *current_cli;
59 static fstring randomfname;
60 static bool use_oplocks;
61 static bool use_level_II_oplocks;
62 static const char *client_txt = "client_oplocks.txt";
63 static bool disable_spnego;
64 static bool use_kerberos;
65 static bool force_dos_errors;
66 static fstring multishare_conn_fname;
67 static bool use_multishare_conn = False;
68 static bool do_encrypt;
69 static const char *local_path = NULL;
70 static enum smb_signing_setting signing_state = SMB_SIGNING_DEFAULT;
71 char *test_filename;
72
73 bool torture_showall = False;
74
75 static double create_procs(bool (*fn)(int), bool *result);
76
77 /********************************************************************
78 Ensure a connection is encrypted.
79 ********************************************************************/
80
81 static bool force_cli_encryption(struct cli_state *c,
82 const char *sharename)
83 {
84 uint16_t major, minor;
85 uint32_t caplow, caphigh;
86 NTSTATUS status;
87
88 if (!SERVER_HAS_UNIX_CIFS(c)) {
89 d_printf("Encryption required and "
90 "server that doesn't support "
91 "UNIX extensions - failing connect\n");
92 return false;
93 }
94
95 status = cli_unix_extensions_version(c, &major, &minor, &caplow,
96 &caphigh);
97 if (!NT_STATUS_IS_OK(status)) {
98 d_printf("Encryption required and "
99 "can't get UNIX CIFS extensions "
100 "version from server: %s\n", nt_errstr(status));
101 return false;
102 }
103
104 if (!(caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)) {
105 d_printf("Encryption required and "
106 "share %s doesn't support "
107 "encryption.\n", sharename);
108 return false;
109 }
110
111 status = cli_smb1_setup_encryption(c, torture_creds);
112 if (!NT_STATUS_IS_OK(status)) {
113 d_printf("Encryption required and "
114 "setup failed with error %s.\n",
115 nt_errstr(status));
116 return false;
117 }
118
119 return true;
120 }
121
122
123 static struct cli_state *open_nbt_connection(void)
124 {
125 struct cli_state *c;
126 NTSTATUS status;
127 int flags = 0;
128
129 if (disable_spnego) {
130 flags |= CLI_FULL_CONNECTION_DONT_SPNEGO;
131 }
132
133 if (use_oplocks) {
134 flags |= CLI_FULL_CONNECTION_OPLOCKS;
135 }
136
137 if (use_level_II_oplocks) {
138 flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS;
139 }
140
141 if (use_kerberos) {
142 flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
143 }
144
145 if (force_dos_errors) {
146 flags |= CLI_FULL_CONNECTION_FORCE_DOS_ERRORS;
147 }
148
149 status = cli_connect_nb(host, NULL, port_to_use, 0x20, myname,
150 signing_state, flags, &c);
151 if (!NT_STATUS_IS_OK(status)) {
152 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
153 return NULL;
154 }
155
156 cli_set_timeout(c, 120000); /* set a really long timeout (2 minutes) */
157
158 return c;
159 }
160
161 /****************************************************************************
162 Send a corrupt session request. See rfc1002.txt 4.3 and 4.3.2.
163 ****************************************************************************/
164
165 static bool cli_bad_session_request(int fd,
166 struct nmb_name *calling, struct nmb_name *called)
167 {
168 TALLOC_CTX *frame;
169 uint8_t len_buf[4];
170 struct iovec iov[3];
171 ssize_t len;
172 uint8_t *inbuf;
173 int err;
174 bool ret = false;
175 uint8_t message_type;
176 uint8_t error;
177 struct tevent_context *ev;
178 struct tevent_req *req;
179
180 frame = talloc_stackframe();
181
182 iov[0].iov_base = len_buf;
183 iov[0].iov_len = sizeof(len_buf);
184
185 /* put in the destination name */
186
187 iov[1].iov_base = name_mangle(talloc_tos(), called->name,
188 called->name_type);
189 if (iov[1].iov_base == NULL) {
190 goto fail;
191 }
192 iov[1].iov_len = name_len((unsigned char *)iov[1].iov_base,
193 talloc_get_size(iov[1].iov_base));
194
195 /* and my name */
196
197 iov[2].iov_base = name_mangle(talloc_tos(), calling->name,
198 calling->name_type);
199 if (iov[2].iov_base == NULL) {
200 goto fail;
201 }
202 iov[2].iov_len = name_len((unsigned char *)iov[2].iov_base,
203 talloc_get_size(iov[2].iov_base));
204
205 /* Deliberately corrupt the name len (first byte) */
206 *((uint8_t *)iov[2].iov_base) = 100;
207
208 /* send a session request (RFC 1002) */
209 /* setup the packet length
210 * Remove four bytes from the length count, since the length
211 * field in the NBT Session Service header counts the number
212 * of bytes which follow. The cli_send_smb() function knows
213 * about this and accounts for those four bytes.
214 * CRH.
215 */
216
217 _smb_setlen(len_buf, iov[1].iov_len + iov[2].iov_len);
218 SCVAL(len_buf,0,0x81);
219
220 len = write_data_iov(fd, iov, 3);
221 if (len == -1) {
222 goto fail;
223 }
224
225 ev = samba_tevent_context_init(frame);
226 if (ev == NULL) {
227 goto fail;
228 }
229 req = read_smb_send(frame, ev, fd);
230 if (req == NULL) {
231 goto fail;
232 }
233 if (!tevent_req_poll(req, ev)) {
234 goto fail;
235 }
236 len = read_smb_recv(req, talloc_tos(), &inbuf, &err);
237 if (len == -1) {
238 errno = err;
239 goto fail;
240 }
241 TALLOC_FREE(ev);
242
243 message_type = CVAL(inbuf, 0);
244 if (message_type != 0x83) {
245 d_fprintf(stderr, "Expected msg type 0x83, got 0x%2.2x\n",
246 message_type);
247 goto fail;
248 }
249
250 if (smb_len(inbuf) != 1) {
251 d_fprintf(stderr, "Expected smb_len 1, got %d\n",
252 (int)smb_len(inbuf));
253 goto fail;
254 }
255
256 error = CVAL(inbuf, 4);
257 if (error != 0x82) {
258 d_fprintf(stderr, "Expected error 0x82, got %d\n",
259 (int)error);
260 goto fail;
261 }
262
263 ret = true;
264 fail:
265 TALLOC_FREE(frame);
266 return ret;
267 }
268
269 /* Insert a NULL at the first separator of the given path and return a pointer
270 * to the remainder of the string.
271 */
272 static char *
273 terminate_path_at_separator(char * path)
274 {
275 char * p;
276
277 if (!path) {
278 return NULL;
279 }
280
281 if ((p = strchr_m(path, '/'))) {
282 *p = '\0';
283 return p + 1;
284 }
285
286 if ((p = strchr_m(path, '\\'))) {
287 *p = '\0';
288 return p + 1;
289 }
290
291 /* No separator. */
292 return NULL;
293 }
294
295 /*
296 parse a //server/share type UNC name
297 */
298 bool smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
299 char **hostname, char **sharename)
300 {
301 char *p;
302
303 *hostname = *sharename = NULL;
304
305 if (strncmp(unc_name, "\\\\", 2) &&
306 strncmp(unc_name, "//", 2)) {
307 return False;
308 }
309
310 *hostname = talloc_strdup(mem_ctx, &unc_name[2]);
311 p = terminate_path_at_separator(*hostname);
312
313 if (p && *p) {
314 *sharename = talloc_strdup(mem_ctx, p);
315 terminate_path_at_separator(*sharename);
316 }
317
318 if (*hostname && *sharename) {
319 return True;
320 }
321
322 TALLOC_FREE(*hostname);
323 TALLOC_FREE(*sharename);
324 return False;
325 }
326
327 static bool torture_open_connection_share(struct cli_state **c,
328 const char *hostname,
329 const char *sharename,
330 int flags)
331 {
332 NTSTATUS status;
333
334 status = cli_full_connection_creds(c,
335 myname,
336 hostname,
337 NULL, /* dest_ss */
338 port_to_use,
339 sharename,
340 "?????",
341 torture_creds,
342 flags,
343 signing_state);
344 if (!NT_STATUS_IS_OK(status)) {
345 printf("failed to open share connection: //%s/%s port:%d - %s\n",
346 hostname, sharename, port_to_use, nt_errstr(status));
347 return False;
348 }
349
350 cli_set_timeout(*c, 120000); /* set a really long timeout (2 minutes) */
351
352 if (do_encrypt) {
353 return force_cli_encryption(*c,
354 sharename);
355 }
356 return True;
357 }
358
359 bool torture_open_connection_flags(struct cli_state **c, int conn_index, int flags)
360 {
361 char **unc_list = NULL;
362 int num_unc_names = 0;
363 bool result;
364
365 if (use_multishare_conn==True) {
366 char *h, *s;
367 unc_list = file_lines_load(multishare_conn_fname, &num_unc_names, 0, NULL);
368 if (!unc_list || num_unc_names <= 0) {
369 printf("Failed to load unc names list from '%s'\n", multishare_conn_fname);
370 exit(1);
371 }
372
373 if (!smbcli_parse_unc(unc_list[conn_index % num_unc_names],
374 NULL, &h, &s)) {
375 printf("Failed to parse UNC name %s\n",
376 unc_list[conn_index % num_unc_names]);
377 TALLOC_FREE(unc_list);
378 exit(1);
379 }
380
381 result = torture_open_connection_share(c, h, s, flags);
382
383 /* h, s were copied earlier */
384 TALLOC_FREE(unc_list);
385 return result;
386 }
387
388 return torture_open_connection_share(c, host, share, flags);
389 }
390
391 bool torture_open_connection(struct cli_state **c, int conn_index)
392 {
393 int flags = CLI_FULL_CONNECTION_FORCE_SMB1;
394
395 if (use_oplocks) {
396 flags |= CLI_FULL_CONNECTION_OPLOCKS;
397 }
398 if (use_level_II_oplocks) {
399 flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS;
400 }
401
402 return torture_open_connection_flags(c, conn_index, flags);
403 }
404
405 bool torture_init_connection(struct cli_state **pcli)
406 {
407 struct cli_state *cli;
408
409 cli = open_nbt_connection();
410 if (cli == NULL) {
411 return false;
412 }
413
414 *pcli = cli;
415 return true;
416 }
417
418 bool torture_cli_session_setup2(struct cli_state *cli, uint16_t *new_vuid)
419 {
420 uint16_t old_vuid = cli_state_get_uid(cli);
421 NTSTATUS status;
422 bool ret;
423
424 cli_state_set_uid(cli, 0);
425 status = cli_session_setup_creds(cli, torture_creds);
426 ret = NT_STATUS_IS_OK(status);
427 *new_vuid = cli_state_get_uid(cli);
428 cli_state_set_uid(cli, old_vuid);
429 return ret;
430 }
431
432
433 bool torture_close_connection(struct cli_state *c)
434 {
435 bool ret = True;
436 NTSTATUS status;
437
438 status = cli_tdis(c);
439 if (!NT_STATUS_IS_OK(status)) {
440 printf("tdis failed (%s)\n", nt_errstr(status));
441 ret = False;
442 }
443
444 cli_shutdown(c);
445
446 return ret;
447 }
448
449
450 /* check if the server produced the expected dos or nt error code */
451 static bool check_both_error(int line, NTSTATUS status,
452 uint8_t eclass, uint32_t ecode, NTSTATUS nterr)
453 {
454 if (NT_STATUS_IS_DOS(status)) {
455 uint8_t cclass;
456 uint32_t num;
457
458 /* Check DOS error */
459 cclass = NT_STATUS_DOS_CLASS(status);
460 num = NT_STATUS_DOS_CODE(status);
461
462 if (eclass != cclass || ecode != num) {
463 printf("unexpected error code class=%d code=%d\n",
464 (int)cclass, (int)num);
465 printf(" expected %d/%d %s (line=%d)\n",
466 (int)eclass, (int)ecode, nt_errstr(nterr), line);
467 return false;
468 }
469 } else {
470 /* Check NT error */
471 if (!NT_STATUS_EQUAL(nterr, status)) {
472 printf("unexpected error code %s\n",
473 nt_errstr(status));
474 printf(" expected %s (line=%d)\n",
475 nt_errstr(nterr), line);
476 return false;
477 }
478 }
479
480 return true;
481 }
482
483
484 /* check if the server produced the expected error code */
485 static bool check_error(int line, NTSTATUS status,
486 uint8_t eclass, uint32_t ecode, NTSTATUS nterr)
487 {
488 if (NT_STATUS_IS_DOS(status)) {
489 uint8_t cclass;
490 uint32_t num;
491
492 /* Check DOS error */
493
494 cclass = NT_STATUS_DOS_CLASS(status);
495 num = NT_STATUS_DOS_CODE(status);
496
497 if (eclass != cclass || ecode != num) {
498 printf("unexpected error code class=%d code=%d\n",
499 (int)cclass, (int)num);
500 printf(" expected %d/%d %s (line=%d)\n",
501 (int)eclass, (int)ecode, nt_errstr(nterr),
502 line);
503 return False;
504 }
505
506 } else {
507 /* Check NT error */
508
509 if (NT_STATUS_V(nterr) != NT_STATUS_V(status)) {
510 printf("unexpected error code %s\n",
511 nt_errstr(status));
512 printf(" expected %s (line=%d)\n", nt_errstr(nterr),
513 line);
514 return False;
515 }
516 }
517
518 return True;
519 }
520
521
522 static bool wait_lock(struct cli_state *c, int fnum, uint32_t offset, uint32_t len)
523 {
524 NTSTATUS status;
525
526 status = cli_lock32(c, fnum, offset, len, -1, WRITE_LOCK);
527
528 while (!NT_STATUS_IS_OK(status)) {
529 if (!check_both_error(__LINE__, status, ERRDOS,
530 ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) {
531 return false;
532 }
533
534 status = cli_lock32(c, fnum, offset, len, -1, WRITE_LOCK);
535 }
536
537 return true;
538 }
539
540
541 static bool rw_torture(struct cli_state *c)
542 {
543 const char *lockfname = "\\torture.lck";
544 fstring fname;
545 uint16_t fnum;
546 uint16_t fnum2;
547 pid_t pid2, pid = getpid();
548 int i, j;
549 char buf[1024];
550 bool correct = True;
551 size_t nread = 0;
552 NTSTATUS status;
553
554 memset(buf, '\0', sizeof(buf));
555
556 status = cli_openx(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
557 DENY_NONE, &fnum2);
558 if (!NT_STATUS_IS_OK(status)) {
559 status = cli_openx(c, lockfname, O_RDWR, DENY_NONE, &fnum2);
560 }
561 if (!NT_STATUS_IS_OK(status)) {
562 printf("open of %s failed (%s)\n",
563 lockfname, nt_errstr(status));
564 return False;
565 }
566
567 for (i=0;i<torture_numops;i++) {
568 unsigned n = (unsigned)sys_random()%10;
569
570 if (i % 10 == 0) {
571 printf("%d\r", i); fflush(stdout);
572 }
573 slprintf(fname, sizeof(fstring) - 1, "\\torture.%u", n);
574
575 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
576 return False;
577 }
578
579 status = cli_openx(c, fname, O_RDWR | O_CREAT | O_TRUNC,
580 DENY_ALL, &fnum);
581 if (!NT_STATUS_IS_OK(status)) {
582 printf("open failed (%s)\n", nt_errstr(status));
583 correct = False;
584 break;
585 }
586
587 status = cli_writeall(c, fnum, 0, (uint8_t *)&pid, 0,
588 sizeof(pid), NULL);
589 if (!NT_STATUS_IS_OK(status)) {
590 printf("write failed (%s)\n", nt_errstr(status));
591 correct = False;
592 }
593
594 for (j=0;j<50;j++) {
595 status = cli_writeall(c, fnum, 0, (uint8_t *)buf,
596 sizeof(pid)+(j*sizeof(buf)),
597 sizeof(buf), NULL);
598 if (!NT_STATUS_IS_OK(status)) {
599 printf("write failed (%s)\n",
600 nt_errstr(status));
601 correct = False;
602 }
603 }
604
605 pid2 = 0;
606
607 status = cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid),
608 &nread);
609 if (!NT_STATUS_IS_OK(status)) {
610 printf("read failed (%s)\n", nt_errstr(status));
611 correct = false;
612 } else if (nread != sizeof(pid)) {
613 printf("read/write compare failed: "
614 "recv %ld req %ld\n", (unsigned long)nread,
615 (unsigned long)sizeof(pid));
616 correct = false;
617 }
618
619 if (pid2 != pid) {
620 printf("data corruption!\n");
621 correct = False;
622 }
623
624 status = cli_close(c, fnum);
625 if (!NT_STATUS_IS_OK(status)) {
626 printf("close failed (%s)\n", nt_errstr(status));
627 correct = False;
628 }
629
630 status = cli_unlink(c, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
631 if (!NT_STATUS_IS_OK(status)) {
632 printf("unlink failed (%s)\n", nt_errstr(status));
633 correct = False;
634 }
635
636 status = cli_unlock(c, fnum2, n*sizeof(int), sizeof(int));
637 if (!NT_STATUS_IS_OK(status)) {
638 printf("unlock failed (%s)\n", nt_errstr(status));
639 correct = False;
640 }
641 }
642
643 cli_close(c, fnum2);
644 cli_unlink(c, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
645
646 printf("%d\n", i);
647
648 return correct;
649 }
650
651 static bool run_torture(int dummy)
652 {
653 struct cli_state *cli;
654 bool ret;
655
656 cli = current_cli;
657
658 smbXcli_conn_set_sockopt(cli->conn, sockops);
659
660 ret = rw_torture(cli);
661
662 if (!torture_close_connection(cli)) {
663 ret = False;
664 }
665
666 return ret;
667 }
668
669 static bool rw_torture3(struct cli_state *c, char *lockfname)
670 {
671 uint16_t fnum = (uint16_t)-1;
672 unsigned int i = 0;
673 char buf[131072];
674 char buf_rd[131072];
675 unsigned count;
676 unsigned countprev = 0;
677 size_t sent = 0;
678 bool correct = True;
679 NTSTATUS status = NT_STATUS_OK;
680
681 srandom(1);
682 for (i = 0; i < sizeof(buf); i += sizeof(uint32_t))
683 {
684 SIVAL(buf, i, sys_random());
685 }
686
687 if (procnum == 0)
688 {
689 status = cli_unlink(
690 c, lockfname,
691 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
692 if (!NT_STATUS_IS_OK(status)) {
693 printf("unlink failed (%s) (normal, this file should "
694 "not exist)\n", nt_errstr(status));
695 }
696
697 status = cli_openx(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
698 DENY_NONE, &fnum);
699 if (!NT_STATUS_IS_OK(status)) {
700 printf("first open read/write of %s failed (%s)\n",
701 lockfname, nt_errstr(status));
702 return False;
703 }
704 }
705 else
706 {
707 for (i = 0; i < 500 && fnum == (uint16_t)-1; i++)
708 {
709 status = cli_openx(c, lockfname, O_RDONLY,
710 DENY_NONE, &fnum);
711 if (NT_STATUS_IS_OK(status)) {
712 break;
713 }
714 smb_msleep(10);
715 }
716 if (!NT_STATUS_IS_OK(status)) {
717 printf("second open read-only of %s failed (%s)\n",
718 lockfname, nt_errstr(status));
719 return False;
720 }
721 }
722
723 i = 0;
724 for (count = 0; count < sizeof(buf); count += sent)
725 {
726 if (count >= countprev) {
727 printf("%d %8d\r", i, count);
728 fflush(stdout);
729 i++;
730 countprev += (sizeof(buf) / 20);
731 }
732
733 if (procnum == 0)
734 {
735 sent = ((unsigned)sys_random()%(20))+ 1;
736 if (sent > sizeof(buf) - count)
737 {
738 sent = sizeof(buf) - count;
739 }
740
741 status = cli_writeall(c, fnum, 0, (uint8_t *)buf+count,
742 count, sent, NULL);
743 if (!NT_STATUS_IS_OK(status)) {
744 printf("write failed (%s)\n",
745 nt_errstr(status));
746 correct = False;
747 }
748 }
749 else
750 {
751 status = cli_read(c, fnum, buf_rd+count, count,
752 sizeof(buf)-count, &sent);
753 if(!NT_STATUS_IS_OK(status)) {
754 printf("read failed offset:%d size:%ld (%s)\n",
755 count, (unsigned long)sizeof(buf)-count,
756 nt_errstr(status));
757 correct = False;
758 sent = 0;
759 } else if (sent > 0) {
760 if (memcmp(buf_rd+count, buf+count, sent) != 0)
761 {
762 printf("read/write compare failed\n");
763 printf("offset: %d req %ld recvd %ld\n", count, (unsigned long)sizeof(buf)-count, (unsigned long)sent);
764 correct = False;
765 break;
766 }
767 }
768 }
769
770 }
771
772 status = cli_close(c, fnum);
773 if (!NT_STATUS_IS_OK(status)) {
774 printf("close failed (%s)\n", nt_errstr(status));
775 correct = False;
776 }
777
778 return correct;
779 }
780
781 static bool rw_torture2(struct cli_state *c1, struct cli_state *c2)
782 {
783 const char *lockfname = "\\torture2.lck";
784 uint16_t fnum1;
785 uint16_t fnum2;
786 int i;
787 char buf[131072];
788 char buf_rd[131072];
789 bool correct = True;
790 size_t bytes_read;
791 NTSTATUS status;
792
793 status = cli_unlink(c1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
794 if (!NT_STATUS_IS_OK(status)) {
795 printf("unlink failed (%s) (normal, this file should not exist)\n", nt_errstr(status));
796 }
797
798 status = cli_openx(c1, lockfname, O_RDWR | O_CREAT | O_EXCL,
799 DENY_NONE, &fnum1);
800 if (!NT_STATUS_IS_OK(status)) {
801 printf("first open read/write of %s failed (%s)\n",
802 lockfname, nt_errstr(status));
803 return False;
804 }
805
806 status = cli_openx(c2, lockfname, O_RDONLY, DENY_NONE, &fnum2);
807 if (!NT_STATUS_IS_OK(status)) {
808 printf("second open read-only of %s failed (%s)\n",
809 lockfname, nt_errstr(status));
810 cli_close(c1, fnum1);
811 return False;
812 }
813
814 for (i = 0; i < torture_numops; i++)
815 {
816 size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
817 if (i % 10 == 0) {
818 printf("%d\r", i); fflush(stdout);
819 }
820
821 generate_random_buffer((unsigned char *)buf, buf_size);
822
823 status = cli_writeall(c1, fnum1, 0, (uint8_t *)buf, 0,
824 buf_size, NULL);
825 if (!NT_STATUS_IS_OK(status)) {
826 printf("write failed (%s)\n", nt_errstr(status));
827 correct = False;
828 break;
829 }
830
831 status = cli_read(c2, fnum2, buf_rd, 0, buf_size, &bytes_read);
832 if(!NT_STATUS_IS_OK(status)) {
833 printf("read failed (%s)\n", nt_errstr(status));
834 correct = false;
835 break;
836 } else if (bytes_read != buf_size) {
837 printf("read failed\n");
838 printf("read %ld, expected %ld\n",
839 (unsigned long)bytes_read,
840 (unsigned long)buf_size);
841 correct = False;
842 break;
843 }
844
845 if (memcmp(buf_rd, buf, buf_size) != 0)
846 {
847 printf("read/write compare failed\n");
848 correct = False;
849 break;
850 }
851 }
852
853 status = cli_close(c2, fnum2);
854 if (!NT_STATUS_IS_OK(status)) {
855 printf("close failed (%s)\n", nt_errstr(status));
856 correct = False;
857 }
858
859 status = cli_close(c1, fnum1);
860 if (!NT_STATUS_IS_OK(status)) {
861 printf("close failed (%s)\n", nt_errstr(status));
862 correct = False;
863 }
864
865 status = cli_unlink(c1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
866 if (!NT_STATUS_IS_OK(status)) {
867 printf("unlink failed (%s)\n", nt_errstr(status));
868 correct = False;
869 }
870
871 return correct;
872 }
873
874 static bool run_readwritetest(int dummy)
875 {
876 struct cli_state *cli1, *cli2;
877 bool test1, test2 = False;
878
879 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
880 return False;
881 }
882 smbXcli_conn_set_sockopt(cli1->conn, sockops);
883 smbXcli_conn_set_sockopt(cli2->conn, sockops);
884
885 printf("starting readwritetest\n");
886
887 test1 = rw_torture2(cli1, cli2);
888 printf("Passed readwritetest v1: %s\n", BOOLSTR(test1));
889
890 if (test1) {
891 test2 = rw_torture2(cli1, cli1);
892 printf("Passed readwritetest v2: %s\n", BOOLSTR(test2));
893 }
894
895 if (!torture_close_connection(cli1)) {
896 test1 = False;
897 }
898
899 if (!torture_close_connection(cli2)) {
900 test2 = False;
901 }
902
903 return (test1 && test2);
904 }
905
906 static bool run_readwritemulti(int dummy)
907 {
908 struct cli_state *cli;
909 bool test;
910
911 cli = current_cli;
912
913 smbXcli_conn_set_sockopt(cli->conn, sockops);
914
915 printf("run_readwritemulti: fname %s\n", randomfname);
916 test = rw_torture3(cli, randomfname);
917
918 if (!torture_close_connection(cli)) {
919 test = False;
920 }
921
922 return test;
923 }
924
925 static bool run_readwritelarge_internal(void)
926 {
927 static struct cli_state *cli1;
928 uint16_t fnum1;
929 const char *lockfname = "\\large.dat";
930 off_t fsize;
931 char buf[126*1024];
932 bool correct = True;
933 NTSTATUS status;
934
935 if (!torture_open_connection(&cli1, 0)) {
936 return False;
937 }
938 smbXcli_conn_set_sockopt(cli1->conn, sockops);
939 memset(buf,'\0',sizeof(buf));
940
941 printf("starting readwritelarge_internal\n");
942
943 cli_unlink(cli1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
944
945 status = cli_openx(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL,
946 DENY_NONE, &fnum1);
947 if (!NT_STATUS_IS_OK(status)) {
948 printf("open read/write of %s failed (%s)\n", lockfname, nt_errstr(status));
949 return False;
950 }
951
952 cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf), NULL);
953
954 status = cli_qfileinfo_basic(cli1, fnum1, NULL, &fsize, NULL, NULL,
955 NULL, NULL, NULL);
956 if (!NT_STATUS_IS_OK(status)) {
957 printf("qfileinfo failed (%s)\n", nt_errstr(status));
958 correct = False;
959 }
960
961 if (fsize == sizeof(buf))
962 printf("readwritelarge_internal test 1 succeeded (size = %lx)\n",
963 (unsigned long)fsize);
964 else {
965 printf("readwritelarge_internal test 1 failed (size = %lx)\n",
966 (unsigned long)fsize);
967 correct = False;
968 }
969
970 status = cli_close(cli1, fnum1);
971 if (!NT_STATUS_IS_OK(status)) {
972 printf("close failed (%s)\n", nt_errstr(status));
973 correct = False;
974 }
975
976 status = cli_unlink(cli1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
977 if (!NT_STATUS_IS_OK(status)) {
978 printf("unlink failed (%s)\n", nt_errstr(status));
979 correct = False;
980 }
981
982 status = cli_openx(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL,
983 DENY_NONE, &fnum1);
984 if (!NT_STATUS_IS_OK(status)) {
985 printf("open read/write of %s failed (%s)\n", lockfname, nt_errstr(status));
986 return False;
987 }
988
989 cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf), NULL);
990
991 status = cli_qfileinfo_basic(cli1, fnum1, NULL, &fsize, NULL, NULL,
992 NULL, NULL, NULL);
993 if (!NT_STATUS_IS_OK(status)) {
994 printf("qfileinfo failed (%s)\n", nt_errstr(status));
995 correct = False;
996 }
997
998 if (fsize == sizeof(buf))
999 printf("readwritelarge_internal test 2 succeeded (size = %lx)\n",
1000 (unsigned long)fsize);
1001 else {
1002 printf("readwritelarge_internal test 2 failed (size = %lx)\n",
1003 (unsigned long)fsize);
1004 correct = False;
1005 }
1006
1007 #if 0
1008 /* ToDo - set allocation. JRA */
1009 if(!cli_set_allocation_size(cli1, fnum1, 0)) {
1010 printf("set allocation size to zero failed (%s)\n", cli_errstr(&cli1));
1011 return False;
1012 }
1013 if (!cli_qfileinfo_basic(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL,
1014 NULL, NULL)) {
1015 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
1016 correct = False;
1017 }
1018 if (fsize != 0)
1019 printf("readwritelarge test 3 (truncate test) succeeded (size = %x)\n", fsize);
1020 #endif
1021
1022 status = cli_close(cli1, fnum1);
1023 if (!NT_STATUS_IS_OK(status)) {
1024 printf("close failed (%s)\n", nt_errstr(status));
1025 correct = False;
1026 }
1027
1028 if (!torture_close_connection(cli1)) {
1029 correct = False;
1030 }
1031 return correct;
1032 }
1033
1034 static bool run_readwritelarge(int dummy)
1035 {
1036 return run_readwritelarge_internal();
1037 }
1038
1039 static bool run_readwritelarge_signtest(int dummy)
1040 {
1041 bool ret;
1042 signing_state = SMB_SIGNING_REQUIRED;
1043 ret = run_readwritelarge_internal();
1044 signing_state = SMB_SIGNING_DEFAULT;
1045 return ret;
1046 }
1047
1048 int line_count = 0;
1049 int nbio_id;
1050
1051 #define ival(s) strtol(s, NULL, 0)
1052
1053 /* run a test that simulates an approximate netbench client load */
1054 static bool run_netbench(int client)
1055 {
1056 struct cli_state *cli;
1057 int i;
1058 char line[1024];
1059 char cname[20];
1060 FILE *f;
1061 const char *params[20];
1062 bool correct = True;
1063
1064 cli = current_cli;
1065
1066 nbio_id = client;
1067
1068 smbXcli_conn_set_sockopt(cli->conn, sockops);
1069
1070 nb_setup(cli);
1071
1072 slprintf(cname,sizeof(cname)-1, "client%d", client);
1073
1074 f = fopen(client_txt, "r");
1075
1076 if (!f) {
1077 perror(client_txt);
1078 return False;
1079 }
1080
1081 while (fgets(line, sizeof(line)-1, f)) {
1082 char *saveptr;
1083 line_count++;
1084
1085 line[strlen(line)-1] = 0;
1086
1087 /* printf("[%d] %s\n", line_count, line); */
1088
1089 all_string_sub(line,"client1", cname, sizeof(line));
1090
1091 /* parse the command parameters */
1092 params[0] = strtok_r(line, " ", &saveptr);
1093 i = 0;
1094 while (params[i]) params[++i] = strtok_r(NULL, " ", &saveptr);
1095
1096 params[i] = "";
1097
1098 if (i < 2) continue;
1099
1100 if (!strncmp(params[0],"SMB", 3)) {
1101 printf("ERROR: You are using a dbench 1 load file\n");
1102 exit(1);
1103 }
1104
1105 if (!strcmp(params[0],"NTCreateX")) {
1106 nb_createx(params[1], ival(params[2]), ival(params[3]),
1107 ival(params[4]));
1108 } else if (!strcmp(params[0],"Close")) {
1109 nb_close(ival(params[1]));
1110 } else if (!strcmp(params[0],"Rename")) {
1111 nb_rename(params[1], params[2]);
1112 } else if (!strcmp(params[0],"Unlink")) {
1113 nb_unlink(params[1]);
1114 } else if (!strcmp(params[0],"Deltree")) {
1115 nb_deltree(params[1]);
1116 } else if (!strcmp(params[0],"Rmdir")) {
1117 nb_rmdir(params[1]);
1118 } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
1119 nb_qpathinfo(params[1]);
1120 } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
1121 nb_qfileinfo(ival(params[1]));
1122 } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
1123 nb_qfsinfo(ival(params[1]));
1124 } else if (!strcmp(params[0],"FIND_FIRST")) {
1125 nb_findfirst(params[1]);
1126 } else if (!strcmp(params[0],"WriteX")) {
1127 nb_writex(ival(params[1]),
1128 ival(params[2]), ival(params[3]), ival(params[4]));
1129 } else if (!strcmp(params[0],"ReadX")) {
1130 nb_readx(ival(params[1]),
1131 ival(params[2]), ival(params[3]), ival(params[4]));
1132 } else if (!strcmp(params[0],"Flush")) {
1133 nb_flush(ival(params[1]));
1134 } else {
1135 printf("Unknown operation %s\n", params[0]);
1136 exit(1);
1137 }
1138 }
1139 fclose(f);
1140
1141 nb_cleanup();
1142
1143 if (!torture_close_connection(cli)) {
1144 correct = False;
1145 }
1146
1147 return correct;
1148 }
1149
1150
1151 /* run a test that simulates an approximate netbench client load */
1152 static bool run_nbench(int dummy)
1153 {
1154 double t;
1155 bool correct = True;
1156
1157 nbio_shmem(torture_nprocs);
1158
1159 nbio_id = -1;
1160
1161 signal(SIGALRM, nb_alarm);
1162 alarm(1);
1163 t = create_procs(run_netbench, &correct);
1164 alarm(0);
1165
1166 printf("\nThroughput %g MB/sec\n",
1167 1.0e-6 * nbio_total() / t);
1168 return correct;
1169 }
1170
1171
1172 /*
1173 This test checks for two things:
1174
1175 1) correct support for retaining locks over a close (ie. the server
1176 must not use posix semantics)
1177 2) support for lock timeouts
1178 */
1179 static bool run_locktest1(int dummy)
1180 {
1181 struct cli_state *cli1, *cli2;
1182 const char *fname = "\\lockt1.lck";
1183 uint16_t fnum1, fnum2, fnum3;
1184 time_t t1, t2;
1185 unsigned lock_timeout;
1186 NTSTATUS status;
1187
1188 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1189 return False;
1190 }
1191 smbXcli_conn_set_sockopt(cli1->conn, sockops);
1192 smbXcli_conn_set_sockopt(cli2->conn, sockops);
1193
1194 printf("starting locktest1\n");
1195
1196 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1197
1198 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
1199 &fnum1);
1200 if (!NT_STATUS_IS_OK(status)) {
1201 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1202 return False;
1203 }
1204
1205 status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum2);
1206 if (!NT_STATUS_IS_OK(status)) {
1207 printf("open2 of %s failed (%s)\n", fname, nt_errstr(status));
1208 return False;
1209 }
1210
1211 status = cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum3);
1212 if (!NT_STATUS_IS_OK(status)) {
1213 printf("open3 of %s failed (%s)\n", fname, nt_errstr(status));
1214 return False;
1215 }
1216
1217 status = cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK);
1218 if (!NT_STATUS_IS_OK(status)) {
1219 printf("lock1 failed (%s)\n", nt_errstr(status));
1220 return false;
1221 }
1222
1223 status = cli_lock32(cli2, fnum3, 0, 4, 0, WRITE_LOCK);
1224 if (NT_STATUS_IS_OK(status)) {
1225 printf("lock2 succeeded! This is a locking bug\n");
1226 return false;
1227 } else {
1228 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1229 NT_STATUS_LOCK_NOT_GRANTED)) {
1230 return false;
1231 }
1232 }
1233
1234 lock_timeout = (1 + (random() % 20));
1235 printf("Testing lock timeout with timeout=%u\n", lock_timeout);
1236 t1 = time(NULL);
1237 status = cli_lock32(cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK);
1238 if (NT_STATUS_IS_OK(status)) {
1239 printf("lock3 succeeded! This is a locking bug\n");
1240 return false;
1241 } else {
1242 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1243 NT_STATUS_FILE_LOCK_CONFLICT)) {
1244 return false;
1245 }
1246 }
1247 t2 = time(NULL);
1248
1249 if (ABS(t2 - t1) < lock_timeout-1) {
1250 printf("error: This server appears not to support timed lock requests\n");
1251 }
1252
1253 printf("server slept for %u seconds for a %u second timeout\n",
1254 (unsigned int)(t2-t1), lock_timeout);
1255
1256 status = cli_close(cli1, fnum2);
1257 if (!NT_STATUS_IS_OK(status)) {
1258 printf("close1 failed (%s)\n", nt_errstr(status));
1259 return False;
1260 }
1261
1262 status = cli_lock32(cli2, fnum3, 0, 4, 0, WRITE_LOCK);
1263 if (NT_STATUS_IS_OK(status)) {
1264 printf("lock4 succeeded! This is a locking bug\n");
1265 return false;
1266 } else {
1267 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1268 NT_STATUS_FILE_LOCK_CONFLICT)) {
1269 return false;
1270 }
1271 }
1272
1273 status = cli_close(cli1, fnum1);
1274 if (!NT_STATUS_IS_OK(status)) {
1275 printf("close2 failed (%s)\n", nt_errstr(status));
1276 return False;
1277 }
1278
1279 status = cli_close(cli2, fnum3);
1280 if (!NT_STATUS_IS_OK(status)) {
1281 printf("close3 failed (%s)\n", nt_errstr(status));
1282 return False;
1283 }
1284
1285 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1286 if (!NT_STATUS_IS_OK(status)) {
1287 printf("unlink failed (%s)\n", nt_errstr(status));
1288 return False;
1289 }
1290
1291
1292 if (!torture_close_connection(cli1)) {
1293 return False;
1294 }
1295
1296 if (!torture_close_connection(cli2)) {
1297 return False;
1298 }
1299
1300 printf("Passed locktest1\n");
1301 return True;
1302 }
1303
1304 /*
1305 this checks to see if a secondary tconx can use open files from an
1306 earlier tconx
1307 */
1308 static bool run_tcon_test(int dummy)
1309 {
1310 static struct cli_state *cli;
1311 const char *fname = "\\tcontest.tmp";
1312 uint16_t fnum1;
1313 uint32_t cnum1, cnum2, cnum3;
1314 struct smbXcli_tcon *orig_tcon = NULL;
1315 uint16_t vuid1, vuid2;
1316 char buf[4];
1317 bool ret = True;
1318 NTSTATUS status;
1319
1320 memset(buf, '\0', sizeof(buf));
1321
1322 if (!torture_open_connection(&cli, 0)) {
1323 return False;
1324 }
1325 smbXcli_conn_set_sockopt(cli->conn, sockops);
1326
1327 printf("starting tcontest\n");
1328
1329 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1330
1331 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1332 if (!NT_STATUS_IS_OK(status)) {
1333 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1334 return False;
1335 }
1336
1337 cnum1 = cli_state_get_tid(cli);
1338 vuid1 = cli_state_get_uid(cli);
1339
1340 status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1341 if (!NT_STATUS_IS_OK(status)) {
1342 printf("initial write failed (%s)", nt_errstr(status));
1343 return False;
1344 }
1345
1346 orig_tcon = cli_state_save_tcon(cli);
1347 if (orig_tcon == NULL) {
1348 return false;
1349 }
1350
1351 status = cli_tree_connect_creds(cli, share, "?????", torture_creds);
1352 if (!NT_STATUS_IS_OK(status)) {
1353 printf("%s refused 2nd tree connect (%s)\n", host,
1354 nt_errstr(status));
1355 cli_shutdown(cli);
1356 return False;
1357 }
1358
1359 cnum2 = cli_state_get_tid(cli);
1360 cnum3 = MAX(cnum1, cnum2) + 1; /* any invalid number */
1361 vuid2 = cli_state_get_uid(cli) + 1;
1362
1363 /* try a write with the wrong tid */
1364 cli_state_set_tid(cli, cnum2);
1365
1366 status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1367 if (NT_STATUS_IS_OK(status)) {
1368 printf("* server allows write with wrong TID\n");
1369 ret = False;
1370 } else {
1371 printf("server fails write with wrong TID : %s\n",
1372 nt_errstr(status));
1373 }
1374
1375
1376 /* try a write with an invalid tid */
1377 cli_state_set_tid(cli, cnum3);
1378
1379 status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1380 if (NT_STATUS_IS_OK(status)) {
1381 printf("* server allows write with invalid TID\n");
1382 ret = False;
1383 } else {
1384 printf("server fails write with invalid TID : %s\n",
1385 nt_errstr(status));
1386 }
1387
1388 /* try a write with an invalid vuid */
1389 cli_state_set_uid(cli, vuid2);
1390 cli_state_set_tid(cli, cnum1);
1391
1392 status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1393 if (NT_STATUS_IS_OK(status)) {
1394 printf("* server allows write with invalid VUID\n");
1395 ret = False;
1396 } else {
1397 printf("server fails write with invalid VUID : %s\n",
1398 nt_errstr(status));
1399 }
1400
1401 cli_state_set_tid(cli, cnum1);
1402 cli_state_set_uid(cli, vuid1);
1403
1404 status = cli_close(cli, fnum1);
1405 if (!NT_STATUS_IS_OK(status)) {
1406 printf("close failed (%s)\n", nt_errstr(status));
1407 return False;
1408 }
1409
1410 cli_state_set_tid(cli, cnum2);
1411
1412 status = cli_tdis(cli);
1413 if (!NT_STATUS_IS_OK(status)) {
1414 printf("secondary tdis failed (%s)\n", nt_errstr(status));
1415 return False;
1416 }
1417
1418 cli_state_restore_tcon(cli, orig_tcon);
1419
1420 cli_state_set_tid(cli, cnum1);
1421
1422 if (!torture_close_connection(cli)) {
1423 return False;
1424 }
1425
1426 return ret;
1427 }
1428
1429
1430 /*
1431 checks for old style tcon support
1432 */
1433 static bool run_tcon2_test(int dummy)
1434 {
1435 static struct cli_state *cli;
1436 uint16_t cnum, max_xmit;
1437 char *service;
1438 NTSTATUS status;
1439
1440 if (!torture_open_connection(&cli, 0)) {
1441 return False;
1442 }
1443 smbXcli_conn_set_sockopt(cli->conn, sockops);
1444
1445 printf("starting tcon2 test\n");
1446
1447 if (asprintf(&service, "\\\\%s\\%s", host, share) == -1) {
1448 return false;
1449 }
1450
1451 status = cli_raw_tcon(cli, service, password, "?????", &max_xmit, &cnum);
1452
1453 SAFE_FREE(service);
1454
1455 if (!NT_STATUS_IS_OK(status)) {
1456 printf("tcon2 failed : %s\n", nt_errstr(status));
1457 } else {
1458 printf("tcon OK : max_xmit=%d cnum=%d\n",
1459 (int)max_xmit, (int)cnum);
1460 }
1461
1462 if (!torture_close_connection(cli)) {
1463 return False;
1464 }
1465
1466 printf("Passed tcon2 test\n");
1467 return True;
1468 }
1469
1470 static bool tcon_devtest(struct cli_state *cli,
1471 const char *myshare, const char *devtype,
1472 const char *return_devtype,
1473 NTSTATUS expected_error)
1474 {
1475 NTSTATUS status;
1476 bool ret;
1477
1478 status = cli_tree_connect_creds(cli, myshare, devtype, torture_creds);
1479
1480 if (NT_STATUS_IS_OK(expected_error)) {
1481 if (NT_STATUS_IS_OK(status)) {
1482 if (return_devtype != NULL &&
1483 strequal(cli->dev, return_devtype)) {
1484 ret = True;
1485 } else {
1486 printf("tconX to share %s with type %s "
1487 "succeeded but returned the wrong "
1488 "device type (got [%s] but should have got [%s])\n",
1489 myshare, devtype, cli->dev, return_devtype);
1490 ret = False;
1491 }
1492 } else {
1493 printf("tconX to share %s with type %s "
1494 "should have succeeded but failed\n",
1495 myshare, devtype);
1496 ret = False;
1497 }
1498 cli_tdis(cli);
1499 } else {
1500 if (NT_STATUS_IS_OK(status)) {
1501 printf("tconx to share %s with type %s "
1502 "should have failed but succeeded\n",
1503 myshare, devtype);
1504 ret = False;
1505 } else {
1506 if (NT_STATUS_EQUAL(status, expected_error)) {
1507 ret = True;
1508 } else {
1509 printf("Returned unexpected error\n");
1510 ret = False;
1511 }
1512 }
1513 }
1514 return ret;
1515 }
1516
1517 /*
1518 checks for correct tconX support
1519 */
1520 static bool run_tcon_devtype_test(int dummy)
1521 {
1522 static struct cli_state *cli1 = NULL;
1523 int flags = CLI_FULL_CONNECTION_FORCE_SMB1;
1524 NTSTATUS status;
1525 bool ret = True;
1526
1527 status = cli_full_connection_creds(&cli1,
1528 myname,
1529 host,
1530 NULL, /* dest_ss */
1531 port_to_use,
1532 NULL, /* service */
1533 NULL, /* service_type */
1534 torture_creds,
1535 flags,
1536 signing_state);
1537
1538 if (!NT_STATUS_IS_OK(status)) {
1539 printf("could not open connection\n");
1540 return False;
1541 }
1542
1543 if (!tcon_devtest(cli1, "IPC$", "A:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1544 ret = False;
1545
1546 if (!tcon_devtest(cli1, "IPC$", "?????", "IPC", NT_STATUS_OK))
1547 ret = False;
1548
1549 if (!tcon_devtest(cli1, "IPC$", "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1550 ret = False;
1551
1552 if (!tcon_devtest(cli1, "IPC$", "IPC", "IPC", NT_STATUS_OK))
1553 ret = False;
1554
1555 if (!tcon_devtest(cli1, "IPC$", "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1556 ret = False;
1557
1558 if (!tcon_devtest(cli1, share, "A:", "A:", NT_STATUS_OK))
1559 ret = False;
1560
1561 if (!tcon_devtest(cli1, share, "?????", "A:", NT_STATUS_OK))
1562 ret = False;
1563
1564 if (!tcon_devtest(cli1, share, "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1565 ret = False;
1566
1567 if (!tcon_devtest(cli1, share, "IPC", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1568 ret = False;
1569
1570 if (!tcon_devtest(cli1, share, "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1571 ret = False;
1572
1573 cli_shutdown(cli1);
1574
1575 if (ret)
1576 printf("Passed tcondevtest\n");
1577
1578 return ret;
1579 }
1580
1581
1582 /*
1583 This test checks that
1584
1585 1) the server supports multiple locking contexts on the one SMB
1586 connection, distinguished by PID.
1587
1588 2) the server correctly fails overlapping locks made by the same PID (this
1589 goes against POSIX behaviour, which is why it is tricky to implement)
1590
1591 3) the server denies unlock requests by an incorrect client PID
1592 */
1593 static bool run_locktest2(int dummy)
1594 {
1595 static struct cli_state *cli;
1596 const char *fname = "\\lockt2.lck";
1597 uint16_t fnum1, fnum2, fnum3;
1598 bool correct = True;
1599 NTSTATUS status;
1600
1601 if (!torture_open_connection(&cli, 0)) {
1602 return False;
1603 }
1604
1605 smbXcli_conn_set_sockopt(cli->conn, sockops);
1606
1607 printf("starting locktest2\n");
1608
1609 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1610
1611 cli_setpid(cli, 1);
1612
1613 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1614 if (!NT_STATUS_IS_OK(status)) {
1615 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1616 return False;
1617 }
1618
1619 status = cli_openx(cli, fname, O_RDWR, DENY_NONE, &fnum2);
1620 if (!NT_STATUS_IS_OK(status)) {
1621 printf("open2 of %s failed (%s)\n", fname, nt_errstr(status));
1622 return False;
1623 }
1624
1625 cli_setpid(cli, 2);
1626
1627 status = cli_openx(cli, fname, O_RDWR, DENY_NONE, &fnum3);
1628 if (!NT_STATUS_IS_OK(status)) {
1629 printf("open3 of %s failed (%s)\n", fname, nt_errstr(status));
1630 return False;
1631 }
1632
1633 cli_setpid(cli, 1);
1634
1635 status = cli_lock32(cli, fnum1, 0, 4, 0, WRITE_LOCK);
1636 if (!NT_STATUS_IS_OK(status)) {
1637 printf("lock1 failed (%s)\n", nt_errstr(status));
1638 return false;
1639 }
1640
1641 status = cli_lock32(cli, fnum1, 0, 4, 0, WRITE_LOCK);
1642 if (NT_STATUS_IS_OK(status)) {
1643 printf("WRITE lock1 succeeded! This is a locking bug\n");
1644 correct = false;
1645 } else {
1646 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1647 NT_STATUS_LOCK_NOT_GRANTED)) {
1648 return false;
1649 }
1650 }
1651
1652 status = cli_lock32(cli, fnum2, 0, 4, 0, WRITE_LOCK);
1653 if (NT_STATUS_IS_OK(status)) {
1654 printf("WRITE lock2 succeeded! This is a locking bug\n");
1655 correct = false;
1656 } else {
1657 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1658 NT_STATUS_LOCK_NOT_GRANTED)) {
1659 return false;
1660 }
1661 }
1662
1663 status = cli_lock32(cli, fnum2, 0, 4, 0, READ_LOCK);
1664 if (NT_STATUS_IS_OK(status)) {
1665 printf("READ lock2 succeeded! This is a locking bug\n");
1666 correct = false;
1667 } else {
1668 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1669 NT_STATUS_FILE_LOCK_CONFLICT)) {
1670 return false;
1671 }
1672 }
1673
1674 status = cli_lock32(cli, fnum1, 100, 4, 0, WRITE_LOCK);
1675 if (!NT_STATUS_IS_OK(status)) {
1676 printf("lock at 100 failed (%s)\n", nt_errstr(status));
1677 }
1678 cli_setpid(cli, 2);
1679 if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 100, 4))) {
1680 printf("unlock at 100 succeeded! This is a locking bug\n");
1681 correct = False;
1682 }
1683
1684 status = cli_unlock(cli, fnum1, 0, 4);
1685 if (NT_STATUS_IS_OK(status)) {
1686 printf("unlock1 succeeded! This is a locking bug\n");
1687 correct = false;
1688 } else {
1689 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1690 NT_STATUS_RANGE_NOT_LOCKED)) {
1691 return false;
1692 }
1693 }
1694
1695 status = cli_unlock(cli, fnum1, 0, 8);
1696 if (NT_STATUS_IS_OK(status)) {
1697 printf("unlock2 succeeded! This is a locking bug\n");
1698 correct = false;
1699 } else {
1700 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1701 NT_STATUS_RANGE_NOT_LOCKED)) {
1702 return false;
1703 }
1704 }
1705
1706 status = cli_lock32(cli, fnum3, 0, 4, 0, WRITE_LOCK);
1707 if (NT_STATUS_IS_OK(status)) {
1708 printf("lock3 succeeded! This is a locking bug\n");
1709 correct = false;
1710 } else {
1711 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1712 NT_STATUS_LOCK_NOT_GRANTED)) {
1713 return false;
1714 }
1715 }
1716
1717 cli_setpid(cli, 1);
1718
1719 status = cli_close(cli, fnum1);
1720 if (!NT_STATUS_IS_OK(status)) {
1721 printf("close1 failed (%s)\n", nt_errstr(status));
1722 return False;
1723 }
1724
1725 status = cli_close(cli, fnum2);
1726 if (!NT_STATUS_IS_OK(status)) {
1727 printf("close2 failed (%s)\n", nt_errstr(status));
1728 return False;
1729 }
1730
1731 status = cli_close(cli, fnum3);
1732 if (!NT_STATUS_IS_OK(status)) {
1733 printf("close3 failed (%s)\n", nt_errstr(status));
1734 return False;
1735 }
1736
1737 if (!torture_close_connection(cli)) {
1738 correct = False;
1739 }
1740
1741 printf("locktest2 finished\n");
1742
1743 return correct;
1744 }
1745
1746
1747 /*
1748 This test checks that
1749
1750 1) the server supports the full offset range in lock requests
1751 */
1752 static bool run_locktest3(int dummy)
1753 {
1754 static struct cli_state *cli1, *cli2;
1755 const char *fname = "\\lockt3.lck";
1756 uint16_t fnum1, fnum2;
1757 int i;
1758 uint32_t offset;
1759 bool correct = True;
1760 NTSTATUS status;
1761
1762 #define NEXT_OFFSET offset += (~(uint32_t)0) / torture_numops
1763
1764 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1765 return False;
1766 }
1767 smbXcli_conn_set_sockopt(cli1->conn, sockops);
1768 smbXcli_conn_set_sockopt(cli2->conn, sockops);
1769
1770 printf("starting locktest3\n");
1771
1772 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1773
1774 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
1775 &fnum1);
1776 if (!NT_STATUS_IS_OK(status)) {
1777 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1778 return False;
1779 }
1780
1781 status = cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1782 if (!NT_STATUS_IS_OK(status)) {
1783 printf("open2 of %s failed (%s)\n", fname, nt_errstr(status));
1784 return False;
1785 }
1786
1787 for (offset=i=0;i<torture_numops;i++) {
1788 NEXT_OFFSET;
1789
1790 status = cli_lock32(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK);
1791 if (!NT_STATUS_IS_OK(status)) {
1792 printf("lock1 %d failed (%s)\n",
1793 i,
1794 nt_errstr(status));
1795 return False;
1796 }
1797
1798 status = cli_lock32(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK);
1799 if (!NT_STATUS_IS_OK(status)) {
1800 printf("lock2 %d failed (%s)\n",
1801 i,
1802 nt_errstr(status));
1803 return False;
1804 }
1805 }
1806
1807 for (offset=i=0;i<torture_numops;i++) {
1808 NEXT_OFFSET;
1809
1810 status = cli_lock32(cli1, fnum1, offset-2, 1, 0, WRITE_LOCK);
1811 if (NT_STATUS_IS_OK(status)) {
1812 printf("error: lock1 %d succeeded!\n", i);
1813 return False;
1814 }
1815
1816 status = cli_lock32(cli2, fnum2, offset-1, 1, 0, WRITE_LOCK);
1817 if (NT_STATUS_IS_OK(status)) {
1818 printf("error: lock2 %d succeeded!\n", i);
1819 return False;
1820 }
1821
1822 status = cli_lock32(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK);
1823 if (NT_STATUS_IS_OK(status)) {
1824 printf("error: lock3 %d succeeded!\n", i);
1825 return False;
1826 }
1827
1828 status = cli_lock32(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK);
1829 if (NT_STATUS_IS_OK(status)) {
1830 printf("error: lock4 %d succeeded!\n", i);
1831 return False;
1832 }
1833 }
1834
1835 for (offset=i=0;i<torture_numops;i++) {
1836 NEXT_OFFSET;
1837
1838 status = cli_unlock(cli1, fnum1, offset-1, 1);
1839 if (!NT_STATUS_IS_OK(status)) {
1840 printf("unlock1 %d failed (%s)\n",
1841 i,
1842 nt_errstr(status));
1843 return False;
1844 }
1845
1846 status = cli_unlock(cli2, fnum2, offset-2, 1);
1847 if (!NT_STATUS_IS_OK(status)) {
1848 printf("unlock2 %d failed (%s)\n",
1849 i,
1850 nt_errstr(status));
1851 return False;
1852 }
1853 }
1854
1855 status = cli_close(cli1, fnum1);
1856 if (!NT_STATUS_IS_OK(status)) {
1857 printf("close1 failed (%s)\n", nt_errstr(status));
1858 return False;
1859 }
1860
1861 status = cli_close(cli2, fnum2);
1862 if (!NT_STATUS_IS_OK(status)) {
1863 printf("close2 failed (%s)\n", nt_errstr(status));
1864 return False;
1865 }
1866
1867 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1868 if (!NT_STATUS_IS_OK(status)) {
1869 printf("unlink failed (%s)\n", nt_errstr(status));
1870 return False;
1871 }
1872
1873 if (!torture_close_connection(cli1)) {
1874 correct = False;
1875 }
1876
1877 if (!torture_close_connection(cli2)) {
1878 correct = False;
1879 }
1880
1881 printf("finished locktest3\n");
1882
1883 return correct;
1884 }
1885
1886 static bool test_cli_read(struct cli_state *cli, uint16_t fnum,
1887 char *buf, off_t offset, size_t size,
1888 size_t *nread, size_t expect)
1889 {
1890 NTSTATUS status;
1891 size_t l_nread;
1892
1893 status = cli_read(cli, fnum, buf, offset, size, &l_nread);
1894
1895 if(!NT_STATUS_IS_OK(status)) {
1896 return false;
1897 } else if (l_nread != expect) {
1898 return false;
1899 }
1900
1901 if (nread) {
1902 *nread = l_nread;
1903 }
1904
1905 return true;
1906 }
1907
1908 #define EXPECTED(ret, v) if ((ret) != (v)) { \
1909 printf("** "); correct = False; \
1910 }
1911
1912 /*
1913 looks at overlapping locks
1914 */
1915 static bool run_locktest4(int dummy)
1916 {
1917 static struct cli_state *cli1, *cli2;
1918 const char *fname = "\\lockt4.lck";
1919 uint16_t fnum1, fnum2, f;
1920 bool ret;
1921 char buf[1000];
1922 bool correct = True;
1923 NTSTATUS status;
1924
1925 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1926 return False;
1927 }
1928
1929 smbXcli_conn_set_sockopt(cli1->conn, sockops);
1930 smbXcli_conn_set_sockopt(cli2->conn, sockops);
1931
1932 printf("starting locktest4\n");
1933
1934 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1935
1936 cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1937 cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1938
1939 memset(buf, 0, sizeof(buf));
1940
1941 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf),
1942 NULL);
1943 if (!NT_STATUS_IS_OK(status)) {
1944 printf("Failed to create file: %s\n", nt_errstr(status));
1945 correct = False;
1946 goto fail;
1947 }
1948
1949 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) &&
1950 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 2, 4, 0, WRITE_LOCK));
1951 EXPECTED(ret, False);
1952 printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
1953
1954 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 10, 4, 0, READ_LOCK)) &&
1955 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 12, 4, 0, READ_LOCK));
1956 EXPECTED(ret, True);
1957 printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
1958
1959 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 20, 4, 0, WRITE_LOCK)) &&
1960 NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 22, 4, 0, WRITE_LOCK));
1961 EXPECTED(ret, False);
1962 printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
1963
1964 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 30, 4, 0, READ_LOCK)) &&
1965 NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 32, 4, 0, READ_LOCK));
1966 EXPECTED(ret, True);
1967 printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
1968
1969 ret = (cli_setpid(cli1, 1),
1970 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 40, 4, 0, WRITE_LOCK))) &&
1971 (cli_setpid(cli1, 2),
1972 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 42, 4, 0, WRITE_LOCK)));
1973 EXPECTED(ret, False);
1974 printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
1975
1976 ret = (cli_setpid(cli1, 1),
1977 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 50, 4, 0, READ_LOCK))) &&
1978 (cli_setpid(cli1, 2),
1979 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 52, 4, 0, READ_LOCK)));
1980 EXPECTED(ret, True);
1981 printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
1982
1983 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 60, 4, 0, READ_LOCK)) &&
1984 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 60, 4, 0, READ_LOCK));
1985 EXPECTED(ret, True);
1986 printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
1987
1988 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 70, 4, 0, WRITE_LOCK)) &&
1989 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 70, 4, 0, WRITE_LOCK));
1990 EXPECTED(ret, False);
1991 printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
1992
1993 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 80, 4, 0, READ_LOCK)) &&
1994 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 80, 4, 0, WRITE_LOCK));
1995 EXPECTED(ret, False);
1996 printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
1997
1998 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 90, 4, 0, WRITE_LOCK)) &&
1999 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 90, 4, 0, READ_LOCK));
2000 EXPECTED(ret, True);
2001 printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
2002
2003 ret = (cli_setpid(cli1, 1),
2004 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 100, 4, 0, WRITE_LOCK))) &&
2005 (cli_setpid(cli1, 2),
2006 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 100, 4, 0, READ_LOCK)));
2007 EXPECTED(ret, False);
2008 printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
2009
2010 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 110, 4, 0, READ_LOCK)) &&
2011 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 112, 4, 0, READ_LOCK)) &&
2012 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 110, 6));
2013 EXPECTED(ret, False);
2014 printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
2015
2016
2017 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 120, 4, 0, WRITE_LOCK)) &&
2018 test_cli_read(cli2, fnum2, buf, 120, 4, NULL, 4);
2019 EXPECTED(ret, False);
2020 printf("this server %s strict write locking\n", ret?"doesn't do":"does");
2021
2022 status = cli_lock32(cli1, fnum1, 130, 4, 0, READ_LOCK);
2023 ret = NT_STATUS_IS_OK(status);
2024 if (ret) {
2025 status = cli_writeall(cli2, fnum2, 0, (uint8_t *)buf, 130, 4,
2026 NULL);
2027 ret = NT_STATUS_IS_OK(status);
2028 }
2029 EXPECTED(ret, False);
2030 printf("this server %s strict read locking\n", ret?"doesn't do":"does");
2031
2032
2033 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 140, 4, 0, READ_LOCK)) &&
2034 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 140, 4, 0, READ_LOCK)) &&
2035 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4)) &&
2036 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4));
2037 EXPECTED(ret, True);
2038 printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
2039
2040
2041 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 150, 4, 0, WRITE_LOCK)) &&
2042 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 150, 4, 0, READ_LOCK)) &&
2043 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4)) &&
2044 test_cli_read(cli2, fnum2, buf, 150, 4, NULL, 4) &&
2045 !(NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2046 150, 4, NULL))) &&
2047 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4));
2048 EXPECTED(ret, True);
2049 printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
2050
2051 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 160, 4, 0, READ_LOCK)) &&
2052 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 160, 4)) &&
2053 NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2054 160, 4, NULL)) &&
2055 test_cli_read(cli2, fnum2, buf, 160, 4, NULL, 4);
2056 EXPECTED(ret, True);
2057 printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
2058
2059 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 170, 4, 0, WRITE_LOCK)) &&
2060 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 170, 4)) &&
2061 NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2062 170, 4, NULL)) &&
2063 test_cli_read(cli2, fnum2, buf, 170, 4, NULL, 4);
2064 EXPECTED(ret, True);
2065 printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
2066
2067 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 190, 4, 0, WRITE_LOCK)) &&
2068 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 190, 4, 0, READ_LOCK)) &&
2069 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 190, 4)) &&
2070 !NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2071 190, 4, NULL)) &&
2072 test_cli_read(cli2, fnum2, buf, 190, 4, NULL, 4);
2073 EXPECTED(ret, True);
2074 printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
2075
2076 cli_close(cli1, fnum1);
2077 cli_close(cli2, fnum2);
2078 cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2079 cli_openx(cli1, fname, O_RDWR, DENY_NONE, &f);
2080 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 8, 0, READ_LOCK)) &&
2081 NT_STATUS_IS_OK(cli_lock32(cli1, f, 0, 1, 0, READ_LOCK)) &&
2082 NT_STATUS_IS_OK(cli_close(cli1, fnum1)) &&
2083 NT_STATUS_IS_OK(cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1)) &&
2084 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 7, 1, 0, WRITE_LOCK));
2085 cli_close(cli1, f);
2086 cli_close(cli1, fnum1);
2087 EXPECTED(ret, True);
2088 printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
2089
2090 fail:
2091 cli_close(cli1, fnum1);
2092 cli_close(cli2, fnum2);
2093 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2094 torture_close_connection(cli1);
2095 torture_close_connection(cli2);
2096
2097 printf("finished locktest4\n");
2098 return correct;
2099 }
2100
2101 /*
2102 looks at lock upgrade/downgrade.
2103 */
2104 static bool run_locktest5(int dummy)
2105 {
2106 static struct cli_state *cli1, *cli2;
2107 const char *fname = "\\lockt5.lck";
2108 uint16_t fnum1, fnum2, fnum3;
2109 bool ret;
2110 char buf[1000];
2111 bool correct = True;
2112 NTSTATUS status;
2113
2114 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2115 return False;
2116 }
2117
2118 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2119 smbXcli_conn_set_sockopt(cli2->conn, sockops);
2120
2121 printf("starting locktest5\n");
2122
2123 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2124
2125 cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2126 cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
2127 cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum3);
2128
2129 memset(buf, 0, sizeof(buf));
2130
2131 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf),
2132 NULL);
2133 if (!NT_STATUS_IS_OK(status)) {
2134 printf("Failed to create file: %s\n", nt_errstr(status));
2135 correct = False;
2136 goto fail;
2137 }
2138
2139 /* Check for NT bug... */
2140 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 8, 0, READ_LOCK)) &&
2141 NT_STATUS_IS_OK(cli_lock32(cli1, fnum3, 0, 1, 0, READ_LOCK));
2142 cli_close(cli1, fnum1);
2143 cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2144 status = cli_lock32(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
2145 ret = NT_STATUS_IS_OK(status);
2146 EXPECTED(ret, True);
2147 printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
2148 cli_close(cli1, fnum1);
2149 cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2150 cli_unlock(cli1, fnum3, 0, 1);
2151
2152 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) &&
2153 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 1, 1, 0, READ_LOCK));
2154 EXPECTED(ret, True);
2155 printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
2156
2157 status = cli_lock32(cli2, fnum2, 0, 4, 0, READ_LOCK);
2158 ret = NT_STATUS_IS_OK(status);
2159 EXPECTED(ret, False);
2160
2161 printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
2162
2163 /* Unlock the process 2 lock. */
2164 cli_unlock(cli2, fnum2, 0, 4);
2165
2166 status = cli_lock32(cli1, fnum3, 0, 4, 0, READ_LOCK);
2167 ret = NT_STATUS_IS_OK(status);
2168 EXPECTED(ret, False);
2169
2170 printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
2171
2172 /* Unlock the process 1 fnum3 lock. */
2173 cli_unlock(cli1, fnum3, 0, 4);
2174
2175 /* Stack 2 more locks here. */
2176 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK)) &&
2177 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK));
2178
2179 EXPECTED(ret, True);
2180 printf("the same process %s stack read locks\n", ret?"can":"cannot");
2181
2182 /* Unlock the first process lock, then check this was the WRITE lock that was
2183 removed. */
2184
2185 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
2186 NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 0, 4, 0, READ_LOCK));
2187
2188 EXPECTED(ret, True);
2189 printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
2190
2191 /* Unlock the process 2 lock. */
2192 cli_unlock(cli2, fnum2, 0, 4);
2193
2194 /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
2195
2196 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 1, 1)) &&
2197 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
2198 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
2199
2200 EXPECTED(ret, True);
2201 printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
2202
2203 /* Ensure the next unlock fails. */
2204 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
2205 EXPECTED(ret, False);
2206 printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
2207
2208 /* Ensure connection 2 can get a write lock. */
2209 status = cli_lock32(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
2210 ret = NT_STATUS_IS_OK(status);
2211 EXPECTED(ret, True);
2212
2213 printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
2214
2215
2216 fail:
2217 cli_close(cli1, fnum1);
2218 cli_close(cli2, fnum2);
2219 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2220 if (!torture_close_connection(cli1)) {
2221 correct = False;
2222 }
2223 if (!torture_close_connection(cli2)) {
2224 correct = False;
2225 }
2226
2227 printf("finished locktest5\n");
2228
2229 return correct;
2230 }
2231
2232 /*
2233 tries the unusual lockingX locktype bits
2234 */
2235 static bool run_locktest6(int dummy)
2236 {
2237 static struct cli_state *cli;
2238 const char *fname[1] = { "\\lock6.txt" };
2239 int i;
2240 uint16_t fnum;
2241 NTSTATUS status;
2242
2243 if (!torture_open_connection(&cli, 0)) {
2244 return False;
2245 }
2246
2247 smbXcli_conn_set_sockopt(cli->conn, sockops);
2248
2249 printf("starting locktest6\n");
2250
2251 for (i=0;i<1;i++) {
2252 printf("Testing %s\n", fname[i]);
2253
2254 cli_unlink(cli, fname[i], FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2255
2256 cli_openx(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
2257 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
2258 cli_close(cli, fnum);
2259 printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
2260
2261 cli_openx(cli, fname[i], O_RDWR, DENY_NONE, &fnum);
2262 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
2263 cli_close(cli, fnum);
2264 printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
2265
2266 cli_unlink(cli, fname[i], FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2267 }
2268
2269 torture_close_connection(cli);
2270
2271 printf("finished locktest6\n");
2272 return True;
2273 }
2274
2275 static bool run_locktest7(int dummy)
2276 {
2277 struct cli_state *cli1;
2278 const char *fname = "\\lockt7.lck";
2279 uint16_t fnum1;
2280 char buf[200];
2281 bool correct = False;
2282 size_t nread;
2283 NTSTATUS status;
2284
2285 if (!torture_open_connection(&cli1, 0)) {
2286 return False;
2287 }
2288
2289 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2290
2291 printf("starting locktest7\n");
2292
2293 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2294
2295 cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2296
2297 memset(buf, 0, sizeof(buf));
2298
2299 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf),
2300 NULL);
2301 if (!NT_STATUS_IS_OK(status)) {
2302 printf("Failed to create file: %s\n", nt_errstr(status));
2303 goto fail;
2304 }
2305
2306 cli_setpid(cli1, 1);
2307
2308 status = cli_lock32(cli1, fnum1, 130, 4, 0, READ_LOCK);
2309 if (!NT_STATUS_IS_OK(status)) {
2310 printf("Unable to apply read lock on range 130:4, "
2311 "error was %s\n", nt_errstr(status));
2312 goto fail;
2313 } else {
2314 printf("pid1 successfully locked range 130:4 for READ\n");
2315 }
2316
2317 status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2318 if (!NT_STATUS_IS_OK(status)) {
2319 printf("pid1 unable to read the range 130:4, error was %s\n",
2320 nt_errstr(status));
2321 goto fail;
2322 } else if (nread != 4) {
2323 printf("pid1 unable to read the range 130:4, "
2324 "recv %ld req %d\n", (unsigned long)nread, 4);
2325 goto fail;
2326 } else {
2327 printf("pid1 successfully read the range 130:4\n");
2328 }
2329
2330 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2331 if (!NT_STATUS_IS_OK(status)) {
2332 printf("pid1 unable to write to the range 130:4, error was "
2333 "%s\n", nt_errstr(status));
2334 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2335 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2336 goto fail;
2337 }
2338 } else {
2339 printf("pid1 successfully wrote to the range 130:4 (should be denied)\n");
2340 goto fail;
2341 }
2342
2343 cli_setpid(cli1, 2);
2344
2345 status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2346 if (!NT_STATUS_IS_OK(status)) {
2347 printf("pid2 unable to read the range 130:4, error was %s\n",
2348 nt_errstr(status));
2349 goto fail;
2350 } else if (nread != 4) {
2351 printf("pid2 unable to read the range 130:4, "
2352 "recv %ld req %d\n", (unsigned long)nread, 4);
2353 goto fail;
2354 } else {
2355 printf("pid2 successfully read the range 130:4\n");
2356 }
2357
2358 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2359 if (!NT_STATUS_IS_OK(status)) {
2360 printf("pid2 unable to write to the range 130:4, error was "
2361 "%s\n", nt_errstr(status));
2362 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2363 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2364 goto fail;
2365 }
2366 } else {
2367 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2368 goto fail;
2369 }
2370
2371 cli_setpid(cli1, 1);
2372 cli_unlock(cli1, fnum1, 130, 4);
2373
2374 status = cli_lock32(cli1, fnum1, 130, 4, 0, WRITE_LOCK);
2375 if (!NT_STATUS_IS_OK(status)) {
2376 printf("Unable to apply write lock on range 130:4, error was %s\n", nt_errstr(status));
2377 goto fail;
2378 } else {
2379 printf("pid1 successfully locked range 130:4 for WRITE\n");
2380 }
2381
2382 status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2383 if (!NT_STATUS_IS_OK(status)) {
2384 printf("pid1 unable to read the range 130:4, error was %s\n",
2385 nt_errstr(status));
2386 goto fail;
2387 } else if (nread != 4) {
2388 printf("pid1 unable to read the range 130:4, "
2389 "recv %ld req %d\n", (unsigned long)nread, 4);
2390 goto fail;
2391 } else {
2392 printf("pid1 successfully read the range 130:4\n");
2393 }
2394
2395 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2396 if (!NT_STATUS_IS_OK(status)) {
2397 printf("pid1 unable to write to the range 130:4, error was "
2398 "%s\n", nt_errstr(status));
2399 goto fail;
2400 } else {
2401 printf("pid1 successfully wrote to the range 130:4\n");
2402 }
2403
2404 cli_setpid(cli1, 2);
2405
2406 status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2407 if (!NT_STATUS_IS_OK(status)) {
2408 printf("pid2 unable to read the range 130:4, error was "
2409 "%s\n", nt_errstr(status));
2410 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2411 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2412 goto fail;
2413 }
2414 } else {
2415 printf("pid2 successfully read the range 130:4 (should be denied) recv %ld\n",
2416 (unsigned long)nread);
2417 goto fail;
2418 }
2419
2420 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2421 if (!NT_STATUS_IS_OK(status)) {
2422 printf("pid2 unable to write to the range 130:4, error was "
2423 "%s\n", nt_errstr(status));
2424 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2425 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2426 goto fail;
2427 }
2428 } else {
2429 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2430 goto fail;
2431 }
2432
2433 cli_unlock(cli1, fnum1, 130, 0);
2434 correct = True;
2435
2436 fail:
2437 cli_close(cli1, fnum1);
2438 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2439 torture_close_connection(cli1);
2440
2441 printf("finished locktest7\n");
2442 return correct;
2443 }
2444
2445 /*
2446 * This demonstrates a problem with our use of GPFS share modes: A file
2447 * descriptor sitting in the pending close queue holding a GPFS share mode
2448 * blocks opening a file another time. Happens with Word 2007 temp files.
2449 * With "posix locking = yes" and "gpfs:sharemodes = yes" enabled, the third
2450 * open is denied with NT_STATUS_SHARING_VIOLATION.
2451 */
2452
2453 static bool run_locktest8(int dummy)
2454 {
2455 struct cli_state *cli1;
2456 const char *fname = "\\lockt8.lck";
2457 uint16_t fnum1, fnum2;
2458 char buf[200];
2459 bool correct = False;
2460 NTSTATUS status;
2461
2462 if (!torture_open_connection(&cli1, 0)) {
2463 return False;
2464 }
2465
2466 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2467
2468 printf("starting locktest8\n");
2469
2470 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2471
2472 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_WRITE,
2473 &fnum1);
2474 if (!NT_STATUS_IS_OK(status)) {
2475 d_fprintf(stderr, "cli_openx returned %s\n", nt_errstr(status));
2476 return false;
2477 }
2478
2479 memset(buf, 0, sizeof(buf));
2480
2481 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum2);
2482 if (!NT_STATUS_IS_OK(status)) {
2483 d_fprintf(stderr, "cli_openx second time returned %s\n",
2484 nt_errstr(status));
2485 goto fail;
2486 }
2487
2488 status = cli_lock32(cli1, fnum2, 1, 1, 0, READ_LOCK);
2489 if (!NT_STATUS_IS_OK(status)) {
2490 printf("Unable to apply read lock on range 1:1, error was "
2491 "%s\n", nt_errstr(status));
2492 goto fail;
2493 }
2494
2495 status = cli_close(cli1, fnum1);
2496 if (!NT_STATUS_IS_OK(status)) {
2497 d_fprintf(stderr, "cli_close(fnum1) %s\n", nt_errstr(status));
2498 goto fail;
2499 }
2500
2501 status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2502 if (!NT_STATUS_IS_OK(status)) {
2503 d_fprintf(stderr, "cli_openx third time returned %s\n",
2504 nt_errstr(status));
2505 goto fail;
2506 }
2507
2508 correct = true;
2509
2510 fail:
2511 cli_close(cli1, fnum1);
2512 cli_close(cli1, fnum2);
2513 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2514 torture_close_connection(cli1);
2515
2516 printf("finished locktest8\n");
2517 return correct;
2518 }
2519
2520 /*
2521 * This test is designed to be run in conjunction with
2522 * external NFS or POSIX locks taken in the filesystem.
2523 * It checks that the smbd server will block until the
2524 * lock is released and then acquire it. JRA.
2525 */
2526
2527 static bool got_alarm;
2528 static struct cli_state *alarm_cli;
2529
2530 static void alarm_handler(int dummy)
2531 {
2532 got_alarm = True;
2533 }
2534
2535 static void alarm_handler_parent(int dummy)
2536 {
2537 smbXcli_conn_disconnect(alarm_cli->conn, NT_STATUS_OK);
2538 }
2539
2540 static void do_local_lock(int read_fd, int write_fd)
2541 {
2542 int fd;
2543 char c = '\0';
2544 struct flock lock;
2545 const char *local_pathname = NULL;
2546 int ret;
2547
2548 local_pathname = talloc_asprintf(talloc_tos(),
2549 "%s/lockt9.lck", local_path);
2550 if (!local_pathname) {
2551 printf("child: alloc fail\n");
2552 exit(1);
2553 }
2554
2555 unlink(local_pathname);
2556 fd = open(local_pathname, O_RDWR|O_CREAT, 0666);
2557 if (fd == -1) {
2558 printf("child: open of %s failed %s.\n",
2559 local_pathname, strerror(errno));
2560 exit(1);
2561 }
2562
2563 /* Now take a fcntl lock. */
2564 lock.l_type = F_WRLCK;
2565 lock.l_whence = SEEK_SET;
2566 lock.l_start = 0;
2567 lock.l_len = 4;
2568 lock.l_pid = getpid();
2569
2570 ret = fcntl(fd,F_SETLK,&lock);
2571 if (ret == -1) {
2572 printf("child: failed to get lock 0:4 on file %s. Error %s\n",
2573 local_pathname, strerror(errno));
2574 exit(1);
2575 } else {
2576 printf("child: got lock 0:4 on file %s.\n",
2577 local_pathname );
2578 fflush(stdout);
2579 }
2580
2581 CatchSignal(SIGALRM, alarm_handler);
2582 alarm(5);
2583 /* Signal the parent. */
2584 if (write(write_fd, &c, 1) != 1) {
2585 printf("child: start signal fail %s.\n",
2586 strerror(errno));
2587 exit(1);
2588 }
2589 alarm(0);
2590
2591 alarm(10);
2592 /* Wait for the parent to be ready. */
2593 if (read(read_fd, &c, 1) != 1) {
2594 printf("child: reply signal fail %s.\n",
2595 strerror(errno));
2596 exit(1);
2597 }
2598 alarm(0);
2599
2600 sleep(5);
2601 close(fd);
2602 printf("child: released lock 0:4 on file %s.\n",
2603 local_pathname );
2604 fflush(stdout);
2605 exit(0);
2606 }
2607
2608 static bool run_locktest9(int dummy)
2609 {
2610 struct cli_state *cli1;
2611 const char *fname = "\\lockt9.lck";
2612 uint16_t fnum;
2613 bool correct = False;
2614 int pipe_in[2], pipe_out[2];
2615 pid_t child_pid;
2616 char c = '\0';
2617 int ret;
2618 struct timeval start;
2619 double seconds;
2620 NTSTATUS status;
2621
2622 printf("starting locktest9\n");
2623
2624 if (local_path == NULL) {
2625 d_fprintf(stderr, "locktest9 must be given a local path via -l <localpath>\n");
2626 return false;
2627 }
2628
2629 if (pipe(pipe_in) == -1 || pipe(pipe_out) == -1) {
2630 return false;
2631 }
2632
2633 child_pid = fork();
2634 if (child_pid == -1) {
2635 return false;
2636 }
2637
2638 if (child_pid == 0) {
2639 /* Child. */
2640 do_local_lock(pipe_out[0], pipe_in[1]);
2641 exit(0);
2642 }
2643
2644 close(pipe_out[0]);
2645 close(pipe_in[1]);
2646 pipe_out[0] = -1;
2647 pipe_in[1] = -1;
2648
2649 /* Parent. */
2650 ret = read(pipe_in[0], &c, 1);
2651 if (ret != 1) {
2652 d_fprintf(stderr, "failed to read start signal from child. %s\n",
2653 strerror(errno));
2654 return false;
2655 }
2656
2657 if (!torture_open_connection(&cli1, 0)) {
2658 return false;
2659 }
2660
2661 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2662
2663 status = cli_openx(cli1, fname, O_RDWR, DENY_NONE,
2664 &fnum);
2665 if (!NT_STATUS_IS_OK(status)) {
2666 d_fprintf(stderr, "cli_openx returned %s\n", nt_errstr(status));
2667 return false;
2668 }
2669
2670 /* Ensure the child has the lock. */
2671 status = cli_lock32(cli1, fnum, 0, 4, 0, WRITE_LOCK);
2672 if (NT_STATUS_IS_OK(status)) {
2673 d_fprintf(stderr, "Got the lock on range 0:4 - this should not happen !\n");
2674 goto fail;
2675 } else {
2676 d_printf("Child has the lock.\n");
2677 }
2678
2679 /* Tell the child to wait 5 seconds then exit. */
2680 ret = write(pipe_out[1], &c, 1);
2681 if (ret != 1) {
2682 d_fprintf(stderr, "failed to send exit signal to child. %s\n",
2683 strerror(errno));
2684 goto fail;
2685 }
2686
2687 /* Wait 20 seconds for the lock. */
2688 alarm_cli = cli1;
2689 CatchSignal(SIGALRM, alarm_handler_parent);
2690 alarm(20);
2691
2692 start = timeval_current();
2693
2694 status = cli_lock32(cli1, fnum, 0, 4, -1, WRITE_LOCK);
2695 if (!NT_STATUS_IS_OK(status)) {
2696 d_fprintf(stderr, "Unable to apply write lock on range 0:4, error was "
2697 "%s\n", nt_errstr(status));
2698 goto fail_nofd;
2699 }
2700 alarm(0);
2701
2702 seconds = timeval_elapsed(&start);
2703
2704 printf("Parent got the lock after %.2f seconds.\n",
2705 seconds);
2706
2707 status = cli_close(cli1, fnum);
2708 if (!NT_STATUS_IS_OK(status)) {
2709 d_fprintf(stderr, "cli_close(fnum1) %s\n", nt_errstr(status));
2710 goto fail;
2711 }
2712
2713 correct = true;
2714
2715 fail:
2716 cli_close(cli1, fnum);
2717 torture_close_connection(cli1);
2718
2719 fail_nofd:
2720
2721 printf("finished locktest9\n");
2722 return correct;
2723 }
2724
2725 /*
2726 test whether fnums and tids open on one VC are available on another (a major
2727 security hole)
2728 */
2729 static bool run_fdpasstest(int dummy)
2730 {
2731 struct cli_state *cli1, *cli2;
2732 const char *fname = "\\fdpass.tst";
2733 uint16_t fnum1;
2734 char buf[1024];
2735 NTSTATUS status;
2736
2737 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2738 return False;
2739 }
2740 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2741 smbXcli_conn_set_sockopt(cli2->conn, sockops);
2742
2743 printf("starting fdpasstest\n");
2744
2745 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2746
2747 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
2748 &fnum1);
2749 if (!NT_STATUS_IS_OK(status)) {
2750 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
2751 return False;
2752 }
2753
2754 status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"hello world\n", 0,
2755 13, NULL);
2756 if (!NT_STATUS_IS_OK(status)) {
2757 printf("write failed (%s)\n", nt_errstr(status));
2758 return False;
2759 }
2760
2761 cli_state_set_uid(cli2, cli_state_get_uid(cli1));
2762 cli_state_set_tid(cli2, cli_state_get_tid(cli1));
2763 cli_setpid(cli2, cli_getpid(cli1));
2764
2765 if (test_cli_read(cli2, fnum1, buf, 0, 13, NULL, 13)) {
2766 printf("read succeeded! nasty security hole [%s]\n", buf);
2767 return false;
2768 }
2769
2770 cli_close(cli1, fnum1);
2771 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2772
2773 torture_close_connection(cli1);
2774 torture_close_connection(cli2);
2775
2776 printf("finished fdpasstest\n");
2777 return True;
2778 }
2779
2780 static bool run_fdsesstest(int dummy)
2781 {
2782 struct cli_state *cli;
2783 uint16_t new_vuid;
2784 uint16_t saved_vuid;
2785 uint32_t new_cnum;
2786 uint32_t saved_cnum;
2787 const char *fname = "\\fdsess.tst";
2788 const char *fname1 = "\\fdsess1.tst";
2789 uint16_t fnum1;
2790 uint16_t fnum2;
2791 char buf[1024];
2792 bool ret = True;
2793 NTSTATUS status;
2794
2795 if (!torture_open_connection(&cli, 0))
2796 return False;
2797 smbXcli_conn_set_sockopt(cli->conn, sockops);
2798
2799 if (!torture_cli_session_setup2(cli, &new_vuid))
2800 return False;
2801
2802 saved_cnum = cli_state_get_tid(cli);
2803 if (!NT_STATUS_IS_OK(cli_tree_connect(cli, share, "?????", NULL)))
2804 return False;
2805 new_cnum = cli_state_get_tid(cli);
2806 cli_state_set_tid(cli, saved_cnum);
2807
2808 printf("starting fdsesstest\n");
2809
2810 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2811 cli_unlink(cli, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2812
2813 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2814 if (!NT_STATUS_IS_OK(status)) {
2815 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
2816 return False;
2817 }
2818
2819 status = cli_writeall(cli, fnum1, 0, (const uint8_t *)"hello world\n", 0, 13,
2820 NULL);
2821 if (!NT_STATUS_IS_OK(status)) {
2822 printf("write failed (%s)\n", nt_errstr(status));
2823 return False;
2824 }
2825
2826 saved_vuid = cli_state_get_uid(cli);
2827 cli_state_set_uid(cli, new_vuid);
2828
2829 if (test_cli_read(cli, fnum1, buf, 0, 13, NULL, 13)) {
2830 printf("read succeeded with different vuid! "
2831 "nasty security hole [%s]\n", buf);
2832 ret = false;
2833 }
2834 /* Try to open a file with different vuid, samba cnum. */
2835 if (NT_STATUS_IS_OK(cli_openx(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum2))) {
2836 printf("create with different vuid, same cnum succeeded.\n");
2837 cli_close(cli, fnum2);
2838 cli_unlink(cli, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2839 } else {
2840 printf("create with different vuid, same cnum failed.\n");
2841 printf("This will cause problems with service clients.\n");
2842 ret = False;
2843 }
2844
2845 cli_state_set_uid(cli, saved_vuid);
2846
2847 /* Try with same vuid, different cnum. */
2848 cli_state_set_tid(cli, new_cnum);
2849
2850 if (test_cli_read(cli, fnum1, buf, 0, 13, NULL, 13)) {
2851 printf("read succeeded with different cnum![%s]\n", buf);
2852 ret = false;
2853 }
2854
2855 cli_state_set_tid(cli, saved_cnum);
2856 cli_close(cli, fnum1);
2857 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2858
2859 torture_close_connection(cli);
2860
2861 printf("finished fdsesstest\n");
2862 return ret;
2863 }
2864
2865 /*
2866 This test checks that
2867
2868 1) the server does not allow an unlink on a file that is open
2869 */
2870 static bool run_unlinktest(int dummy)
2871 {
2872 struct cli_state *cli;
2873 const char *fname = "\\unlink.tst";
2874 uint16_t fnum;
2875 bool correct = True;
2876 NTSTATUS status;
2877
2878 if (!torture_open_connection(&cli, 0)) {
2879 return False;
2880 }
2881
2882 smbXcli_conn_set_sockopt(cli->conn, sockops);
2883
2884 printf("starting unlink test\n");
2885
2886 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2887
2888 cli_setpid(cli, 1);
2889
2890 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
2891 if (!NT_STATUS_IS_OK(status)) {
2892 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
2893 return False;
2894 }
2895
2896 status = cli_unlink(cli, fname,
2897 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2898 if (NT_STATUS_IS_OK(status)) {
2899 printf("error: server allowed unlink on an open file\n");
2900 correct = False;
2901 } else {
2902 correct = check_error(__LINE__, status, ERRDOS, ERRbadshare,
2903 NT_STATUS_SHARING_VIOLATION);
2904 }
2905
2906 cli_close(cli, fnum);
2907 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2908
2909 if (!torture_close_connection(cli)) {
2910 correct = False;
2911 }
2912
2913 printf("unlink test finished\n");
2914
2915 return correct;
2916 }
2917
2918
2919 /*
2920 test how many open files this server supports on the one socket
2921 */
2922 static bool run_maxfidtest(int dummy)
2923 {
2924 struct cli_state *cli;
2925 fstring fname;
2926 uint16_t fnums[0x11000];
2927 int i;
2928 int retries=4;
2929 bool correct = True;
2930 NTSTATUS status;
2931
2932 cli = current_cli;
2933
2934 if (retries <= 0) {
2935 printf("failed to connect\n");
2936 return False;
2937 }
2938
2939 smbXcli_conn_set_sockopt(cli->conn, sockops);
2940
2941 for (i=0; i<0x11000; i++) {
2942 slprintf(fname,sizeof(fname)-1,"\\maxfid.%d.%d", i,(int)getpid());
2943 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE,
2944 &fnums[i]);
2945 if (!NT_STATUS_IS_OK(status)) {
2946 printf("open of %s failed (%s)\n",
2947 fname, nt_errstr(status));
2948 printf("maximum fnum is %d\n", i);
2949 break;
2950 }
2951 printf("%6d\r", i);
2952 }
2953 printf("%6d\n", i);
2954 i--;
2955
2956 printf("cleaning up\n");
2957 for (;i>=0;i--) {
2958 slprintf(fname,sizeof(fname)-1,"\\maxfid.%d.%d", i,(int)getpid());
2959 cli_close(cli, fnums[i]);
2960
2961 status = cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2962 if (!NT_STATUS_IS_OK(status)) {
2963 printf("unlink of %s failed (%s)\n",
2964 fname, nt_errstr(status));
2965 correct = False;
2966 }
2967 printf("%6d\r", i);
2968 }
2969 printf("%6d\n", 0);
2970
2971 printf("maxfid test finished\n");
2972 if (!torture_close_connection(cli)) {
2973 correct = False;
2974 }
2975 return correct;
2976 }
2977
2978 /* generate a random buffer */
2979 static void rand_buf(char *buf, int len)
2980 {
2981 while (len--) {
2982 *buf = (char)sys_random();
2983 buf++;
2984 }
2985 }
2986
2987 /* send smb negprot commands, not reading the response */
2988 static bool run_negprot_nowait(int dummy)
2989 {
2990 struct tevent_context *ev;
2991 int i;
2992 struct cli_state *cli;
2993 bool correct = True;
2994
2995 printf("starting negprot nowait test\n");
2996
2997 ev = samba_tevent_context_init(talloc_tos());
2998 if (ev == NULL) {
2999 return false;
3000 }
3001
3002 if (!(cli = open_nbt_connection())) {
3003 TALLOC_FREE(ev);
3004 return False;
3005 }
3006
3007 for (i=0;i<50000;i++) {
3008 struct tevent_req *req;
3009
3010 req = smbXcli_negprot_send(ev, ev, cli->conn, cli->timeout,
3011 PROTOCOL_CORE, PROTOCOL_NT1, 0);
3012 if (req == NULL) {
3013 TALLOC_FREE(ev);
3014 return false;
3015 }
3016 if (!tevent_req_poll(req, ev)) {
3017 d_fprintf(stderr, "tevent_req_poll failed: %s\n",
3018 strerror(errno));
3019 TALLOC_FREE(ev);
3020 return false;
3021 }
3022 TALLOC_FREE(req);
3023 }
3024
3025 if (torture_close_connection(cli)) {
3026 correct = False;
3027 }
3028
3029 printf("finished negprot nowait test\n");
3030
3031 return correct;
3032 }
3033
3034 /* send smb negprot commands, not reading the response */
3035 static bool run_bad_nbt_session(int dummy)
3036 {
3037 struct nmb_name called, calling;
3038 struct sockaddr_storage ss;
3039 NTSTATUS status;
3040 int fd;
3041 bool ret;
3042
3043 printf("starting bad nbt session test\n");
3044
3045 make_nmb_name(&calling, myname, 0x0);
3046 make_nmb_name(&called , host, 0x20);
3047
3048 if (!resolve_name(host, &ss, 0x20, true)) {
3049 d_fprintf(stderr, "Could not resolve name %s\n", host);
3050 return false;
3051 }
3052
3053 status = open_socket_out(&ss, NBT_SMB_PORT, 10000, &fd);
3054 if (!NT_STATUS_IS_OK(status)) {
3055 d_fprintf(stderr, "open_socket_out failed: %s\n",
3056 nt_errstr(status));
3057 return false;
3058 }
3059
3060 ret = cli_bad_session_request(fd, &calling, &called);
3061 close(fd);
3062 if (!ret) {
3063 d_fprintf(stderr, "open_socket_out failed: %s\n",
3064 nt_errstr(status));
3065 return false;
3066 }
3067
3068 printf("finished bad nbt session test\n");
3069 return true;
3070 }
3071
3072 /* send random IPC commands */
3073 static bool run_randomipc(int dummy)
3074 {
3075 char *rparam = NULL;
3076 char *rdata = NULL;
3077 unsigned int rdrcnt,rprcnt;
3078 char param[1024];
3079 int api, param_len, i;
3080 struct cli_state *cli;
3081 bool correct = True;
3082 int count = 50000;
3083
3084 printf("starting random ipc test\n");
3085
3086 if (!torture_open_connection(&cli, 0)) {
3087 return False;
3088 }
3089
3090 for (i=0;i<count;i++) {
3091 api = sys_random() % 500;
3092 param_len = (sys_random() % 64);
3093
3094 rand_buf(param, param_len);
3095
3096 SSVAL(param,0,api);
3097
3098 cli_api(cli,
3099 param, param_len, 8,
3100 NULL, 0, CLI_BUFFER_SIZE,
3101 &rparam, &rprcnt,
3102 &rdata, &rdrcnt);
3103 if (i % 100 == 0) {
3104 printf("%d/%d\r", i,count);
3105 }
3106 }
3107 printf("%d/%d\n", i, count);
3108
3109 if (!torture_close_connection(cli)) {
3110 correct = False;
3111 }
3112
3113 SAFE_FREE(rparam);
3114 SAFE_FREE(rdata);
3115
3116 printf("finished random ipc test\n");
3117
3118 return correct;
3119 }
3120
3121
3122
3123 static void browse_callback(const char *sname, uint32_t stype,
3124 const char *comment, void *state)
3125 {
3126 printf("\t%20.20s %08x %s\n", sname, stype, comment);
3127 }
3128
3129
3130
3131 /*
3132 This test checks the browse list code
3133
3134 */
3135 static bool run_browsetest(int dummy)
3136 {
3137 static struct cli_state *cli;
3138 bool correct = True;
3139
3140 printf("starting browse test\n");
3141
3142 if (!torture_open_connection(&cli, 0)) {
3143 return False;
3144 }
3145
3146 printf("domain list:\n");
3147 cli_NetServerEnum(cli, cli->server_domain,
3148 SV_TYPE_DOMAIN_ENUM,
3149 browse_callback, NULL);
3150
3151 printf("machine list:\n");
3152 cli_NetServerEnum(cli, cli->server_domain,
3153 SV_TYPE_ALL,
3154 browse_callback, NULL);
3155
3156 if (!torture_close_connection(cli)) {
3157 correct = False;
3158 }
3159
3160 printf("browse test finished\n");
3161
3162 return correct;
3163
3164 }
3165
3166 static bool check_attributes(struct cli_state *cli,
3167 const char *fname,
3168 uint16_t expected_attrs)
3169 {
3170 uint16_t attrs = 0;
3171 NTSTATUS status = cli_getatr(cli,
3172 fname,
3173 &attrs,
3174 NULL,
3175 NULL);
3176 if (!NT_STATUS_IS_OK(status)) {
3177 printf("cli_getatr failed with %s\n",
3178 nt_errstr(status));
3179 return false;
3180 }
3181 if (attrs != expected_attrs) {
3182 printf("Attributes incorrect 0x%x, should be 0x%x\n",
3183 (unsigned int)attrs,
3184 (unsigned int)expected_attrs);
3185 return false;
3186 }
3187 return true;
3188 }
3189
3190 /*
3191 This checks how the getatr calls works
3192 */
3193 static bool run_attrtest(int dummy)
3194 {
3195 struct cli_state *cli;
3196 uint16_t fnum;
3197 time_t t, t2;
3198 const char *fname = "\\attrib123456789.tst";
3199 bool correct = True;
3200 NTSTATUS status;
3201
3202 printf("starting attrib test\n");
3203
3204 if (!torture_open_connection(&cli, 0)) {
3205 return False;
3206 }
3207
3208 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3209 cli_openx(cli, fname,
3210 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3211 cli_close(cli, fnum);
3212
3213 status = cli_getatr(cli, fname, NULL, NULL, &t);
3214 if (!NT_STATUS_IS_OK(status)) {
3215 printf("getatr failed (%s)\n", nt_errstr(status));
3216 correct = False;
3217 }
3218
3219 if (labs(t - time(NULL)) > 60*60*24*10) {
3220 printf("ERROR: SMBgetatr bug. time is %s",
3221 ctime(&t));
3222 t = time(NULL);
3223 correct = True;
3224 }
3225
3226 t2 = t-60*60*24; /* 1 day ago */
3227
3228 status = cli_setatr(cli, fname, 0, t2);
3229 if (!NT_STATUS_IS_OK(status)) {
3230 printf("setatr failed (%s)\n", nt_errstr(status));
3231 correct = True;
3232 }
3233
3234 status = cli_getatr(cli, fname, NULL, NULL, &t);
3235 if (!NT_STATUS_IS_OK(status)) {
3236 printf("getatr failed (%s)\n", nt_errstr(status));
3237 correct = True;
3238 }
3239
3240 if (t != t2) {
3241 printf("ERROR: getatr/setatr bug. times are\n%s",
3242 ctime(&t));
3243 printf("%s", ctime(&t2));
3244 correct = True;
3245 }
3246
3247 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3248
3249 /* Check cli_setpathinfo_basic() */
3250 /* Re-create the file. */
3251 status = cli_openx(cli, fname,
3252 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3253 if (!NT_STATUS_IS_OK(status)) {
3254 printf("Failed to recreate %s (%s)\n",
3255 fname, nt_errstr(status));
3256 correct = false;
3257 }
3258 cli_close(cli, fnum);
3259
3260 status = cli_setpathinfo_basic(cli,
3261 fname,
3262 0, /* create */
3263 0, /* access */
3264 0, /* write */
3265 0, /* change */
3266 FILE_ATTRIBUTE_SYSTEM |
3267 FILE_ATTRIBUTE_HIDDEN |
3268 FILE_ATTRIBUTE_READONLY);
3269 if (!NT_STATUS_IS_OK(status)) {
3270 printf("cli_setpathinfo_basic failed with %s\n",
3271 nt_errstr(status));
3272 correct = false;
3273 }
3274
3275 /* Check attributes are correct. */
3276 correct = check_attributes(cli,
3277 fname,
3278 FILE_ATTRIBUTE_SYSTEM |
3279 FILE_ATTRIBUTE_HIDDEN |
3280 FILE_ATTRIBUTE_READONLY);
3281 if (correct == false) {
3282 goto out;
3283 }
3284
3285 /* Setting to FILE_ATTRIBUTE_NORMAL should be ignored. */
3286 status = cli_setpathinfo_basic(cli,
3287 fname,
3288 0, /* create */
3289 0, /* access */
3290 0, /* write */
3291 0, /* change */
3292 FILE_ATTRIBUTE_NORMAL);
3293 if (!NT_STATUS_IS_OK(status)) {
3294 printf("cli_setpathinfo_basic failed with %s\n",
3295 nt_errstr(status));
3296 correct = false;
3297 }
3298
3299 /* Check attributes are correct. */
3300 correct = check_attributes(cli,
3301 fname,
3302 FILE_ATTRIBUTE_SYSTEM |
3303 FILE_ATTRIBUTE_HIDDEN |
3304 FILE_ATTRIBUTE_READONLY);
3305 if (correct == false) {
3306 goto out;
3307 }
3308
3309 /* Setting to (uint16_t)-1 should also be ignored. */
3310 status = cli_setpathinfo_basic(cli,
3311 fname,
3312 0, /* create */
3313 0, /* access */
3314 0, /* write */
3315 0, /* change */
3316 (uint16_t)-1);
3317 if (!NT_STATUS_IS_OK(status)) {
3318 printf("cli_setpathinfo_basic failed with %s\n",
3319 nt_errstr(status));
3320 correct = false;
3321 }
3322
3323 /* Check attributes are correct. */
3324 correct = check_attributes(cli,
3325 fname,
3326 FILE_ATTRIBUTE_SYSTEM |
3327 FILE_ATTRIBUTE_HIDDEN |
3328 FILE_ATTRIBUTE_READONLY);
3329 if (correct == false) {
3330 goto out;
3331 }
3332
3333 /* Setting to 0 should clear them all. */
3334 status = cli_setpathinfo_basic(cli,
3335 fname,
3336 0, /* create */
3337 0, /* access */
3338 0, /* write */
3339 0, /* change */
3340 0);
3341 if (!NT_STATUS_IS_OK(status)) {
3342 printf("cli_setpathinfo_basic failed with %s\n",
3343 nt_errstr(status));
3344 correct = false;
3345 }
3346
3347 /* Check attributes are correct. */
3348 correct = check_attributes(cli,
3349 fname,
3350 FILE_ATTRIBUTE_NORMAL);
3351 if (correct == false) {
3352 goto out;
3353 }
3354
3355 out:
3356
3357 cli_unlink(cli,
3358 fname,
3359 FILE_ATTRIBUTE_SYSTEM |
3360 FILE_ATTRIBUTE_HIDDEN|
3361 FILE_ATTRIBUTE_READONLY);
3362
3363 if (!torture_close_connection(cli)) {
3364 correct = False;
3365 }
3366
3367 printf("attrib test finished\n");
3368
3369 return correct;
3370 }
3371
3372
3373 /*
3374 This checks a couple of trans2 calls
3375 */
3376 static bool run_trans2test(int dummy)
3377 {
3378 struct cli_state *cli;
3379 uint16_t fnum;
3380 off_t size;
3381 time_t c_time, a_time, m_time;
3382 struct timespec c_time_ts, a_time_ts, m_time_ts, w_time_ts, m_time2_ts;
3383 const char *fname = "\\trans2.tst";
3384 const char *dname = "\\trans2";
3385 const char *fname2 = "\\trans2\\trans2.tst";
3386 char *pname;
3387 bool correct = True;
3388 NTSTATUS status;
3389 uint32_t fs_attr;
3390
3391 printf("starting trans2 test\n");
3392
3393 if (!torture_open_connection(&cli, 0)) {
3394 return False;
3395 }
3396
3397 status = cli_get_fs_attr_info(cli, &fs_attr);
3398 if (!NT_STATUS_IS_OK(status)) {
3399 printf("ERROR: cli_get_fs_attr_info returned %s\n",
3400 nt_errstr(status));
3401 correct = false;
3402 }
3403
3404 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3405 cli_openx(cli, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3406 status = cli_qfileinfo_basic(cli, fnum, NULL, &size, &c_time_ts,
3407 &a_time_ts, &w_time_ts, &m_time_ts, NULL);
3408 if (!NT_STATUS_IS_OK(status)) {
3409 printf("ERROR: qfileinfo failed (%s)\n", nt_errstr(status));
3410 correct = False;
3411 }
3412
3413 status = cli_qfilename(cli, fnum, talloc_tos(), &pname);
3414 if (!NT_STATUS_IS_OK(status)) {
3415 printf("ERROR: qfilename failed (%s)\n", nt_errstr(status));
3416 correct = False;
3417 }
3418 else if (strcmp(pname, fname)) {
3419 printf("qfilename gave different name? [%s] [%s]\n",
3420 fname, pname);
3421 correct = False;
3422 }
3423
3424 cli_close(cli, fnum);
3425
3426 sleep(2);
3427
3428 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3429 status = cli_openx(cli, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE,
3430 &fnum);
3431 if (!NT_STATUS_IS_OK(status)) {
3432 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3433 return False;
3434 }
3435 cli_close(cli, fnum);
3436
3437 status = cli_qpathinfo1(cli, fname, &c_time, &a_time, &m_time, &size,
3438 NULL);
3439 if (!NT_STATUS_IS_OK(status)) {
3440 printf("ERROR: qpathinfo failed (%s)\n", nt_errstr(status));
3441 correct = False;
3442 } else {
3443 time_t t = time(NULL);
3444
3445 if (c_time != m_time) {
3446 printf("create time=%s", ctime(&c_time));
3447 printf("modify time=%s", ctime(&m_time));
3448 printf("This system appears to have sticky create times\n");
3449 }
3450 if ((labs(a_time - t) > 60) && (a_time % (60*60) == 0)) {
3451 printf("access time=%s", ctime(&a_time));
3452 printf("This system appears to set a midnight access time\n");
3453 correct = False;
3454 }
3455
3456 if (labs(m_time - t) > 60*60*24*7) {
3457 printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
3458 correct = False;
3459 }
3460 }
3461
3462
3463 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3464 cli_openx(cli, fname,
3465 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3466 cli_close(cli, fnum);
3467 status = cli_qpathinfo2(cli, fname, &c_time_ts, &a_time_ts, &w_time_ts,
3468 &m_time_ts, &size, NULL, NULL);
3469 if (!NT_STATUS_IS_OK(status)) {
3470 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
3471 correct = False;
3472 } else {
3473 if (w_time_ts.tv_sec < 60*60*24*2) {
3474 printf("write time=%s", ctime(&w_time_ts.tv_sec));
3475 printf("This system appears to set a initial 0 write time\n");
3476 correct = False;
3477 }
3478 }
3479
3480 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3481
3482
3483 /* check if the server updates the directory modification time
3484 when creating a new file */
3485 status = cli_mkdir(cli, dname);
3486 if (!NT_STATUS_IS_OK(status)) {
3487 printf("ERROR: mkdir failed (%s)\n", nt_errstr(status));
3488 correct = False;
3489 }
3490 sleep(3);
3491 status = cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts,
3492 &w_time_ts, &m_time_ts, &size, NULL, NULL);
3493 if (!NT_STATUS_IS_OK(status)) {
3494 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
3495 correct = False;
3496 }
3497
3498 cli_openx(cli, fname2,
3499 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3500 cli_writeall(cli, fnum, 0, (uint8_t *)&fnum, 0, sizeof(fnum), NULL);
3501 cli_close(cli, fnum);
3502 status = cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts,
3503 &w_time_ts, &m_time2_ts, &size, NULL, NULL);
3504 if (!NT_STATUS_IS_OK(status)) {
3505 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
3506 correct = False;
3507 } else {
3508 if (memcmp(&m_time_ts, &m_time2_ts, sizeof(struct timespec))
3509 == 0) {
3510 printf("This system does not update directory modification times\n");
3511 correct = False;
3512 }
3513 }
3514 cli_unlink(cli, fname2, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3515 cli_rmdir(cli, dname);
3516
3517 if (!torture_close_connection(cli)) {
3518 correct = False;
3519 }
3520
3521 printf("trans2 test finished\n");
3522
3523 return correct;
3524 }
3525
3526 /*
3527 This checks new W2K calls.
3528 */
3529
3530 static NTSTATUS new_trans(struct cli_state *pcli, int fnum, int level)
3531 {
3532 uint8_t *buf = NULL;
3533 uint32_t len;
3534 NTSTATUS status;
3535
3536 status = cli_qfileinfo(talloc_tos(), pcli, fnum, level, 0,
3537 CLI_BUFFER_SIZE, NULL, &buf, &len);
3538 if (!NT_STATUS_IS_OK(status)) {
3539 printf("ERROR: qfileinfo (%d) failed (%s)\n", level,
3540 nt_errstr(status));
3541 } else {
3542 printf("qfileinfo: level %d, len = %u\n", level, len);
3543 dump_data(0, (uint8_t *)buf, len);
3544 printf("\n");
3545 }
3546 TALLOC_FREE(buf);
3547 return status;
3548 }
3549
3550 static bool run_w2ktest(int dummy)
3551 {
3552 struct cli_state *cli;
3553 uint16_t fnum;
3554 const char *fname = "\\w2ktest\\w2k.tst";
3555 int level;
3556 bool correct = True;
3557
3558 printf("starting w2k test\n");
3559
3560 if (!torture_open_connection(&cli, 0)) {
3561 return False;
3562 }
3563
3564 cli_openx(cli, fname,
3565 O_RDWR | O_CREAT , DENY_NONE, &fnum);
3566
3567 for (level = 1004; level < 1040; level++) {
3568 new_trans(cli, fnum, level);
3569 }
3570
3571 cli_close(cli, fnum);
3572
3573 if (!torture_close_connection(cli)) {
3574 correct = False;
3575 }
3576
3577 printf("w2k test finished\n");
3578
3579 return correct;
3580 }
3581
3582
3583 /*
3584 this is a harness for some oplock tests
3585 */
3586 static bool run_oplock1(int dummy)
3587 {
3588 struct cli_state *cli1;
3589 const char *fname = "\\lockt1.lck";
3590 uint16_t fnum1;
3591 bool correct = True;
3592 NTSTATUS status;
3593
3594 printf("starting oplock test 1\n");
3595
3596 if (!torture_open_connection(&cli1, 0)) {
3597 return False;
3598 }
3599
3600 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3601
3602 smbXcli_conn_set_sockopt(cli1->conn, sockops);
3603
3604 cli1->use_oplocks = True;
3605
3606 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
3607 &fnum1);
3608 if (!NT_STATUS_IS_OK(status)) {
3609 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3610 return False;
3611 }
3612
3613 cli1->use_oplocks = False;
3614
3615 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3616 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3617
3618 status = cli_close(cli1, fnum1);
3619 if (!NT_STATUS_IS_OK(status)) {
3620 printf("close2 failed (%s)\n", nt_errstr(status));
3621 return False;
3622 }
3623
3624 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3625 if (!NT_STATUS_IS_OK(status)) {
3626 printf("unlink failed (%s)\n", nt_errstr(status));
3627 return False;
3628 }
3629
3630 if (!torture_close_connection(cli1)) {
3631 correct = False;
3632 }
3633
3634 printf("finished oplock test 1\n");
3635
3636 return correct;
3637 }
3638
3639 static bool run_oplock2(int dummy)
3640 {
3641 struct cli_state *cli1, *cli2;
3642 const char *fname = "\\lockt2.lck";
3643 uint16_t fnum1, fnum2;
3644 int saved_use_oplocks = use_oplocks;
3645 char buf[4];
3646 bool correct = True;
3647 volatile bool *shared_correct;
3648 size_t nread;
3649 NTSTATUS status;
3650
3651 shared_correct = (volatile bool *)anonymous_shared_allocate(sizeof(bool));
3652 *shared_correct = True;
3653
3654 use_level_II_oplocks = True;
3655 use_oplocks = True;
3656
3657 printf("starting oplock test 2\n");
3658
3659 if (!torture_open_connection(&cli1, 0)) {
3660 use_level_II_oplocks = False;
3661 use_oplocks = saved_use_oplocks;
3662 return False;
3663 }
3664
3665 if (!torture_open_connection(&cli2, 1)) {
3666 use_level_II_oplocks = False;
3667 use_oplocks = saved_use_oplocks;
3668 return False;
3669 }
3670
3671 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3672
3673 smbXcli_conn_set_sockopt(cli1->conn, sockops);
3674 smbXcli_conn_set_sockopt(cli2->conn, sockops);
3675
3676 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
3677 &fnum1);
3678 if (!NT_STATUS_IS_OK(status)) {
3679 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3680 return False;
3681 }
3682
3683 /* Don't need the globals any more. */
3684 use_level_II_oplocks = False;
3685 use_oplocks = saved_use_oplocks;
3686
3687 if (fork() == 0) {
3688 /* Child code */
3689 status = cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
3690 if (!NT_STATUS_IS_OK(status)) {
3691 printf("second open of %s failed (%s)\n", fname, nt_errstr(status));
3692 *shared_correct = False;
3693 exit(0);
3694 }
3695
3696 sleep(2);
3697
3698 status = cli_close(cli2, fnum2);
3699 if (!NT_STATUS_IS_OK(status)) {
3700 printf("close2 failed (%s)\n", nt_errstr(status));
3701 *shared_correct = False;
3702 }
3703
3704 exit(0);
3705 }
3706
3707 sleep(2);
3708
3709 /* Ensure cli1 processes the break. Empty file should always return 0
3710 * bytes. */
3711 status = cli_read(cli1, fnum1, buf, 0, 4, &nread);
3712 if (!NT_STATUS_IS_OK(status)) {
3713 printf("read on fnum1 failed (%s)\n", nt_errstr(status));
3714 correct = false;
3715 } else if (nread != 0) {
3716 printf("read on empty fnum1 failed. recv %ld expected %d\n",
3717 (unsigned long)nread, 0);
3718 correct = false;
3719 }
3720
3721 /* Should now be at level II. */
3722 /* Test if sending a write locks causes a break to none. */
3723 status = cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK);
3724 if (!NT_STATUS_IS_OK(status)) {
3725 printf("lock failed (%s)\n", nt_errstr(status));
3726 correct = False;
3727 }
3728
3729 cli_unlock(cli1, fnum1, 0, 4);
3730
3731 sleep(2);
3732
3733 status = cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK);
3734 if (!NT_STATUS_IS_OK(status)) {
3735 printf("lock failed (%s)\n", nt_errstr(status));
3736 correct = False;
3737 }
3738
3739 cli_unlock(cli1, fnum1, 0, 4);
3740
3741 sleep(2);
3742
3743 cli_read(cli1, fnum1, buf, 0, 4, NULL);
3744
3745 status = cli_close(cli1, fnum1);
3746 if (!NT_STATUS_IS_OK(status)) {
3747 printf("close1 failed (%s)\n", nt_errstr(status));
3748 correct = False;
3749 }
3750
3751 sleep(4);
3752
3753 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3754 if (!NT_STATUS_IS_OK(status)) {
3755 printf("unlink failed (%s)\n", nt_errstr(status));
3756 correct = False;
3757 }
3758
3759 if (!torture_close_connection(cli1)) {
3760 correct = False;
3761 }
3762
3763 if (!*shared_correct) {
3764 correct = False;
3765 }
3766
3767 printf("finished oplock test 2\n");
3768
3769 return correct;
3770 }
3771
3772 struct oplock4_state {
3773 struct tevent_context *ev;
3774 struct cli_state *cli;
3775 bool *got_break;
3776 uint16_t *fnum2;
3777 };
3778
3779 static void oplock4_got_break(struct tevent_req *req);
3780 static void oplock4_got_open(struct tevent_req *req);
3781
3782 static bool run_oplock4(int dummy)
3783 {
3784 struct tevent_context *ev;
3785 struct cli_state *cli1, *cli2;
3786 struct tevent_req *oplock_req, *open_req;
3787 const char *fname = "\\lockt4.lck";
3788 const char *fname_ln = "\\lockt4_ln.lck";
3789 uint16_t fnum1, fnum2;
3790 int saved_use_oplocks = use_oplocks;
3791 NTSTATUS status;
3792 bool correct = true;
3793
3794 bool got_break;
3795
3796 struct oplock4_state *state;
3797
3798 printf("starting oplock test 4\n");
3799
3800 if (!torture_open_connection(&cli1, 0)) {
3801 use_level_II_oplocks = false;
3802 use_oplocks = saved_use_oplocks;
3803 return false;
3804 }
3805
3806 if (!torture_open_connection(&cli2, 1)) {
3807 use_level_II_oplocks = false;
3808 use_oplocks = saved_use_oplocks;
3809 return false;
3810 }
3811
3812 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3813 cli_unlink(cli1, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3814
3815 smbXcli_conn_set_sockopt(cli1->conn, sockops);
3816 smbXcli_conn_set_sockopt(cli2->conn, sockops);
3817
3818 /* Create the file. */
3819 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
3820 &fnum1);
3821 if (!NT_STATUS_IS_OK(status)) {
3822 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3823 return false;
3824 }
3825
3826 status = cli_close(cli1, fnum1);
3827 if (!NT_STATUS_IS_OK(status)) {
3828 printf("close1 failed (%s)\n", nt_errstr(status));
3829 return false;
3830 }
3831
3832 /* Now create a hardlink. */
3833 status = cli_nt_hardlink(cli1, fname, fname_ln);
3834 if (!NT_STATUS_IS_OK(status)) {
3835 printf("nt hardlink failed (%s)\n", nt_errstr(status));
3836 return false;
3837 }
3838
3839 /* Prove that opening hardlinks cause deny modes to conflict. */
3840 status = cli_openx(cli1, fname, O_RDWR, DENY_ALL, &fnum1);
3841 if (!NT_STATUS_IS_OK(status)) {
3842 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3843 return false;
3844 }
3845
3846 status = cli_openx(cli1, fname_ln, O_RDWR, DENY_NONE, &fnum2);
3847 if (NT_STATUS_IS_OK(status)) {
3848 printf("open of %s succeeded - should fail with sharing violation.\n",
3849 fname_ln);
3850 return false;
3851 }
3852
3853 if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
3854 printf("open of %s should fail with sharing violation. Got %s\n",
3855 fname_ln, nt_errstr(status));
3856 return false;
3857 }
3858
3859 status = cli_close(cli1, fnum1);
3860 if (!NT_STATUS_IS_OK(status)) {
3861 printf("close1 failed (%s)\n", nt_errstr(status));
3862 return false;
3863 }
3864
3865 cli1->use_oplocks = true;
3866 cli2->use_oplocks = true;
3867
3868 status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
3869 if (!NT_STATUS_IS_OK(status)) {
3870 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3871 return false;
3872 }
3873
3874 ev = samba_tevent_context_init(talloc_tos());
3875 if (ev == NULL) {
3876 printf("tevent_context_init failed\n");
3877 return false;
3878 }
3879
3880 state = talloc(ev, struct oplock4_state);
3881 if (state == NULL) {
3882 printf("talloc failed\n");
3883 return false;
3884 }
3885 state->ev = ev;
3886 state->cli = cli1;
3887 state->got_break = &got_break;
3888 state->fnum2 = &fnum2;
3889
3890 oplock_req = cli_smb_oplock_break_waiter_send(
3891 talloc_tos(), ev, cli1);
3892 if (oplock_req == NULL) {
3893 printf("cli_smb_oplock_break_waiter_send failed\n");
3894 return false;
3895 }
3896 tevent_req_set_callback(oplock_req, oplock4_got_break, state);
3897
3898 open_req = cli_openx_send(
3899 talloc_tos(), ev, cli2, fname_ln, O_RDWR, DENY_NONE);
3900 if (open_req == NULL) {
3901 printf("cli_openx_send failed\n");
3902 return false;
3903 }
3904 tevent_req_set_callback(open_req, oplock4_got_open, state);
3905
3906 got_break = false;
3907 fnum2 = 0xffff;
3908
3909 while (!got_break || fnum2 == 0xffff) {
3910 int ret;
3911 ret = tevent_loop_once(ev);
3912 if (ret == -1) {
3913 printf("tevent_loop_once failed: %s\n",
3914 strerror(errno));
3915 return false;
3916 }
3917 }
3918
3919 status = cli_close(cli2, fnum2);
3920 if (!NT_STATUS_IS_OK(status)) {
3921 printf("close2 failed (%s)\n", nt_errstr(status));
3922 correct = false;
3923 }
3924
3925 status = cli_close(cli1, fnum1);
3926 if (!NT_STATUS_IS_OK(status)) {
3927 printf("close1 failed (%s)\n", nt_errstr(status));
3928 correct = false;
3929 }
3930
3931 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3932 if (!NT_STATUS_IS_OK(status)) {
3933 printf("unlink failed (%s)\n", nt_errstr(status));
3934 correct = false;
3935 }
3936
3937 status = cli_unlink(cli1, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3938 if (!NT_STATUS_IS_OK(status)) {
3939 printf("unlink failed (%s)\n", nt_errstr(status));
3940 correct = false;
3941 }
3942
3943 if (!torture_close_connection(cli1)) {
3944 correct = false;
3945 }
3946
3947 if (!got_break) {
3948 correct = false;
3949 }
3950
3951 printf("finished oplock test 4\n");
3952
3953 return correct;
3954 }
3955
3956 static void oplock4_got_break(struct tevent_req *req)
3957 {
3958 struct oplock4_state *state = tevent_req_callback_data(
3959 req, struct oplock4_state);
3960 uint16_t fnum;
3961 uint8_t level;
3962 NTSTATUS status;
3963
3964 status = cli_smb_oplock_break_waiter_recv(req, &fnum, &level);
3965 TALLOC_FREE(req);
3966 if (!NT_STATUS_IS_OK(status)) {
3967 printf("cli_smb_oplock_break_waiter_recv returned %s\n",
3968 nt_errstr(status));
3969 return;
3970 }
3971 *state->got_break = true;
3972
3973 req = cli_oplock_ack_send(state, state->ev, state->cli, fnum,
3974 NO_OPLOCK);
3975 if (req == NULL) {
3976 printf("cli_oplock_ack_send failed\n");
3977 return;
3978 }
3979 }
3980
3981 static void oplock4_got_open(struct tevent_req *req)
3982 {
3983 struct oplock4_state *state = tevent_req_callback_data(
3984 req, struct oplock4_state);
3985 NTSTATUS status;
3986
3987 status = cli_openx_recv(req, state->fnum2);
3988 if (!NT_STATUS_IS_OK(status)) {
3989 printf("cli_openx_recv returned %s\n", nt_errstr(status));
3990 *state->fnum2 = 0xffff;
3991 }
3992 }
3993
3994 /*
3995 Test delete on close semantics.
3996 */
3997 static bool run_deletetest(int dummy)
3998 {
3999 struct cli_state *cli1 = NULL;
4000 struct cli_state *cli2 = NULL;
4001 const char *fname = "\\delete.file";
4002 uint16_t fnum1 = (uint16_t)-1;
4003 uint16_t fnum2 = (uint16_t)-1;
4004 bool correct = false;
4005 NTSTATUS status;
4006
4007 printf("starting delete test\n");
4008
4009 if (!torture_open_connection(&cli1, 0)) {
4010 return False;
4011 }
4012
4013 smbXcli_conn_set_sockopt(cli1->conn, sockops);
4014
4015 /* Test 1 - this should delete the file on close. */
4016
4017 cli_setatr(cli1, fname, 0, 0);
4018 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4019
4020 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
4021 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
4022 FILE_DELETE_ON_CLOSE, 0, &fnum1, NULL);
4023 if (!NT_STATUS_IS_OK(status)) {
4024 printf("[1] open of %s failed (%s)\n", fname, nt_errstr(status));
4025 goto fail;
4026 }
4027
4028 status = cli_close(cli1, fnum1);
4029 if (!NT_STATUS_IS_OK(status)) {
4030 printf("[1] close failed (%s)\n", nt_errstr(status));
4031 goto fail;
4032 }
4033
4034 status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
4035 if (NT_STATUS_IS_OK(status)) {
4036 printf("[1] open of %s succeeded (should fail)\n", fname);
4037 goto fail;
4038 }
4039
4040 printf("first delete on close test succeeded.\n");
4041
4042 /* Test 2 - this should delete the file on close. */
4043
4044 cli_setatr(cli1, fname, 0, 0);
4045 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4046
4047 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
4048 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
4049 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4050 if (!NT_STATUS_IS_OK(status)) {
4051 printf("[2] open of %s failed (%s)\n", fname, nt_errstr(status));
4052 goto fail;
4053 }
4054
4055 status = cli_nt_delete_on_close(cli1, fnum1, true);
4056 if (!NT_STATUS_IS_OK(status)) {
4057 printf("[2] setting delete_on_close failed (%s)\n", nt_errstr(status));
4058 goto fail;
4059 }
4060
4061 status = cli_close(cli1, fnum1);
4062 if (!NT_STATUS_IS_OK(status)) {
4063 printf("[2] close failed (%s)\n", nt_errstr(status));
4064 goto fail;
4065 }
4066
4067 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
4068 if (NT_STATUS_IS_OK(status)) {
4069 printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
4070 status = cli_close(cli1, fnum1);
4071 if (!NT_STATUS_IS_OK(status)) {
4072 printf("[2] close failed (%s)\n", nt_errstr(status));
4073 }
4074 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4075 goto fail;
4076 }
4077
4078 printf("second delete on close test succeeded.\n");
4079
4080 /* Test 3 - ... */
4081 cli_setatr(cli1, fname, 0, 0);
4082 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4083
4084 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
4085 FILE_ATTRIBUTE_NORMAL,
4086 FILE_SHARE_READ|FILE_SHARE_WRITE,
4087 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4088 if (!NT_STATUS_IS_OK(status)) {
4089 printf("[3] open - 1 of %s failed (%s)\n", fname, nt_errstr(status));
4090 goto fail;
4091 }
4092
4093 /* This should fail with a sharing violation - open for delete is only compatible
4094 with SHARE_DELETE. */
4095
4096 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4097 FILE_ATTRIBUTE_NORMAL,
4098 FILE_SHARE_READ|FILE_SHARE_WRITE,
4099 FILE_OPEN, 0, 0, &fnum2, NULL);
4100 if (NT_STATUS_IS_OK(status)) {
4101 printf("[3] open - 2 of %s succeeded - should have failed.\n", fname);
4102 goto fail;
4103 }
4104
4105 /* This should succeed. */
4106 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4107 FILE_ATTRIBUTE_NORMAL,
4108 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4109 FILE_OPEN, 0, 0, &fnum2, NULL);
4110 if (!NT_STATUS_IS_OK(status)) {
4111 printf("[3] open - 3 of %s failed (%s)\n", fname, nt_errstr(status));
4112 goto fail;
4113 }
4114
4115 status = cli_nt_delete_on_close(cli1, fnum1, true);
4116 if (!NT_STATUS_IS_OK(status)) {
4117 printf("[3] setting delete_on_close failed (%s)\n", nt_errstr(status));
4118 goto fail;
4119 }
4120
4121 status = cli_close(cli1, fnum1);
4122 if (!NT_STATUS_IS_OK(status)) {
4123 printf("[3] close 1 failed (%s)\n", nt_errstr(status));
4124 goto fail;
4125 }
4126
4127 status = cli_close(cli1, fnum2);
4128 if (!NT_STATUS_IS_OK(status)) {
4129 printf("[3] close 2 failed (%s)\n", nt_errstr(status));
4130 goto fail;
4131 }
4132
4133 /* This should fail - file should no longer be there. */
4134
4135 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
4136 if (NT_STATUS_IS_OK(status)) {
4137 printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
4138 status = cli_close(cli1, fnum1);
4139 if (!NT_STATUS_IS_OK(status)) {
4140 printf("[3] close failed (%s)\n", nt_errstr(status));
4141 }
4142 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4143 goto fail;
4144 }
4145
4146 printf("third delete on close test succeeded.\n");
4147
4148 /* Test 4 ... */
4149 cli_setatr(cli1, fname, 0, 0);
4150 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4151
4152 status = cli_ntcreate(cli1, fname, 0,
4153 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4154 FILE_ATTRIBUTE_NORMAL,
4155 FILE_SHARE_READ|FILE_SHARE_WRITE,
4156 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4157 if (!NT_STATUS_IS_OK(status)) {
4158 printf("[4] open of %s failed (%s)\n", fname, nt_errstr(status));
4159 goto fail;
4160 }
4161
4162 /* This should succeed. */
4163 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4164 FILE_ATTRIBUTE_NORMAL,
4165 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4166 FILE_OPEN, 0, 0, &fnum2, NULL);
4167 if (!NT_STATUS_IS_OK(status)) {
4168 printf("[4] open - 2 of %s failed (%s)\n", fname, nt_errstr(status));
4169 goto fail;
4170 }
4171
4172 status = cli_close(cli1, fnum2);
4173 if (!NT_STATUS_IS_OK(status)) {
4174 printf("[4] close - 1 failed (%s)\n", nt_errstr(status));
4175 goto fail;
4176 }
4177
4178 status = cli_nt_delete_on_close(cli1, fnum1, true);
4179 if (!NT_STATUS_IS_OK(status)) {
4180 printf("[4] setting delete_on_close failed (%s)\n", nt_errstr(status));
4181 goto fail;
4182 }
4183
4184 /* This should fail - no more opens once delete on close set. */
4185 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4186 FILE_ATTRIBUTE_NORMAL,
4187 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4188 FILE_OPEN, 0, 0, &fnum2, NULL);
4189 if (NT_STATUS_IS_OK(status)) {
4190 printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname );
4191 goto fail;
4192 }
4193
4194 status = cli_close(cli1, fnum1);
4195 if (!NT_STATUS_IS_OK(status)) {
4196 printf("[4] close - 2 failed (%s)\n", nt_errstr(status));
4197 goto fail;
4198 }
4199
4200 printf("fourth delete on close test succeeded.\n");
4201
4202 /* Test 5 ... */
4203 cli_setatr(cli1, fname, 0, 0);
4204 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4205
4206 status = cli_openx(cli1, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum1);
4207 if (!NT_STATUS_IS_OK(status)) {
4208 printf("[5] open of %s failed (%s)\n", fname, nt_errstr(status));
4209 goto fail;
4210 }
4211
4212 /* This should fail - only allowed on NT opens with DELETE access. */
4213
4214 status = cli_nt_delete_on_close(cli1, fnum1, true);
4215 if (NT_STATUS_IS_OK(status)) {
4216 printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
4217 goto fail;
4218 }
4219
4220 status = cli_close(cli1, fnum1);
4221 if (!NT_STATUS_IS_OK(status)) {
4222 printf("[5] close failed (%s)\n", nt_errstr(status));
4223 goto fail;
4224 }
4225
4226 printf("fifth delete on close test succeeded.\n");
4227
4228 /* Test 6 ... */
4229 cli_setatr(cli1, fname, 0, 0);
4230 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4231
4232 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
4233 FILE_ATTRIBUTE_NORMAL,
4234 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4235 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4236 if (!NT_STATUS_IS_OK(status)) {
4237 printf("[6] open of %s failed (%s)\n", fname,
4238 nt_errstr(status));
4239 goto fail;
4240 }
4241
4242 /* This should fail - only allowed on NT opens with DELETE access. */
4243
4244 status = cli_nt_delete_on_close(cli1, fnum1, true);
4245 if (NT_STATUS_IS_OK(status)) {
4246 printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
4247 goto fail;
4248 }
4249
4250 status = cli_close(cli1, fnum1);
4251 if (!NT_STATUS_IS_OK(status)) {
4252 printf("[6] close failed (%s)\n", nt_errstr(status));
4253 goto fail;
4254 }
4255
4256 printf("sixth delete on close test succeeded.\n");
4257
4258 /* Test 7 ... */
4259 cli_setatr(cli1, fname, 0, 0);
4260 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4261
4262 status = cli_ntcreate(cli1, fname, 0,
4263 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4264 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
4265 0, 0, &fnum1, NULL);
4266 if (!NT_STATUS_IS_OK(status)) {
4267 printf("[7] open of %s failed (%s)\n", fname, nt_errstr(status));
4268 goto fail;
4269 }
4270
4271 status = cli_nt_delete_on_close(cli1, fnum1, true);
4272 if (!NT_STATUS_IS_OK(status)) {
4273 printf("[7] setting delete_on_close on file failed !\n");
4274 goto fail;
4275 }
4276
4277 status = cli_nt_delete_on_close(cli1, fnum1, false);
4278 if (!NT_STATUS_IS_OK(status)) {
4279 printf("[7] unsetting delete_on_close on file failed !\n");
4280 goto fail;
4281 }
4282
4283 status = cli_close(cli1, fnum1);
4284 if (!NT_STATUS_IS_OK(status)) {
4285 printf("[7] close - 1 failed (%s)\n", nt_errstr(status));
4286 goto fail;
4287 }
4288
4289 /* This next open should succeed - we reset the flag. */
4290 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
4291 if (!NT_STATUS_IS_OK(status)) {
4292 printf("[7] open of %s failed (%s)\n", fname, nt_errstr(status));
4293 goto fail;
4294 }
4295
4296 status = cli_close(cli1, fnum1);
4297 if (!NT_STATUS_IS_OK(status)) {
4298 printf("[7] close - 2 failed (%s)\n", nt_errstr(status));
4299 goto fail;
4300 }
4301
4302 printf("seventh delete on close test succeeded.\n");
4303
4304 /* Test 8 ... */
4305 cli_setatr(cli1, fname, 0, 0);
4306 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4307
4308 if (!torture_open_connection(&cli2, 1)) {
4309 printf("[8] failed to open second connection.\n");
4310 goto fail;
4311 }
4312
4313 smbXcli_conn_set_sockopt(cli1->conn, sockops);
4314
4315 status = cli_ntcreate(cli1, fname, 0,
4316 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4317 FILE_ATTRIBUTE_NORMAL,
4318 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4319 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4320 if (!NT_STATUS_IS_OK(status)) {
4321 printf("[8] open 1 of %s failed (%s)\n", fname, nt_errstr(status));
4322 goto fail;
4323 }
4324
4325 status = cli_ntcreate(cli2, fname, 0,
4326 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4327 FILE_ATTRIBUTE_NORMAL,
4328 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4329 FILE_OPEN, 0, 0, &fnum2, NULL);
4330 if (!NT_STATUS_IS_OK(status)) {
4331 printf("[8] open 2 of %s failed (%s)\n", fname, nt_errstr(status));
4332 goto fail;
4333 }
4334
4335 status = cli_nt_delete_on_close(cli1, fnum1, true);
4336 if (!NT_STATUS_IS_OK(status)) {
4337 printf("[8] setting delete_on_close on file failed !\n");
4338 goto fail;
4339 }
4340
4341 status = cli_close(cli1, fnum1);
4342 if (!NT_STATUS_IS_OK(status)) {
4343 printf("[8] close - 1 failed (%s)\n", nt_errstr(status));
4344 goto fail;
4345 }
4346
4347 status = cli_close(cli2, fnum2);
4348 if (!NT_STATUS_IS_OK(status)) {
4349 printf("[8] close - 2 failed (%s)\n", nt_errstr(status));
4350 goto fail;
4351 }
4352
4353 /* This should fail.. */
4354 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
4355 if (NT_STATUS_IS_OK(status)) {
4356 printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
4357 goto fail;
4358 }
4359
4360 printf("eighth delete on close test succeeded.\n");
4361
4362 /* Test 9 ... */
4363
4364 /* This should fail - we need to set DELETE_ACCESS. */
4365 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
4366 FILE_ATTRIBUTE_NORMAL,
4367 FILE_SHARE_NONE,
4368 FILE_OVERWRITE_IF,
4369 FILE_DELETE_ON_CLOSE, 0, &fnum1, NULL);
4370 if (NT_STATUS_IS_OK(status)) {
4371 printf("[9] open of %s succeeded should have failed!\n", fname);
4372 goto fail;
4373 }
4374
4375 printf("ninth delete on close test succeeded.\n");
4376
4377 /* Test 10 ... */
4378
4379 status = cli_ntcreate(cli1, fname, 0,
4380 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4381 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
4382 FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE,
4383 0, &fnum1, NULL);
4384 if (!NT_STATUS_IS_OK(status)) {
4385 printf("[10] open of %s failed (%s)\n", fname, nt_errstr(status));
4386 goto fail;
4387 }
4388
4389 /* This should delete the file. */
4390 status = cli_close(cli1, fnum1);
4391 if (!NT_STATUS_IS_OK(status)) {
4392 printf("[10] close failed (%s)\n", nt_errstr(status));
4393 goto fail;
4394 }
4395
4396 /* This should fail.. */
4397 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
4398 if (NT_STATUS_IS_OK(status)) {
4399 printf("[10] open of %s succeeded should have been deleted on close !\n", fname);
4400 goto fail;
4401 }
4402
4403 printf("tenth delete on close test succeeded.\n");
4404
4405 /* Test 11 ... */
4406
4407 cli_setatr(cli1, fname, 0, 0);
4408 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4409
4410 /* Can we open a read-only file with delete access? */
4411
4412 /* Create a readonly file. */
4413 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
4414 FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE,
4415 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4416 if (!NT_STATUS_IS_OK(status)) {
4417 printf("[11] open of %s failed (%s)\n", fname, nt_errstr(status));
4418 goto fail;
4419 }
4420
4421 status = cli_close(cli1, fnum1);
4422 if (!NT_STATUS_IS_OK(status)) {
4423 printf("[11] close failed (%s)\n", nt_errstr(status));
4424 goto fail;
4425 }
4426
4427 /* Now try open for delete access. */
4428 status = cli_ntcreate(cli1, fname, 0,
4429 FILE_READ_ATTRIBUTES|DELETE_ACCESS,
4430 0,
4431 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4432 FILE_OPEN, 0, 0, &fnum1, NULL);
4433 if (!NT_STATUS_IS_OK(status)) {
4434 printf("[11] open of %s failed: %s\n", fname, nt_errstr(status));
4435 goto fail;
4436 }
4437
4438 cli_close(cli1, fnum1);
4439
4440 printf("eleventh delete on close test succeeded.\n");
4441
4442 /*
4443 * Test 12
4444 * like test 4 but with initial delete on close
4445 */
4446
4447 cli_setatr(cli1, fname, 0, 0);
4448 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4449
4450 status = cli_ntcreate(cli1, fname, 0,
4451 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4452 FILE_ATTRIBUTE_NORMAL,
4453 FILE_SHARE_READ|FILE_SHARE_WRITE,
4454 FILE_OVERWRITE_IF,
4455 FILE_DELETE_ON_CLOSE, 0, &fnum1, NULL);
4456 if (!NT_STATUS_IS_OK(status)) {
4457 printf("[12] open 1 of %s failed (%s)\n", fname, nt_errstr(status));
4458 goto fail;
4459 }
4460
4461 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4462 FILE_ATTRIBUTE_NORMAL,
4463 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4464 FILE_OPEN, 0, 0, &fnum2, NULL);
4465 if (!NT_STATUS_IS_OK(status)) {
4466 printf("[12] open 2 of %s failed(%s).\n", fname, nt_errstr(status));
4467 goto fail;
4468 }
4469
4470 status = cli_close(cli1, fnum2);
4471 if (!NT_STATUS_IS_OK(status)) {
4472 printf("[12] close 1 failed (%s)\n", nt_errstr(status));
4473 goto fail;
4474 }
4475
4476 status = cli_nt_delete_on_close(cli1, fnum1, true);
4477 if (!NT_STATUS_IS_OK(status)) {
4478 printf("[12] setting delete_on_close failed (%s)\n", nt_errstr(status));
4479 goto fail;
4480 }
4481
4482 /* This should fail - no more opens once delete on close set. */
4483 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4484 FILE_ATTRIBUTE_NORMAL,
4485 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4486 FILE_OPEN, 0, 0, &fnum2, NULL);
4487 if (NT_STATUS_IS_OK(status)) {
4488 printf("[12] open 3 of %s succeeded - should fail).\n", fname);
4489 goto fail;
4490 }
4491
4492 status = cli_nt_delete_on_close(cli1, fnum1, false);
4493 if (!NT_STATUS_IS_OK(status)) {
4494 printf("[12] unsetting delete_on_close failed (%s)\n", nt_errstr(status));
4495 goto fail;
4496 }
4497
4498 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4499 FILE_ATTRIBUTE_NORMAL,
4500 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4501 FILE_OPEN, 0, 0, &fnum2, NULL);
4502 if (!NT_STATUS_IS_OK(status)) {
4503 printf("[12] open 4 of %s failed (%s)\n", fname, nt_errstr(status));
4504 goto fail;
4505 }
4506
4507 status = cli_close(cli1, fnum2);
4508 if (!NT_STATUS_IS_OK(status)) {
4509 printf("[12] close 2 failed (%s)\n", nt_errstr(status));
4510 goto fail;
4511 }
4512
4513 status = cli_close(cli1, fnum1);
4514 if (!NT_STATUS_IS_OK(status)) {
4515 printf("[12] close 3 failed (%s)\n", nt_errstr(status));
4516 goto fail;
4517 }
4518
4519 /*
4520 * setting delete on close on the handle does
4521 * not unset the initial delete on close...
4522 */
4523 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4524 FILE_ATTRIBUTE_NORMAL,
4525 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4526 FILE_OPEN, 0, 0, &fnum2, NULL);
4527 if (NT_STATUS_IS_OK(status)) {
4528 printf("[12] open 5 of %s succeeded - should fail).\n", fname);
4529 goto fail;
4530 } else if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
4531 printf("ntcreate returned %s, expected "
4532 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
4533 nt_errstr(status));
4534 goto fail;
4535 }
4536
4537 printf("twelfth delete on close test succeeded.\n");
4538
4539
4540 printf("finished delete test\n");
4541
4542 correct = true;
4543
4544 fail:
4545 /* FIXME: This will crash if we aborted before cli2 got
4546 * intialized, because these functions don't handle
4547 * uninitialized connections. */
4548
4549 if (fnum1 != (uint16_t)-1) cli_close(cli1, fnum1);
4550 if (fnum2 != (uint16_t)-1) cli_close(cli1, fnum2);
4551 cli_setatr(cli1, fname, 0, 0);
4552 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4553
4554 if (cli1 && !torture_close_connection(cli1)) {
4555 correct = False;
4556 }
4557 if (cli2 && !torture_close_connection(cli2)) {
4558 correct = False;
4559 }
4560 return correct;
4561 }
4562
4563
4564 /*
4565 Test wildcard delete.
4566 */
4567 static bool run_wild_deletetest(int dummy)
4568 {
4569 struct cli_state *cli = NULL;
4570 const char *dname = "\\WTEST";
4571 const char *fname = "\\WTEST\\A";
4572 const char *wunlink_name = "\\WTEST\\*";
4573 uint16_t fnum1 = (uint16_t)-1;
4574 bool correct = false;
4575 NTSTATUS status;
4576
4577 printf("starting wildcard delete test\n");
4578
4579 if (!torture_open_connection(&cli, 0)) {
4580 return false;
4581 }
4582
4583 smbXcli_conn_set_sockopt(cli->conn, sockops);
4584
4585 cli_unlink(cli, fname, 0);
4586 cli_rmdir(cli, dname);
4587 status = cli_mkdir(cli, dname);
4588 if (!NT_STATUS_IS_OK(status)) {
4589 printf("mkdir of %s failed %s!\n", dname, nt_errstr(status));
4590 goto fail;
4591 }
4592 status = cli_openx(cli, fname, O_CREAT|O_RDONLY, DENY_NONE, &fnum1);
4593 if (!NT_STATUS_IS_OK(status)) {
4594 printf("open of %s failed %s!\n", fname, nt_errstr(status));
4595 goto fail;
4596 }
4597 status = cli_close(cli, fnum1);
4598 fnum1 = -1;
4599
4600 /*
4601 * Note the unlink attribute-type of zero. This should
4602 * map into FILE_ATTRIBUTE_NORMAL at the server even
4603 * on a wildcard delete.
4604 */
4605
4606 status = cli_unlink(cli, wunlink_name, 0);
4607 if (!NT_STATUS_IS_OK(status)) {
4608 printf("unlink of %s failed %s!\n",
4609 wunlink_name, nt_errstr(status));
4610 goto fail;
4611 }
4612
4613 printf("finished wildcard delete test\n");
4614
4615 correct = true;
4616
4617 fail:
4618
4619 if (fnum1 != (uint16_t)-1) cli_close(cli, fnum1);
4620 cli_unlink(cli, fname, 0);
4621 cli_rmdir(cli, dname);
4622
4623 if (cli && !torture_close_connection(cli)) {
4624 correct = false;
4625 }
4626 return correct;
4627 }
4628
4629 static bool run_deletetest_ln(int dummy)
4630 {
4631 struct cli_state *cli;
4632 const char *fname = "\\delete1";
4633 const char *fname_ln = "\\delete1_ln";
4634 uint16_t fnum;
4635 uint16_t fnum1;
4636 NTSTATUS status;
4637 bool correct = true;
4638 time_t t;
4639
4640 printf("starting deletetest-ln\n");
4641
4642 if (!torture_open_connection(&cli, 0)) {
4643 return false;
4644 }
4645
4646 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4647 cli_unlink(cli, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4648
4649 smbXcli_conn_set_sockopt(cli->conn, sockops);
4650
4651 /* Create the file. */
4652 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
4653 if (!NT_STATUS_IS_OK(status)) {
4654 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4655 return false;
4656 }
4657
4658 status = cli_close(cli, fnum);
4659 if (!NT_STATUS_IS_OK(status)) {
4660 printf("close1 failed (%s)\n", nt_errstr(status));
4661 return false;
4662 }
4663
4664 /* Now create a hardlink. */
4665 status = cli_nt_hardlink(cli, fname, fname_ln);
4666 if (!NT_STATUS_IS_OK(status)) {
4667 printf("nt hardlink failed (%s)\n", nt_errstr(status));
4668 return false;
4669 }
4670
4671 /* Open the original file. */
4672 status = cli_ntcreate(cli, fname, 0, FILE_READ_DATA,
4673 FILE_ATTRIBUTE_NORMAL,
4674 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4675 FILE_OPEN_IF, 0, 0, &fnum, NULL);
4676 if (!NT_STATUS_IS_OK(status)) {
4677 printf("ntcreate of %s failed (%s)\n", fname, nt_errstr(status));
4678 return false;
4679 }
4680
4681 /* Unlink the hard link path. */
4682 status = cli_ntcreate(cli, fname_ln, 0, DELETE_ACCESS,
4683 FILE_ATTRIBUTE_NORMAL,
4684 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4685 FILE_OPEN_IF, 0, 0, &fnum1, NULL);
4686 if (!NT_STATUS_IS_OK(status)) {
4687 printf("ntcreate of %s failed (%s)\n", fname_ln, nt_errstr(status));
4688 return false;
4689 }
4690 status = cli_nt_delete_on_close(cli, fnum1, true);
4691 if (!NT_STATUS_IS_OK(status)) {
4692 d_printf("(%s) failed to set delete_on_close %s: %s\n",
4693 __location__, fname_ln, nt_errstr(status));
4694 return false;
4695 }
4696
4697 status = cli_close(cli, fnum1);
4698 if (!NT_STATUS_IS_OK(status)) {
4699 printf("close %s failed (%s)\n",
4700 fname_ln, nt_errstr(status));
4701 return false;
4702 }
4703
4704 status = cli_close(cli, fnum);
4705 if (!NT_STATUS_IS_OK(status)) {
4706 printf("close %s failed (%s)\n",
4707 fname, nt_errstr(status));
4708 return false;
4709 }
4710
4711 /* Ensure the original file is still there. */
4712 status = cli_getatr(cli, fname, NULL, NULL, &t);
4713 if (!NT_STATUS_IS_OK(status)) {
4714 printf("%s getatr on file %s failed (%s)\n",
4715 __location__,
4716 fname,
4717 nt_errstr(status));
4718 correct = False;
4719 }
4720
4721 /* Ensure the link path is gone. */
4722 status = cli_getatr(cli, fname_ln, NULL, NULL, &t);
4723 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
4724 printf("%s, getatr for file %s returned wrong error code %s "
4725 "- should have been deleted\n",
4726 __location__,
4727 fname_ln, nt_errstr(status));
4728 correct = False;
4729 }
4730
4731 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4732 cli_unlink(cli, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4733
4734 if (!torture_close_connection(cli)) {
4735 correct = false;
4736 }
4737
4738 printf("finished deletetest-ln\n");
4739
4740 return correct;
4741 }
4742
4743 /*
4744 print out server properties
4745 */
4746 static bool run_properties(int dummy)
4747 {
4748 struct cli_state *cli;
4749 bool correct = True;
4750
4751 printf("starting properties test\n");
4752
4753 ZERO_STRUCT(cli);
4754
4755 if (!torture_open_connection(&cli, 0)) {
4756 return False;
4757 }
4758
4759 smbXcli_conn_set_sockopt(cli->conn, sockops);
4760
4761 d_printf("Capabilities 0x%08x\n", smb1cli_conn_capabilities(cli->conn));
4762
4763 if (!torture_close_connection(cli)) {
4764 correct = False;
4765 }
4766
4767 return correct;
4768 }
4769
4770
4771
4772 /* FIRST_DESIRED_ACCESS 0xf019f */
4773 #define FIRST_DESIRED_ACCESS FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\
4774 FILE_READ_EA| /* 0xf */ \
4775 FILE_WRITE_EA|FILE_READ_ATTRIBUTES| /* 0x90 */ \
4776 FILE_WRITE_ATTRIBUTES| /* 0x100 */ \
4777 DELETE_ACCESS|READ_CONTROL_ACCESS|\
4778 WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS /* 0xf0000 */
4779 /* SECOND_DESIRED_ACCESS 0xe0080 */
4780 #define SECOND_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
4781 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
4782 WRITE_OWNER_ACCESS /* 0xe0000 */
4783
4784 #if 0
4785 #define THIRD_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
4786 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
4787 FILE_READ_DATA|\
4788 WRITE_OWNER_ACCESS /* */
4789 #endif
4790
4791 /*
4792 Test ntcreate calls made by xcopy
4793 */
4794 static bool run_xcopy(int dummy)
4795 {
4796 static struct cli_state *cli1;
4797 const char *fname = "\\test.txt";
4798 bool correct = True;
4799 uint16_t fnum1, fnum2;
4800 NTSTATUS status;
4801
4802 printf("starting xcopy test\n");
4803
4804 if (!torture_open_connection(&cli1, 0)) {
4805 return False;
4806 }
4807
4808 status = cli_ntcreate(cli1, fname, 0, FIRST_DESIRED_ACCESS,
4809 FILE_ATTRIBUTE_ARCHIVE, FILE_SHARE_NONE,
4810 FILE_OVERWRITE_IF, 0x4044, 0, &fnum1, NULL);
4811 if (!NT_STATUS_IS_OK(status)) {
4812 printf("First open failed - %s\n", nt_errstr(status));
4813 return False;
4814 }
4815
4816 status = cli_ntcreate(cli1, fname, 0, SECOND_DESIRED_ACCESS, 0,
4817 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4818 FILE_OPEN, 0x200000, 0, &fnum2, NULL);
4819 if (!NT_STATUS_IS_OK(status)) {
4820 printf("second open failed - %s\n", nt_errstr(status));
4821 return False;
4822 }
4823
4824 if (!torture_close_connection(cli1)) {
4825 correct = False;
4826 }
4827
4828 return correct;
4829 }
4830
4831 /*
4832 Test rename on files open with share delete and no share delete.
4833 */
4834 static bool run_rename(int dummy)
4835 {
4836 static struct cli_state *cli1;
4837 const char *fname = "\\test.txt";
4838 const char *fname1 = "\\test1.txt";
4839 bool correct = True;
4840 uint16_t fnum1;
4841 uint16_t attr;
4842 NTSTATUS status;
4843
4844 printf("starting rename test\n");
4845
4846 if (!torture_open_connection(&cli1, 0)) {
4847 return False;
4848 }
4849
4850 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4851 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4852
4853 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4854 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
4855 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4856 if (!NT_STATUS_IS_OK(status)) {
4857 printf("First open failed - %s\n", nt_errstr(status));
4858 return False;
4859 }
4860
4861 status = cli_rename(cli1, fname, fname1, false);
4862 if (!NT_STATUS_IS_OK(status)) {
4863 printf("First rename failed (SHARE_READ) (this is correct) - %s\n", nt_errstr(status));
4864 } else {
4865 printf("First rename succeeded (SHARE_READ) - this should have failed !\n");
4866 correct = False;
4867 }
4868
4869 status = cli_close(cli1, fnum1);
4870 if (!NT_STATUS_IS_OK(status)) {
4871 printf("close - 1 failed (%s)\n", nt_errstr(status));
4872 return False;
4873 }
4874
4875 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4876 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4877 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4878 #if 0
4879 FILE_SHARE_DELETE|FILE_SHARE_NONE,
4880 #else
4881 FILE_SHARE_DELETE|FILE_SHARE_READ,
4882 #endif
4883 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4884 if (!NT_STATUS_IS_OK(status)) {
4885 printf("Second open failed - %s\n", nt_errstr(status));
4886 return False;
4887 }
4888
4889 status = cli_rename(cli1, fname, fname1, false);
4890 if (!NT_STATUS_IS_OK(status)) {
4891 printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", nt_errstr(status));
4892 correct = False;
4893 } else {
4894 printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n");
4895 }
4896
4897 status = cli_close(cli1, fnum1);
4898 if (!NT_STATUS_IS_OK(status)) {
4899 printf("close - 2 failed (%s)\n", nt_errstr(status));
4900 return False;
4901 }
4902
4903 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4904 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4905
4906 status = cli_ntcreate(cli1, fname, 0, READ_CONTROL_ACCESS,
4907 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
4908 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4909 if (!NT_STATUS_IS_OK(status)) {
4910 printf("Third open failed - %s\n", nt_errstr(status));
4911 return False;
4912 }
4913
4914
4915 #if 0
4916 {
4917 uint16_t fnum2;
4918
4919 if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
4920 FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum2, NULL))) {
4921 printf("Fourth open failed - %s\n", cli_errstr(cli1));
4922 return False;
4923 }
4924 if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum2, true))) {
4925 printf("[8] setting delete_on_close on file failed !\n");
4926 return False;
4927 }
4928
4929 if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
4930 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
4931 return False;
4932 }
4933 }
4934 #endif
4935
4936 status = cli_rename(cli1, fname, fname1, false);
4937 if (!NT_STATUS_IS_OK(status)) {
4938 printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", nt_errstr(status));
4939 correct = False;
4940 } else {
4941 printf("Third rename succeeded (SHARE_NONE)\n");
4942 }
4943
4944 status = cli_close(cli1, fnum1);
4945 if (!NT_STATUS_IS_OK(status)) {
4946 printf("close - 3 failed (%s)\n", nt_errstr(status));
4947 return False;
4948 }
4949
4950 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4951 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4952
4953 /*----*/
4954
4955 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4956 FILE_ATTRIBUTE_NORMAL,
4957 FILE_SHARE_READ | FILE_SHARE_WRITE,
4958 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4959 if (!NT_STATUS_IS_OK(status)) {
4960 printf("Fourth open failed - %s\n", nt_errstr(status));
4961 return False;
4962 }
4963
4964 status = cli_rename(cli1, fname, fname1, false);
4965 if (!NT_STATUS_IS_OK(status)) {
4966 printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", nt_errstr(status));
4967 } else {
4968 printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n");
4969 correct = False;
4970 }
4971
4972 status = cli_close(cli1, fnum1);
4973 if (!NT_STATUS_IS_OK(status)) {
4974 printf("close - 4 failed (%s)\n", nt_errstr(status));
4975 return False;
4976 }
4977
4978 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4979 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4980
4981 /*--*/
4982
4983 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4984 FILE_ATTRIBUTE_NORMAL,
4985 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
4986 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
4987 if (!NT_STATUS_IS_OK(status)) {
4988 printf("Fifth open failed - %s\n", nt_errstr(status));
4989 return False;
4990 }
4991
4992 status = cli_rename(cli1, fname, fname1, false);
4993 if (!NT_STATUS_IS_OK(status)) {
4994 printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n", nt_errstr(status));
4995 correct = False;
4996 } else {
4997 printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", nt_errstr(status));
4998 }
4999
5000 /*
5001 * Now check if the first name still exists ...
5002 */
5003
5004 /* if (!NT_STATUS_OP(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
5005 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
5006 FILE_OVERWRITE_IF, 0, 0, &fnum2, NULL))) {
5007 printf("Opening original file after rename of open file fails: %s\n",
5008 cli_errstr(cli1));
5009 }
5010 else {
5011 printf("Opening original file after rename of open file works ...\n");
5012 (void)cli_close(cli1, fnum2);
5013 } */
5014
5015 /*--*/
5016 status = cli_close(cli1, fnum1);
5017 if (!NT_STATUS_IS_OK(status)) {
5018 printf("close - 5 failed (%s)\n", nt_errstr(status));
5019 return False;
5020 }
5021
5022 /* Check that the renamed file has FILE_ATTRIBUTE_ARCHIVE. */
5023 status = cli_getatr(cli1, fname1, &attr, NULL, NULL);
5024 if (!NT_STATUS_IS_OK(status)) {
5025 printf("getatr on file %s failed - %s ! \n",
5026 fname1, nt_errstr(status));
5027 correct = False;
5028 } else {
5029 if (attr != FILE_ATTRIBUTE_ARCHIVE) {
5030 printf("Renamed file %s has wrong attr 0x%x "
5031 "(should be 0x%x)\n",
5032 fname1,
5033 attr,
5034 (unsigned int)FILE_ATTRIBUTE_ARCHIVE);
5035 correct = False;
5036 } else {
5037 printf("Renamed file %s has archive bit set\n", fname1);
5038 }
5039 }
5040
5041 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5042 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5043
5044 if (!torture_close_connection(cli1)) {
5045 correct = False;
5046 }
5047
5048 return correct;
5049 }
5050
5051 /*
5052 Test rename into a directory with an ACL denying it.
5053 */
5054 static bool run_rename_access(int dummy)
5055 {
5056 static struct cli_state *cli = NULL;
5057 static struct cli_state *posix_cli = NULL;
5058 const char *src = "test.txt";
5059 const char *dname = "dir";
5060 const char *dst = "dir\\test.txt";
5061 const char *dsrc = "test.dir";
5062 const char *ddst = "dir\\test.dir";
5063 uint16_t fnum = (uint16_t)-1;
5064 struct security_descriptor *sd = NULL;
5065 struct security_descriptor *newsd = NULL;
5066 NTSTATUS status;
5067 TALLOC_CTX *frame = NULL;
5068
5069 frame = talloc_stackframe();
5070 printf("starting rename access test\n");
5071
5072 /* Windows connection. */
5073 if (!torture_open_connection(&cli, 0)) {
5074 goto fail;
5075 }
5076
5077 smbXcli_conn_set_sockopt(cli->conn, sockops);
5078
5079 /* Posix connection. */
5080 if (!torture_open_connection(&posix_cli, 0)) {
5081 goto fail;
5082 }
5083
5084 smbXcli_conn_set_sockopt(posix_cli->conn, sockops);
5085
5086 status = torture_setup_unix_extensions(posix_cli);
5087 if (!NT_STATUS_IS_OK(status)) {
5088 goto fail;
5089 }
5090
5091 /* Start with a clean slate. */
5092 cli_unlink(cli, src, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5093 cli_unlink(cli, dst, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5094 cli_rmdir(cli, dsrc);
5095 cli_rmdir(cli, ddst);
5096 cli_rmdir(cli, dname);
5097
5098 /*
5099 * Setup the destination directory with a DENY ACE to
5100 * prevent new files within it.
5101 */
5102 status = cli_ntcreate(cli,
5103 dname,
5104 0,
5105 FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS|
5106 WRITE_DAC_ACCESS|FILE_READ_DATA|
5107 WRITE_OWNER_ACCESS,
5108 FILE_ATTRIBUTE_DIRECTORY,
5109 FILE_SHARE_READ|FILE_SHARE_WRITE,
5110 FILE_CREATE,
5111 FILE_DIRECTORY_FILE,
5112 0,
5113 &fnum,
5114 NULL);
5115 if (!NT_STATUS_IS_OK(status)) {
5116 printf("Create of %s - %s\n", dname, nt_errstr(status));
5117 goto fail;
5118 }
5119
5120 status = cli_query_secdesc(cli,
5121 fnum,
5122 frame,
5123 &sd);
5124 if (!NT_STATUS_IS_OK(status)) {
5125 printf("cli_query_secdesc failed for %s (%s)\n",
5126 dname, nt_errstr(status));
5127 goto fail;
5128 }
5129
5130 newsd = security_descriptor_dacl_create(frame,
5131 0,
5132 NULL,
5133 NULL,
5134 SID_WORLD,
5135 SEC_ACE_TYPE_ACCESS_DENIED,
5136 SEC_DIR_ADD_FILE|SEC_DIR_ADD_SUBDIR,
5137 0,
5138 NULL);
5139 if (newsd == NULL) {
5140 goto fail;
5141 }
5142 sd->dacl = security_acl_concatenate(frame,
5143 newsd->dacl,
5144 sd->dacl);
5145 if (sd->dacl == NULL) {
5146 goto fail;
5147 }
5148 status = cli_set_secdesc(cli, fnum, sd);
5149 if (!NT_STATUS_IS_OK(status)) {
5150 printf("cli_set_secdesc failed for %s (%s)\n",
5151 dname, nt_errstr(status));
5152 goto fail;
5153 }
5154 status = cli_close(cli, fnum);
5155 if (!NT_STATUS_IS_OK(status)) {
5156 printf("close failed for %s (%s)\n",
5157 dname, nt_errstr(status));
5158 goto fail;
5159 }
5160 /* Now go around the back and chmod to 777 via POSIX. */
5161 status = cli_posix_chmod(posix_cli, dname, 0777);
5162 if (!NT_STATUS_IS_OK(status)) {
5163 printf("cli_posix_chmod failed for %s (%s)\n",
5164 dname, nt_errstr(status));
5165 goto fail;
5166 }
5167
5168 /* Check we can't create a file within dname via Windows. */
5169 status = cli_openx(cli, dst, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
5170 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
5171 cli_close(posix_cli, fnum);
5172 printf("Create of %s should be ACCESS denied, was %s\n",
5173 dst, nt_errstr(status));
5174 goto fail;
5175 }
5176
5177 /* Make the sample file/directory. */
5178 status = cli_openx(cli, src, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
5179 if (!NT_STATUS_IS_OK(status)) {
5180 printf("open of %s failed (%s)\n", src, nt_errstr(status));
5181 goto fail;
5182 }
5183 status = cli_close(cli, fnum);
5184 if (!NT_STATUS_IS_OK(status)) {
5185 printf("cli_close failed (%s)\n", nt_errstr(status));
5186 goto fail;
5187 }
5188
5189 status = cli_mkdir(cli, dsrc);
5190 if (!NT_STATUS_IS_OK(status)) {
5191 printf("cli_mkdir of %s failed (%s)\n",
5192 dsrc, nt_errstr(status));
5193 goto fail;
5194 }
5195
5196 /*
5197 * OK - renames of the new file and directory into the
5198 * dst directory should fail.
5199 */
5200
5201 status = cli_rename(cli, src, dst, false);
5202 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
5203 printf("rename of %s -> %s should be ACCESS denied, was %s\n",
5204 src, dst, nt_errstr(status));
5205 goto fail;
5206 }
5207 status = cli_rename(cli, dsrc, ddst, false);
5208 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
5209 printf("rename of %s -> %s should be ACCESS denied, was %s\n",
5210 src, dst, nt_errstr(status));
5211 goto fail;
5212 }
5213
5214 TALLOC_FREE(frame);
5215 return true;
5216
5217 fail:
5218
5219 if (posix_cli) {
5220 torture_close_connection(posix_cli);
5221 }
5222
5223 if (cli) {
5224 if (fnum != (uint16_t)-1) {
5225 cli_close(cli, fnum);
5226 }
5227 cli_unlink(cli, src,
5228 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5229 cli_unlink(cli, dst,
5230 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5231 cli_rmdir(cli, dsrc);
5232 cli_rmdir(cli, ddst);
5233 cli_rmdir(cli, dname);
5234
5235 torture_close_connection(cli);
5236 }
5237
5238 TALLOC_FREE(frame);
5239 return false;
5240 }
5241
5242 /*
5243 Test owner rights ACE.
5244 */
5245 static bool run_owner_rights(int dummy)
5246 {
5247 static struct cli_state *cli = NULL;
5248 const char *fname = "owner_rights.txt";
5249 uint16_t fnum = (uint16_t)-1;
5250 struct security_descriptor *sd = NULL;
5251 struct security_descriptor *newsd = NULL;
5252 NTSTATUS status;
5253 TALLOC_CTX *frame = NULL;
5254
5255 frame = talloc_stackframe();
5256 printf("starting owner rights test\n");
5257
5258 /* Windows connection. */
5259 if (!torture_open_connection(&cli, 0)) {
5260 goto fail;
5261 }
5262
5263 smbXcli_conn_set_sockopt(cli->conn, sockops);
5264
5265 /* Start with a clean slate. */
5266 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5267
5268 /* Create the test file. */
5269 /* Now try and open for read and write-dac. */
5270 status = cli_ntcreate(cli,
5271 fname,
5272 0,
5273 GENERIC_ALL_ACCESS,
5274 FILE_ATTRIBUTE_NORMAL,
5275 FILE_SHARE_READ|FILE_SHARE_WRITE|
5276 FILE_SHARE_DELETE,
5277 FILE_CREATE,
5278 0,
5279 0,
5280 &fnum,
5281 NULL);
5282 if (!NT_STATUS_IS_OK(status)) {
5283 printf("Create of %s - %s\n", fname, nt_errstr(status));
5284 goto fail;
5285 }
5286
5287 /* Get the original SD. */
5288 status = cli_query_secdesc(cli,
5289 fnum,
5290 frame,
5291 &sd);
5292 if (!NT_STATUS_IS_OK(status)) {
5293 printf("cli_query_secdesc failed for %s (%s)\n",
5294 fname, nt_errstr(status));
5295 goto fail;
5296 }
5297
5298 /*
5299 * Add an "owner-rights" ACE denying WRITE_DATA,
5300 * and an "owner-rights" ACE allowing READ_DATA.
5301 */
5302
5303 newsd = security_descriptor_dacl_create(frame,
5304 0,
5305 NULL,
5306 NULL,
5307 SID_OWNER_RIGHTS,
5308 SEC_ACE_TYPE_ACCESS_DENIED,
5309 FILE_WRITE_DATA,
5310 0,
5311 SID_OWNER_RIGHTS,
5312 SEC_ACE_TYPE_ACCESS_ALLOWED,
5313 FILE_READ_DATA,
5314 0,
5315 NULL);
5316 if (newsd == NULL) {
5317 goto fail;
5318 }
5319 sd->dacl = security_acl_concatenate(frame,
5320 newsd->dacl,
5321 sd->dacl);
5322 if (sd->dacl == NULL) {
5323 goto fail;
5324 }
5325 status = cli_set_secdesc(cli, fnum, sd);
5326 if (!NT_STATUS_IS_OK(status)) {
5327 printf("cli_set_secdesc failed for %s (%s)\n",
5328 fname, nt_errstr(status));
5329 goto fail;
5330 }
5331 status = cli_close(cli, fnum);
5332 if (!NT_STATUS_IS_OK(status)) {
5333 printf("close failed for %s (%s)\n",
5334 fname, nt_errstr(status));
5335 goto fail;
5336 }
5337 fnum = (uint16_t)-1;
5338
5339 /* Try and open for FILE_WRITE_DATA */
5340 status = cli_ntcreate(cli,
5341 fname,
5342 0,
5343 FILE_WRITE_DATA,
5344 FILE_ATTRIBUTE_NORMAL,
5345 FILE_SHARE_READ|FILE_SHARE_WRITE|
5346 FILE_SHARE_DELETE,
5347 FILE_OPEN,
5348 0,
5349 0,
5350 &fnum,
5351 NULL);
5352 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
5353 printf("Open of %s - %s\n", fname, nt_errstr(status));
5354 goto fail;
5355 }
5356
5357 /* Now try and open for FILE_READ_DATA */
5358 status = cli_ntcreate(cli,
5359 fname,
5360 0,
5361 FILE_READ_DATA,
5362 FILE_ATTRIBUTE_NORMAL,
5363 FILE_SHARE_READ|FILE_SHARE_WRITE|
5364 FILE_SHARE_DELETE,
5365 FILE_OPEN,
5366 0,
5367 0,
5368 &fnum,
5369 NULL);
5370 if (!NT_STATUS_IS_OK(status)) {
5371 printf("Open of %s - %s\n", fname, nt_errstr(status));
5372 goto fail;
5373 }
5374
5375 status = cli_close(cli, fnum);
5376 if (!NT_STATUS_IS_OK(status)) {
5377 printf("close failed for %s (%s)\n",
5378 fname, nt_errstr(status));
5379 goto fail;
5380 }
5381
5382 /* Restore clean slate. */
5383 TALLOC_FREE(sd);
5384 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5385
5386 /* Create the test file. */
5387 status = cli_ntcreate(cli,
5388 fname,
5389 0,
5390 GENERIC_ALL_ACCESS,
5391 FILE_ATTRIBUTE_NORMAL,
5392 FILE_SHARE_READ|FILE_SHARE_WRITE|
5393 FILE_SHARE_DELETE,
5394 FILE_CREATE,
5395 0,
5396 0,
5397 &fnum,
5398 NULL);
5399 if (!NT_STATUS_IS_OK(status)) {
5400 printf("Create of %s - %s\n", fname, nt_errstr(status));
5401 goto fail;
5402 }
5403
5404 /* Get the original SD. */
5405 status = cli_query_secdesc(cli,
5406 fnum,
5407 frame,
5408 &sd);
5409 if (!NT_STATUS_IS_OK(status)) {
5410 printf("cli_query_secdesc failed for %s (%s)\n",
5411 fname, nt_errstr(status));
5412 goto fail;
5413 }
5414
5415 /*
5416 * Add an "owner-rights ACE denying WRITE_DATA,
5417 * and an "owner-rights ACE allowing READ_DATA|WRITE_DATA.
5418 */
5419
5420 newsd = security_descriptor_dacl_create(frame,
5421 0,
5422 NULL,
5423 NULL,
5424 SID_OWNER_RIGHTS,
5425 SEC_ACE_TYPE_ACCESS_DENIED,
5426 FILE_WRITE_DATA,
5427 0,
5428 SID_OWNER_RIGHTS,
5429 SEC_ACE_TYPE_ACCESS_ALLOWED,
5430 FILE_READ_DATA|FILE_WRITE_DATA,
5431 0,
5432 NULL);
5433 if (newsd == NULL) {
5434 goto fail;
5435 }
5436 sd->dacl = security_acl_concatenate(frame,
5437 newsd->dacl,
5438 sd->dacl);
5439 if (sd->dacl == NULL) {
5440 goto fail;
5441 }
5442 status = cli_set_secdesc(cli, fnum, sd);
5443 if (!NT_STATUS_IS_OK(status)) {
5444 printf("cli_set_secdesc failed for %s (%s)\n",
5445 fname, nt_errstr(status));
5446 goto fail;
5447 }
5448 status = cli_close(cli, fnum);
5449 if (!NT_STATUS_IS_OK(status)) {
5450 printf("close failed for %s (%s)\n",
5451 fname, nt_errstr(status));
5452 goto fail;
5453 }
5454 fnum = (uint16_t)-1;
5455
5456 /* Try and open for FILE_WRITE_DATA */
5457 status = cli_ntcreate(cli,
5458 fname,
5459 0,
5460 FILE_WRITE_DATA,
5461 FILE_ATTRIBUTE_NORMAL,
5462 FILE_SHARE_READ|FILE_SHARE_WRITE|
5463 FILE_SHARE_DELETE,
5464 FILE_OPEN,
5465 0,
5466 0,
5467 &fnum,
5468 NULL);
5469 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
5470 printf("Open of %s - %s\n", fname, nt_errstr(status));
5471 goto fail;
5472 }
5473
5474 /* Now try and open for FILE_READ_DATA */
5475 status = cli_ntcreate(cli,
5476 fname,
5477 0,
5478 FILE_READ_DATA,
5479 FILE_ATTRIBUTE_NORMAL,
5480 FILE_SHARE_READ|FILE_SHARE_WRITE|
5481 FILE_SHARE_DELETE,
5482 FILE_OPEN,
5483 0,
5484 0,
5485 &fnum,
5486 NULL);
5487 if (!NT_STATUS_IS_OK(status)) {
5488 printf("Open of %s - %s\n", fname, nt_errstr(status));
5489 goto fail;
5490 }
5491
5492 status = cli_close(cli, fnum);
5493 if (!NT_STATUS_IS_OK(status)) {
5494 printf("close failed for %s (%s)\n",
5495 fname, nt_errstr(status));
5496 goto fail;
5497 }
5498
5499 /* Restore clean slate. */
5500 TALLOC_FREE(sd);
5501 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5502
5503
5504 /* Create the test file. */
5505 status = cli_ntcreate(cli,
5506 fname,
5507 0,
5508 GENERIC_ALL_ACCESS,
5509 FILE_ATTRIBUTE_NORMAL,
5510 FILE_SHARE_READ|FILE_SHARE_WRITE|
5511 FILE_SHARE_DELETE,
5512 FILE_CREATE,
5513 0,
5514 0,
5515 &fnum,
5516 NULL);
5517 if (!NT_STATUS_IS_OK(status)) {
5518 printf("Create of %s - %s\n", fname, nt_errstr(status));
5519 goto fail;
5520 }
5521
5522 /* Get the original SD. */
5523 status = cli_query_secdesc(cli,
5524 fnum,
5525 frame,
5526 &sd);
5527 if (!NT_STATUS_IS_OK(status)) {
5528 printf("cli_query_secdesc failed for %s (%s)\n",
5529 fname, nt_errstr(status));
5530 goto fail;
5531 }
5532
5533 /*
5534 * Add an "authenticated users" ACE allowing READ_DATA,
5535 * add an "owner-rights" denying READ_DATA,
5536 * and an "authenticated users" ACE allowing WRITE_DATA.
5537 */
5538
5539 newsd = security_descriptor_dacl_create(frame,
5540 0,
5541 NULL,
5542 NULL,
5543 SID_NT_AUTHENTICATED_USERS,
5544 SEC_ACE_TYPE_ACCESS_ALLOWED,
5545 FILE_READ_DATA,
5546 0,
5547 SID_OWNER_RIGHTS,
5548 SEC_ACE_TYPE_ACCESS_DENIED,
5549 FILE_READ_DATA,
5550 0,
5551 SID_NT_AUTHENTICATED_USERS,
5552 SEC_ACE_TYPE_ACCESS_ALLOWED,
5553 FILE_WRITE_DATA,
5554 0,
5555 NULL);
5556 if (newsd == NULL) {
5557 printf("newsd == NULL\n");
5558 goto fail;
5559 }
5560 sd->dacl = security_acl_concatenate(frame,
5561 newsd->dacl,
5562 sd->dacl);
5563 if (sd->dacl == NULL) {
5564 printf("sd->dacl == NULL\n");
5565 goto fail;
5566 }
5567 status = cli_set_secdesc(cli, fnum, sd);
5568 if (!NT_STATUS_IS_OK(status)) {
5569 printf("cli_set_secdesc failed for %s (%s)\n",
5570 fname, nt_errstr(status));
5571 goto fail;
5572 }
5573 status = cli_close(cli, fnum);
5574 if (!NT_STATUS_IS_OK(status)) {
5575 printf("close failed for %s (%s)\n",
5576 fname, nt_errstr(status));
5577 goto fail;
5578 }
5579 fnum = (uint16_t)-1;
5580
5581 /* Now try and open for FILE_READ_DATA|FILE_WRITE_DATA */
5582 status = cli_ntcreate(cli,
5583 fname,
5584 0,
5585 FILE_READ_DATA|FILE_WRITE_DATA,
5586 FILE_ATTRIBUTE_NORMAL,
5587 FILE_SHARE_READ|FILE_SHARE_WRITE|
5588 FILE_SHARE_DELETE,
5589 FILE_OPEN,
5590 0,
5591 0,
5592 &fnum,
5593 NULL);
5594 if (!NT_STATUS_IS_OK(status)) {
5595 printf("Open of %s - %s\n", fname, nt_errstr(status));
5596 goto fail;
5597 }
5598
5599 status = cli_close(cli, fnum);
5600 if (!NT_STATUS_IS_OK(status)) {
5601 printf("close failed for %s (%s)\n",
5602 fname, nt_errstr(status));
5603 goto fail;
5604 }
5605
5606 cli_unlink(cli, fname,
5607 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5608
5609 TALLOC_FREE(frame);
5610 return true;
5611
5612 fail:
5613
5614 if (cli) {
5615 if (fnum != (uint16_t)-1) {
5616 cli_close(cli, fnum);
5617 }
5618 cli_unlink(cli, fname,
5619 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5620 torture_close_connection(cli);
5621 }
5622
5623 TALLOC_FREE(frame);
5624 return false;
5625 }
5626
5627 static bool run_pipe_number(int dummy)
5628 {
5629 struct cli_state *cli1;
5630 const char *pipe_name = "\\SPOOLSS";
5631 uint16_t fnum;
5632 int num_pipes = 0;
5633 NTSTATUS status;
5634
5635 printf("starting pipenumber test\n");
5636 if (!torture_open_connection(&cli1, 0)) {
5637 return False;
5638 }
5639
5640 smbXcli_conn_set_sockopt(cli1->conn, sockops);
5641 while(1) {
5642 status = cli_ntcreate(cli1, pipe_name, 0, FILE_READ_DATA,
5643 FILE_ATTRIBUTE_NORMAL,
5644 FILE_SHARE_READ|FILE_SHARE_WRITE,
5645 FILE_OPEN_IF, 0, 0, &fnum, NULL);
5646 if (!NT_STATUS_IS_OK(status)) {
5647 printf("Open of pipe %s failed with error (%s)\n", pipe_name, nt_errstr(status));
5648 break;
5649 }
5650 num_pipes++;
5651 printf("\r%6d", num_pipes);
5652 }
5653
5654 printf("pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
5655 torture_close_connection(cli1);
5656 return True;
5657 }
5658
5659 /*
5660 Test open mode returns on read-only files.
5661 */
5662 static bool run_opentest(int dummy)
5663 {
5664 static struct cli_state *cli1;
5665 static struct cli_state *cli2;
5666 const char *fname = "\\readonly.file";
5667 uint16_t fnum1, fnum2;
5668 char buf[20];
5669 off_t fsize;
5670 bool correct = True;
5671 char *tmp_path;
5672 NTSTATUS status;
5673
5674 printf("starting open test\n");
5675
5676 if (!torture_open_connection(&cli1, 0)) {
5677 return False;
5678 }
5679
5680 cli_setatr(cli1, fname, 0, 0);
5681 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5682
5683 smbXcli_conn_set_sockopt(cli1->conn, sockops);
5684
5685 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
5686 if (!NT_STATUS_IS_OK(status)) {
5687 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
5688 return False;
5689 }
5690
5691 status = cli_close(cli1, fnum1);
5692 if (!NT_STATUS_IS_OK(status)) {
5693 printf("close2 failed (%s)\n", nt_errstr(status));
5694 return False;
5695 }
5696
5697 status = cli_setatr(cli1, fname, FILE_ATTRIBUTE_READONLY, 0);
5698 if (!NT_STATUS_IS_OK(status)) {
5699 printf("cli_setatr failed (%s)\n", nt_errstr(status));
5700 return False;
5701 }
5702
5703 status = cli_openx(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1);
5704 if (!NT_STATUS_IS_OK(status)) {
5705 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
5706 return False;
5707 }
5708
5709 /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
5710 status = cli_openx(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
5711
5712 if (check_error(__LINE__, status, ERRDOS, ERRnoaccess,
5713 NT_STATUS_ACCESS_DENIED)) {
5714 printf("correct error code ERRDOS/ERRnoaccess returned\n");
5715 }
5716
5717 printf("finished open test 1\n");
5718
5719 cli_close(cli1, fnum1);
5720
5721 /* Now try not readonly and ensure ERRbadshare is returned. */
5722
5723 cli_setatr(cli1, fname, 0, 0);
5724
5725 status = cli_openx(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1);
5726 if (!NT_STATUS_IS_OK(status)) {
5727 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
5728 return False;
5729 }
5730
5731 /* This will fail - but the error should be ERRshare. */
5732 status = cli_openx(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
5733
5734 if (check_error(__LINE__, status, ERRDOS, ERRbadshare,
5735 NT_STATUS_SHARING_VIOLATION)) {
5736 printf("correct error code ERRDOS/ERRbadshare returned\n");
5737 }
5738
5739 status = cli_close(cli1, fnum1);
5740 if (!NT_STATUS_IS_OK(status)) {
5741 printf("close2 failed (%s)\n", nt_errstr(status));
5742 return False;
5743 }
5744
5745 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5746
5747 printf("finished open test 2\n");
5748
5749 /* Test truncate open disposition on file opened for read. */
5750 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
5751 if (!NT_STATUS_IS_OK(status)) {
5752 printf("(3) open (1) of %s failed (%s)\n", fname, nt_errstr(status));
5753 return False;
5754 }
5755
5756 /* write 20 bytes. */
5757
5758 memset(buf, '\0', 20);
5759
5760 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, 20, NULL);
5761 if (!NT_STATUS_IS_OK(status)) {
5762 printf("write failed (%s)\n", nt_errstr(status));
5763 correct = False;
5764 }
5765
5766 status = cli_close(cli1, fnum1);
5767 if (!NT_STATUS_IS_OK(status)) {
5768 printf("(3) close1 failed (%s)\n", nt_errstr(status));
5769 return False;
5770 }
5771
5772 /* Ensure size == 20. */
5773 status = cli_getatr(cli1, fname, NULL, &fsize, NULL);
5774 if (!NT_STATUS_IS_OK(status)) {
5775 printf("(3) getatr failed (%s)\n", nt_errstr(status));
5776 return False;
5777 }
5778
5779 if (fsize != 20) {
5780 printf("(3) file size != 20\n");
5781 return False;
5782 }
5783
5784 /* Now test if we can truncate a file opened for readonly. */
5785 status = cli_openx(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE, &fnum1);
5786 if (!NT_STATUS_IS_OK(status)) {
5787 printf("(3) open (2) of %s failed (%s)\n", fname, nt_errstr(status));
5788 return False;
5789 }
5790
5791 status = cli_close(cli1, fnum1);
5792 if (!NT_STATUS_IS_OK(status)) {
5793 printf("close2 failed (%s)\n", nt_errstr(status));
5794 return False;
5795 }
5796
5797 /* Ensure size == 0. */
5798 status = cli_getatr(cli1, fname, NULL, &fsize, NULL);
5799 if (!NT_STATUS_IS_OK(status)) {
5800 printf("(3) getatr failed (%s)\n", nt_errstr(status));
5801 return False;
5802 }
5803
5804 if (fsize != 0) {
5805 printf("(3) file size != 0\n");
5806 return False;
5807 }
5808 printf("finished open test 3\n");
5809
5810 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5811
5812 printf("Do ctemp tests\n");
5813 status = cli_ctemp(cli1, talloc_tos(), "\\", &fnum1, &tmp_path);
5814 if (!NT_STATUS_IS_OK(status)) {
5815 printf("ctemp failed (%s)\n", nt_errstr(status));
5816 return False;
5817 }
5818
5819 printf("ctemp gave path %s\n", tmp_path);
5820 status = cli_close(cli1, fnum1);
5821 if (!NT_STATUS_IS_OK(status)) {
5822 printf("close of temp failed (%s)\n", nt_errstr(status));
5823 }
5824
5825 status = cli_unlink(cli1, tmp_path, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5826 if (!NT_STATUS_IS_OK(status)) {
5827 printf("unlink of temp failed (%s)\n", nt_errstr(status));
5828 }
5829
5830 /* Test the non-io opens... */
5831
5832 if (!torture_open_connection(&cli2, 1)) {
5833 return False;
5834 }
5835
5836 cli_setatr(cli2, fname, 0, 0);
5837 cli_unlink(cli2, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5838
5839 smbXcli_conn_set_sockopt(cli2->conn, sockops);
5840
5841 printf("TEST #1 testing 2 non-io opens (no delete)\n");
5842 status = cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES,
5843 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5844 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5845 if (!NT_STATUS_IS_OK(status)) {
5846 printf("TEST #1 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5847 return False;
5848 }
5849
5850 status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
5851 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5852 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
5853 if (!NT_STATUS_IS_OK(status)) {
5854 printf("TEST #1 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5855 return False;
5856 }
5857
5858 status = cli_close(cli1, fnum1);
5859 if (!NT_STATUS_IS_OK(status)) {
5860 printf("TEST #1 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5861 return False;
5862 }
5863
5864 status = cli_close(cli2, fnum2);
5865 if (!NT_STATUS_IS_OK(status)) {
5866 printf("TEST #1 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5867 return False;
5868 }
5869
5870 printf("non-io open test #1 passed.\n");
5871
5872 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5873
5874 printf("TEST #2 testing 2 non-io opens (first with delete)\n");
5875
5876 status = cli_ntcreate(cli1, fname, 0,
5877 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5878 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5879 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5880 if (!NT_STATUS_IS_OK(status)) {
5881 printf("TEST #2 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5882 return False;
5883 }
5884
5885 status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
5886 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5887 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
5888 if (!NT_STATUS_IS_OK(status)) {
5889 printf("TEST #2 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5890 return False;
5891 }
5892
5893 status = cli_close(cli1, fnum1);
5894 if (!NT_STATUS_IS_OK(status)) {
5895 printf("TEST #2 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5896 return False;
5897 }
5898
5899 status = cli_close(cli2, fnum2);
5900 if (!NT_STATUS_IS_OK(status)) {
5901 printf("TEST #2 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5902 return False;
5903 }
5904
5905 printf("non-io open test #2 passed.\n");
5906
5907 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5908
5909 printf("TEST #3 testing 2 non-io opens (second with delete)\n");
5910
5911 status = cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES,
5912 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5913 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5914 if (!NT_STATUS_IS_OK(status)) {
5915 printf("TEST #3 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5916 return False;
5917 }
5918
5919 status = cli_ntcreate(cli2, fname, 0,
5920 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5921 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5922 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
5923 if (!NT_STATUS_IS_OK(status)) {
5924 printf("TEST #3 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5925 return False;
5926 }
5927
5928 status = cli_close(cli1, fnum1);
5929 if (!NT_STATUS_IS_OK(status)) {
5930 printf("TEST #3 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5931 return False;
5932 }
5933
5934 status = cli_close(cli2, fnum2);
5935 if (!NT_STATUS_IS_OK(status)) {
5936 printf("TEST #3 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5937 return False;
5938 }
5939
5940 printf("non-io open test #3 passed.\n");
5941
5942 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5943
5944 printf("TEST #4 testing 2 non-io opens (both with delete)\n");
5945
5946 status = cli_ntcreate(cli1, fname, 0,
5947 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5948 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5949 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5950 if (!NT_STATUS_IS_OK(status)) {
5951 printf("TEST #4 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5952 return False;
5953 }
5954
5955 status = cli_ntcreate(cli2, fname, 0,
5956 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5957 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5958 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
5959 if (NT_STATUS_IS_OK(status)) {
5960 printf("TEST #4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, nt_errstr(status));
5961 return False;
5962 }
5963
5964 printf("TEST #4 open 2 of %s gave %s (correct error should be %s)\n", fname, nt_errstr(status), "sharing violation");
5965
5966 status = cli_close(cli1, fnum1);
5967 if (!NT_STATUS_IS_OK(status)) {
5968 printf("TEST #4 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5969 return False;
5970 }
5971
5972 printf("non-io open test #4 passed.\n");
5973
5974 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5975
5976 printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
5977
5978 status = cli_ntcreate(cli1, fname, 0,
5979 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5980 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE,
5981 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5982 if (!NT_STATUS_IS_OK(status)) {
5983 printf("TEST #5 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5984 return False;
5985 }
5986
5987 status = cli_ntcreate(cli2, fname, 0,
5988 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5989 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE,
5990 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
5991 if (!NT_STATUS_IS_OK(status)) {
5992 printf("TEST #5 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5993 return False;
5994 }
5995
5996 status = cli_close(cli1, fnum1);
5997 if (!NT_STATUS_IS_OK(status)) {
5998 printf("TEST #5 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5999 return False;
6000 }
6001
6002 status = cli_close(cli2, fnum2);
6003 if (!NT_STATUS_IS_OK(status)) {
6004 printf("TEST #5 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
6005 return False;
6006 }
6007
6008 printf("non-io open test #5 passed.\n");
6009
6010 printf("TEST #6 testing 1 non-io open, one io open\n");
6011
6012 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6013
6014 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA,
6015 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
6016 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
6017 if (!NT_STATUS_IS_OK(status)) {
6018 printf("TEST #6 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
6019 return False;
6020 }
6021
6022 status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
6023 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
6024 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
6025 if (!NT_STATUS_IS_OK(status)) {
6026 printf("TEST #6 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
6027 return False;
6028 }
6029
6030 status = cli_close(cli1, fnum1);
6031 if (!NT_STATUS_IS_OK(status)) {
6032 printf("TEST #6 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
6033 return False;
6034 }
6035
6036 status = cli_close(cli2, fnum2);
6037 if (!NT_STATUS_IS_OK(status)) {
6038 printf("TEST #6 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
6039 return False;
6040 }
6041
6042 printf("non-io open test #6 passed.\n");
6043
6044 printf("TEST #7 testing 1 non-io open, one io open with delete\n");
6045
6046 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6047
6048 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA,
6049 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
6050 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
6051 if (!NT_STATUS_IS_OK(status)) {
6052 printf("TEST #7 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
6053 return False;
6054 }
6055
6056 status = cli_ntcreate(cli2, fname, 0,
6057 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
6058 FILE_ATTRIBUTE_NORMAL,
6059 FILE_SHARE_READ|FILE_SHARE_DELETE,
6060 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
6061 if (NT_STATUS_IS_OK(status)) {
6062 printf("TEST #7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, nt_errstr(status));
6063 return False;
6064 }
6065
6066 printf("TEST #7 open 2 of %s gave %s (correct error should be %s)\n", fname, nt_errstr(status), "sharing violation");
6067
6068 status = cli_close(cli1, fnum1);
6069 if (!NT_STATUS_IS_OK(status)) {
6070 printf("TEST #7 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
6071 return False;
6072 }
6073
6074 printf("non-io open test #7 passed.\n");
6075
6076 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6077
6078 printf("TEST #8 testing open without WRITE_ATTRIBUTES, updating close write time.\n");
6079 status = cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA, FILE_ATTRIBUTE_NORMAL,
6080 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
6081 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
6082 if (!NT_STATUS_IS_OK(status)) {
6083 printf("TEST #8 open of %s failed (%s)\n", fname, nt_errstr(status));
6084 correct = false;
6085 goto out;
6086 }
6087
6088 /* Write to ensure we have to update the file time. */
6089 status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
6090 NULL);
6091 if (!NT_STATUS_IS_OK(status)) {
6092 printf("TEST #8 cli_write failed: %s\n", nt_errstr(status));
6093 correct = false;
6094 goto out;
6095 }
6096
6097 status = cli_close(cli1, fnum1);
6098 if (!NT_STATUS_IS_OK(status)) {
6099 printf("TEST #8 close of %s failed (%s)\n", fname, nt_errstr(status));
6100 correct = false;
6101 }
6102
6103 out:
6104
6105 if (!torture_close_connection(cli1)) {
6106 correct = False;
6107 }
6108 if (!torture_close_connection(cli2)) {
6109 correct = False;
6110 }
6111
6112 return correct;
6113 }
6114
6115 NTSTATUS torture_setup_unix_extensions(struct cli_state *cli)
6116 {
6117 uint16_t major, minor;
6118 uint32_t caplow, caphigh;
6119 NTSTATUS status;
6120
6121 if (!SERVER_HAS_UNIX_CIFS(cli)) {
6122 printf("Server doesn't support UNIX CIFS extensions.\n");
6123 return NT_STATUS_NOT_SUPPORTED;
6124 }
6125
6126 status = cli_unix_extensions_version(cli, &major, &minor, &caplow,
6127 &caphigh);
6128 if (!NT_STATUS_IS_OK(status)) {
6129 printf("Server didn't return UNIX CIFS extensions: %s\n",
6130 nt_errstr(status));
6131 return status;
6132 }
6133
6134 status = cli_set_unix_extensions_capabilities(cli, major, minor,
6135 caplow, caphigh);
6136 if (!NT_STATUS_IS_OK(status)) {
6137 printf("Server doesn't support setting UNIX CIFS extensions: "
6138 "%s.\n", nt_errstr(status));
6139 return status;
6140 }
6141
6142 return NT_STATUS_OK;
6143 }
6144
6145 /*
6146 Test POSIX open /mkdir calls.
6147 */
6148 static bool run_simple_posix_open_test(int dummy)
6149 {
6150 static struct cli_state *cli1;
6151 const char *fname = "posix:file";
6152 const char *hname = "posix:hlink";
6153 const char *sname = "posix:symlink";
6154 const char *dname = "posix:dir";
6155 char buf[10];
6156 char namebuf[11];
6157 uint16_t fnum1 = (uint16_t)-1;
6158 SMB_STRUCT_STAT sbuf;
6159 bool correct = false;
6160 NTSTATUS status;
6161 size_t nread;
6162 const char *fname_windows = "windows_file";
6163 uint16_t fnum2 = (uint16_t)-1;
6164
6165 printf("Starting simple POSIX open test\n");
6166
6167 if (!torture_open_connection(&cli1, 0)) {
6168 return false;
6169 }
6170
6171 smbXcli_conn_set_sockopt(cli1->conn, sockops);
6172
6173 status = torture_setup_unix_extensions(cli1);
6174 if (!NT_STATUS_IS_OK(status)) {
6175 return false;
6176 }
6177
6178 cli_setatr(cli1, fname, 0, 0);
6179 cli_posix_unlink(cli1, fname);
6180 cli_setatr(cli1, dname, 0, 0);
6181 cli_posix_rmdir(cli1, dname);
6182 cli_setatr(cli1, hname, 0, 0);
6183 cli_posix_unlink(cli1, hname);
6184 cli_setatr(cli1, sname, 0, 0);
6185 cli_posix_unlink(cli1, sname);
6186 cli_setatr(cli1, fname_windows, 0, 0);
6187 cli_posix_unlink(cli1, fname_windows);
6188
6189 /* Create a directory. */
6190 status = cli_posix_mkdir(cli1, dname, 0777);
6191 if (!NT_STATUS_IS_OK(status)) {
6192 printf("POSIX mkdir of %s failed (%s)\n", dname, nt_errstr(status));
6193 goto out;
6194 }
6195
6196 status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL,
6197 0600, &fnum1);
6198 if (!NT_STATUS_IS_OK(status)) {
6199 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
6200 goto out;
6201 }
6202
6203 /* Test ftruncate - set file size. */
6204 status = cli_ftruncate(cli1, fnum1, 1000);
6205 if (!NT_STATUS_IS_OK(status)) {
6206 printf("ftruncate failed (%s)\n", nt_errstr(status));
6207 goto out;
6208 }
6209
6210 /* Ensure st_size == 1000 */
6211 status = cli_posix_stat(cli1, fname, &sbuf);
6212 if (!NT_STATUS_IS_OK(status)) {
6213 printf("stat failed (%s)\n", nt_errstr(status));
6214 goto out;
6215 }
6216
6217 if (sbuf.st_ex_size != 1000) {
6218 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
6219 goto out;
6220 }
6221
6222 /* Ensure st_mode == 0600 */
6223 if ((sbuf.st_ex_mode & 07777) != 0600) {
6224 printf("posix_open - bad permissions 0%o != 0600\n",
6225 (unsigned int)(sbuf.st_ex_mode & 07777));
6226 goto out;
6227 }
6228
6229 /* Test ftruncate - set file size back to zero. */
6230 status = cli_ftruncate(cli1, fnum1, 0);
6231 if (!NT_STATUS_IS_OK(status)) {
6232 printf("ftruncate failed (%s)\n", nt_errstr(status));
6233 goto out;
6234 }
6235
6236 status = cli_close(cli1, fnum1);
6237 if (!NT_STATUS_IS_OK(status)) {
6238 printf("close failed (%s)\n", nt_errstr(status));
6239 goto out;
6240 }
6241
6242 /* Now open the file again for read only. */
6243 status = cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1);
6244 if (!NT_STATUS_IS_OK(status)) {
6245 printf("POSIX open of %s failed (%s)\n", fname, nt_errstr(status));
6246 goto out;
6247 }
6248
6249 /* Now unlink while open. */
6250 status = cli_posix_unlink(cli1, fname);
6251 if (!NT_STATUS_IS_OK(status)) {
6252 printf("POSIX unlink of %s failed (%s)\n", fname, nt_errstr(status));
6253 goto out;
6254 }
6255
6256 status = cli_close(cli1, fnum1);
6257 if (!NT_STATUS_IS_OK(status)) {
6258 printf("close(2) failed (%s)\n", nt_errstr(status));
6259 goto out;
6260 }
6261
6262 /* Ensure the file has gone. */
6263 status = cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1);
6264 if (NT_STATUS_IS_OK(status)) {
6265 printf("POSIX open of %s succeeded, should have been deleted.\n", fname);
6266 goto out;
6267 }
6268
6269 /* Create again to test open with O_TRUNC. */
6270 status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1);
6271 if (!NT_STATUS_IS_OK(status)) {
6272 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
6273 goto out;
6274 }
6275
6276 /* Test ftruncate - set file size. */
6277 status = cli_ftruncate(cli1, fnum1, 1000);
6278 if (!NT_STATUS_IS_OK(status)) {
6279 printf("ftruncate failed (%s)\n", nt_errstr(status));
6280 goto out;
6281 }
6282
6283 /* Ensure st_size == 1000 */
6284 status = cli_posix_stat(cli1, fname, &sbuf);
6285 if (!NT_STATUS_IS_OK(status)) {
6286 printf("stat failed (%s)\n", nt_errstr(status));
6287 goto out;
6288 }
6289
6290 if (sbuf.st_ex_size != 1000) {
6291 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
6292 goto out;
6293 }
6294
6295 status = cli_close(cli1, fnum1);
6296 if (!NT_STATUS_IS_OK(status)) {
6297 printf("close(2) failed (%s)\n", nt_errstr(status));
6298 goto out;
6299 }
6300
6301 /* Re-open with O_TRUNC. */
6302 status = cli_posix_open(cli1, fname, O_WRONLY|O_TRUNC, 0600, &fnum1);
6303 if (!NT_STATUS_IS_OK(status)) {
6304 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
6305 goto out;
6306 }
6307
6308 /* Ensure st_size == 0 */
6309 status = cli_posix_stat(cli1, fname, &sbuf);
6310 if (!NT_STATUS_IS_OK(status)) {
6311 printf("stat failed (%s)\n", nt_errstr(status));
6312 goto out;
6313 }
6314
6315 if (sbuf.st_ex_size != 0) {
6316 printf("O_TRUNC - stat size (%u) != 0\n", (unsigned int)sbuf.st_ex_size);
6317 goto out;
6318 }
6319
6320 status = cli_close(cli1, fnum1);
6321 if (!NT_STATUS_IS_OK(status)) {
6322 printf("close failed (%s)\n", nt_errstr(status));
6323 goto out;
6324 }
6325
6326 status = cli_posix_unlink(cli1, fname);
6327 if (!NT_STATUS_IS_OK(status)) {
6328 printf("POSIX unlink of %s failed (%s)\n", fname, nt_errstr(status));
6329 goto out;
6330 }
6331
6332 status = cli_posix_open(cli1, dname, O_RDONLY, 0, &fnum1);
6333 if (!NT_STATUS_IS_OK(status)) {
6334 printf("POSIX open directory O_RDONLY of %s failed (%s)\n",
6335 dname, nt_errstr(status));
6336 goto out;
6337 }
6338
6339 cli_close(cli1, fnum1);
6340
6341 /* What happens when we try and POSIX open a directory for write ? */
6342 status = cli_posix_open(cli1, dname, O_RDWR, 0, &fnum1);
6343 if (NT_STATUS_IS_OK(status)) {
6344 printf("POSIX open of directory %s succeeded, should have failed.\n", fname);
6345 goto out;
6346 } else {
6347 if (!check_both_error(__LINE__, status, ERRDOS, EISDIR,
6348 NT_STATUS_FILE_IS_A_DIRECTORY)) {
6349 goto out;
6350 }
6351 }
6352
6353 /* Create the file. */
6354 status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL,
6355 0600, &fnum1);
6356 if (!NT_STATUS_IS_OK(status)) {
6357 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
6358 goto out;
6359 }
6360
6361 /* Write some data into it. */
6362 status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
6363 NULL);
6364 if (!NT_STATUS_IS_OK(status)) {
6365 printf("cli_write failed: %s\n", nt_errstr(status));
6366 goto out;
6367 }
6368
6369 cli_close(cli1, fnum1);
6370
6371 /* Now create a hardlink. */
6372 status = cli_posix_hardlink(cli1, fname, hname);
6373 if (!NT_STATUS_IS_OK(status)) {
6374 printf("POSIX hardlink of %s failed (%s)\n", hname, nt_errstr(status));
6375 goto out;
6376 }
6377
6378 /* Now create a symlink. */
6379 status = cli_posix_symlink(cli1, fname, sname);
6380 if (!NT_STATUS_IS_OK(status)) {
6381 printf("POSIX symlink of %s failed (%s)\n", sname, nt_errstr(status));
6382 goto out;
6383 }
6384
6385 /* Open the hardlink for read. */
6386 status = cli_posix_open(cli1, hname, O_RDONLY, 0, &fnum1);
6387 if (!NT_STATUS_IS_OK(status)) {
6388 printf("POSIX open of %s failed (%s)\n", hname, nt_errstr(status));
6389 goto out;
6390 }
6391
6392 status = cli_read(cli1, fnum1, buf, 0, 10, &nread);
6393 if (!NT_STATUS_IS_OK(status)) {
6394 printf("POSIX read of %s failed (%s)\n", hname,
6395 nt_errstr(status));
6396 goto out;
6397 } else if (nread != 10) {
6398 printf("POSIX read of %s failed. Received %ld, expected %d\n",
6399 hname, (unsigned long)nread, 10);
6400 goto out;
6401 }
6402
6403 if (memcmp(buf, "TEST DATA\n", 10)) {
6404 printf("invalid data read from hardlink\n");
6405 goto out;
6406 }
6407
6408 /* Do a POSIX lock/unlock. */
6409 status = cli_posix_lock(cli1, fnum1, 0, 100, true, READ_LOCK);
6410 if (!NT_STATUS_IS_OK(status)) {
6411 printf("POSIX lock failed %s\n", nt_errstr(status));
6412 goto out;
6413 }
6414
6415 /* Punch a hole in the locked area. */
6416 status = cli_posix_unlock(cli1, fnum1, 10, 80);
6417 if (!NT_STATUS_IS_OK(status)) {
6418 printf("POSIX unlock failed %s\n", nt_errstr(status));
6419 goto out;
6420 }
6421
6422 cli_close(cli1, fnum1);
6423
6424 /* Open the symlink for read - this should fail. A POSIX
6425 client should not be doing opens on a symlink. */
6426 status = cli_posix_open(cli1, sname, O_RDONLY, 0, &fnum1);
6427 if (NT_STATUS_IS_OK(status)) {
6428 printf("POSIX open of %s succeeded (should have failed)\n", sname);
6429 goto out;
6430 } else {
6431 if (!check_both_error(__LINE__, status, ERRDOS, ERRbadpath,
6432 NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
6433 printf("POSIX open of %s should have failed "
6434 "with NT_STATUS_OBJECT_PATH_NOT_FOUND, "
6435 "failed with %s instead.\n",
6436 sname, nt_errstr(status));
6437 goto out;
6438 }
6439 }
6440
6441 status = cli_posix_readlink(cli1, sname, namebuf, sizeof(namebuf));
6442 if (!NT_STATUS_IS_OK(status)) {
6443 printf("POSIX readlink on %s failed (%s)\n", sname, nt_errstr(status));
6444 goto out;
6445 }
6446
6447 if (strcmp(namebuf, fname) != 0) {
6448 printf("POSIX readlink on %s failed to match name %s (read %s)\n",
6449 sname, fname, namebuf);
6450 goto out;
6451 }
6452
6453 status = cli_posix_rmdir(cli1, dname);
6454 if (!NT_STATUS_IS_OK(status)) {
6455 printf("POSIX rmdir failed (%s)\n", nt_errstr(status));
6456 goto out;
6457 }
6458
6459 /* Check directory opens with a specific permission. */
6460 status = cli_posix_mkdir(cli1, dname, 0700);
6461 if (!NT_STATUS_IS_OK(status)) {
6462 printf("POSIX mkdir of %s failed (%s)\n", dname, nt_errstr(status));
6463 goto out;
6464 }
6465
6466 /* Ensure st_mode == 0700 */
6467 status = cli_posix_stat(cli1, dname, &sbuf);
6468 if (!NT_STATUS_IS_OK(status)) {
6469 printf("stat failed (%s)\n", nt_errstr(status));
6470 goto out;
6471 }
6472
6473 if ((sbuf.st_ex_mode & 07777) != 0700) {
6474 printf("posix_mkdir - bad permissions 0%o != 0700\n",
6475 (unsigned int)(sbuf.st_ex_mode & 07777));
6476 goto out;
6477 }
6478
6479 /*
6480 * Now create a Windows file, and attempt a POSIX unlink.
6481 * This should fail with a sharing violation but due to:
6482 *
6483 * [Bug 9571] Unlink after open causes smbd to panic
6484 *
6485 * ensure we've fixed the lock ordering violation.
6486 */
6487
6488 status = cli_ntcreate(cli1, fname_windows, 0,
6489 FILE_READ_DATA|FILE_WRITE_DATA, 0,
6490 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
6491 FILE_CREATE,
6492 0x0, 0x0, &fnum2, NULL);
6493 if (!NT_STATUS_IS_OK(status)) {
6494 printf("Windows create of %s failed (%s)\n", fname_windows,
6495 nt_errstr(status));
6496 goto out;
6497 }
6498
6499 /* Now try posix_unlink. */
6500 status = cli_posix_unlink(cli1, fname_windows);
6501 if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
6502 printf("POSIX unlink of %s should fail "
6503 "with NT_STATUS_SHARING_VIOLATION "
6504 "got %s instead !\n",
6505 fname_windows,
6506 nt_errstr(status));
6507 goto out;
6508 }
6509
6510 cli_close(cli1, fnum2);
6511
6512 printf("Simple POSIX open test passed\n");
6513 correct = true;
6514
6515 out:
6516
6517 if (fnum1 != (uint16_t)-1) {
6518 cli_close(cli1, fnum1);
6519 fnum1 = (uint16_t)-1;
6520 }
6521
6522 if (fnum2 != (uint16_t)-1) {
6523 cli_close(cli1, fnum2);
6524 fnum2 = (uint16_t)-1;
6525 }
6526
6527 cli_setatr(cli1, sname, 0, 0);
6528 cli_posix_unlink(cli1, sname);
6529 cli_setatr(cli1, hname, 0, 0);
6530 cli_posix_unlink(cli1, hname);
6531 cli_setatr(cli1, fname, 0, 0);
6532 cli_posix_unlink(cli1, fname);
6533 cli_setatr(cli1, dname, 0, 0);
6534 cli_posix_rmdir(cli1, dname);
6535 cli_setatr(cli1, fname_windows, 0, 0);
6536 cli_posix_unlink(cli1, fname_windows);
6537
6538 if (!torture_close_connection(cli1)) {
6539 correct = false;
6540 }
6541
6542 return correct;
6543 }
6544
6545 /*
6546 Test POSIX and Windows ACLs are rejected on symlinks.
6547 */
6548 static bool run_acl_symlink_test(int dummy)
6549 {
6550 static struct cli_state *cli;
6551 const char *fname = "posix_file";
6552 const char *sname = "posix_symlink";
6553 uint16_t fnum = (uint16_t)-1;
6554 bool correct = false;
6555 NTSTATUS status;
6556 char *posix_acl = NULL;
6557 size_t posix_acl_len = 0;
6558 char *posix_acl_sym = NULL;
6559 size_t posix_acl_len_sym = 0;
6560 struct security_descriptor *sd = NULL;
6561 struct security_descriptor *sd_sym = NULL;
6562 TALLOC_CTX *frame = NULL;
6563
6564 frame = talloc_stackframe();
6565
6566 printf("Starting acl symlink test\n");
6567
6568 if (!torture_open_connection(&cli, 0)) {
6569 TALLOC_FREE(frame);
6570 return false;
6571 }
6572
6573 smbXcli_conn_set_sockopt(cli->conn, sockops);
6574
6575 status = torture_setup_unix_extensions(cli);
6576 if (!NT_STATUS_IS_OK(status)) {
6577 TALLOC_FREE(frame);
6578 return false;
6579 }
6580
6581 cli_setatr(cli, fname, 0, 0);
6582 cli_posix_unlink(cli, fname);
6583 cli_setatr(cli, sname, 0, 0);
6584 cli_posix_unlink(cli, sname);
6585
6586 status = cli_ntcreate(cli,
6587 fname,
6588 0,
6589 READ_CONTROL_ACCESS,
6590 0,
6591 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
6592 FILE_CREATE,
6593 0x0,
6594 0x0,
6595 &fnum,
6596 NULL);
6597
6598 if (!NT_STATUS_IS_OK(status)) {
6599 printf("cli_ntcreate of %s failed (%s)\n",
6600 fname,
6601 nt_errstr(status));
6602 goto out;
6603 }
6604
6605 /* Get the Windows ACL on the file. */
6606 status = cli_query_secdesc(cli,
6607 fnum,
6608 frame,
6609 &sd);
6610 if (!NT_STATUS_IS_OK(status)) {
6611 printf("cli_query_secdesc failed (%s)\n",
6612 nt_errstr(status));
6613 goto out;
6614 }
6615
6616 /* Get the POSIX ACL on the file. */
6617 status = cli_posix_getacl(cli,
6618 fname,
6619 frame,
6620 &posix_acl_len,
6621 &posix_acl);
6622
6623 if (!NT_STATUS_IS_OK(status)) {
6624 printf("cli_posix_getacl failed (%s)\n",
6625 nt_errstr(status));
6626 goto out;
6627 }
6628
6629 status = cli_close(cli, fnum);
6630 if (!NT_STATUS_IS_OK(status)) {
6631 printf("close failed (%s)\n", nt_errstr(status));
6632 goto out;
6633 }
6634 fnum = (uint16_t)-1;
6635
6636 /* Now create a symlink. */
6637 status = cli_posix_symlink(cli, fname, sname);
6638 if (!NT_STATUS_IS_OK(status)) {
6639 printf("cli_posix_symlink of %s -> %s failed (%s)\n",
6640 sname,
6641 fname,
6642 nt_errstr(status));
6643 goto out;
6644 }
6645
6646 /* Open a handle on the symlink. */
6647 status = cli_ntcreate(cli,
6648 sname,
6649 0,
6650 READ_CONTROL_ACCESS|SEC_STD_WRITE_DAC,
6651 0,
6652 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
6653 FILE_OPEN,
6654 0x0,
6655 0x0,
6656 &fnum,
6657 NULL);
6658
6659 if (!NT_STATUS_IS_OK(status)) {
6660 printf("cli_posix_open of %s failed (%s)\n",
6661 sname,
6662 nt_errstr(status));
6663 goto out;
6664 }
6665
6666 /* Get the Windows ACL on the symlink handle. Should fail */
6667 status = cli_query_secdesc(cli,
6668 fnum,
6669 frame,
6670 &sd_sym);
6671
6672 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
6673 printf("cli_query_secdesc on a symlink gave %s. "
6674 "Should be NT_STATUS_ACCESS_DENIED.\n",
6675 nt_errstr(status));
6676 goto out;
6677 }
6678
6679 /* Get the POSIX ACL on the symlink pathname. Should fail. */
6680 status = cli_posix_getacl(cli,
6681 sname,
6682 frame,
6683 &posix_acl_len_sym,
6684 &posix_acl_sym);
6685
6686 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
6687 printf("cli_posix_getacl on a symlink gave %s. "
6688 "Should be NT_STATUS_ACCESS_DENIED.\n",
6689 nt_errstr(status));
6690 goto out;
6691 }
6692
6693 /* Set the Windows ACL on the symlink handle. Should fail */
6694 status = cli_set_security_descriptor(cli,
6695 fnum,
6696 SECINFO_DACL,
6697 sd);
6698
6699 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
6700 printf("cli_query_secdesc on a symlink gave %s. "
6701 "Should be NT_STATUS_ACCESS_DENIED.\n",
6702 nt_errstr(status));
6703 goto out;
6704 }
6705
6706 /* Set the POSIX ACL on the symlink pathname. Should fail. */
6707 status = cli_posix_setacl(cli,
6708 sname,
6709 posix_acl,
6710 posix_acl_len);
6711
6712 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
6713 printf("cli_posix_getacl on a symlink gave %s. "
6714 "Should be NT_STATUS_ACCESS_DENIED.\n",
6715 nt_errstr(status));
6716 goto out;
6717 }
6718
6719 printf("ACL symlink test passed\n");
6720 correct = true;
6721
6722 out:
6723
6724 if (fnum != (uint16_t)-1) {
6725 cli_close(cli, fnum);
6726 fnum = (uint16_t)-1;
6727 }
6728
6729 cli_setatr(cli, sname, 0, 0);
6730 cli_posix_unlink(cli, sname);
6731 cli_setatr(cli, fname, 0, 0);
6732 cli_posix_unlink(cli, fname);
6733
6734 if (!torture_close_connection(cli)) {
6735 correct = false;
6736 }
6737
6738 TALLOC_FREE(frame);
6739 return correct;
6740 }
6741
6742 /*
6743 Test POSIX can delete a file containing streams.
6744 */
6745 static bool run_posix_stream_delete(int dummy)
6746 {
6747 struct cli_state *cli1 = NULL;
6748 struct cli_state *cli2 = NULL;
6749 const char *fname = "streamfile";
6750 const char *stream_fname = "streamfile:Zone.Identifier:$DATA";
6751 uint16_t fnum1 = (uint16_t)-1;
6752 bool correct = false;
6753 NTSTATUS status;
6754 TALLOC_CTX *frame = NULL;
6755
6756 frame = talloc_stackframe();
6757
6758 printf("Starting POSIX stream delete test\n");
6759
6760 if (!torture_open_connection(&cli1, 0) ||
6761 !torture_open_connection(&cli2, 1)) {
6762 TALLOC_FREE(frame);
6763 return false;
6764 }
6765
6766 smbXcli_conn_set_sockopt(cli1->conn, sockops);
6767 smbXcli_conn_set_sockopt(cli2->conn, sockops);
6768
6769 status = torture_setup_unix_extensions(cli2);
6770 if (!NT_STATUS_IS_OK(status)) {
6771 goto out;
6772 }
6773
6774 cli_setatr(cli1, fname, 0, 0);
6775 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6776
6777 /* Create the file. */
6778 status = cli_ntcreate(cli1,
6779 fname,
6780 0,
6781 READ_CONTROL_ACCESS,
6782 0,
6783 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
6784 FILE_CREATE,
6785 0x0,
6786 0x0,
6787 &fnum1,
6788 NULL);
6789
6790 if (!NT_STATUS_IS_OK(status)) {
6791 printf("cli_ntcreate of %s failed (%s)\n",
6792 fname,
6793 nt_errstr(status));
6794 goto out;
6795 }
6796
6797 status = cli_close(cli1, fnum1);
6798 if (!NT_STATUS_IS_OK(status)) {
6799 printf("cli_close of %s failed (%s)\n",
6800 fname,
6801 nt_errstr(status));
6802 goto out;
6803 }
6804 fnum1 = (uint16_t)-1;
6805
6806 /* Now create the stream. */
6807 status = cli_ntcreate(cli1,
6808 stream_fname,
6809 0,
6810 FILE_WRITE_DATA,
6811 0,
6812 FILE_SHARE_READ|FILE_SHARE_WRITE,
6813 FILE_CREATE,
6814 0x0,
6815 0x0,
6816 &fnum1,
6817 NULL);
6818
6819 if (!NT_STATUS_IS_OK(status)) {
6820 printf("cli_ntcreate of %s failed (%s)\n",
6821 stream_fname,
6822 nt_errstr(status));
6823 goto out;
6824 }
6825
6826 /* Leave the stream handle open... */
6827
6828 /* POSIX unlink should fail. */
6829 status = cli_posix_unlink(cli2, fname);
6830 if (NT_STATUS_IS_OK(status)) {
6831 printf("cli_posix_unlink of %s succeeded, should have failed\n",
6832 fname);
6833 goto out;
6834 }
6835
6836 if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
6837 printf("cli_posix_unlink of %s failed with (%s) "
6838 "should have been NT_STATUS_SHARING_VIOLATION\n",
6839 fname,
6840 nt_errstr(status));
6841 goto out;
6842 }
6843
6844 /* Close the stream handle. */
6845 status = cli_close(cli1, fnum1);
6846 if (!NT_STATUS_IS_OK(status)) {
6847 printf("cli_close of %s failed (%s)\n",
6848 stream_fname,
6849 nt_errstr(status));
6850 goto out;
6851 }
6852 fnum1 = (uint16_t)-1;
6853
6854 /* POSIX unlink after stream handle closed should succeed. */
6855 status = cli_posix_unlink(cli2, fname);
6856 if (!NT_STATUS_IS_OK(status)) {
6857 printf("cli_posix_unlink of %s failed (%s)\n",
6858 fname,
6859 nt_errstr(status));
6860 goto out;
6861 }
6862
6863 printf("POSIX stream delete test passed\n");
6864 correct = true;
6865
6866 out:
6867
6868 if (fnum1 != (uint16_t)-1) {
6869 cli_close(cli1, fnum1);
6870 fnum1 = (uint16_t)-1;
6871 }
6872
6873 cli_setatr(cli1, fname, 0, 0);
6874 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6875
6876 if (!torture_close_connection(cli1)) {
6877 correct = false;
6878 }
6879 if (!torture_close_connection(cli2)) {
6880 correct = false;
6881 }
6882
6883 TALLOC_FREE(frame);
6884 return correct;
6885 }
6886
6887 /*
6888 Test setting EA's are rejected on symlinks.
6889 */
6890 static bool run_ea_symlink_test(int dummy)
6891 {
6892 static struct cli_state *cli;
6893 const char *fname = "posix_file_ea";
6894 const char *sname = "posix_symlink_ea";
6895 const char *ea_name = "testea_name";
6896 const char *ea_value = "testea_value";
6897 uint16_t fnum = (uint16_t)-1;
6898 bool correct = false;
6899 NTSTATUS status;
6900 size_t i, num_eas;
6901 struct ea_struct *eas = NULL;
6902 TALLOC_CTX *frame = NULL;
6903
6904 frame = talloc_stackframe();
6905
6906 printf("Starting EA symlink test\n");
6907
6908 if (!torture_open_connection(&cli, 0)) {
6909 TALLOC_FREE(frame);
6910 return false;
6911 }
6912
6913 smbXcli_conn_set_sockopt(cli->conn, sockops);
6914
6915 status = torture_setup_unix_extensions(cli);
6916 if (!NT_STATUS_IS_OK(status)) {
6917 TALLOC_FREE(frame);
6918 return false;
6919 }
6920
6921 cli_setatr(cli, fname, 0, 0);
6922 cli_posix_unlink(cli, fname);
6923 cli_setatr(cli, sname, 0, 0);
6924 cli_posix_unlink(cli, sname);
6925
6926 status = cli_ntcreate(cli,
6927 fname,
6928 0,
6929 READ_CONTROL_ACCESS,
6930 0,
6931 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
6932 FILE_CREATE,
6933 0x0,
6934 0x0,
6935 &fnum,
6936 NULL);
6937
6938 if (!NT_STATUS_IS_OK(status)) {
6939 printf("cli_ntcreate of %s failed (%s)\n",
6940 fname,
6941 nt_errstr(status));
6942 goto out;
6943 }
6944
6945 status = cli_close(cli, fnum);
6946 if (!NT_STATUS_IS_OK(status)) {
6947 printf("close failed (%s)\n",
6948 nt_errstr(status));
6949 goto out;
6950 }
6951 fnum = (uint16_t)-1;
6952
6953 /* Set an EA on the path. */
6954 status = cli_set_ea_path(cli,
6955 fname,
6956 ea_name,
6957 ea_value,
6958 strlen(ea_value)+1);
6959
6960 if (!NT_STATUS_IS_OK(status)) {
6961 printf("cli_set_ea_path failed (%s)\n",
6962 nt_errstr(status));
6963 goto out;
6964 }
6965
6966 /* Now create a symlink. */
6967 status = cli_posix_symlink(cli, fname, sname);
6968 if (!NT_STATUS_IS_OK(status)) {
6969 printf("cli_posix_symlink of %s -> %s failed (%s)\n",
6970 sname,
6971 fname,
6972 nt_errstr(status));
6973 goto out;
6974 }
6975
6976 /* Get the EA list on the path. Should return value set. */
6977 status = cli_get_ea_list_path(cli,
6978 fname,
6979 frame,
6980 &num_eas,
6981 &eas);
6982
6983 if (!NT_STATUS_IS_OK(status)) {
6984 printf("cli_get_ea_list_path failed (%s)\n",
6985 nt_errstr(status));
6986 goto out;
6987 }
6988
6989 /* Ensure the EA we set is there. */
6990 for (i=0; i<num_eas; i++) {
6991 if (strcmp(eas[i].name, ea_name) == 0 &&
6992 eas[i].value.length == strlen(ea_value)+1 &&
6993 memcmp(eas[i].value.data,
6994 ea_value,
6995 eas[i].value.length) == 0) {
6996 break;
6997 }
6998 }
6999
7000 if (i == num_eas) {
7001 printf("Didn't find EA on pathname %s\n",
7002 fname);
7003 goto out;
7004 }
7005
7006 num_eas = 0;
7007 TALLOC_FREE(eas);
7008
7009 /* Get the EA list on the symlink. Should return empty list. */
7010 status = cli_get_ea_list_path(cli,
7011 sname,
7012 frame,
7013 &num_eas,
7014 &eas);
7015
7016 if (!NT_STATUS_IS_OK(status)) {
7017 printf("cli_get_ea_list_path failed (%s)\n",
7018 nt_errstr(status));
7019 goto out;
7020 }
7021
7022 if (num_eas != 0) {
7023 printf("cli_get_ea_list_path failed (%s)\n",
7024 nt_errstr(status));
7025 goto out;
7026 }
7027
7028 /* Set an EA on the symlink. Should fail. */
7029 status = cli_set_ea_path(cli,
7030 sname,
7031 ea_name,
7032 ea_value,
7033 strlen(ea_value)+1);
7034
7035 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
7036 printf("cli_set_ea_path on a symlink gave %s. "
7037 "Should be NT_STATUS_ACCESS_DENIED.\n",
7038 nt_errstr(status));
7039 goto out;
7040 }
7041
7042 printf("EA symlink test passed\n");
7043 correct = true;
7044
7045 out:
7046
7047 if (fnum != (uint16_t)-1) {
7048 cli_close(cli, fnum);
7049 fnum = (uint16_t)-1;
7050 }
7051
7052 cli_setatr(cli, sname, 0, 0);
7053 cli_posix_unlink(cli, sname);
7054 cli_setatr(cli, fname, 0, 0);
7055 cli_posix_unlink(cli, fname);
7056
7057 if (!torture_close_connection(cli)) {
7058 correct = false;
7059 }
7060
7061 TALLOC_FREE(frame);
7062 return correct;
7063 }
7064
7065 /*
7066 Test POSIX locks are OFD-locks.
7067 */
7068 static bool run_posix_ofd_lock_test(int dummy)
7069 {
7070 static struct cli_state *cli;
7071 const char *fname = "posix_file";
7072 uint16_t fnum1 = (uint16_t)-1;
7073 uint16_t fnum2 = (uint16_t)-1;
7074 bool correct = false;
7075 NTSTATUS status;
7076 TALLOC_CTX *frame = NULL;
7077
7078 frame = talloc_stackframe();
7079
7080 printf("Starting POSIX ofd-lock test\n");
7081
7082 if (!torture_open_connection(&cli, 0)) {
7083 TALLOC_FREE(frame);
7084 return false;
7085 }
7086
7087 smbXcli_conn_set_sockopt(cli->conn, sockops);
7088
7089 status = torture_setup_unix_extensions(cli);
7090 if (!NT_STATUS_IS_OK(status)) {
7091 TALLOC_FREE(frame);
7092 return false;
7093 }
7094
7095 cli_setatr(cli, fname, 0, 0);
7096 cli_posix_unlink(cli, fname);
7097
7098 /* Open the file twice. */
7099 status = cli_posix_open(cli, fname, O_RDWR|O_CREAT|O_EXCL,
7100 0600, &fnum1);
7101 if (!NT_STATUS_IS_OK(status)) {
7102 printf("First POSIX open of %s failed\n", fname);
7103 goto out;
7104 }
7105
7106 status = cli_posix_open(cli, fname, O_RDWR, 0, &fnum2);
7107 if (!NT_STATUS_IS_OK(status)) {
7108 printf("First POSIX open of %s failed\n", fname);
7109 goto out;
7110 }
7111
7112 /* Set a 0-50 lock on fnum1. */
7113 status = cli_posix_lock(cli, fnum1, 0, 50, false, WRITE_LOCK);
7114 if (!NT_STATUS_IS_OK(status)) {
7115 printf("POSIX lock (1) failed %s\n", nt_errstr(status));
7116 goto out;
7117 }
7118
7119 /* Set a 60-100 lock on fnum2. */
7120 status = cli_posix_lock(cli, fnum2, 60, 100, false, WRITE_LOCK);
7121 if (!NT_STATUS_IS_OK(status)) {
7122 printf("POSIX lock (2) failed %s\n", nt_errstr(status));
7123 goto out;
7124 }
7125
7126 /* close fnum1 - 0-50 lock should go away. */
7127 status = cli_close(cli, fnum1);
7128 if (!NT_STATUS_IS_OK(status)) {
7129 printf("close failed (%s)\n",
7130 nt_errstr(status));
7131 goto out;
7132 }
7133 fnum1 = (uint16_t)-1;
7134
7135 /* Change the lock context. */
7136 cli_setpid(cli, cli_getpid(cli) + 1);
7137
7138 /* Re-open fnum1. */
7139 status = cli_posix_open(cli, fname, O_RDWR, 0, &fnum1);
7140 if (!NT_STATUS_IS_OK(status)) {
7141 printf("Third POSIX open of %s failed\n", fname);
7142 goto out;
7143 }
7144
7145 /* 60-100 lock should still be there. */
7146 status = cli_posix_lock(cli, fnum1, 60, 100, false, WRITE_LOCK);
7147 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
7148 printf("POSIX lock 60-100 not there %s\n", nt_errstr(status));
7149 goto out;
7150 }
7151
7152 /* 0-50 lock should be gone. */
7153 status = cli_posix_lock(cli, fnum1, 0, 50, false, WRITE_LOCK);
7154 if (!NT_STATUS_IS_OK(status)) {
7155 printf("POSIX lock 0-50 failed %s\n", nt_errstr(status));
7156 goto out;
7157 }
7158
7159 printf("POSIX OFD lock test passed\n");
7160 correct = true;
7161
7162 out:
7163
7164 if (fnum1 != (uint16_t)-1) {
7165 cli_close(cli, fnum1);
7166 fnum1 = (uint16_t)-1;
7167 }
7168 if (fnum2 != (uint16_t)-1) {
7169 cli_close(cli, fnum2);
7170 fnum2 = (uint16_t)-1;
7171 }
7172
7173 cli_setatr(cli, fname, 0, 0);
7174 cli_posix_unlink(cli, fname);
7175
7176 if (!torture_close_connection(cli)) {
7177 correct = false;
7178 }
7179
7180 TALLOC_FREE(frame);
7181 return correct;
7182 }
7183
7184 static uint32_t open_attrs_table[] = {
7185 FILE_ATTRIBUTE_NORMAL,
7186 FILE_ATTRIBUTE_ARCHIVE,
7187 FILE_ATTRIBUTE_READONLY,
7188 FILE_ATTRIBUTE_HIDDEN,
7189 FILE_ATTRIBUTE_SYSTEM,
7190
7191 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY,
7192 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN,
7193 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,
7194 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
7195 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
7196 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
7197
7198 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
7199 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
7200 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
7201 FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM,
7202 };
7203
7204 struct trunc_open_results {
7205 unsigned int num;
7206 uint32_t init_attr;
7207 uint32_t trunc_attr;
7208 uint32_t result_attr;
7209 };
7210
7211 static struct trunc_open_results attr_results[] = {
7212 { 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
7213 { 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
7214 { 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
7215 { 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
7216 { 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
7217 { 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
7218 { 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
7219 { 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
7220 { 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
7221 { 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
7222 { 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
7223 { 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
7224 { 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
7225 { 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
7226 { 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 },
7227 { 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
7228 { 119, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
7229 { 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 },
7230 { 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 },
7231 { 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 },
7232 { 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
7233 { 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
7234 { 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
7235 { 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
7236 { 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
7237 { 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
7238 };
7239
7240 static bool run_openattrtest(int dummy)
7241 {
7242 static struct cli_state *cli1;
7243 const char *fname = "\\openattr.file";
7244 uint16_t fnum1;
7245 bool correct = True;
7246 uint16_t attr;
7247 unsigned int i, j, k, l;
7248 NTSTATUS status;
7249
7250 printf("starting open attr test\n");
7251
7252 if (!torture_open_connection(&cli1, 0)) {
7253 return False;
7254 }
7255
7256 smbXcli_conn_set_sockopt(cli1->conn, sockops);
7257
7258 for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32_t); i++) {
7259 cli_setatr(cli1, fname, 0, 0);
7260 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7261
7262 status = cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA,
7263 open_attrs_table[i], FILE_SHARE_NONE,
7264 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
7265 if (!NT_STATUS_IS_OK(status)) {
7266 printf("open %d (1) of %s failed (%s)\n", i, fname, nt_errstr(status));
7267 return False;
7268 }
7269
7270 status = cli_close(cli1, fnum1);
7271 if (!NT_STATUS_IS_OK(status)) {
7272 printf("close %d (1) of %s failed (%s)\n", i, fname, nt_errstr(status));
7273 return False;
7274 }
7275
7276 for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32_t); j++) {
7277 status = cli_ntcreate(cli1, fname, 0,
7278 FILE_READ_DATA|FILE_WRITE_DATA,
7279 open_attrs_table[j],
7280 FILE_SHARE_NONE, FILE_OVERWRITE,
7281 0, 0, &fnum1, NULL);
7282 if (!NT_STATUS_IS_OK(status)) {
7283 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
7284 if (attr_results[l].num == k) {
7285 printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
7286 k, open_attrs_table[i],
7287 open_attrs_table[j],
7288 fname, NT_STATUS_V(status), nt_errstr(status));
7289 correct = False;
7290 }
7291 }
7292
7293 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
7294 printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n",
7295 k, open_attrs_table[i], open_attrs_table[j],
7296 nt_errstr(status));
7297 correct = False;
7298 }
7299 #if 0
7300 printf("[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]);
7301 #endif
7302 k++;
7303 continue;
7304 }
7305
7306 status = cli_close(cli1, fnum1);
7307 if (!NT_STATUS_IS_OK(status)) {
7308 printf("close %d (2) of %s failed (%s)\n", j, fname, nt_errstr(status));
7309 return False;
7310 }
7311
7312 status = cli_getatr(cli1, fname, &attr, NULL, NULL);
7313 if (!NT_STATUS_IS_OK(status)) {
7314 printf("getatr(2) failed (%s)\n", nt_errstr(status));
7315 return False;
7316 }
7317
7318 #if 0
7319 printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
7320 k, open_attrs_table[i], open_attrs_table[j], attr );
7321 #endif
7322
7323 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
7324 if (attr_results[l].num == k) {
7325 if (attr != attr_results[l].result_attr ||
7326 open_attrs_table[i] != attr_results[l].init_attr ||
7327 open_attrs_table[j] != attr_results[l].trunc_attr) {
7328 printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
7329 open_attrs_table[i],
7330 open_attrs_table[j],
7331 (unsigned int)attr,
7332 attr_results[l].result_attr);
7333 correct = False;
7334 }
7335 break;
7336 }
7337 }
7338 k++;
7339 }
7340 }
7341
7342 cli_setatr(cli1, fname, 0, 0);
7343 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7344
7345 printf("open attr test %s.\n", correct ? "passed" : "failed");
7346
7347 if (!torture_close_connection(cli1)) {
7348 correct = False;
7349 }
7350 return correct;
7351 }
7352
7353 static NTSTATUS list_fn(const char *mnt, struct file_info *finfo,
7354 const char *name, void *state)
7355 {
7356 int *matched = (int *)state;
7357 if (matched != NULL) {
7358 *matched += 1;
7359 }
7360 return NT_STATUS_OK;
7361 }
7362
7363 /*
7364 test directory listing speed
7365 */
7366 static bool run_dirtest(int dummy)
7367 {
7368 int i;
7369 static struct cli_state *cli;
7370 uint16_t fnum;
7371 struct timeval core_start;
7372 bool correct = True;
7373 int matched;
7374
7375 printf("starting directory test\n");
7376
7377 if (!torture_open_connection(&cli, 0)) {
7378 return False;
7379 }
7380
7381 smbXcli_conn_set_sockopt(cli->conn, sockops);
7382
7383 srandom(0);
7384 for (i=0;i<torture_numops;i++) {
7385 fstring fname;
7386 slprintf(fname, sizeof(fname), "\\%x", (int)random());
7387 if (!NT_STATUS_IS_OK(cli_openx(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum))) {
7388 fprintf(stderr,"Failed to open %s\n", fname);
7389 return False;
7390 }
7391 cli_close(cli, fnum);
7392 }
7393
7394 core_start = timeval_current();
7395
7396 matched = 0;
7397 cli_list(cli, "a*.*", 0, list_fn, &matched);
7398 printf("Matched %d\n", matched);
7399
7400 matched = 0;
7401 cli_list(cli, "b*.*", 0, list_fn, &matched);
7402 printf("Matched %d\n", matched);
7403
7404 matched = 0;
7405 cli_list(cli, "xyzabc", 0, list_fn, &matched);
7406 printf("Matched %d\n", matched);
7407
7408 printf("dirtest core %g seconds\n", timeval_elapsed(&core_start));
7409
7410 srandom(0);
7411 for (i=0;i<torture_numops;i++) {
7412 fstring fname;
7413 slprintf(fname, sizeof(fname), "\\%x", (int)random());
7414 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7415 }
7416
7417 if (!torture_close_connection(cli)) {
7418 correct = False;
7419 }
7420
7421 printf("finished dirtest\n");
7422
7423 return correct;
7424 }
7425
7426 static NTSTATUS del_fn(const char *mnt, struct file_info *finfo, const char *mask,
7427 void *state)
7428 {
7429 struct cli_state *pcli = (struct cli_state *)state;
7430 fstring fname;
7431 slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name);
7432
7433 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
7434 return NT_STATUS_OK;
7435
7436 if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
7437 if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname)))
7438 printf("del_fn: failed to rmdir %s\n,", fname );
7439 } else {
7440 if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN)))
7441 printf("del_fn: failed to unlink %s\n,", fname );
7442 }
7443 return NT_STATUS_OK;
7444 }
7445
7446
7447 /*
7448 sees what IOCTLs are supported
7449 */
7450 bool torture_ioctl_test(int dummy)
7451 {
7452 static struct cli_state *cli;
7453 uint16_t device, function;
7454 uint16_t fnum;
7455 const char *fname = "\\ioctl.dat";
7456 DATA_BLOB blob;
7457 NTSTATUS status;
7458
7459 if (!torture_open_connection(&cli, 0)) {
7460 return False;
7461 }
7462
7463 printf("starting ioctl test\n");
7464
7465 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7466
7467 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
7468 if (!NT_STATUS_IS_OK(status)) {
7469 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
7470 return False;
7471 }
7472
7473 status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob);
7474 printf("ioctl device info: %s\n", nt_errstr(status));
7475
7476 status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob);
7477 printf("ioctl job info: %s\n", nt_errstr(status));
7478
7479 for (device=0;device<0x100;device++) {
7480 printf("ioctl test with device = 0x%x\n", device);
7481 for (function=0;function<0x100;function++) {
7482 uint32_t code = (device<<16) | function;
7483
7484 status = cli_raw_ioctl(cli, fnum, code, &blob);
7485
7486 if (NT_STATUS_IS_OK(status)) {
7487 printf("ioctl 0x%x OK : %d bytes\n", (int)code,
7488 (int)blob.length);
7489 data_blob_free(&blob);
7490 }
7491 }
7492 }
7493
7494 if (!torture_close_connection(cli)) {
7495 return False;
7496 }
7497
7498 return True;
7499 }
7500
7501
7502 /*
7503 tries varients of chkpath
7504 */
7505 bool torture_chkpath_test(int dummy)
7506 {
7507 static struct cli_state *cli;
7508 uint16_t fnum;
7509 bool ret;
7510 NTSTATUS status;
7511
7512 if (!torture_open_connection(&cli, 0)) {
7513 return False;
7514 }
7515
7516 printf("starting chkpath test\n");
7517
7518 /* cleanup from an old run */
7519 cli_rmdir(cli, "\\chkpath.dir\\dir2");
7520 cli_unlink(cli, "\\chkpath.dir\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7521 cli_rmdir(cli, "\\chkpath.dir");
7522
7523 status = cli_mkdir(cli, "\\chkpath.dir");
7524 if (!NT_STATUS_IS_OK(status)) {
7525 printf("mkdir1 failed : %s\n", nt_errstr(status));
7526 return False;
7527 }
7528
7529 status = cli_mkdir(cli, "\\chkpath.dir\\dir2");
7530 if (!NT_STATUS_IS_OK(status)) {
7531 printf("mkdir2 failed : %s\n", nt_errstr(status));
7532 return False;
7533 }
7534
7535 status = cli_openx(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL,
7536 DENY_NONE, &fnum);
7537 if (!NT_STATUS_IS_OK(status)) {
7538 printf("open1 failed (%s)\n", nt_errstr(status));
7539 return False;
7540 }
7541 cli_close(cli, fnum);
7542
7543 status = cli_chkpath(cli, "\\chkpath.dir");
7544 if (!NT_STATUS_IS_OK(status)) {
7545 printf("chkpath1 failed: %s\n", nt_errstr(status));
7546 ret = False;
7547 }
7548
7549 status = cli_chkpath(cli, "\\chkpath.dir\\dir2");
7550 if (!NT_STATUS_IS_OK(status)) {
7551 printf("chkpath2 failed: %s\n", nt_errstr(status));
7552 ret = False;
7553 }
7554
7555 status = cli_chkpath(cli, "\\chkpath.dir\\foo.txt");
7556 if (!NT_STATUS_IS_OK(status)) {
7557 ret = check_error(__LINE__, status, ERRDOS, ERRbadpath,
7558 NT_STATUS_NOT_A_DIRECTORY);
7559 } else {
7560 printf("* chkpath on a file should fail\n");
7561 ret = False;
7562 }
7563
7564 status = cli_chkpath(cli, "\\chkpath.dir\\bar.txt");
7565 if (!NT_STATUS_IS_OK(status)) {
7566 ret = check_error(__LINE__, status, ERRDOS, ERRbadfile,
7567 NT_STATUS_OBJECT_NAME_NOT_FOUND);
7568 } else {
7569 printf("* chkpath on a non existent file should fail\n");
7570 ret = False;
7571 }
7572
7573 status = cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt");
7574 if (!NT_STATUS_IS_OK(status)) {
7575 ret = check_error(__LINE__, status, ERRDOS, ERRbadpath,
7576 NT_STATUS_OBJECT_PATH_NOT_FOUND);
7577 } else {
7578 printf("* chkpath on a non existent component should fail\n");
7579 ret = False;
7580 }
7581
7582 cli_rmdir(cli, "\\chkpath.dir\\dir2");
7583 cli_unlink(cli, "\\chkpath.dir\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7584 cli_rmdir(cli, "\\chkpath.dir");
7585
7586 if (!torture_close_connection(cli)) {
7587 return False;
7588 }
7589
7590 return ret;
7591 }
7592
7593 static bool run_eatest(int dummy)
7594 {
7595 static struct cli_state *cli;
7596 const char *fname = "\\eatest.txt";
7597 bool correct = True;
7598 uint16_t fnum;
7599 int i;
7600 size_t num_eas;
7601 struct ea_struct *ea_list = NULL;
7602 TALLOC_CTX *mem_ctx = talloc_init("eatest");
7603 NTSTATUS status;
7604
7605 printf("starting eatest\n");
7606
7607 if (!torture_open_connection(&cli, 0)) {
7608 talloc_destroy(mem_ctx);
7609 return False;
7610 }
7611
7612 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7613
7614 status = cli_ntcreate(cli, fname, 0,
7615 FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
7616 FILE_SHARE_NONE, FILE_OVERWRITE_IF,
7617 0x4044, 0, &fnum, NULL);
7618 if (!NT_STATUS_IS_OK(status)) {
7619 printf("open failed - %s\n", nt_errstr(status));
7620 talloc_destroy(mem_ctx);
7621 return False;
7622 }
7623
7624 for (i = 0; i < 10; i++) {
7625 fstring ea_name, ea_val;
7626
7627 slprintf(ea_name, sizeof(ea_name), "EA_%d", i);
7628 memset(ea_val, (char)i+1, i+1);
7629 status = cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1);
7630 if (!NT_STATUS_IS_OK(status)) {
7631 printf("ea_set of name %s failed - %s\n", ea_name,
7632 nt_errstr(status));
7633 talloc_destroy(mem_ctx);
7634 return False;
7635 }
7636 }
7637
7638 cli_close(cli, fnum);
7639 for (i = 0; i < 10; i++) {
7640 fstring ea_name, ea_val;
7641
7642 slprintf(ea_name, sizeof(ea_name), "EA_%d", i+10);
7643 memset(ea_val, (char)i+1, i+1);
7644 status = cli_set_ea_path(cli, fname, ea_name, ea_val, i+1);
7645 if (!NT_STATUS_IS_OK(status)) {
7646 printf("ea_set of name %s failed - %s\n", ea_name,
7647 nt_errstr(status));
7648 talloc_destroy(mem_ctx);
7649 return False;
7650 }
7651 }
7652
7653 status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
7654 if (!NT_STATUS_IS_OK(status)) {
7655 printf("ea_get list failed - %s\n", nt_errstr(status));
7656 correct = False;
7657 }
7658
7659 printf("num_eas = %d\n", (int)num_eas);
7660
7661 if (num_eas != 20) {
7662 printf("Should be 20 EA's stored... failing.\n");
7663 correct = False;
7664 }
7665
7666 for (i = 0; i < num_eas; i++) {
7667 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
7668 dump_data(0, ea_list[i].value.data,
7669 ea_list[i].value.length);
7670 }
7671
7672 /* Setting EA's to zero length deletes them. Test this */
7673 printf("Now deleting all EA's - case indepenent....\n");
7674
7675 #if 1
7676 cli_set_ea_path(cli, fname, "", "", 0);
7677 #else
7678 for (i = 0; i < 20; i++) {
7679 fstring ea_name;
7680 slprintf(ea_name, sizeof(ea_name), "ea_%d", i);
7681 status = cli_set_ea_path(cli, fname, ea_name, "", 0);
7682 if (!NT_STATUS_IS_OK(status)) {
7683 printf("ea_set of name %s failed - %s\n", ea_name,
7684 nt_errstr(status));
7685 talloc_destroy(mem_ctx);
7686 return False;
7687 }
7688 }
7689 #endif
7690
7691 status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
7692 if (!NT_STATUS_IS_OK(status)) {
7693 printf("ea_get list failed - %s\n", nt_errstr(status));
7694 correct = False;
7695 }
7696
7697 printf("num_eas = %d\n", (int)num_eas);
7698 for (i = 0; i < num_eas; i++) {
7699 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
7700 dump_data(0, ea_list[i].value.data,
7701 ea_list[i].value.length);
7702 }
7703
7704 if (num_eas != 0) {
7705 printf("deleting EA's failed.\n");
7706 correct = False;
7707 }
7708
7709 /* Try and delete a non existent EA. */
7710 status = cli_set_ea_path(cli, fname, "foo", "", 0);
7711 if (!NT_STATUS_IS_OK(status)) {
7712 printf("deleting non-existent EA 'foo' should succeed. %s\n",
7713 nt_errstr(status));
7714 correct = False;
7715 }
7716
7717 talloc_destroy(mem_ctx);
7718 if (!torture_close_connection(cli)) {
7719 correct = False;
7720 }
7721
7722 return correct;
7723 }
7724
7725 static bool run_dirtest1(int dummy)
7726 {
7727 int i;
7728 static struct cli_state *cli;
7729 uint16_t fnum;
7730 int num_seen;
7731 bool correct = True;
7732
7733 printf("starting directory test\n");
7734
7735 if (!torture_open_connection(&cli, 0)) {
7736 return False;
7737 }
7738
7739 smbXcli_conn_set_sockopt(cli->conn, sockops);
7740
7741 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
7742 cli_list(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, del_fn, cli);
7743 cli_rmdir(cli, "\\LISTDIR");
7744 cli_mkdir(cli, "\\LISTDIR");
7745
7746 /* Create 1000 files and 1000 directories. */
7747 for (i=0;i<1000;i++) {
7748 fstring fname;
7749 slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i);
7750 if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
7751 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF,
7752 0, 0, &fnum, NULL))) {
7753 fprintf(stderr,"Failed to open %s\n", fname);
7754 return False;
7755 }
7756 cli_close(cli, fnum);
7757 }
7758 for (i=0;i<1000;i++) {
7759 fstring fname;
7760 slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i);
7761 if (!NT_STATUS_IS_OK(cli_mkdir(cli, fname))) {
7762 fprintf(stderr,"Failed to open %s\n", fname);
7763 return False;
7764 }
7765 }
7766
7767 /* Now ensure that doing an old list sees both files and directories. */
7768 num_seen = 0;
7769 cli_list_old(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
7770 printf("num_seen = %d\n", num_seen );
7771 /* We should see 100 files + 1000 directories + . and .. */
7772 if (num_seen != 2002)
7773 correct = False;
7774
7775 /* Ensure if we have the "must have" bits we only see the
7776 * relevent entries.
7777 */
7778 num_seen = 0;
7779 cli_list_old(cli, "\\LISTDIR\\*", (FILE_ATTRIBUTE_DIRECTORY<<8)|FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
7780 printf("num_seen = %d\n", num_seen );
7781 if (num_seen != 1002)
7782 correct = False;
7783
7784 num_seen = 0;
7785 cli_list_old(cli, "\\LISTDIR\\*", (FILE_ATTRIBUTE_ARCHIVE<<8)|FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
7786 printf("num_seen = %d\n", num_seen );
7787 if (num_seen != 1000)
7788 correct = False;
7789
7790 /* Delete everything. */
7791 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
7792 cli_list(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, del_fn, cli);
7793 cli_rmdir(cli, "\\LISTDIR");
7794
7795 #if 0
7796 printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
7797 printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
7798 printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
7799 #endif
7800
7801 if (!torture_close_connection(cli)) {
7802 correct = False;
7803 }
7804
7805 printf("finished dirtest1\n");
7806
7807 return correct;
7808 }
7809
7810 static bool run_error_map_extract(int dummy) {
7811
7812 static struct cli_state *c_dos;
7813 static struct cli_state *c_nt;
7814 NTSTATUS status;
7815
7816 uint32_t error;
7817
7818 uint32_t errnum;
7819 uint8_t errclass;
7820
7821 NTSTATUS nt_status;
7822
7823 fstring user;
7824
7825 /* NT-Error connection */
7826
7827 disable_spnego = true;
7828 if (!(c_nt = open_nbt_connection())) {
7829 disable_spnego = false;
7830 return False;
7831 }
7832 disable_spnego = false;
7833
7834 status = smbXcli_negprot(c_nt->conn, c_nt->timeout, PROTOCOL_CORE,
7835 PROTOCOL_NT1);
7836
7837 if (!NT_STATUS_IS_OK(status)) {
7838 printf("%s rejected the NT-error negprot (%s)\n", host,
7839 nt_errstr(status));
7840 cli_shutdown(c_nt);
7841 return False;
7842 }
7843
7844 status = cli_session_setup_anon(c_nt);
7845 if (!NT_STATUS_IS_OK(status)) {
7846 printf("%s rejected the NT-error initial session setup (%s)\n",host, nt_errstr(status));
7847 return False;
7848 }
7849
7850 /* DOS-Error connection */
7851
7852 disable_spnego = true;
7853 force_dos_errors = true;
7854 if (!(c_dos = open_nbt_connection())) {
7855 disable_spnego = false;
7856 force_dos_errors = false;
7857 return False;
7858 }
7859 disable_spnego = false;
7860 force_dos_errors = false;
7861
7862 status = smbXcli_negprot(c_dos->conn, c_dos->timeout, PROTOCOL_CORE,
7863 PROTOCOL_NT1);
7864 if (!NT_STATUS_IS_OK(status)) {
7865 printf("%s rejected the DOS-error negprot (%s)\n", host,
7866 nt_errstr(status));
7867 cli_shutdown(c_dos);
7868 return False;
7869 }
7870
7871 status = cli_session_setup_anon(c_dos);
7872 if (!NT_STATUS_IS_OK(status)) {
7873 printf("%s rejected the DOS-error initial session setup (%s)\n",
7874 host, nt_errstr(status));
7875 return False;
7876 }
7877
7878 c_nt->map_dos_errors = false;
7879 c_dos->map_dos_errors = false;
7880
7881 for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) {
7882 struct cli_credentials *user_creds = NULL;
7883
7884 fstr_sprintf(user, "%X", error);
7885
7886 user_creds = cli_session_creds_init(talloc_tos(),
7887 user,
7888 workgroup,
7889 NULL, /* realm */
7890 password,
7891 false, /* use_kerberos */
7892 false, /* fallback_after_kerberos */
7893 false, /* use_ccache */
7894 false); /* password_is_nt_hash */
7895 if (user_creds == NULL) {
7896 printf("cli_session_creds_init(%s) failed\n", user);
7897 return false;
7898 }
7899
7900 status = cli_session_setup_creds(c_nt, user_creds);
7901 if (NT_STATUS_IS_OK(status)) {
7902 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
7903 }
7904
7905 /* Case #1: 32-bit NT errors */
7906 if (!NT_STATUS_IS_DOS(status)) {
7907 nt_status = status;
7908 } else {
7909 printf("/** Dos error on NT connection! (%s) */\n",
7910 nt_errstr(status));
7911 nt_status = NT_STATUS(0xc0000000);
7912 }
7913
7914 status = cli_session_setup_creds(c_dos, user_creds);
7915 if (NT_STATUS_IS_OK(status)) {
7916 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
7917 }
7918
7919 /* Case #1: 32-bit NT errors */
7920 if (NT_STATUS_IS_DOS(status)) {
7921 printf("/** NT error on DOS connection! (%s) */\n",
7922 nt_errstr(status));
7923 errnum = errclass = 0;
7924 } else {
7925 errclass = NT_STATUS_DOS_CLASS(status);
7926 errnum = NT_STATUS_DOS_CODE(status);
7927 }
7928
7929 if (NT_STATUS_V(nt_status) != error) {
7930 printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n",
7931 get_nt_error_c_code(talloc_tos(), NT_STATUS(error)),
7932 get_nt_error_c_code(talloc_tos(), nt_status));
7933 }
7934
7935 printf("\t{%s,\t%s,\t%s},\n",
7936 smb_dos_err_class(errclass),
7937 smb_dos_err_name(errclass, errnum),
7938 get_nt_error_c_code(talloc_tos(), NT_STATUS(error)));
7939
7940 TALLOC_FREE(user_creds);
7941 }
7942 return True;
7943 }
7944
7945 static bool run_sesssetup_bench(int dummy)
7946 {
7947 static struct cli_state *c;
7948 const char *fname = "\\file.dat";
7949 uint16_t fnum;
7950 NTSTATUS status;
7951 int i;
7952
7953 if (!torture_open_connection(&c, 0)) {
7954 return false;
7955 }
7956
7957 status = cli_ntcreate(c, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
7958 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
7959 FILE_DELETE_ON_CLOSE, 0, &fnum, NULL);
7960 if (!NT_STATUS_IS_OK(status)) {
7961 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
7962 return false;
7963 }
7964
7965 for (i=0; i<torture_numops; i++) {
7966 status = cli_session_setup_creds(c, torture_creds);
7967 if (!NT_STATUS_IS_OK(status)) {
7968 d_printf("(%s) cli_session_setup_creds failed: %s\n",
7969 __location__, nt_errstr(status));
7970 return false;
7971 }
7972
7973 d_printf("\r%d ", (int)cli_state_get_uid(c));
7974
7975 status = cli_ulogoff(c);
7976 if (!NT_STATUS_IS_OK(status)) {
7977 d_printf("(%s) cli_ulogoff failed: %s\n",
7978 __location__, nt_errstr(status));
7979 return false;
7980 }
7981 }
7982
7983 return true;
7984 }
7985
7986 static bool subst_test(const char *str, const char *user, const char *domain,
7987 uid_t uid, gid_t gid, const char *expected)
7988 {
7989 char *subst;
7990 bool result = true;
7991
7992 subst = talloc_sub_specified(talloc_tos(), str, user, NULL, domain, uid, gid);
7993
7994 if (strcmp(subst, expected) != 0) {
7995 printf("sub_specified(%s, %s, %s, %d, %d) returned [%s], expected "
7996 "[%s]\n", str, user, domain, (int)uid, (int)gid, subst,
7997 expected);
7998 result = false;
7999 }
8000
8001 TALLOC_FREE(subst);
8002 return result;
8003 }
8004
8005 static void chain1_open_completion(struct tevent_req *req)
8006 {
8007 uint16_t fnum;
8008 NTSTATUS status;
8009 status = cli_openx_recv(req, &fnum);
8010 TALLOC_FREE(req);
8011
8012 d_printf("cli_openx_recv returned %s: %d\n",
8013 nt_errstr(status),
8014 NT_STATUS_IS_OK(status) ? fnum : -1);
8015 }
8016
8017 static void chain1_write_completion(struct tevent_req *req)
8018 {
8019 size_t written;
8020 NTSTATUS status;
8021 status = cli_write_andx_recv(req, &written);
8022 TALLOC_FREE(req);
8023
8024 d_printf("cli_write_andx_recv returned %s: %d\n",
8025 nt_errstr(status),
8026 NT_STATUS_IS_OK(status) ? (int)written : -1);
8027 }
8028
8029 static void chain1_close_completion(struct tevent_req *req)
8030 {
8031 NTSTATUS status;
8032 bool *done = (bool *)tevent_req_callback_data_void(req);
8033
8034 status = cli_close_recv(req);
8035 *done = true;
8036
8037 TALLOC_FREE(req);
8038
8039 d_printf("cli_close returned %s\n", nt_errstr(status));
8040 }
8041
8042 static bool run_chain1(int dummy)
8043 {
8044 struct cli_state *cli1;
8045 struct tevent_context *evt = samba_tevent_context_init(NULL);
8046 struct tevent_req *reqs[3], *smbreqs[3];
8047 bool done = false;
8048 const char *str = "foobar";
8049 NTSTATUS status;
8050
8051 printf("starting chain1 test\n");
8052 if (!torture_open_connection(&cli1, 0)) {
8053 return False;
8054 }
8055
8056 smbXcli_conn_set_sockopt(cli1->conn, sockops);
8057
8058 reqs[0] = cli_openx_create(talloc_tos(), evt, cli1, "\\test",
8059 O_CREAT|O_RDWR, 0, &smbreqs[0]);
8060 if (reqs[0] == NULL) return false;
8061 tevent_req_set_callback(reqs[0], chain1_open_completion, NULL);
8062
8063
8064 reqs[1] = cli_write_andx_create(talloc_tos(), evt, cli1, 0, 0,
8065 (const uint8_t *)str, 0, strlen(str)+1,
8066 smbreqs, 1, &smbreqs[1]);
8067 if (reqs[1] == NULL) return false;
8068 tevent_req_set_callback(reqs[1], chain1_write_completion, NULL);
8069
8070 reqs[2] = cli_smb1_close_create(talloc_tos(), evt, cli1, 0, &smbreqs[2]);
8071 if (reqs[2] == NULL) return false;
8072 tevent_req_set_callback(reqs[2], chain1_close_completion, &done);
8073
8074 status = smb1cli_req_chain_submit(smbreqs, ARRAY_SIZE(smbreqs));
8075 if (!NT_STATUS_IS_OK(status)) {
8076 return false;
8077 }
8078
8079 while (!done) {
8080 tevent_loop_once(evt);
8081 }
8082
8083 torture_close_connection(cli1);
8084 return True;
8085 }
8086
8087 static void chain2_sesssetup_completion(struct tevent_req *req)
8088 {
8089 NTSTATUS status;
8090 status = cli_session_setup_guest_recv(req);
8091 d_printf("sesssetup returned %s\n", nt_errstr(status));
8092 }
8093
8094 static void chain2_tcon_completion(struct tevent_req *req)
8095 {
8096 bool *done = (bool *)tevent_req_callback_data_void(req);
8097 NTSTATUS status;
8098 status = cli_tcon_andx_recv(req);
8099 d_printf("tcon_and_x returned %s\n", nt_errstr(status));
8100 *done = true;
8101 }
8102
8103 static bool run_chain2(int dummy)
8104 {
8105 struct cli_state *cli1;
8106 struct tevent_context *evt = samba_tevent_context_init(NULL);
8107 struct tevent_req *reqs[2], *smbreqs[2];
8108 bool done = false;
8109 NTSTATUS status;
8110 int flags = CLI_FULL_CONNECTION_FORCE_SMB1;
8111
8112 printf("starting chain2 test\n");
8113 status = cli_start_connection(&cli1, lp_netbios_name(), host, NULL,
8114 port_to_use, SMB_SIGNING_DEFAULT, flags);
8115 if (!NT_STATUS_IS_OK(status)) {
8116 return False;
8117 }
8118
8119 smbXcli_conn_set_sockopt(cli1->conn, sockops);
8120
8121 reqs[0] = cli_session_setup_guest_create(talloc_tos(), evt, cli1,
8122 &smbreqs[0]);
8123 if (reqs[0] == NULL) return false;
8124 tevent_req_set_callback(reqs[0], chain2_sesssetup_completion, NULL);
8125
8126 reqs[1] = cli_tcon_andx_create(talloc_tos(), evt, cli1, "IPC$",
8127 "?????", NULL, 0, &smbreqs[1]);
8128 if (reqs[1] == NULL) return false;
8129 tevent_req_set_callback(reqs[1], chain2_tcon_completion, &done);
8130
8131 status = smb1cli_req_chain_submit(smbreqs, ARRAY_SIZE(smbreqs));
8132 if (!NT_STATUS_IS_OK(status)) {
8133 return false;
8134 }
8135
8136 while (!done) {
8137 tevent_loop_once(evt);
8138 }
8139
8140 torture_close_connection(cli1);
8141 return True;
8142 }
8143
8144
8145 struct torture_createdel_state {
8146 struct tevent_context *ev;
8147 struct cli_state *cli;
8148 };
8149
8150 static void torture_createdel_created(struct tevent_req *subreq);
8151 static void torture_createdel_closed(struct tevent_req *subreq);
8152
8153 static struct tevent_req *torture_createdel_send(TALLOC_CTX *mem_ctx,
8154 struct tevent_context *ev,
8155 struct cli_state *cli,
8156 const char *name)
8157 {
8158 struct tevent_req *req, *subreq;
8159 struct torture_createdel_state *state;
8160
8161 req = tevent_req_create(mem_ctx, &state,
8162 struct torture_createdel_state);
8163 if (req == NULL) {
8164 return NULL;
8165 }
8166 state->ev = ev;
8167 state->cli = cli;
8168
8169 subreq = cli_ntcreate_send(
8170 state, ev, cli, name, 0,
8171 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
8172 FILE_ATTRIBUTE_NORMAL,
8173 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
8174 FILE_OPEN_IF, FILE_DELETE_ON_CLOSE, 0);
8175
8176 if (tevent_req_nomem(subreq, req)) {
8177 return tevent_req_post(req, ev);
8178 }
8179 tevent_req_set_callback(subreq, torture_createdel_created, req);
8180 return req;
8181 }
8182
8183 static void torture_createdel_created(struct tevent_req *subreq)
8184 {
8185 struct tevent_req *req = tevent_req_callback_data(
8186 subreq, struct tevent_req);
8187 struct torture_createdel_state *state = tevent_req_data(
8188 req, struct torture_createdel_state);
8189 NTSTATUS status;
8190 uint16_t fnum;
8191
8192 status = cli_ntcreate_recv(subreq, &fnum, NULL);
8193 TALLOC_FREE(subreq);
8194 if (tevent_req_nterror(req, status)) {
8195 DEBUG(10, ("cli_ntcreate_recv returned %s\n",
8196 nt_errstr(status)));
8197 return;
8198 }
8199
8200 subreq = cli_close_send(state, state->ev, state->cli, fnum);
8201 if (tevent_req_nomem(subreq, req)) {
8202 return;
8203 }
8204 tevent_req_set_callback(subreq, torture_createdel_closed, req);
8205 }
8206
8207 static void torture_createdel_closed(struct tevent_req *subreq)
8208 {
8209 struct tevent_req *req = tevent_req_callback_data(
8210 subreq, struct tevent_req);
8211 NTSTATUS status;
8212
8213 status = cli_close_recv(subreq);
8214 if (tevent_req_nterror(req, status)) {
8215 DEBUG(10, ("cli_close_recv returned %s\n", nt_errstr(status)));
8216 return;
8217 }
8218 tevent_req_done(req);
8219 }
8220
8221 static NTSTATUS torture_createdel_recv(struct tevent_req *req)
8222 {
8223 return tevent_req_simple_recv_ntstatus(req);
8224 }
8225
8226 struct torture_createdels_state {
8227 struct tevent_context *ev;
8228 struct cli_state *cli;
8229 const char *base_name;
8230 int sent;
8231 int received;
8232 int num_files;
8233 struct tevent_req **reqs;
8234 };
8235
8236 static void torture_createdels_done(struct tevent_req *subreq);
8237
8238 static struct tevent_req *torture_createdels_send(TALLOC_CTX *mem_ctx,
8239 struct tevent_context *ev,
8240 struct cli_state *cli,
8241 const char *base_name,
8242 int num_parallel,
8243 int num_files)
8244 {
8245 struct tevent_req *req;
8246 struct torture_createdels_state *state;
8247 int i;
8248
8249 req = tevent_req_create(mem_ctx, &state,
8250 struct torture_createdels_state);
8251 if (req == NULL) {
8252 return NULL;
8253 }
8254 state->ev = ev;
8255 state->cli = cli;
8256 state->base_name = talloc_strdup(state, base_name);
8257 if (tevent_req_nomem(state->base_name, req)) {
8258 return tevent_req_post(req, ev);
8259 }
8260 state->num_files = MAX(num_parallel, num_files);
8261 state->sent = 0;
8262 state->received = 0;
8263
8264 state->reqs = talloc_array(state, struct tevent_req *, num_parallel);
8265 if (tevent_req_nomem(state->reqs, req)) {
8266 return tevent_req_post(req, ev);
8267 }
8268
8269 for (i=0; i<num_parallel; i++) {
8270 char *name;
8271
8272 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
8273 state->sent);
8274 if (tevent_req_nomem(name, req)) {
8275 return tevent_req_post(req, ev);
8276 }
8277 state->reqs[i] = torture_createdel_send(
8278 state->reqs, state->ev, state->cli, name);
8279 if (tevent_req_nomem(state->reqs[i], req)) {
8280 return tevent_req_post(req, ev);
8281 }
8282 name = talloc_move(state->reqs[i], &name);
8283 tevent_req_set_callback(state->reqs[i],
8284 torture_createdels_done, req);
8285 state->sent += 1;
8286 }
8287 return req;
8288 }
8289
8290 static void torture_createdels_done(struct tevent_req *subreq)
8291 {
8292 struct tevent_req *req = tevent_req_callback_data(
8293 subreq, struct tevent_req);
8294 struct torture_createdels_state *state = tevent_req_data(
8295 req, struct torture_createdels_state);
8296 size_t num_parallel = talloc_array_length(state->reqs);
8297 NTSTATUS status;
8298 char *name;
8299 int i;
8300
8301 status = torture_createdel_recv(subreq);
8302 if (!NT_STATUS_IS_OK(status)){
8303 DEBUG(10, ("torture_createdel_recv returned %s\n",
8304 nt_errstr(status)));
8305 TALLOC_FREE(subreq);
8306 tevent_req_nterror(req, status);
8307 return;
8308 }
8309
8310 for (i=0; i<num_parallel; i++) {
8311 if (subreq == state->reqs[i]) {
8312 break;
8313 }
8314 }
8315 if (i == num_parallel) {
8316 DEBUG(10, ("received something we did not send\n"));
8317 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
8318 return;
8319 }
8320 TALLOC_FREE(state->reqs[i]);
8321
8322 if (state->sent >= state->num_files) {
8323 tevent_req_done(req);
8324 return;
8325 }
8326
8327 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
8328 state->sent);
8329 if (tevent_req_nomem(name, req)) {
8330 return;
8331 }
8332 state->reqs[i] = torture_createdel_send(state->reqs, state->ev,
8333 state->cli, name);
8334 if (tevent_req_nomem(state->reqs[i], req)) {
8335 return;
8336 }
8337 name = talloc_move(state->reqs[i], &name);
8338 tevent_req_set_callback(state->reqs[i], torture_createdels_done, req);
8339 state->sent += 1;
8340 }
8341
8342 static NTSTATUS torture_createdels_recv(struct tevent_req *req)
8343 {
8344 return tevent_req_simple_recv_ntstatus(req);
8345 }
8346
8347 struct swallow_notify_state {
8348 struct tevent_context *ev;
8349 struct cli_state *cli;
8350 uint16_t fnum;
8351 uint32_t completion_filter;
8352 bool recursive;
8353 bool (*fn)(uint32_t action, const char *name, void *priv);
8354 void *priv;
8355 };
8356
8357 static void swallow_notify_done(struct tevent_req *subreq);
8358
8359 static struct tevent_req *swallow_notify_send(TALLOC_CTX *mem_ctx,
8360 struct tevent_context *ev,
8361 struct cli_state *cli,
8362 uint16_t fnum,
8363 uint32_t completion_filter,
8364 bool recursive,
8365 bool (*fn)(uint32_t action,
8366 const char *name,
8367 void *priv),
8368 void *priv)
8369 {
8370 struct tevent_req *req, *subreq;
8371 struct swallow_notify_state *state;
8372
8373 req = tevent_req_create(mem_ctx, &state,
8374 struct swallow_notify_state);
8375 if (req == NULL) {
8376 return NULL;
8377 }
8378 state->ev = ev;
8379 state->cli = cli;
8380 state->fnum = fnum;
8381 state->completion_filter = completion_filter;
8382 state->recursive = recursive;
8383 state->fn = fn;
8384 state->priv = priv;
8385
8386 subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
8387 0xffff, state->completion_filter,
8388 state->recursive);
8389 if (tevent_req_nomem(subreq, req)) {
8390 return tevent_req_post(req, ev);
8391 }
8392 tevent_req_set_callback(subreq, swallow_notify_done, req);
8393 return req;
8394 }
8395
8396 static void swallow_notify_done(struct tevent_req *subreq)
8397 {
8398 struct tevent_req *req = tevent_req_callback_data(
8399 subreq, struct tevent_req);
8400 struct swallow_notify_state *state = tevent_req_data(
8401 req, struct swallow_notify_state);
8402 NTSTATUS status;
8403 uint32_t i, num_changes;
8404 struct notify_change *changes;
8405
8406 status = cli_notify_recv(subreq, state, &num_changes, &changes);
8407 TALLOC_FREE(subreq);
8408 if (!NT_STATUS_IS_OK(status)) {
8409 DEBUG(10, ("cli_notify_recv returned %s\n",
8410 nt_errstr(status)));
8411 tevent_req_nterror(req, status);
8412 return;
8413 }
8414
8415 for (i=0; i<num_changes; i++) {
8416 state->fn(changes[i].action, changes[i].name, state->priv);
8417 }
8418 TALLOC_FREE(changes);
8419
8420 subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
8421 0xffff, state->completion_filter,
8422 state->recursive);
8423 if (tevent_req_nomem(subreq, req)) {
8424 return;
8425 }
8426 tevent_req_set_callback(subreq, swallow_notify_done, req);
8427 }
8428
8429 static bool print_notifies(uint32_t action, const char *name, void *priv)
8430 {
8431 if (DEBUGLEVEL > 5) {
8432 d_printf("%d %s\n", (int)action, name);
8433 }
8434 return true;
8435 }
8436
8437 static void notify_bench_done(struct tevent_req *req)
8438 {
8439 int *num_finished = (int *)tevent_req_callback_data_void(req);
8440 *num_finished += 1;
8441 }
8442
8443 static bool run_notify_bench(int dummy)
8444 {
8445 const char *dname = "\\notify-bench";
8446 struct tevent_context *ev;
8447 NTSTATUS status;
8448 uint16_t dnum;
8449 struct tevent_req *req1;
8450 struct tevent_req *req2 = NULL;
8451 int i, num_unc_names;
8452 int num_finished = 0;
8453
8454 printf("starting notify-bench test\n");
8455
8456 if (use_multishare_conn) {
8457 char **unc_list;
8458 unc_list = file_lines_load(multishare_conn_fname,
8459 &num_unc_names, 0, NULL);
8460 if (!unc_list || num_unc_names <= 0) {
8461 d_printf("Failed to load unc names list from '%s'\n",
8462 multishare_conn_fname);
8463 return false;
8464 }
8465 TALLOC_FREE(unc_list);
8466 } else {
8467 num_unc_names = 1;
8468 }
8469
8470 ev = samba_tevent_context_init(talloc_tos());
8471 if (ev == NULL) {
8472 d_printf("tevent_context_init failed\n");
8473 return false;
8474 }
8475
8476 for (i=0; i<num_unc_names; i++) {
8477 struct cli_state *cli;
8478 char *base_fname;
8479
8480 base_fname = talloc_asprintf(talloc_tos(), "%s\\file%3.3d.",
8481 dname, i);
8482 if (base_fname == NULL) {
8483 return false;
8484 }
8485
8486 if (!torture_open_connection(&cli, i)) {
8487 return false;
8488 }
8489
8490 status = cli_ntcreate(cli, dname, 0,
8491 MAXIMUM_ALLOWED_ACCESS,
8492 0, FILE_SHARE_READ|FILE_SHARE_WRITE|
8493 FILE_SHARE_DELETE,
8494 FILE_OPEN_IF, FILE_DIRECTORY_FILE, 0,
8495 &dnum, NULL);
8496
8497 if (!NT_STATUS_IS_OK(status)) {
8498 d_printf("Could not create %s: %s\n", dname,
8499 nt_errstr(status));
8500 return false;
8501 }
8502
8503 req1 = swallow_notify_send(talloc_tos(), ev, cli, dnum,
8504 FILE_NOTIFY_CHANGE_FILE_NAME |
8505 FILE_NOTIFY_CHANGE_DIR_NAME |
8506 FILE_NOTIFY_CHANGE_ATTRIBUTES |
8507 FILE_NOTIFY_CHANGE_LAST_WRITE,
8508 false, print_notifies, NULL);
8509 if (req1 == NULL) {
8510 d_printf("Could not create notify request\n");
8511 return false;
8512 }
8513
8514 req2 = torture_createdels_send(talloc_tos(), ev, cli,
8515 base_fname, 10, torture_numops);
8516 if (req2 == NULL) {
8517 d_printf("Could not create createdels request\n");
8518 return false;
8519 }
8520 TALLOC_FREE(base_fname);
8521
8522 tevent_req_set_callback(req2, notify_bench_done,
8523 &num_finished);
8524 }
8525
8526 while (num_finished < num_unc_names) {
8527 int ret;
8528 ret = tevent_loop_once(ev);
8529 if (ret != 0) {
8530 d_printf("tevent_loop_once failed\n");
8531 return false;
8532 }
8533 }
8534
8535 if (!tevent_req_poll(req2, ev)) {
8536 d_printf("tevent_req_poll failed\n");
8537 }
8538
8539 status = torture_createdels_recv(req2);
8540 d_printf("torture_createdels_recv returned %s\n", nt_errstr(status));
8541
8542 return true;
8543 }
8544
8545 static bool run_mangle1(int dummy)
8546 {
8547 struct cli_state *cli;
8548 const char *fname = "this_is_a_long_fname_to_be_mangled.txt";
8549 uint16_t fnum;
8550 fstring alt_name;
8551 NTSTATUS status;
8552 time_t change_time, access_time, write_time;
8553 off_t size;
8554 uint16_t mode;
8555
8556 printf("starting mangle1 test\n");
8557 if (!torture_open_connection(&cli, 0)) {
8558 return False;
8559 }
8560
8561 smbXcli_conn_set_sockopt(cli->conn, sockops);
8562
8563 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
8564 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
8565 0, 0, &fnum, NULL);
8566 if (!NT_STATUS_IS_OK(status)) {
8567 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
8568 return false;
8569 }
8570 cli_close(cli, fnum);
8571
8572 status = cli_qpathinfo_alt_name(cli, fname, alt_name);
8573 if (!NT_STATUS_IS_OK(status)) {
8574 d_printf("cli_qpathinfo_alt_name failed: %s\n",
8575 nt_errstr(status));
8576 return false;
8577 }
8578 d_printf("alt_name: %s\n", alt_name);
8579
8580 status = cli_openx(cli, alt_name, O_RDONLY, DENY_NONE, &fnum);
8581 if (!NT_STATUS_IS_OK(status)) {
8582 d_printf("cli_openx(%s) failed: %s\n", alt_name,
8583 nt_errstr(status));
8584 return false;
8585 }
8586 cli_close(cli, fnum);
8587
8588 status = cli_qpathinfo1(cli, alt_name, &change_time, &access_time,
8589 &write_time, &size, &mode);
8590 if (!NT_STATUS_IS_OK(status)) {
8591 d_printf("cli_qpathinfo1(%s) failed: %s\n", alt_name,
8592 nt_errstr(status));
8593 return false;
8594 }
8595
8596 return true;
8597 }
8598
8599 static NTSTATUS mangle_illegal_list_shortname_fn(const char *mntpoint,
8600 struct file_info *f,
8601 const char *mask,
8602 void *state)
8603 {
8604 if (f->short_name == NULL) {
8605 return NT_STATUS_OK;
8606 }
8607
8608 if (strlen(f->short_name) == 0) {
8609 return NT_STATUS_OK;
8610 }
8611
8612 printf("unexpected shortname: %s\n", f->short_name);
8613
8614 return NT_STATUS_OBJECT_NAME_INVALID;
8615 }
8616
8617 static NTSTATUS mangle_illegal_list_name_fn(const char *mntpoint,
8618 struct file_info *f,
8619 const char *mask,
8620 void *state)
8621 {
8622 char *name = state;
8623
8624 printf("name: %s\n", f->name);
8625 fstrcpy(name, f->name);
8626 return NT_STATUS_OK;
8627 }
8628
8629 static bool run_mangle_illegal(int dummy)
8630 {
8631 struct cli_state *cli = NULL;
8632 struct cli_state *cli_posix = NULL;
8633 const char *fname = "\\MANGLE_ILLEGAL\\this_is_a_long_fname_to_be_mangled.txt";
8634 const char *illegal_fname = "MANGLE_ILLEGAL/foo:bar";
8635 char *mangled_path = NULL;
8636 uint16_t fnum;
8637 fstring name;
8638 fstring alt_name;
8639 NTSTATUS status;
8640
8641 printf("starting mangle-illegal test\n");
8642
8643 if (!torture_open_connection(&cli, 0)) {
8644 return False;
8645 }
8646
8647 smbXcli_conn_set_sockopt(cli->conn, sockops);
8648
8649 if (!torture_open_connection(&cli_posix, 0)) {
8650 return false;
8651 }
8652
8653 smbXcli_conn_set_sockopt(cli_posix->conn, sockops);
8654
8655 status = torture_setup_unix_extensions(cli_posix);
8656 if (!NT_STATUS_IS_OK(status)) {
8657 return false;
8658 }
8659
8660 cli_rmdir(cli, "\\MANGLE_ILLEGAL");
8661 status = cli_mkdir(cli, "\\MANGLE_ILLEGAL");
8662 if (!NT_STATUS_IS_OK(status)) {
8663 printf("mkdir1 failed : %s\n", nt_errstr(status));
8664 return False;
8665 }
8666
8667 /*
8668 * Create a file with illegal NTFS characters and test that we
8669 * get a usable mangled name
8670 */
8671
8672 cli_setatr(cli_posix, illegal_fname, 0, 0);
8673 cli_posix_unlink(cli_posix, illegal_fname);
8674
8675 status = cli_posix_open(cli_posix, illegal_fname, O_RDWR|O_CREAT|O_EXCL,
8676 0600, &fnum);
8677 if (!NT_STATUS_IS_OK(status)) {
8678 printf("POSIX create of %s failed (%s)\n",
8679 illegal_fname, nt_errstr(status));
8680 return false;
8681 }
8682
8683 status = cli_close(cli_posix, fnum);
8684 if (!NT_STATUS_IS_OK(status)) {
8685 printf("close failed (%s)\n", nt_errstr(status));
8686 return false;
8687 }
8688
8689 status = cli_list(cli, "\\MANGLE_ILLEGAL\\*", 0, mangle_illegal_list_name_fn, &name);
8690 if (!NT_STATUS_IS_OK(status)) {
8691 d_printf("cli_list failed: %s\n", nt_errstr(status));
8692 return false;
8693 }
8694
8695 mangled_path = talloc_asprintf(talloc_tos(), "\\MANGLE_ILLEGAL\\%s", name);
8696 if (mangled_path == NULL) {
8697 return false;
8698 }
8699
8700 status = cli_openx(cli, mangled_path, O_RDONLY, DENY_NONE, &fnum);
8701 if (!NT_STATUS_IS_OK(status)) {
8702 d_printf("cli_openx(%s) failed: %s\n", mangled_path, nt_errstr(status));
8703 TALLOC_FREE(mangled_path);
8704 return false;
8705 }
8706 TALLOC_FREE(mangled_path);
8707 cli_close(cli, fnum);
8708
8709 cli_setatr(cli_posix, illegal_fname, 0, 0);
8710 cli_posix_unlink(cli_posix, illegal_fname);
8711
8712 /*
8713 * Create a file with a long name and check that we got *no* short name.
8714 */
8715
8716 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
8717 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
8718 0, 0, &fnum, NULL);
8719 if (!NT_STATUS_IS_OK(status)) {
8720 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
8721 return false;
8722 }
8723 cli_close(cli, fnum);
8724
8725 status = cli_list(cli, fname, 0, mangle_illegal_list_shortname_fn, &alt_name);
8726 if (!NT_STATUS_IS_OK(status)) {
8727 d_printf("cli_list failed\n");
8728 return false;
8729 }
8730
8731 cli_unlink(cli, fname, 0);
8732 cli_rmdir(cli, "\\MANGLE_ILLEGAL");
8733
8734 if (!torture_close_connection(cli_posix)) {
8735 return false;
8736 }
8737
8738 if (!torture_close_connection(cli)) {
8739 return false;
8740 }
8741
8742 return true;
8743 }
8744
8745 static size_t null_source(uint8_t *buf, size_t n, void *priv)
8746 {
8747 size_t *to_pull = (size_t *)priv;
8748 size_t thistime = *to_pull;
8749
8750 thistime = MIN(thistime, n);
8751 if (thistime == 0) {
8752 return 0;
8753 }
8754
8755 memset(buf, 0, thistime);
8756 *to_pull -= thistime;
8757 return thistime;
8758 }
8759
8760 static bool run_windows_write(int dummy)
8761 {
8762 struct cli_state *cli1;
8763 uint16_t fnum;
8764 int i;
8765 bool ret = false;
8766 const char *fname = "\\writetest.txt";
8767 struct timeval start_time;
8768 double seconds;
8769 double kbytes;
8770 NTSTATUS status;
8771
8772 printf("starting windows_write test\n");
8773 if (!torture_open_connection(&cli1, 0)) {
8774 return False;
8775 }
8776
8777 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
8778 if (!NT_STATUS_IS_OK(status)) {
8779 printf("open failed (%s)\n", nt_errstr(status));
8780 return False;
8781 }
8782
8783 smbXcli_conn_set_sockopt(cli1->conn, sockops);
8784
8785 start_time = timeval_current();
8786
8787 for (i=0; i<torture_numops; i++) {
8788 uint8_t c = 0;
8789 off_t start = i * torture_blocksize;
8790 size_t to_pull = torture_blocksize - 1;
8791
8792 status = cli_writeall(cli1, fnum, 0, &c,
8793 start + torture_blocksize - 1, 1, NULL);
8794 if (!NT_STATUS_IS_OK(status)) {
8795 printf("cli_write failed: %s\n", nt_errstr(status));
8796 goto fail;
8797 }
8798
8799 status = cli_push(cli1, fnum, 0, i * torture_blocksize, torture_blocksize,
8800 null_source, &to_pull);
8801 if (!NT_STATUS_IS_OK(status)) {
8802 printf("cli_push returned: %s\n", nt_errstr(status));
8803 goto fail;
8804 }
8805 }
8806
8807 seconds = timeval_elapsed(&start_time);
8808 kbytes = (double)torture_blocksize * torture_numops;
8809 kbytes /= 1024;
8810
8811 printf("Wrote %d kbytes in %.2f seconds: %d kb/sec\n", (int)kbytes,
8812 (double)seconds, (int)(kbytes/seconds));
8813
8814 ret = true;
8815 fail:
8816 cli_close(cli1, fnum);
8817 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
8818 torture_close_connection(cli1);
8819 return ret;
8820 }
8821
8822 static size_t calc_expected_return(struct cli_state *cli, size_t len_requested)
8823 {
8824 size_t max_pdu = 0x1FFFF;
8825
8826 if (cli->server_posix_capabilities & CIFS_UNIX_LARGE_READ_CAP) {
8827 max_pdu = 0xFFFFFF;
8828 }
8829
8830 if (smb1cli_conn_signing_is_active(cli->conn)) {
8831 max_pdu = 0x1FFFF;
8832 }
8833
8834 if (smb1cli_conn_encryption_on(cli->conn)) {
8835 max_pdu = CLI_BUFFER_SIZE;
8836 }
8837
8838 if ((len_requested & 0xFFFF0000) == 0xFFFF0000) {
8839 len_requested &= 0xFFFF;
8840 }
8841
8842 return MIN(len_requested,
8843 max_pdu - (MIN_SMB_SIZE + VWV(12) + 1 /* padding byte */));
8844 }
8845
8846 static bool check_read_call(struct cli_state *cli,
8847 uint16_t fnum,
8848 uint8_t *buf,
8849 size_t len_requested)
8850 {
8851 NTSTATUS status;
8852 struct tevent_req *subreq = NULL;
8853 ssize_t len_read = 0;
8854 size_t len_expected = 0;
8855 struct tevent_context *ev = NULL;
8856
8857 ev = samba_tevent_context_init(talloc_tos());
8858 if (ev == NULL) {
8859 return false;
8860 }
8861
8862 subreq = cli_read_andx_send(talloc_tos(),
8863 ev,
8864 cli,
8865 fnum,
8866 0,
8867 len_requested);
8868
8869 if (!tevent_req_poll_ntstatus(subreq, ev, &status)) {
8870 return false;
8871 }
8872
8873 status = cli_read_andx_recv(subreq, &len_read, &buf);
8874 if (!NT_STATUS_IS_OK(status)) {
8875 d_printf("cli_read_andx_recv failed: %s\n", nt_errstr(status));
8876 return false;
8877 }
8878
8879 TALLOC_FREE(subreq);
8880 TALLOC_FREE(ev);
8881
8882 len_expected = calc_expected_return(cli, len_requested);
8883
8884 if (len_expected > 0x10000 && len_read == 0x10000) {
8885 /* Windows servers only return a max of 0x10000,
8886 doesn't matter if you set CAP_LARGE_READX in
8887 the client sessionsetupX call or not. */
8888 d_printf("Windows server - returned 0x10000 on a read of 0x%x\n",
8889 (unsigned int)len_requested);
8890 } else if (len_read != len_expected) {
8891 d_printf("read of 0x%x failed: got 0x%x, expected 0x%x\n",
8892 (unsigned int)len_requested,
8893 (unsigned int)len_read,
8894 (unsigned int)len_expected);
8895 return false;
8896 } else {
8897 d_printf("Correct read reply.\n");
8898 }
8899
8900 return true;
8901 }
8902
8903 /* Test large readX variants. */
8904 static bool large_readx_tests(struct cli_state *cli,
8905 uint16_t fnum,
8906 uint8_t *buf)
8907 {
8908 /* A read of 0xFFFF0001 should *always* return 1 byte. */
8909 if (check_read_call(cli, fnum, buf, 0xFFFF0001) == false) {
8910 return false;
8911 }
8912 /* A read of 0x10000 should return 0x10000 bytes. */
8913 if (check_read_call(cli, fnum, buf, 0x10000) == false) {
8914 return false;
8915 }
8916 /* A read of 0x10000 should return 0x10001 bytes. */
8917 if (check_read_call(cli, fnum, buf, 0x10001) == false) {
8918 return false;
8919 }
8920 /* A read of 0x1FFFF - (MIN_SMB_SIZE + VWV(12) should return
8921 the requested number of bytes. */
8922 if (check_read_call(cli, fnum, buf, 0x1FFFF - (MIN_SMB_SIZE + VWV(12))) == false) {
8923 return false;
8924 }
8925 /* A read of 1MB should return 1MB bytes (on Samba). */
8926 if (check_read_call(cli, fnum, buf, 0x100000) == false) {
8927 return false;
8928 }
8929
8930 if (check_read_call(cli, fnum, buf, 0x20001) == false) {
8931 return false;
8932 }
8933 if (check_read_call(cli, fnum, buf, 0x22000001) == false) {
8934 return false;
8935 }
8936 if (check_read_call(cli, fnum, buf, 0xFFFE0001) == false) {
8937 return false;
8938 }
8939 return true;
8940 }
8941
8942 static bool run_large_readx(int dummy)
8943 {
8944 uint8_t *buf = NULL;
8945 struct cli_state *cli1 = NULL;
8946 struct cli_state *cli2 = NULL;
8947 bool correct = false;
8948 const char *fname = "\\large_readx.dat";
8949 NTSTATUS status;
8950 uint16_t fnum1 = UINT16_MAX;
8951 uint32_t normal_caps = 0;
8952 size_t file_size = 20*1024*1024;
8953 TALLOC_CTX *frame = talloc_stackframe();
8954 size_t i;
8955 struct {
8956 const char *name;
8957 enum smb_signing_setting signing_setting;
8958 enum protocol_types protocol;
8959 } runs[] = {
8960 {
8961 .name = "NT1",
8962 .signing_setting = SMB_SIGNING_IF_REQUIRED,
8963 .protocol = PROTOCOL_NT1,
8964 },{
8965 .name = "NT1 - SIGNING_REQUIRED",
8966 .signing_setting = SMB_SIGNING_REQUIRED,
8967 .protocol = PROTOCOL_NT1,
8968 },
8969 };
8970
8971 printf("starting large_readx test\n");
8972
8973 if (!torture_open_connection(&cli1, 0)) {
8974 goto out;
8975 }
8976
8977 normal_caps = smb1cli_conn_capabilities(cli1->conn);
8978
8979 if (!(normal_caps & CAP_LARGE_READX)) {
8980 d_printf("Server doesn't have CAP_LARGE_READX 0x%x\n",
8981 (unsigned int)normal_caps);
8982 goto out;
8983 }
8984
8985 /* Create a file of size 4MB. */
8986 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
8987 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
8988 0, 0, &fnum1, NULL);
8989
8990 if (!NT_STATUS_IS_OK(status)) {
8991 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
8992 goto out;
8993 }
8994
8995 /* Write file_size bytes. */
8996 buf = talloc_zero_array(frame, uint8_t, file_size);
8997 if (buf == NULL) {
8998 goto out;
8999 }
9000
9001 status = cli_writeall(cli1,
9002 fnum1,
9003 0,
9004 buf,
9005 0,
9006 file_size,
9007 NULL);
9008 if (!NT_STATUS_IS_OK(status)) {
9009 d_printf("cli_writeall failed: %s\n", nt_errstr(status));
9010 goto out;
9011 }
9012
9013 status = cli_close(cli1, fnum1);
9014 if (!NT_STATUS_IS_OK(status)) {
9015 d_printf("cli_close failed: %s\n", nt_errstr(status));
9016 goto out;
9017 }
9018
9019 fnum1 = UINT16_MAX;
9020
9021 for (i=0; i < ARRAY_SIZE(runs); i++) {
9022 enum smb_signing_setting saved_signing_setting = signing_state;
9023 uint16_t fnum2 = -1;
9024
9025 if (do_encrypt &&
9026 (runs[i].signing_setting == SMB_SIGNING_REQUIRED))
9027 {
9028 d_printf("skip[%u] - %s\n", (unsigned)i, runs[i].name);
9029 continue;
9030 }
9031
9032 d_printf("run[%u] - %s\n", (unsigned)i, runs[i].name);
9033
9034 signing_state = runs[i].signing_setting;
9035 cli2 = open_nbt_connection();
9036 signing_state = saved_signing_setting;
9037 if (cli2 == NULL) {
9038 goto out;
9039 }
9040
9041 status = smbXcli_negprot(cli2->conn,
9042 cli2->timeout,
9043 runs[i].protocol,
9044 runs[i].protocol);
9045 if (!NT_STATUS_IS_OK(status)) {
9046 goto out;
9047 }
9048
9049 status = cli_session_setup_creds(cli2, torture_creds);
9050 if (!NT_STATUS_IS_OK(status)) {
9051 goto out;
9052 }
9053
9054 status = cli_tree_connect(cli2,
9055 share,
9056 "?????",
9057 password);
9058 if (!NT_STATUS_IS_OK(status)) {
9059 goto out;
9060 }
9061
9062 cli_set_timeout(cli2, 120000); /* set a really long timeout (2 minutes) */
9063
9064 normal_caps = smb1cli_conn_capabilities(cli2->conn);
9065
9066 if (!(normal_caps & CAP_LARGE_READX)) {
9067 d_printf("Server doesn't have CAP_LARGE_READX 0x%x\n",
9068 (unsigned int)normal_caps);
9069 goto out;
9070 }
9071
9072 if (do_encrypt) {
9073 if (force_cli_encryption(cli2, share) == false) {
9074 goto out;
9075 }
9076 } else if (SERVER_HAS_UNIX_CIFS(cli2)) {
9077 uint16_t major, minor;
9078 uint32_t caplow, caphigh;
9079
9080 status = cli_unix_extensions_version(cli2,
9081 &major, &minor,
9082 &caplow, &caphigh);
9083 if (!NT_STATUS_IS_OK(status)) {
9084 goto out;
9085 }
9086 }
9087
9088 status = cli_ntcreate(cli2, fname, 0, FILE_READ_DATA,
9089 FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN,
9090 0, 0, &fnum2, NULL);
9091 if (!NT_STATUS_IS_OK(status)) {
9092 d_printf("Second open %s failed: %s\n", fname, nt_errstr(status));
9093 goto out;
9094 }
9095
9096 /* All reads must return less than file_size bytes. */
9097 if (!large_readx_tests(cli2, fnum2, buf)) {
9098 goto out;
9099 }
9100
9101 status = cli_close(cli2, fnum2);
9102 if (!NT_STATUS_IS_OK(status)) {
9103 d_printf("cli_close failed: %s\n", nt_errstr(status));
9104 goto out;
9105 }
9106 fnum2 = -1;
9107
9108 if (!torture_close_connection(cli2)) {
9109 goto out;
9110 }
9111 cli2 = NULL;
9112 }
9113
9114 correct = true;
9115 printf("Success on large_readx test\n");
9116
9117 out:
9118
9119 if (cli2) {
9120 if (!torture_close_connection(cli2)) {
9121 correct = false;
9122 }
9123 }
9124
9125 if (cli1) {
9126 if (fnum1 != UINT16_MAX) {
9127 status = cli_close(cli1, fnum1);
9128 if (!NT_STATUS_IS_OK(status)) {
9129 d_printf("cli_close failed: %s\n", nt_errstr(status));
9130 }
9131 fnum1 = UINT16_MAX;
9132 }
9133
9134 status = cli_unlink(cli1, fname,
9135 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
9136 if (!NT_STATUS_IS_OK(status)) {
9137 printf("unlink failed (%s)\n", nt_errstr(status));
9138 }
9139
9140 if (!torture_close_connection(cli1)) {
9141 correct = false;
9142 }
9143 }
9144
9145 TALLOC_FREE(frame);
9146
9147 printf("finished large_readx test\n");
9148 return correct;
9149 }
9150
9151 static bool run_cli_echo(int dummy)
9152 {
9153 struct cli_state *cli;
9154 NTSTATUS status;
9155
9156 printf("starting cli_echo test\n");
9157 if (!torture_open_connection(&cli, 0)) {
9158 return false;
9159 }
9160 smbXcli_conn_set_sockopt(cli->conn, sockops);
9161
9162 status = cli_echo(cli, 5, data_blob_const("hello", 5));
9163
9164 d_printf("cli_echo returned %s\n", nt_errstr(status));
9165
9166 torture_close_connection(cli);
9167 return NT_STATUS_IS_OK(status);
9168 }
9169
9170 static bool run_uid_regression_test(int dummy)
9171 {
9172 static struct cli_state *cli;
9173 int16_t old_vuid;
9174 int32_t old_cnum;
9175 bool correct = True;
9176 struct smbXcli_tcon *orig_tcon = NULL;
9177 NTSTATUS status;
9178
9179 printf("starting uid regression test\n");
9180
9181 if (!torture_open_connection(&cli, 0)) {
9182 return False;
9183 }
9184
9185 smbXcli_conn_set_sockopt(cli->conn, sockops);
9186
9187 /* Ok - now save then logoff our current user. */
9188 old_vuid = cli_state_get_uid(cli);
9189
9190 status = cli_ulogoff(cli);
9191 if (!NT_STATUS_IS_OK(status)) {
9192 d_printf("(%s) cli_ulogoff failed: %s\n",
9193 __location__, nt_errstr(status));
9194 correct = false;
9195 goto out;
9196 }
9197
9198 cli_state_set_uid(cli, old_vuid);
9199
9200 /* Try an operation. */
9201 status = cli_mkdir(cli, "\\uid_reg_test");
9202 if (NT_STATUS_IS_OK(status)) {
9203 d_printf("(%s) cli_mkdir succeeded\n",
9204 __location__);
9205 correct = false;
9206 goto out;
9207 } else {
9208 /* Should be bad uid. */
9209 if (!check_error(__LINE__, status, ERRSRV, ERRbaduid,
9210 NT_STATUS_USER_SESSION_DELETED)) {
9211 correct = false;
9212 goto out;
9213 }
9214 }
9215
9216 old_cnum = cli_state_get_tid(cli);
9217 orig_tcon = cli_state_save_tcon(cli);
9218 if (orig_tcon == NULL) {
9219 correct = false;
9220 goto out;
9221 }
9222
9223 /* Now try a SMBtdis with the invald vuid set to zero. */
9224 cli_state_set_uid(cli, 0);
9225
9226 /* This should succeed. */
9227 status = cli_tdis(cli);
9228
9229 if (NT_STATUS_IS_OK(status)) {
9230 d_printf("First tdis with invalid vuid should succeed.\n");
9231 } else {
9232 d_printf("First tdis failed (%s)\n", nt_errstr(status));
9233 correct = false;
9234 cli_state_restore_tcon(cli, orig_tcon);
9235 goto out;
9236 }
9237
9238 cli_state_restore_tcon(cli, orig_tcon);
9239 cli_state_set_uid(cli, old_vuid);
9240 cli_state_set_tid(cli, old_cnum);
9241
9242 /* This should fail. */
9243 status = cli_tdis(cli);
9244 if (NT_STATUS_IS_OK(status)) {
9245 d_printf("Second tdis with invalid vuid should fail - succeeded instead !.\n");
9246 correct = false;
9247 goto out;
9248 } else {
9249 /* Should be bad tid. */
9250 if (!check_error(__LINE__, status, ERRSRV, ERRinvnid,
9251 NT_STATUS_NETWORK_NAME_DELETED)) {
9252 correct = false;
9253 goto out;
9254 }
9255 }
9256
9257 cli_rmdir(cli, "\\uid_reg_test");
9258
9259 out:
9260
9261 cli_shutdown(cli);
9262 return correct;
9263 }
9264
9265
9266 static const char *illegal_chars = "*\\/?<>|\":";
9267 static char force_shortname_chars[] = " +,.[];=\177";
9268
9269 static NTSTATUS shortname_del_fn(const char *mnt, struct file_info *finfo,
9270 const char *mask, void *state)
9271 {
9272 struct cli_state *pcli = (struct cli_state *)state;
9273 fstring fname;
9274 NTSTATUS status = NT_STATUS_OK;
9275
9276 slprintf(fname, sizeof(fname), "\\shortname\\%s", finfo->name);
9277
9278 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
9279 return NT_STATUS_OK;
9280
9281 if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
9282 status = cli_rmdir(pcli, fname);
9283 if (!NT_STATUS_IS_OK(status)) {
9284 printf("del_fn: failed to rmdir %s\n,", fname );
9285 }
9286 } else {
9287 status = cli_unlink(pcli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
9288 if (!NT_STATUS_IS_OK(status)) {
9289 printf("del_fn: failed to unlink %s\n,", fname );
9290 }
9291 }
9292 return status;
9293 }
9294
9295 struct sn_state {
9296 int matched;
9297 int i;
9298 bool val;
9299 };
9300
9301 static NTSTATUS shortname_list_fn(const char *mnt, struct file_info *finfo,
9302 const char *name, void *state)
9303 {
9304 struct sn_state *s = (struct sn_state *)state;
9305 int i = s->i;
9306
9307 #if 0
9308 printf("shortname list: i = %d, name = |%s|, shortname = |%s|\n",
9309 i, finfo->name, finfo->short_name);
9310 #endif
9311
9312 if (strchr(force_shortname_chars, i)) {
9313 if (!finfo->short_name) {
9314 /* Shortname not created when it should be. */
9315 d_printf("(%s) ERROR: Shortname was not created for file %s containing %d\n",
9316 __location__, finfo->name, i);
9317 s->val = true;
9318 }
9319 } else if (finfo->short_name){
9320 /* Shortname created when it should not be. */
9321 d_printf("(%s) ERROR: Shortname %s was created for file %s\n",
9322 __location__, finfo->short_name, finfo->name);
9323 s->val = true;
9324 }
9325 s->matched += 1;
9326 return NT_STATUS_OK;
9327 }
9328
9329 static bool run_shortname_test(int dummy)
9330 {
9331 static struct cli_state *cli;
9332 bool correct = True;
9333 int i;
9334 struct sn_state s;
9335 char fname[40];
9336 NTSTATUS status;
9337
9338 printf("starting shortname test\n");
9339
9340 if (!torture_open_connection(&cli, 0)) {
9341 return False;
9342 }
9343
9344 smbXcli_conn_set_sockopt(cli->conn, sockops);
9345
9346 cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
9347 cli_list(cli, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY, shortname_del_fn, cli);
9348 cli_rmdir(cli, "\\shortname");
9349
9350 status = cli_mkdir(cli, "\\shortname");
9351 if (!NT_STATUS_IS_OK(status)) {
9352 d_printf("(%s) cli_mkdir of \\shortname failed: %s\n",
9353 __location__, nt_errstr(status));
9354 correct = false;
9355 goto out;
9356 }
9357
9358 if (strlcpy(fname, "\\shortname\\", sizeof(fname)) >= sizeof(fname)) {
9359 correct = false;
9360 goto out;
9361 }
9362 if (strlcat(fname, "test .txt", sizeof(fname)) >= sizeof(fname)) {
9363 correct = false;
9364 goto out;
9365 }
9366
9367 s.val = false;
9368
9369 for (i = 32; i < 128; i++) {
9370 uint16_t fnum = (uint16_t)-1;
9371
9372 s.i = i;
9373
9374 if (strchr(illegal_chars, i)) {
9375 continue;
9376 }
9377 fname[15] = i;
9378
9379 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
9380 FILE_SHARE_READ|FILE_SHARE_WRITE,
9381 FILE_OVERWRITE_IF, 0, 0, &fnum, NULL);
9382 if (!NT_STATUS_IS_OK(status)) {
9383 d_printf("(%s) cli_nt_create of %s failed: %s\n",
9384 __location__, fname, nt_errstr(status));
9385 correct = false;
9386 goto out;
9387 }
9388 cli_close(cli, fnum);
9389
9390 s.matched = 0;
9391 status = cli_list(cli, "\\shortname\\test*.*", 0,
9392 shortname_list_fn, &s);
9393 if (s.matched != 1) {
9394 d_printf("(%s) failed to list %s: %s\n",
9395 __location__, fname, nt_errstr(status));
9396 correct = false;
9397 goto out;
9398 }
9399
9400 status = cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
9401 if (!NT_STATUS_IS_OK(status)) {
9402 d_printf("(%s) failed to delete %s: %s\n",
9403 __location__, fname, nt_errstr(status));
9404 correct = false;
9405 goto out;
9406 }
9407
9408 if (s.val) {
9409 correct = false;
9410 goto out;
9411 }
9412 }
9413
9414 out:
9415
9416 cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
9417 cli_list(cli, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY, shortname_del_fn, cli);
9418 cli_rmdir(cli, "\\shortname");
9419 torture_close_connection(cli);
9420 return correct;
9421 }
9422
9423 static void pagedsearch_cb(struct tevent_req *req)
9424 {
9425 TLDAPRC rc;
9426 struct tldap_message *msg;
9427 char *dn;
9428
9429 rc = tldap_search_paged_recv(req, talloc_tos(), &msg);
9430 if (!TLDAP_RC_IS_SUCCESS(rc)) {
9431 d_printf("tldap_search_paged_recv failed: %s\n",
9432 tldap_rc2string(rc));
9433 return;
9434 }
9435 if (tldap_msg_type(msg) != TLDAP_RES_SEARCH_ENTRY) {
9436 TALLOC_FREE(msg);
9437 return;
9438 }
9439 if (!tldap_entry_dn(msg, &dn)) {
9440 d_printf("tldap_entry_dn failed\n");
9441 return;
9442 }
9443 d_printf("%s\n", dn);
9444 TALLOC_FREE(msg);
9445 }
9446
9447 static bool run_tldap(int dummy)
9448 {
9449 struct tldap_context *ld;
9450 int fd;
9451 TLDAPRC rc;
9452 NTSTATUS status;
9453 struct sockaddr_storage addr;
9454 struct tevent_context *ev;
9455 struct tevent_req *req;
9456 char *basedn;
9457 const char *filter;
9458
9459 if (!resolve_name(host, &addr, 0, false)) {
9460 d_printf("could not find host %s\n", host);
9461 return false;
9462 }
9463 status = open_socket_out(&addr, 389, 9999, &fd);
9464 if (!NT_STATUS_IS_OK(status)) {
9465 d_printf("open_socket_out failed: %s\n", nt_errstr(status));
9466 return false;
9467 }
9468
9469 ld = tldap_context_create(talloc_tos(), fd);
9470 if (ld == NULL) {
9471 close(fd);
9472 d_printf("tldap_context_create failed\n");
9473 return false;
9474 }
9475
9476 rc = tldap_fetch_rootdse(ld);
9477 if (!TLDAP_RC_IS_SUCCESS(rc)) {
9478 d_printf("tldap_fetch_rootdse failed: %s\n",
9479 tldap_errstr(talloc_tos(), ld, rc));
9480 return false;
9481 }
9482
9483 basedn = tldap_talloc_single_attribute(
9484 tldap_rootdse(ld), "defaultNamingContext", talloc_tos());
9485 if (basedn == NULL) {
9486 d_printf("no defaultNamingContext\n");
9487 return false;
9488 }
9489 d_printf("defaultNamingContext: %s\n", basedn);
9490
9491 ev = samba_tevent_context_init(talloc_tos());
9492 if (ev == NULL) {
9493 d_printf("tevent_context_init failed\n");
9494 return false;
9495 }
9496
9497 req = tldap_search_paged_send(talloc_tos(), ev, ld, basedn,
9498 TLDAP_SCOPE_SUB, "(objectclass=*)",
9499 NULL, 0, 0,
9500 NULL, 0, NULL, 0, 0, 0, 0, 5);
9501 if (req == NULL) {
9502 d_printf("tldap_search_paged_send failed\n");
9503 return false;
9504 }
9505 tevent_req_set_callback(req, pagedsearch_cb, NULL);
9506
9507 tevent_req_poll(req, ev);
9508
9509 TALLOC_FREE(req);
9510
9511 /* test search filters against rootDSE */
9512 filter = "(&(|(name=samba)(nextRid<=10000000)(usnChanged>=10)(samba~=ambas)(!(name=s*m*a)))"
9513 "(|(name:=samba)(name:dn:2.5.13.5:=samba)(:dn:2.5.13.5:=samba)(!(name=*samba))))";
9514
9515 rc = tldap_search(ld, "", TLDAP_SCOPE_BASE, filter,
9516 NULL, 0, 0, NULL, 0, NULL, 0, 0, 0, 0,
9517 talloc_tos(), NULL);
9518 if (!TLDAP_RC_IS_SUCCESS(rc)) {
9519 d_printf("tldap_search with complex filter failed: %s\n",
9520 tldap_errstr(talloc_tos(), ld, rc));
9521 return false;
9522 }
9523
9524 TALLOC_FREE(ld);
9525 return true;
9526 }
9527
9528 /* Torture test to ensure no regression of :
9529 https://bugzilla.samba.org/show_bug.cgi?id=7084
9530 */
9531
9532 static bool run_dir_createtime(int dummy)
9533 {
9534 struct cli_state *cli;
9535 const char *dname = "\\testdir";
9536 const char *fname = "\\testdir\\testfile";
9537 NTSTATUS status;
9538 struct timespec create_time;
9539 struct timespec create_time1;
9540 uint16_t fnum;
9541 bool ret = false;
9542
9543 if (!torture_open_connection(&cli, 0)) {
9544 return false;
9545 }
9546
9547 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
9548 cli_rmdir(cli, dname);
9549
9550 status = cli_mkdir(cli, dname);
9551 if (!NT_STATUS_IS_OK(status)) {
9552 printf("mkdir failed: %s\n", nt_errstr(status));
9553 goto out;
9554 }
9555
9556 status = cli_qpathinfo2(cli, dname, &create_time, NULL, NULL, NULL,
9557 NULL, NULL, NULL);
9558 if (!NT_STATUS_IS_OK(status)) {
9559 printf("cli_qpathinfo2 returned %s\n",
9560 nt_errstr(status));
9561 goto out;
9562 }
9563
9564 /* Sleep 3 seconds, then create a file. */
9565 sleep(3);
9566
9567 status = cli_openx(cli, fname, O_RDWR | O_CREAT | O_EXCL,
9568 DENY_NONE, &fnum);
9569 if (!NT_STATUS_IS_OK(status)) {
9570 printf("cli_openx failed: %s\n", nt_errstr(status));
9571 goto out;
9572 }
9573
9574 status = cli_qpathinfo2(cli, dname, &create_time1, NULL, NULL, NULL,
9575 NULL, NULL, NULL);
9576 if (!NT_STATUS_IS_OK(status)) {
9577 printf("cli_qpathinfo2 (2) returned %s\n",
9578 nt_errstr(status));
9579 goto out;
9580 }
9581
9582 if (timespec_compare(&create_time1, &create_time)) {
9583 printf("run_dir_createtime: create time was updated (error)\n");
9584 } else {
9585 printf("run_dir_createtime: create time was not updated (correct)\n");
9586 ret = true;
9587 }
9588
9589 out:
9590
9591 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
9592 cli_rmdir(cli, dname);
9593 if (!torture_close_connection(cli)) {
9594 ret = false;
9595 }
9596 return ret;
9597 }
9598
9599
9600 static bool run_streamerror(int dummy)
9601 {
9602 struct cli_state *cli;
9603 const char *dname = "\\testdir";
9604 const char *streamname =
9605 "testdir:{4c8cc155-6c1e-11d1-8e41-00c04fb9386d}:$DATA";
9606 NTSTATUS status;
9607 time_t change_time, access_time, write_time;
9608 off_t size;
9609 uint16_t mode, fnum;
9610 bool ret = true;
9611
9612 if (!torture_open_connection(&cli, 0)) {
9613 return false;
9614 }
9615
9616 cli_unlink(cli, "\\testdir\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
9617 cli_rmdir(cli, dname);
9618
9619 status = cli_mkdir(cli, dname);
9620 if (!NT_STATUS_IS_OK(status)) {
9621 printf("mkdir failed: %s\n", nt_errstr(status));
9622 return false;
9623 }
9624
9625 status = cli_qpathinfo1(cli, streamname, &change_time, &access_time,
9626 &write_time, &size, &mode);
9627 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
9628 printf("pathinfo returned %s, expected "
9629 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
9630 nt_errstr(status));
9631 ret = false;
9632 }
9633
9634 status = cli_ntcreate(cli, streamname, 0x16,
9635 FILE_READ_DATA|FILE_READ_EA|
9636 FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS,
9637 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
9638 FILE_OPEN, 0, 0, &fnum, NULL);
9639
9640 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
9641 printf("ntcreate returned %s, expected "
9642 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
9643 nt_errstr(status));
9644 ret = false;
9645 }
9646
9647
9648 cli_rmdir(cli, dname);
9649 return ret;
9650 }
9651
9652 struct pidtest_state {
9653 bool success;
9654 uint16_t vwv[1];
9655 DATA_BLOB data;
9656 };
9657
9658 static void pid_echo_done(struct tevent_req *subreq);
9659
9660 static struct tevent_req *pid_echo_send(TALLOC_CTX *mem_ctx,
9661 struct tevent_context *ev,
9662 struct cli_state *cli)
9663 {
9664 struct tevent_req *req, *subreq;
9665 struct pidtest_state *state;
9666
9667 req = tevent_req_create(mem_ctx, &state, struct pidtest_state);
9668 if (req == NULL) {
9669 return NULL;
9670 }
9671
9672 SSVAL(state->vwv, 0, 1);
9673 state->data = data_blob_const("hello", 5);
9674
9675 subreq = smb1cli_req_send(state,
9676 ev,
9677 cli->conn,
9678 SMBecho,
9679 0, 0, /* *_flags */
9680 0, 0, /* *_flags2 */
9681 cli->timeout,
9682 0xDEADBEEF, /* pid */
9683 NULL, /* tcon */
9684 NULL, /* session */
9685 ARRAY_SIZE(state->vwv), state->vwv,
9686 state->data.length, state->data.data);
9687
9688 if (tevent_req_nomem(subreq, req)) {
9689 return tevent_req_post(req, ev);
9690 }
9691 tevent_req_set_callback(subreq, pid_echo_done, req);
9692 return req;
9693 }
9694
9695 static void pid_echo_done(struct tevent_req *subreq)
9696 {
9697 struct tevent_req *req = tevent_req_callback_data(
9698 subreq, struct tevent_req);
9699 struct pidtest_state *state = tevent_req_data(
9700 req, struct pidtest_state);
9701 NTSTATUS status;
9702 uint32_t num_bytes;
9703 uint8_t *bytes = NULL;
9704 struct iovec *recv_iov = NULL;
9705 uint8_t *phdr = NULL;
9706 uint16_t pidlow = 0;
9707 uint16_t pidhigh = 0;
9708 struct smb1cli_req_expected_response expected[] = {
9709 {
9710 .status = NT_STATUS_OK,
9711 .wct = 1,
9712 },
9713 };
9714
9715 status = smb1cli_req_recv(subreq, state,
9716 &recv_iov,
9717 &phdr,
9718 NULL, /* pwct */
9719 NULL, /* pvwv */
9720 NULL, /* pvwv_offset */
9721 &num_bytes,
9722 &bytes,
9723 NULL, /* pbytes_offset */
9724 NULL, /* pinbuf */
9725 expected, ARRAY_SIZE(expected));
9726
9727 TALLOC_FREE(subreq);
9728
9729 if (!NT_STATUS_IS_OK(status)) {
9730 tevent_req_nterror(req, status);
9731 return;
9732 }
9733
9734 if (num_bytes != state->data.length) {
9735 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
9736 return;
9737 }
9738
9739 if (memcmp(bytes, state->data.data, num_bytes) != 0) {
9740 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
9741 return;
9742 }
9743
9744 /* Check pid low/high == DEADBEEF */
9745 pidlow = SVAL(phdr, HDR_PID);
9746 if (pidlow != 0xBEEF){
9747 printf("Incorrect pidlow 0x%x, should be 0xBEEF\n",
9748 (unsigned int)pidlow);
9749 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
9750 return;
9751 }
9752 pidhigh = SVAL(phdr, HDR_PIDHIGH);
9753 if (pidhigh != 0xDEAD){
9754 printf("Incorrect pidhigh 0x%x, should be 0xDEAD\n",
9755 (unsigned int)pidhigh);
9756 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
9757 return;
9758 }
9759
9760 tevent_req_done(req);
9761 }
9762
9763 static NTSTATUS pid_echo_recv(struct tevent_req *req)
9764 {
9765 return tevent_req_simple_recv_ntstatus(req);
9766 }
9767
9768 static bool run_pidhigh(int dummy)
9769 {
9770 bool success = false;
9771 struct cli_state *cli = NULL;
9772 NTSTATUS status;
9773 struct tevent_context *ev = NULL;
9774 struct tevent_req *req = NULL;
9775 TALLOC_CTX *frame = talloc_stackframe();
9776
9777 printf("starting pid high test\n");
9778 if (!torture_open_connection(&cli, 0)) {
9779 return false;
9780 }
9781 smbXcli_conn_set_sockopt(cli->conn, sockops);
9782
9783 ev = samba_tevent_context_init(frame);
9784 if (ev == NULL) {
9785 goto fail;
9786 }
9787
9788 req = pid_echo_send(frame, ev, cli);
9789 if (req == NULL) {
9790 goto fail;
9791 }
9792
9793 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
9794 goto fail;
9795 }
9796
9797 status = pid_echo_recv(req);
9798 if (NT_STATUS_IS_OK(status)) {
9799 printf("pid high test ok\n");
9800 success = true;
9801 }
9802
9803 fail:
9804
9805 TALLOC_FREE(frame);
9806 torture_close_connection(cli);
9807 return success;
9808 }
9809
9810 /*
9811 Test Windows open on a bad POSIX symlink.
9812 */
9813 static bool run_symlink_open_test(int dummy)
9814 {
9815 static struct cli_state *cli;
9816 const char *fname = "non_existant_file";
9817 const char *sname = "dangling_symlink";
9818 uint16_t fnum = (uint16_t)-1;
9819 bool correct = false;
9820 NTSTATUS status;
9821 TALLOC_CTX *frame = NULL;
9822
9823 frame = talloc_stackframe();
9824
9825 printf("Starting Windows bad symlink open test\n");
9826
9827 if (!torture_open_connection(&cli, 0)) {
9828 TALLOC_FREE(frame);
9829 return false;
9830 }
9831
9832 smbXcli_conn_set_sockopt(cli->conn, sockops);
9833
9834 status = torture_setup_unix_extensions(cli);
9835 if (!NT_STATUS_IS_OK(status)) {
9836 TALLOC_FREE(frame);
9837 return false;
9838 }
9839
9840 /* Ensure nothing exists. */
9841 cli_setatr(cli, fname, 0, 0);
9842 cli_posix_unlink(cli, fname);
9843 cli_setatr(cli, sname, 0, 0);
9844 cli_posix_unlink(cli, sname);
9845
9846 /* Create a symlink pointing nowhere. */
9847 status = cli_posix_symlink(cli, fname, sname);
9848 if (!NT_STATUS_IS_OK(status)) {
9849 printf("cli_posix_symlink of %s -> %s failed (%s)\n",
9850 sname,
9851 fname,
9852 nt_errstr(status));
9853 goto out;
9854 }
9855
9856 /* Now ensure that a Windows open doesn't hang. */
9857 status = cli_ntcreate(cli,
9858 sname,
9859 0,
9860 FILE_READ_DATA|FILE_WRITE_DATA,
9861 0,
9862 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
9863 FILE_OPEN_IF,
9864 0x0,
9865 0x0,
9866 &fnum,
9867 NULL);
9868
9869 /*
9870 * We get either NT_STATUS_OBJECT_NAME_NOT_FOUND or
9871 * NT_STATUS_OBJECT_PATH_NOT_FOUND depending on if
9872 * we use O_NOFOLLOW on the server or not.
9873 */
9874 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND) ||
9875 NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND))
9876 {
9877 correct = true;
9878 } else {
9879 printf("cli_ntcreate of %s returned %s - should return"
9880 " either (%s) or (%s)\n",
9881 sname,
9882 nt_errstr(status),
9883 nt_errstr(NT_STATUS_OBJECT_NAME_NOT_FOUND),
9884 nt_errstr(NT_STATUS_OBJECT_PATH_NOT_FOUND));
9885 goto out;
9886 }
9887
9888 correct = true;
9889
9890 out:
9891
9892 if (fnum != (uint16_t)-1) {
9893 cli_close(cli, fnum);
9894 fnum = (uint16_t)-1;
9895 }
9896
9897 cli_setatr(cli, sname, 0, 0);
9898 cli_posix_unlink(cli, sname);
9899 cli_setatr(cli, fname, 0, 0);
9900 cli_posix_unlink(cli, fname);
9901
9902 if (!torture_close_connection(cli)) {
9903 correct = false;
9904 }
9905
9906 TALLOC_FREE(frame);
9907 return correct;
9908 }
9909
9910 /*
9911 * Only testing minimal time strings, as the others
9912 * need (locale-dependent) guessing at what strftime does and
9913 * even may differ in builds.
9914 */
9915 static bool timesubst_test(void)
9916 {
9917 TALLOC_CTX *ctx = NULL;
9918 /* Sa 23. Dez 04:33:20 CET 2017 */
9919 const struct timeval tv = { 1514000000, 123 };
9920 const char* expect_minimal = "20171223_033320";
9921 const char* expect_minus = "20171223_033320_000123";
9922 char *s;
9923 char *env_tz, *orig_tz = NULL;
9924 bool result = true;
9925
9926 ctx = talloc_new(NULL);
9927
9928 env_tz = getenv("TZ");
9929 if(env_tz) {
9930 orig_tz = talloc_strdup(ctx, env_tz);
9931 }
9932 setenv("TZ", "UTC", 1);
9933
9934 s = minimal_timeval_string(ctx, &tv, false);
9935
9936 if(!s || strcmp(s, expect_minimal)) {
9937 printf("minimal_timeval_string(ctx, tv, false) returned [%s], expected "
9938 "[%s]\n", s ? s : "<nil>", expect_minimal);
9939 result = false;
9940 }
9941 TALLOC_FREE(s);
9942 s = minimal_timeval_string(ctx, &tv, true);
9943 if(!s || strcmp(s, expect_minus)) {
9944 printf("minimal_timeval_string(ctx, tv, true) returned [%s], expected "
9945 "[%s]\n", s ? s : "<nil>", expect_minus);
9946 result = false;
9947 }
9948 TALLOC_FREE(s);
9949
9950 if(orig_tz) {
9951 setenv("TZ", orig_tz, 1);
9952 }
9953
9954 TALLOC_FREE(ctx);
9955 return result;
9956 }
9957
9958 static bool run_local_substitute(int dummy)
9959 {
9960 bool ok = true;
9961
9962 ok &= subst_test("%U", "bla", "", -1, -1, "bla");
9963 ok &= subst_test("%u%U", "bla", "", -1, -1, "blabla");
9964 ok &= subst_test("%g", "", "", -1, -1, "NO_GROUP");
9965 ok &= subst_test("%G", "", "", -1, -1, "NO_GROUP");
9966 ok &= subst_test("%g", "", "", -1, 0, gidtoname(0));
9967 ok &= subst_test("%G", "", "", -1, 0, gidtoname(0));
9968 ok &= subst_test("%D%u", "u", "dom", -1, 0, "domu");
9969 ok &= subst_test("%i %I", "", "", -1, -1, "0.0.0.0 0.0.0.0");
9970 ok &= subst_test("%j %J", "", "", -1, -1, "0_0_0_0 0_0_0_0");
9971 /* Substitution depends on current time, so better test the underlying
9972 formatting function. At least covers %t. */
9973 ok &= timesubst_test();
9974
9975 /* Different captialization rules in sub_basic... */
9976
9977 ok &= (strcmp(talloc_sub_basic(talloc_tos(), "BLA", "dom", "%U%D"),
9978 "blaDOM") == 0);
9979
9980 return ok;
9981 }
9982
9983 static bool run_local_base64(int dummy)
9984 {
9985 int i;
9986 bool ret = true;
9987
9988 for (i=1; i<2000; i++) {
9989 DATA_BLOB blob1, blob2;
9990 char *b64;
9991
9992 blob1.data = talloc_array(talloc_tos(), uint8_t, i);
9993 blob1.length = i;
9994 generate_random_buffer(blob1.data, blob1.length);
9995
9996 b64 = base64_encode_data_blob(talloc_tos(), blob1);
9997 if (b64 == NULL) {
9998 d_fprintf(stderr, "base64_encode_data_blob failed "
9999 "for %d bytes\n", i);
10000 ret = false;
10001 }
10002 blob2 = base64_decode_data_blob(b64);
10003 TALLOC_FREE(b64);
10004
10005 if (data_blob_cmp(&blob1, &blob2)) {
10006 d_fprintf(stderr, "data_blob_cmp failed for %d "
10007 "bytes\n", i);
10008 ret = false;
10009 }
10010 TALLOC_FREE(blob1.data);
10011 data_blob_free(&blob2);
10012 }
10013 return ret;
10014 }
10015
10016 static void parse_fn(time_t timeout, DATA_BLOB blob, void *private_data)
10017 {
10018 return;
10019 }
10020
10021 static bool run_local_gencache(int dummy)
10022 {
10023 char *val;
10024 time_t tm;
10025 DATA_BLOB blob;
10026 char v;
10027 struct memcache *mem;
10028 int i;
10029
10030 mem = memcache_init(NULL, 0);
10031 if (mem == NULL) {
10032 d_printf("%s: memcache_init failed\n", __location__);
10033 return false;
10034 }
10035 memcache_set_global(mem);
10036
10037 if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
10038 d_printf("%s: gencache_set() failed\n", __location__);
10039 return False;
10040 }
10041
10042 if (!gencache_get("foo", NULL, NULL, NULL)) {
10043 d_printf("%s: gencache_get() failed\n", __location__);
10044 return False;
10045 }
10046
10047 for (i=0; i<1000000; i++) {
10048 gencache_parse("foo", parse_fn, NULL);
10049 }
10050
10051 if (!gencache_get("foo", talloc_tos(), &val, &tm)) {
10052 d_printf("%s: gencache_get() failed\n", __location__);
10053 return False;
10054 }
10055 TALLOC_FREE(val);
10056
10057 if (!gencache_get("foo", talloc_tos(), &val, &tm)) {
10058 d_printf("%s: gencache_get() failed\n", __location__);
10059 return False;
10060 }
10061
10062 if (strcmp(val, "bar") != 0) {
10063 d_printf("%s: gencache_get() returned %s, expected %s\n",
10064 __location__, val, "bar");
10065 TALLOC_FREE(val);
10066 return False;
10067 }
10068
10069 TALLOC_FREE(val);
10070
10071 if (!gencache_del("foo")) {
10072 d_printf("%s: gencache_del() failed\n", __location__);
10073 return False;
10074 }
10075 if (gencache_del("foo")) {
10076 d_printf("%s: second gencache_del() succeeded\n",
10077 __location__);
10078 return False;
10079 }
10080
10081 if (gencache_get("foo", talloc_tos(), &val, &tm)) {
10082 d_printf("%s: gencache_get() on deleted entry "
10083 "succeeded\n", __location__);
10084 return False;
10085 }
10086
10087 blob = data_blob_string_const_null("bar");
10088 tm = time(NULL) + 60;
10089
10090 if (!gencache_set_data_blob("foo", blob, tm)) {
10091 d_printf("%s: gencache_set_data_blob() failed\n", __location__);
10092 return False;
10093 }
10094
10095 if (!gencache_get_data_blob("foo", talloc_tos(), &blob, NULL, NULL)) {
10096 d_printf("%s: gencache_get_data_blob() failed\n", __location__);
10097 return False;
10098 }
10099
10100 if (strcmp((const char *)blob.data, "bar") != 0) {
10101 d_printf("%s: gencache_get_data_blob() returned %s, expected %s\n",
10102 __location__, (const char *)blob.data, "bar");
10103 data_blob_free(&blob);
10104 return False;
10105 }
10106
10107 data_blob_free(&blob);
10108
10109 if (!gencache_del("foo")) {
10110 d_printf("%s: gencache_del() failed\n", __location__);
10111 return False;
10112 }
10113 if (gencache_del("foo")) {
10114 d_printf("%s: second gencache_del() succeeded\n",
10115 __location__);
10116 return False;
10117 }
10118
10119 if (gencache_get_data_blob("foo", talloc_tos(), &blob, NULL, NULL)) {
10120 d_printf("%s: gencache_get_data_blob() on deleted entry "
10121 "succeeded\n", __location__);
10122 return False;
10123 }
10124
10125 v = 1;
10126 blob.data = (uint8_t *)&v;
10127 blob.length = sizeof(v);
10128
10129 if (!gencache_set_data_blob("blob", blob, tm)) {
10130 d_printf("%s: gencache_set_data_blob() failed\n",
10131 __location__);
10132 return false;
10133 }
10134 if (gencache_get("blob", talloc_tos(), &val, &tm)) {
10135 d_printf("%s: gencache_get succeeded\n", __location__);
10136 return false;
10137 }
10138
10139 return True;
10140 }
10141
10142 static bool rbt_testval(struct db_context *db, const char *key,
10143 const char *value)
10144 {
10145 struct db_record *rec;
10146 TDB_DATA data = string_tdb_data(value);
10147 bool ret = false;
10148 NTSTATUS status;
10149 TDB_DATA dbvalue;
10150
10151 rec = dbwrap_fetch_locked(db, db, string_tdb_data(key));
10152 if (rec == NULL) {
10153 d_fprintf(stderr, "fetch_locked failed\n");
10154 goto done;
10155 }
10156 status = dbwrap_record_store(rec, data, 0);
10157 if (!NT_STATUS_IS_OK(status)) {
10158 d_fprintf(stderr, "store failed: %s\n", nt_errstr(status));
10159 goto done;
10160 }
10161 TALLOC_FREE(rec);
10162
10163 rec = dbwrap_fetch_locked(db, db, string_tdb_data(key));
10164 if (rec == NULL) {
10165 d_fprintf(stderr, "second fetch_locked failed\n");
10166 goto done;
10167 }
10168
10169 dbvalue = dbwrap_record_get_value(rec);
10170 if ((dbvalue.dsize != data.dsize)
10171 || (memcmp(dbvalue.dptr, data.dptr, data.dsize) != 0)) {
10172 d_fprintf(stderr, "Got wrong data back\n");
10173 goto done;
10174 }
10175
10176 ret = true;
10177 done:
10178 TALLOC_FREE(rec);
10179 return ret;
10180 }
10181
10182 static int local_rbtree_traverse_read(struct db_record *rec, void *private_data)
10183 {
10184 int *count2 = (int *)private_data;
10185 (*count2)++;
10186 return 0;
10187 }
10188
10189 static int local_rbtree_traverse_delete(struct db_record *rec, void *private_data)
10190 {
10191 int *count2 = (int *)private_data;
10192 (*count2)++;
10193 dbwrap_record_delete(rec);
10194 return 0;
10195 }
10196
10197 static bool run_local_rbtree(int dummy)
10198 {
10199 struct db_context *db;
10200 bool ret = false;
10201 int i;
10202 NTSTATUS status;
10203 int count = 0;
10204 int count2 = 0;
10205
10206 db = db_open_rbt(NULL);
10207
10208 if (db == NULL) {
10209 d_fprintf(stderr, "db_open_rbt failed\n");
10210 return false;
10211 }
10212
10213 for (i=0; i<1000; i++) {
10214 char *key, *value;
10215
10216 if (asprintf(&key, "key%ld", random()) == -1) {
10217 goto done;
10218 }
10219 if (asprintf(&value, "value%ld", random()) == -1) {
10220 SAFE_FREE(key);
10221 goto done;
10222 }
10223
10224 if (!rbt_testval(db, key, value)) {
10225 SAFE_FREE(key);
10226 SAFE_FREE(value);
10227 goto done;
10228 }
10229
10230 SAFE_FREE(value);
10231 if (asprintf(&value, "value%ld", random()) == -1) {
10232 SAFE_FREE(key);
10233 goto done;
10234 }
10235
10236 if (!rbt_testval(db, key, value)) {
10237 SAFE_FREE(key);
10238 SAFE_FREE(value);
10239 goto done;
10240 }
10241
10242 SAFE_FREE(key);
10243 SAFE_FREE(value);
10244 }
10245
10246 ret = true;
10247 count = 0; count2 = 0;
10248 status = dbwrap_traverse_read(db, local_rbtree_traverse_read,
10249 &count2, &count);
10250 printf("%s: read1: %d %d, %s\n", __func__, count, count2, nt_errstr(status));
10251 if ((count != count2) || (count != 1000)) {
10252 ret = false;
10253 }
10254 count = 0; count2 = 0;
10255 status = dbwrap_traverse(db, local_rbtree_traverse_delete,
10256 &count2, &count);
10257 printf("%s: delete: %d %d, %s\n", __func__, count, count2, nt_errstr(status));
10258 if ((count != count2) || (count != 1000)) {
10259 ret = false;
10260 }
10261 count = 0; count2 = 0;
10262 status = dbwrap_traverse_read(db, local_rbtree_traverse_read,
10263 &count2, &count);
10264 printf("%s: read2: %d %d, %s\n", __func__, count, count2, nt_errstr(status));
10265 if ((count != count2) || (count != 0)) {
10266 ret = false;
10267 }
10268
10269 done:
10270 TALLOC_FREE(db);
10271 return ret;
10272 }
10273
10274
10275 /*
10276 local test for character set functions
10277
10278 This is a very simple test for the functionality in convert_string_error()
10279 */
10280 static bool run_local_convert_string(int dummy)
10281 {
10282 TALLOC_CTX *tmp_ctx = talloc_new(NULL);
10283 const char *test_strings[2] = { "March", "M\303\244rz" };
10284 char dst[7];
10285 int i;
10286
10287 for (i=0; i<2; i++) {
10288 const char *str = test_strings[i];
10289 int len = strlen(str);
10290 size_t converted_size;
10291 bool ret;
10292
10293 memset(dst, 'X', sizeof(dst));
10294
10295 /* first try with real source length */
10296 ret = convert_string_error(CH_UNIX, CH_UTF8,
10297 str, len,
10298 dst, sizeof(dst),
10299 &converted_size);
10300 if (ret != true) {
10301 d_fprintf(stderr, "Failed to convert '%s' to CH_DISPLAY\n", str);
10302 goto failed;
10303 }
10304
10305 if (converted_size != len) {
10306 d_fprintf(stderr, "Converted size of '%s' should be %d - got %d\n",
10307 str, len, (int)converted_size);
10308 goto failed;
10309 }
10310
10311 if (strncmp(str, dst, converted_size) != 0) {
10312 d_fprintf(stderr, "Expected '%s' to match '%s'\n", str, dst);
10313 goto failed;
10314 }
10315
10316 if (strlen(str) != converted_size) {
10317 d_fprintf(stderr, "Expected '%s' length %d - got %d\n", str,
10318 (int)strlen(str), (int)converted_size);
10319 goto failed;
10320 }
10321
10322 if (dst[converted_size] != 'X') {
10323 d_fprintf(stderr, "Expected no termination of '%s'\n", dst);
10324 goto failed;
10325 }
10326
10327 /* now with srclen==-1, this causes the nul to be
10328 * converted too */
10329 ret = convert_string_error(CH_UNIX, CH_UTF8,
10330 str, -1,
10331 dst, sizeof(dst),
10332 &converted_size);
10333 if (ret != true) {
10334 d_fprintf(stderr, "Failed to convert '%s' to CH_DISPLAY\n", str);
10335 goto failed;
10336 }
10337
10338 if (converted_size != len+1) {
10339 d_fprintf(stderr, "Converted size of '%s' should be %d - got %d\n",
10340 str, len, (int)converted_size);
10341 goto failed;
10342 }
10343
10344 if (strncmp(str, dst, converted_size) != 0) {
10345 d_fprintf(stderr, "Expected '%s' to match '%s'\n", str, dst);
10346 goto failed;
10347 }
10348
10349 if (len+1 != converted_size) {
10350 d_fprintf(stderr, "Expected '%s' length %d - got %d\n", str,
10351 len+1, (int)converted_size);
10352 goto failed;
10353 }
10354
10355 if (dst[converted_size] != 'X') {
10356 d_fprintf(stderr, "Expected no termination of '%s'\n", dst);
10357 goto failed;
10358 }
10359
10360 }
10361
10362
10363 TALLOC_FREE(tmp_ctx);
10364 return true;
10365 failed:
10366 TALLOC_FREE(tmp_ctx);
10367 return false;
10368 }
10369
10370 static bool run_local_string_to_sid(int dummy) {
10371 struct dom_sid sid;
10372
10373 if (string_to_sid(&sid, "S--1-5-32-545")) {
10374 printf("allowing S--1-5-32-545\n");
10375 return false;
10376 }
10377 if (string_to_sid(&sid, "S-1-5-32-+545")) {
10378 printf("allowing S-1-5-32-+545\n");
10379 return false;
10380 }
10381 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")) {
10382 printf("allowing S-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0\n");
10383 return false;
10384 }
10385 if (string_to_sid(&sid, "S-1-5-32-545-abc")) {
10386 printf("allowing S-1-5-32-545-abc\n");
10387 return false;
10388 }
10389 if (string_to_sid(&sid, "S-300-5-32-545")) {
10390 printf("allowing S-300-5-32-545\n");
10391 return false;
10392 }
10393 if (string_to_sid(&sid, "S-1-0xfffffffffffffe-32-545")) {
10394 printf("allowing S-1-0xfffffffffffffe-32-545\n");
10395 return false;
10396 }
10397 if (string_to_sid(&sid, "S-1-0xffffffffffff-5294967297-545")) {
10398 printf("allowing S-1-0xffffffffffff-5294967297-545\n");
10399 return false;
10400 }
10401 if (!string_to_sid(&sid, "S-1-0xfffffffffffe-32-545")) {
10402 printf("could not parse S-1-0xfffffffffffe-32-545\n");
10403 return false;
10404 }
10405 if (!string_to_sid(&sid, "S-1-5-32-545")) {
10406 printf("could not parse S-1-5-32-545\n");
10407 return false;
10408 }
10409 if (!dom_sid_equal(&sid, &global_sid_Builtin_Users)) {
10410 printf("mis-parsed S-1-5-32-545 as %s\n",
10411 sid_string_tos(&sid));
10412 return false;
10413 }
10414 return true;
10415 }
10416
10417 static bool sid_to_string_test(const char *expected) {
10418 char *str;
10419 bool res = true;
10420 struct dom_sid sid;
10421
10422 if (!string_to_sid(&sid, expected)) {
10423 printf("could not parse %s\n", expected);
10424 return false;
10425 }
10426
10427 str = dom_sid_string(NULL, &sid);
10428 if (strcmp(str, expected)) {
10429 printf("Comparison failed (%s != %s)\n", str, expected);
10430 res = false;
10431 }
10432 TALLOC_FREE(str);
10433 return res;
10434 }
10435
10436 static bool run_local_sid_to_string(int dummy) {
10437 if (!sid_to_string_test("S-1-0xffffffffffff-1-1-1-1-1-1-1-1-1-1-1-1"))
10438 return false;
10439 if (!sid_to_string_test("S-1-545"))
10440 return false;
10441 if (!sid_to_string_test("S-255-3840-1-1-1-1"))
10442 return false;
10443 return true;
10444 }
10445
10446 static bool run_local_binary_to_sid(int dummy) {
10447 struct dom_sid *sid = talloc(NULL, struct dom_sid);
10448 static const uint8_t good_binary_sid[] = {
10449 0x1, /* revision number */
10450 15, /* num auths */
10451 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
10452 0x1, 0x1, 0x1, 0x1, /* auth[0] */
10453 0x1, 0x1, 0x1, 0x1, /* auth[1] */
10454 0x1, 0x1, 0x1, 0x1, /* auth[2] */
10455 0x1, 0x1, 0x1, 0x1, /* auth[3] */
10456 0x1, 0x1, 0x1, 0x1, /* auth[4] */
10457 0x1, 0x1, 0x1, 0x1, /* auth[5] */
10458 0x1, 0x1, 0x1, 0x1, /* auth[6] */
10459 0x1, 0x1, 0x1, 0x1, /* auth[7] */
10460 0x1, 0x1, 0x1, 0x1, /* auth[8] */
10461 0x1, 0x1, 0x1, 0x1, /* auth[9] */
10462 0x1, 0x1, 0x1, 0x1, /* auth[10] */
10463 0x1, 0x1, 0x1, 0x1, /* auth[11] */
10464 0x1, 0x1, 0x1, 0x1, /* auth[12] */
10465 0x1, 0x1, 0x1, 0x1, /* auth[13] */
10466 0x1, 0x1, 0x1, 0x1, /* auth[14] */
10467 };
10468
10469 static const uint8_t long_binary_sid[] = {
10470 0x1, /* revision number */
10471 15, /* num auths */
10472 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
10473 0x1, 0x1, 0x1, 0x1, /* auth[0] */
10474 0x1, 0x1, 0x1, 0x1, /* auth[1] */
10475 0x1, 0x1, 0x1, 0x1, /* auth[2] */
10476 0x1, 0x1, 0x1, 0x1, /* auth[3] */
10477 0x1, 0x1, 0x1, 0x1, /* auth[4] */
10478 0x1, 0x1, 0x1, 0x1, /* auth[5] */
10479 0x1, 0x1, 0x1, 0x1, /* auth[6] */
10480 0x1, 0x1, 0x1, 0x1, /* auth[7] */
10481 0x1, 0x1, 0x1, 0x1, /* auth[8] */
10482 0x1, 0x1, 0x1, 0x1, /* auth[9] */
10483 0x1, 0x1, 0x1, 0x1, /* auth[10] */
10484 0x1, 0x1, 0x1, 0x1, /* auth[11] */
10485 0x1, 0x1, 0x1, 0x1, /* auth[12] */
10486 0x1, 0x1, 0x1, 0x1, /* auth[13] */
10487 0x1, 0x1, 0x1, 0x1, /* auth[14] */
10488 0x1, 0x1, 0x1, 0x1, /* auth[15] */
10489 0x1, 0x1, 0x1, 0x1, /* auth[16] */
10490 0x1, 0x1, 0x1, 0x1, /* auth[17] */
10491 };
10492
10493 static const uint8_t long_binary_sid2[] = {
10494 0x1, /* revision number */
10495 32, /* num auths */
10496 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
10497 0x1, 0x1, 0x1, 0x1, /* auth[0] */
10498 0x1, 0x1, 0x1, 0x1, /* auth[1] */
10499 0x1, 0x1, 0x1, 0x1, /* auth[2] */
10500 0x1, 0x1, 0x1, 0x1, /* auth[3] */
10501 0x1, 0x1, 0x1, 0x1, /* auth[4] */
10502 0x1, 0x1, 0x1, 0x1, /* auth[5] */
10503 0x1, 0x1, 0x1, 0x1, /* auth[6] */
10504 0x1, 0x1, 0x1, 0x1, /* auth[7] */
10505 0x1, 0x1, 0x1, 0x1, /* auth[8] */
10506 0x1, 0x1, 0x1, 0x1, /* auth[9] */
10507 0x1, 0x1, 0x1, 0x1, /* auth[10] */
10508 0x1, 0x1, 0x1, 0x1, /* auth[11] */
10509 0x1, 0x1, 0x1, 0x1, /* auth[12] */
10510 0x1, 0x1, 0x1, 0x1, /* auth[13] */
10511 0x1, 0x1, 0x1, 0x1, /* auth[14] */
10512 0x1, 0x1, 0x1, 0x1, /* auth[15] */
10513 0x1, 0x1, 0x1, 0x1, /* auth[16] */
10514 0x1, 0x1, 0x1, 0x1, /* auth[17] */
10515 0x1, 0x1, 0x1, 0x1, /* auth[18] */
10516 0x1, 0x1, 0x1, 0x1, /* auth[19] */
10517 0x1, 0x1, 0x1, 0x1, /* auth[20] */
10518 0x1, 0x1, 0x1, 0x1, /* auth[21] */
10519 0x1, 0x1, 0x1, 0x1, /* auth[22] */
10520 0x1, 0x1, 0x1, 0x1, /* auth[23] */
10521 0x1, 0x1, 0x1, 0x1, /* auth[24] */
10522 0x1, 0x1, 0x1, 0x1, /* auth[25] */
10523 0x1, 0x1, 0x1, 0x1, /* auth[26] */
10524 0x1, 0x1, 0x1, 0x1, /* auth[27] */
10525 0x1, 0x1, 0x1, 0x1, /* auth[28] */
10526 0x1, 0x1, 0x1, 0x1, /* auth[29] */
10527 0x1, 0x1, 0x1, 0x1, /* auth[30] */
10528 0x1, 0x1, 0x1, 0x1, /* auth[31] */
10529 };
10530
10531 if (!sid_parse(good_binary_sid, sizeof(good_binary_sid), sid)) {
10532 return false;
10533 }
10534 if (sid_parse(long_binary_sid2, sizeof(long_binary_sid2), sid)) {
10535 return false;
10536 }
10537 if (sid_parse(long_binary_sid, sizeof(long_binary_sid), sid)) {
10538 return false;
10539 }
10540 return true;
10541 }
10542
10543 /* Split a path name into filename and stream name components. Canonicalise
10544 * such that an implicit $DATA token is always explicit.
10545 *
10546 * The "specification" of this function can be found in the
10547 * run_local_stream_name() function in torture.c, I've tried those
10548 * combinations against a W2k3 server.
10549 */
10550
10551 static NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
10552 char **pbase, char **pstream)
10553 {
10554 char *base = NULL;
10555 char *stream = NULL;
10556 char *sname; /* stream name */
10557 const char *stype; /* stream type */
10558
10559 DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
10560
10561 sname = strchr_m(fname, ':');
10562
10563 if (sname == NULL) {
10564 if (pbase != NULL) {
10565 base = talloc_strdup(mem_ctx, fname);
10566 NT_STATUS_HAVE_NO_MEMORY(base);
10567 }
10568 goto done;
10569 }
10570
10571 if (pbase != NULL) {
10572 base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
10573 NT_STATUS_HAVE_NO_MEMORY(base);
10574 }
10575
10576 sname += 1;
10577
10578 stype = strchr_m(sname, ':');
10579
10580 if (stype == NULL) {
10581 sname = talloc_strdup(mem_ctx, sname);
10582 stype = "$DATA";
10583 }
10584 else {
10585 if (strcasecmp_m(stype, ":$DATA") != 0) {
10586 /*
10587 * If there is an explicit stream type, so far we only
10588 * allow $DATA. Is there anything else allowed? -- vl
10589 */
10590 DEBUG(10, ("[%s] is an invalid stream type\n", stype));
10591 TALLOC_FREE(base);
10592 return NT_STATUS_OBJECT_NAME_INVALID;
10593 }
10594 sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
10595 stype += 1;
10596 }
10597
10598 if (sname == NULL) {
10599 TALLOC_FREE(base);
10600 return NT_STATUS_NO_MEMORY;
10601 }
10602
10603 if (sname[0] == '\0') {
10604 /*
10605 * no stream name, so no stream
10606 */
10607 goto done;
10608 }
10609
10610 if (pstream != NULL) {
10611 stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
10612 if (stream == NULL) {
10613 TALLOC_FREE(sname);
10614 TALLOC_FREE(base);
10615 return NT_STATUS_NO_MEMORY;
10616 }
10617 /*
10618 * upper-case the type field
10619 */
10620 (void)strupper_m(strchr_m(stream, ':')+1);
10621 }
10622
10623 done:
10624 if (pbase != NULL) {
10625 *pbase = base;
10626 }
10627 if (pstream != NULL) {
10628 *pstream = stream;
10629 }
10630 return NT_STATUS_OK;
10631 }
10632
10633 static bool test_stream_name(const char *fname, const char *expected_base,
10634 const char *expected_stream,
10635 NTSTATUS expected_status)
10636 {
10637 NTSTATUS status;
10638 char *base = NULL;
10639 char *stream = NULL;
10640
10641 status = split_ntfs_stream_name(talloc_tos(), fname, &base, &stream);
10642 if (!NT_STATUS_EQUAL(status, expected_status)) {
10643 goto error;
10644 }
10645
10646 if (!NT_STATUS_IS_OK(status)) {
10647 return true;
10648 }
10649
10650 if (base == NULL) goto error;
10651
10652 if (strcmp(expected_base, base) != 0) goto error;
10653
10654 if ((expected_stream != NULL) && (stream == NULL)) goto error;
10655 if ((expected_stream == NULL) && (stream != NULL)) goto error;
10656
10657 if ((stream != NULL) && (strcmp(expected_stream, stream) != 0))
10658 goto error;
10659
10660 TALLOC_FREE(base);
10661 TALLOC_FREE(stream);
10662 return true;
10663
10664 error:
10665 d_fprintf(stderr, "Do test_stream(%s, %s, %s, %s)\n",
10666 fname, expected_base ? expected_base : "<NULL>",
10667 expected_stream ? expected_stream : "<NULL>",
10668 nt_errstr(expected_status));
10669 d_fprintf(stderr, "-> base=%s, stream=%s, status=%s\n",
10670 base ? base : "<NULL>", stream ? stream : "<NULL>",
10671 nt_errstr(status));
10672 TALLOC_FREE(base);
10673 TALLOC_FREE(stream);
10674 return false;
10675 }
10676
10677 static bool run_local_stream_name(int dummy)
10678 {
10679 bool ret = true;
10680
10681 ret &= test_stream_name(
10682 "bla", "bla", NULL, NT_STATUS_OK);
10683 ret &= test_stream_name(
10684 "bla::$DATA", "bla", NULL, NT_STATUS_OK);
10685 ret &= test_stream_name(
10686 "bla:blub:", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
10687 ret &= test_stream_name(
10688 "bla::", NULL, NULL, NT_STATUS_OBJECT_NAME_INVALID);
10689 ret &= test_stream_name(
10690 "bla::123", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
10691 ret &= test_stream_name(
10692 "bla:$DATA", "bla", "$DATA:$DATA", NT_STATUS_OK);
10693 ret &= test_stream_name(
10694 "bla:x:$DATA", "bla", "x:$DATA", NT_STATUS_OK);
10695 ret &= test_stream_name(
10696 "bla:x", "bla", "x:$DATA", NT_STATUS_OK);
10697
10698 return ret;
10699 }
10700
10701 static bool data_blob_equal(DATA_BLOB a, DATA_BLOB b)
10702 {
10703 if (a.length != b.length) {
10704 printf("a.length=%d != b.length=%d\n",
10705 (int)a.length, (int)b.length);
10706 return false;
10707 }
10708 if (memcmp(a.data, b.data, a.length) != 0) {
10709 printf("a.data and b.data differ\n");
10710 return false;
10711 }
10712 return true;
10713 }
10714
10715 static bool run_local_memcache(int dummy)
10716 {
10717 struct memcache *cache;
10718 DATA_BLOB k1, k2, k3;
10719 DATA_BLOB d1, d3;
10720 DATA_BLOB v1, v3;
10721
10722 TALLOC_CTX *mem_ctx;
10723 char *ptr1 = NULL;
10724 char *ptr2 = NULL;
10725
10726 char *str1, *str2;
10727 size_t size1, size2;
10728 bool ret = false;
10729
10730 mem_ctx = talloc_init("foo");
10731 if (mem_ctx == NULL) {
10732 return false;
10733 }
10734
10735 /* STAT_CACHE TESTS */
10736
10737 cache = memcache_init(NULL, sizeof(void *) == 8 ? 200 : 100);
10738
10739 if (cache == NULL) {
10740 printf("memcache_init failed\n");
10741 return false;
10742 }
10743
10744 d1 = data_blob_const("d1", 2);
10745 d3 = data_blob_const("d3", 2);
10746
10747 k1 = data_blob_const("d1", 2);
10748 k2 = data_blob_const("d2", 2);
10749 k3 = data_blob_const("d3", 2);
10750
10751 memcache_add(cache, STAT_CACHE, k1, d1);
10752
10753 if (!memcache_lookup(cache, STAT_CACHE, k1, &v1)) {
10754 printf("could not find k1\n");
10755 return false;
10756 }
10757 if (!data_blob_equal(d1, v1)) {
10758 return false;
10759 }
10760
10761 memcache_add(cache, STAT_CACHE, k1, d3);
10762
10763 if (!memcache_lookup(cache, STAT_CACHE, k1, &v3)) {
10764 printf("could not find replaced k1\n");
10765 return false;
10766 }
10767 if (!data_blob_equal(d3, v3)) {
10768 return false;
10769 }
10770
10771 TALLOC_FREE(cache);
10772
10773 /* GETWD_CACHE TESTS */
10774 str1 = talloc_strdup(mem_ctx, "string1");
10775 if (str1 == NULL) {
10776 return false;
10777 }
10778 ptr2 = str1; /* Keep an alias for comparison. */
10779
10780 str2 = talloc_strdup(mem_ctx, "string2");
10781 if (str2 == NULL) {
10782 return false;
10783 }
10784
10785 cache = memcache_init(NULL, sizeof(void *) == 8 ? 200 : 100);
10786 if (cache == NULL) {
10787 printf("memcache_init failed\n");
10788 return false;
10789 }
10790
10791 memcache_add_talloc(cache, GETWD_CACHE, k2, &str1);
10792 /* str1 == NULL now. */
10793 ptr1 = memcache_lookup_talloc(cache, GETWD_CACHE, k2);
10794 if (ptr1 == NULL) {
10795 printf("could not find k2\n");
10796 return false;
10797 }
10798 if (ptr1 != ptr2) {
10799 printf("fetch of k2 got wrong string\n");
10800 return false;
10801 }
10802
10803 /* Add a blob to ensure k2 gets purged. */
10804 d3 = data_blob_talloc_zero(mem_ctx, 180);
10805 memcache_add(cache, STAT_CACHE, k3, d3);
10806
10807 ptr2 = memcache_lookup_talloc(cache, GETWD_CACHE, k2);
10808 if (ptr2 != NULL) {
10809 printf("Did find k2, should have been purged\n");
10810 return false;
10811 }
10812
10813 TALLOC_FREE(cache);
10814 TALLOC_FREE(mem_ctx);
10815
10816 mem_ctx = talloc_init("foo");
10817 if (mem_ctx == NULL) {
10818 return false;
10819 }
10820
10821 cache = memcache_init(NULL, 0);
10822 if (cache == NULL) {
10823 return false;
10824 }
10825
10826 str1 = talloc_strdup(mem_ctx, "string1");
10827 if (str1 == NULL) {
10828 return false;
10829 }
10830 str2 = talloc_strdup(mem_ctx, "string2");
10831 if (str2 == NULL) {
10832 return false;
10833 }
10834 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
10835 data_blob_string_const("torture"), &str1);
10836 size1 = talloc_total_size(cache);
10837
10838 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
10839 data_blob_string_const("torture"), &str2);
10840 size2 = talloc_total_size(cache);
10841
10842 printf("size1=%d, size2=%d\n", (int)size1, (int)size2);
10843
10844 if (size2 > size1) {
10845 printf("memcache leaks memory!\n");
10846 goto fail;
10847 }
10848
10849 ret = true;
10850 fail:
10851 TALLOC_FREE(cache);
10852 return ret;
10853 }
10854
10855 static void wbclient_done(struct tevent_req *req)
10856 {
10857 wbcErr wbc_err;
10858 struct winbindd_response *wb_resp;
10859 int *i = (int *)tevent_req_callback_data_void(req);
10860
10861 wbc_err = wb_trans_recv(req, req, &wb_resp);
10862 TALLOC_FREE(req);
10863 *i += 1;
10864 d_printf("wb_trans_recv %d returned %s\n", *i, wbcErrorString(wbc_err));
10865 }
10866
10867 static bool run_wbclient_multi_ping(int dummy)
10868 {
10869 struct tevent_context *ev;
10870 struct wb_context **wb_ctx;
10871 struct winbindd_request wb_req;
10872 bool result = false;
10873 int i, j;
10874
10875 BlockSignals(True, SIGPIPE);
10876
10877 ev = tevent_context_init(talloc_tos());
10878 if (ev == NULL) {
10879 goto fail;
10880 }
10881
10882 wb_ctx = talloc_array(ev, struct wb_context *, torture_nprocs);
10883 if (wb_ctx == NULL) {
10884 goto fail;
10885 }
10886
10887 ZERO_STRUCT(wb_req);
10888 wb_req.cmd = WINBINDD_PING;
10889
10890 d_printf("torture_nprocs=%d, numops=%d\n", (int)torture_nprocs, (int)torture_numops);
10891
10892 for (i=0; i<torture_nprocs; i++) {
10893 wb_ctx[i] = wb_context_init(ev, NULL);
10894 if (wb_ctx[i] == NULL) {
10895 goto fail;
10896 }
10897 for (j=0; j<torture_numops; j++) {
10898 struct tevent_req *req;
10899 req = wb_trans_send(ev, ev, wb_ctx[i],
10900 (j % 2) == 0, &wb_req);
10901 if (req == NULL) {
10902 goto fail;
10903 }
10904 tevent_req_set_callback(req, wbclient_done, &i);
10905 }
10906 }
10907
10908 i = 0;
10909
10910 while (i < torture_nprocs * torture_numops) {
10911 tevent_loop_once(ev);
10912 }
10913
10914 result = true;
10915 fail:
10916 TALLOC_FREE(ev);
10917 return result;
10918 }
10919
10920 static bool dbtrans_inc(struct db_context *db)
10921 {
10922 struct db_record *rec;
10923 uint32_t val;
10924 bool ret = false;
10925 NTSTATUS status;
10926 TDB_DATA value;
10927
10928 rec = dbwrap_fetch_locked(db, db, string_term_tdb_data("transtest"));
10929 if (rec == NULL) {
10930 printf(__location__ "fetch_lock failed\n");
10931 return false;
10932 }
10933
10934 value = dbwrap_record_get_value(rec);
10935
10936 if (value.dsize != sizeof(uint32_t)) {
10937 printf(__location__ "value.dsize = %d\n",
10938 (int)value.dsize);
10939 goto fail;
10940 }
10941
10942 memcpy(&val, value.dptr, sizeof(val));
10943 val += 1;
10944
10945 status = dbwrap_record_store(
10946 rec, make_tdb_data((uint8_t *)&val, sizeof(val)), 0);
10947 if (!NT_STATUS_IS_OK(status)) {
10948 printf(__location__ "store failed: %s\n",
10949 nt_errstr(status));
10950 goto fail;
10951 }
10952
10953 ret = true;
10954 fail:
10955 TALLOC_FREE(rec);
10956 return ret;
10957 }
10958
10959 static bool run_local_dbtrans(int dummy)
10960 {
10961 struct db_context *db;
10962 struct db_record *rec;
10963 NTSTATUS status;
10964 uint32_t initial;
10965 int res;
10966 TDB_DATA value;
10967
10968 db = db_open(talloc_tos(), "transtest.tdb", 0, TDB_DEFAULT,
10969 O_RDWR|O_CREAT, 0600, DBWRAP_LOCK_ORDER_1,
10970 DBWRAP_FLAG_NONE);
10971 if (db == NULL) {
10972 printf("Could not open transtest.db\n");
10973 return false;
10974 }
10975
10976 res = dbwrap_transaction_start(db);
10977 if (res != 0) {
10978 printf(__location__ "transaction_start failed\n");
10979 return false;
10980 }
10981
10982 rec = dbwrap_fetch_locked(db, db, string_term_tdb_data("transtest"));
10983 if (rec == NULL) {
10984 printf(__location__ "fetch_lock failed\n");
10985 return false;
10986 }
10987
10988 value = dbwrap_record_get_value(rec);
10989
10990 if (value.dptr == NULL) {
10991 initial = 0;
10992 status = dbwrap_record_store(
10993 rec, make_tdb_data((uint8_t *)&initial,
10994 sizeof(initial)),
10995 0);
10996 if (!NT_STATUS_IS_OK(status)) {
10997 printf(__location__ "store returned %s\n",
10998 nt_errstr(status));
10999 return false;
11000 }
11001 }
11002
11003 TALLOC_FREE(rec);
11004
11005 res = dbwrap_transaction_commit(db);
11006 if (res != 0) {
11007 printf(__location__ "transaction_commit failed\n");
11008 return false;
11009 }
11010
11011 while (true) {
11012 uint32_t val, val2;
11013 int i;
11014
11015 res = dbwrap_transaction_start(db);
11016 if (res != 0) {
11017 printf(__location__ "transaction_start failed\n");
11018 break;
11019 }
11020
11021 status = dbwrap_fetch_uint32_bystring(db, "transtest", &val);
11022 if (!NT_STATUS_IS_OK(status)) {
11023 printf(__location__ "dbwrap_fetch_uint32 failed: %s\n",
11024 nt_errstr(status));
11025 break;
11026 }
11027
11028 for (i=0; i<10; i++) {
11029 if (!dbtrans_inc(db)) {
11030 return false;
11031 }
11032 }
11033
11034 status = dbwrap_fetch_uint32_bystring(db, "transtest", &val2);
11035 if (!NT_STATUS_IS_OK(status)) {
11036 printf(__location__ "dbwrap_fetch_uint32 failed: %s\n",
11037 nt_errstr(status));
11038 break;
11039 }
11040
11041 if (val2 != val + 10) {
11042 printf(__location__ "val=%d, val2=%d\n",
11043 (int)val, (int)val2);
11044 break;
11045 }
11046
11047 printf("val2=%d\r", val2);
11048
11049 res = dbwrap_transaction_commit(db);
11050 if (res != 0) {
11051 printf(__location__ "transaction_commit failed\n");
11052 break;
11053 }
11054 }
11055
11056 TALLOC_FREE(db);
11057 return true;
11058 }
11059
11060 /*
11061 * Just a dummy test to be run under a debugger. There's no real way
11062 * to inspect the tevent_poll specific function from outside of
11063 * tevent_poll.c.
11064 */
11065
11066 static bool run_local_tevent_poll(int dummy)
11067 {
11068 struct tevent_context *ev;
11069 struct tevent_fd *fd1, *fd2;
11070 bool result = false;
11071
11072 ev = tevent_context_init_byname(NULL, "poll");
11073 if (ev == NULL) {
11074 d_fprintf(stderr, "tevent_context_init_byname failed\n");
11075 goto fail;
11076 }
11077
11078 fd1 = tevent_add_fd(ev, ev, 2, 0, NULL, NULL);
11079 if (fd1 == NULL) {
11080 d_fprintf(stderr, "tevent_add_fd failed\n");
11081 goto fail;
11082 }
11083 fd2 = tevent_add_fd(ev, ev, 3, 0, NULL, NULL);
11084 if (fd2 == NULL) {
11085 d_fprintf(stderr, "tevent_add_fd failed\n");
11086 goto fail;
11087 }
11088 TALLOC_FREE(fd2);
11089
11090 fd2 = tevent_add_fd(ev, ev, 1, 0, NULL, NULL);
11091 if (fd2 == NULL) {
11092 d_fprintf(stderr, "tevent_add_fd failed\n");
11093 goto fail;
11094 }
11095
11096 result = true;
11097 fail:
11098 TALLOC_FREE(ev);
11099 return result;
11100 }
11101
11102 static bool run_local_hex_encode_buf(int dummy)
11103 {
11104 char buf[17];
11105 uint8_t src[8];
11106 int i;
11107
11108 for (i=0; i<sizeof(src); i++) {
11109 src[i] = i;
11110 }
11111 hex_encode_buf(buf, src, sizeof(src));
11112 if (strcmp(buf, "0001020304050607") != 0) {
11113 return false;
11114 }
11115 hex_encode_buf(buf, NULL, 0);
11116 if (buf[0] != '\0') {
11117 return false;
11118 }
11119 return true;
11120 }
11121
11122 static const char *remove_duplicate_addrs2_test_strings_vector[] = {
11123 "0.0.0.0",
11124 "::0",
11125 "1.2.3.1",
11126 "0.0.0.0",
11127 "0.0.0.0",
11128 "1.2.3.2",
11129 "1.2.3.3",
11130 "1.2.3.4",
11131 "1.2.3.5",
11132 "::0",
11133 "1.2.3.6",
11134 "1.2.3.7",
11135 "::0",
11136 "::0",
11137 "::0",
11138 "1.2.3.8",
11139 "1.2.3.9",
11140 "1.2.3.10",
11141 "1.2.3.11",
11142 "1.2.3.12",
11143 "1.2.3.13",
11144 "1001:1111:1111:1000:0:1111:1111:1111",
11145 "1.2.3.1",
11146 "1.2.3.2",
11147 "1.2.3.3",
11148 "1.2.3.12",
11149 "::0",
11150 "::0"
11151 };
11152
11153 static const char *remove_duplicate_addrs2_test_strings_result[] = {
11154 "1.2.3.1",
11155 "1.2.3.2",
11156 "1.2.3.3",
11157 "1.2.3.4",
11158 "1.2.3.5",
11159 "1.2.3.6",
11160 "1.2.3.7",
11161 "1.2.3.8",
11162 "1.2.3.9",
11163 "1.2.3.10",
11164 "1.2.3.11",
11165 "1.2.3.12",
11166 "1.2.3.13",
11167 "1001:1111:1111:1000:0:1111:1111:1111"
11168 };
11169
11170 static bool run_local_remove_duplicate_addrs2(int dummy)
11171 {
11172 struct ip_service test_vector[28];
11173 int count, i;
11174
11175 /* Construct the sockaddr_storage test vector. */
11176 for (i = 0; i < 28; i++) {
11177 struct addrinfo hints;
11178 struct addrinfo *res = NULL;
11179 int ret;
11180
11181 memset(&hints, '\0', sizeof(hints));
11182 hints.ai_flags = AI_NUMERICHOST;
11183 ret = getaddrinfo(remove_duplicate_addrs2_test_strings_vector[i],
11184 NULL,
11185 &hints,
11186 &res);
11187 if (ret) {
11188 fprintf(stderr, "getaddrinfo failed on [%s]\n",
11189 remove_duplicate_addrs2_test_strings_vector[i]);
11190 return false;
11191 }
11192 memset(&test_vector[i], '\0', sizeof(test_vector[i]));
11193 memcpy(&test_vector[i].ss,
11194 res->ai_addr,
11195 res->ai_addrlen);
11196 freeaddrinfo(res);
11197 }
11198
11199 count = remove_duplicate_addrs2(test_vector, i);
11200
11201 if (count != 14) {
11202 fprintf(stderr, "count wrong (%d) should be 14\n",
11203 count);
11204 return false;
11205 }
11206
11207 for (i = 0; i < count; i++) {
11208 char addr[INET6_ADDRSTRLEN];
11209
11210 print_sockaddr(addr, sizeof(addr), &test_vector[i].ss);
11211
11212 if (strcmp(addr, remove_duplicate_addrs2_test_strings_result[i]) != 0) {
11213 fprintf(stderr, "mismatch on [%d] [%s] [%s]\n",
11214 i,
11215 addr,
11216 remove_duplicate_addrs2_test_strings_result[i]);
11217 return false;
11218 }
11219 }
11220
11221 printf("run_local_remove_duplicate_addrs2: success\n");
11222 return true;
11223 }
11224
11225 static bool run_local_tdb_opener(int dummy)
11226 {
11227 TDB_CONTEXT *t;
11228 unsigned v = 0;
11229
11230 while (1) {
11231 t = tdb_open("test.tdb", 1000, TDB_CLEAR_IF_FIRST,
11232 O_RDWR|O_CREAT, 0755);
11233 if (t == NULL) {
11234 perror("tdb_open failed");
11235 return false;
11236 }
11237 tdb_close(t);
11238
11239 v += 1;
11240 printf("\r%u", v);
11241 }
11242 return true;
11243 }
11244
11245 static bool run_local_tdb_writer(int dummy)
11246 {
11247 TDB_CONTEXT *t;
11248 unsigned v = 0;
11249 TDB_DATA val;
11250
11251 t = tdb_open("test.tdb", 1000, 0, O_RDWR|O_CREAT, 0755);
11252 if (t == 0) {
11253 perror("tdb_open failed");
11254 return 1;
11255 }
11256
11257 val.dptr = (uint8_t *)&v;
11258 val.dsize = sizeof(v);
11259
11260 while (1) {
11261 TDB_DATA data;
11262 int ret;
11263
11264 ret = tdb_store(t, val, val, 0);
11265 if (ret != 0) {
11266 printf("%s\n", tdb_errorstr(t));
11267 }
11268 v += 1;
11269 printf("\r%u", v);
11270
11271 data = tdb_fetch(t, val);
11272 if (data.dptr != NULL) {
11273 SAFE_FREE(data.dptr);
11274 }
11275 }
11276 return true;
11277 }
11278
11279 static bool run_local_canonicalize_path(int dummy)
11280 {
11281 const char *src[] = {
11282 "/foo/..",
11283 "/..",
11284 "/foo/bar/../baz",
11285 "/foo/././",
11286 "/../foo",
11287 ".././././",
11288 ".././././../../../boo",
11289 "./..",
11290 NULL
11291 };
11292 const char *dst[] = {
11293 "/",
11294 "/",
11295 "/foo/baz",
11296 "/foo",
11297 "/foo",
11298 "/",
11299 "/boo",
11300 "/",
11301 NULL
11302 };
11303 unsigned int i;
11304
11305 for (i = 0; src[i] != NULL; i++) {
11306 char *d = canonicalize_absolute_path(talloc_tos(), src[i]);
11307 if (d == NULL) {
11308 perror("talloc fail\n");
11309 return false;
11310 }
11311 if (strcmp(d, dst[i]) != 0) {
11312 d_fprintf(stderr,
11313 "canonicalize missmatch %s -> %s != %s",
11314 src[i], d, dst[i]);
11315 return false;
11316 }
11317 talloc_free(d);
11318 }
11319 return true;
11320 }
11321
11322 static bool run_ign_bad_negprot(int dummy)
11323 {
11324 struct tevent_context *ev;
11325 struct tevent_req *req;
11326 struct smbXcli_conn *conn;
11327 struct sockaddr_storage ss;
11328 NTSTATUS status;
11329 int fd;
11330 bool ok;
11331
11332 printf("starting ignore bad negprot\n");
11333
11334 ok = resolve_name(host, &ss, 0x20, true);
11335 if (!ok) {
11336 d_fprintf(stderr, "Could not resolve name %s\n", host);
11337 return false;
11338 }
11339
11340 status = open_socket_out(&ss, 445, 10000, &fd);
11341 if (!NT_STATUS_IS_OK(status)) {
11342 d_fprintf(stderr, "open_socket_out failed: %s\n",
11343 nt_errstr(status));
11344 return false;
11345 }
11346
11347 conn = smbXcli_conn_create(talloc_tos(), fd, host, SMB_SIGNING_OFF, 0,
11348 NULL, 0);
11349 if (conn == NULL) {
11350 d_fprintf(stderr, "smbXcli_conn_create failed\n");
11351 return false;
11352 }
11353
11354 status = smbXcli_negprot(conn, 0, PROTOCOL_CORE, PROTOCOL_CORE);
11355 if (NT_STATUS_IS_OK(status)) {
11356 d_fprintf(stderr, "smbXcli_negprot succeeded!\n");
11357 return false;
11358 }
11359
11360 ev = samba_tevent_context_init(talloc_tos());
11361 if (ev == NULL) {
11362 d_fprintf(stderr, "samba_tevent_context_init failed\n");
11363 return false;
11364 }
11365
11366 req = smb1cli_session_setup_nt1_send(
11367 ev, ev, conn, 0, getpid(), NULL, 65503, 2, 1, 0, "", "",
11368 data_blob_null, data_blob_null, 0x40,
11369 "Windows 2000 2195", "Windows 2000 5.0");
11370 if (req == NULL) {
11371 d_fprintf(stderr, "smb1cli_session_setup_nt1_send failed\n");
11372 return false;
11373 }
11374
11375 ok = tevent_req_poll_ntstatus(req, ev, &status);
11376 if (!ok) {
11377 d_fprintf(stderr, "tevent_req_poll failed\n");
11378 return false;
11379 }
11380
11381 status = smb1cli_session_setup_nt1_recv(req, NULL, NULL, NULL, NULL,
11382 NULL, NULL);
11383 if (!NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_RESET)) {
11384 d_fprintf(stderr, "smb1cli_session_setup_nt1_recv returned "
11385 "%s, expected NT_STATUS_CONNECTION_RESET\n",
11386 nt_errstr(status));
11387 return false;
11388 }
11389
11390 TALLOC_FREE(conn);
11391
11392 printf("starting ignore bad negprot\n");
11393
11394 return true;
11395 }
11396
11397 static double create_procs(bool (*fn)(int), bool *result)
11398 {
11399 int i, status;
11400 volatile pid_t *child_status;
11401 volatile bool *child_status_out;
11402 int synccount;
11403 int tries = 8;
11404 struct timeval start;
11405
11406 synccount = 0;
11407
11408 child_status = (volatile pid_t *)anonymous_shared_allocate(sizeof(pid_t)*torture_nprocs);
11409 if (!child_status) {
11410 printf("Failed to setup shared memory\n");
11411 return -1;
11412 }
11413
11414 child_status_out = (volatile bool *)anonymous_shared_allocate(sizeof(bool)*torture_nprocs);
11415 if (!child_status_out) {
11416 printf("Failed to setup result status shared memory\n");
11417 return -1;
11418 }
11419
11420 for (i = 0; i < torture_nprocs; i++) {
11421 child_status[i] = 0;
11422 child_status_out[i] = True;
11423 }
11424
11425 start = timeval_current();
11426
11427 for (i=0;i<torture_nprocs;i++) {
11428 procnum = i;
11429 if (fork() == 0) {
11430 pid_t mypid = getpid();
11431 sys_srandom(((int)mypid) ^ ((int)time(NULL)));
11432
11433 slprintf(myname,sizeof(myname),"CLIENT%d", i);
11434
11435 while (1) {
11436 if (torture_open_connection(&current_cli, i)) break;
11437 if (tries-- == 0) {
11438 printf("pid %d failed to start\n", (int)getpid());
11439 _exit(1);
11440 }
11441 smb_msleep(10);
11442 }
11443
11444 child_status[i] = getpid();
11445
11446 while (child_status[i] && timeval_elapsed(&start) < 5) smb_msleep(2);
11447
11448 child_status_out[i] = fn(i);
11449 _exit(0);
11450 }
11451 }
11452
11453 do {
11454 synccount = 0;
11455 for (i=0;i<torture_nprocs;i++) {
11456 if (child_status[i]) synccount++;
11457 }
11458 if (synccount == torture_nprocs) break;
11459 smb_msleep(10);
11460 } while (timeval_elapsed(&start) < 30);
11461
11462 if (synccount != torture_nprocs) {
11463 printf("FAILED TO START %d CLIENTS (started %d)\n", torture_nprocs, synccount);
11464 *result = False;
11465 return timeval_elapsed(&start);
11466 }
11467
11468 /* start the client load */
11469 start = timeval_current();
11470
11471 for (i=0;i<torture_nprocs;i++) {
11472 child_status[i] = 0;
11473 }
11474
11475 printf("%d clients started\n", torture_nprocs);
11476
11477 for (i=0;i<torture_nprocs;i++) {
11478 while (waitpid(0, &status, 0) == -1 && errno == EINTR) /* noop */ ;
11479 }
11480
11481 printf("\n");
11482
11483 for (i=0;i<torture_nprocs;i++) {
11484 if (!child_status_out[i]) {
11485 *result = False;
11486 }
11487 }
11488 return timeval_elapsed(&start);
11489 }
11490
11491 #define FLAG_MULTIPROC 1
11492
11493 static struct {
11494 const char *name;
11495 bool (*fn)(int);
11496 unsigned flags;
11497 } torture_ops[] = {
11498 {"FDPASS", run_fdpasstest, 0},
11499 {"LOCK1", run_locktest1, 0},
11500 {"LOCK2", run_locktest2, 0},
11501 {"LOCK3", run_locktest3, 0},
11502 {"LOCK4", run_locktest4, 0},
11503 {"LOCK5", run_locktest5, 0},
11504 {"LOCK6", run_locktest6, 0},
11505 {"LOCK7", run_locktest7, 0},
11506 {"LOCK8", run_locktest8, 0},
11507 {"LOCK9", run_locktest9, 0},
11508 {"UNLINK", run_unlinktest, 0},
11509 {"BROWSE", run_browsetest, 0},
11510 {"ATTR", run_attrtest, 0},
11511 {"TRANS2", run_trans2test, 0},
11512 {"MAXFID", run_maxfidtest, FLAG_MULTIPROC},
11513 {"TORTURE",run_torture, FLAG_MULTIPROC},
11514 {"RANDOMIPC", run_randomipc, 0},
11515 {"NEGNOWAIT", run_negprot_nowait, 0},
11516 {"NBENCH", run_nbench, 0},
11517 {"NBENCH2", run_nbench2, 0},
11518 {"OPLOCK1", run_oplock1, 0},
11519 {"OPLOCK2", run_oplock2, 0},
11520 {"OPLOCK4", run_oplock4, 0},
11521 {"DIR", run_dirtest, 0},
11522 {"DIR1", run_dirtest1, 0},
11523 {"DIR-CREATETIME", run_dir_createtime, 0},
11524 {"DENY1", torture_denytest1, 0},
11525 {"DENY2", torture_denytest2, 0},
11526 {"TCON", run_tcon_test, 0},
11527 {"TCONDEV", run_tcon_devtype_test, 0},
11528 {"RW1", run_readwritetest, 0},
11529 {"RW2", run_readwritemulti, FLAG_MULTIPROC},
11530 {"RW3", run_readwritelarge, 0},
11531 {"RW-SIGNING", run_readwritelarge_signtest, 0},
11532 {"OPEN", run_opentest, 0},
11533 {"POSIX", run_simple_posix_open_test, 0},
11534 {"POSIX-APPEND", run_posix_append, 0},
11535 {"POSIX-SYMLINK-ACL", run_acl_symlink_test, 0},
11536 {"POSIX-SYMLINK-EA", run_ea_symlink_test, 0},
11537 {"POSIX-STREAM-DELETE", run_posix_stream_delete, 0},
11538 {"POSIX-OFD-LOCK", run_posix_ofd_lock_test, 0},
11539 {"WINDOWS-BAD-SYMLINK", run_symlink_open_test, 0},
11540 {"CASE-INSENSITIVE-CREATE", run_case_insensitive_create, 0},
11541 {"ASYNC-ECHO", run_async_echo, 0},
11542 { "UID-REGRESSION-TEST", run_uid_regression_test, 0},
11543 { "SHORTNAME-TEST", run_shortname_test, 0},
11544 { "ADDRCHANGE", run_addrchange, 0},
11545 #if 1
11546 {"OPENATTR", run_openattrtest, 0},
11547 #endif
11548 {"XCOPY", run_xcopy, 0},
11549 {"RENAME", run_rename, 0},
11550 {"RENAME-ACCESS", run_rename_access, 0},
11551 {"OWNER-RIGHTS", run_owner_rights, 0},
11552 {"DELETE", run_deletetest, 0},
11553 {"WILDDELETE", run_wild_deletetest, 0},
11554 {"DELETE-LN", run_deletetest_ln, 0},
11555 {"PROPERTIES", run_properties, 0},
11556 {"MANGLE", torture_mangle, 0},
11557 {"MANGLE1", run_mangle1, 0},
11558 {"MANGLE-ILLEGAL", run_mangle_illegal, 0},
11559 {"W2K", run_w2ktest, 0},
11560 {"TRANS2SCAN", torture_trans2_scan, 0},
11561 {"NTTRANSSCAN", torture_nttrans_scan, 0},
11562 {"UTABLE", torture_utable, 0},
11563 {"CASETABLE", torture_casetable, 0},
11564 {"ERRMAPEXTRACT", run_error_map_extract, 0},
11565 {"PIPE_NUMBER", run_pipe_number, 0},
11566 {"TCON2", run_tcon2_test, 0},
11567 {"IOCTL", torture_ioctl_test, 0},
11568 {"CHKPATH", torture_chkpath_test, 0},
11569 {"FDSESS", run_fdsesstest, 0},
11570 { "EATEST", run_eatest, 0},
11571 { "SESSSETUP_BENCH", run_sesssetup_bench, 0},
11572 { "CHAIN1", run_chain1, 0},
11573 { "CHAIN2", run_chain2, 0},
11574 { "CHAIN3", run_chain3, 0},
11575 { "WINDOWS-WRITE", run_windows_write, 0},
11576 { "LARGE_READX", run_large_readx, 0},
11577 { "NTTRANS-CREATE", run_nttrans_create, 0},
11578 { "NTTRANS-FSCTL", run_nttrans_fsctl, 0},
11579 { "CLI_ECHO", run_cli_echo, 0},
11580 { "TLDAP", run_tldap },
11581 { "STREAMERROR", run_streamerror },
11582 { "NOTIFY-BENCH", run_notify_bench },
11583 { "NOTIFY-BENCH2", run_notify_bench2 },
11584 { "NOTIFY-BENCH3", run_notify_bench3 },
11585 { "BAD-NBT-SESSION", run_bad_nbt_session },
11586 { "IGN-BAD-NEGPROT", run_ign_bad_negprot },
11587 { "SMB-ANY-CONNECT", run_smb_any_connect },
11588 { "NOTIFY-ONLINE", run_notify_online },
11589 { "SMB2-BASIC", run_smb2_basic },
11590 { "SMB2-NEGPROT", run_smb2_negprot },
11591 { "SMB2-SESSION-RECONNECT", run_smb2_session_reconnect },
11592 { "SMB2-TCON-DEPENDENCE", run_smb2_tcon_dependence },
11593 { "SMB2-MULTI-CHANNEL", run_smb2_multi_channel },
11594 { "SMB2-SESSION-REAUTH", run_smb2_session_reauth },
11595 { "SMB2-FTRUNCATE", run_smb2_ftruncate },
11596 { "CLEANUP1", run_cleanup1 },
11597 { "CLEANUP2", run_cleanup2 },
11598 { "CLEANUP3", run_cleanup3 },
11599 { "CLEANUP4", run_cleanup4 },
11600 { "OPLOCK-CANCEL", run_oplock_cancel },
11601 { "PIDHIGH", run_pidhigh },
11602 { "LOCAL-SUBSTITUTE", run_local_substitute, 0},
11603 { "LOCAL-GENCACHE", run_local_gencache, 0},
11604 { "LOCAL-DBWRAP-WATCH1", run_dbwrap_watch1, 0 },
11605 { "LOCAL-DBWRAP-WATCH2", run_dbwrap_watch2, 0 },
11606 { "LOCAL-DBWRAP-DO-LOCKED1", run_dbwrap_do_locked1, 0 },
11607 { "LOCAL-MESSAGING-READ1", run_messaging_read1, 0 },
11608 { "LOCAL-MESSAGING-READ2", run_messaging_read2, 0 },
11609 { "LOCAL-MESSAGING-READ3", run_messaging_read3, 0 },
11610 { "LOCAL-MESSAGING-READ4", run_messaging_read4, 0 },
11611 { "LOCAL-MESSAGING-FDPASS1", run_messaging_fdpass1, 0 },
11612 { "LOCAL-MESSAGING-FDPASS2", run_messaging_fdpass2, 0 },
11613 { "LOCAL-MESSAGING-FDPASS2a", run_messaging_fdpass2a, 0 },
11614 { "LOCAL-MESSAGING-FDPASS2b", run_messaging_fdpass2b, 0 },
11615 { "LOCAL-MESSAGING-SEND-ALL", run_messaging_send_all, 0 },
11616 { "LOCAL-BASE64", run_local_base64, 0},
11617 { "LOCAL-RBTREE", run_local_rbtree, 0},
11618 { "LOCAL-MEMCACHE", run_local_memcache, 0},
11619 { "LOCAL-STREAM-NAME", run_local_stream_name, 0},
11620 { "WBCLIENT-MULTI-PING", run_wbclient_multi_ping, 0},
11621 { "LOCAL-string_to_sid", run_local_string_to_sid, 0},
11622 { "LOCAL-sid_to_string", run_local_sid_to_string, 0},
11623 { "LOCAL-binary_to_sid", run_local_binary_to_sid, 0},
11624 { "LOCAL-DBTRANS", run_local_dbtrans, 0},
11625 { "LOCAL-TEVENT-POLL", run_local_tevent_poll, 0},
11626 { "LOCAL-CONVERT-STRING", run_local_convert_string, 0},
11627 { "LOCAL-CONV-AUTH-INFO", run_local_conv_auth_info, 0},
11628 { "LOCAL-hex_encode_buf", run_local_hex_encode_buf, 0},
11629 { "LOCAL-IDMAP-TDB-COMMON", run_idmap_tdb_common_test, 0},
11630 { "LOCAL-remove_duplicate_addrs2", run_local_remove_duplicate_addrs2, 0},
11631 { "local-tdb-opener", run_local_tdb_opener, 0 },
11632 { "local-tdb-writer", run_local_tdb_writer, 0 },
11633 { "LOCAL-DBWRAP-CTDB", run_local_dbwrap_ctdb, 0 },
11634 { "LOCAL-BENCH-PTHREADPOOL", run_bench_pthreadpool, 0 },
11635 { "LOCAL-PTHREADPOOL-TEVENT", run_pthreadpool_tevent, 0 },
11636 { "LOCAL-G-LOCK1", run_g_lock1, 0 },
11637 { "LOCAL-G-LOCK2", run_g_lock2, 0 },
11638 { "LOCAL-G-LOCK3", run_g_lock3, 0 },
11639 { "LOCAL-G-LOCK4", run_g_lock4, 0 },
11640 { "LOCAL-G-LOCK5", run_g_lock5, 0 },
11641 { "LOCAL-G-LOCK6", run_g_lock6, 0 },
11642 { "LOCAL-G-LOCK-PING-PONG", run_g_lock_ping_pong, 0 },
11643 { "LOCAL-CANONICALIZE-PATH", run_local_canonicalize_path, 0 },
11644 { "LOCAL-NAMEMAP-CACHE1", run_local_namemap_cache1, 0 },
11645 { "qpathinfo-bufsize", run_qpathinfo_bufsize, 0 },
11646 {NULL, NULL, 0}};
11647
11648 /****************************************************************************
11649 run a specified test or "ALL"
11650 ****************************************************************************/
11651 static bool run_test(const char *name)
11652 {
11653 bool ret = True;
11654 bool result = True;
11655 bool found = False;
11656 int i;
11657 double t;
11658 if (strequal(name,"ALL")) {
11659 for (i=0;torture_ops[i].name;i++) {
11660 run_test(torture_ops[i].name);
11661 }
11662 found = True;
11663 }
11664
11665 for (i=0;torture_ops[i].name;i++) {
11666 fstr_sprintf(randomfname, "\\XX%x",
11667 (unsigned)random());
11668
11669 if (strequal(name, torture_ops[i].name)) {
11670 found = True;
11671 printf("Running %s\n", name);
11672 if (torture_ops[i].flags & FLAG_MULTIPROC) {
11673 t = create_procs(torture_ops[i].fn, &result);
11674 if (!result) {
11675 ret = False;
11676 printf("TEST %s FAILED!\n", name);
11677 }
11678 } else {
11679 struct timeval start;
11680 start = timeval_current();
11681 if (!torture_ops[i].fn(0)) {
11682 ret = False;
11683 printf("TEST %s FAILED!\n", name);
11684 }
11685 t = timeval_elapsed(&start);
11686 }
11687 printf("%s took %g secs\n\n", name, t);
11688 }
11689 }
11690
11691 if (!found) {
11692 printf("Did not find a test named %s\n", name);
11693 ret = False;
11694 }
11695
11696 return ret;
11697 }
11698
11699
11700 static void usage(void)
11701 {
11702 int i;
11703
11704 printf("WARNING samba4 test suite is much more complete nowadays.\n");
11705 printf("Please use samba4 torture.\n\n");
11706
11707 printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
11708
11709 printf("\t-d debuglevel\n");
11710 printf("\t-U user%%pass\n");
11711 printf("\t-k use kerberos\n");
11712 printf("\t-N numprocs\n");
11713 printf("\t-n my_netbios_name\n");
11714 printf("\t-W workgroup\n");
11715 printf("\t-o num_operations\n");
11716 printf("\t-O socket_options\n");
11717 printf("\t-m maximum protocol\n");
11718 printf("\t-L use oplocks\n");
11719 printf("\t-c CLIENT.TXT specify client load file for NBENCH\n");
11720 printf("\t-A showall\n");
11721 printf("\t-p port\n");
11722 printf("\t-s seed\n");
11723 printf("\t-b unclist_filename specify multiple shares for multiple connections\n");
11724 printf("\t-f filename filename to test\n");
11725 printf("\t-e encrypt\n");
11726 printf("\n\n");
11727
11728 printf("tests are:");
11729 for (i=0;torture_ops[i].name;i++) {
11730 printf(" %s", torture_ops[i].name);
11731 }
11732 printf("\n");
11733
11734 printf("default test is ALL\n");
11735
11736 exit(1);
11737 }
11738
11739 /****************************************************************************
11740 main program
11741 ****************************************************************************/
11742 int main(int argc,char *argv[])
11743 {
11744 int opt, i;
11745 char *p;
11746 int gotuser = 0;
11747 int gotpass = 0;
11748 bool correct = True;
11749 TALLOC_CTX *frame = talloc_stackframe();
11750 int seed = time(NULL);
11751
11752 #ifdef HAVE_SETBUFFER
11753 setbuffer(stdout, NULL, 0);
11754 #endif
11755
11756 setup_logging("smbtorture", DEBUG_STDOUT);
11757
11758 smb_init_locale();
11759 fault_setup();
11760
11761 if (is_default_dyn_CONFIGFILE()) {
11762 if(getenv("SMB_CONF_PATH")) {
11763 set_dyn_CONFIGFILE(getenv("SMB_CONF_PATH"));
11764 }
11765 }
11766 lp_load_global(get_dyn_CONFIGFILE());
11767 load_interfaces();
11768
11769 if (argc < 2) {
11770 usage();
11771 }
11772
11773 for(p = argv[1]; *p; p++)
11774 if(*p == '\\')
11775 *p = '/';
11776
11777 if (strncmp(argv[1], "//", 2)) {
11778 usage();
11779 }
11780
11781 fstrcpy(host, &argv[1][2]);
11782 p = strchr_m(&host[2],'/');
11783 if (!p) {
11784 usage();
11785 }
11786 *p = 0;
11787 fstrcpy(share, p+1);
11788
11789 fstrcpy(myname, get_myname(talloc_tos()));
11790 if (!*myname) {
11791 fprintf(stderr, "Failed to get my hostname.\n");
11792 return 1;
11793 }
11794
11795 if (*username == 0 && getenv("LOGNAME")) {
11796 fstrcpy(username,getenv("LOGNAME"));
11797 }
11798
11799 argc--;
11800 argv++;
11801
11802 fstrcpy(workgroup, lp_workgroup());
11803
11804 while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ll:d:Aec:ks:b:B:f:"))
11805 != EOF) {
11806 switch (opt) {
11807 case 'p':
11808 port_to_use = atoi(optarg);
11809 break;
11810 case 's':
11811 seed = atoi(optarg);
11812 break;
11813 case 'W':
11814 fstrcpy(workgroup,optarg);
11815 break;
11816 case 'm':
11817 lp_set_cmdline("client max protocol", optarg);
11818 break;
11819 case 'N':
11820 torture_nprocs = atoi(optarg);
11821 break;
11822 case 'o':
11823 torture_numops = atoi(optarg);
11824 break;
11825 case 'd':
11826 lp_set_cmdline("log level", optarg);
11827 break;
11828 case 'O':
11829 sockops = optarg;
11830 break;
11831 case 'L':
11832 use_oplocks = True;
11833 break;
11834 case 'l':
11835 local_path = optarg;
11836 break;
11837 case 'A':
11838 torture_showall = True;
11839 break;
11840 case 'n':
11841 fstrcpy(myname, optarg);
11842 break;
11843 case 'c':
11844 client_txt = optarg;
11845 break;
11846 case 'e':
11847 do_encrypt = true;
11848 break;
11849 case 'k':
11850 #ifdef HAVE_KRB5
11851 use_kerberos = True;
11852 #else
11853 d_printf("No kerberos support compiled in\n");
11854 exit(1);
11855 #endif
11856 break;
11857 case 'U':
11858 gotuser = 1;
11859 fstrcpy(username,optarg);
11860 p = strchr_m(username,'%');
11861 if (p) {
11862 *p = 0;
11863 fstrcpy(password, p+1);
11864 gotpass = 1;
11865 }
11866 break;
11867 case 'b':
11868 fstrcpy(multishare_conn_fname, optarg);
11869 use_multishare_conn = True;
11870 break;
11871 case 'B':
11872 torture_blocksize = atoi(optarg);
11873 break;
11874 case 'f':
11875 test_filename = SMB_STRDUP(optarg);
11876 break;
11877 default:
11878 printf("Unknown option %c (%d)\n", (char)opt, opt);
11879 usage();
11880 }
11881 }
11882
11883 d_printf("using seed %d\n", seed);
11884
11885 srandom(seed);
11886
11887 if(use_kerberos && !gotuser) gotpass = True;
11888
11889 while (!gotpass) {
11890 char pwd[256] = {0};
11891 int rc;
11892
11893 rc = samba_getpass("Password:", pwd, sizeof(pwd), false, false);
11894 if (rc == 0) {
11895 fstrcpy(password, pwd);
11896 gotpass = 1;
11897 }
11898 }
11899
11900 printf("host=%s share=%s user=%s myname=%s\n",
11901 host, share, username, myname);
11902
11903 torture_creds = cli_session_creds_init(frame,
11904 username,
11905 workgroup,
11906 NULL, /* realm */
11907 password,
11908 use_kerberos,
11909 false, /* fallback_after_kerberos */
11910 false, /* use_ccache */
11911 false); /* password_is_nt_hash */
11912 if (torture_creds == NULL) {
11913 d_printf("cli_session_creds_init() failed.\n");
11914 exit(1);
11915 }
11916
11917 if (argc == optind) {
11918 correct = run_test("ALL");
11919 } else {
11920 for (i=optind;i<argc;i++) {
11921 if (!run_test(argv[i])) {
11922 correct = False;
11923 }
11924 }
11925 }
11926
11927 TALLOC_FREE(frame);
11928
11929 if (correct) {
11930 return(0);
11931 } else {
11932 return(1);
11933 }
11934 }
Samba GIT mirror