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