?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ctdb-server: Remove duplicate logic
[samba4-gss.git] / source3 / torture / torture.c
blob36f0d99d911176954649bc5114d050e2471d27a3
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 "libsmb/namequery.h"
24 #include "wbc_async.h"
25 #include "torture/proto.h"
26 #include "libcli/security/security.h"
27 #include "tldap.h"
28 #include "tldap_util.h"
29 #include "tldap_gensec_bind.h"
30 #include "tldap_tls_connect.h"
31 #include "../librpc/gen_ndr/svcctl.h"
32 #include "../lib/util/memcache.h"
33 #include "nsswitch/winbind_client.h"
34 #include "dbwrap/dbwrap.h"
35 #include "dbwrap/dbwrap_open.h"
36 #include "dbwrap/dbwrap_rbt.h"
37 #include "async_smb.h"
38 #include "libsmb/libsmb.h"
39 #include "libsmb/clirap.h"
40 #include "trans2.h"
41 #include "libsmb/nmblib.h"
42 #include "../lib/util/tevent_ntstatus.h"
43 #include "util_tdb.h"
44 #include "../libcli/smb/read_smb.h"
45 #include "../libcli/smb/smbXcli_base.h"
46 #include "lib/util/sys_rw_data.h"
47 #include "lib/util/base64.h"
48 #include "lib/util/time.h"
49 #include "lib/gencache.h"
50 #include "lib/util/sys_rw.h"
51 #include "lib/util/asn1.h"
52 #include "lib/util/util_file.h"
53 #include "lib/param/param.h"
54 #include "auth/gensec/gensec.h"
55 #include "lib/util/string_wrappers.h"
56 #include "source3/lib/substitute.h"
57 #include "ads.h"
58
59 #include <gnutls/gnutls.h>
60 #include <gnutls/crypto.h>
61
62 extern char *optarg;
63 extern int optind;
64
65 fstring host, workgroup, share, password, username, myname;
66 struct cli_credentials *torture_creds;
67 static const char *sockops="TCP_NODELAY";
68 int torture_nprocs=1;
69 static int port_to_use=0;
70 int torture_numops=100;
71 int torture_blocksize=1024*1024;
72 static int procnum; /* records process count number when forking */
73 static struct cli_state *current_cli;
74 static fstring randomfname;
75 static bool use_oplocks;
76 static bool use_level_II_oplocks;
77 static const char *client_txt = "client_oplocks.txt";
78 static bool disable_spnego;
79 static bool use_kerberos;
80 static bool force_dos_errors;
81 static fstring multishare_conn_fname;
82 static bool use_multishare_conn = False;
83 static bool do_encrypt;
84 static const char *local_path = NULL;
85 static enum smb_signing_setting signing_state = SMB_SIGNING_DEFAULT;
86 char *test_filename;
87
88 bool torture_showall = False;
89
90 static double create_procs(bool (*fn)(int), bool *result);
91
92 /********************************************************************
93 Ensure a connection is encrypted.
94 ********************************************************************/
95
96 static bool force_cli_encryption(struct cli_state *c,
97 const char *sharename)
98 {
99 uint16_t major, minor;
100 uint32_t caplow, caphigh;
101 NTSTATUS status;
102
103 if (!SERVER_HAS_UNIX_CIFS(c)) {
104 d_printf("Encryption required and "
105 "server that doesn't support "
106 "UNIX extensions - failing connect\n");
107 return false;
108 }
109
110 status = cli_unix_extensions_version(c, &major, &minor, &caplow,
111 &caphigh);
112 if (!NT_STATUS_IS_OK(status)) {
113 d_printf("Encryption required and "
114 "can't get UNIX CIFS extensions "
115 "version from server: %s\n", nt_errstr(status));
116 return false;
117 }
118
119 if (!(caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)) {
120 d_printf("Encryption required and "
121 "share %s doesn't support "
122 "encryption.\n", sharename);
123 return false;
124 }
125
126 status = cli_smb1_setup_encryption(c, torture_creds);
127 if (!NT_STATUS_IS_OK(status)) {
128 d_printf("Encryption required and "
129 "setup failed with error %s.\n",
130 nt_errstr(status));
131 return false;
132 }
133
134 return true;
135 }
136
137
138 static struct cli_state *open_nbt_connection(void)
139 {
140 struct cli_state *c;
141 NTSTATUS status;
142 int flags = 0;
143
144 if (disable_spnego) {
145 flags |= CLI_FULL_CONNECTION_DONT_SPNEGO;
146 }
147
148 if (use_oplocks) {
149 flags |= CLI_FULL_CONNECTION_OPLOCKS;
150 }
151
152 if (use_level_II_oplocks) {
153 flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS;
154 }
155
156 if (force_dos_errors) {
157 flags |= CLI_FULL_CONNECTION_FORCE_DOS_ERRORS;
158 }
159
160 status = cli_connect_nb(NULL,
161 host,
162 NULL,
163 port_to_use,
164 0x20,
165 myname,
166 signing_state,
167 flags,
168 &c);
169 if (!NT_STATUS_IS_OK(status)) {
170 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
171 return NULL;
172 }
173
174 cli_set_timeout(c, 120000); /* set a really long timeout (2 minutes) */
175
176 return c;
177 }
178
179 /****************************************************************************
180 Send a corrupt session request. See rfc1002.txt 4.3 and 4.3.2.
181 ****************************************************************************/
182
183 static bool cli_bad_session_request(int fd,
184 struct nmb_name *calling, struct nmb_name *called)
185 {
186 TALLOC_CTX *frame;
187 uint8_t len_buf[4];
188 struct iovec iov[3];
189 ssize_t len;
190 uint8_t *inbuf;
191 int err;
192 bool ret = false;
193 uint8_t message_type;
194 uint8_t error;
195 struct tevent_context *ev;
196 struct tevent_req *req;
197
198 frame = talloc_stackframe();
199
200 iov[0].iov_base = len_buf;
201 iov[0].iov_len = sizeof(len_buf);
202
203 /* put in the destination name */
204
205 iov[1].iov_base = name_mangle(talloc_tos(), called->name,
206 called->name_type);
207 if (iov[1].iov_base == NULL) {
208 goto fail;
209 }
210 iov[1].iov_len = name_len((unsigned char *)iov[1].iov_base,
211 talloc_get_size(iov[1].iov_base));
212
213 /* and my name */
214
215 iov[2].iov_base = name_mangle(talloc_tos(), calling->name,
216 calling->name_type);
217 if (iov[2].iov_base == NULL) {
218 goto fail;
219 }
220 iov[2].iov_len = name_len((unsigned char *)iov[2].iov_base,
221 talloc_get_size(iov[2].iov_base));
222
223 /* Deliberately corrupt the name len (first byte) */
224 *((uint8_t *)iov[2].iov_base) = 100;
225
226 /* send a session request (RFC 1002) */
227 /* setup the packet length
228 * Remove four bytes from the length count, since the length
229 * field in the NBT Session Service header counts the number
230 * of bytes which follow. The cli_send_smb() function knows
231 * about this and accounts for those four bytes.
232 * CRH.
233 */
234
235 _smb_setlen(len_buf, iov[1].iov_len + iov[2].iov_len);
236 SCVAL(len_buf,0,0x81);
237
238 len = write_data_iov(fd, iov, 3);
239 if (len == -1) {
240 goto fail;
241 }
242
243 ev = samba_tevent_context_init(frame);
244 if (ev == NULL) {
245 goto fail;
246 }
247 req = read_smb_send(frame, ev, fd);
248 if (req == NULL) {
249 goto fail;
250 }
251 if (!tevent_req_poll(req, ev)) {
252 goto fail;
253 }
254 len = read_smb_recv(req, talloc_tos(), &inbuf, &err);
255 if (len == -1) {
256 errno = err;
257 goto fail;
258 }
259 TALLOC_FREE(ev);
260
261 message_type = CVAL(inbuf, 0);
262 if (message_type != 0x83) {
263 d_fprintf(stderr, "Expected msg type 0x83, got 0x%2.2x\n",
264 message_type);
265 goto fail;
266 }
267
268 if (smb_len(inbuf) != 1) {
269 d_fprintf(stderr, "Expected smb_len 1, got %d\n",
270 (int)smb_len(inbuf));
271 goto fail;
272 }
273
274 error = CVAL(inbuf, 4);
275 if (error != 0x82) {
276 d_fprintf(stderr, "Expected error 0x82, got %d\n",
277 (int)error);
278 goto fail;
279 }
280
281 ret = true;
282 fail:
283 TALLOC_FREE(frame);
284 return ret;
285 }
286
287 /* Insert a NULL at the first separator of the given path and return a pointer
288 * to the remainder of the string.
289 */
290 static char *
291 terminate_path_at_separator(char * path)
292 {
293 char * p;
294
295 if (!path) {
296 return NULL;
297 }
298
299 if ((p = strchr_m(path, '/'))) {
300 *p = '\0';
301 return p + 1;
302 }
303
304 if ((p = strchr_m(path, '\\'))) {
305 *p = '\0';
306 return p + 1;
307 }
308
309 /* No separator. */
310 return NULL;
311 }
312
313 /*
314 parse a //server/share type UNC name
315 */
316 bool smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
317 char **hostname, char **sharename)
318 {
319 char *p;
320
321 *hostname = *sharename = NULL;
322
323 if (strncmp(unc_name, "\\\\", 2) &&
324 strncmp(unc_name, "//", 2)) {
325 return False;
326 }
327
328 *hostname = talloc_strdup(mem_ctx, &unc_name[2]);
329 p = terminate_path_at_separator(*hostname);
330
331 if (p && *p) {
332 *sharename = talloc_strdup(mem_ctx, p);
333 terminate_path_at_separator(*sharename);
334 }
335
336 if (*hostname && *sharename) {
337 return True;
338 }
339
340 TALLOC_FREE(*hostname);
341 TALLOC_FREE(*sharename);
342 return False;
343 }
344
345 static bool torture_open_connection_share(struct cli_state **c,
346 const char *hostname,
347 const char *sharename,
348 int flags)
349 {
350 NTSTATUS status;
351
352 status = cli_full_connection_creds(NULL,
353 c,
354 myname,
355 hostname,
356 NULL, /* dest_ss */
357 port_to_use,
358 sharename,
359 "?????",
360 torture_creds,
361 flags);
362 if (!NT_STATUS_IS_OK(status)) {
363 printf("failed to open share connection: //%s/%s port:%d - %s\n",
364 hostname, sharename, port_to_use, nt_errstr(status));
365 return False;
366 }
367
368 cli_set_timeout(*c, 120000); /* set a really long timeout (2 minutes) */
369
370 if (do_encrypt) {
371 return force_cli_encryption(*c,
372 sharename);
373 }
374 return True;
375 }
376
377 bool torture_open_connection_flags(struct cli_state **c, int conn_index, int flags)
378 {
379 char **unc_list = NULL;
380 int num_unc_names = 0;
381 bool result;
382
383 if (use_multishare_conn==True) {
384 char *h, *s;
385 unc_list = file_lines_load(multishare_conn_fname, &num_unc_names, 0, NULL);
386 if (!unc_list || num_unc_names <= 0) {
387 printf("Failed to load unc names list from '%s'\n", multishare_conn_fname);
388 exit(1);
389 }
390
391 if (!smbcli_parse_unc(unc_list[conn_index % num_unc_names],
392 NULL, &h, &s)) {
393 printf("Failed to parse UNC name %s\n",
394 unc_list[conn_index % num_unc_names]);
395 TALLOC_FREE(unc_list);
396 exit(1);
397 }
398
399 result = torture_open_connection_share(c, h, s, flags);
400
401 /* h, s were copied earlier */
402 TALLOC_FREE(unc_list);
403 return result;
404 }
405
406 return torture_open_connection_share(c, host, share, flags);
407 }
408
409 bool torture_open_connection(struct cli_state **c, int conn_index)
410 {
411 int flags = CLI_FULL_CONNECTION_FORCE_SMB1;
412
413 if (use_oplocks) {
414 flags |= CLI_FULL_CONNECTION_OPLOCKS;
415 }
416 if (use_level_II_oplocks) {
417 flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS;
418 }
419
420 return torture_open_connection_flags(c, conn_index, flags);
421 }
422
423 bool torture_init_connection(struct cli_state **pcli)
424 {
425 struct cli_state *cli;
426
427 cli = open_nbt_connection();
428 if (cli == NULL) {
429 return false;
430 }
431
432 *pcli = cli;
433 return true;
434 }
435
436 bool torture_cli_session_setup2(struct cli_state *cli, uint16_t *new_vuid)
437 {
438 uint16_t old_vuid = cli_state_get_uid(cli);
439 NTSTATUS status;
440 bool ret;
441
442 cli_state_set_uid(cli, 0);
443 status = cli_session_setup_creds(cli, torture_creds);
444 ret = NT_STATUS_IS_OK(status);
445 *new_vuid = cli_state_get_uid(cli);
446 cli_state_set_uid(cli, old_vuid);
447 return ret;
448 }
449
450
451 bool torture_close_connection(struct cli_state *c)
452 {
453 bool ret = True;
454 NTSTATUS status;
455
456 status = cli_tdis(c);
457 if (!NT_STATUS_IS_OK(status)) {
458 printf("tdis failed (%s)\n", nt_errstr(status));
459 ret = False;
460 }
461
462 cli_shutdown(c);
463
464 return ret;
465 }
466
467 void torture_conn_set_sockopt(struct cli_state *cli)
468 {
469 smbXcli_conn_set_sockopt(cli->conn, sockops);
470 }
471
472 static NTSTATUS torture_delete_fn(struct file_info *finfo,
473 const char *pattern,
474 void *state)
475 {
476 NTSTATUS status;
477 char *filename = NULL;
478 char *dirname = NULL;
479 char *p = NULL;
480 TALLOC_CTX *frame = talloc_stackframe();
481 struct cli_state *cli = (struct cli_state *)state;
482
483 if (ISDOT(finfo->name) || ISDOTDOT(finfo->name)) {
484 TALLOC_FREE(frame);
485 return NT_STATUS_OK;
486 }
487
488 dirname = talloc_strdup(frame, pattern);
489 if (dirname == NULL) {
490 TALLOC_FREE(frame);
491 return NT_STATUS_NO_MEMORY;
492 }
493 p = strrchr_m(dirname, '\\');
494 if (p != NULL) {
495 /* Remove the terminating '\' */
496 *p = '\0';
497 }
498 if (dirname[0] != '\0') {
499 filename = talloc_asprintf(frame,
500 "%s\\%s",
501 dirname,
502 finfo->name);
503 } else {
504 filename = talloc_asprintf(frame,
505 "%s",
506 finfo->name);
507 }
508 if (filename == NULL) {
509 TALLOC_FREE(frame);
510 return NT_STATUS_NO_MEMORY;
511 }
512 if (finfo->attr & FILE_ATTRIBUTE_DIRECTORY) {
513 char *subdirname = talloc_asprintf(frame,
514 "%s\\*",
515 filename);
516 if (subdirname == NULL) {
517 TALLOC_FREE(frame);
518 return NT_STATUS_NO_MEMORY;
519 }
520 status = cli_list(cli,
521 subdirname,
522 FILE_ATTRIBUTE_DIRECTORY |
523 FILE_ATTRIBUTE_HIDDEN |
524 FILE_ATTRIBUTE_SYSTEM,
525 torture_delete_fn,
526 cli);
527 if (!NT_STATUS_IS_OK(status)) {
528 printf("torture_delete_fn: cli_list "
529 "of %s failed (%s)\n",
530 subdirname,
531 nt_errstr(status));
532 TALLOC_FREE(frame);
533 return status;
534 }
535 status = cli_rmdir(cli, filename);
536 } else {
537 status = cli_unlink(cli,
538 filename,
539 FILE_ATTRIBUTE_SYSTEM |
540 FILE_ATTRIBUTE_HIDDEN);
541 }
542 if (!NT_STATUS_IS_OK(status)) {
543 if (finfo->attr & FILE_ATTRIBUTE_DIRECTORY) {
544 printf("torture_delete_fn: cli_rmdir"
545 " of %s failed (%s)\n",
546 filename,
547 nt_errstr(status));
548 } else {
549 printf("torture_delete_fn: cli_unlink"
550 " of %s failed (%s)\n",
551 filename,
552 nt_errstr(status));
553 }
554 }
555 TALLOC_FREE(frame);
556 return status;
557 }
558
559 void torture_deltree(struct cli_state *cli, const char *dname)
560 {
561 char *mask = NULL;
562 NTSTATUS status;
563
564 /* It might be a file */
565 (void)cli_unlink(cli,
566 dname,
567 FILE_ATTRIBUTE_SYSTEM |
568 FILE_ATTRIBUTE_HIDDEN);
569
570 mask = talloc_asprintf(cli,
571 "%s\\*",
572 dname);
573 if (mask == NULL) {
574 printf("torture_deltree: talloc_asprintf failed\n");
575 return;
576 }
577
578 status = cli_list(cli,
579 mask,
580 FILE_ATTRIBUTE_DIRECTORY |
581 FILE_ATTRIBUTE_HIDDEN|
582 FILE_ATTRIBUTE_SYSTEM,
583 torture_delete_fn,
584 cli);
585 if (!NT_STATUS_IS_OK(status)) {
586 printf("torture_deltree: cli_list of %s failed (%s)\n",
587 mask,
588 nt_errstr(status));
589 }
590 TALLOC_FREE(mask);
591 status = cli_rmdir(cli, dname);
592 if (!NT_STATUS_IS_OK(status)) {
593 printf("torture_deltree: cli_rmdir of %s failed (%s)\n",
594 dname,
595 nt_errstr(status));
596 }
597 }
598
599 /* check if the server produced the expected dos or nt error code */
600 static bool check_both_error(int line, NTSTATUS status,
601 uint8_t eclass, uint32_t ecode, NTSTATUS nterr)
602 {
603 if (NT_STATUS_IS_DOS(status)) {
604 uint8_t cclass;
605 uint32_t num;
606
607 /* Check DOS error */
608 cclass = NT_STATUS_DOS_CLASS(status);
609 num = NT_STATUS_DOS_CODE(status);
610
611 if (eclass != cclass || ecode != num) {
612 printf("unexpected error code class=%d code=%d\n",
613 (int)cclass, (int)num);
614 printf(" expected %d/%d %s (line=%d)\n",
615 (int)eclass, (int)ecode, nt_errstr(nterr), line);
616 return false;
617 }
618 } else {
619 /* Check NT error */
620 if (!NT_STATUS_EQUAL(nterr, status)) {
621 printf("unexpected error code %s\n",
622 nt_errstr(status));
623 printf(" expected %s (line=%d)\n",
624 nt_errstr(nterr), line);
625 return false;
626 }
627 }
628
629 return true;
630 }
631
632
633 /* check if the server produced the expected error code */
634 static bool check_error(int line, NTSTATUS status,
635 uint8_t eclass, uint32_t ecode, NTSTATUS nterr)
636 {
637 if (NT_STATUS_IS_DOS(status)) {
638 uint8_t cclass;
639 uint32_t num;
640
641 /* Check DOS error */
642
643 cclass = NT_STATUS_DOS_CLASS(status);
644 num = NT_STATUS_DOS_CODE(status);
645
646 if (eclass != cclass || ecode != num) {
647 printf("unexpected error code class=%d code=%d\n",
648 (int)cclass, (int)num);
649 printf(" expected %d/%d %s (line=%d)\n",
650 (int)eclass, (int)ecode, nt_errstr(nterr),
651 line);
652 return False;
653 }
654
655 } else {
656 /* Check NT error */
657
658 if (NT_STATUS_V(nterr) != NT_STATUS_V(status)) {
659 printf("unexpected error code %s\n",
660 nt_errstr(status));
661 printf(" expected %s (line=%d)\n", nt_errstr(nterr),
662 line);
663 return False;
664 }
665 }
666
667 return True;
668 }
669
670 NTSTATUS cli_qpathinfo1(struct cli_state *cli,
671 const char *fname,
672 time_t *change_time,
673 time_t *access_time,
674 time_t *write_time,
675 off_t *size,
676 uint32_t *pattr)
677 {
678 int timezone = smb1cli_conn_server_time_zone(cli->conn);
679 time_t (*date_fn)(const void *buf, int serverzone) = NULL;
680 uint8_t *rdata = NULL;
681 uint32_t num_rdata;
682 NTSTATUS status;
683
684 status = cli_qpathinfo(talloc_tos(),
685 cli,
686 fname,
687 SMB_INFO_STANDARD,
688 22,
689 CLI_BUFFER_SIZE,
690 &rdata,
691 &num_rdata);
692 if (!NT_STATUS_IS_OK(status)) {
693 return status;
694 }
695 if (cli->win95) {
696 date_fn = make_unix_date;
697 } else {
698 date_fn = make_unix_date2;
699 }
700
701 if (change_time) {
702 *change_time = date_fn(rdata + 0, timezone);
703 }
704 if (access_time) {
705 *access_time = date_fn(rdata + 4, timezone);
706 }
707 if (write_time) {
708 *write_time = date_fn(rdata + 8, timezone);
709 }
710 if (size) {
711 *size = PULL_LE_U32(rdata, 12);
712 }
713 if (pattr) {
714 *pattr = PULL_LE_U16(rdata, l1_attrFile);
715 }
716 return NT_STATUS_OK;
717 }
718
719 static bool wait_lock(struct cli_state *c, int fnum, uint32_t offset, uint32_t len)
720 {
721 NTSTATUS status;
722
723 status = cli_lock32(c, fnum, offset, len, -1, WRITE_LOCK);
724
725 while (!NT_STATUS_IS_OK(status)) {
726 if (!check_both_error(__LINE__, status, ERRDOS,
727 ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) {
728 return false;
729 }
730
731 status = cli_lock32(c, fnum, offset, len, -1, WRITE_LOCK);
732 }
733
734 return true;
735 }
736
737
738 static bool rw_torture(struct cli_state *c)
739 {
740 const char *lockfname = "\\torture.lck";
741 fstring fname;
742 uint16_t fnum;
743 uint16_t fnum2;
744 pid_t pid2, pid = getpid();
745 int i, j;
746 char buf[1024];
747 bool correct = True;
748 size_t nread = 0;
749 NTSTATUS status;
750
751 memset(buf, '\0', sizeof(buf));
752
753 status = cli_openx(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
754 DENY_NONE, &fnum2);
755 if (!NT_STATUS_IS_OK(status)) {
756 status = cli_openx(c, lockfname, O_RDWR, DENY_NONE, &fnum2);
757 }
758 if (!NT_STATUS_IS_OK(status)) {
759 printf("open of %s failed (%s)\n",
760 lockfname, nt_errstr(status));
761 return False;
762 }
763
764 for (i=0;i<torture_numops;i++) {
765 unsigned n = (unsigned)sys_random()%10;
766
767 if (i % 10 == 0) {
768 printf("%d\r", i); fflush(stdout);
769 }
770 slprintf(fname, sizeof(fstring) - 1, "\\torture.%u", n);
771
772 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
773 return False;
774 }
775
776 status = cli_openx(c, fname, O_RDWR | O_CREAT | O_TRUNC,
777 DENY_ALL, &fnum);
778 if (!NT_STATUS_IS_OK(status)) {
779 printf("open failed (%s)\n", nt_errstr(status));
780 correct = False;
781 break;
782 }
783
784 status = cli_writeall(c, fnum, 0, (uint8_t *)&pid, 0,
785 sizeof(pid), NULL);
786 if (!NT_STATUS_IS_OK(status)) {
787 printf("write failed (%s)\n", nt_errstr(status));
788 correct = False;
789 }
790
791 for (j=0;j<50;j++) {
792 status = cli_writeall(c, fnum, 0, (uint8_t *)buf,
793 sizeof(pid)+(j*sizeof(buf)),
794 sizeof(buf), NULL);
795 if (!NT_STATUS_IS_OK(status)) {
796 printf("write failed (%s)\n",
797 nt_errstr(status));
798 correct = False;
799 }
800 }
801
802 pid2 = 0;
803
804 status = cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid),
805 &nread);
806 if (!NT_STATUS_IS_OK(status)) {
807 printf("read failed (%s)\n", nt_errstr(status));
808 correct = false;
809 } else if (nread != sizeof(pid)) {
810 printf("read/write compare failed: "
811 "recv %ld req %ld\n", (unsigned long)nread,
812 (unsigned long)sizeof(pid));
813 correct = false;
814 }
815
816 if (pid2 != pid) {
817 printf("data corruption!\n");
818 correct = False;
819 }
820
821 status = cli_close(c, fnum);
822 if (!NT_STATUS_IS_OK(status)) {
823 printf("close failed (%s)\n", nt_errstr(status));
824 correct = False;
825 }
826
827 status = cli_unlink(c, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
828 if (!NT_STATUS_IS_OK(status)) {
829 printf("unlink failed (%s)\n", nt_errstr(status));
830 correct = False;
831 }
832
833 status = cli_unlock(c, fnum2, n*sizeof(int), sizeof(int));
834 if (!NT_STATUS_IS_OK(status)) {
835 printf("unlock failed (%s)\n", nt_errstr(status));
836 correct = False;
837 }
838 }
839
840 cli_close(c, fnum2);
841 cli_unlink(c, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
842
843 printf("%d\n", i);
844
845 return correct;
846 }
847
848 static bool run_torture(int dummy)
849 {
850 struct cli_state *cli;
851 bool ret;
852
853 cli = current_cli;
854
855 smbXcli_conn_set_sockopt(cli->conn, sockops);
856
857 ret = rw_torture(cli);
858
859 if (!torture_close_connection(cli)) {
860 ret = False;
861 }
862
863 return ret;
864 }
865
866 static bool rw_torture3(struct cli_state *c, char *lockfname)
867 {
868 uint16_t fnum = (uint16_t)-1;
869 unsigned int i = 0;
870 char buf[131072];
871 char buf_rd[131072];
872 unsigned count;
873 unsigned countprev = 0;
874 size_t sent = 0;
875 bool correct = True;
876 NTSTATUS status = NT_STATUS_OK;
877
878 srandom(1);
879 for (i = 0; i < sizeof(buf); i += sizeof(uint32_t))
880 {
881 SIVAL(buf, i, sys_random());
882 }
883
884 if (procnum == 0)
885 {
886 status = cli_unlink(
887 c, lockfname,
888 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
889 if (!NT_STATUS_IS_OK(status)) {
890 printf("unlink failed (%s) (normal, this file should "
891 "not exist)\n", nt_errstr(status));
892 }
893
894 status = cli_openx(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
895 DENY_NONE, &fnum);
896 if (!NT_STATUS_IS_OK(status)) {
897 printf("first open read/write of %s failed (%s)\n",
898 lockfname, nt_errstr(status));
899 return False;
900 }
901 }
902 else
903 {
904 for (i = 0; i < 500 && fnum == (uint16_t)-1; i++)
905 {
906 status = cli_openx(c, lockfname, O_RDONLY,
907 DENY_NONE, &fnum);
908 if (NT_STATUS_IS_OK(status)) {
909 break;
910 }
911 smb_msleep(10);
912 }
913 if (!NT_STATUS_IS_OK(status)) {
914 printf("second open read-only of %s failed (%s)\n",
915 lockfname, nt_errstr(status));
916 return False;
917 }
918 }
919
920 i = 0;
921 for (count = 0; count < sizeof(buf); count += sent)
922 {
923 if (count >= countprev) {
924 printf("%d %8d\r", i, count);
925 fflush(stdout);
926 i++;
927 countprev += (sizeof(buf) / 20);
928 }
929
930 if (procnum == 0)
931 {
932 sent = ((unsigned)sys_random()%(20))+ 1;
933 if (sent > sizeof(buf) - count)
934 {
935 sent = sizeof(buf) - count;
936 }
937
938 status = cli_writeall(c, fnum, 0, (uint8_t *)buf+count,
939 count, sent, NULL);
940 if (!NT_STATUS_IS_OK(status)) {
941 printf("write failed (%s)\n",
942 nt_errstr(status));
943 correct = False;
944 }
945 }
946 else
947 {
948 status = cli_read(c, fnum, buf_rd+count, count,
949 sizeof(buf)-count, &sent);
950 if(!NT_STATUS_IS_OK(status)) {
951 printf("read failed offset:%d size:%ld (%s)\n",
952 count, (unsigned long)sizeof(buf)-count,
953 nt_errstr(status));
954 correct = False;
955 sent = 0;
956 } else if (sent > 0) {
957 if (memcmp(buf_rd+count, buf+count, sent) != 0)
958 {
959 printf("read/write compare failed\n");
960 printf("offset: %d req %ld recvd %ld\n", count, (unsigned long)sizeof(buf)-count, (unsigned long)sent);
961 correct = False;
962 break;
963 }
964 }
965 }
966
967 }
968
969 status = cli_close(c, fnum);
970 if (!NT_STATUS_IS_OK(status)) {
971 printf("close failed (%s)\n", nt_errstr(status));
972 correct = False;
973 }
974
975 return correct;
976 }
977
978 static bool rw_torture2(struct cli_state *c1, struct cli_state *c2)
979 {
980 const char *lockfname = "\\torture2.lck";
981 uint16_t fnum1;
982 uint16_t fnum2;
983 int i;
984 char buf[131072];
985 char buf_rd[131072];
986 bool correct = True;
987 size_t bytes_read;
988 NTSTATUS status;
989
990 status = cli_unlink(c1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
991 if (!NT_STATUS_IS_OK(status)) {
992 printf("unlink failed (%s) (normal, this file should not exist)\n", nt_errstr(status));
993 }
994
995 status = cli_openx(c1, lockfname, O_RDWR | O_CREAT | O_EXCL,
996 DENY_NONE, &fnum1);
997 if (!NT_STATUS_IS_OK(status)) {
998 printf("first open read/write of %s failed (%s)\n",
999 lockfname, nt_errstr(status));
1000 return False;
1001 }
1002
1003 status = cli_openx(c2, lockfname, O_RDONLY, DENY_NONE, &fnum2);
1004 if (!NT_STATUS_IS_OK(status)) {
1005 printf("second open read-only of %s failed (%s)\n",
1006 lockfname, nt_errstr(status));
1007 cli_close(c1, fnum1);
1008 return False;
1009 }
1010
1011 for (i = 0; i < torture_numops; i++)
1012 {
1013 size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
1014 if (i % 10 == 0) {
1015 printf("%d\r", i); fflush(stdout);
1016 }
1017
1018 generate_random_buffer((unsigned char *)buf, buf_size);
1019
1020 status = cli_writeall(c1, fnum1, 0, (uint8_t *)buf, 0,
1021 buf_size, NULL);
1022 if (!NT_STATUS_IS_OK(status)) {
1023 printf("write failed (%s)\n", nt_errstr(status));
1024 correct = False;
1025 break;
1026 }
1027
1028 status = cli_read(c2, fnum2, buf_rd, 0, buf_size, &bytes_read);
1029 if(!NT_STATUS_IS_OK(status)) {
1030 printf("read failed (%s)\n", nt_errstr(status));
1031 correct = false;
1032 break;
1033 } else if (bytes_read != buf_size) {
1034 printf("read failed\n");
1035 printf("read %ld, expected %ld\n",
1036 (unsigned long)bytes_read,
1037 (unsigned long)buf_size);
1038 correct = False;
1039 break;
1040 }
1041
1042 if (memcmp(buf_rd, buf, buf_size) != 0)
1043 {
1044 printf("read/write compare failed\n");
1045 correct = False;
1046 break;
1047 }
1048 }
1049
1050 status = cli_close(c2, fnum2);
1051 if (!NT_STATUS_IS_OK(status)) {
1052 printf("close failed (%s)\n", nt_errstr(status));
1053 correct = False;
1054 }
1055
1056 status = cli_close(c1, fnum1);
1057 if (!NT_STATUS_IS_OK(status)) {
1058 printf("close failed (%s)\n", nt_errstr(status));
1059 correct = False;
1060 }
1061
1062 status = cli_unlink(c1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1063 if (!NT_STATUS_IS_OK(status)) {
1064 printf("unlink failed (%s)\n", nt_errstr(status));
1065 correct = False;
1066 }
1067
1068 return correct;
1069 }
1070
1071 static bool run_readwritetest(int dummy)
1072 {
1073 struct cli_state *cli1, *cli2;
1074 bool test1, test2 = False;
1075
1076 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1077 return False;
1078 }
1079 smbXcli_conn_set_sockopt(cli1->conn, sockops);
1080 smbXcli_conn_set_sockopt(cli2->conn, sockops);
1081
1082 printf("starting readwritetest\n");
1083
1084 test1 = rw_torture2(cli1, cli2);
1085 printf("Passed readwritetest v1: %s\n", BOOLSTR(test1));
1086
1087 if (test1) {
1088 test2 = rw_torture2(cli1, cli1);
1089 printf("Passed readwritetest v2: %s\n", BOOLSTR(test2));
1090 }
1091
1092 if (!torture_close_connection(cli1)) {
1093 test1 = False;
1094 }
1095
1096 if (!torture_close_connection(cli2)) {
1097 test2 = False;
1098 }
1099
1100 return (test1 && test2);
1101 }
1102
1103 static bool run_readwritemulti(int dummy)
1104 {
1105 struct cli_state *cli;
1106 bool test;
1107
1108 cli = current_cli;
1109
1110 smbXcli_conn_set_sockopt(cli->conn, sockops);
1111
1112 printf("run_readwritemulti: fname %s\n", randomfname);
1113 test = rw_torture3(cli, randomfname);
1114
1115 if (!torture_close_connection(cli)) {
1116 test = False;
1117 }
1118
1119 return test;
1120 }
1121
1122 static bool run_readwritelarge_internal(void)
1123 {
1124 static struct cli_state *cli1;
1125 uint16_t fnum1;
1126 const char *lockfname = "\\large.dat";
1127 off_t fsize;
1128 char buf[126*1024];
1129 bool correct = True;
1130 NTSTATUS status;
1131
1132 if (!torture_open_connection(&cli1, 0)) {
1133 return False;
1134 }
1135 smbXcli_conn_set_sockopt(cli1->conn, sockops);
1136 memset(buf,'\0',sizeof(buf));
1137
1138 printf("starting readwritelarge_internal\n");
1139
1140 cli_unlink(cli1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1141
1142 status = cli_openx(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL,
1143 DENY_NONE, &fnum1);
1144 if (!NT_STATUS_IS_OK(status)) {
1145 printf("open read/write of %s failed (%s)\n", lockfname, nt_errstr(status));
1146 return False;
1147 }
1148
1149 cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf), NULL);
1150
1151 status = cli_qfileinfo_basic(cli1, fnum1, NULL, &fsize, NULL, NULL,
1152 NULL, NULL, NULL);
1153 if (!NT_STATUS_IS_OK(status)) {
1154 printf("qfileinfo failed (%s)\n", nt_errstr(status));
1155 correct = False;
1156 }
1157
1158 if (fsize == sizeof(buf))
1159 printf("readwritelarge_internal test 1 succeeded (size = %lx)\n",
1160 (unsigned long)fsize);
1161 else {
1162 printf("readwritelarge_internal test 1 failed (size = %lx)\n",
1163 (unsigned long)fsize);
1164 correct = False;
1165 }
1166
1167 status = cli_close(cli1, fnum1);
1168 if (!NT_STATUS_IS_OK(status)) {
1169 printf("close failed (%s)\n", nt_errstr(status));
1170 correct = False;
1171 }
1172
1173 status = cli_unlink(cli1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1174 if (!NT_STATUS_IS_OK(status)) {
1175 printf("unlink failed (%s)\n", nt_errstr(status));
1176 correct = False;
1177 }
1178
1179 status = cli_openx(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL,
1180 DENY_NONE, &fnum1);
1181 if (!NT_STATUS_IS_OK(status)) {
1182 printf("open read/write of %s failed (%s)\n", lockfname, nt_errstr(status));
1183 return False;
1184 }
1185
1186 cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf), NULL);
1187
1188 status = cli_qfileinfo_basic(cli1, fnum1, NULL, &fsize, NULL, NULL,
1189 NULL, NULL, NULL);
1190 if (!NT_STATUS_IS_OK(status)) {
1191 printf("qfileinfo failed (%s)\n", nt_errstr(status));
1192 correct = False;
1193 }
1194
1195 if (fsize == sizeof(buf))
1196 printf("readwritelarge_internal test 2 succeeded (size = %lx)\n",
1197 (unsigned long)fsize);
1198 else {
1199 printf("readwritelarge_internal test 2 failed (size = %lx)\n",
1200 (unsigned long)fsize);
1201 correct = False;
1202 }
1203
1204 status = cli_close(cli1, fnum1);
1205 if (!NT_STATUS_IS_OK(status)) {
1206 printf("close failed (%s)\n", nt_errstr(status));
1207 correct = False;
1208 }
1209
1210 if (!torture_close_connection(cli1)) {
1211 correct = False;
1212 }
1213 return correct;
1214 }
1215
1216 static bool run_readwritelarge(int dummy)
1217 {
1218 return run_readwritelarge_internal();
1219 }
1220
1221 static bool run_readwritelarge_signtest(int dummy)
1222 {
1223 bool ret;
1224 signing_state = SMB_SIGNING_REQUIRED;
1225 ret = run_readwritelarge_internal();
1226 signing_state = SMB_SIGNING_DEFAULT;
1227 return ret;
1228 }
1229
1230 int line_count = 0;
1231 int nbio_id;
1232
1233 #define ival(s) strtol(s, NULL, 0)
1234
1235 /* run a test that simulates an approximate netbench client load */
1236 static bool run_netbench(int client)
1237 {
1238 struct cli_state *cli;
1239 int i;
1240 char line[1024];
1241 char cname[20];
1242 FILE *f;
1243 const char *params[20];
1244 bool correct = True;
1245
1246 cli = current_cli;
1247
1248 nbio_id = client;
1249
1250 smbXcli_conn_set_sockopt(cli->conn, sockops);
1251
1252 nb_setup(cli);
1253
1254 slprintf(cname,sizeof(cname)-1, "client%d", client);
1255
1256 f = fopen(client_txt, "r");
1257
1258 if (!f) {
1259 perror(client_txt);
1260 return False;
1261 }
1262
1263 while (fgets(line, sizeof(line)-1, f)) {
1264 char *saveptr;
1265 line_count++;
1266
1267 line[strlen(line)-1] = 0;
1268
1269 /* printf("[%d] %s\n", line_count, line); */
1270
1271 all_string_sub(line,"client1", cname, sizeof(line));
1272
1273 /* parse the command parameters */
1274 params[0] = strtok_r(line, " ", &saveptr);
1275 i = 0;
1276 while (params[i]) params[++i] = strtok_r(NULL, " ", &saveptr);
1277
1278 params[i] = "";
1279
1280 if (i < 2) continue;
1281
1282 if (!strncmp(params[0],"SMB", 3)) {
1283 printf("ERROR: You are using a dbench 1 load file\n");
1284 exit(1);
1285 }
1286
1287 if (!strcmp(params[0],"NTCreateX")) {
1288 nb_createx(params[1], ival(params[2]), ival(params[3]),
1289 ival(params[4]));
1290 } else if (!strcmp(params[0],"Close")) {
1291 nb_close(ival(params[1]));
1292 } else if (!strcmp(params[0],"Rename")) {
1293 nb_rename(params[1], params[2]);
1294 } else if (!strcmp(params[0],"Unlink")) {
1295 nb_unlink(params[1]);
1296 } else if (!strcmp(params[0],"Deltree")) {
1297 nb_deltree(params[1]);
1298 } else if (!strcmp(params[0],"Rmdir")) {
1299 nb_rmdir(params[1]);
1300 } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
1301 nb_qpathinfo(params[1]);
1302 } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
1303 nb_qfileinfo(ival(params[1]));
1304 } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
1305 nb_qfsinfo(ival(params[1]));
1306 } else if (!strcmp(params[0],"FIND_FIRST")) {
1307 nb_findfirst(params[1]);
1308 } else if (!strcmp(params[0],"WriteX")) {
1309 nb_writex(ival(params[1]),
1310 ival(params[2]), ival(params[3]), ival(params[4]));
1311 } else if (!strcmp(params[0],"ReadX")) {
1312 nb_readx(ival(params[1]),
1313 ival(params[2]), ival(params[3]), ival(params[4]));
1314 } else if (!strcmp(params[0],"Flush")) {
1315 nb_flush(ival(params[1]));
1316 } else {
1317 printf("Unknown operation %s\n", params[0]);
1318 exit(1);
1319 }
1320 }
1321 fclose(f);
1322
1323 nb_cleanup();
1324
1325 if (!torture_close_connection(cli)) {
1326 correct = False;
1327 }
1328
1329 return correct;
1330 }
1331
1332
1333 /* run a test that simulates an approximate netbench client load */
1334 static bool run_nbench(int dummy)
1335 {
1336 double t;
1337 bool correct = True;
1338
1339 nbio_shmem(torture_nprocs);
1340
1341 nbio_id = -1;
1342
1343 signal(SIGALRM, nb_alarm);
1344 alarm(1);
1345 t = create_procs(run_netbench, &correct);
1346 alarm(0);
1347
1348 printf("\nThroughput %g MB/sec\n",
1349 1.0e-6 * nbio_total() / t);
1350 return correct;
1351 }
1352
1353
1354 /*
1355 This test checks for two things:
1356
1357 1) correct support for retaining locks over a close (ie. the server
1358 must not use posix semantics)
1359 2) support for lock timeouts
1360 */
1361 static bool run_locktest1(int dummy)
1362 {
1363 struct cli_state *cli1, *cli2;
1364 const char *fname = "\\lockt1.lck";
1365 uint16_t fnum1, fnum2, fnum3;
1366 time_t t1, t2;
1367 unsigned lock_timeout;
1368 NTSTATUS status;
1369
1370 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1371 return False;
1372 }
1373 smbXcli_conn_set_sockopt(cli1->conn, sockops);
1374 smbXcli_conn_set_sockopt(cli2->conn, sockops);
1375
1376 printf("starting locktest1\n");
1377
1378 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1379
1380 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
1381 &fnum1);
1382 if (!NT_STATUS_IS_OK(status)) {
1383 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1384 return False;
1385 }
1386
1387 status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum2);
1388 if (!NT_STATUS_IS_OK(status)) {
1389 printf("open2 of %s failed (%s)\n", fname, nt_errstr(status));
1390 return False;
1391 }
1392
1393 status = cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum3);
1394 if (!NT_STATUS_IS_OK(status)) {
1395 printf("open3 of %s failed (%s)\n", fname, nt_errstr(status));
1396 return False;
1397 }
1398
1399 status = cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK);
1400 if (!NT_STATUS_IS_OK(status)) {
1401 printf("lock1 failed (%s)\n", nt_errstr(status));
1402 return false;
1403 }
1404
1405 status = cli_lock32(cli2, fnum3, 0, 4, 0, WRITE_LOCK);
1406 if (NT_STATUS_IS_OK(status)) {
1407 printf("lock2 succeeded! This is a locking bug\n");
1408 return false;
1409 } else {
1410 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1411 NT_STATUS_LOCK_NOT_GRANTED)) {
1412 return false;
1413 }
1414 }
1415
1416 lock_timeout = (1 + (random() % 20));
1417 printf("Testing lock timeout with timeout=%u\n", lock_timeout);
1418 t1 = time(NULL);
1419 status = cli_lock32(cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK);
1420 if (NT_STATUS_IS_OK(status)) {
1421 printf("lock3 succeeded! This is a locking bug\n");
1422 return false;
1423 } else {
1424 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1425 NT_STATUS_FILE_LOCK_CONFLICT)) {
1426 return false;
1427 }
1428 }
1429 t2 = time(NULL);
1430
1431 if (ABS(t2 - t1) < lock_timeout-1) {
1432 printf("error: This server appears not to support timed lock requests\n");
1433 }
1434
1435 printf("server slept for %u seconds for a %u second timeout\n",
1436 (unsigned int)(t2-t1), lock_timeout);
1437
1438 status = cli_close(cli1, fnum2);
1439 if (!NT_STATUS_IS_OK(status)) {
1440 printf("close1 failed (%s)\n", nt_errstr(status));
1441 return False;
1442 }
1443
1444 status = cli_lock32(cli2, fnum3, 0, 4, 0, WRITE_LOCK);
1445 if (NT_STATUS_IS_OK(status)) {
1446 printf("lock4 succeeded! This is a locking bug\n");
1447 return false;
1448 } else {
1449 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1450 NT_STATUS_FILE_LOCK_CONFLICT)) {
1451 return false;
1452 }
1453 }
1454
1455 status = cli_close(cli1, fnum1);
1456 if (!NT_STATUS_IS_OK(status)) {
1457 printf("close2 failed (%s)\n", nt_errstr(status));
1458 return False;
1459 }
1460
1461 status = cli_close(cli2, fnum3);
1462 if (!NT_STATUS_IS_OK(status)) {
1463 printf("close3 failed (%s)\n", nt_errstr(status));
1464 return False;
1465 }
1466
1467 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1468 if (!NT_STATUS_IS_OK(status)) {
1469 printf("unlink failed (%s)\n", nt_errstr(status));
1470 return False;
1471 }
1472
1473
1474 if (!torture_close_connection(cli1)) {
1475 return False;
1476 }
1477
1478 if (!torture_close_connection(cli2)) {
1479 return False;
1480 }
1481
1482 printf("Passed locktest1\n");
1483 return True;
1484 }
1485
1486 /*
1487 this checks to see if a secondary tconx can use open files from an
1488 earlier tconx
1489 */
1490 static bool run_tcon_test(int dummy)
1491 {
1492 static struct cli_state *cli;
1493 const char *fname = "\\tcontest.tmp";
1494 uint16_t fnum1;
1495 uint32_t cnum1, cnum2, cnum3;
1496 struct smbXcli_tcon *orig_tcon = NULL;
1497 char *orig_share = NULL;
1498 uint16_t vuid1, vuid2;
1499 char buf[4];
1500 bool ret = True;
1501 NTSTATUS status;
1502
1503 memset(buf, '\0', sizeof(buf));
1504
1505 if (!torture_open_connection(&cli, 0)) {
1506 return False;
1507 }
1508 smbXcli_conn_set_sockopt(cli->conn, sockops);
1509
1510 printf("starting tcontest\n");
1511
1512 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1513
1514 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1515 if (!NT_STATUS_IS_OK(status)) {
1516 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1517 return False;
1518 }
1519
1520 cnum1 = cli_state_get_tid(cli);
1521 vuid1 = cli_state_get_uid(cli);
1522
1523 status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1524 if (!NT_STATUS_IS_OK(status)) {
1525 printf("initial write failed (%s)", nt_errstr(status));
1526 return False;
1527 }
1528
1529 cli_state_save_tcon_share(cli, &orig_tcon, &orig_share);
1530
1531 status = cli_tree_connect_creds(cli, share, "?????", torture_creds);
1532 if (!NT_STATUS_IS_OK(status)) {
1533 printf("%s refused 2nd tree connect (%s)\n", host,
1534 nt_errstr(status));
1535 cli_state_restore_tcon_share(cli, orig_tcon, orig_share);
1536 cli_shutdown(cli);
1537 return False;
1538 }
1539
1540 cnum2 = cli_state_get_tid(cli);
1541 cnum3 = MAX(cnum1, cnum2) + 1; /* any invalid number */
1542 vuid2 = cli_state_get_uid(cli) + 1;
1543
1544 /* try a write with the wrong tid */
1545 cli_state_set_tid(cli, cnum2);
1546
1547 status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1548 if (NT_STATUS_IS_OK(status)) {
1549 printf("* server allows write with wrong TID\n");
1550 ret = False;
1551 } else {
1552 printf("server fails write with wrong TID : %s\n",
1553 nt_errstr(status));
1554 }
1555
1556
1557 /* try a write with an invalid tid */
1558 cli_state_set_tid(cli, cnum3);
1559
1560 status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1561 if (NT_STATUS_IS_OK(status)) {
1562 printf("* server allows write with invalid TID\n");
1563 ret = False;
1564 } else {
1565 printf("server fails write with invalid TID : %s\n",
1566 nt_errstr(status));
1567 }
1568
1569 /* try a write with an invalid vuid */
1570 cli_state_set_uid(cli, vuid2);
1571 cli_state_set_tid(cli, cnum1);
1572
1573 status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1574 if (NT_STATUS_IS_OK(status)) {
1575 printf("* server allows write with invalid VUID\n");
1576 ret = False;
1577 } else {
1578 printf("server fails write with invalid VUID : %s\n",
1579 nt_errstr(status));
1580 }
1581
1582 cli_state_set_tid(cli, cnum1);
1583 cli_state_set_uid(cli, vuid1);
1584
1585 status = cli_close(cli, fnum1);
1586 if (!NT_STATUS_IS_OK(status)) {
1587 printf("close failed (%s)\n", nt_errstr(status));
1588 cli_state_restore_tcon_share(cli, orig_tcon, orig_share);
1589 cli_shutdown(cli);
1590 return False;
1591 }
1592
1593 cli_state_set_tid(cli, cnum2);
1594
1595 status = cli_tdis(cli);
1596 if (!NT_STATUS_IS_OK(status)) {
1597 printf("secondary tdis failed (%s)\n", nt_errstr(status));
1598 cli_state_restore_tcon_share(cli, orig_tcon, orig_share);
1599 cli_shutdown(cli);
1600 return False;
1601 }
1602
1603 cli_state_restore_tcon_share(cli, orig_tcon, orig_share);
1604
1605 cli_state_set_tid(cli, cnum1);
1606
1607 if (!torture_close_connection(cli)) {
1608 return False;
1609 }
1610
1611 return ret;
1612 }
1613
1614
1615 /*
1616 checks for old style tcon support
1617 */
1618 static bool run_tcon2_test(int dummy)
1619 {
1620 static struct cli_state *cli;
1621 uint16_t cnum, max_xmit;
1622 char *service;
1623 NTSTATUS status;
1624
1625 if (!torture_open_connection(&cli, 0)) {
1626 return False;
1627 }
1628 smbXcli_conn_set_sockopt(cli->conn, sockops);
1629
1630 printf("starting tcon2 test\n");
1631
1632 if (asprintf(&service, "\\\\%s\\%s", host, share) == -1) {
1633 return false;
1634 }
1635
1636 status = cli_raw_tcon(cli, service, password, "?????", &max_xmit, &cnum);
1637
1638 SAFE_FREE(service);
1639
1640 if (!NT_STATUS_IS_OK(status)) {
1641 printf("tcon2 failed : %s\n", nt_errstr(status));
1642 } else {
1643 printf("tcon OK : max_xmit=%d cnum=%d\n",
1644 (int)max_xmit, (int)cnum);
1645 }
1646
1647 if (!torture_close_connection(cli)) {
1648 return False;
1649 }
1650
1651 printf("Passed tcon2 test\n");
1652 return True;
1653 }
1654
1655 static bool tcon_devtest(struct cli_state *cli,
1656 const char *myshare, const char *devtype,
1657 const char *return_devtype,
1658 NTSTATUS expected_error)
1659 {
1660 NTSTATUS status;
1661 bool ret;
1662
1663 status = cli_tree_connect_creds(cli, myshare, devtype, torture_creds);
1664
1665 if (NT_STATUS_IS_OK(expected_error)) {
1666 if (NT_STATUS_IS_OK(status)) {
1667 if (return_devtype != NULL &&
1668 strequal(cli->dev, return_devtype)) {
1669 ret = True;
1670 } else {
1671 printf("tconX to share %s with type %s "
1672 "succeeded but returned the wrong "
1673 "device type (got [%s] but should have got [%s])\n",
1674 myshare, devtype, cli->dev, return_devtype);
1675 ret = False;
1676 }
1677 } else {
1678 printf("tconX to share %s with type %s "
1679 "should have succeeded but failed\n",
1680 myshare, devtype);
1681 ret = False;
1682 }
1683 cli_tdis(cli);
1684 } else {
1685 if (NT_STATUS_IS_OK(status)) {
1686 printf("tconx to share %s with type %s "
1687 "should have failed but succeeded\n",
1688 myshare, devtype);
1689 ret = False;
1690 } else {
1691 if (NT_STATUS_EQUAL(status, expected_error)) {
1692 ret = True;
1693 } else {
1694 printf("Returned unexpected error\n");
1695 ret = False;
1696 }
1697 }
1698 }
1699 return ret;
1700 }
1701
1702 /*
1703 checks for correct tconX support
1704 */
1705 static bool run_tcon_devtype_test(int dummy)
1706 {
1707 static struct cli_state *cli1 = NULL;
1708 int flags = CLI_FULL_CONNECTION_FORCE_SMB1;
1709 NTSTATUS status;
1710 bool ret = True;
1711
1712 status = cli_full_connection_creds(NULL,
1713 &cli1,
1714 myname,
1715 host,
1716 NULL, /* dest_ss */
1717 port_to_use,
1718 NULL, /* service */
1719 NULL, /* service_type */
1720 torture_creds,
1721 flags);
1722
1723 if (!NT_STATUS_IS_OK(status)) {
1724 printf("could not open connection\n");
1725 return False;
1726 }
1727
1728 if (!tcon_devtest(cli1, "IPC$", "A:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1729 ret = False;
1730
1731 if (!tcon_devtest(cli1, "IPC$", "?????", "IPC", NT_STATUS_OK))
1732 ret = False;
1733
1734 if (!tcon_devtest(cli1, "IPC$", "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1735 ret = False;
1736
1737 if (!tcon_devtest(cli1, "IPC$", "IPC", "IPC", NT_STATUS_OK))
1738 ret = False;
1739
1740 if (!tcon_devtest(cli1, "IPC$", "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1741 ret = False;
1742
1743 if (!tcon_devtest(cli1, share, "A:", "A:", NT_STATUS_OK))
1744 ret = False;
1745
1746 if (!tcon_devtest(cli1, share, "?????", "A:", NT_STATUS_OK))
1747 ret = False;
1748
1749 if (!tcon_devtest(cli1, share, "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1750 ret = False;
1751
1752 if (!tcon_devtest(cli1, share, "IPC", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1753 ret = False;
1754
1755 if (!tcon_devtest(cli1, share, "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1756 ret = False;
1757
1758 cli_shutdown(cli1);
1759
1760 if (ret)
1761 printf("Passed tcondevtest\n");
1762
1763 return ret;
1764 }
1765
1766
1767 /*
1768 This test checks that
1769
1770 1) the server supports multiple locking contexts on the one SMB
1771 connection, distinguished by PID.
1772
1773 2) the server correctly fails overlapping locks made by the same PID (this
1774 goes against POSIX behaviour, which is why it is tricky to implement)
1775
1776 3) the server denies unlock requests by an incorrect client PID
1777 */
1778 static bool run_locktest2(int dummy)
1779 {
1780 static struct cli_state *cli;
1781 const char *fname = "\\lockt2.lck";
1782 uint16_t fnum1, fnum2, fnum3;
1783 bool correct = True;
1784 NTSTATUS status;
1785
1786 if (!torture_open_connection(&cli, 0)) {
1787 return False;
1788 }
1789
1790 smbXcli_conn_set_sockopt(cli->conn, sockops);
1791
1792 printf("starting locktest2\n");
1793
1794 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1795
1796 cli_setpid(cli, 1);
1797
1798 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1799 if (!NT_STATUS_IS_OK(status)) {
1800 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1801 return False;
1802 }
1803
1804 status = cli_openx(cli, fname, O_RDWR, DENY_NONE, &fnum2);
1805 if (!NT_STATUS_IS_OK(status)) {
1806 printf("open2 of %s failed (%s)\n", fname, nt_errstr(status));
1807 return False;
1808 }
1809
1810 cli_setpid(cli, 2);
1811
1812 status = cli_openx(cli, fname, O_RDWR, DENY_NONE, &fnum3);
1813 if (!NT_STATUS_IS_OK(status)) {
1814 printf("open3 of %s failed (%s)\n", fname, nt_errstr(status));
1815 return False;
1816 }
1817
1818 cli_setpid(cli, 1);
1819
1820 status = cli_lock32(cli, fnum1, 0, 4, 0, WRITE_LOCK);
1821 if (!NT_STATUS_IS_OK(status)) {
1822 printf("lock1 failed (%s)\n", nt_errstr(status));
1823 return false;
1824 }
1825
1826 status = cli_lock32(cli, fnum1, 0, 4, 0, WRITE_LOCK);
1827 if (NT_STATUS_IS_OK(status)) {
1828 printf("WRITE lock1 succeeded! This is a locking bug\n");
1829 correct = false;
1830 } else {
1831 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1832 NT_STATUS_LOCK_NOT_GRANTED)) {
1833 return false;
1834 }
1835 }
1836
1837 status = cli_lock32(cli, fnum2, 0, 4, 0, WRITE_LOCK);
1838 if (NT_STATUS_IS_OK(status)) {
1839 printf("WRITE lock2 succeeded! This is a locking bug\n");
1840 correct = false;
1841 } else {
1842 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1843 NT_STATUS_LOCK_NOT_GRANTED)) {
1844 return false;
1845 }
1846 }
1847
1848 status = cli_lock32(cli, fnum2, 0, 4, 0, READ_LOCK);
1849 if (NT_STATUS_IS_OK(status)) {
1850 printf("READ lock2 succeeded! This is a locking bug\n");
1851 correct = false;
1852 } else {
1853 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1854 NT_STATUS_FILE_LOCK_CONFLICT)) {
1855 return false;
1856 }
1857 }
1858
1859 status = cli_lock32(cli, fnum1, 100, 4, 0, WRITE_LOCK);
1860 if (!NT_STATUS_IS_OK(status)) {
1861 printf("lock at 100 failed (%s)\n", nt_errstr(status));
1862 }
1863 cli_setpid(cli, 2);
1864 if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 100, 4))) {
1865 printf("unlock at 100 succeeded! This is a locking bug\n");
1866 correct = False;
1867 }
1868
1869 status = cli_unlock(cli, fnum1, 0, 4);
1870 if (NT_STATUS_IS_OK(status)) {
1871 printf("unlock1 succeeded! This is a locking bug\n");
1872 correct = false;
1873 } else {
1874 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1875 NT_STATUS_RANGE_NOT_LOCKED)) {
1876 return false;
1877 }
1878 }
1879
1880 status = cli_unlock(cli, fnum1, 0, 8);
1881 if (NT_STATUS_IS_OK(status)) {
1882 printf("unlock2 succeeded! This is a locking bug\n");
1883 correct = false;
1884 } else {
1885 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1886 NT_STATUS_RANGE_NOT_LOCKED)) {
1887 return false;
1888 }
1889 }
1890
1891 status = cli_lock32(cli, fnum3, 0, 4, 0, WRITE_LOCK);
1892 if (NT_STATUS_IS_OK(status)) {
1893 printf("lock3 succeeded! This is a locking bug\n");
1894 correct = false;
1895 } else {
1896 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1897 NT_STATUS_LOCK_NOT_GRANTED)) {
1898 return false;
1899 }
1900 }
1901
1902 cli_setpid(cli, 1);
1903
1904 status = cli_close(cli, fnum1);
1905 if (!NT_STATUS_IS_OK(status)) {
1906 printf("close1 failed (%s)\n", nt_errstr(status));
1907 return False;
1908 }
1909
1910 status = cli_close(cli, fnum2);
1911 if (!NT_STATUS_IS_OK(status)) {
1912 printf("close2 failed (%s)\n", nt_errstr(status));
1913 return False;
1914 }
1915
1916 status = cli_close(cli, fnum3);
1917 if (!NT_STATUS_IS_OK(status)) {
1918 printf("close3 failed (%s)\n", nt_errstr(status));
1919 return False;
1920 }
1921
1922 if (!torture_close_connection(cli)) {
1923 correct = False;
1924 }
1925
1926 printf("locktest2 finished\n");
1927
1928 return correct;
1929 }
1930
1931
1932 /*
1933 This test checks that
1934
1935 1) the server supports the full offset range in lock requests
1936 */
1937 static bool run_locktest3(int dummy)
1938 {
1939 static struct cli_state *cli1, *cli2;
1940 const char *fname = "\\lockt3.lck";
1941 uint16_t fnum1, fnum2;
1942 int i;
1943 uint32_t offset;
1944 bool correct = True;
1945 NTSTATUS status;
1946
1947 #define NEXT_OFFSET offset += (~(uint32_t)0) / torture_numops
1948
1949 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1950 return False;
1951 }
1952 smbXcli_conn_set_sockopt(cli1->conn, sockops);
1953 smbXcli_conn_set_sockopt(cli2->conn, sockops);
1954
1955 printf("starting locktest3\n");
1956
1957 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1958
1959 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
1960 &fnum1);
1961 if (!NT_STATUS_IS_OK(status)) {
1962 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1963 return False;
1964 }
1965
1966 status = cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1967 if (!NT_STATUS_IS_OK(status)) {
1968 printf("open2 of %s failed (%s)\n", fname, nt_errstr(status));
1969 return False;
1970 }
1971
1972 for (offset=i=0;i<torture_numops;i++) {
1973 NEXT_OFFSET;
1974
1975 status = cli_lock32(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK);
1976 if (!NT_STATUS_IS_OK(status)) {
1977 printf("lock1 %d failed (%s)\n",
1978 i,
1979 nt_errstr(status));
1980 return False;
1981 }
1982
1983 status = cli_lock32(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK);
1984 if (!NT_STATUS_IS_OK(status)) {
1985 printf("lock2 %d failed (%s)\n",
1986 i,
1987 nt_errstr(status));
1988 return False;
1989 }
1990 }
1991
1992 for (offset=i=0;i<torture_numops;i++) {
1993 NEXT_OFFSET;
1994
1995 status = cli_lock32(cli1, fnum1, offset-2, 1, 0, WRITE_LOCK);
1996 if (NT_STATUS_IS_OK(status)) {
1997 printf("error: lock1 %d succeeded!\n", i);
1998 return False;
1999 }
2000
2001 status = cli_lock32(cli2, fnum2, offset-1, 1, 0, WRITE_LOCK);
2002 if (NT_STATUS_IS_OK(status)) {
2003 printf("error: lock2 %d succeeded!\n", i);
2004 return False;
2005 }
2006
2007 status = cli_lock32(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK);
2008 if (NT_STATUS_IS_OK(status)) {
2009 printf("error: lock3 %d succeeded!\n", i);
2010 return False;
2011 }
2012
2013 status = cli_lock32(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK);
2014 if (NT_STATUS_IS_OK(status)) {
2015 printf("error: lock4 %d succeeded!\n", i);
2016 return False;
2017 }
2018 }
2019
2020 for (offset=i=0;i<torture_numops;i++) {
2021 NEXT_OFFSET;
2022
2023 status = cli_unlock(cli1, fnum1, offset-1, 1);
2024 if (!NT_STATUS_IS_OK(status)) {
2025 printf("unlock1 %d failed (%s)\n",
2026 i,
2027 nt_errstr(status));
2028 return False;
2029 }
2030
2031 status = cli_unlock(cli2, fnum2, offset-2, 1);
2032 if (!NT_STATUS_IS_OK(status)) {
2033 printf("unlock2 %d failed (%s)\n",
2034 i,
2035 nt_errstr(status));
2036 return False;
2037 }
2038 }
2039
2040 status = cli_close(cli1, fnum1);
2041 if (!NT_STATUS_IS_OK(status)) {
2042 printf("close1 failed (%s)\n", nt_errstr(status));
2043 return False;
2044 }
2045
2046 status = cli_close(cli2, fnum2);
2047 if (!NT_STATUS_IS_OK(status)) {
2048 printf("close2 failed (%s)\n", nt_errstr(status));
2049 return False;
2050 }
2051
2052 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2053 if (!NT_STATUS_IS_OK(status)) {
2054 printf("unlink failed (%s)\n", nt_errstr(status));
2055 return False;
2056 }
2057
2058 if (!torture_close_connection(cli1)) {
2059 correct = False;
2060 }
2061
2062 if (!torture_close_connection(cli2)) {
2063 correct = False;
2064 }
2065
2066 printf("finished locktest3\n");
2067
2068 return correct;
2069 }
2070
2071 static bool test_cli_read(struct cli_state *cli, uint16_t fnum,
2072 char *buf, off_t offset, size_t size,
2073 size_t *nread, size_t expect)
2074 {
2075 NTSTATUS status;
2076 size_t l_nread;
2077
2078 status = cli_read(cli, fnum, buf, offset, size, &l_nread);
2079
2080 if(!NT_STATUS_IS_OK(status)) {
2081 return false;
2082 } else if (l_nread != expect) {
2083 return false;
2084 }
2085
2086 if (nread) {
2087 *nread = l_nread;
2088 }
2089
2090 return true;
2091 }
2092
2093 #define EXPECTED(ret, v) if ((ret) != (v)) { \
2094 printf("** "); correct = False; \
2095 }
2096
2097 /*
2098 looks at overlapping locks
2099 */
2100 static bool run_locktest4(int dummy)
2101 {
2102 static struct cli_state *cli1, *cli2;
2103 const char *fname = "\\lockt4.lck";
2104 uint16_t fnum1, fnum2, f;
2105 bool ret;
2106 char buf[1000];
2107 bool correct = True;
2108 NTSTATUS status;
2109
2110 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2111 return False;
2112 }
2113
2114 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2115 smbXcli_conn_set_sockopt(cli2->conn, sockops);
2116
2117 printf("starting locktest4\n");
2118
2119 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2120
2121 cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2122 cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
2123
2124 memset(buf, 0, sizeof(buf));
2125
2126 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf),
2127 NULL);
2128 if (!NT_STATUS_IS_OK(status)) {
2129 printf("Failed to create file: %s\n", nt_errstr(status));
2130 correct = False;
2131 goto fail;
2132 }
2133
2134 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) &&
2135 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 2, 4, 0, WRITE_LOCK));
2136 EXPECTED(ret, False);
2137 printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
2138
2139 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 10, 4, 0, READ_LOCK)) &&
2140 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 12, 4, 0, READ_LOCK));
2141 EXPECTED(ret, True);
2142 printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
2143
2144 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 20, 4, 0, WRITE_LOCK)) &&
2145 NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 22, 4, 0, WRITE_LOCK));
2146 EXPECTED(ret, False);
2147 printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
2148
2149 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 30, 4, 0, READ_LOCK)) &&
2150 NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 32, 4, 0, READ_LOCK));
2151 EXPECTED(ret, True);
2152 printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
2153
2154 ret = (cli_setpid(cli1, 1),
2155 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 40, 4, 0, WRITE_LOCK))) &&
2156 (cli_setpid(cli1, 2),
2157 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 42, 4, 0, WRITE_LOCK)));
2158 EXPECTED(ret, False);
2159 printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
2160
2161 ret = (cli_setpid(cli1, 1),
2162 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 50, 4, 0, READ_LOCK))) &&
2163 (cli_setpid(cli1, 2),
2164 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 52, 4, 0, READ_LOCK)));
2165 EXPECTED(ret, True);
2166 printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
2167
2168 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 60, 4, 0, READ_LOCK)) &&
2169 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 60, 4, 0, READ_LOCK));
2170 EXPECTED(ret, True);
2171 printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
2172
2173 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 70, 4, 0, WRITE_LOCK)) &&
2174 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 70, 4, 0, WRITE_LOCK));
2175 EXPECTED(ret, False);
2176 printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
2177
2178 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 80, 4, 0, READ_LOCK)) &&
2179 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 80, 4, 0, WRITE_LOCK));
2180 EXPECTED(ret, False);
2181 printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
2182
2183 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 90, 4, 0, WRITE_LOCK)) &&
2184 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 90, 4, 0, READ_LOCK));
2185 EXPECTED(ret, True);
2186 printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
2187
2188 ret = (cli_setpid(cli1, 1),
2189 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 100, 4, 0, WRITE_LOCK))) &&
2190 (cli_setpid(cli1, 2),
2191 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 100, 4, 0, READ_LOCK)));
2192 EXPECTED(ret, False);
2193 printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
2194
2195 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 110, 4, 0, READ_LOCK)) &&
2196 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 112, 4, 0, READ_LOCK)) &&
2197 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 110, 6));
2198 EXPECTED(ret, False);
2199 printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
2200
2201
2202 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 120, 4, 0, WRITE_LOCK)) &&
2203 test_cli_read(cli2, fnum2, buf, 120, 4, NULL, 4);
2204 EXPECTED(ret, False);
2205 printf("this server %s strict write locking\n", ret?"doesn't do":"does");
2206
2207 status = cli_lock32(cli1, fnum1, 130, 4, 0, READ_LOCK);
2208 ret = NT_STATUS_IS_OK(status);
2209 if (ret) {
2210 status = cli_writeall(cli2, fnum2, 0, (uint8_t *)buf, 130, 4,
2211 NULL);
2212 ret = NT_STATUS_IS_OK(status);
2213 }
2214 EXPECTED(ret, False);
2215 printf("this server %s strict read locking\n", ret?"doesn't do":"does");
2216
2217
2218 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 140, 4, 0, READ_LOCK)) &&
2219 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 140, 4, 0, READ_LOCK)) &&
2220 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4)) &&
2221 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4));
2222 EXPECTED(ret, True);
2223 printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
2224
2225
2226 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 150, 4, 0, WRITE_LOCK)) &&
2227 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 150, 4, 0, READ_LOCK)) &&
2228 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4)) &&
2229 test_cli_read(cli2, fnum2, buf, 150, 4, NULL, 4) &&
2230 !(NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2231 150, 4, NULL))) &&
2232 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4));
2233 EXPECTED(ret, True);
2234 printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
2235
2236 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 160, 4, 0, READ_LOCK)) &&
2237 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 160, 4)) &&
2238 NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2239 160, 4, NULL)) &&
2240 test_cli_read(cli2, fnum2, buf, 160, 4, NULL, 4);
2241 EXPECTED(ret, True);
2242 printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
2243
2244 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 170, 4, 0, WRITE_LOCK)) &&
2245 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 170, 4)) &&
2246 NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2247 170, 4, NULL)) &&
2248 test_cli_read(cli2, fnum2, buf, 170, 4, NULL, 4);
2249 EXPECTED(ret, True);
2250 printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
2251
2252 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 190, 4, 0, WRITE_LOCK)) &&
2253 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 190, 4, 0, READ_LOCK)) &&
2254 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 190, 4)) &&
2255 !NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2256 190, 4, NULL)) &&
2257 test_cli_read(cli2, fnum2, buf, 190, 4, NULL, 4);
2258 EXPECTED(ret, True);
2259 printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
2260
2261 cli_close(cli1, fnum1);
2262 cli_close(cli2, fnum2);
2263 cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2264 cli_openx(cli1, fname, O_RDWR, DENY_NONE, &f);
2265 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 8, 0, READ_LOCK)) &&
2266 NT_STATUS_IS_OK(cli_lock32(cli1, f, 0, 1, 0, READ_LOCK)) &&
2267 NT_STATUS_IS_OK(cli_close(cli1, fnum1)) &&
2268 NT_STATUS_IS_OK(cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1)) &&
2269 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 7, 1, 0, WRITE_LOCK));
2270 cli_close(cli1, f);
2271 cli_close(cli1, fnum1);
2272 EXPECTED(ret, True);
2273 printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
2274
2275 fail:
2276 cli_close(cli1, fnum1);
2277 cli_close(cli2, fnum2);
2278 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2279 torture_close_connection(cli1);
2280 torture_close_connection(cli2);
2281
2282 printf("finished locktest4\n");
2283 return correct;
2284 }
2285
2286 /*
2287 looks at lock upgrade/downgrade.
2288 */
2289 static bool run_locktest5(int dummy)
2290 {
2291 static struct cli_state *cli1, *cli2;
2292 const char *fname = "\\lockt5.lck";
2293 uint16_t fnum1, fnum2, fnum3;
2294 bool ret;
2295 char buf[1000];
2296 bool correct = True;
2297 NTSTATUS status;
2298
2299 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2300 return False;
2301 }
2302
2303 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2304 smbXcli_conn_set_sockopt(cli2->conn, sockops);
2305
2306 printf("starting locktest5\n");
2307
2308 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2309
2310 cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2311 cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
2312 cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum3);
2313
2314 memset(buf, 0, sizeof(buf));
2315
2316 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf),
2317 NULL);
2318 if (!NT_STATUS_IS_OK(status)) {
2319 printf("Failed to create file: %s\n", nt_errstr(status));
2320 correct = False;
2321 goto fail;
2322 }
2323
2324 /* Check for NT bug... */
2325 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 8, 0, READ_LOCK)) &&
2326 NT_STATUS_IS_OK(cli_lock32(cli1, fnum3, 0, 1, 0, READ_LOCK));
2327 cli_close(cli1, fnum1);
2328 cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2329 status = cli_lock32(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
2330 ret = NT_STATUS_IS_OK(status);
2331 EXPECTED(ret, True);
2332 printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
2333 cli_close(cli1, fnum1);
2334 cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2335 cli_unlock(cli1, fnum3, 0, 1);
2336
2337 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) &&
2338 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 1, 1, 0, READ_LOCK));
2339 EXPECTED(ret, True);
2340 printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
2341
2342 status = cli_lock32(cli2, fnum2, 0, 4, 0, READ_LOCK);
2343 ret = NT_STATUS_IS_OK(status);
2344 EXPECTED(ret, False);
2345
2346 printf("a different process %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
2347
2348 /* Unlock the process 2 lock. */
2349 cli_unlock(cli2, fnum2, 0, 4);
2350
2351 status = cli_lock32(cli1, fnum3, 0, 4, 0, READ_LOCK);
2352 ret = NT_STATUS_IS_OK(status);
2353 EXPECTED(ret, False);
2354
2355 printf("the same process on a different fnum %s get a read lock\n", ret?"can":"cannot");
2356
2357 /* Unlock the process 1 fnum3 lock. */
2358 cli_unlock(cli1, fnum3, 0, 4);
2359
2360 /* Stack 2 more locks here. */
2361 ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK)) &&
2362 NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK));
2363
2364 EXPECTED(ret, True);
2365 printf("the same process %s stack read locks\n", ret?"can":"cannot");
2366
2367 /* Unlock the first process lock, then check this was the WRITE lock that was
2368 removed. */
2369
2370 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
2371 NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 0, 4, 0, READ_LOCK));
2372
2373 EXPECTED(ret, True);
2374 printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
2375
2376 /* Unlock the process 2 lock. */
2377 cli_unlock(cli2, fnum2, 0, 4);
2378
2379 /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
2380
2381 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 1, 1)) &&
2382 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
2383 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
2384
2385 EXPECTED(ret, True);
2386 printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
2387
2388 /* Ensure the next unlock fails. */
2389 ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
2390 EXPECTED(ret, False);
2391 printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
2392
2393 /* Ensure connection 2 can get a write lock. */
2394 status = cli_lock32(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
2395 ret = NT_STATUS_IS_OK(status);
2396 EXPECTED(ret, True);
2397
2398 printf("a different process %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
2399
2400
2401 fail:
2402 cli_close(cli1, fnum1);
2403 cli_close(cli2, fnum2);
2404 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2405 if (!torture_close_connection(cli1)) {
2406 correct = False;
2407 }
2408 if (!torture_close_connection(cli2)) {
2409 correct = False;
2410 }
2411
2412 printf("finished locktest5\n");
2413
2414 return correct;
2415 }
2416
2417 /*
2418 tries the unusual lockingX locktype bits
2419 */
2420 static bool run_locktest6(int dummy)
2421 {
2422 static struct cli_state *cli;
2423 const char *fname[1] = { "\\lock6.txt" };
2424 int i;
2425 uint16_t fnum;
2426 NTSTATUS status;
2427
2428 if (!torture_open_connection(&cli, 0)) {
2429 return False;
2430 }
2431
2432 smbXcli_conn_set_sockopt(cli->conn, sockops);
2433
2434 printf("starting locktest6\n");
2435
2436 for (i=0;i<1;i++) {
2437 printf("Testing %s\n", fname[i]);
2438
2439 cli_unlink(cli, fname[i], FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2440
2441 cli_openx(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
2442 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
2443 cli_close(cli, fnum);
2444 printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
2445
2446 cli_openx(cli, fname[i], O_RDWR, DENY_NONE, &fnum);
2447 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
2448 cli_close(cli, fnum);
2449 printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
2450
2451 cli_unlink(cli, fname[i], FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2452 }
2453
2454 torture_close_connection(cli);
2455
2456 printf("finished locktest6\n");
2457 return True;
2458 }
2459
2460 static bool run_locktest7(int dummy)
2461 {
2462 struct cli_state *cli1;
2463 const char *fname = "\\lockt7.lck";
2464 uint16_t fnum1;
2465 char buf[200];
2466 bool correct = False;
2467 size_t nread;
2468 NTSTATUS status;
2469
2470 if (!torture_open_connection(&cli1, 0)) {
2471 return False;
2472 }
2473
2474 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2475
2476 printf("starting locktest7\n");
2477
2478 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2479
2480 cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2481
2482 memset(buf, 0, sizeof(buf));
2483
2484 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf),
2485 NULL);
2486 if (!NT_STATUS_IS_OK(status)) {
2487 printf("Failed to create file: %s\n", nt_errstr(status));
2488 goto fail;
2489 }
2490
2491 cli_setpid(cli1, 1);
2492
2493 status = cli_lock32(cli1, fnum1, 130, 4, 0, READ_LOCK);
2494 if (!NT_STATUS_IS_OK(status)) {
2495 printf("Unable to apply read lock on range 130:4, "
2496 "error was %s\n", nt_errstr(status));
2497 goto fail;
2498 } else {
2499 printf("pid1 successfully locked range 130:4 for READ\n");
2500 }
2501
2502 status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2503 if (!NT_STATUS_IS_OK(status)) {
2504 printf("pid1 unable to read the range 130:4, error was %s\n",
2505 nt_errstr(status));
2506 goto fail;
2507 } else if (nread != 4) {
2508 printf("pid1 unable to read the range 130:4, "
2509 "recv %ld req %d\n", (unsigned long)nread, 4);
2510 goto fail;
2511 } else {
2512 printf("pid1 successfully read the range 130:4\n");
2513 }
2514
2515 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2516 if (!NT_STATUS_IS_OK(status)) {
2517 printf("pid1 unable to write to the range 130:4, error was "
2518 "%s\n", nt_errstr(status));
2519 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2520 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2521 goto fail;
2522 }
2523 } else {
2524 printf("pid1 successfully wrote to the range 130:4 (should be denied)\n");
2525 goto fail;
2526 }
2527
2528 cli_setpid(cli1, 2);
2529
2530 status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2531 if (!NT_STATUS_IS_OK(status)) {
2532 printf("pid2 unable to read the range 130:4, error was %s\n",
2533 nt_errstr(status));
2534 goto fail;
2535 } else if (nread != 4) {
2536 printf("pid2 unable to read the range 130:4, "
2537 "recv %ld req %d\n", (unsigned long)nread, 4);
2538 goto fail;
2539 } else {
2540 printf("pid2 successfully read the range 130:4\n");
2541 }
2542
2543 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2544 if (!NT_STATUS_IS_OK(status)) {
2545 printf("pid2 unable to write to the range 130:4, error was "
2546 "%s\n", nt_errstr(status));
2547 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2548 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2549 goto fail;
2550 }
2551 } else {
2552 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2553 goto fail;
2554 }
2555
2556 cli_setpid(cli1, 1);
2557 cli_unlock(cli1, fnum1, 130, 4);
2558
2559 status = cli_lock32(cli1, fnum1, 130, 4, 0, WRITE_LOCK);
2560 if (!NT_STATUS_IS_OK(status)) {
2561 printf("Unable to apply write lock on range 130:4, error was %s\n", nt_errstr(status));
2562 goto fail;
2563 } else {
2564 printf("pid1 successfully locked range 130:4 for WRITE\n");
2565 }
2566
2567 status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2568 if (!NT_STATUS_IS_OK(status)) {
2569 printf("pid1 unable to read the range 130:4, error was %s\n",
2570 nt_errstr(status));
2571 goto fail;
2572 } else if (nread != 4) {
2573 printf("pid1 unable to read the range 130:4, "
2574 "recv %ld req %d\n", (unsigned long)nread, 4);
2575 goto fail;
2576 } else {
2577 printf("pid1 successfully read the range 130:4\n");
2578 }
2579
2580 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2581 if (!NT_STATUS_IS_OK(status)) {
2582 printf("pid1 unable to write to the range 130:4, error was "
2583 "%s\n", nt_errstr(status));
2584 goto fail;
2585 } else {
2586 printf("pid1 successfully wrote to the range 130:4\n");
2587 }
2588
2589 cli_setpid(cli1, 2);
2590
2591 status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2592 if (!NT_STATUS_IS_OK(status)) {
2593 printf("pid2 unable to read the range 130:4, error was "
2594 "%s\n", nt_errstr(status));
2595 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2596 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2597 goto fail;
2598 }
2599 } else {
2600 printf("pid2 successfully read the range 130:4 (should be denied) recv %ld\n",
2601 (unsigned long)nread);
2602 goto fail;
2603 }
2604
2605 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2606 if (!NT_STATUS_IS_OK(status)) {
2607 printf("pid2 unable to write to the range 130:4, error was "
2608 "%s\n", nt_errstr(status));
2609 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2610 printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2611 goto fail;
2612 }
2613 } else {
2614 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2615 goto fail;
2616 }
2617
2618 cli_unlock(cli1, fnum1, 130, 0);
2619 correct = True;
2620
2621 fail:
2622 cli_close(cli1, fnum1);
2623 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2624 torture_close_connection(cli1);
2625
2626 printf("finished locktest7\n");
2627 return correct;
2628 }
2629
2630 /*
2631 * This demonstrates a problem with our use of GPFS share modes: A file
2632 * descriptor sitting in the pending close queue holding a GPFS share mode
2633 * blocks opening a file another time. Happens with Word 2007 temp files.
2634 * With "posix locking = yes" and "gpfs:sharemodes = yes" enabled, the third
2635 * open is denied with NT_STATUS_SHARING_VIOLATION.
2636 */
2637
2638 static bool run_locktest8(int dummy)
2639 {
2640 struct cli_state *cli1;
2641 const char *fname = "\\lockt8.lck";
2642 uint16_t fnum1, fnum2;
2643 char buf[200];
2644 bool correct = False;
2645 NTSTATUS status;
2646
2647 if (!torture_open_connection(&cli1, 0)) {
2648 return False;
2649 }
2650
2651 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2652
2653 printf("starting locktest8\n");
2654
2655 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2656
2657 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_WRITE,
2658 &fnum1);
2659 if (!NT_STATUS_IS_OK(status)) {
2660 d_fprintf(stderr, "cli_openx returned %s\n", nt_errstr(status));
2661 return false;
2662 }
2663
2664 memset(buf, 0, sizeof(buf));
2665
2666 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum2);
2667 if (!NT_STATUS_IS_OK(status)) {
2668 d_fprintf(stderr, "cli_openx second time returned %s\n",
2669 nt_errstr(status));
2670 goto fail;
2671 }
2672
2673 status = cli_lock32(cli1, fnum2, 1, 1, 0, READ_LOCK);
2674 if (!NT_STATUS_IS_OK(status)) {
2675 printf("Unable to apply read lock on range 1:1, error was "
2676 "%s\n", nt_errstr(status));
2677 goto fail;
2678 }
2679
2680 status = cli_close(cli1, fnum1);
2681 if (!NT_STATUS_IS_OK(status)) {
2682 d_fprintf(stderr, "cli_close(fnum1) %s\n", nt_errstr(status));
2683 goto fail;
2684 }
2685
2686 status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2687 if (!NT_STATUS_IS_OK(status)) {
2688 d_fprintf(stderr, "cli_openx third time returned %s\n",
2689 nt_errstr(status));
2690 goto fail;
2691 }
2692
2693 correct = true;
2694
2695 fail:
2696 cli_close(cli1, fnum1);
2697 cli_close(cli1, fnum2);
2698 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2699 torture_close_connection(cli1);
2700
2701 printf("finished locktest8\n");
2702 return correct;
2703 }
2704
2705 /*
2706 * This test is designed to be run in conjunction with
2707 * external NFS or POSIX locks taken in the filesystem.
2708 * It checks that the smbd server will block until the
2709 * lock is released and then acquire it. JRA.
2710 */
2711
2712 static bool got_alarm;
2713 static struct cli_state *alarm_cli;
2714
2715 static void alarm_handler(int dummy)
2716 {
2717 got_alarm = True;
2718 }
2719
2720 static void alarm_handler_parent(int dummy)
2721 {
2722 smbXcli_conn_disconnect(alarm_cli->conn, NT_STATUS_LOCAL_DISCONNECT);
2723 }
2724
2725 static void do_local_lock(const char *fname, int read_fd, int write_fd)
2726 {
2727 int fd;
2728 char c = '\0';
2729 struct flock lock;
2730 const char *local_pathname = NULL;
2731 int ret;
2732
2733 local_pathname = talloc_asprintf(talloc_tos(),
2734 "%s/%s", local_path, fname);
2735 if (!local_pathname) {
2736 printf("child: alloc fail\n");
2737 exit(1);
2738 }
2739
2740 unlink(local_pathname);
2741 fd = open(local_pathname, O_RDWR|O_CREAT, 0666);
2742 if (fd == -1) {
2743 printf("child: open of %s failed %s.\n",
2744 local_pathname, strerror(errno));
2745 exit(1);
2746 }
2747
2748 /* Now take a fcntl lock. */
2749 lock.l_type = F_WRLCK;
2750 lock.l_whence = SEEK_SET;
2751 lock.l_start = 0;
2752 lock.l_len = 4;
2753 lock.l_pid = getpid();
2754
2755 ret = fcntl(fd,F_SETLK,&lock);
2756 if (ret == -1) {
2757 printf("child: failed to get lock 0:4 on file %s. Error %s\n",
2758 local_pathname, strerror(errno));
2759 exit(1);
2760 } else {
2761 printf("child: got lock 0:4 on file %s.\n",
2762 local_pathname );
2763 fflush(stdout);
2764 }
2765
2766 CatchSignal(SIGALRM, alarm_handler);
2767 alarm(5);
2768 /* Signal the parent. */
2769 if (write(write_fd, &c, 1) != 1) {
2770 printf("child: start signal fail %s.\n",
2771 strerror(errno));
2772 exit(1);
2773 }
2774 alarm(0);
2775
2776 alarm(10);
2777 /* Wait for the parent to be ready. */
2778 if (read(read_fd, &c, 1) != 1) {
2779 printf("child: reply signal fail %s.\n",
2780 strerror(errno));
2781 exit(1);
2782 }
2783 alarm(0);
2784
2785 sleep(5);
2786 close(fd);
2787 printf("child: released lock 0:4 on file %s.\n",
2788 local_pathname );
2789 fflush(stdout);
2790 exit(0);
2791 }
2792
2793 static bool _run_locktest9X(const char *fname, int timeout)
2794 {
2795 struct cli_state *cli1;
2796 char *fpath = talloc_asprintf(talloc_tos(), "\\%s", fname);
2797 uint16_t fnum;
2798 bool correct = False;
2799 int pipe_in[2], pipe_out[2];
2800 pid_t child_pid;
2801 char c = '\0';
2802 int ret;
2803 struct timeval start;
2804 double seconds;
2805 NTSTATUS status;
2806
2807 printf("starting locktest9X: %s\n", fname);
2808
2809 if (local_path == NULL) {
2810 d_fprintf(stderr, "locktest9X must be given a local path via -l <localpath>\n");
2811 return false;
2812 }
2813
2814 if (pipe(pipe_in) == -1 || pipe(pipe_out) == -1) {
2815 return false;
2816 }
2817
2818 child_pid = fork();
2819 if (child_pid == -1) {
2820 return false;
2821 }
2822
2823 if (child_pid == 0) {
2824 /* Child. */
2825 do_local_lock(fname, pipe_out[0], pipe_in[1]);
2826 exit(0);
2827 }
2828
2829 close(pipe_out[0]);
2830 close(pipe_in[1]);
2831 pipe_out[0] = -1;
2832 pipe_in[1] = -1;
2833
2834 /* Parent. */
2835 ret = read(pipe_in[0], &c, 1);
2836 if (ret != 1) {
2837 d_fprintf(stderr, "failed to read start signal from child. %s\n",
2838 strerror(errno));
2839 return false;
2840 }
2841
2842 if (!torture_open_connection(&cli1, 0)) {
2843 return false;
2844 }
2845
2846 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2847
2848 status = cli_openx(cli1, fpath, O_RDWR, DENY_NONE,
2849 &fnum);
2850 if (!NT_STATUS_IS_OK(status)) {
2851 d_fprintf(stderr, "cli_openx returned %s\n", nt_errstr(status));
2852 return false;
2853 }
2854
2855 /* Ensure the child has the lock. */
2856 status = cli_lock32(cli1, fnum, 0, 4, 0, WRITE_LOCK);
2857 if (NT_STATUS_IS_OK(status)) {
2858 d_fprintf(stderr, "Got the lock on range 0:4 - this should not happen !\n");
2859 goto fail;
2860 } else {
2861 d_printf("Child has the lock.\n");
2862 }
2863
2864 /* Tell the child to wait 5 seconds then exit. */
2865 ret = write(pipe_out[1], &c, 1);
2866 if (ret != 1) {
2867 d_fprintf(stderr, "failed to send exit signal to child. %s\n",
2868 strerror(errno));
2869 goto fail;
2870 }
2871
2872 /* Wait 20 seconds for the lock. */
2873 alarm_cli = cli1;
2874 CatchSignal(SIGALRM, alarm_handler_parent);
2875 alarm(20);
2876
2877 start = timeval_current();
2878
2879 status = cli_lock32(cli1, fnum, 0, 4, timeout, WRITE_LOCK);
2880 if (!NT_STATUS_IS_OK(status)) {
2881 d_fprintf(stderr, "Unable to apply write lock on range 0:4, error was "
2882 "%s\n", nt_errstr(status));
2883 goto fail_nofd;
2884 }
2885 alarm(0);
2886
2887 seconds = timeval_elapsed(&start);
2888
2889 printf("Parent got the lock after %.2f seconds.\n",
2890 seconds);
2891
2892 status = cli_close(cli1, fnum);
2893 if (!NT_STATUS_IS_OK(status)) {
2894 d_fprintf(stderr, "cli_close(fnum1) %s\n", nt_errstr(status));
2895 goto fail;
2896 }
2897
2898 correct = true;
2899
2900 fail:
2901 cli_close(cli1, fnum);
2902 torture_close_connection(cli1);
2903
2904 fail_nofd:
2905
2906 printf("finished locktest9X: %s\n", fname);
2907 return correct;
2908 }
2909
2910 static bool run_locktest9a(int dummy)
2911 {
2912 return _run_locktest9X("lock9a.dat", -1);
2913 }
2914
2915 static bool run_locktest9b(int dummy)
2916 {
2917 return _run_locktest9X("lock9b.dat", 10000);
2918 }
2919
2920 struct locktest10_state {
2921 bool ok;
2922 bool done;
2923 };
2924
2925 static void locktest10_lockingx_done(struct tevent_req *subreq);
2926 static void locktest10_read_andx_done(struct tevent_req *subreq);
2927
2928 static bool run_locktest10(int dummy)
2929 {
2930 struct tevent_context *ev = NULL;
2931 struct cli_state *cli1 = NULL;
2932 struct cli_state *cli2 = NULL;
2933 struct smb1_lock_element lck = { 0 };
2934 struct tevent_req *reqs[2] = { NULL };
2935 struct tevent_req *smbreqs[2] = { NULL };
2936 const char fname[] = "\\lockt10.lck";
2937 uint16_t fnum1, fnum2;
2938 bool ret = false;
2939 bool ok;
2940 uint8_t data = 1;
2941 struct locktest10_state state = { .ok = true };
2942 NTSTATUS status;
2943
2944 printf("starting locktest10\n");
2945
2946 ev = samba_tevent_context_init(NULL);
2947 if (ev == NULL) {
2948 d_fprintf(stderr, "samba_tevent_context_init failed\n");
2949 goto done;
2950 }
2951
2952 ok = torture_open_connection(&cli1, 0);
2953 if (!ok) {
2954 goto done;
2955 }
2956 smbXcli_conn_set_sockopt(cli1->conn, sockops);
2957
2958 ok = torture_open_connection(&cli2, 1);
2959 if (!ok) {
2960 goto done;
2961 }
2962 smbXcli_conn_set_sockopt(cli2->conn, sockops);
2963
2964 status = cli_openx(cli1, fname, O_CREAT|O_RDWR, DENY_NONE, &fnum1);
2965 if (!NT_STATUS_IS_OK(status)) {
2966 d_fprintf(stderr,
2967 "cli_openx failed: %s\n",
2968 nt_errstr(status));
2969 goto done;
2970 }
2971
2972 status = cli_writeall(cli1, fnum1, 0, &data, 0, sizeof(data), NULL);
2973 if (!NT_STATUS_IS_OK(status)) {
2974 d_fprintf(stderr,
2975 "cli_writeall failed: %s\n",
2976 nt_errstr(status));
2977 goto done;
2978 }
2979
2980 status = cli_openx(cli2, fname, O_CREAT|O_RDWR, DENY_NONE, &fnum2);
2981 if (!NT_STATUS_IS_OK(status)) {
2982 d_fprintf(stderr,
2983 "cli_openx failed: %s\n",
2984 nt_errstr(status));
2985 goto done;
2986 }
2987
2988 status = cli_locktype(
2989 cli2, fnum2, 0, 1, 0, LOCKING_ANDX_EXCLUSIVE_LOCK);
2990 if (!NT_STATUS_IS_OK(status)) {
2991 d_fprintf(stderr,
2992 "cli_locktype failed: %s\n",
2993 nt_errstr(status));
2994 goto done;
2995 }
2996
2997 lck = (struct smb1_lock_element) {
2998 .pid = cli_getpid(cli1), .offset = 0, .length = 1,
2999 };
3000
3001 reqs[0] = cli_lockingx_create(
3002 ev, /* mem_ctx */
3003 ev, /* tevent_context */
3004 cli1, /* cli */
3005 fnum1, /* fnum */
3006 LOCKING_ANDX_EXCLUSIVE_LOCK, /* typeoflock */
3007 0, /* newoplocklevel */
3008 1, /* timeout */
3009 0, /* num_unlocks */
3010 NULL, /* unlocks */
3011 1, /* num_locks */
3012 &lck, /* locks */
3013 &smbreqs[0]); /* psmbreq */
3014 if (reqs[0] == NULL) {
3015 d_fprintf(stderr, "cli_lockingx_create failed\n");
3016 goto done;
3017 }
3018 tevent_req_set_callback(reqs[0], locktest10_lockingx_done, &state);
3019
3020 reqs[1] = cli_read_andx_create(
3021 ev, /* mem_ctx */
3022 ev, /* ev */
3023 cli1, /* cli */
3024 fnum1, /* fnum */
3025 0, /* offset */
3026 1, /* size */
3027 &smbreqs[1]); /* psmbreq */
3028 if (reqs[1] == NULL) {
3029 d_fprintf(stderr, "cli_read_andx_create failed\n");
3030 goto done;
3031 }
3032 tevent_req_set_callback(reqs[1], locktest10_read_andx_done, &state);
3033
3034 status = smb1cli_req_chain_submit(smbreqs, ARRAY_SIZE(smbreqs));
3035 if (!NT_STATUS_IS_OK(status)) {
3036 d_fprintf(stderr,
3037 "smb1cli_req_chain_submit failed: %s\n",
3038 nt_errstr(status));
3039 goto done;
3040 }
3041
3042 while (!state.done) {
3043 tevent_loop_once(ev);
3044 }
3045
3046 torture_close_connection(cli1);
3047
3048 if (state.ok) {
3049 ret = true;
3050 }
3051 done:
3052 return ret;
3053 }
3054
3055 static void locktest10_lockingx_done(struct tevent_req *subreq)
3056 {
3057 struct locktest10_state *state = tevent_req_callback_data_void(subreq);
3058 NTSTATUS status;
3059
3060 status = cli_lockingx_recv(subreq);
3061 TALLOC_FREE(subreq);
3062
3063 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
3064 d_printf("cli_lockingx returned %s\n", nt_errstr(status));
3065 state->ok = false;
3066 }
3067 }
3068
3069 static void locktest10_read_andx_done(struct tevent_req *subreq)
3070 {
3071 struct locktest10_state *state = tevent_req_callback_data_void(subreq);
3072 ssize_t received = -1;
3073 uint8_t *rcvbuf = NULL;
3074 NTSTATUS status;
3075
3076 status = cli_read_andx_recv(subreq, &received, &rcvbuf);
3077
3078 if (!NT_STATUS_EQUAL(status, NT_STATUS_REQUEST_ABORTED)) {
3079 d_printf("cli_read_andx returned %s\n", nt_errstr(status));
3080 state->ok = false;
3081 }
3082
3083 state->done = true;
3084 TALLOC_FREE(subreq);
3085 }
3086
3087 static bool run_locktest11(int dummy)
3088 {
3089 struct cli_state *cli1;
3090 const char *fname = "\\lockt11.lck";
3091 NTSTATUS status;
3092 uint16_t fnum;
3093 bool ret = false;
3094
3095 if (!torture_open_connection(&cli1, 0)) {
3096 return false;
3097 }
3098
3099 smbXcli_conn_set_sockopt(cli1->conn, sockops);
3100
3101 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3102
3103 status = cli_openx(cli1, fname, O_CREAT|O_RDWR, DENY_NONE, &fnum);
3104 if (!NT_STATUS_IS_OK(status)) {
3105 d_fprintf(stderr,
3106 "cli_openx returned %s\n",
3107 nt_errstr(status));
3108 return false;
3109 }
3110
3111 /*
3112 * Test that LOCKING_ANDX_CANCEL_LOCK without any locks
3113 * returns NT_STATUS_OK
3114 */
3115
3116 status = cli_lockingx(
3117 cli1, /* cli */
3118 fnum, /* fnum */
3119 LOCKING_ANDX_CANCEL_LOCK, /* typeoflock */
3120 0, /* newoplocklevel */
3121 0, /* timeout */
3122 0, /* num_unlocks */
3123 NULL, /* unlocks */
3124 0, /* num_locks */
3125 NULL); /* locks */
3126
3127 if (!NT_STATUS_IS_OK(status)) {
3128 d_printf("cli_lockingX returned %s\n", nt_errstr(status));
3129 goto fail;
3130 }
3131
3132 ret = true;
3133 fail:
3134 cli_close(cli1, fnum);
3135 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3136
3137 return ret;
3138 }
3139
3140 struct deferred_close_state {
3141 struct tevent_context *ev;
3142 struct cli_state *cli;
3143 uint16_t fnum;
3144 };
3145
3146 static void deferred_close_waited(struct tevent_req *subreq);
3147 static void deferred_close_done(struct tevent_req *subreq);
3148
3149 static struct tevent_req *deferred_close_send(
3150 TALLOC_CTX *mem_ctx,
3151 struct tevent_context *ev,
3152 int wait_secs,
3153 struct cli_state *cli,
3154 uint16_t fnum)
3155 {
3156 struct tevent_req *req = NULL, *subreq = NULL;
3157 struct deferred_close_state *state = NULL;
3158 struct timeval wakeup_time = timeval_current_ofs(wait_secs, 0);
3159
3160 req = tevent_req_create(
3161 mem_ctx, &state, struct deferred_close_state);
3162 if (req == NULL) {
3163 return NULL;
3164 }
3165 state->ev = ev;
3166 state->cli = cli;
3167 state->fnum = fnum;
3168
3169 subreq = tevent_wakeup_send(state, state->ev, wakeup_time);
3170 if (tevent_req_nomem(subreq, req)) {
3171 return tevent_req_post(req, ev);
3172 }
3173 tevent_req_set_callback(subreq, deferred_close_waited, req);
3174 return req;
3175 }
3176
3177 static void deferred_close_waited(struct tevent_req *subreq)
3178 {
3179 struct tevent_req *req = tevent_req_callback_data(
3180 subreq, struct tevent_req);
3181 struct deferred_close_state *state = tevent_req_data(
3182 req, struct deferred_close_state);
3183 bool ok;
3184
3185 ok = tevent_wakeup_recv(subreq);
3186 TALLOC_FREE(subreq);
3187 if (!ok) {
3188 tevent_req_oom(req);
3189 return;
3190 }
3191
3192 subreq = cli_close_send(state, state->ev, state->cli, state->fnum, 0);
3193 if (tevent_req_nomem(subreq, req)) {
3194 return;
3195 }
3196 tevent_req_set_callback(subreq, deferred_close_done, req);
3197 }
3198
3199 static void deferred_close_done(struct tevent_req *subreq)
3200 {
3201 NTSTATUS status = cli_close_recv(subreq);
3202 tevent_req_simple_finish_ntstatus(subreq, status);
3203 }
3204
3205 static NTSTATUS deferred_close_recv(struct tevent_req *req)
3206 {
3207 return tevent_req_simple_recv_ntstatus(req);
3208 }
3209
3210 struct lockread_state {
3211 struct smb1_lock_element lck;
3212 struct tevent_req *reqs[2];
3213 struct tevent_req *smbreqs[2];
3214 NTSTATUS lock_status;
3215 NTSTATUS read_status;
3216 uint8_t *readbuf;
3217 };
3218
3219 static void lockread_lockingx_done(struct tevent_req *subreq);
3220 static void lockread_read_andx_done(struct tevent_req *subreq);
3221
3222 static struct tevent_req *lockread_send(
3223 TALLOC_CTX *mem_ctx,
3224 struct tevent_context *ev,
3225 struct cli_state *cli,
3226 uint16_t fnum)
3227 {
3228 struct tevent_req *req = NULL;
3229 struct lockread_state *state = NULL;
3230 NTSTATUS status;
3231
3232 req = tevent_req_create(mem_ctx, &state, struct lockread_state);
3233 if (req == NULL) {
3234 return NULL;
3235 }
3236
3237 state->lck = (struct smb1_lock_element) {
3238 .pid = cli_getpid(cli), .offset = 0, .length = 1,
3239 };
3240
3241 state->reqs[0] = cli_lockingx_create(
3242 ev, /* mem_ctx */
3243 ev, /* tevent_context */
3244 cli, /* cli */
3245 fnum, /* fnum */
3246 LOCKING_ANDX_EXCLUSIVE_LOCK, /* typeoflock */
3247 0, /* newoplocklevel */
3248 10000, /* timeout */
3249 0, /* num_unlocks */
3250 NULL, /* unlocks */
3251 1, /* num_locks */
3252 &state->lck, /* locks */
3253 &state->smbreqs[0]); /* psmbreq */
3254 if (tevent_req_nomem(state->reqs[0], req)) {
3255 return tevent_req_post(req, ev);
3256 }
3257 tevent_req_set_callback(
3258 state->reqs[0], lockread_lockingx_done, req);
3259
3260 state->reqs[1] = cli_read_andx_create(
3261 ev, /* mem_ctx */
3262 ev, /* ev */
3263 cli, /* cli */
3264 fnum, /* fnum */
3265 0, /* offset */
3266 1, /* size */
3267 &state->smbreqs[1]); /* psmbreq */
3268 if (tevent_req_nomem(state->reqs[1], req)) {
3269 return tevent_req_post(req, ev);
3270 }
3271 tevent_req_set_callback(
3272 state->reqs[1], lockread_read_andx_done, req);
3273
3274 status = smb1cli_req_chain_submit(state->smbreqs, 2);
3275 if (tevent_req_nterror(req, status)) {
3276 return tevent_req_post(req, ev);
3277 }
3278 return req;
3279 }
3280
3281 static void lockread_lockingx_done(struct tevent_req *subreq)
3282 {
3283 struct tevent_req *req = tevent_req_callback_data(
3284 subreq, struct tevent_req);
3285 struct lockread_state *state = tevent_req_data(
3286 req, struct lockread_state);
3287 state->lock_status = cli_lockingx_recv(subreq);
3288 TALLOC_FREE(subreq);
3289 d_fprintf(stderr,
3290 "lockingx returned %s\n",
3291 nt_errstr(state->lock_status));
3292 }
3293
3294 static void lockread_read_andx_done(struct tevent_req *subreq)
3295 {
3296 struct tevent_req *req = tevent_req_callback_data(
3297 subreq, struct tevent_req);
3298 struct lockread_state *state = tevent_req_data(
3299 req, struct lockread_state);
3300 ssize_t received = -1;
3301 uint8_t *rcvbuf = NULL;
3302
3303 state->read_status = cli_read_andx_recv(subreq, &received, &rcvbuf);
3304
3305 d_fprintf(stderr,
3306 "read returned %s\n",
3307 nt_errstr(state->read_status));
3308
3309 if (!NT_STATUS_IS_OK(state->read_status)) {
3310 TALLOC_FREE(subreq);
3311 tevent_req_done(req);
3312 return;
3313 }
3314
3315 if (received > 0) {
3316 state->readbuf = talloc_memdup(state, rcvbuf, received);
3317 TALLOC_FREE(subreq);
3318 if (tevent_req_nomem(state->readbuf, req)) {
3319 return;
3320 }
3321 }
3322 TALLOC_FREE(subreq);
3323 tevent_req_done(req);
3324 }
3325
3326 static NTSTATUS lockread_recv(
3327 struct tevent_req *req,
3328 NTSTATUS *lock_status,
3329 NTSTATUS *read_status,
3330 TALLOC_CTX *mem_ctx,
3331 uint8_t **read_buf)
3332 {
3333 struct lockread_state *state = tevent_req_data(
3334 req, struct lockread_state);
3335 NTSTATUS status;
3336
3337 if (tevent_req_is_nterror(req, &status)) {
3338 return status;
3339 }
3340
3341 *lock_status = state->lock_status;
3342 *read_status = state->read_status;
3343 if (state->readbuf != NULL) {
3344 *read_buf = talloc_move(mem_ctx, &state->readbuf);
3345 } else {
3346 *read_buf = NULL;
3347 }
3348
3349 return NT_STATUS_OK;
3350 }
3351
3352 struct lock12_state {
3353 uint8_t dummy;
3354 };
3355
3356 static void lock12_closed(struct tevent_req *subreq);
3357 static void lock12_read(struct tevent_req *subreq);
3358
3359 static struct tevent_req *lock12_send(
3360 TALLOC_CTX *mem_ctx,
3361 struct tevent_context *ev,
3362 struct cli_state *cli,
3363 uint16_t fnum1,
3364 uint16_t fnum2)
3365 {
3366 struct tevent_req *req = NULL, *subreq = NULL;
3367 struct lock12_state *state = NULL;
3368
3369 req = tevent_req_create(mem_ctx, &state, struct lock12_state);
3370 if (req == NULL) {
3371 return NULL;
3372 }
3373
3374 subreq = deferred_close_send(state, ev, 1, cli, fnum1);
3375 if (tevent_req_nomem(subreq, req)) {
3376 return tevent_req_post(req, ev);
3377 }
3378 tevent_req_set_callback(subreq, lock12_closed, req);
3379
3380 subreq = lockread_send(state, ev, cli, fnum2);
3381 if (tevent_req_nomem(subreq, req)) {
3382 return tevent_req_post(req, ev);
3383 }
3384 tevent_req_set_callback(subreq, lock12_read, req);
3385
3386 return req;
3387 }
3388
3389 static void lock12_closed(struct tevent_req *subreq)
3390 {
3391 struct tevent_req *req = tevent_req_callback_data(
3392 subreq, struct tevent_req);
3393 NTSTATUS status;
3394
3395 status = deferred_close_recv(subreq);
3396 TALLOC_FREE(subreq);
3397 DBG_DEBUG("close returned %s\n", nt_errstr(status));
3398 if (tevent_req_nterror(req, status)) {
3399 return;
3400 }
3401 }
3402
3403 static void lock12_read(struct tevent_req *subreq)
3404 {
3405 struct tevent_req *req = tevent_req_callback_data(
3406 subreq, struct tevent_req);
3407 struct lock12_state *state = tevent_req_data(
3408 req, struct lock12_state);
3409 NTSTATUS status, lock_status, read_status;
3410 uint8_t *buf = NULL;
3411
3412 status = lockread_recv(
3413 subreq, &lock_status, &read_status, state, &buf);
3414 TALLOC_FREE(subreq);
3415 if (tevent_req_nterror(req, status) ||
3416 tevent_req_nterror(req, lock_status) ||
3417 tevent_req_nterror(req, read_status)) {
3418 return;
3419 }
3420 tevent_req_done(req);
3421 }
3422
3423 static NTSTATUS lock12_recv(struct tevent_req *req)
3424
3425 {
3426 NTSTATUS status;
3427
3428 if (tevent_req_is_nterror(req, &status)) {
3429 return status;
3430 }
3431 return NT_STATUS_OK;
3432 }
3433
3434 static bool run_locktest12(int dummy)
3435 {
3436 struct tevent_context *ev = NULL;
3437 struct tevent_req *req = NULL;
3438 struct cli_state *cli = NULL;
3439 const char fname[] = "\\lockt12.lck";
3440 uint16_t fnum1, fnum2;
3441 bool ret = false;
3442 bool ok;
3443 uint8_t data = 1;
3444 NTSTATUS status;
3445
3446 printf("starting locktest12\n");
3447
3448 ev = samba_tevent_context_init(NULL);
3449 if (ev == NULL) {
3450 d_fprintf(stderr, "samba_tevent_context_init failed\n");
3451 goto done;
3452 }
3453
3454 ok = torture_open_connection(&cli, 0);
3455 if (!ok) {
3456 goto done;
3457 }
3458 smbXcli_conn_set_sockopt(cli->conn, sockops);
3459
3460 status = cli_openx(cli, fname, O_CREAT|O_RDWR, DENY_NONE, &fnum1);
3461 if (!NT_STATUS_IS_OK(status)) {
3462 d_fprintf(stderr,
3463 "cli_openx failed: %s\n",
3464 nt_errstr(status));
3465 goto done;
3466 }
3467
3468 status = cli_openx(cli, fname, O_CREAT|O_RDWR, DENY_NONE, &fnum2);
3469 if (!NT_STATUS_IS_OK(status)) {
3470 d_fprintf(stderr,
3471 "cli_openx failed: %s\n",
3472 nt_errstr(status));
3473 goto done;
3474 }
3475
3476 status = cli_writeall(cli, fnum1, 0, &data, 0, sizeof(data), NULL);
3477 if (!NT_STATUS_IS_OK(status)) {
3478 d_fprintf(stderr,
3479 "cli_writeall failed: %s\n",
3480 nt_errstr(status));
3481 goto done;
3482 }
3483
3484 status = cli_locktype(
3485 cli, fnum1, 0, 1, 0, LOCKING_ANDX_EXCLUSIVE_LOCK);
3486 if (!NT_STATUS_IS_OK(status)) {
3487 d_fprintf(stderr,
3488 "cli_locktype failed: %s\n",
3489 nt_errstr(status));
3490 goto done;
3491 }
3492
3493 req = lock12_send(ev, ev, cli, fnum1, fnum2);
3494 if (req == NULL) {
3495 d_fprintf(stderr, "lock12_send failed\n");
3496 goto done;
3497 }
3498
3499 ok = tevent_req_poll_ntstatus(req, ev, &status);
3500 if (!ok) {
3501 d_fprintf(stderr, "tevent_req_poll_ntstatus failed\n");
3502 goto done;
3503 }
3504
3505 if (!NT_STATUS_IS_OK(status)) {
3506 d_fprintf(stderr,
3507 "tevent_req_poll_ntstatus returned %s\n",
3508 nt_errstr(status));
3509 goto done;
3510 }
3511
3512 status = lock12_recv(req);
3513 if (!NT_STATUS_IS_OK(status)) {
3514 d_fprintf(stderr, "lock12 returned %s\n", nt_errstr(status));
3515 goto done;
3516 }
3517
3518 ret = true;
3519 done:
3520 if (cli != NULL) {
3521 torture_close_connection(cli);
3522 }
3523 return ret;
3524 }
3525
3526 struct lock_ntcancel_state {
3527 struct timeval start;
3528 struct smb1_lock_element lck;
3529 struct tevent_req *subreq;
3530 };
3531
3532 static void lock_ntcancel_waited(struct tevent_req *subreq);
3533 static void lock_ntcancel_done(struct tevent_req *subreq);
3534
3535 static struct tevent_req *lock_ntcancel_send(
3536 TALLOC_CTX *mem_ctx,
3537 struct tevent_context *ev,
3538 struct cli_state *cli,
3539 uint16_t fnum)
3540 {
3541 struct tevent_req *req = NULL, *subreq = NULL;
3542 struct lock_ntcancel_state *state = NULL;
3543
3544 req = tevent_req_create(mem_ctx, &state, struct lock_ntcancel_state);
3545 if (req == NULL) {
3546 return NULL;
3547 }
3548 state->lck = (struct smb1_lock_element) {
3549 .pid = cli_getpid(cli), .offset = 0, .length = 1,
3550 };
3551 state->start = timeval_current();
3552
3553 state->subreq = cli_lockingx_send(
3554 state, /* mem_ctx */
3555 ev, /* tevent_context */
3556 cli, /* cli */
3557 fnum, /* fnum */
3558 LOCKING_ANDX_EXCLUSIVE_LOCK, /* typeoflock */
3559 0, /* newoplocklevel */
3560 10000, /* timeout */
3561 0, /* num_unlocks */
3562 NULL, /* unlocks */
3563 1, /* num_locks */
3564 &state->lck); /* locks */
3565 if (tevent_req_nomem(state->subreq, req)) {
3566 return tevent_req_post(req, ev);
3567 }
3568 tevent_req_set_callback(state->subreq, lock_ntcancel_done, req);
3569
3570 subreq = tevent_wakeup_send(state, ev, timeval_current_ofs(1, 0));
3571 if (tevent_req_nomem(subreq, req)) {
3572 return tevent_req_post(req, ev);
3573 }
3574 tevent_req_set_callback(subreq, lock_ntcancel_waited, req);
3575 return req;
3576 }
3577
3578 static void lock_ntcancel_waited(struct tevent_req *subreq)
3579 {
3580 struct tevent_req *req = tevent_req_callback_data(
3581 subreq, struct tevent_req);
3582 struct lock_ntcancel_state *state = tevent_req_data(
3583 req, struct lock_ntcancel_state);
3584 bool ok;
3585
3586 ok = tevent_wakeup_recv(subreq);
3587 TALLOC_FREE(subreq);
3588 if (!ok) {
3589 tevent_req_oom(req);
3590 return;
3591 }
3592
3593 ok = tevent_req_cancel(state->subreq);
3594 if (!ok) {
3595 d_fprintf(stderr, "Could not cancel subreq\n");
3596 tevent_req_oom(req);
3597 return;
3598 }
3599 }
3600
3601 static void lock_ntcancel_done(struct tevent_req *subreq)
3602 {
3603 struct tevent_req *req = tevent_req_callback_data(
3604 subreq, struct tevent_req);
3605 struct lock_ntcancel_state *state = tevent_req_data(
3606 req, struct lock_ntcancel_state);
3607 NTSTATUS status;
3608 double elapsed;
3609
3610 status = cli_lockingx_recv(subreq);
3611 TALLOC_FREE(subreq);
3612
3613 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
3614 d_printf("cli_lockingx returned %s\n", nt_errstr(status));
3615 tevent_req_nterror(req, NT_STATUS_UNSUCCESSFUL);
3616 return;
3617 }
3618
3619 elapsed = timeval_elapsed(&state->start);
3620
3621 if (elapsed > 3) {
3622 d_printf("cli_lockingx was too slow, cancel did not work\n");
3623 tevent_req_nterror(req, NT_STATUS_UNSUCCESSFUL);
3624 return;
3625 }
3626
3627 tevent_req_done(req);
3628 }
3629
3630 static NTSTATUS lock_ntcancel_recv(struct tevent_req *req)
3631 {
3632 return tevent_req_simple_recv_ntstatus(req);
3633 }
3634
3635 static bool run_locktest13(int dummy)
3636 {
3637 struct tevent_context *ev = NULL;
3638 struct tevent_req *req = NULL;
3639 struct cli_state *cli = NULL;
3640 const char fname[] = "\\lockt13.lck";
3641 uint16_t fnum1, fnum2;
3642 bool ret = false;
3643 bool ok;
3644 uint8_t data = 1;
3645 NTSTATUS status;
3646
3647 printf("starting locktest13\n");
3648
3649 ev = samba_tevent_context_init(NULL);
3650 if (ev == NULL) {
3651 d_fprintf(stderr, "samba_tevent_context_init failed\n");
3652 goto done;
3653 }
3654
3655 ok = torture_open_connection(&cli, 0);
3656 if (!ok) {
3657 goto done;
3658 }
3659 smbXcli_conn_set_sockopt(cli->conn, sockops);
3660
3661 status = cli_openx(cli, fname, O_CREAT|O_RDWR, DENY_NONE, &fnum1);
3662 if (!NT_STATUS_IS_OK(status)) {
3663 d_fprintf(stderr,
3664 "cli_openx failed: %s\n",
3665 nt_errstr(status));
3666 goto done;
3667 }
3668
3669 status = cli_openx(cli, fname, O_CREAT|O_RDWR, DENY_NONE, &fnum2);
3670 if (!NT_STATUS_IS_OK(status)) {
3671 d_fprintf(stderr,
3672 "cli_openx failed: %s\n",
3673 nt_errstr(status));
3674 goto done;
3675 }
3676
3677 status = cli_writeall(cli, fnum1, 0, &data, 0, sizeof(data), NULL);
3678 if (!NT_STATUS_IS_OK(status)) {
3679 d_fprintf(stderr,
3680 "cli_writeall failed: %s\n",
3681 nt_errstr(status));
3682 goto done;
3683 }
3684
3685 status = cli_locktype(
3686 cli, fnum1, 0, 1, 0, LOCKING_ANDX_EXCLUSIVE_LOCK);
3687 if (!NT_STATUS_IS_OK(status)) {
3688 d_fprintf(stderr,
3689 "cli_locktype failed: %s\n",
3690 nt_errstr(status));
3691 goto done;
3692 }
3693
3694 req = lock_ntcancel_send(ev, ev, cli, fnum2);
3695 if (req == NULL) {
3696 d_fprintf(stderr, "lock_ntcancel_send failed\n");
3697 goto done;
3698 }
3699
3700 ok = tevent_req_poll_ntstatus(req, ev, &status);
3701 if (!ok) {
3702 d_fprintf(stderr, "tevent_req_poll_ntstatus failed\n");
3703 goto done;
3704 }
3705
3706 if (!NT_STATUS_IS_OK(status)) {
3707 d_fprintf(stderr,
3708 "tevent_req_poll_ntstatus returned %s\n",
3709 nt_errstr(status));
3710 goto done;
3711 }
3712
3713 status = lock_ntcancel_recv(req);
3714 if (!NT_STATUS_IS_OK(status)) {
3715 d_fprintf(stderr,
3716 "lock_ntcancel returned %s\n",
3717 nt_errstr(status));
3718 goto done;
3719 }
3720
3721 ret = true;
3722 done:
3723 if (cli != NULL) {
3724 torture_close_connection(cli);
3725 }
3726 return ret;
3727 }
3728
3729 /*
3730 test whether fnums and tids open on one VC are available on another (a major
3731 security hole)
3732 */
3733 static bool run_fdpasstest(int dummy)
3734 {
3735 struct cli_state *cli1, *cli2;
3736 const char *fname = "\\fdpass.tst";
3737 uint16_t fnum1;
3738 char buf[1024];
3739 NTSTATUS status;
3740
3741 if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
3742 return False;
3743 }
3744 smbXcli_conn_set_sockopt(cli1->conn, sockops);
3745 smbXcli_conn_set_sockopt(cli2->conn, sockops);
3746
3747 printf("starting fdpasstest\n");
3748
3749 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3750
3751 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
3752 &fnum1);
3753 if (!NT_STATUS_IS_OK(status)) {
3754 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3755 return False;
3756 }
3757
3758 status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"hello world\n", 0,
3759 13, NULL);
3760 if (!NT_STATUS_IS_OK(status)) {
3761 printf("write failed (%s)\n", nt_errstr(status));
3762 return False;
3763 }
3764
3765 cli_state_set_uid(cli2, cli_state_get_uid(cli1));
3766 cli_state_set_tid(cli2, cli_state_get_tid(cli1));
3767 cli_setpid(cli2, cli_getpid(cli1));
3768
3769 if (test_cli_read(cli2, fnum1, buf, 0, 13, NULL, 13)) {
3770 printf("read succeeded! nasty security hole [%s]\n", buf);
3771 return false;
3772 }
3773
3774 cli_close(cli1, fnum1);
3775 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3776
3777 torture_close_connection(cli1);
3778 torture_close_connection(cli2);
3779
3780 printf("finished fdpasstest\n");
3781 return True;
3782 }
3783
3784 static bool run_fdsesstest(int dummy)
3785 {
3786 struct cli_state *cli;
3787 uint16_t new_vuid;
3788 uint16_t saved_vuid;
3789 uint32_t new_cnum;
3790 uint32_t saved_cnum;
3791 const char *fname = "\\fdsess.tst";
3792 const char *fname1 = "\\fdsess1.tst";
3793 uint16_t fnum1;
3794 uint16_t fnum2;
3795 char buf[1024];
3796 bool ret = True;
3797 NTSTATUS status;
3798
3799 if (!torture_open_connection(&cli, 0))
3800 return False;
3801 smbXcli_conn_set_sockopt(cli->conn, sockops);
3802
3803 if (!torture_cli_session_setup2(cli, &new_vuid))
3804 return False;
3805
3806 saved_cnum = cli_state_get_tid(cli);
3807 if (!NT_STATUS_IS_OK(cli_tree_connect(cli, share, "?????", NULL)))
3808 return False;
3809 new_cnum = cli_state_get_tid(cli);
3810 cli_state_set_tid(cli, saved_cnum);
3811
3812 printf("starting fdsesstest\n");
3813
3814 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3815 cli_unlink(cli, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3816
3817 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
3818 if (!NT_STATUS_IS_OK(status)) {
3819 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3820 return False;
3821 }
3822
3823 status = cli_writeall(cli, fnum1, 0, (const uint8_t *)"hello world\n", 0, 13,
3824 NULL);
3825 if (!NT_STATUS_IS_OK(status)) {
3826 printf("write failed (%s)\n", nt_errstr(status));
3827 return False;
3828 }
3829
3830 saved_vuid = cli_state_get_uid(cli);
3831 cli_state_set_uid(cli, new_vuid);
3832
3833 if (test_cli_read(cli, fnum1, buf, 0, 13, NULL, 13)) {
3834 printf("read succeeded with different vuid! "
3835 "nasty security hole [%s]\n", buf);
3836 ret = false;
3837 }
3838 /* Try to open a file with different vuid, samba cnum. */
3839 if (NT_STATUS_IS_OK(cli_openx(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum2))) {
3840 printf("create with different vuid, same cnum succeeded.\n");
3841 cli_close(cli, fnum2);
3842 cli_unlink(cli, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3843 } else {
3844 printf("create with different vuid, same cnum failed.\n");
3845 printf("This will cause problems with service clients.\n");
3846 ret = False;
3847 }
3848
3849 cli_state_set_uid(cli, saved_vuid);
3850
3851 /* Try with same vuid, different cnum. */
3852 cli_state_set_tid(cli, new_cnum);
3853
3854 if (test_cli_read(cli, fnum1, buf, 0, 13, NULL, 13)) {
3855 printf("read succeeded with different cnum![%s]\n", buf);
3856 ret = false;
3857 }
3858
3859 cli_state_set_tid(cli, saved_cnum);
3860 cli_close(cli, fnum1);
3861 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3862
3863 torture_close_connection(cli);
3864
3865 printf("finished fdsesstest\n");
3866 return ret;
3867 }
3868
3869 /*
3870 This test checks that
3871
3872 1) the server does not allow an unlink on a file that is open
3873 */
3874 static bool run_unlinktest(int dummy)
3875 {
3876 struct cli_state *cli;
3877 const char *fname = "\\unlink.tst";
3878 uint16_t fnum;
3879 bool correct = True;
3880 NTSTATUS status;
3881
3882 if (!torture_open_connection(&cli, 0)) {
3883 return False;
3884 }
3885
3886 smbXcli_conn_set_sockopt(cli->conn, sockops);
3887
3888 printf("starting unlink test\n");
3889
3890 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3891
3892 cli_setpid(cli, 1);
3893
3894 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
3895 if (!NT_STATUS_IS_OK(status)) {
3896 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3897 return False;
3898 }
3899
3900 status = cli_unlink(cli, fname,
3901 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3902 if (NT_STATUS_IS_OK(status)) {
3903 printf("error: server allowed unlink on an open file\n");
3904 correct = False;
3905 } else {
3906 correct = check_error(__LINE__, status, ERRDOS, ERRbadshare,
3907 NT_STATUS_SHARING_VIOLATION);
3908 }
3909
3910 cli_close(cli, fnum);
3911 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3912
3913 if (!torture_close_connection(cli)) {
3914 correct = False;
3915 }
3916
3917 printf("unlink test finished\n");
3918
3919 return correct;
3920 }
3921
3922
3923 /*
3924 test how many open files this server supports on the one socket
3925 */
3926 static bool run_maxfidtest(int dummy)
3927 {
3928 struct cli_state *cli;
3929 fstring fname;
3930 uint16_t fnums[0x11000];
3931 int i;
3932 int retries=4;
3933 bool correct = True;
3934 NTSTATUS status;
3935
3936 cli = current_cli;
3937
3938 if (retries <= 0) {
3939 printf("failed to connect\n");
3940 return False;
3941 }
3942
3943 smbXcli_conn_set_sockopt(cli->conn, sockops);
3944
3945 for (i=0; i<0x11000; i++) {
3946 slprintf(fname,sizeof(fname)-1,"\\maxfid.%d.%d", i,(int)getpid());
3947 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE,
3948 &fnums[i]);
3949 if (!NT_STATUS_IS_OK(status)) {
3950 printf("open of %s failed (%s)\n",
3951 fname, nt_errstr(status));
3952 printf("maximum fnum is %d\n", i);
3953 break;
3954 }
3955 printf("%6d\r", i);
3956 }
3957 printf("%6d\n", i);
3958 i--;
3959
3960 printf("cleaning up\n");
3961 for (;i>=0;i--) {
3962 slprintf(fname,sizeof(fname)-1,"\\maxfid.%d.%d", i,(int)getpid());
3963 cli_close(cli, fnums[i]);
3964
3965 status = cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3966 if (!NT_STATUS_IS_OK(status)) {
3967 printf("unlink of %s failed (%s)\n",
3968 fname, nt_errstr(status));
3969 correct = False;
3970 }
3971 printf("%6d\r", i);
3972 }
3973 printf("%6d\n", 0);
3974
3975 printf("maxfid test finished\n");
3976 if (!torture_close_connection(cli)) {
3977 correct = False;
3978 }
3979 return correct;
3980 }
3981
3982 /* send smb negprot commands, not reading the response */
3983 static bool run_negprot_nowait(int dummy)
3984 {
3985 struct tevent_context *ev;
3986 int i;
3987 struct cli_state *cli;
3988 bool correct = True;
3989
3990 printf("starting negprot nowait test\n");
3991
3992 ev = samba_tevent_context_init(talloc_tos());
3993 if (ev == NULL) {
3994 return false;
3995 }
3996
3997 if (!(cli = open_nbt_connection())) {
3998 TALLOC_FREE(ev);
3999 return False;
4000 }
4001
4002 for (i=0;i<50000;i++) {
4003 struct tevent_req *req;
4004
4005 req = smbXcli_negprot_send(
4006 ev,
4007 ev,
4008 cli->conn,
4009 cli->timeout,
4010 PROTOCOL_CORE,
4011 PROTOCOL_NT1,
4012 0,
4013 NULL);
4014 if (req == NULL) {
4015 TALLOC_FREE(ev);
4016 return false;
4017 }
4018 if (!tevent_req_poll(req, ev)) {
4019 d_fprintf(stderr, "tevent_req_poll failed: %s\n",
4020 strerror(errno));
4021 TALLOC_FREE(ev);
4022 return false;
4023 }
4024 TALLOC_FREE(req);
4025 }
4026
4027 if (torture_close_connection(cli)) {
4028 correct = False;
4029 }
4030
4031 printf("finished negprot nowait test\n");
4032
4033 return correct;
4034 }
4035
4036 /* send smb negprot commands, not reading the response */
4037 static bool run_bad_nbt_session(int dummy)
4038 {
4039 struct nmb_name called, calling;
4040 struct sockaddr_storage ss;
4041 NTSTATUS status;
4042 int fd;
4043 bool ret;
4044
4045 printf("starting bad nbt session test\n");
4046
4047 make_nmb_name(&calling, myname, 0x0);
4048 make_nmb_name(&called , host, 0x20);
4049
4050 if (!resolve_name(host, &ss, 0x20, true)) {
4051 d_fprintf(stderr, "Could not resolve name %s\n", host);
4052 return false;
4053 }
4054
4055 status = open_socket_out(&ss, NBT_SMB_PORT, 10000, &fd);
4056 if (!NT_STATUS_IS_OK(status)) {
4057 d_fprintf(stderr, "open_socket_out failed: %s\n",
4058 nt_errstr(status));
4059 return false;
4060 }
4061
4062 ret = cli_bad_session_request(fd, &calling, &called);
4063 close(fd);
4064 if (!ret) {
4065 d_fprintf(stderr, "open_socket_out failed: %s\n",
4066 nt_errstr(status));
4067 return false;
4068 }
4069
4070 printf("finished bad nbt session test\n");
4071 return true;
4072 }
4073
4074 /* send random IPC commands */
4075 static bool run_randomipc(int dummy)
4076 {
4077 int i;
4078 struct cli_state *cli;
4079 bool correct = True;
4080 int count = 50000;
4081
4082 printf("starting random ipc test\n");
4083
4084 if (!torture_open_connection(&cli, 0)) {
4085 return False;
4086 }
4087
4088 for (i=0;i<count;i++) {
4089 int api = sys_random() % 500;
4090 int param_len = (sys_random() % 64);
4091 uint8_t param[1024];
4092 uint8_t *rparam = NULL;
4093 uint8_t *rdata = NULL;
4094 uint32_t rdrcnt, rprcnt;
4095
4096 generate_random_buffer(param, param_len);
4097
4098 SSVAL(param,0,api);
4099
4100 cli_trans(talloc_tos(), /* mem_ctx */
4101 cli, /* cli */
4102 SMBtrans, /* cmd */
4103 "\\PIPE\\LANMAN", /* name */
4104 0, /* fid */
4105 0, /* function */
4106 0, /* flags */
4107 NULL, /* setup */
4108 0, /* num_setup */
4109 0, /* max_setup */
4110 param, /* param */
4111 param_len, /* num_param */
4112 8, /* max_param */
4113 NULL, /* data */
4114 0, /* num_data */
4115 CLI_BUFFER_SIZE, /* max_data, for W2K */
4116 NULL, /* recv_flags2 */
4117 NULL, /* rsetup */
4118 0, /* min_rsetup */
4119 NULL, /* num_rsetup */
4120 &rparam, /* rparam */
4121 0, /* min_rparam */
4122 &rprcnt, /* num_rparam */
4123 &rdata, /* rdata */
4124 0, /* min_rdata */
4125 &rdrcnt); /* num_rdata */
4126 if (i % 100 == 0) {
4127 printf("%d/%d\r", i,count);
4128 }
4129 TALLOC_FREE(rparam);
4130 TALLOC_FREE(rdata);
4131 }
4132 printf("%d/%d\n", i, count);
4133
4134 if (!torture_close_connection(cli)) {
4135 correct = False;
4136 }
4137
4138 printf("finished random ipc test\n");
4139
4140 return correct;
4141 }
4142
4143
4144
4145 static void browse_callback(const char *sname, uint32_t stype,
4146 const char *comment, void *state)
4147 {
4148 printf("\t%20.20s %08x %s\n", sname, stype, comment);
4149 }
4150
4151
4152
4153 /*
4154 This test checks the browse list code
4155
4156 */
4157 static bool run_browsetest(int dummy)
4158 {
4159 static struct cli_state *cli;
4160 bool correct = True;
4161
4162 printf("starting browse test\n");
4163
4164 if (!torture_open_connection(&cli, 0)) {
4165 return False;
4166 }
4167
4168 printf("domain list:\n");
4169 cli_NetServerEnum(cli, cli->server_domain,
4170 SV_TYPE_DOMAIN_ENUM,
4171 browse_callback, NULL);
4172
4173 printf("machine list:\n");
4174 cli_NetServerEnum(cli, cli->server_domain,
4175 SV_TYPE_ALL,
4176 browse_callback, NULL);
4177
4178 if (!torture_close_connection(cli)) {
4179 correct = False;
4180 }
4181
4182 printf("browse test finished\n");
4183
4184 return correct;
4185
4186 }
4187
4188 static bool check_attributes(struct cli_state *cli,
4189 const char *fname,
4190 uint32_t expected_attrs)
4191 {
4192 uint32_t attrs = 0;
4193 NTSTATUS status = cli_getatr(cli,
4194 fname,
4195 &attrs,
4196 NULL,
4197 NULL);
4198 if (!NT_STATUS_IS_OK(status)) {
4199 printf("cli_getatr failed with %s\n",
4200 nt_errstr(status));
4201 return false;
4202 }
4203 if (attrs != expected_attrs) {
4204 printf("Attributes incorrect 0x%x, should be 0x%x\n",
4205 (unsigned int)attrs,
4206 (unsigned int)expected_attrs);
4207 return false;
4208 }
4209 return true;
4210 }
4211
4212 /*
4213 This checks how the getatr calls works
4214 */
4215 static bool run_attrtest(int dummy)
4216 {
4217 struct cli_state *cli;
4218 uint16_t fnum;
4219 time_t t, t2;
4220 const char *fname = "\\attrib123456789.tst";
4221 bool correct = True;
4222 NTSTATUS status;
4223
4224 printf("starting attrib test\n");
4225
4226 if (!torture_open_connection(&cli, 0)) {
4227 return False;
4228 }
4229
4230 /* Ensure we can't unlink with out-of-range (unknown) attribute. */
4231 status = cli_unlink(cli, fname, 0x20000);
4232 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
4233 correct = false;
4234 goto out;
4235 }
4236
4237 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4238 cli_openx(cli, fname,
4239 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
4240 cli_close(cli, fnum);
4241
4242 status = cli_getatr(cli, fname, NULL, NULL, &t);
4243 if (!NT_STATUS_IS_OK(status)) {
4244 printf("getatr failed (%s)\n", nt_errstr(status));
4245 correct = False;
4246 }
4247
4248 if (labs(t - time(NULL)) > 60*60*24*10) {
4249 printf("ERROR: SMBgetatr bug. time is %s",
4250 ctime(&t));
4251 t = time(NULL);
4252 correct = True;
4253 }
4254
4255 t2 = t-60*60*24; /* 1 day ago */
4256
4257 /* Ensure we can't set with out-of-range (unknown) attribute. */
4258 status = cli_setatr(cli, fname, 0x20000, t2);
4259 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
4260 correct = false;
4261 goto out;
4262 }
4263
4264 status = cli_setatr(cli, fname, 0, t2);
4265 if (!NT_STATUS_IS_OK(status)) {
4266 printf("setatr failed (%s)\n", nt_errstr(status));
4267 correct = True;
4268 }
4269
4270 status = cli_getatr(cli, fname, NULL, NULL, &t);
4271 if (!NT_STATUS_IS_OK(status)) {
4272 printf("getatr failed (%s)\n", nt_errstr(status));
4273 correct = True;
4274 }
4275
4276 if (t != t2) {
4277 printf("ERROR: getatr/setatr bug. times are\n%s",
4278 ctime(&t));
4279 printf("%s", ctime(&t2));
4280 correct = True;
4281 }
4282
4283 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4284
4285 /* Check cli_setpathinfo_ext() */
4286 /* Re-create the file. */
4287 status = cli_openx(cli, fname,
4288 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
4289 if (!NT_STATUS_IS_OK(status)) {
4290 printf("Failed to recreate %s (%s)\n",
4291 fname, nt_errstr(status));
4292 correct = false;
4293 }
4294 cli_close(cli, fnum);
4295
4296 status = cli_setpathinfo_ext(
4297 cli,
4298 fname,
4299 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* create */
4300 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* access */
4301 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* write */
4302 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* change */
4303 FILE_ATTRIBUTE_SYSTEM |
4304 FILE_ATTRIBUTE_HIDDEN |
4305 FILE_ATTRIBUTE_READONLY);
4306 if (!NT_STATUS_IS_OK(status)) {
4307 printf("cli_setpathinfo_ext failed with %s\n",
4308 nt_errstr(status));
4309 correct = false;
4310 }
4311
4312 /* Check attributes are correct. */
4313 correct = check_attributes(cli,
4314 fname,
4315 FILE_ATTRIBUTE_SYSTEM |
4316 FILE_ATTRIBUTE_HIDDEN |
4317 FILE_ATTRIBUTE_READONLY);
4318 if (correct == false) {
4319 goto out;
4320 }
4321
4322 /* Setting to FILE_ATTRIBUTE_NORMAL should be ignored. */
4323 status = cli_setpathinfo_ext(
4324 cli,
4325 fname,
4326 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* create */
4327 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* access */
4328 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* write */
4329 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* change */
4330 FILE_ATTRIBUTE_NORMAL);
4331 if (!NT_STATUS_IS_OK(status)) {
4332 printf("cli_setpathinfo_ext failed with %s\n",
4333 nt_errstr(status));
4334 correct = false;
4335 }
4336
4337 /* Check attributes are correct. */
4338 correct = check_attributes(cli,
4339 fname,
4340 FILE_ATTRIBUTE_SYSTEM |
4341 FILE_ATTRIBUTE_HIDDEN |
4342 FILE_ATTRIBUTE_READONLY);
4343 if (correct == false) {
4344 goto out;
4345 }
4346
4347 /* Setting to (uint16_t)-1 should also be ignored. */
4348 status = cli_setpathinfo_ext(
4349 cli,
4350 fname,
4351 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* create */
4352 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* access */
4353 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* write */
4354 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* change */
4355 (uint32_t)-1);
4356 if (!NT_STATUS_IS_OK(status)) {
4357 printf("cli_setpathinfo_ext failed with %s\n",
4358 nt_errstr(status));
4359 correct = false;
4360 }
4361
4362 /* Check attributes are correct. */
4363 correct = check_attributes(cli,
4364 fname,
4365 FILE_ATTRIBUTE_SYSTEM |
4366 FILE_ATTRIBUTE_HIDDEN |
4367 FILE_ATTRIBUTE_READONLY);
4368 if (correct == false) {
4369 goto out;
4370 }
4371
4372 /* Setting to 0 should clear them all. */
4373 status = cli_setpathinfo_ext(
4374 cli,
4375 fname,
4376 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* create */
4377 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* access */
4378 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* write */
4379 (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* change */
4380 0);
4381 if (!NT_STATUS_IS_OK(status)) {
4382 printf("cli_setpathinfo_ext failed with %s\n",
4383 nt_errstr(status));
4384 correct = false;
4385 }
4386
4387 /* Check attributes are correct. */
4388 correct = check_attributes(cli,
4389 fname,
4390 FILE_ATTRIBUTE_NORMAL);
4391 if (correct == false) {
4392 goto out;
4393 }
4394
4395 out:
4396
4397 cli_unlink(cli,
4398 fname,
4399 FILE_ATTRIBUTE_SYSTEM |
4400 FILE_ATTRIBUTE_HIDDEN|
4401 FILE_ATTRIBUTE_READONLY);
4402
4403 if (!torture_close_connection(cli)) {
4404 correct = False;
4405 }
4406
4407 printf("attrib test finished\n");
4408
4409 return correct;
4410 }
4411
4412 static NTSTATUS cli_qfilename(
4413 struct cli_state *cli,
4414 uint16_t fnum,
4415 TALLOC_CTX *mem_ctx,
4416 char **_name)
4417 {
4418 uint16_t recv_flags2;
4419 uint8_t *rdata;
4420 uint32_t num_rdata;
4421 NTSTATUS status;
4422 char *name = NULL;
4423 uint32_t namelen;
4424
4425 status = cli_qfileinfo(talloc_tos(),
4426 cli,
4427 fnum,
4428 FSCC_FILE_NAME_INFORMATION,
4429 4,
4430 CLI_BUFFER_SIZE,
4431 &recv_flags2,
4432 &rdata,
4433 &num_rdata);
4434 if (!NT_STATUS_IS_OK(status)) {
4435 return status;
4436 }
4437
4438 namelen = IVAL(rdata, 0);
4439 if (namelen > (num_rdata - 4)) {
4440 TALLOC_FREE(rdata);
4441 return NT_STATUS_INVALID_NETWORK_RESPONSE;
4442 }
4443
4444 pull_string_talloc(mem_ctx,
4445 (const char *)rdata,
4446 recv_flags2,
4447 &name,
4448 rdata + 4,
4449 namelen,
4450 STR_UNICODE);
4451 if (name == NULL) {
4452 status = map_nt_error_from_unix(errno);
4453 TALLOC_FREE(rdata);
4454 return status;
4455 }
4456
4457 *_name = name;
4458 TALLOC_FREE(rdata);
4459 return NT_STATUS_OK;
4460 }
4461
4462 /*
4463 This checks a couple of trans2 calls
4464 */
4465 static bool run_trans2test(int dummy)
4466 {
4467 struct cli_state *cli;
4468 uint16_t fnum;
4469 off_t size;
4470 time_t c_time, a_time, m_time;
4471 struct timespec c_time_ts, a_time_ts, m_time_ts, w_time_ts, m_time2_ts;
4472 const char *fname = "\\trans2.tst";
4473 const char *dname = "\\trans2";
4474 const char *fname2 = "\\trans2\\trans2.tst";
4475 char *pname = NULL;
4476 bool correct = True;
4477 NTSTATUS status;
4478 uint32_t fs_attr;
4479 uint64_t ino;
4480
4481 printf("starting trans2 test\n");
4482
4483 if (!torture_open_connection(&cli, 0)) {
4484 return False;
4485 }
4486
4487 if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
4488 /* Ensure ino is zero, SMB2 gets a real one. */
4489 ino = 0;
4490 } else {
4491 /* Ensure ino is -1, SMB1 never gets a real one. */
4492 ino = (uint64_t)-1;
4493 }
4494
4495 status = cli_get_fs_attr_info(cli, &fs_attr);
4496 if (!NT_STATUS_IS_OK(status)) {
4497 printf("ERROR: cli_get_fs_attr_info returned %s\n",
4498 nt_errstr(status));
4499 correct = false;
4500 }
4501
4502 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4503 cli_openx(cli, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
4504 status = cli_qfileinfo_basic(cli, fnum, NULL, &size, &c_time_ts,
4505 &a_time_ts, &w_time_ts, &m_time_ts, NULL);
4506 if (!NT_STATUS_IS_OK(status)) {
4507 printf("ERROR: qfileinfo failed (%s)\n", nt_errstr(status));
4508 correct = False;
4509 }
4510
4511 status = cli_qfilename(cli, fnum, talloc_tos(), &pname);
4512 if (!NT_STATUS_IS_OK(status)) {
4513 printf("ERROR: qfilename failed (%s)\n", nt_errstr(status));
4514 correct = False;
4515 }
4516 else if (strcmp(pname, fname)) {
4517 printf("qfilename gave different name? [%s] [%s]\n",
4518 fname, pname);
4519 correct = False;
4520 }
4521
4522 cli_close(cli, fnum);
4523
4524 sleep(2);
4525
4526 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4527 status = cli_openx(cli, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE,
4528 &fnum);
4529 if (!NT_STATUS_IS_OK(status)) {
4530 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4531 return False;
4532 }
4533 cli_close(cli, fnum);
4534
4535 status = cli_qpathinfo1(cli, fname, &c_time, &a_time, &m_time, &size,
4536 NULL);
4537 if (!NT_STATUS_IS_OK(status)) {
4538 printf("ERROR: qpathinfo failed (%s)\n", nt_errstr(status));
4539 correct = False;
4540 } else {
4541 time_t t = time(NULL);
4542
4543 if (c_time != m_time) {
4544 printf("create time=%s", ctime(&c_time));
4545 printf("modify time=%s", ctime(&m_time));
4546 printf("This system appears to have sticky create times\n");
4547 }
4548 if ((labs(a_time - t) > 60) && (a_time % (60*60) == 0)) {
4549 printf("access time=%s", ctime(&a_time));
4550 printf("This system appears to set a midnight access time\n");
4551 correct = False;
4552 }
4553
4554 if (labs(m_time - t) > 60*60*24*7) {
4555 printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
4556 correct = False;
4557 }
4558 }
4559
4560
4561 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4562 cli_openx(cli, fname,
4563 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
4564 cli_close(cli, fnum);
4565 status = cli_qpathinfo2(cli,
4566 fname,
4567 &c_time_ts,
4568 &a_time_ts,
4569 &w_time_ts,
4570 &m_time_ts,
4571 &size,
4572 NULL,
4573 &ino,
4574 NULL);
4575 if (!NT_STATUS_IS_OK(status)) {
4576 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
4577 correct = False;
4578 } else {
4579 if (w_time_ts.tv_sec < 60*60*24*2) {
4580 printf("write time=%s", ctime(&w_time_ts.tv_sec));
4581 printf("This system appears to set a initial 0 write time\n");
4582 correct = False;
4583 }
4584 if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
4585 /* SMB2 should always return an inode. */
4586 if (ino == 0) {
4587 printf("SMB2 bad inode (0)\n");
4588 correct = false;
4589 }
4590 } else {
4591 /* SMB1 must always return zero here. */
4592 if (ino != 0) {
4593 printf("SMB1 bad inode (!0)\n");
4594 correct = false;
4595 }
4596 }
4597 }
4598
4599 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4600
4601
4602 /* check if the server updates the directory modification time
4603 when creating a new file */
4604 status = cli_mkdir(cli, dname);
4605 if (!NT_STATUS_IS_OK(status)) {
4606 printf("ERROR: mkdir failed (%s)\n", nt_errstr(status));
4607 correct = False;
4608 }
4609 sleep(3);
4610 status = cli_qpathinfo2(cli,
4611 "\\trans2\\",
4612 &c_time_ts,
4613 &a_time_ts,
4614 &w_time_ts,
4615 &m_time_ts,
4616 &size,
4617 NULL,
4618 NULL,
4619 NULL);
4620 if (!NT_STATUS_IS_OK(status)) {
4621 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
4622 correct = False;
4623 }
4624
4625 cli_openx(cli, fname2,
4626 O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
4627 cli_writeall(cli, fnum, 0, (uint8_t *)&fnum, 0, sizeof(fnum), NULL);
4628 cli_close(cli, fnum);
4629 status = cli_qpathinfo2(cli,
4630 "\\trans2\\",
4631 &c_time_ts,
4632 &a_time_ts,
4633 &w_time_ts,
4634 &m_time2_ts,
4635 &size,
4636 NULL,
4637 NULL,
4638 NULL);
4639 if (!NT_STATUS_IS_OK(status)) {
4640 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
4641 correct = False;
4642 } else {
4643 if (memcmp(&m_time_ts, &m_time2_ts, sizeof(struct timespec))
4644 == 0) {
4645 printf("This system does not update directory modification times\n");
4646 correct = False;
4647 }
4648 }
4649 cli_unlink(cli, fname2, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4650 cli_rmdir(cli, dname);
4651
4652 if (!torture_close_connection(cli)) {
4653 correct = False;
4654 }
4655
4656 printf("trans2 test finished\n");
4657
4658 return correct;
4659 }
4660
4661 /*
4662 This checks new W2K calls.
4663 */
4664
4665 static NTSTATUS new_trans(struct cli_state *pcli, int fnum, int level)
4666 {
4667 uint8_t *buf = NULL;
4668 uint32_t len;
4669 NTSTATUS status;
4670
4671 status = cli_qfileinfo(talloc_tos(), pcli, fnum, level, 0,
4672 CLI_BUFFER_SIZE, NULL, &buf, &len);
4673 if (!NT_STATUS_IS_OK(status)) {
4674 printf("ERROR: qfileinfo (%d) failed (%s)\n", level,
4675 nt_errstr(status));
4676 } else {
4677 printf("qfileinfo: level %d, len = %u\n", level, len);
4678 dump_data(0, (uint8_t *)buf, len);
4679 printf("\n");
4680 }
4681 TALLOC_FREE(buf);
4682 return status;
4683 }
4684
4685 static bool run_w2ktest(int dummy)
4686 {
4687 struct cli_state *cli;
4688 uint16_t fnum;
4689 const char *fname = "\\w2ktest\\w2k.tst";
4690 int level;
4691 bool correct = True;
4692
4693 printf("starting w2k test\n");
4694
4695 if (!torture_open_connection(&cli, 0)) {
4696 return False;
4697 }
4698
4699 cli_openx(cli, fname,
4700 O_RDWR | O_CREAT , DENY_NONE, &fnum);
4701
4702 for (level = 1004; level < 1040; level++) {
4703 new_trans(cli, fnum, level);
4704 }
4705
4706 cli_close(cli, fnum);
4707
4708 if (!torture_close_connection(cli)) {
4709 correct = False;
4710 }
4711
4712 printf("w2k test finished\n");
4713
4714 return correct;
4715 }
4716
4717
4718 /*
4719 this is a harness for some oplock tests
4720 */
4721 static bool run_oplock1(int dummy)
4722 {
4723 struct cli_state *cli1;
4724 const char *fname = "\\lockt1.lck";
4725 uint16_t fnum1;
4726 bool correct = True;
4727 NTSTATUS status;
4728
4729 printf("starting oplock test 1\n");
4730
4731 if (!torture_open_connection(&cli1, 0)) {
4732 return False;
4733 }
4734
4735 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4736
4737 smbXcli_conn_set_sockopt(cli1->conn, sockops);
4738
4739 cli1->use_oplocks = True;
4740
4741 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
4742 &fnum1);
4743 if (!NT_STATUS_IS_OK(status)) {
4744 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4745 return False;
4746 }
4747
4748 cli1->use_oplocks = False;
4749
4750 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4751 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4752
4753 status = cli_close(cli1, fnum1);
4754 if (!NT_STATUS_IS_OK(status)) {
4755 printf("close2 failed (%s)\n", nt_errstr(status));
4756 return False;
4757 }
4758
4759 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4760 if (!NT_STATUS_IS_OK(status)) {
4761 printf("unlink failed (%s)\n", nt_errstr(status));
4762 return False;
4763 }
4764
4765 if (!torture_close_connection(cli1)) {
4766 correct = False;
4767 }
4768
4769 printf("finished oplock test 1\n");
4770
4771 return correct;
4772 }
4773
4774 static bool run_oplock2(int dummy)
4775 {
4776 struct cli_state *cli1, *cli2;
4777 const char *fname = "\\lockt2.lck";
4778 uint16_t fnum1, fnum2;
4779 int saved_use_oplocks = use_oplocks;
4780 char buf[4];
4781 bool correct = True;
4782 volatile bool *shared_correct;
4783 size_t nread;
4784 NTSTATUS status;
4785
4786 shared_correct = (volatile bool *)anonymous_shared_allocate(sizeof(bool));
4787 *shared_correct = True;
4788
4789 use_level_II_oplocks = True;
4790 use_oplocks = True;
4791
4792 printf("starting oplock test 2\n");
4793
4794 if (!torture_open_connection(&cli1, 0)) {
4795 use_level_II_oplocks = False;
4796 use_oplocks = saved_use_oplocks;
4797 return False;
4798 }
4799
4800 if (!torture_open_connection(&cli2, 1)) {
4801 use_level_II_oplocks = False;
4802 use_oplocks = saved_use_oplocks;
4803 return False;
4804 }
4805
4806 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4807
4808 smbXcli_conn_set_sockopt(cli1->conn, sockops);
4809 smbXcli_conn_set_sockopt(cli2->conn, sockops);
4810
4811 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
4812 &fnum1);
4813 if (!NT_STATUS_IS_OK(status)) {
4814 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4815 return False;
4816 }
4817
4818 /* Don't need the globals any more. */
4819 use_level_II_oplocks = False;
4820 use_oplocks = saved_use_oplocks;
4821
4822 if (fork() == 0) {
4823 /* Child code */
4824 status = cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
4825 if (!NT_STATUS_IS_OK(status)) {
4826 printf("second open of %s failed (%s)\n", fname, nt_errstr(status));
4827 *shared_correct = False;
4828 exit(0);
4829 }
4830
4831 sleep(2);
4832
4833 status = cli_close(cli2, fnum2);
4834 if (!NT_STATUS_IS_OK(status)) {
4835 printf("close2 failed (%s)\n", nt_errstr(status));
4836 *shared_correct = False;
4837 }
4838
4839 exit(0);
4840 }
4841
4842 sleep(2);
4843
4844 /* Ensure cli1 processes the break. Empty file should always return 0
4845 * bytes. */
4846 status = cli_read(cli1, fnum1, buf, 0, 4, &nread);
4847 if (!NT_STATUS_IS_OK(status)) {
4848 printf("read on fnum1 failed (%s)\n", nt_errstr(status));
4849 correct = false;
4850 } else if (nread != 0) {
4851 printf("read on empty fnum1 failed. recv %ld expected %d\n",
4852 (unsigned long)nread, 0);
4853 correct = false;
4854 }
4855
4856 /* Should now be at level II. */
4857 /* Test if sending a write locks causes a break to none. */
4858 status = cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK);
4859 if (!NT_STATUS_IS_OK(status)) {
4860 printf("lock failed (%s)\n", nt_errstr(status));
4861 correct = False;
4862 }
4863
4864 cli_unlock(cli1, fnum1, 0, 4);
4865
4866 sleep(2);
4867
4868 status = cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK);
4869 if (!NT_STATUS_IS_OK(status)) {
4870 printf("lock failed (%s)\n", nt_errstr(status));
4871 correct = False;
4872 }
4873
4874 cli_unlock(cli1, fnum1, 0, 4);
4875
4876 sleep(2);
4877
4878 cli_read(cli1, fnum1, buf, 0, 4, NULL);
4879
4880 status = cli_close(cli1, fnum1);
4881 if (!NT_STATUS_IS_OK(status)) {
4882 printf("close1 failed (%s)\n", nt_errstr(status));
4883 correct = False;
4884 }
4885
4886 sleep(4);
4887
4888 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4889 if (!NT_STATUS_IS_OK(status)) {
4890 printf("unlink failed (%s)\n", nt_errstr(status));
4891 correct = False;
4892 }
4893
4894 if (!torture_close_connection(cli1)) {
4895 correct = False;
4896 }
4897
4898 if (!*shared_correct) {
4899 correct = False;
4900 }
4901
4902 printf("finished oplock test 2\n");
4903
4904 return correct;
4905 }
4906
4907 struct oplock4_state {
4908 struct tevent_context *ev;
4909 struct cli_state *cli;
4910 bool *got_break;
4911 uint16_t *fnum2;
4912 };
4913
4914 static void oplock4_got_break(struct tevent_req *req);
4915 static void oplock4_got_open(struct tevent_req *req);
4916
4917 static bool run_oplock4(int dummy)
4918 {
4919 struct tevent_context *ev;
4920 struct cli_state *cli1, *cli2;
4921 struct tevent_req *oplock_req, *open_req;
4922 const char *fname = "\\lockt4.lck";
4923 const char *fname_ln = "\\lockt4_ln.lck";
4924 uint16_t fnum1, fnum2;
4925 int saved_use_oplocks = use_oplocks;
4926 NTSTATUS status;
4927 bool correct = true;
4928
4929 bool got_break;
4930
4931 struct oplock4_state *state;
4932
4933 printf("starting oplock test 4\n");
4934
4935 if (!torture_open_connection(&cli1, 0)) {
4936 use_level_II_oplocks = false;
4937 use_oplocks = saved_use_oplocks;
4938 return false;
4939 }
4940
4941 if (!torture_open_connection(&cli2, 1)) {
4942 use_level_II_oplocks = false;
4943 use_oplocks = saved_use_oplocks;
4944 return false;
4945 }
4946
4947 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4948 cli_unlink(cli1, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4949
4950 smbXcli_conn_set_sockopt(cli1->conn, sockops);
4951 smbXcli_conn_set_sockopt(cli2->conn, sockops);
4952
4953 /* Create the file. */
4954 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
4955 &fnum1);
4956 if (!NT_STATUS_IS_OK(status)) {
4957 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4958 return false;
4959 }
4960
4961 status = cli_close(cli1, fnum1);
4962 if (!NT_STATUS_IS_OK(status)) {
4963 printf("close1 failed (%s)\n", nt_errstr(status));
4964 return false;
4965 }
4966
4967 /* Now create a hardlink. */
4968 status = cli_hardlink(cli1, fname, fname_ln);
4969 if (!NT_STATUS_IS_OK(status)) {
4970 printf("nt hardlink failed (%s)\n", nt_errstr(status));
4971 return false;
4972 }
4973
4974 /* Prove that opening hardlinks cause deny modes to conflict. */
4975 status = cli_openx(cli1, fname, O_RDWR, DENY_ALL, &fnum1);
4976 if (!NT_STATUS_IS_OK(status)) {
4977 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4978 return false;
4979 }
4980
4981 status = cli_openx(cli1, fname_ln, O_RDWR, DENY_NONE, &fnum2);
4982 if (NT_STATUS_IS_OK(status)) {
4983 printf("open of %s succeeded - should fail with sharing violation.\n",
4984 fname_ln);
4985 return false;
4986 }
4987
4988 if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
4989 printf("open of %s should fail with sharing violation. Got %s\n",
4990 fname_ln, nt_errstr(status));
4991 return false;
4992 }
4993
4994 status = cli_close(cli1, fnum1);
4995 if (!NT_STATUS_IS_OK(status)) {
4996 printf("close1 failed (%s)\n", nt_errstr(status));
4997 return false;
4998 }
4999
5000 cli1->use_oplocks = true;
5001 cli2->use_oplocks = true;
5002
5003 status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &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 ev = samba_tevent_context_init(talloc_tos());
5010 if (ev == NULL) {
5011 printf("tevent_context_init failed\n");
5012 return false;
5013 }
5014
5015 state = talloc(ev, struct oplock4_state);
5016 if (state == NULL) {
5017 printf("talloc failed\n");
5018 return false;
5019 }
5020 state->ev = ev;
5021 state->cli = cli1;
5022 state->got_break = &got_break;
5023 state->fnum2 = &fnum2;
5024
5025 oplock_req = cli_smb_oplock_break_waiter_send(
5026 talloc_tos(), ev, cli1);
5027 if (oplock_req == NULL) {
5028 printf("cli_smb_oplock_break_waiter_send failed\n");
5029 return false;
5030 }
5031 tevent_req_set_callback(oplock_req, oplock4_got_break, state);
5032
5033 open_req = cli_openx_send(
5034 talloc_tos(), ev, cli2, fname_ln, O_RDWR, DENY_NONE);
5035 if (open_req == NULL) {
5036 printf("cli_openx_send failed\n");
5037 return false;
5038 }
5039 tevent_req_set_callback(open_req, oplock4_got_open, state);
5040
5041 got_break = false;
5042 fnum2 = 0xffff;
5043
5044 while (!got_break || fnum2 == 0xffff) {
5045 int ret;
5046 ret = tevent_loop_once(ev);
5047 if (ret == -1) {
5048 printf("tevent_loop_once failed: %s\n",
5049 strerror(errno));
5050 return false;
5051 }
5052 }
5053
5054 status = cli_close(cli2, fnum2);
5055 if (!NT_STATUS_IS_OK(status)) {
5056 printf("close2 failed (%s)\n", nt_errstr(status));
5057 correct = false;
5058 }
5059
5060 status = cli_close(cli1, fnum1);
5061 if (!NT_STATUS_IS_OK(status)) {
5062 printf("close1 failed (%s)\n", nt_errstr(status));
5063 correct = false;
5064 }
5065
5066 status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5067 if (!NT_STATUS_IS_OK(status)) {
5068 printf("unlink failed (%s)\n", nt_errstr(status));
5069 correct = false;
5070 }
5071
5072 status = cli_unlink(cli1, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5073 if (!NT_STATUS_IS_OK(status)) {
5074 printf("unlink failed (%s)\n", nt_errstr(status));
5075 correct = false;
5076 }
5077
5078 if (!torture_close_connection(cli1)) {
5079 correct = false;
5080 }
5081
5082 if (!got_break) {
5083 correct = false;
5084 }
5085
5086 printf("finished oplock test 4\n");
5087
5088 return correct;
5089 }
5090
5091 static void oplock4_got_break(struct tevent_req *req)
5092 {
5093 struct oplock4_state *state = tevent_req_callback_data(
5094 req, struct oplock4_state);
5095 uint16_t fnum;
5096 uint8_t level;
5097 NTSTATUS status;
5098
5099 status = cli_smb_oplock_break_waiter_recv(req, &fnum, &level);
5100 TALLOC_FREE(req);
5101 if (!NT_STATUS_IS_OK(status)) {
5102 printf("cli_smb_oplock_break_waiter_recv returned %s\n",
5103 nt_errstr(status));
5104 return;
5105 }
5106 *state->got_break = true;
5107
5108 req = cli_oplock_ack_send(state, state->ev, state->cli, fnum,
5109 NO_OPLOCK);
5110 if (req == NULL) {
5111 printf("cli_oplock_ack_send failed\n");
5112 return;
5113 }
5114 }
5115
5116 static void oplock4_got_open(struct tevent_req *req)
5117 {
5118 struct oplock4_state *state = tevent_req_callback_data(
5119 req, struct oplock4_state);
5120 NTSTATUS status;
5121
5122 status = cli_openx_recv(req, state->fnum2);
5123 if (!NT_STATUS_IS_OK(status)) {
5124 printf("cli_openx_recv returned %s\n", nt_errstr(status));
5125 *state->fnum2 = 0xffff;
5126 }
5127 }
5128
5129 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
5130
5131 struct oplock5_state {
5132 int pipe_down_fd;
5133 };
5134
5135 /*
5136 * Async open the file that has a kernel oplock, do an echo to get
5137 * that 100% across, close the file to signal to the child fd that the
5138 * oplock can be dropped, wait for the open reply.
5139 */
5140
5141 static void oplock5_opened(struct tevent_req *subreq);
5142 static void oplock5_pong(struct tevent_req *subreq);
5143 static void oplock5_timedout(struct tevent_req *subreq);
5144
5145 static struct tevent_req *oplock5_send(
5146 TALLOC_CTX *mem_ctx,
5147 struct tevent_context *ev,
5148 struct cli_state *cli,
5149 const char *fname,
5150 int pipe_down_fd)
5151 {
5152 struct tevent_req *req = NULL, *subreq = NULL;
5153 struct oplock5_state *state = NULL;
5154 static uint8_t data = 0;
5155
5156 req = tevent_req_create(mem_ctx, &state, struct oplock5_state);
5157 if (req == NULL) {
5158 return NULL;
5159 }
5160 state->pipe_down_fd = pipe_down_fd;
5161
5162 subreq = cli_ntcreate_send(
5163 state,
5164 ev,
5165 cli,
5166 fname,
5167 0, /* CreatFlags */
5168 SEC_FILE_READ_DATA, /* DesiredAccess */
5169 FILE_ATTRIBUTE_NORMAL, /* FileAttributes */
5170 FILE_SHARE_WRITE|FILE_SHARE_READ, /* ShareAccess */
5171 FILE_OPEN, /* CreateDisposition */
5172 FILE_NON_DIRECTORY_FILE, /* CreateOptions */
5173 0, /* Impersonation */
5174 0); /* SecurityFlags */
5175 if (tevent_req_nomem(subreq, req)) {
5176 return tevent_req_post(req, ev);
5177 }
5178 tevent_req_set_callback(subreq, oplock5_opened, req);
5179
5180 subreq = cli_echo_send(
5181 state,
5182 ev,
5183 cli,
5184 1,
5185 (DATA_BLOB) { .data = &data, .length = sizeof(data) });
5186 if (tevent_req_nomem(subreq, req)) {
5187 return tevent_req_post(req, ev);
5188 }
5189 tevent_req_set_callback(subreq, oplock5_pong, req);
5190
5191 subreq = tevent_wakeup_send(state, ev, timeval_current_ofs(20, 0));
5192 if (tevent_req_nomem(subreq, req)) {
5193 return tevent_req_post(req, ev);
5194 }
5195 tevent_req_set_callback(subreq, oplock5_timedout, req);
5196
5197 return req;
5198 }
5199
5200 static void oplock5_opened(struct tevent_req *subreq)
5201 {
5202 struct tevent_req *req = tevent_req_callback_data(
5203 subreq, struct tevent_req);
5204 NTSTATUS status;
5205 uint16_t fnum;
5206
5207 status = cli_ntcreate_recv(subreq, &fnum, NULL);
5208 TALLOC_FREE(subreq);
5209 if (tevent_req_nterror(req, status)) {
5210 return;
5211 }
5212 tevent_req_done(req);
5213 }
5214
5215 static void oplock5_pong(struct tevent_req *subreq)
5216 {
5217 struct tevent_req *req = tevent_req_callback_data(
5218 subreq, struct tevent_req);
5219 struct oplock5_state *state = tevent_req_data(
5220 req, struct oplock5_state);
5221 NTSTATUS status;
5222
5223 status = cli_echo_recv(subreq);
5224 TALLOC_FREE(subreq);
5225 if (tevent_req_nterror(req, status)) {
5226 return;
5227 }
5228
5229 close(state->pipe_down_fd);
5230 }
5231
5232 static void oplock5_timedout(struct tevent_req *subreq)
5233 {
5234 struct tevent_req *req = tevent_req_callback_data(
5235 subreq, struct tevent_req);
5236 bool ok;
5237
5238 ok = tevent_wakeup_recv(subreq);
5239 TALLOC_FREE(subreq);
5240 if (!ok) {
5241 tevent_req_oom(req);
5242 return;
5243 }
5244 tevent_req_nterror(req, NT_STATUS_TIMEOUT);
5245 }
5246
5247 static NTSTATUS oplock5_recv(struct tevent_req *req)
5248 {
5249 return tevent_req_simple_recv_ntstatus(req);
5250 }
5251
5252 static bool run_oplock5(int dummy)
5253 {
5254 struct tevent_context *ev = NULL;
5255 struct tevent_req *req = NULL;
5256 struct cli_state *cli = NULL;
5257 const char *fname = "oplock5.txt";
5258 int pipe_down[2], pipe_up[2];
5259 pid_t child_pid;
5260 uint8_t c = '\0';
5261 NTSTATUS status;
5262 int ret;
5263 bool ok;
5264
5265 printf("starting oplock5\n");
5266
5267 if (local_path == NULL) {
5268 d_fprintf(stderr, "oplock5 must be given a local path via "
5269 "-l <localpath>\n");
5270 return false;
5271 }
5272
5273 ret = pipe(pipe_down);
5274 if (ret == -1) {
5275 d_fprintf(stderr, "pipe() failed: %s\n", strerror(errno));
5276 return false;
5277 }
5278 ret = pipe(pipe_up);
5279 if (ret == -1) {
5280 d_fprintf(stderr, "pipe() failed: %s\n", strerror(errno));
5281 return false;
5282 }
5283
5284 child_pid = fork();
5285 if (child_pid == -1) {
5286 d_fprintf(stderr, "fork() failed: %s\n", strerror(errno));
5287 return false;
5288 }
5289
5290 if (child_pid == 0) {
5291 char *local_file = NULL;
5292 int fd;
5293
5294 close(pipe_down[1]);
5295 close(pipe_up[0]);
5296
5297 local_file = talloc_asprintf(
5298 talloc_tos(), "%s/%s", local_path, fname);
5299 if (local_file == 0) {
5300 c = 1;
5301 goto do_write;
5302 }
5303 fd = open(local_file, O_RDWR|O_CREAT, 0644);
5304 if (fd == -1) {
5305 d_fprintf(stderr,
5306 "open(%s) in child failed: %s\n",
5307 local_file,
5308 strerror(errno));
5309 c = 2;
5310 goto do_write;
5311 }
5312
5313 signal(SIGIO, SIG_IGN);
5314
5315 ret = fcntl(fd, F_SETLEASE, F_WRLCK);
5316 if (ret == -1) {
5317 d_fprintf(stderr,
5318 "SETLEASE in child failed: %s\n",
5319 strerror(errno));
5320 c = 3;
5321 goto do_write;
5322 }
5323
5324 do_write:
5325 ret = sys_write(pipe_up[1], &c, sizeof(c));
5326 if (ret == -1) {
5327 d_fprintf(stderr,
5328 "sys_write failed: %s\n",
5329 strerror(errno));
5330 exit(4);
5331 }
5332 ret = sys_read(pipe_down[0], &c, sizeof(c));
5333 if (ret == -1) {
5334 d_fprintf(stderr,
5335 "sys_read failed: %s\n",
5336 strerror(errno));
5337 exit(5);
5338 }
5339 exit(0);
5340 }
5341
5342 close(pipe_up[1]);
5343 close(pipe_down[0]);
5344
5345 ret = sys_read(pipe_up[0], &c, sizeof(c));
5346 if (ret != 1) {
5347 d_fprintf(stderr,
5348 "sys_read failed: %s\n",
5349 strerror(errno));
5350 return false;
5351 }
5352 if (c != 0) {
5353 d_fprintf(stderr, "got error code %"PRIu8"\n", c);
5354 return false;
5355 }
5356
5357 ok = torture_open_connection(&cli, 0);
5358 if (!ok) {
5359 d_fprintf(stderr, "torture_open_connection failed\n");
5360 return false;
5361 }
5362
5363 ev = samba_tevent_context_init(talloc_tos());
5364 if (ev == NULL) {
5365 d_fprintf(stderr, "samba_tevent_context_init failed\n");
5366 return false;
5367 }
5368
5369 req = oplock5_send(ev, ev, cli, fname, pipe_down[1]);
5370 if (req == NULL) {
5371 d_fprintf(stderr, "oplock5_send failed\n");
5372 return false;
5373 }
5374
5375 ok = tevent_req_poll_ntstatus(req, ev, &status);
5376 if (!ok) {
5377 d_fprintf(stderr,
5378 "tevent_req_poll_ntstatus failed: %s\n",
5379 nt_errstr(status));
5380 return false;
5381 }
5382
5383 status = oplock5_recv(req);
5384 TALLOC_FREE(req);
5385 if (!NT_STATUS_IS_OK(status)) {
5386 d_fprintf(stderr,
5387 "oplock5 failed: %s\n",
5388 nt_errstr(status));
5389 return false;
5390 }
5391
5392 return true;
5393 }
5394
5395 #endif /* HAVE_KERNEL_OPLOCKS_LINUX */
5396
5397 /*
5398 Test delete on close semantics.
5399 */
5400 static bool run_deletetest(int dummy)
5401 {
5402 struct cli_state *cli1 = NULL;
5403 struct cli_state *cli2 = NULL;
5404 const char *fname = "\\delete.file";
5405 uint16_t fnum1 = (uint16_t)-1;
5406 uint16_t fnum2 = (uint16_t)-1;
5407 bool correct = false;
5408 NTSTATUS status;
5409
5410 printf("starting delete test\n");
5411
5412 if (!torture_open_connection(&cli1, 0)) {
5413 return False;
5414 }
5415
5416 smbXcli_conn_set_sockopt(cli1->conn, sockops);
5417
5418 /* Test 1 - this should delete the file on close. */
5419
5420 cli_setatr(cli1, fname, 0, 0);
5421 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5422
5423 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
5424 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
5425 FILE_DELETE_ON_CLOSE, 0, &fnum1, NULL);
5426 if (!NT_STATUS_IS_OK(status)) {
5427 printf("[1] open of %s failed (%s)\n", fname, nt_errstr(status));
5428 goto fail;
5429 }
5430
5431 status = cli_close(cli1, fnum1);
5432 if (!NT_STATUS_IS_OK(status)) {
5433 printf("[1] close failed (%s)\n", nt_errstr(status));
5434 goto fail;
5435 }
5436
5437 status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
5438 if (NT_STATUS_IS_OK(status)) {
5439 printf("[1] open of %s succeeded (should fail)\n", fname);
5440 goto fail;
5441 }
5442
5443 printf("first delete on close test succeeded.\n");
5444
5445 /* Test 2 - this should delete the file on close. */
5446
5447 cli_setatr(cli1, fname, 0, 0);
5448 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5449
5450 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
5451 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5452 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5453 if (!NT_STATUS_IS_OK(status)) {
5454 printf("[2] open of %s failed (%s)\n", fname, nt_errstr(status));
5455 goto fail;
5456 }
5457
5458 status = cli_nt_delete_on_close(cli1, fnum1, true);
5459 if (!NT_STATUS_IS_OK(status)) {
5460 printf("[2] setting delete_on_close failed (%s)\n", nt_errstr(status));
5461 goto fail;
5462 }
5463
5464 status = cli_close(cli1, fnum1);
5465 if (!NT_STATUS_IS_OK(status)) {
5466 printf("[2] close failed (%s)\n", nt_errstr(status));
5467 goto fail;
5468 }
5469
5470 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
5471 if (NT_STATUS_IS_OK(status)) {
5472 printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
5473 status = cli_close(cli1, fnum1);
5474 if (!NT_STATUS_IS_OK(status)) {
5475 printf("[2] close failed (%s)\n", nt_errstr(status));
5476 }
5477 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5478 goto fail;
5479 }
5480
5481 printf("second delete on close test succeeded.\n");
5482
5483 /* Test 3 - ... */
5484 cli_setatr(cli1, fname, 0, 0);
5485 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5486
5487 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
5488 FILE_ATTRIBUTE_NORMAL,
5489 FILE_SHARE_READ|FILE_SHARE_WRITE,
5490 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5491 if (!NT_STATUS_IS_OK(status)) {
5492 printf("[3] open - 1 of %s failed (%s)\n", fname, nt_errstr(status));
5493 goto fail;
5494 }
5495
5496 /* This should fail with a sharing violation - open for delete is only compatible
5497 with SHARE_DELETE. */
5498
5499 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
5500 FILE_ATTRIBUTE_NORMAL,
5501 FILE_SHARE_READ|FILE_SHARE_WRITE,
5502 FILE_OPEN, 0, 0, &fnum2, NULL);
5503 if (NT_STATUS_IS_OK(status)) {
5504 printf("[3] open - 2 of %s succeeded - should have failed.\n", fname);
5505 goto fail;
5506 }
5507
5508 /* This should succeed. */
5509 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
5510 FILE_ATTRIBUTE_NORMAL,
5511 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5512 FILE_OPEN, 0, 0, &fnum2, NULL);
5513 if (!NT_STATUS_IS_OK(status)) {
5514 printf("[3] open - 3 of %s failed (%s)\n", fname, nt_errstr(status));
5515 goto fail;
5516 }
5517
5518 status = cli_nt_delete_on_close(cli1, fnum1, true);
5519 if (!NT_STATUS_IS_OK(status)) {
5520 printf("[3] setting delete_on_close failed (%s)\n", nt_errstr(status));
5521 goto fail;
5522 }
5523
5524 status = cli_close(cli1, fnum1);
5525 if (!NT_STATUS_IS_OK(status)) {
5526 printf("[3] close 1 failed (%s)\n", nt_errstr(status));
5527 goto fail;
5528 }
5529
5530 status = cli_close(cli1, fnum2);
5531 if (!NT_STATUS_IS_OK(status)) {
5532 printf("[3] close 2 failed (%s)\n", nt_errstr(status));
5533 goto fail;
5534 }
5535
5536 /* This should fail - file should no longer be there. */
5537
5538 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
5539 if (NT_STATUS_IS_OK(status)) {
5540 printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
5541 status = cli_close(cli1, fnum1);
5542 if (!NT_STATUS_IS_OK(status)) {
5543 printf("[3] close failed (%s)\n", nt_errstr(status));
5544 }
5545 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5546 goto fail;
5547 }
5548
5549 printf("third delete on close test succeeded.\n");
5550
5551 /* Test 4 ... */
5552 cli_setatr(cli1, fname, 0, 0);
5553 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5554
5555 status = cli_ntcreate(cli1, fname, 0,
5556 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
5557 FILE_ATTRIBUTE_NORMAL,
5558 FILE_SHARE_READ|FILE_SHARE_WRITE,
5559 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5560 if (!NT_STATUS_IS_OK(status)) {
5561 printf("[4] open of %s failed (%s)\n", fname, nt_errstr(status));
5562 goto fail;
5563 }
5564
5565 /* This should succeed. */
5566 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
5567 FILE_ATTRIBUTE_NORMAL,
5568 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5569 FILE_OPEN, 0, 0, &fnum2, NULL);
5570 if (!NT_STATUS_IS_OK(status)) {
5571 printf("[4] open - 2 of %s failed (%s)\n", fname, nt_errstr(status));
5572 goto fail;
5573 }
5574
5575 status = cli_close(cli1, fnum2);
5576 if (!NT_STATUS_IS_OK(status)) {
5577 printf("[4] close - 1 failed (%s)\n", nt_errstr(status));
5578 goto fail;
5579 }
5580
5581 status = cli_nt_delete_on_close(cli1, fnum1, true);
5582 if (!NT_STATUS_IS_OK(status)) {
5583 printf("[4] setting delete_on_close failed (%s)\n", nt_errstr(status));
5584 goto fail;
5585 }
5586
5587 /* This should fail - no more opens once delete on close set. */
5588 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
5589 FILE_ATTRIBUTE_NORMAL,
5590 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5591 FILE_OPEN, 0, 0, &fnum2, NULL);
5592 if (NT_STATUS_IS_OK(status)) {
5593 printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname );
5594 goto fail;
5595 }
5596
5597 status = cli_close(cli1, fnum1);
5598 if (!NT_STATUS_IS_OK(status)) {
5599 printf("[4] close - 2 failed (%s)\n", nt_errstr(status));
5600 goto fail;
5601 }
5602
5603 printf("fourth delete on close test succeeded.\n");
5604
5605 /* Test 5 ... */
5606 cli_setatr(cli1, fname, 0, 0);
5607 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5608
5609 status = cli_openx(cli1, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum1);
5610 if (!NT_STATUS_IS_OK(status)) {
5611 printf("[5] open of %s failed (%s)\n", fname, nt_errstr(status));
5612 goto fail;
5613 }
5614
5615 /* This should fail - only allowed on NT opens with DELETE access. */
5616
5617 status = cli_nt_delete_on_close(cli1, fnum1, true);
5618 if (NT_STATUS_IS_OK(status)) {
5619 printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
5620 goto fail;
5621 }
5622
5623 status = cli_close(cli1, fnum1);
5624 if (!NT_STATUS_IS_OK(status)) {
5625 printf("[5] close failed (%s)\n", nt_errstr(status));
5626 goto fail;
5627 }
5628
5629 printf("fifth delete on close test succeeded.\n");
5630
5631 /* Test 6 ... */
5632 cli_setatr(cli1, fname, 0, 0);
5633 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5634
5635 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
5636 FILE_ATTRIBUTE_NORMAL,
5637 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5638 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5639 if (!NT_STATUS_IS_OK(status)) {
5640 printf("[6] open of %s failed (%s)\n", fname,
5641 nt_errstr(status));
5642 goto fail;
5643 }
5644
5645 /* This should fail - only allowed on NT opens with DELETE access. */
5646
5647 status = cli_nt_delete_on_close(cli1, fnum1, true);
5648 if (NT_STATUS_IS_OK(status)) {
5649 printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
5650 goto fail;
5651 }
5652
5653 status = cli_close(cli1, fnum1);
5654 if (!NT_STATUS_IS_OK(status)) {
5655 printf("[6] close failed (%s)\n", nt_errstr(status));
5656 goto fail;
5657 }
5658
5659 printf("sixth delete on close test succeeded.\n");
5660
5661 /* Test 7 ... */
5662 cli_setatr(cli1, fname, 0, 0);
5663 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5664
5665 status = cli_ntcreate(cli1, fname, 0,
5666 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
5667 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
5668 0, 0, &fnum1, NULL);
5669 if (!NT_STATUS_IS_OK(status)) {
5670 printf("[7] open of %s failed (%s)\n", fname, nt_errstr(status));
5671 goto fail;
5672 }
5673
5674 status = cli_nt_delete_on_close(cli1, fnum1, true);
5675 if (!NT_STATUS_IS_OK(status)) {
5676 printf("[7] setting delete_on_close on file failed !\n");
5677 goto fail;
5678 }
5679
5680 status = cli_nt_delete_on_close(cli1, fnum1, false);
5681 if (!NT_STATUS_IS_OK(status)) {
5682 printf("[7] unsetting delete_on_close on file failed !\n");
5683 goto fail;
5684 }
5685
5686 status = cli_close(cli1, fnum1);
5687 if (!NT_STATUS_IS_OK(status)) {
5688 printf("[7] close - 1 failed (%s)\n", nt_errstr(status));
5689 goto fail;
5690 }
5691
5692 /* This next open should succeed - we reset the flag. */
5693 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
5694 if (!NT_STATUS_IS_OK(status)) {
5695 printf("[7] open of %s failed (%s)\n", fname, nt_errstr(status));
5696 goto fail;
5697 }
5698
5699 status = cli_close(cli1, fnum1);
5700 if (!NT_STATUS_IS_OK(status)) {
5701 printf("[7] close - 2 failed (%s)\n", nt_errstr(status));
5702 goto fail;
5703 }
5704
5705 printf("seventh delete on close test succeeded.\n");
5706
5707 /* Test 8 ... */
5708 cli_setatr(cli1, fname, 0, 0);
5709 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5710
5711 if (!torture_open_connection(&cli2, 1)) {
5712 printf("[8] failed to open second connection.\n");
5713 goto fail;
5714 }
5715
5716 smbXcli_conn_set_sockopt(cli1->conn, sockops);
5717
5718 status = cli_ntcreate(cli1, fname, 0,
5719 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
5720 FILE_ATTRIBUTE_NORMAL,
5721 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5722 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5723 if (!NT_STATUS_IS_OK(status)) {
5724 printf("[8] open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5725 goto fail;
5726 }
5727
5728 status = cli_ntcreate(cli2, fname, 0,
5729 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
5730 FILE_ATTRIBUTE_NORMAL,
5731 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5732 FILE_OPEN, 0, 0, &fnum2, NULL);
5733 if (!NT_STATUS_IS_OK(status)) {
5734 printf("[8] open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5735 goto fail;
5736 }
5737
5738 status = cli_nt_delete_on_close(cli1, fnum1, true);
5739 if (!NT_STATUS_IS_OK(status)) {
5740 printf("[8] setting delete_on_close on file failed !\n");
5741 goto fail;
5742 }
5743
5744 status = cli_close(cli1, fnum1);
5745 if (!NT_STATUS_IS_OK(status)) {
5746 printf("[8] close - 1 failed (%s)\n", nt_errstr(status));
5747 goto fail;
5748 }
5749
5750 status = cli_close(cli2, fnum2);
5751 if (!NT_STATUS_IS_OK(status)) {
5752 printf("[8] close - 2 failed (%s)\n", nt_errstr(status));
5753 goto fail;
5754 }
5755
5756 /* This should fail.. */
5757 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
5758 if (NT_STATUS_IS_OK(status)) {
5759 printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
5760 goto fail;
5761 }
5762
5763 printf("eighth delete on close test succeeded.\n");
5764
5765 /* Test 9 ... */
5766
5767 /* This should fail - we need to set DELETE_ACCESS. */
5768 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
5769 FILE_ATTRIBUTE_NORMAL,
5770 FILE_SHARE_NONE,
5771 FILE_OVERWRITE_IF,
5772 FILE_DELETE_ON_CLOSE, 0, &fnum1, NULL);
5773 if (NT_STATUS_IS_OK(status)) {
5774 printf("[9] open of %s succeeded should have failed!\n", fname);
5775 goto fail;
5776 }
5777
5778 printf("ninth delete on close test succeeded.\n");
5779
5780 /* Test 10 ... */
5781
5782 status = cli_ntcreate(cli1, fname, 0,
5783 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
5784 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5785 FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE,
5786 0, &fnum1, NULL);
5787 if (!NT_STATUS_IS_OK(status)) {
5788 printf("[10] open of %s failed (%s)\n", fname, nt_errstr(status));
5789 goto fail;
5790 }
5791
5792 /* This should delete the file. */
5793 status = cli_close(cli1, fnum1);
5794 if (!NT_STATUS_IS_OK(status)) {
5795 printf("[10] close failed (%s)\n", nt_errstr(status));
5796 goto fail;
5797 }
5798
5799 /* This should fail.. */
5800 status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
5801 if (NT_STATUS_IS_OK(status)) {
5802 printf("[10] open of %s succeeded should have been deleted on close !\n", fname);
5803 goto fail;
5804 }
5805
5806 printf("tenth delete on close test succeeded.\n");
5807
5808 /* Test 11 ... */
5809
5810 cli_setatr(cli1, fname, 0, 0);
5811 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5812
5813 /* Can we open a read-only file with delete access? */
5814
5815 /* Create a readonly file. */
5816 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
5817 FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE,
5818 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
5819 if (!NT_STATUS_IS_OK(status)) {
5820 printf("[11] open of %s failed (%s)\n", fname, nt_errstr(status));
5821 goto fail;
5822 }
5823
5824 status = cli_close(cli1, fnum1);
5825 if (!NT_STATUS_IS_OK(status)) {
5826 printf("[11] close failed (%s)\n", nt_errstr(status));
5827 goto fail;
5828 }
5829
5830 /* Now try open for delete access. */
5831 status = cli_ntcreate(cli1, fname, 0,
5832 FILE_READ_ATTRIBUTES|DELETE_ACCESS,
5833 0,
5834 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5835 FILE_OPEN, 0, 0, &fnum1, NULL);
5836 if (!NT_STATUS_IS_OK(status)) {
5837 printf("[11] open of %s failed: %s\n", fname, nt_errstr(status));
5838 goto fail;
5839 }
5840
5841 cli_close(cli1, fnum1);
5842
5843 printf("eleventh delete on close test succeeded.\n");
5844
5845 /*
5846 * Test 12
5847 * like test 4 but with initial delete on close
5848 */
5849
5850 cli_setatr(cli1, fname, 0, 0);
5851 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5852
5853 status = cli_ntcreate(cli1, fname, 0,
5854 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
5855 FILE_ATTRIBUTE_NORMAL,
5856 FILE_SHARE_READ|FILE_SHARE_WRITE,
5857 FILE_OVERWRITE_IF,
5858 FILE_DELETE_ON_CLOSE, 0, &fnum1, NULL);
5859 if (!NT_STATUS_IS_OK(status)) {
5860 printf("[12] open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5861 goto fail;
5862 }
5863
5864 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
5865 FILE_ATTRIBUTE_NORMAL,
5866 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5867 FILE_OPEN, 0, 0, &fnum2, NULL);
5868 if (!NT_STATUS_IS_OK(status)) {
5869 printf("[12] open 2 of %s failed(%s).\n", fname, nt_errstr(status));
5870 goto fail;
5871 }
5872
5873 status = cli_close(cli1, fnum2);
5874 if (!NT_STATUS_IS_OK(status)) {
5875 printf("[12] close 1 failed (%s)\n", nt_errstr(status));
5876 goto fail;
5877 }
5878
5879 status = cli_nt_delete_on_close(cli1, fnum1, true);
5880 if (!NT_STATUS_IS_OK(status)) {
5881 printf("[12] setting delete_on_close failed (%s)\n", nt_errstr(status));
5882 goto fail;
5883 }
5884
5885 /* This should fail - no more opens once delete on close set. */
5886 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
5887 FILE_ATTRIBUTE_NORMAL,
5888 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5889 FILE_OPEN, 0, 0, &fnum2, NULL);
5890 if (NT_STATUS_IS_OK(status)) {
5891 printf("[12] open 3 of %s succeeded - should fail).\n", fname);
5892 goto fail;
5893 }
5894
5895 status = cli_nt_delete_on_close(cli1, fnum1, false);
5896 if (!NT_STATUS_IS_OK(status)) {
5897 printf("[12] unsetting delete_on_close failed (%s)\n", nt_errstr(status));
5898 goto fail;
5899 }
5900
5901 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
5902 FILE_ATTRIBUTE_NORMAL,
5903 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5904 FILE_OPEN, 0, 0, &fnum2, NULL);
5905 if (!NT_STATUS_IS_OK(status)) {
5906 printf("[12] open 4 of %s failed (%s)\n", fname, nt_errstr(status));
5907 goto fail;
5908 }
5909
5910 status = cli_close(cli1, fnum2);
5911 if (!NT_STATUS_IS_OK(status)) {
5912 printf("[12] close 2 failed (%s)\n", nt_errstr(status));
5913 goto fail;
5914 }
5915
5916 status = cli_close(cli1, fnum1);
5917 if (!NT_STATUS_IS_OK(status)) {
5918 printf("[12] close 3 failed (%s)\n", nt_errstr(status));
5919 goto fail;
5920 }
5921
5922 /*
5923 * setting delete on close on the handle does
5924 * not unset the initial delete on close...
5925 */
5926 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
5927 FILE_ATTRIBUTE_NORMAL,
5928 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5929 FILE_OPEN, 0, 0, &fnum2, NULL);
5930 if (NT_STATUS_IS_OK(status)) {
5931 printf("[12] open 5 of %s succeeded - should fail).\n", fname);
5932 goto fail;
5933 } else if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
5934 printf("ntcreate returned %s, expected "
5935 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
5936 nt_errstr(status));
5937 goto fail;
5938 }
5939
5940 printf("twelfth delete on close test succeeded.\n");
5941
5942
5943 printf("finished delete test\n");
5944
5945 correct = true;
5946
5947 fail:
5948 /* FIXME: This will crash if we aborted before cli2 got
5949 * initialized, because these functions don't handle
5950 * uninitialized connections. */
5951
5952 if (fnum1 != (uint16_t)-1) cli_close(cli1, fnum1);
5953 if (fnum2 != (uint16_t)-1) cli_close(cli1, fnum2);
5954 cli_setatr(cli1, fname, 0, 0);
5955 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5956
5957 if (cli1 && !torture_close_connection(cli1)) {
5958 correct = False;
5959 }
5960 if (cli2 && !torture_close_connection(cli2)) {
5961 correct = False;
5962 }
5963 return correct;
5964 }
5965
5966 struct delete_stream_state {
5967 bool closed;
5968 };
5969
5970 static void delete_stream_unlinked(struct tevent_req *subreq);
5971 static void delete_stream_closed(struct tevent_req *subreq);
5972
5973 static struct tevent_req *delete_stream_send(
5974 TALLOC_CTX *mem_ctx,
5975 struct tevent_context *ev,
5976 struct cli_state *cli,
5977 const char *base_fname,
5978 uint16_t stream_fnum)
5979 {
5980 struct tevent_req *req = NULL, *subreq = NULL;
5981 struct delete_stream_state *state = NULL;
5982
5983 req = tevent_req_create(
5984 mem_ctx, &state, struct delete_stream_state);
5985 if (req == NULL) {
5986 return NULL;
5987 }
5988
5989 subreq = cli_unlink_send(
5990 state,
5991 ev,
5992 cli,
5993 base_fname,
5994 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5995 if (tevent_req_nomem(subreq, req)) {
5996 return tevent_req_post(req, ev);
5997 }
5998 tevent_req_set_callback(subreq, delete_stream_unlinked, req);
5999
6000 subreq = cli_close_send(state, ev, cli, stream_fnum, 0);
6001 if (tevent_req_nomem(subreq, req)) {
6002 return tevent_req_post(req, ev);
6003 }
6004 tevent_req_set_callback(subreq, delete_stream_closed, req);
6005
6006 return req;
6007 }
6008
6009 static void delete_stream_unlinked(struct tevent_req *subreq)
6010 {
6011 struct tevent_req *req = tevent_req_callback_data(
6012 subreq, struct tevent_req);
6013 struct delete_stream_state *state = tevent_req_data(
6014 req, struct delete_stream_state);
6015 NTSTATUS status;
6016
6017 status = cli_unlink_recv(subreq);
6018 TALLOC_FREE(subreq);
6019 if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
6020 printf("cli_unlink returned %s\n",
6021 nt_errstr(status));
6022 tevent_req_nterror(req, NT_STATUS_UNSUCCESSFUL);
6023 return;
6024 }
6025 if (!state->closed) {
6026 /* close reply should have come in first */
6027 printf("Not closed\n");
6028 tevent_req_nterror(req, NT_STATUS_UNSUCCESSFUL);
6029 return;
6030 }
6031 tevent_req_done(req);
6032 }
6033
6034 static void delete_stream_closed(struct tevent_req *subreq)
6035 {
6036 struct tevent_req *req = tevent_req_callback_data(
6037 subreq, struct tevent_req);
6038 struct delete_stream_state *state = tevent_req_data(
6039 req, struct delete_stream_state);
6040 NTSTATUS status;
6041
6042 status = cli_close_recv(subreq);
6043 TALLOC_FREE(subreq);
6044 if (tevent_req_nterror(req, status)) {
6045 return;
6046 }
6047 /* also waiting for the unlink to come back */
6048 state->closed = true;
6049 }
6050
6051 static NTSTATUS delete_stream_recv(struct tevent_req *req)
6052 {
6053 return tevent_req_simple_recv_ntstatus(req);
6054 }
6055
6056 static bool run_delete_stream(int dummy)
6057 {
6058 struct tevent_context *ev = NULL;
6059 struct tevent_req *req = NULL;
6060 struct cli_state *cli = NULL;
6061 const char fname[] = "delete_stream";
6062 const char fname_stream[] = "delete_stream:Zone.Identifier:$DATA";
6063 uint16_t fnum1, fnum2;
6064 NTSTATUS status;
6065 bool ok;
6066
6067 printf("Starting stream delete test\n");
6068
6069 ok = torture_open_connection(&cli, 0);
6070 if (!ok) {
6071 return false;
6072 }
6073
6074 cli_setatr(cli, fname, 0, 0);
6075 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6076
6077 /* Create the file. */
6078 status = cli_ntcreate(
6079 cli,
6080 fname,
6081 0,
6082 READ_CONTROL_ACCESS,
6083 0,
6084 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
6085 FILE_CREATE,
6086 0x0,
6087 0x0,
6088 &fnum1,
6089 NULL);
6090 if (!NT_STATUS_IS_OK(status)) {
6091 d_fprintf(stderr,
6092 "cli_ntcreate of %s failed (%s)\n",
6093 fname,
6094 nt_errstr(status));
6095 return false;
6096 }
6097 status = cli_close(cli, fnum1);
6098 if (!NT_STATUS_IS_OK(status)) {
6099 d_fprintf(stderr,
6100 "cli_close of %s failed (%s)\n",
6101 fname,
6102 nt_errstr(status));
6103 return false;
6104 }
6105
6106 /* Now create the stream. */
6107 status = cli_ntcreate(
6108 cli,
6109 fname_stream,
6110 0,
6111 FILE_WRITE_DATA,
6112 0,
6113 FILE_SHARE_READ|FILE_SHARE_WRITE,
6114 FILE_CREATE,
6115 0x0,
6116 0x0,
6117 &fnum1,
6118 NULL);
6119
6120 if (!NT_STATUS_IS_OK(status)) {
6121 d_fprintf(stderr,
6122 "cli_ntcreate of %s failed (%s)\n",
6123 fname_stream,
6124 nt_errstr(status));
6125 return false;
6126 }
6127
6128 /* open it a second time */
6129
6130 status = cli_ntcreate(
6131 cli,
6132 fname_stream,
6133 0,
6134 FILE_WRITE_DATA,
6135 0,
6136 FILE_SHARE_READ|FILE_SHARE_WRITE,
6137 FILE_OPEN,
6138 0x0,
6139 0x0,
6140 &fnum2,
6141 NULL);
6142
6143 if (!NT_STATUS_IS_OK(status)) {
6144 d_fprintf(stderr,
6145 "2nd cli_ntcreate of %s failed (%s)\n",
6146 fname_stream,
6147 nt_errstr(status));
6148 return false;
6149 }
6150
6151 ev = samba_tevent_context_init(talloc_tos());
6152 if (ev == NULL) {
6153 d_fprintf(stderr, "samba_tevent_context_init failed\n");
6154 return false;
6155 }
6156
6157 req = delete_stream_send(ev, ev, cli, fname, fnum1);
6158 if (req == NULL) {
6159 d_fprintf(stderr, "delete_stream_send failed\n");
6160 return false;
6161 }
6162
6163 ok = tevent_req_poll_ntstatus(req, ev, &status);
6164 if (!ok) {
6165 d_fprintf(stderr,
6166 "tevent_req_poll_ntstatus failed: %s\n",
6167 nt_errstr(status));
6168 return false;
6169 }
6170
6171 status = delete_stream_recv(req);
6172 TALLOC_FREE(req);
6173 if (!NT_STATUS_IS_OK(status)) {
6174 d_fprintf(stderr,
6175 "delete_stream failed: %s\n",
6176 nt_errstr(status));
6177 return false;
6178 }
6179
6180 status = cli_close(cli, fnum2);
6181 if (!NT_STATUS_IS_OK(status)) {
6182 d_fprintf(stderr,
6183 "close failed: %s\n",
6184 nt_errstr(status));
6185 return false;
6186 }
6187
6188 status = cli_unlink(
6189 cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6190 if (!NT_STATUS_IS_OK(status)) {
6191 d_fprintf(stderr,
6192 "unlink failed: %s\n",
6193 nt_errstr(status));
6194 return false;
6195 }
6196
6197 return true;
6198 }
6199
6200 /*
6201 Exercise delete on close semantics - use on the PRINT1 share in torture
6202 testing.
6203 */
6204 static bool run_delete_print_test(int dummy)
6205 {
6206 struct cli_state *cli1 = NULL;
6207 const char *fname = "print_delete.file";
6208 uint16_t fnum1 = (uint16_t)-1;
6209 bool correct = false;
6210 const char *buf = "print file data\n";
6211 NTSTATUS status;
6212
6213 printf("starting print delete test\n");
6214
6215 if (!torture_open_connection(&cli1, 0)) {
6216 return false;
6217 }
6218
6219 smbXcli_conn_set_sockopt(cli1->conn, sockops);
6220
6221 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
6222 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
6223 0, 0, &fnum1, NULL);
6224 if (!NT_STATUS_IS_OK(status)) {
6225 printf("open of %s failed (%s)\n",
6226 fname,
6227 nt_errstr(status));
6228 goto fail;
6229 }
6230
6231 status = cli_writeall(cli1,
6232 fnum1,
6233 0,
6234 (const uint8_t *)buf,
6235 0, /* offset */
6236 strlen(buf), /* size */
6237 NULL);
6238 if (!NT_STATUS_IS_OK(status)) {
6239 printf("writing print file data failed (%s)\n",
6240 nt_errstr(status));
6241 goto fail;
6242 }
6243
6244 status = cli_nt_delete_on_close(cli1, fnum1, true);
6245 if (!NT_STATUS_IS_OK(status)) {
6246 printf("setting delete_on_close failed (%s)\n",
6247 nt_errstr(status));
6248 goto fail;
6249 }
6250
6251 status = cli_close(cli1, fnum1);
6252 if (!NT_STATUS_IS_OK(status)) {
6253 printf("close failed (%s)\n", nt_errstr(status));
6254 goto fail;
6255 }
6256
6257 printf("finished print delete test\n");
6258
6259 correct = true;
6260
6261 fail:
6262
6263 if (fnum1 != (uint16_t)-1) {
6264 cli_close(cli1, fnum1);
6265 }
6266
6267 if (cli1 && !torture_close_connection(cli1)) {
6268 correct = false;
6269 }
6270 return correct;
6271 }
6272
6273 static bool run_deletetest_ln(int dummy)
6274 {
6275 struct cli_state *cli;
6276 const char *fname = "\\delete1";
6277 const char *fname_ln = "\\delete1_ln";
6278 uint16_t fnum;
6279 uint16_t fnum1;
6280 NTSTATUS status;
6281 bool correct = true;
6282 time_t t;
6283
6284 printf("starting deletetest-ln\n");
6285
6286 if (!torture_open_connection(&cli, 0)) {
6287 return false;
6288 }
6289
6290 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6291 cli_unlink(cli, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6292
6293 smbXcli_conn_set_sockopt(cli->conn, sockops);
6294
6295 /* Create the file. */
6296 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
6297 if (!NT_STATUS_IS_OK(status)) {
6298 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
6299 return false;
6300 }
6301
6302 status = cli_close(cli, fnum);
6303 if (!NT_STATUS_IS_OK(status)) {
6304 printf("close1 failed (%s)\n", nt_errstr(status));
6305 return false;
6306 }
6307
6308 /* Now create a hardlink. */
6309 status = cli_hardlink(cli, fname, fname_ln);
6310 if (!NT_STATUS_IS_OK(status)) {
6311 printf("nt hardlink failed (%s)\n", nt_errstr(status));
6312 return false;
6313 }
6314
6315 /* Open the original file. */
6316 status = cli_ntcreate(cli, fname, 0, FILE_READ_DATA,
6317 FILE_ATTRIBUTE_NORMAL,
6318 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
6319 FILE_OPEN_IF, 0, 0, &fnum, NULL);
6320 if (!NT_STATUS_IS_OK(status)) {
6321 printf("ntcreate of %s failed (%s)\n", fname, nt_errstr(status));
6322 return false;
6323 }
6324
6325 /* Unlink the hard link path. */
6326 status = cli_ntcreate(cli, fname_ln, 0, DELETE_ACCESS,
6327 FILE_ATTRIBUTE_NORMAL,
6328 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
6329 FILE_OPEN_IF, 0, 0, &fnum1, NULL);
6330 if (!NT_STATUS_IS_OK(status)) {
6331 printf("ntcreate of %s failed (%s)\n", fname_ln, nt_errstr(status));
6332 return false;
6333 }
6334 status = cli_nt_delete_on_close(cli, fnum1, true);
6335 if (!NT_STATUS_IS_OK(status)) {
6336 d_printf("(%s) failed to set delete_on_close %s: %s\n",
6337 __location__, fname_ln, nt_errstr(status));
6338 return false;
6339 }
6340
6341 status = cli_close(cli, fnum1);
6342 if (!NT_STATUS_IS_OK(status)) {
6343 printf("close %s failed (%s)\n",
6344 fname_ln, nt_errstr(status));
6345 return false;
6346 }
6347
6348 status = cli_close(cli, fnum);
6349 if (!NT_STATUS_IS_OK(status)) {
6350 printf("close %s failed (%s)\n",
6351 fname, nt_errstr(status));
6352 return false;
6353 }
6354
6355 /* Ensure the original file is still there. */
6356 status = cli_getatr(cli, fname, NULL, NULL, &t);
6357 if (!NT_STATUS_IS_OK(status)) {
6358 printf("%s getatr on file %s failed (%s)\n",
6359 __location__,
6360 fname,
6361 nt_errstr(status));
6362 correct = False;
6363 }
6364
6365 /* Ensure the link path is gone. */
6366 status = cli_getatr(cli, fname_ln, NULL, NULL, &t);
6367 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
6368 printf("%s, getatr for file %s returned wrong error code %s "
6369 "- should have been deleted\n",
6370 __location__,
6371 fname_ln, nt_errstr(status));
6372 correct = False;
6373 }
6374
6375 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6376 cli_unlink(cli, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6377
6378 if (!torture_close_connection(cli)) {
6379 correct = false;
6380 }
6381
6382 printf("finished deletetest-ln\n");
6383
6384 return correct;
6385 }
6386
6387 /*
6388 print out server properties
6389 */
6390 static bool run_properties(int dummy)
6391 {
6392 struct cli_state *cli;
6393 bool correct = True;
6394
6395 printf("starting properties test\n");
6396
6397 ZERO_STRUCT(cli);
6398
6399 if (!torture_open_connection(&cli, 0)) {
6400 return False;
6401 }
6402
6403 smbXcli_conn_set_sockopt(cli->conn, sockops);
6404
6405 d_printf("Capabilities 0x%08x\n", smb1cli_conn_capabilities(cli->conn));
6406
6407 if (!torture_close_connection(cli)) {
6408 correct = False;
6409 }
6410
6411 return correct;
6412 }
6413
6414
6415
6416 /* FIRST_DESIRED_ACCESS 0xf019f */
6417 #define FIRST_DESIRED_ACCESS FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\
6418 FILE_READ_EA| /* 0xf */ \
6419 FILE_WRITE_EA|FILE_READ_ATTRIBUTES| /* 0x90 */ \
6420 FILE_WRITE_ATTRIBUTES| /* 0x100 */ \
6421 DELETE_ACCESS|READ_CONTROL_ACCESS|\
6422 WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS /* 0xf0000 */
6423 /* SECOND_DESIRED_ACCESS 0xe0080 */
6424 #define SECOND_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
6425 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
6426 WRITE_OWNER_ACCESS /* 0xe0000 */
6427
6428 #if 0
6429 #define THIRD_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \
6430 READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
6431 FILE_READ_DATA|\
6432 WRITE_OWNER_ACCESS /* */
6433 #endif
6434
6435 /*
6436 Test ntcreate calls made by xcopy
6437 */
6438 static bool run_xcopy(int dummy)
6439 {
6440 static struct cli_state *cli1;
6441 const char *fname = "\\test.txt";
6442 bool correct = True;
6443 uint16_t fnum1, fnum2;
6444 NTSTATUS status;
6445
6446 printf("starting xcopy test\n");
6447
6448 if (!torture_open_connection(&cli1, 0)) {
6449 return False;
6450 }
6451
6452 status = cli_ntcreate(cli1, fname, 0, FIRST_DESIRED_ACCESS,
6453 FILE_ATTRIBUTE_ARCHIVE, FILE_SHARE_NONE,
6454 FILE_OVERWRITE_IF, 0x4044, 0, &fnum1, NULL);
6455 if (!NT_STATUS_IS_OK(status)) {
6456 printf("First open failed - %s\n", nt_errstr(status));
6457 return False;
6458 }
6459
6460 status = cli_ntcreate(cli1, fname, 0, SECOND_DESIRED_ACCESS, 0,
6461 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
6462 FILE_OPEN, 0x200000, 0, &fnum2, NULL);
6463 if (!NT_STATUS_IS_OK(status)) {
6464 printf("second open failed - %s\n", nt_errstr(status));
6465 return False;
6466 }
6467
6468 if (!torture_close_connection(cli1)) {
6469 correct = False;
6470 }
6471
6472 return correct;
6473 }
6474
6475 /*
6476 Test rename on files open with share delete and no share delete.
6477 */
6478 static bool run_rename(int dummy)
6479 {
6480 static struct cli_state *cli1;
6481 const char *fname = "\\test.txt";
6482 const char *fname1 = "\\test1.txt";
6483 bool correct = True;
6484 uint16_t fnum1;
6485 uint32_t attr;
6486 NTSTATUS status;
6487
6488 printf("starting rename test\n");
6489
6490 if (!torture_open_connection(&cli1, 0)) {
6491 return False;
6492 }
6493
6494 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6495 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6496
6497 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
6498 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
6499 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
6500 if (!NT_STATUS_IS_OK(status)) {
6501 printf("First open failed - %s\n", nt_errstr(status));
6502 return False;
6503 }
6504
6505 status = cli_rename(cli1, fname, fname1, false);
6506 if (!NT_STATUS_IS_OK(status)) {
6507 printf("First rename failed (SHARE_READ) (this is correct) - %s\n", nt_errstr(status));
6508 } else {
6509 printf("First rename succeeded (SHARE_READ) - this should have failed !\n");
6510 correct = False;
6511 }
6512
6513 status = cli_close(cli1, fnum1);
6514 if (!NT_STATUS_IS_OK(status)) {
6515 printf("close - 1 failed (%s)\n", nt_errstr(status));
6516 return False;
6517 }
6518
6519 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6520 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6521 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
6522 #if 0
6523 FILE_SHARE_DELETE|FILE_SHARE_NONE,
6524 #else
6525 FILE_SHARE_DELETE|FILE_SHARE_READ,
6526 #endif
6527 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
6528 if (!NT_STATUS_IS_OK(status)) {
6529 printf("Second open failed - %s\n", nt_errstr(status));
6530 return False;
6531 }
6532
6533 status = cli_rename(cli1, fname, fname1, false);
6534 if (!NT_STATUS_IS_OK(status)) {
6535 printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", nt_errstr(status));
6536 correct = False;
6537 } else {
6538 printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n");
6539 }
6540
6541 status = cli_close(cli1, fnum1);
6542 if (!NT_STATUS_IS_OK(status)) {
6543 printf("close - 2 failed (%s)\n", nt_errstr(status));
6544 return False;
6545 }
6546
6547 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6548 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6549
6550 status = cli_ntcreate(cli1, fname, 0, READ_CONTROL_ACCESS,
6551 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
6552 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
6553 if (!NT_STATUS_IS_OK(status)) {
6554 printf("Third open failed - %s\n", nt_errstr(status));
6555 return False;
6556 }
6557
6558
6559 status = cli_rename(cli1, fname, fname1, false);
6560 if (!NT_STATUS_IS_OK(status)) {
6561 printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", nt_errstr(status));
6562 correct = False;
6563 } else {
6564 printf("Third rename succeeded (SHARE_NONE)\n");
6565 }
6566
6567 status = cli_close(cli1, fnum1);
6568 if (!NT_STATUS_IS_OK(status)) {
6569 printf("close - 3 failed (%s)\n", nt_errstr(status));
6570 return False;
6571 }
6572
6573 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6574 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6575
6576 /*----*/
6577
6578 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
6579 FILE_ATTRIBUTE_NORMAL,
6580 FILE_SHARE_READ | FILE_SHARE_WRITE,
6581 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
6582 if (!NT_STATUS_IS_OK(status)) {
6583 printf("Fourth open failed - %s\n", nt_errstr(status));
6584 return False;
6585 }
6586
6587 status = cli_rename(cli1, fname, fname1, false);
6588 if (!NT_STATUS_IS_OK(status)) {
6589 printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", nt_errstr(status));
6590 } else {
6591 printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n");
6592 correct = False;
6593 }
6594
6595 status = cli_close(cli1, fnum1);
6596 if (!NT_STATUS_IS_OK(status)) {
6597 printf("close - 4 failed (%s)\n", nt_errstr(status));
6598 return False;
6599 }
6600
6601 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6602 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6603
6604 /*--*/
6605
6606 status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
6607 FILE_ATTRIBUTE_NORMAL,
6608 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
6609 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
6610 if (!NT_STATUS_IS_OK(status)) {
6611 printf("Fifth open failed - %s\n", nt_errstr(status));
6612 return False;
6613 }
6614
6615 status = cli_rename(cli1, fname, fname1, false);
6616 if (!NT_STATUS_IS_OK(status)) {
6617 printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n", nt_errstr(status));
6618 correct = False;
6619 } else {
6620 printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", nt_errstr(status));
6621 }
6622
6623 /*--*/
6624 status = cli_close(cli1, fnum1);
6625 if (!NT_STATUS_IS_OK(status)) {
6626 printf("close - 5 failed (%s)\n", nt_errstr(status));
6627 return False;
6628 }
6629
6630 /* Check that the renamed file has FILE_ATTRIBUTE_ARCHIVE. */
6631 status = cli_getatr(cli1, fname1, &attr, NULL, NULL);
6632 if (!NT_STATUS_IS_OK(status)) {
6633 printf("getatr on file %s failed - %s ! \n",
6634 fname1, nt_errstr(status));
6635 correct = False;
6636 } else {
6637 if (attr != FILE_ATTRIBUTE_ARCHIVE) {
6638 printf("Renamed file %s has wrong attr 0x%x "
6639 "(should be 0x%x)\n",
6640 fname1,
6641 attr,
6642 (unsigned int)FILE_ATTRIBUTE_ARCHIVE);
6643 correct = False;
6644 } else {
6645 printf("Renamed file %s has archive bit set\n", fname1);
6646 }
6647 }
6648
6649 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6650 cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6651
6652 if (!torture_close_connection(cli1)) {
6653 correct = False;
6654 }
6655
6656 return correct;
6657 }
6658
6659 /*
6660 Test rename into a directory with an ACL denying it.
6661 */
6662 static bool run_rename_access(int dummy)
6663 {
6664 static struct cli_state *cli = NULL;
6665 static struct cli_state *posix_cli = NULL;
6666 const char *src = "test.txt";
6667 const char *dname = "dir";
6668 const char *dst = "dir\\test.txt";
6669 const char *dsrc = "test.dir";
6670 const char *ddst = "dir\\test.dir";
6671 uint16_t fnum = (uint16_t)-1;
6672 struct security_descriptor *sd = NULL;
6673 struct security_descriptor *newsd = NULL;
6674 NTSTATUS status;
6675 TALLOC_CTX *frame = NULL;
6676
6677 frame = talloc_stackframe();
6678 printf("starting rename access test\n");
6679
6680 /* Windows connection. */
6681 if (!torture_open_connection(&cli, 0)) {
6682 goto fail;
6683 }
6684
6685 smbXcli_conn_set_sockopt(cli->conn, sockops);
6686
6687 /* Posix connection. */
6688 if (!torture_open_connection(&posix_cli, 0)) {
6689 goto fail;
6690 }
6691
6692 smbXcli_conn_set_sockopt(posix_cli->conn, sockops);
6693
6694 status = torture_setup_unix_extensions(posix_cli);
6695 if (!NT_STATUS_IS_OK(status)) {
6696 goto fail;
6697 }
6698
6699 /* Start with a clean slate. */
6700 cli_unlink(cli, src, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6701 cli_unlink(cli, dst, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6702 cli_rmdir(cli, dsrc);
6703 cli_rmdir(cli, ddst);
6704 cli_rmdir(cli, dname);
6705
6706 /*
6707 * Setup the destination directory with a DENY ACE to
6708 * prevent new files within it.
6709 */
6710 status = cli_ntcreate(cli,
6711 dname,
6712 0,
6713 FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS|
6714 WRITE_DAC_ACCESS|FILE_READ_DATA|
6715 WRITE_OWNER_ACCESS,
6716 FILE_ATTRIBUTE_DIRECTORY,
6717 FILE_SHARE_READ|FILE_SHARE_WRITE,
6718 FILE_CREATE,
6719 FILE_DIRECTORY_FILE,
6720 0,
6721 &fnum,
6722 NULL);
6723 if (!NT_STATUS_IS_OK(status)) {
6724 printf("Create of %s - %s\n", dname, nt_errstr(status));
6725 goto fail;
6726 }
6727
6728 status = cli_query_secdesc(cli,
6729 fnum,
6730 frame,
6731 &sd);
6732 if (!NT_STATUS_IS_OK(status)) {
6733 printf("cli_query_secdesc failed for %s (%s)\n",
6734 dname, nt_errstr(status));
6735 goto fail;
6736 }
6737
6738 newsd = security_descriptor_dacl_create(frame,
6739 0,
6740 NULL,
6741 NULL,
6742 SID_WORLD,
6743 SEC_ACE_TYPE_ACCESS_DENIED,
6744 SEC_DIR_ADD_FILE|SEC_DIR_ADD_SUBDIR,
6745 0,
6746 NULL);
6747 if (newsd == NULL) {
6748 goto fail;
6749 }
6750 sd->dacl = security_acl_concatenate(frame,
6751 newsd->dacl,
6752 sd->dacl);
6753 if (sd->dacl == NULL) {
6754 goto fail;
6755 }
6756 status = cli_set_secdesc(cli, fnum, sd);
6757 if (!NT_STATUS_IS_OK(status)) {
6758 printf("cli_set_secdesc failed for %s (%s)\n",
6759 dname, nt_errstr(status));
6760 goto fail;
6761 }
6762 status = cli_close(cli, fnum);
6763 if (!NT_STATUS_IS_OK(status)) {
6764 printf("close failed for %s (%s)\n",
6765 dname, nt_errstr(status));
6766 goto fail;
6767 }
6768 /* Now go around the back and chmod to 777 via POSIX. */
6769 status = cli_chmod(posix_cli, dname, 0777);
6770 if (!NT_STATUS_IS_OK(status)) {
6771 printf("cli_chmod failed for %s (%s)\n",
6772 dname,
6773 nt_errstr(status));
6774 goto fail;
6775 }
6776
6777 /* Check we can't create a file within dname via Windows. */
6778 status = cli_openx(cli, dst, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
6779 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
6780 cli_close(posix_cli, fnum);
6781 printf("Create of %s should be ACCESS denied, was %s\n",
6782 dst, nt_errstr(status));
6783 goto fail;
6784 }
6785
6786 /* Make the sample file/directory. */
6787 status = cli_openx(cli, src, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
6788 if (!NT_STATUS_IS_OK(status)) {
6789 printf("open of %s failed (%s)\n", src, nt_errstr(status));
6790 goto fail;
6791 }
6792 status = cli_close(cli, fnum);
6793 if (!NT_STATUS_IS_OK(status)) {
6794 printf("cli_close failed (%s)\n", nt_errstr(status));
6795 goto fail;
6796 }
6797
6798 status = cli_mkdir(cli, dsrc);
6799 if (!NT_STATUS_IS_OK(status)) {
6800 printf("cli_mkdir of %s failed (%s)\n",
6801 dsrc, nt_errstr(status));
6802 goto fail;
6803 }
6804
6805 /*
6806 * OK - renames of the new file and directory into the
6807 * dst directory should fail.
6808 */
6809
6810 status = cli_rename(cli, src, dst, false);
6811 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
6812 printf("rename of %s -> %s should be ACCESS denied, was %s\n",
6813 src, dst, nt_errstr(status));
6814 goto fail;
6815 }
6816 status = cli_rename(cli, dsrc, ddst, false);
6817 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
6818 printf("rename of %s -> %s should be ACCESS denied, was %s\n",
6819 src, dst, nt_errstr(status));
6820 goto fail;
6821 }
6822
6823 TALLOC_FREE(frame);
6824 return true;
6825
6826 fail:
6827
6828 if (posix_cli) {
6829 torture_close_connection(posix_cli);
6830 }
6831
6832 if (cli) {
6833 if (fnum != (uint16_t)-1) {
6834 cli_close(cli, fnum);
6835 }
6836 cli_unlink(cli, src,
6837 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6838 cli_unlink(cli, dst,
6839 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6840 cli_rmdir(cli, dsrc);
6841 cli_rmdir(cli, ddst);
6842 cli_rmdir(cli, dname);
6843
6844 torture_close_connection(cli);
6845 }
6846
6847 TALLOC_FREE(frame);
6848 return false;
6849 }
6850
6851 /*
6852 Test owner rights ACE.
6853 */
6854 static bool run_owner_rights(int dummy)
6855 {
6856 static struct cli_state *cli = NULL;
6857 const char *fname = "owner_rights.txt";
6858 uint16_t fnum = (uint16_t)-1;
6859 struct security_descriptor *sd = NULL;
6860 struct security_descriptor *newsd = NULL;
6861 NTSTATUS status;
6862 TALLOC_CTX *frame = NULL;
6863
6864 frame = talloc_stackframe();
6865 printf("starting owner rights test\n");
6866
6867 /* Windows connection. */
6868 if (!torture_open_connection(&cli, 0)) {
6869 goto fail;
6870 }
6871
6872 smbXcli_conn_set_sockopt(cli->conn, sockops);
6873
6874 /* Start with a clean slate. */
6875 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6876
6877 /* Create the test file. */
6878 /* Now try and open for read and write-dac. */
6879 status = cli_ntcreate(cli,
6880 fname,
6881 0,
6882 GENERIC_ALL_ACCESS,
6883 FILE_ATTRIBUTE_NORMAL,
6884 FILE_SHARE_READ|FILE_SHARE_WRITE|
6885 FILE_SHARE_DELETE,
6886 FILE_CREATE,
6887 0,
6888 0,
6889 &fnum,
6890 NULL);
6891 if (!NT_STATUS_IS_OK(status)) {
6892 printf("Create of %s - %s\n", fname, nt_errstr(status));
6893 goto fail;
6894 }
6895
6896 /* Get the original SD. */
6897 status = cli_query_secdesc(cli,
6898 fnum,
6899 frame,
6900 &sd);
6901 if (!NT_STATUS_IS_OK(status)) {
6902 printf("cli_query_secdesc failed for %s (%s)\n",
6903 fname, nt_errstr(status));
6904 goto fail;
6905 }
6906
6907 /*
6908 * Add an "owner-rights" ACE denying WRITE_DATA,
6909 * and an "owner-rights" ACE allowing READ_DATA.
6910 */
6911
6912 newsd = security_descriptor_dacl_create(frame,
6913 0,
6914 NULL,
6915 NULL,
6916 SID_OWNER_RIGHTS,
6917 SEC_ACE_TYPE_ACCESS_DENIED,
6918 FILE_WRITE_DATA,
6919 0,
6920 SID_OWNER_RIGHTS,
6921 SEC_ACE_TYPE_ACCESS_ALLOWED,
6922 FILE_READ_DATA,
6923 0,
6924 NULL);
6925 if (newsd == NULL) {
6926 goto fail;
6927 }
6928 sd->dacl = security_acl_concatenate(frame,
6929 newsd->dacl,
6930 sd->dacl);
6931 if (sd->dacl == NULL) {
6932 goto fail;
6933 }
6934 status = cli_set_secdesc(cli, fnum, sd);
6935 if (!NT_STATUS_IS_OK(status)) {
6936 printf("cli_set_secdesc failed for %s (%s)\n",
6937 fname, nt_errstr(status));
6938 goto fail;
6939 }
6940 status = cli_close(cli, fnum);
6941 if (!NT_STATUS_IS_OK(status)) {
6942 printf("close failed for %s (%s)\n",
6943 fname, nt_errstr(status));
6944 goto fail;
6945 }
6946 fnum = (uint16_t)-1;
6947
6948 /* Try and open for FILE_WRITE_DATA */
6949 status = cli_ntcreate(cli,
6950 fname,
6951 0,
6952 FILE_WRITE_DATA,
6953 FILE_ATTRIBUTE_NORMAL,
6954 FILE_SHARE_READ|FILE_SHARE_WRITE|
6955 FILE_SHARE_DELETE,
6956 FILE_OPEN,
6957 0,
6958 0,
6959 &fnum,
6960 NULL);
6961 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
6962 printf("Open of %s - %s\n", fname, nt_errstr(status));
6963 goto fail;
6964 }
6965
6966 /* Now try and open for FILE_READ_DATA */
6967 status = cli_ntcreate(cli,
6968 fname,
6969 0,
6970 FILE_READ_DATA,
6971 FILE_ATTRIBUTE_NORMAL,
6972 FILE_SHARE_READ|FILE_SHARE_WRITE|
6973 FILE_SHARE_DELETE,
6974 FILE_OPEN,
6975 0,
6976 0,
6977 &fnum,
6978 NULL);
6979 if (!NT_STATUS_IS_OK(status)) {
6980 printf("Open of %s - %s\n", fname, nt_errstr(status));
6981 goto fail;
6982 }
6983
6984 status = cli_close(cli, fnum);
6985 if (!NT_STATUS_IS_OK(status)) {
6986 printf("close failed for %s (%s)\n",
6987 fname, nt_errstr(status));
6988 goto fail;
6989 }
6990
6991 /* Restore clean slate. */
6992 TALLOC_FREE(sd);
6993 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6994
6995 /* Create the test file. */
6996 status = cli_ntcreate(cli,
6997 fname,
6998 0,
6999 GENERIC_ALL_ACCESS,
7000 FILE_ATTRIBUTE_NORMAL,
7001 FILE_SHARE_READ|FILE_SHARE_WRITE|
7002 FILE_SHARE_DELETE,
7003 FILE_CREATE,
7004 0,
7005 0,
7006 &fnum,
7007 NULL);
7008 if (!NT_STATUS_IS_OK(status)) {
7009 printf("Create of %s - %s\n", fname, nt_errstr(status));
7010 goto fail;
7011 }
7012
7013 /* Get the original SD. */
7014 status = cli_query_secdesc(cli,
7015 fnum,
7016 frame,
7017 &sd);
7018 if (!NT_STATUS_IS_OK(status)) {
7019 printf("cli_query_secdesc failed for %s (%s)\n",
7020 fname, nt_errstr(status));
7021 goto fail;
7022 }
7023
7024 /*
7025 * Add an "owner-rights ACE denying WRITE_DATA,
7026 * and an "owner-rights ACE allowing READ_DATA|WRITE_DATA.
7027 */
7028
7029 newsd = security_descriptor_dacl_create(frame,
7030 0,
7031 NULL,
7032 NULL,
7033 SID_OWNER_RIGHTS,
7034 SEC_ACE_TYPE_ACCESS_DENIED,
7035 FILE_WRITE_DATA,
7036 0,
7037 SID_OWNER_RIGHTS,
7038 SEC_ACE_TYPE_ACCESS_ALLOWED,
7039 FILE_READ_DATA|FILE_WRITE_DATA,
7040 0,
7041 NULL);
7042 if (newsd == NULL) {
7043 goto fail;
7044 }
7045 sd->dacl = security_acl_concatenate(frame,
7046 newsd->dacl,
7047 sd->dacl);
7048 if (sd->dacl == NULL) {
7049 goto fail;
7050 }
7051 status = cli_set_secdesc(cli, fnum, sd);
7052 if (!NT_STATUS_IS_OK(status)) {
7053 printf("cli_set_secdesc failed for %s (%s)\n",
7054 fname, nt_errstr(status));
7055 goto fail;
7056 }
7057 status = cli_close(cli, fnum);
7058 if (!NT_STATUS_IS_OK(status)) {
7059 printf("close failed for %s (%s)\n",
7060 fname, nt_errstr(status));
7061 goto fail;
7062 }
7063 fnum = (uint16_t)-1;
7064
7065 /* Try and open for FILE_WRITE_DATA */
7066 status = cli_ntcreate(cli,
7067 fname,
7068 0,
7069 FILE_WRITE_DATA,
7070 FILE_ATTRIBUTE_NORMAL,
7071 FILE_SHARE_READ|FILE_SHARE_WRITE|
7072 FILE_SHARE_DELETE,
7073 FILE_OPEN,
7074 0,
7075 0,
7076 &fnum,
7077 NULL);
7078 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
7079 printf("Open of %s - %s\n", fname, nt_errstr(status));
7080 goto fail;
7081 }
7082
7083 /* Now try and open for FILE_READ_DATA */
7084 status = cli_ntcreate(cli,
7085 fname,
7086 0,
7087 FILE_READ_DATA,
7088 FILE_ATTRIBUTE_NORMAL,
7089 FILE_SHARE_READ|FILE_SHARE_WRITE|
7090 FILE_SHARE_DELETE,
7091 FILE_OPEN,
7092 0,
7093 0,
7094 &fnum,
7095 NULL);
7096 if (!NT_STATUS_IS_OK(status)) {
7097 printf("Open of %s - %s\n", fname, nt_errstr(status));
7098 goto fail;
7099 }
7100
7101 status = cli_close(cli, fnum);
7102 if (!NT_STATUS_IS_OK(status)) {
7103 printf("close failed for %s (%s)\n",
7104 fname, nt_errstr(status));
7105 goto fail;
7106 }
7107
7108 /* Restore clean slate. */
7109 TALLOC_FREE(sd);
7110 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7111
7112
7113 /* Create the test file. */
7114 status = cli_ntcreate(cli,
7115 fname,
7116 0,
7117 GENERIC_ALL_ACCESS,
7118 FILE_ATTRIBUTE_NORMAL,
7119 FILE_SHARE_READ|FILE_SHARE_WRITE|
7120 FILE_SHARE_DELETE,
7121 FILE_CREATE,
7122 0,
7123 0,
7124 &fnum,
7125 NULL);
7126 if (!NT_STATUS_IS_OK(status)) {
7127 printf("Create of %s - %s\n", fname, nt_errstr(status));
7128 goto fail;
7129 }
7130
7131 /* Get the original SD. */
7132 status = cli_query_secdesc(cli,
7133 fnum,
7134 frame,
7135 &sd);
7136 if (!NT_STATUS_IS_OK(status)) {
7137 printf("cli_query_secdesc failed for %s (%s)\n",
7138 fname, nt_errstr(status));
7139 goto fail;
7140 }
7141
7142 /*
7143 * Add an "authenticated users" ACE allowing READ_DATA,
7144 * add an "owner-rights" denying READ_DATA,
7145 * and an "authenticated users" ACE allowing WRITE_DATA.
7146 */
7147
7148 newsd = security_descriptor_dacl_create(frame,
7149 0,
7150 NULL,
7151 NULL,
7152 SID_NT_AUTHENTICATED_USERS,
7153 SEC_ACE_TYPE_ACCESS_ALLOWED,
7154 FILE_READ_DATA,
7155 0,
7156 SID_OWNER_RIGHTS,
7157 SEC_ACE_TYPE_ACCESS_DENIED,
7158 FILE_READ_DATA,
7159 0,
7160 SID_NT_AUTHENTICATED_USERS,
7161 SEC_ACE_TYPE_ACCESS_ALLOWED,
7162 FILE_WRITE_DATA,
7163 0,
7164 NULL);
7165 if (newsd == NULL) {
7166 printf("newsd == NULL\n");
7167 goto fail;
7168 }
7169 sd->dacl = security_acl_concatenate(frame,
7170 newsd->dacl,
7171 sd->dacl);
7172 if (sd->dacl == NULL) {
7173 printf("sd->dacl == NULL\n");
7174 goto fail;
7175 }
7176 status = cli_set_secdesc(cli, fnum, sd);
7177 if (!NT_STATUS_IS_OK(status)) {
7178 printf("cli_set_secdesc failed for %s (%s)\n",
7179 fname, nt_errstr(status));
7180 goto fail;
7181 }
7182 status = cli_close(cli, fnum);
7183 if (!NT_STATUS_IS_OK(status)) {
7184 printf("close failed for %s (%s)\n",
7185 fname, nt_errstr(status));
7186 goto fail;
7187 }
7188 fnum = (uint16_t)-1;
7189
7190 /* Now try and open for FILE_READ_DATA|FILE_WRITE_DATA */
7191 status = cli_ntcreate(cli,
7192 fname,
7193 0,
7194 FILE_READ_DATA|FILE_WRITE_DATA,
7195 FILE_ATTRIBUTE_NORMAL,
7196 FILE_SHARE_READ|FILE_SHARE_WRITE|
7197 FILE_SHARE_DELETE,
7198 FILE_OPEN,
7199 0,
7200 0,
7201 &fnum,
7202 NULL);
7203 if (!NT_STATUS_IS_OK(status)) {
7204 printf("Open of %s - %s\n", fname, nt_errstr(status));
7205 goto fail;
7206 }
7207
7208 status = cli_close(cli, fnum);
7209 if (!NT_STATUS_IS_OK(status)) {
7210 printf("close failed for %s (%s)\n",
7211 fname, nt_errstr(status));
7212 goto fail;
7213 }
7214
7215 cli_unlink(cli, fname,
7216 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7217
7218 TALLOC_FREE(frame);
7219 return true;
7220
7221 fail:
7222
7223 if (cli) {
7224 if (fnum != (uint16_t)-1) {
7225 cli_close(cli, fnum);
7226 }
7227 cli_unlink(cli, fname,
7228 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7229 torture_close_connection(cli);
7230 }
7231
7232 TALLOC_FREE(frame);
7233 return false;
7234 }
7235
7236 /*
7237 * Test SMB1-specific open with SEC_FLAG_SYSTEM_SECURITY.
7238 * Note this test only works with a user with SeSecurityPrivilege set.
7239 *
7240 * NB. This is also tested in samba3.base.createx_access
7241 * but this makes it very explicit what we're looking for.
7242 */
7243 static bool run_smb1_system_security(int dummy)
7244 {
7245 static struct cli_state *cli = NULL;
7246 const char *fname = "system_security.txt";
7247 uint16_t fnum = (uint16_t)-1;
7248 NTSTATUS status;
7249 TALLOC_CTX *frame = NULL;
7250
7251 frame = talloc_stackframe();
7252 printf("starting smb1 system security test\n");
7253
7254 /* SMB1 connection - torture_open_connection() forces this. */
7255 if (!torture_open_connection(&cli, 0)) {
7256 goto fail;
7257 }
7258
7259 smbXcli_conn_set_sockopt(cli->conn, sockops);
7260
7261 /* Start with a clean slate. */
7262 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7263
7264 /* Create the test file. */
7265 status = cli_ntcreate(cli,
7266 fname,
7267 0,
7268 GENERIC_ALL_ACCESS,
7269 FILE_ATTRIBUTE_NORMAL,
7270 FILE_SHARE_READ|FILE_SHARE_WRITE|
7271 FILE_SHARE_DELETE,
7272 FILE_CREATE,
7273 0,
7274 0,
7275 &fnum,
7276 NULL);
7277 if (!NT_STATUS_IS_OK(status)) {
7278 printf("Create of %s - %s\n", fname, nt_errstr(status));
7279 goto fail;
7280 }
7281
7282 status = cli_close(cli, fnum);
7283
7284 /* Open with SEC_FLAG_SYSTEM_SECURITY only. */
7285 /*
7286 * On SMB1 this succeeds - SMB2 it fails,
7287 * see the SMB2-SACL test.
7288 */
7289 status = cli_ntcreate(cli,
7290 fname,
7291 0,
7292 SEC_FLAG_SYSTEM_SECURITY,
7293 FILE_ATTRIBUTE_NORMAL,
7294 FILE_SHARE_READ|FILE_SHARE_WRITE|
7295 FILE_SHARE_DELETE,
7296 FILE_OPEN,
7297 0,
7298 0,
7299 &fnum,
7300 NULL);
7301 if (!NT_STATUS_IS_OK(status)) {
7302 printf("Open of %s - %s\n", fname, nt_errstr(status));
7303 goto fail;
7304 }
7305
7306 status = cli_close(cli, fnum);
7307
7308 cli_unlink(cli, fname,
7309 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7310
7311 torture_close_connection(cli);
7312 TALLOC_FREE(frame);
7313 return true;
7314
7315 fail:
7316
7317 if (cli) {
7318 if (fnum != (uint16_t)-1) {
7319 cli_close(cli, fnum);
7320 }
7321 cli_unlink(cli, fname,
7322 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7323 torture_close_connection(cli);
7324 }
7325
7326 TALLOC_FREE(frame);
7327 return false;
7328 }
7329
7330 static bool run_pipe_number(int dummy)
7331 {
7332 struct cli_state *cli1;
7333 const char *pipe_name = "\\SPOOLSS";
7334 uint16_t fnum;
7335 int num_pipes = 0;
7336 NTSTATUS status;
7337
7338 printf("starting pipenumber test\n");
7339 if (!torture_open_connection(&cli1, 0)) {
7340 return False;
7341 }
7342
7343 smbXcli_conn_set_sockopt(cli1->conn, sockops);
7344 while(1) {
7345 status = cli_ntcreate(cli1, pipe_name, 0, FILE_READ_DATA,
7346 FILE_ATTRIBUTE_NORMAL,
7347 FILE_SHARE_READ|FILE_SHARE_WRITE,
7348 FILE_OPEN_IF, 0, 0, &fnum, NULL);
7349 if (!NT_STATUS_IS_OK(status)) {
7350 printf("Open of pipe %s failed with error (%s)\n", pipe_name, nt_errstr(status));
7351 break;
7352 }
7353 num_pipes++;
7354 printf("\r%6d", num_pipes);
7355 }
7356
7357 printf("pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
7358 torture_close_connection(cli1);
7359 return True;
7360 }
7361
7362 /*
7363 Test open mode returns on read-only files.
7364 */
7365 static bool run_opentest(int dummy)
7366 {
7367 static struct cli_state *cli1;
7368 static struct cli_state *cli2;
7369 const char *fname = "\\readonly.file";
7370 uint16_t fnum1, fnum2;
7371 char buf[20];
7372 off_t fsize;
7373 bool correct = True;
7374 char *tmp_path;
7375 NTSTATUS status;
7376
7377 printf("starting open test\n");
7378
7379 if (!torture_open_connection(&cli1, 0)) {
7380 return False;
7381 }
7382
7383 cli_setatr(cli1, fname, 0, 0);
7384 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7385
7386 smbXcli_conn_set_sockopt(cli1->conn, sockops);
7387
7388 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
7389 if (!NT_STATUS_IS_OK(status)) {
7390 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
7391 return False;
7392 }
7393
7394 status = cli_close(cli1, fnum1);
7395 if (!NT_STATUS_IS_OK(status)) {
7396 printf("close2 failed (%s)\n", nt_errstr(status));
7397 return False;
7398 }
7399
7400 status = cli_setatr(cli1, fname, FILE_ATTRIBUTE_READONLY, 0);
7401 if (!NT_STATUS_IS_OK(status)) {
7402 printf("cli_setatr failed (%s)\n", nt_errstr(status));
7403 return False;
7404 }
7405
7406 status = cli_openx(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1);
7407 if (!NT_STATUS_IS_OK(status)) {
7408 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
7409 return False;
7410 }
7411
7412 /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
7413 status = cli_openx(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
7414
7415 if (check_error(__LINE__, status, ERRDOS, ERRnoaccess,
7416 NT_STATUS_ACCESS_DENIED)) {
7417 printf("correct error code ERRDOS/ERRnoaccess returned\n");
7418 }
7419
7420 printf("finished open test 1\n");
7421
7422 cli_close(cli1, fnum1);
7423
7424 /* Now try not readonly and ensure ERRbadshare is returned. */
7425
7426 cli_setatr(cli1, fname, 0, 0);
7427
7428 status = cli_openx(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1);
7429 if (!NT_STATUS_IS_OK(status)) {
7430 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
7431 return False;
7432 }
7433
7434 /* This will fail - but the error should be ERRshare. */
7435 status = cli_openx(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
7436
7437 if (check_error(__LINE__, status, ERRDOS, ERRbadshare,
7438 NT_STATUS_SHARING_VIOLATION)) {
7439 printf("correct error code ERRDOS/ERRbadshare returned\n");
7440 }
7441
7442 status = cli_close(cli1, fnum1);
7443 if (!NT_STATUS_IS_OK(status)) {
7444 printf("close2 failed (%s)\n", nt_errstr(status));
7445 return False;
7446 }
7447
7448 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7449
7450 printf("finished open test 2\n");
7451
7452 /* Test truncate open disposition on file opened for read. */
7453 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
7454 if (!NT_STATUS_IS_OK(status)) {
7455 printf("(3) open (1) of %s failed (%s)\n", fname, nt_errstr(status));
7456 return False;
7457 }
7458
7459 /* write 20 bytes. */
7460
7461 memset(buf, '\0', 20);
7462
7463 status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, 20, NULL);
7464 if (!NT_STATUS_IS_OK(status)) {
7465 printf("write failed (%s)\n", nt_errstr(status));
7466 correct = False;
7467 }
7468
7469 status = cli_close(cli1, fnum1);
7470 if (!NT_STATUS_IS_OK(status)) {
7471 printf("(3) close1 failed (%s)\n", nt_errstr(status));
7472 return False;
7473 }
7474
7475 /* Ensure size == 20. */
7476 status = cli_getatr(cli1, fname, NULL, &fsize, NULL);
7477 if (!NT_STATUS_IS_OK(status)) {
7478 printf("(3) getatr failed (%s)\n", nt_errstr(status));
7479 return False;
7480 }
7481
7482 if (fsize != 20) {
7483 printf("(3) file size != 20\n");
7484 return False;
7485 }
7486
7487 /* Now test if we can truncate a file opened for readonly. */
7488 status = cli_openx(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE, &fnum1);
7489 if (!NT_STATUS_IS_OK(status)) {
7490 printf("(3) open (2) of %s failed (%s)\n", fname, nt_errstr(status));
7491 return False;
7492 }
7493
7494 status = cli_close(cli1, fnum1);
7495 if (!NT_STATUS_IS_OK(status)) {
7496 printf("close2 failed (%s)\n", nt_errstr(status));
7497 return False;
7498 }
7499
7500 /* Ensure size == 0. */
7501 status = cli_getatr(cli1, fname, NULL, &fsize, NULL);
7502 if (!NT_STATUS_IS_OK(status)) {
7503 printf("(3) getatr failed (%s)\n", nt_errstr(status));
7504 return False;
7505 }
7506
7507 if (fsize != 0) {
7508 printf("(3) file size != 0\n");
7509 return False;
7510 }
7511 printf("finished open test 3\n");
7512
7513 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7514
7515 printf("Do ctemp tests\n");
7516 status = cli_ctemp(cli1, talloc_tos(), "\\", &fnum1, &tmp_path);
7517 if (!NT_STATUS_IS_OK(status)) {
7518 printf("ctemp failed (%s)\n", nt_errstr(status));
7519 return False;
7520 }
7521
7522 printf("ctemp gave path %s\n", tmp_path);
7523 status = cli_close(cli1, fnum1);
7524 if (!NT_STATUS_IS_OK(status)) {
7525 printf("close of temp failed (%s)\n", nt_errstr(status));
7526 }
7527
7528 status = cli_unlink(cli1, tmp_path, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7529 if (!NT_STATUS_IS_OK(status)) {
7530 printf("unlink of temp failed (%s)\n", nt_errstr(status));
7531 }
7532
7533 /* Test the non-io opens... */
7534
7535 if (!torture_open_connection(&cli2, 1)) {
7536 return False;
7537 }
7538
7539 cli_setatr(cli2, fname, 0, 0);
7540 cli_unlink(cli2, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7541
7542 smbXcli_conn_set_sockopt(cli2->conn, sockops);
7543
7544 printf("TEST #1 testing 2 non-io opens (no delete)\n");
7545 status = cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES,
7546 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
7547 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
7548 if (!NT_STATUS_IS_OK(status)) {
7549 printf("TEST #1 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
7550 return False;
7551 }
7552
7553 status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
7554 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
7555 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
7556 if (!NT_STATUS_IS_OK(status)) {
7557 printf("TEST #1 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
7558 return False;
7559 }
7560
7561 status = cli_close(cli1, fnum1);
7562 if (!NT_STATUS_IS_OK(status)) {
7563 printf("TEST #1 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
7564 return False;
7565 }
7566
7567 status = cli_close(cli2, fnum2);
7568 if (!NT_STATUS_IS_OK(status)) {
7569 printf("TEST #1 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
7570 return False;
7571 }
7572
7573 printf("non-io open test #1 passed.\n");
7574
7575 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7576
7577 printf("TEST #2 testing 2 non-io opens (first with delete)\n");
7578
7579 status = cli_ntcreate(cli1, fname, 0,
7580 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
7581 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
7582 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
7583 if (!NT_STATUS_IS_OK(status)) {
7584 printf("TEST #2 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
7585 return False;
7586 }
7587
7588 status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
7589 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
7590 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
7591 if (!NT_STATUS_IS_OK(status)) {
7592 printf("TEST #2 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
7593 return False;
7594 }
7595
7596 status = cli_close(cli1, fnum1);
7597 if (!NT_STATUS_IS_OK(status)) {
7598 printf("TEST #2 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
7599 return False;
7600 }
7601
7602 status = cli_close(cli2, fnum2);
7603 if (!NT_STATUS_IS_OK(status)) {
7604 printf("TEST #2 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
7605 return False;
7606 }
7607
7608 printf("non-io open test #2 passed.\n");
7609
7610 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7611
7612 printf("TEST #3 testing 2 non-io opens (second with delete)\n");
7613
7614 status = cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES,
7615 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
7616 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
7617 if (!NT_STATUS_IS_OK(status)) {
7618 printf("TEST #3 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
7619 return False;
7620 }
7621
7622 status = cli_ntcreate(cli2, fname, 0,
7623 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
7624 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
7625 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
7626 if (!NT_STATUS_IS_OK(status)) {
7627 printf("TEST #3 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
7628 return False;
7629 }
7630
7631 status = cli_close(cli1, fnum1);
7632 if (!NT_STATUS_IS_OK(status)) {
7633 printf("TEST #3 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
7634 return False;
7635 }
7636
7637 status = cli_close(cli2, fnum2);
7638 if (!NT_STATUS_IS_OK(status)) {
7639 printf("TEST #3 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
7640 return False;
7641 }
7642
7643 printf("non-io open test #3 passed.\n");
7644
7645 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7646
7647 printf("TEST #4 testing 2 non-io opens (both with delete)\n");
7648
7649 status = cli_ntcreate(cli1, fname, 0,
7650 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
7651 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
7652 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
7653 if (!NT_STATUS_IS_OK(status)) {
7654 printf("TEST #4 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
7655 return False;
7656 }
7657
7658 status = cli_ntcreate(cli2, fname, 0,
7659 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
7660 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
7661 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
7662 if (NT_STATUS_IS_OK(status)) {
7663 printf("TEST #4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, nt_errstr(status));
7664 return False;
7665 }
7666
7667 printf("TEST #4 open 2 of %s gave %s (correct error should be %s)\n", fname, nt_errstr(status), "sharing violation");
7668
7669 status = cli_close(cli1, fnum1);
7670 if (!NT_STATUS_IS_OK(status)) {
7671 printf("TEST #4 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
7672 return False;
7673 }
7674
7675 printf("non-io open test #4 passed.\n");
7676
7677 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7678
7679 printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
7680
7681 status = cli_ntcreate(cli1, fname, 0,
7682 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
7683 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE,
7684 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
7685 if (!NT_STATUS_IS_OK(status)) {
7686 printf("TEST #5 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
7687 return False;
7688 }
7689
7690 status = cli_ntcreate(cli2, fname, 0,
7691 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
7692 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE,
7693 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
7694 if (!NT_STATUS_IS_OK(status)) {
7695 printf("TEST #5 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
7696 return False;
7697 }
7698
7699 status = cli_close(cli1, fnum1);
7700 if (!NT_STATUS_IS_OK(status)) {
7701 printf("TEST #5 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
7702 return False;
7703 }
7704
7705 status = cli_close(cli2, fnum2);
7706 if (!NT_STATUS_IS_OK(status)) {
7707 printf("TEST #5 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
7708 return False;
7709 }
7710
7711 printf("non-io open test #5 passed.\n");
7712
7713 printf("TEST #6 testing 1 non-io open, one io open\n");
7714
7715 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7716
7717 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA,
7718 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
7719 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
7720 if (!NT_STATUS_IS_OK(status)) {
7721 printf("TEST #6 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
7722 return False;
7723 }
7724
7725 status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
7726 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
7727 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
7728 if (!NT_STATUS_IS_OK(status)) {
7729 printf("TEST #6 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
7730 return False;
7731 }
7732
7733 status = cli_close(cli1, fnum1);
7734 if (!NT_STATUS_IS_OK(status)) {
7735 printf("TEST #6 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
7736 return False;
7737 }
7738
7739 status = cli_close(cli2, fnum2);
7740 if (!NT_STATUS_IS_OK(status)) {
7741 printf("TEST #6 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
7742 return False;
7743 }
7744
7745 printf("non-io open test #6 passed.\n");
7746
7747 printf("TEST #7 testing 1 non-io open, one io open with delete\n");
7748
7749 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7750
7751 status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA,
7752 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
7753 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
7754 if (!NT_STATUS_IS_OK(status)) {
7755 printf("TEST #7 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
7756 return False;
7757 }
7758
7759 status = cli_ntcreate(cli2, fname, 0,
7760 DELETE_ACCESS|FILE_READ_ATTRIBUTES,
7761 FILE_ATTRIBUTE_NORMAL,
7762 FILE_SHARE_READ|FILE_SHARE_DELETE,
7763 FILE_OPEN_IF, 0, 0, &fnum2, NULL);
7764 if (NT_STATUS_IS_OK(status)) {
7765 printf("TEST #7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, nt_errstr(status));
7766 return False;
7767 }
7768
7769 printf("TEST #7 open 2 of %s gave %s (correct error should be %s)\n", fname, nt_errstr(status), "sharing violation");
7770
7771 status = cli_close(cli1, fnum1);
7772 if (!NT_STATUS_IS_OK(status)) {
7773 printf("TEST #7 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
7774 return False;
7775 }
7776
7777 printf("non-io open test #7 passed.\n");
7778
7779 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7780
7781 printf("TEST #8 testing open without WRITE_ATTRIBUTES, updating close write time.\n");
7782 status = cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA, FILE_ATTRIBUTE_NORMAL,
7783 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
7784 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
7785 if (!NT_STATUS_IS_OK(status)) {
7786 printf("TEST #8 open of %s failed (%s)\n", fname, nt_errstr(status));
7787 correct = false;
7788 goto out;
7789 }
7790
7791 /* Write to ensure we have to update the file time. */
7792 status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
7793 NULL);
7794 if (!NT_STATUS_IS_OK(status)) {
7795 printf("TEST #8 cli_write failed: %s\n", nt_errstr(status));
7796 correct = false;
7797 goto out;
7798 }
7799
7800 status = cli_close(cli1, fnum1);
7801 if (!NT_STATUS_IS_OK(status)) {
7802 printf("TEST #8 close of %s failed (%s)\n", fname, nt_errstr(status));
7803 correct = false;
7804 }
7805
7806 out:
7807
7808 if (!torture_close_connection(cli1)) {
7809 correct = False;
7810 }
7811 if (!torture_close_connection(cli2)) {
7812 correct = False;
7813 }
7814
7815 return correct;
7816 }
7817
7818 NTSTATUS torture_setup_unix_extensions(struct cli_state *cli)
7819 {
7820 uint16_t major, minor;
7821 uint32_t caplow, caphigh;
7822 NTSTATUS status;
7823
7824 if (!SERVER_HAS_UNIX_CIFS(cli)) {
7825 printf("Server doesn't support UNIX CIFS extensions.\n");
7826 return NT_STATUS_NOT_SUPPORTED;
7827 }
7828
7829 status = cli_unix_extensions_version(cli, &major, &minor, &caplow,
7830 &caphigh);
7831 if (!NT_STATUS_IS_OK(status)) {
7832 printf("Server didn't return UNIX CIFS extensions: %s\n",
7833 nt_errstr(status));
7834 return status;
7835 }
7836
7837 status = cli_set_unix_extensions_capabilities(cli, major, minor,
7838 caplow, caphigh);
7839 if (!NT_STATUS_IS_OK(status)) {
7840 printf("Server doesn't support setting UNIX CIFS extensions: "
7841 "%s.\n", nt_errstr(status));
7842 return status;
7843 }
7844
7845 return NT_STATUS_OK;
7846 }
7847
7848 /*
7849 Test POSIX open /mkdir calls.
7850 */
7851 static bool run_simple_posix_open_test(int dummy)
7852 {
7853 static struct cli_state *cli1;
7854 const char *fname = "posix:file";
7855 const char *hname = "posix:hlink";
7856 const char *sname = "posix:symlink";
7857 const char *dname = "posix:dir";
7858 char buf[10];
7859 char *target = NULL;
7860 uint16_t fnum1 = (uint16_t)-1;
7861 SMB_STRUCT_STAT sbuf;
7862 bool correct = false;
7863 NTSTATUS status;
7864 size_t nread;
7865 const char *fname_windows = "windows_file";
7866 uint16_t fnum2 = (uint16_t)-1;
7867 bool ok;
7868
7869 printf("Starting simple POSIX open test\n");
7870
7871 if (!torture_open_connection(&cli1, 0)) {
7872 return false;
7873 }
7874
7875 smbXcli_conn_set_sockopt(cli1->conn, sockops);
7876
7877 status = torture_setup_unix_extensions(cli1);
7878 if (!NT_STATUS_IS_OK(status)) {
7879 return false;
7880 }
7881
7882 cli_setatr(cli1, fname, 0, 0);
7883 cli_posix_unlink(cli1, fname);
7884 cli_setatr(cli1, dname, 0, 0);
7885 cli_posix_rmdir(cli1, dname);
7886 cli_setatr(cli1, hname, 0, 0);
7887 cli_posix_unlink(cli1, hname);
7888 cli_setatr(cli1, sname, 0, 0);
7889 cli_posix_unlink(cli1, sname);
7890 cli_setatr(cli1, fname_windows, 0, 0);
7891 cli_posix_unlink(cli1, fname_windows);
7892
7893 /* Create a directory. */
7894 status = cli_posix_mkdir(cli1, dname, 0777);
7895 if (!NT_STATUS_IS_OK(status)) {
7896 printf("POSIX mkdir of %s failed (%s)\n", dname, nt_errstr(status));
7897 goto out;
7898 }
7899
7900 status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL,
7901 0600, &fnum1);
7902 if (!NT_STATUS_IS_OK(status)) {
7903 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
7904 goto out;
7905 }
7906
7907 /* Test ftruncate - set file size. */
7908 status = cli_ftruncate(cli1, fnum1, 1000);
7909 if (!NT_STATUS_IS_OK(status)) {
7910 printf("ftruncate failed (%s)\n", nt_errstr(status));
7911 goto out;
7912 }
7913
7914 /* Ensure st_size == 1000 */
7915 status = cli_posix_stat(cli1, fname, &sbuf);
7916 if (!NT_STATUS_IS_OK(status)) {
7917 printf("stat failed (%s)\n", nt_errstr(status));
7918 goto out;
7919 }
7920
7921 if (sbuf.st_ex_size != 1000) {
7922 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
7923 goto out;
7924 }
7925
7926 /* Ensure st_mode == 0600 */
7927 if ((sbuf.st_ex_mode & 07777) != 0600) {
7928 printf("posix_open - bad permissions 0%o != 0600\n",
7929 (unsigned int)(sbuf.st_ex_mode & 07777));
7930 goto out;
7931 }
7932
7933 /* Test ftruncate - set file size back to zero. */
7934 status = cli_ftruncate(cli1, fnum1, 0);
7935 if (!NT_STATUS_IS_OK(status)) {
7936 printf("ftruncate failed (%s)\n", nt_errstr(status));
7937 goto out;
7938 }
7939
7940 status = cli_close(cli1, fnum1);
7941 if (!NT_STATUS_IS_OK(status)) {
7942 printf("close failed (%s)\n", nt_errstr(status));
7943 goto out;
7944 }
7945
7946 /* Now open the file again for read only. */
7947 status = cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1);
7948 if (!NT_STATUS_IS_OK(status)) {
7949 printf("POSIX open of %s failed (%s)\n", fname, nt_errstr(status));
7950 goto out;
7951 }
7952
7953 /* Now unlink while open. */
7954 status = cli_posix_unlink(cli1, fname);
7955 if (!NT_STATUS_IS_OK(status)) {
7956 printf("POSIX unlink of %s failed (%s)\n", fname, nt_errstr(status));
7957 goto out;
7958 }
7959
7960 status = cli_close(cli1, fnum1);
7961 if (!NT_STATUS_IS_OK(status)) {
7962 printf("close(2) failed (%s)\n", nt_errstr(status));
7963 goto out;
7964 }
7965
7966 /* Ensure the file has gone. */
7967 status = cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1);
7968 if (NT_STATUS_IS_OK(status)) {
7969 printf("POSIX open of %s succeeded, should have been deleted.\n", fname);
7970 goto out;
7971 }
7972
7973 /* Create again to test open with O_TRUNC. */
7974 status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1);
7975 if (!NT_STATUS_IS_OK(status)) {
7976 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
7977 goto out;
7978 }
7979
7980 /* Test ftruncate - set file size. */
7981 status = cli_ftruncate(cli1, fnum1, 1000);
7982 if (!NT_STATUS_IS_OK(status)) {
7983 printf("ftruncate failed (%s)\n", nt_errstr(status));
7984 goto out;
7985 }
7986
7987 /* Ensure st_size == 1000 */
7988 status = cli_posix_stat(cli1, fname, &sbuf);
7989 if (!NT_STATUS_IS_OK(status)) {
7990 printf("stat failed (%s)\n", nt_errstr(status));
7991 goto out;
7992 }
7993
7994 if (sbuf.st_ex_size != 1000) {
7995 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
7996 goto out;
7997 }
7998
7999 status = cli_close(cli1, fnum1);
8000 if (!NT_STATUS_IS_OK(status)) {
8001 printf("close(2) failed (%s)\n", nt_errstr(status));
8002 goto out;
8003 }
8004
8005 /* Re-open with O_TRUNC. */
8006 status = cli_posix_open(cli1, fname, O_WRONLY|O_TRUNC, 0600, &fnum1);
8007 if (!NT_STATUS_IS_OK(status)) {
8008 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
8009 goto out;
8010 }
8011
8012 /* Ensure st_size == 0 */
8013 status = cli_posix_stat(cli1, fname, &sbuf);
8014 if (!NT_STATUS_IS_OK(status)) {
8015 printf("stat failed (%s)\n", nt_errstr(status));
8016 goto out;
8017 }
8018
8019 if (sbuf.st_ex_size != 0) {
8020 printf("O_TRUNC - stat size (%u) != 0\n", (unsigned int)sbuf.st_ex_size);
8021 goto out;
8022 }
8023
8024 status = cli_close(cli1, fnum1);
8025 if (!NT_STATUS_IS_OK(status)) {
8026 printf("close failed (%s)\n", nt_errstr(status));
8027 goto out;
8028 }
8029
8030 status = cli_posix_unlink(cli1, fname);
8031 if (!NT_STATUS_IS_OK(status)) {
8032 printf("POSIX unlink of %s failed (%s)\n", fname, nt_errstr(status));
8033 goto out;
8034 }
8035
8036 status = cli_posix_open(cli1, dname, O_RDONLY, 0, &fnum1);
8037 if (!NT_STATUS_IS_OK(status)) {
8038 printf("POSIX open directory O_RDONLY of %s failed (%s)\n",
8039 dname, nt_errstr(status));
8040 goto out;
8041 }
8042
8043 cli_close(cli1, fnum1);
8044
8045 /* What happens when we try and POSIX open a directory for write ? */
8046 status = cli_posix_open(cli1, dname, O_RDWR, 0, &fnum1);
8047 if (NT_STATUS_IS_OK(status)) {
8048 printf("POSIX open of directory %s succeeded, "
8049 "should have failed.\n",
8050 dname);
8051 goto out;
8052 } else {
8053 if (!check_both_error(__LINE__, status, ERRDOS, EISDIR,
8054 NT_STATUS_FILE_IS_A_DIRECTORY)) {
8055 goto out;
8056 }
8057 }
8058
8059 /* Create the file. */
8060 status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL,
8061 0600, &fnum1);
8062 if (!NT_STATUS_IS_OK(status)) {
8063 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
8064 goto out;
8065 }
8066
8067 /* Write some data into it. */
8068 status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
8069 NULL);
8070 if (!NT_STATUS_IS_OK(status)) {
8071 printf("cli_write failed: %s\n", nt_errstr(status));
8072 goto out;
8073 }
8074
8075 cli_close(cli1, fnum1);
8076
8077 /* Now create a hardlink. */
8078 status = cli_posix_hardlink(cli1, fname, hname);
8079 if (!NT_STATUS_IS_OK(status)) {
8080 printf("POSIX hardlink of %s failed (%s)\n", hname, nt_errstr(status));
8081 goto out;
8082 }
8083
8084 /* Now create a symlink. */
8085 status = cli_posix_symlink(cli1, fname, sname);
8086 if (!NT_STATUS_IS_OK(status)) {
8087 printf("POSIX symlink of %s failed (%s)\n", sname, nt_errstr(status));
8088 goto out;
8089 }
8090
8091 /* Open the hardlink for read. */
8092 status = cli_posix_open(cli1, hname, O_RDONLY, 0, &fnum1);
8093 if (!NT_STATUS_IS_OK(status)) {
8094 printf("POSIX open of %s failed (%s)\n", hname, nt_errstr(status));
8095 goto out;
8096 }
8097
8098 status = cli_read(cli1, fnum1, buf, 0, 10, &nread);
8099 if (!NT_STATUS_IS_OK(status)) {
8100 printf("POSIX read of %s failed (%s)\n", hname,
8101 nt_errstr(status));
8102 goto out;
8103 } else if (nread != 10) {
8104 printf("POSIX read of %s failed. Received %ld, expected %d\n",
8105 hname, (unsigned long)nread, 10);
8106 goto out;
8107 }
8108
8109 if (memcmp(buf, "TEST DATA\n", 10)) {
8110 printf("invalid data read from hardlink\n");
8111 goto out;
8112 }
8113
8114 /* Do a POSIX lock/unlock. */
8115 status = cli_posix_lock(cli1, fnum1, 0, 100, true, READ_LOCK);
8116 if (!NT_STATUS_IS_OK(status)) {
8117 printf("POSIX lock failed %s\n", nt_errstr(status));
8118 goto out;
8119 }
8120
8121 /* Punch a hole in the locked area. */
8122 status = cli_posix_unlock(cli1, fnum1, 10, 80);
8123 if (!NT_STATUS_IS_OK(status)) {
8124 printf("POSIX unlock failed %s\n", nt_errstr(status));
8125 goto out;
8126 }
8127
8128 cli_close(cli1, fnum1);
8129
8130 /* Open the symlink for read - this should fail. A POSIX
8131 client should not be doing opens on a symlink. */
8132 status = cli_posix_open(cli1, sname, O_RDONLY, 0, &fnum1);
8133 if (NT_STATUS_IS_OK(status)) {
8134 printf("POSIX open of %s succeeded (should have failed)\n", sname);
8135 goto out;
8136 }
8137 ok = check_both_error(
8138 __LINE__, status, ERRDOS, ERRbadpath,
8139 NT_STATUS_OBJECT_NAME_NOT_FOUND);
8140 if (!ok) {
8141 printf("POSIX open of %s should have failed "
8142 "with NT_STATUS_OBJECT_NAME_NOT_FOUND, "
8143 "failed with %s instead.\n",
8144 sname, nt_errstr(status));
8145 goto out;
8146 }
8147
8148 status = cli_readlink(cli1, sname, talloc_tos(), &target, NULL, NULL);
8149 if (!NT_STATUS_IS_OK(status)) {
8150 printf("POSIX readlink on %s failed (%s)\n", sname, nt_errstr(status));
8151 goto out;
8152 }
8153
8154 if (strcmp(target, fname) != 0) {
8155 printf("POSIX readlink on %s failed to match name %s (read %s)\n",
8156 sname, fname, target);
8157 goto out;
8158 }
8159
8160 status = cli_posix_rmdir(cli1, dname);
8161 if (!NT_STATUS_IS_OK(status)) {
8162 printf("POSIX rmdir failed (%s)\n", nt_errstr(status));
8163 goto out;
8164 }
8165
8166 /* Check directory opens with a specific permission. */
8167 status = cli_posix_mkdir(cli1, dname, 0700);
8168 if (!NT_STATUS_IS_OK(status)) {
8169 printf("POSIX mkdir of %s failed (%s)\n", dname, nt_errstr(status));
8170 goto out;
8171 }
8172
8173 /* Ensure st_mode == 0700 */
8174 status = cli_posix_stat(cli1, dname, &sbuf);
8175 if (!NT_STATUS_IS_OK(status)) {
8176 printf("stat failed (%s)\n", nt_errstr(status));
8177 goto out;
8178 }
8179
8180 if ((sbuf.st_ex_mode & 07777) != 0700) {
8181 printf("posix_mkdir - bad permissions 0%o != 0700\n",
8182 (unsigned int)(sbuf.st_ex_mode & 07777));
8183 goto out;
8184 }
8185
8186 /*
8187 * Now create a Windows file, and attempt a POSIX unlink.
8188 * This should fail with a sharing violation but due to:
8189 *
8190 * [Bug 9571] Unlink after open causes smbd to panic
8191 *
8192 * ensure we've fixed the lock ordering violation.
8193 */
8194
8195 status = cli_ntcreate(cli1, fname_windows, 0,
8196 FILE_READ_DATA|FILE_WRITE_DATA, 0,
8197 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
8198 FILE_CREATE,
8199 0x0, 0x0, &fnum2, NULL);
8200 if (!NT_STATUS_IS_OK(status)) {
8201 printf("Windows create of %s failed (%s)\n", fname_windows,
8202 nt_errstr(status));
8203 goto out;
8204 }
8205
8206 /* Now try posix_unlink. */
8207 status = cli_posix_unlink(cli1, fname_windows);
8208 if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
8209 printf("POSIX unlink of %s should fail "
8210 "with NT_STATUS_SHARING_VIOLATION "
8211 "got %s instead !\n",
8212 fname_windows,
8213 nt_errstr(status));
8214 goto out;
8215 }
8216
8217 cli_close(cli1, fnum2);
8218
8219 printf("Simple POSIX open test passed\n");
8220 correct = true;
8221
8222 out:
8223
8224 if (fnum1 != (uint16_t)-1) {
8225 cli_close(cli1, fnum1);
8226 fnum1 = (uint16_t)-1;
8227 }
8228
8229 if (fnum2 != (uint16_t)-1) {
8230 cli_close(cli1, fnum2);
8231 fnum2 = (uint16_t)-1;
8232 }
8233
8234 cli_setatr(cli1, sname, 0, 0);
8235 cli_posix_unlink(cli1, sname);
8236 cli_setatr(cli1, hname, 0, 0);
8237 cli_posix_unlink(cli1, hname);
8238 cli_setatr(cli1, fname, 0, 0);
8239 cli_posix_unlink(cli1, fname);
8240 cli_setatr(cli1, dname, 0, 0);
8241 cli_posix_rmdir(cli1, dname);
8242 cli_setatr(cli1, fname_windows, 0, 0);
8243 cli_posix_unlink(cli1, fname_windows);
8244
8245 if (!torture_close_connection(cli1)) {
8246 correct = false;
8247 }
8248
8249 return correct;
8250 }
8251
8252 /*
8253 Test POSIX and Windows ACLs are rejected on symlinks.
8254 */
8255 static bool run_acl_symlink_test(int dummy)
8256 {
8257 static struct cli_state *cli;
8258 const char *fname = "posix_file";
8259 const char *sname = "posix_symlink";
8260 uint16_t fnum = (uint16_t)-1;
8261 bool correct = false;
8262 NTSTATUS status;
8263 char *posix_acl = NULL;
8264 size_t posix_acl_len = 0;
8265 char *posix_acl_sym = NULL;
8266 size_t posix_acl_len_sym = 0;
8267 struct security_descriptor *sd = NULL;
8268 TALLOC_CTX *frame = NULL;
8269
8270 frame = talloc_stackframe();
8271
8272 printf("Starting acl symlink test\n");
8273
8274 if (!torture_open_connection(&cli, 0)) {
8275 TALLOC_FREE(frame);
8276 return false;
8277 }
8278
8279 smbXcli_conn_set_sockopt(cli->conn, sockops);
8280
8281 status = torture_setup_unix_extensions(cli);
8282 if (!NT_STATUS_IS_OK(status)) {
8283 TALLOC_FREE(frame);
8284 return false;
8285 }
8286
8287 cli_setatr(cli, fname, 0, 0);
8288 cli_posix_unlink(cli, fname);
8289 cli_setatr(cli, sname, 0, 0);
8290 cli_posix_unlink(cli, sname);
8291
8292 status = cli_ntcreate(cli,
8293 fname,
8294 0,
8295 READ_CONTROL_ACCESS,
8296 0,
8297 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
8298 FILE_CREATE,
8299 0x0,
8300 0x0,
8301 &fnum,
8302 NULL);
8303
8304 if (!NT_STATUS_IS_OK(status)) {
8305 printf("cli_ntcreate of %s failed (%s)\n",
8306 fname,
8307 nt_errstr(status));
8308 goto out;
8309 }
8310
8311 /* Get the Windows ACL on the file. */
8312 status = cli_query_secdesc(cli,
8313 fnum,
8314 frame,
8315 &sd);
8316 if (!NT_STATUS_IS_OK(status)) {
8317 printf("cli_query_secdesc failed (%s)\n",
8318 nt_errstr(status));
8319 goto out;
8320 }
8321
8322 /* Get the POSIX ACL on the file. */
8323 status = cli_posix_getacl(cli,
8324 fname,
8325 frame,
8326 &posix_acl_len,
8327 &posix_acl);
8328
8329 if (!NT_STATUS_IS_OK(status)) {
8330 printf("cli_posix_getacl failed (%s)\n",
8331 nt_errstr(status));
8332 goto out;
8333 }
8334
8335 status = cli_close(cli, fnum);
8336 if (!NT_STATUS_IS_OK(status)) {
8337 printf("close failed (%s)\n", nt_errstr(status));
8338 goto out;
8339 }
8340 fnum = (uint16_t)-1;
8341
8342 /* Now create a symlink. */
8343 status = cli_posix_symlink(cli, fname, sname);
8344 if (!NT_STATUS_IS_OK(status)) {
8345 printf("cli_posix_symlink of %s -> %s failed (%s)\n",
8346 sname,
8347 fname,
8348 nt_errstr(status));
8349 goto out;
8350 }
8351
8352 /* Open a handle on the symlink for SD set/get should fail. */
8353 status = cli_ntcreate(cli,
8354 sname,
8355 0,
8356 READ_CONTROL_ACCESS|SEC_STD_WRITE_DAC,
8357 0,
8358 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
8359 FILE_OPEN,
8360 0x0,
8361 0x0,
8362 &fnum,
8363 NULL);
8364
8365 if (NT_STATUS_IS_OK(status)) {
8366 printf("Symlink open for getsd/setsd of %s "
8367 "succeeded (should fail)\n",
8368 sname);
8369 goto out;
8370 }
8371
8372 /* Try a stat-open on the symlink, should also fail. */
8373 status = cli_ntcreate(cli,
8374 sname,
8375 0,
8376 FILE_READ_ATTRIBUTES|FILE_WRITE_ATTRIBUTES,
8377 0,
8378 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
8379 FILE_OPEN,
8380 0x0,
8381 0x0,
8382 &fnum,
8383 NULL);
8384
8385 if (NT_STATUS_IS_OK(status)) {
8386 printf("Stat-open of symlink succeeded (should fail)\n");
8387 goto out;
8388 }
8389
8390 /* Get the POSIX ACL on the symlink pathname. Should fail. */
8391 status = cli_posix_getacl(cli,
8392 sname,
8393 frame,
8394 &posix_acl_len_sym,
8395 &posix_acl_sym);
8396
8397 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
8398 printf("cli_posix_getacl on a symlink gave %s. "
8399 "Should be NT_STATUS_ACCESS_DENIED.\n",
8400 nt_errstr(status));
8401 goto out;
8402 }
8403
8404 /* Set the POSIX ACL on the symlink pathname. Should fail. */
8405 status = cli_posix_setacl(cli,
8406 sname,
8407 posix_acl,
8408 posix_acl_len);
8409
8410 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
8411 printf("cli_posix_setacl on a symlink gave %s. "
8412 "Should be NT_STATUS_ACCESS_DENIED.\n",
8413 nt_errstr(status));
8414 goto out;
8415 }
8416
8417 printf("ACL symlink test passed\n");
8418 correct = true;
8419
8420 out:
8421
8422 if (fnum != (uint16_t)-1) {
8423 cli_close(cli, fnum);
8424 fnum = (uint16_t)-1;
8425 }
8426
8427 cli_setatr(cli, sname, 0, 0);
8428 cli_posix_unlink(cli, sname);
8429 cli_setatr(cli, fname, 0, 0);
8430 cli_posix_unlink(cli, fname);
8431
8432 if (!torture_close_connection(cli)) {
8433 correct = false;
8434 }
8435
8436 TALLOC_FREE(frame);
8437 return correct;
8438 }
8439
8440 /*
8441 Test POSIX can delete a file containing streams.
8442 */
8443 static bool run_posix_stream_delete(int dummy)
8444 {
8445 struct cli_state *cli1 = NULL;
8446 struct cli_state *cli2 = NULL;
8447 const char *fname = "streamfile";
8448 const char *stream_fname = "streamfile:Zone.Identifier:$DATA";
8449 uint16_t fnum1 = (uint16_t)-1;
8450 bool correct = false;
8451 NTSTATUS status;
8452 TALLOC_CTX *frame = NULL;
8453
8454 frame = talloc_stackframe();
8455
8456 printf("Starting POSIX stream delete test\n");
8457
8458 if (!torture_open_connection(&cli1, 0) ||
8459 !torture_open_connection(&cli2, 1)) {
8460 TALLOC_FREE(frame);
8461 return false;
8462 }
8463
8464 smbXcli_conn_set_sockopt(cli1->conn, sockops);
8465 smbXcli_conn_set_sockopt(cli2->conn, sockops);
8466
8467 status = torture_setup_unix_extensions(cli2);
8468 if (!NT_STATUS_IS_OK(status)) {
8469 goto out;
8470 }
8471
8472 cli_setatr(cli1, fname, 0, 0);
8473 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
8474
8475 /* Create the file. */
8476 status = cli_ntcreate(cli1,
8477 fname,
8478 0,
8479 READ_CONTROL_ACCESS,
8480 0,
8481 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
8482 FILE_CREATE,
8483 0x0,
8484 0x0,
8485 &fnum1,
8486 NULL);
8487
8488 if (!NT_STATUS_IS_OK(status)) {
8489 printf("cli_ntcreate of %s failed (%s)\n",
8490 fname,
8491 nt_errstr(status));
8492 goto out;
8493 }
8494
8495 status = cli_close(cli1, fnum1);
8496 if (!NT_STATUS_IS_OK(status)) {
8497 printf("cli_close of %s failed (%s)\n",
8498 fname,
8499 nt_errstr(status));
8500 goto out;
8501 }
8502 fnum1 = (uint16_t)-1;
8503
8504 /* Now create the stream. */
8505 status = cli_ntcreate(cli1,
8506 stream_fname,
8507 0,
8508 FILE_WRITE_DATA,
8509 0,
8510 FILE_SHARE_READ|FILE_SHARE_WRITE,
8511 FILE_CREATE,
8512 0x0,
8513 0x0,
8514 &fnum1,
8515 NULL);
8516
8517 if (!NT_STATUS_IS_OK(status)) {
8518 printf("cli_ntcreate of %s failed (%s)\n",
8519 stream_fname,
8520 nt_errstr(status));
8521 goto out;
8522 }
8523
8524 /* Leave the stream handle open... */
8525
8526 /* POSIX unlink should fail. */
8527 status = cli_posix_unlink(cli2, fname);
8528 if (NT_STATUS_IS_OK(status)) {
8529 printf("cli_posix_unlink of %s succeeded, should have failed\n",
8530 fname);
8531 goto out;
8532 }
8533
8534 if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
8535 printf("cli_posix_unlink of %s failed with (%s) "
8536 "should have been NT_STATUS_SHARING_VIOLATION\n",
8537 fname,
8538 nt_errstr(status));
8539 goto out;
8540 }
8541
8542 /* Close the stream handle. */
8543 status = cli_close(cli1, fnum1);
8544 if (!NT_STATUS_IS_OK(status)) {
8545 printf("cli_close of %s failed (%s)\n",
8546 stream_fname,
8547 nt_errstr(status));
8548 goto out;
8549 }
8550 fnum1 = (uint16_t)-1;
8551
8552 /* POSIX unlink after stream handle closed should succeed. */
8553 status = cli_posix_unlink(cli2, fname);
8554 if (!NT_STATUS_IS_OK(status)) {
8555 printf("cli_posix_unlink of %s failed (%s)\n",
8556 fname,
8557 nt_errstr(status));
8558 goto out;
8559 }
8560
8561 printf("POSIX stream delete test passed\n");
8562 correct = true;
8563
8564 out:
8565
8566 if (fnum1 != (uint16_t)-1) {
8567 cli_close(cli1, fnum1);
8568 fnum1 = (uint16_t)-1;
8569 }
8570
8571 cli_setatr(cli1, fname, 0, 0);
8572 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
8573
8574 if (!torture_close_connection(cli1)) {
8575 correct = false;
8576 }
8577 if (!torture_close_connection(cli2)) {
8578 correct = false;
8579 }
8580
8581 TALLOC_FREE(frame);
8582 return correct;
8583 }
8584
8585 /*
8586 Test setting EA's are rejected on symlinks.
8587 */
8588 static bool run_ea_symlink_test(int dummy)
8589 {
8590 static struct cli_state *cli;
8591 const char *fname = "posix_file_ea";
8592 const char *sname = "posix_symlink_ea";
8593 const char *ea_name = "testea_name";
8594 const char *ea_value = "testea_value";
8595 uint16_t fnum = (uint16_t)-1;
8596 bool correct = false;
8597 NTSTATUS status;
8598 size_t i, num_eas;
8599 struct ea_struct *eas = NULL;
8600 TALLOC_CTX *frame = NULL;
8601
8602 frame = talloc_stackframe();
8603
8604 printf("Starting EA symlink test\n");
8605
8606 if (!torture_open_connection(&cli, 0)) {
8607 TALLOC_FREE(frame);
8608 return false;
8609 }
8610
8611 smbXcli_conn_set_sockopt(cli->conn, sockops);
8612
8613 status = torture_setup_unix_extensions(cli);
8614 if (!NT_STATUS_IS_OK(status)) {
8615 TALLOC_FREE(frame);
8616 return false;
8617 }
8618
8619 cli_setatr(cli, fname, 0, 0);
8620 cli_posix_unlink(cli, fname);
8621 cli_setatr(cli, sname, 0, 0);
8622 cli_posix_unlink(cli, sname);
8623
8624 status = cli_ntcreate(cli,
8625 fname,
8626 0,
8627 READ_CONTROL_ACCESS,
8628 0,
8629 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
8630 FILE_CREATE,
8631 0x0,
8632 0x0,
8633 &fnum,
8634 NULL);
8635
8636 if (!NT_STATUS_IS_OK(status)) {
8637 printf("cli_ntcreate of %s failed (%s)\n",
8638 fname,
8639 nt_errstr(status));
8640 goto out;
8641 }
8642
8643 status = cli_close(cli, fnum);
8644 if (!NT_STATUS_IS_OK(status)) {
8645 printf("close failed (%s)\n",
8646 nt_errstr(status));
8647 goto out;
8648 }
8649 fnum = (uint16_t)-1;
8650
8651 /* Set an EA on the path. */
8652 status = cli_set_ea_path(cli,
8653 fname,
8654 ea_name,
8655 ea_value,
8656 strlen(ea_value)+1);
8657
8658 if (!NT_STATUS_IS_OK(status)) {
8659 printf("cli_set_ea_path failed (%s)\n",
8660 nt_errstr(status));
8661 goto out;
8662 }
8663
8664 /* Now create a symlink. */
8665 status = cli_posix_symlink(cli, fname, sname);
8666 if (!NT_STATUS_IS_OK(status)) {
8667 printf("cli_posix_symlink of %s -> %s failed (%s)\n",
8668 sname,
8669 fname,
8670 nt_errstr(status));
8671 goto out;
8672 }
8673
8674 /* Get the EA list on the path. Should return value set. */
8675 status = cli_get_ea_list_path(cli,
8676 fname,
8677 frame,
8678 &num_eas,
8679 &eas);
8680
8681 if (!NT_STATUS_IS_OK(status)) {
8682 printf("cli_get_ea_list_path failed (%s)\n",
8683 nt_errstr(status));
8684 goto out;
8685 }
8686
8687 /* Ensure the EA we set is there. */
8688 for (i=0; i<num_eas; i++) {
8689 if (strcmp(eas[i].name, ea_name) == 0 &&
8690 eas[i].value.length == strlen(ea_value)+1 &&
8691 memcmp(eas[i].value.data,
8692 ea_value,
8693 eas[i].value.length) == 0) {
8694 break;
8695 }
8696 }
8697
8698 if (i == num_eas) {
8699 printf("Didn't find EA on pathname %s\n",
8700 fname);
8701 goto out;
8702 }
8703
8704 num_eas = 0;
8705 TALLOC_FREE(eas);
8706
8707 /* Get the EA list on the symlink. Should return empty list. */
8708 status = cli_get_ea_list_path(cli,
8709 sname,
8710 frame,
8711 &num_eas,
8712 &eas);
8713
8714 if (!NT_STATUS_IS_OK(status)) {
8715 printf("cli_get_ea_list_path failed (%s)\n",
8716 nt_errstr(status));
8717 goto out;
8718 }
8719
8720 if (num_eas != 0) {
8721 printf("cli_get_ea_list_path failed (%s)\n",
8722 nt_errstr(status));
8723 goto out;
8724 }
8725
8726 /* Set an EA on the symlink. Should fail. */
8727 status = cli_set_ea_path(cli,
8728 sname,
8729 ea_name,
8730 ea_value,
8731 strlen(ea_value)+1);
8732
8733 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
8734 printf("cli_set_ea_path on a symlink gave %s. "
8735 "Should be NT_STATUS_ACCESS_DENIED.\n",
8736 nt_errstr(status));
8737 goto out;
8738 }
8739
8740 printf("EA symlink test passed\n");
8741 correct = true;
8742
8743 out:
8744
8745 if (fnum != (uint16_t)-1) {
8746 cli_close(cli, fnum);
8747 fnum = (uint16_t)-1;
8748 }
8749
8750 cli_setatr(cli, sname, 0, 0);
8751 cli_posix_unlink(cli, sname);
8752 cli_setatr(cli, fname, 0, 0);
8753 cli_posix_unlink(cli, fname);
8754
8755 if (!torture_close_connection(cli)) {
8756 correct = false;
8757 }
8758
8759 TALLOC_FREE(frame);
8760 return correct;
8761 }
8762
8763 /*
8764 Test POSIX locks are OFD-locks.
8765 */
8766 static bool run_posix_ofd_lock_test(int dummy)
8767 {
8768 static struct cli_state *cli;
8769 const char *fname = "posix_file";
8770 uint16_t fnum1 = (uint16_t)-1;
8771 uint16_t fnum2 = (uint16_t)-1;
8772 bool correct = false;
8773 NTSTATUS status;
8774 TALLOC_CTX *frame = NULL;
8775
8776 frame = talloc_stackframe();
8777
8778 printf("Starting POSIX ofd-lock test\n");
8779
8780 if (!torture_open_connection(&cli, 0)) {
8781 TALLOC_FREE(frame);
8782 return false;
8783 }
8784
8785 smbXcli_conn_set_sockopt(cli->conn, sockops);
8786
8787 status = torture_setup_unix_extensions(cli);
8788 if (!NT_STATUS_IS_OK(status)) {
8789 TALLOC_FREE(frame);
8790 return false;
8791 }
8792
8793 cli_setatr(cli, fname, 0, 0);
8794 cli_posix_unlink(cli, fname);
8795
8796 /* Open the file twice. */
8797 status = cli_posix_open(cli, fname, O_RDWR|O_CREAT|O_EXCL,
8798 0600, &fnum1);
8799 if (!NT_STATUS_IS_OK(status)) {
8800 printf("First POSIX open of %s failed\n", fname);
8801 goto out;
8802 }
8803
8804 status = cli_posix_open(cli, fname, O_RDWR, 0, &fnum2);
8805 if (!NT_STATUS_IS_OK(status)) {
8806 printf("First POSIX open of %s failed\n", fname);
8807 goto out;
8808 }
8809
8810 /* Set a 0-50 lock on fnum1. */
8811 status = cli_posix_lock(cli, fnum1, 0, 50, false, WRITE_LOCK);
8812 if (!NT_STATUS_IS_OK(status)) {
8813 printf("POSIX lock (1) failed %s\n", nt_errstr(status));
8814 goto out;
8815 }
8816
8817 /* Set a 60-100 lock on fnum2. */
8818 status = cli_posix_lock(cli, fnum2, 60, 100, false, WRITE_LOCK);
8819 if (!NT_STATUS_IS_OK(status)) {
8820 printf("POSIX lock (2) failed %s\n", nt_errstr(status));
8821 goto out;
8822 }
8823
8824 /* close fnum1 - 0-50 lock should go away. */
8825 status = cli_close(cli, fnum1);
8826 if (!NT_STATUS_IS_OK(status)) {
8827 printf("close failed (%s)\n",
8828 nt_errstr(status));
8829 goto out;
8830 }
8831 fnum1 = (uint16_t)-1;
8832
8833 /* Change the lock context. */
8834 cli_setpid(cli, cli_getpid(cli) + 1);
8835
8836 /* Re-open fnum1. */
8837 status = cli_posix_open(cli, fname, O_RDWR, 0, &fnum1);
8838 if (!NT_STATUS_IS_OK(status)) {
8839 printf("Third POSIX open of %s failed\n", fname);
8840 goto out;
8841 }
8842
8843 /* 60-100 lock should still be there. */
8844 status = cli_posix_lock(cli, fnum1, 60, 100, false, WRITE_LOCK);
8845 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
8846 printf("POSIX lock 60-100 not there %s\n", nt_errstr(status));
8847 goto out;
8848 }
8849
8850 /* 0-50 lock should be gone. */
8851 status = cli_posix_lock(cli, fnum1, 0, 50, false, WRITE_LOCK);
8852 if (!NT_STATUS_IS_OK(status)) {
8853 printf("POSIX lock 0-50 failed %s\n", nt_errstr(status));
8854 goto out;
8855 }
8856
8857 printf("POSIX OFD lock test passed\n");
8858 correct = true;
8859
8860 out:
8861
8862 if (fnum1 != (uint16_t)-1) {
8863 cli_close(cli, fnum1);
8864 fnum1 = (uint16_t)-1;
8865 }
8866 if (fnum2 != (uint16_t)-1) {
8867 cli_close(cli, fnum2);
8868 fnum2 = (uint16_t)-1;
8869 }
8870
8871 cli_setatr(cli, fname, 0, 0);
8872 cli_posix_unlink(cli, fname);
8873
8874 if (!torture_close_connection(cli)) {
8875 correct = false;
8876 }
8877
8878 TALLOC_FREE(frame);
8879 return correct;
8880 }
8881
8882 struct posix_blocking_state {
8883 struct tevent_context *ev;
8884 struct cli_state *cli1;
8885 uint16_t fnum1;
8886 struct cli_state *cli2;
8887 uint16_t fnum2;
8888 bool gotblocked;
8889 bool gotecho;
8890 };
8891
8892 static void posix_blocking_locked(struct tevent_req *subreq);
8893 static void posix_blocking_gotblocked(struct tevent_req *subreq);
8894 static void posix_blocking_gotecho(struct tevent_req *subreq);
8895 static void posix_blocking_unlocked(struct tevent_req *subreq);
8896
8897 static struct tevent_req *posix_blocking_send(
8898 TALLOC_CTX *mem_ctx,
8899 struct tevent_context *ev,
8900 struct cli_state *cli1,
8901 uint16_t fnum1,
8902 struct cli_state *cli2,
8903 uint16_t fnum2)
8904 {
8905 struct tevent_req *req = NULL, *subreq = NULL;
8906 struct posix_blocking_state *state = NULL;
8907
8908 req = tevent_req_create(mem_ctx, &state, struct posix_blocking_state);
8909 if (req == NULL) {
8910 return NULL;
8911 }
8912 state->ev = ev;
8913 state->cli1 = cli1;
8914 state->fnum1 = fnum1;
8915 state->cli2 = cli2;
8916 state->fnum2 = fnum2;
8917
8918 subreq = cli_posix_lock_send(
8919 state,
8920 state->ev,
8921 state->cli1,
8922 state->fnum1,
8923 0,
8924 1,
8925 false,
8926 WRITE_LOCK);
8927 if (tevent_req_nomem(subreq, req)) {
8928 return tevent_req_post(req, ev);
8929 }
8930 tevent_req_set_callback(subreq, posix_blocking_locked, req);
8931 return req;
8932 }
8933
8934 static void posix_blocking_locked(struct tevent_req *subreq)
8935 {
8936 struct tevent_req *req = tevent_req_callback_data(
8937 subreq, struct tevent_req);
8938 struct posix_blocking_state *state = tevent_req_data(
8939 req, struct posix_blocking_state);
8940 NTSTATUS status;
8941
8942 status = cli_posix_lock_recv(subreq);
8943 TALLOC_FREE(subreq);
8944 if (tevent_req_nterror(req, status)) {
8945 return;
8946 }
8947
8948 subreq = cli_posix_lock_send(
8949 state,
8950 state->ev,
8951 state->cli2,
8952 state->fnum2,
8953 0,
8954 1,
8955 true,
8956 WRITE_LOCK);
8957 if (tevent_req_nomem(subreq, req)) {
8958 return;
8959 }
8960 tevent_req_set_callback(subreq, posix_blocking_gotblocked, req);
8961
8962 /* Make sure the blocking request is delivered */
8963 subreq = cli_echo_send(
8964 state,
8965 state->ev,
8966 state->cli2,
8967 1,
8968 (DATA_BLOB) { .data = (uint8_t *)state, .length = 1 });
8969 if (tevent_req_nomem(subreq, req)) {
8970 return;
8971 }
8972 tevent_req_set_callback(subreq, posix_blocking_gotecho, req);
8973 }
8974
8975 static void posix_blocking_gotblocked(struct tevent_req *subreq)
8976 {
8977 struct tevent_req *req = tevent_req_callback_data(
8978 subreq, struct tevent_req);
8979 struct posix_blocking_state *state = tevent_req_data(
8980 req, struct posix_blocking_state);
8981 NTSTATUS status;
8982
8983 status = cli_posix_lock_recv(subreq);
8984 TALLOC_FREE(subreq);
8985 if (tevent_req_nterror(req, status)) {
8986 return;
8987 }
8988 if (!state->gotecho) {
8989 printf("blocked req got through before echo\n");
8990 tevent_req_nterror(req, NT_STATUS_INVALID_LOCK_SEQUENCE);
8991 return;
8992 }
8993 tevent_req_done(req);
8994 }
8995
8996 static void posix_blocking_gotecho(struct tevent_req *subreq)
8997 {
8998 struct tevent_req *req = tevent_req_callback_data(
8999 subreq, struct tevent_req);
9000 struct posix_blocking_state *state = tevent_req_data(
9001 req, struct posix_blocking_state);
9002 NTSTATUS status;
9003
9004 status = cli_echo_recv(subreq);
9005 TALLOC_FREE(subreq);
9006 if (tevent_req_nterror(req, status)) {
9007 return;
9008 }
9009 if (state->gotblocked) {
9010 printf("blocked req got through before echo\n");
9011 tevent_req_nterror(req, NT_STATUS_INVALID_LOCK_SEQUENCE);
9012 return;
9013 }
9014 state->gotecho = true;
9015
9016 subreq = cli_posix_lock_send(
9017 state,
9018 state->ev,
9019 state->cli1,
9020 state->fnum1,
9021 0,
9022 1,
9023 false,
9024 UNLOCK_LOCK);
9025 if (tevent_req_nomem(subreq, req)) {
9026 return;
9027 }
9028 tevent_req_set_callback(subreq, posix_blocking_unlocked, req);
9029 }
9030
9031 static void posix_blocking_unlocked(struct tevent_req *subreq)
9032 {
9033 struct tevent_req *req = tevent_req_callback_data(
9034 subreq, struct tevent_req);
9035 NTSTATUS status;
9036
9037 status = cli_posix_lock_recv(subreq);
9038 TALLOC_FREE(subreq);
9039 if (tevent_req_nterror(req, status)) {
9040 return;
9041 }
9042 /* tevent_req_done in posix_blocking_gotlocked */
9043 }
9044
9045 static NTSTATUS posix_blocking_recv(struct tevent_req *req)
9046 {
9047 return tevent_req_simple_recv_ntstatus(req);
9048 }
9049
9050 static bool run_posix_blocking_lock(int dummy)
9051 {
9052 struct tevent_context *ev = NULL;
9053 struct cli_state *cli1 = NULL, *cli2 = NULL;
9054 const char *fname = "posix_blocking";
9055 uint16_t fnum1 = UINT16_MAX, fnum2 = UINT16_MAX;
9056 struct tevent_req *req = NULL;
9057 NTSTATUS status;
9058 bool ret = false;
9059 bool ok;
9060
9061 printf("Starting posix blocking lock test\n");
9062
9063 ev = samba_tevent_context_init(NULL);
9064 if (ev == NULL) {
9065 return false;
9066 }
9067
9068 ok = torture_open_connection(&cli1, 0);
9069 if (!ok) {
9070 goto fail;
9071 }
9072 ok = torture_open_connection(&cli2, 0);
9073 if (!ok) {
9074 goto fail;
9075 }
9076
9077 smbXcli_conn_set_sockopt(cli1->conn, sockops);
9078
9079 status = torture_setup_unix_extensions(cli1);
9080 if (!NT_STATUS_IS_OK(status)) {
9081 return false;
9082 }
9083
9084 status = torture_setup_unix_extensions(cli2);
9085 if (!NT_STATUS_IS_OK(status)) {
9086 return false;
9087 }
9088
9089 cli_setatr(cli1, fname, 0, 0);
9090 cli_posix_unlink(cli1, fname);
9091
9092 status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL,
9093 0600, &fnum1);
9094 if (!NT_STATUS_IS_OK(status)) {
9095 printf("First POSIX open of %s failed: %s\n",
9096 fname,
9097 nt_errstr(status));
9098 goto fail;
9099 }
9100
9101 status = cli_posix_open(cli2, fname, O_RDWR, 0600, &fnum2);
9102 if (!NT_STATUS_IS_OK(status)) {
9103 printf("Second POSIX open of %s failed: %s\n",
9104 fname,
9105 nt_errstr(status));
9106 goto fail;
9107 }
9108
9109 req = posix_blocking_send(ev, ev, cli1, fnum1, cli2, fnum2);
9110 if (req == NULL) {
9111 printf("cli_posix_blocking failed\n");
9112 goto fail;
9113 }
9114
9115 ok = tevent_req_poll_ntstatus(req, ev, &status);
9116 if (!ok) {
9117 printf("tevent_req_poll_ntstatus failed: %s\n",
9118 nt_errstr(status));
9119 goto fail;
9120 }
9121 status = posix_blocking_recv(req);
9122 TALLOC_FREE(req);
9123 if (!NT_STATUS_IS_OK(status)) {
9124 printf("posix_blocking_recv returned %s\n",
9125 nt_errstr(status));
9126 goto fail;
9127 }
9128
9129 ret = true;
9130 fail:
9131
9132 if (fnum1 != UINT16_MAX) {
9133 cli_close(cli1, fnum1);
9134 fnum1 = UINT16_MAX;
9135 }
9136 if (fnum2 != UINT16_MAX) {
9137 cli_close(cli2, fnum2);
9138 fnum2 = UINT16_MAX;
9139 }
9140
9141 if (cli1 != NULL) {
9142 cli_setatr(cli1, fname, 0, 0);
9143 cli_posix_unlink(cli1, fname);
9144 }
9145
9146 ok = true;
9147
9148 if (cli1 != NULL) {
9149 ok &= torture_close_connection(cli1);
9150 cli1 = NULL;
9151 }
9152 if (cli2 != NULL) {
9153 ok &= torture_close_connection(cli2);
9154 cli2 = NULL;
9155 }
9156
9157 if (!ok) {
9158 ret = false;
9159 }
9160 TALLOC_FREE(ev);
9161 return ret;
9162 }
9163
9164 /*
9165 Test POSIX mkdir is case-sensitive.
9166 */
9167 static bool run_posix_mkdir_test(int dummy)
9168 {
9169 static struct cli_state *cli;
9170 const char *fname_foo = "POSIX_foo";
9171 const char *fname_foo_Foo = "POSIX_foo/Foo";
9172 const char *fname_foo_foo = "POSIX_foo/foo";
9173 const char *fname_Foo = "POSIX_Foo";
9174 const char *fname_Foo_Foo = "POSIX_Foo/Foo";
9175 const char *fname_Foo_foo = "POSIX_Foo/foo";
9176 bool correct = false;
9177 NTSTATUS status;
9178 TALLOC_CTX *frame = NULL;
9179 uint16_t fnum = (uint16_t)-1;
9180
9181 frame = talloc_stackframe();
9182
9183 printf("Starting POSIX mkdir test\n");
9184
9185 if (!torture_open_connection(&cli, 0)) {
9186 TALLOC_FREE(frame);
9187 return false;
9188 }
9189
9190 smbXcli_conn_set_sockopt(cli->conn, sockops);
9191
9192 status = torture_setup_unix_extensions(cli);
9193 if (!NT_STATUS_IS_OK(status)) {
9194 TALLOC_FREE(frame);
9195 return false;
9196 }
9197
9198 cli_posix_rmdir(cli, fname_foo_foo);
9199 cli_posix_rmdir(cli, fname_foo_Foo);
9200 cli_posix_rmdir(cli, fname_foo);
9201
9202 cli_posix_rmdir(cli, fname_Foo_foo);
9203 cli_posix_rmdir(cli, fname_Foo_Foo);
9204 cli_posix_rmdir(cli, fname_Foo);
9205
9206 /*
9207 * Create a file POSIX_foo then try
9208 * and use it in a directory path by
9209 * doing mkdir POSIX_foo/bar.
9210 * The mkdir should fail with
9211 * NT_STATUS_OBJECT_PATH_NOT_FOUND
9212 */
9213
9214 status = cli_posix_open(cli,
9215 fname_foo,
9216 O_RDWR|O_CREAT,
9217 0666,
9218 &fnum);
9219 if (!NT_STATUS_IS_OK(status)) {
9220 printf("cli_posix_open of %s failed error %s\n",
9221 fname_foo,
9222 nt_errstr(status));
9223 goto out;
9224 }
9225
9226 status = cli_posix_mkdir(cli, fname_foo_foo, 0777);
9227 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
9228 printf("cli_posix_mkdir of %s should fail with "
9229 "NT_STATUS_OBJECT_PATH_NOT_FOUND got "
9230 "%s instead\n",
9231 fname_foo_foo,
9232 nt_errstr(status));
9233 goto out;
9234 }
9235
9236 status = cli_close(cli, fnum);
9237 if (!NT_STATUS_IS_OK(status)) {
9238 printf("cli_close failed %s\n", nt_errstr(status));
9239 goto out;
9240 }
9241 fnum = (uint16_t)-1;
9242
9243 status = cli_posix_unlink(cli, fname_foo);
9244 if (!NT_STATUS_IS_OK(status)) {
9245 printf("cli_posix_unlink of %s failed error %s\n",
9246 fname_foo,
9247 nt_errstr(status));
9248 goto out;
9249 }
9250
9251 /*
9252 * Now we've deleted everything, posix_mkdir, posix_rmdir,
9253 * posix_open, posix_unlink, on
9254 * POSIX_foo/foo should return NT_STATUS_OBJECT_PATH_NOT_FOUND
9255 * not silently create POSIX_foo/foo.
9256 */
9257
9258 status = cli_posix_mkdir(cli, fname_foo_foo, 0777);
9259 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
9260 printf("cli_posix_mkdir of %s should fail with "
9261 "NT_STATUS_OBJECT_PATH_NOT_FOUND got "
9262 "%s instead\n",
9263 fname_foo_foo,
9264 nt_errstr(status));
9265 goto out;
9266 }
9267
9268 status = cli_posix_rmdir(cli, fname_foo_foo);
9269 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
9270 printf("cli_posix_rmdir of %s should fail with "
9271 "NT_STATUS_OBJECT_PATH_NOT_FOUND got "
9272 "%s instead\n",
9273 fname_foo_foo,
9274 nt_errstr(status));
9275 goto out;
9276 }
9277
9278 status = cli_posix_open(cli,
9279 fname_foo_foo,
9280 O_RDWR|O_CREAT,
9281 0666,
9282 &fnum);
9283 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
9284 printf("cli_posix_open of %s should fail with "
9285 "NT_STATUS_OBJECT_PATH_NOT_FOUND got "
9286 "%s instead\n",
9287 fname_foo_foo,
9288 nt_errstr(status));
9289 goto out;
9290 }
9291
9292 status = cli_posix_unlink(cli, fname_foo_foo);
9293 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
9294 printf("cli_posix_unlink of %s should fail with "
9295 "NT_STATUS_OBJECT_PATH_NOT_FOUND got "
9296 "%s instead\n",
9297 fname_foo_foo,
9298 nt_errstr(status));
9299 goto out;
9300 }
9301
9302 status = cli_posix_mkdir(cli, fname_foo, 0777);
9303 if (!NT_STATUS_IS_OK(status)) {
9304 printf("cli_posix_mkdir of %s failed\n", fname_foo);
9305 goto out;
9306 }
9307
9308 status = cli_posix_mkdir(cli, fname_Foo, 0777);
9309 if (!NT_STATUS_IS_OK(status)) {
9310 printf("cli_posix_mkdir of %s failed\n", fname_Foo);
9311 goto out;
9312 }
9313
9314 status = cli_posix_mkdir(cli, fname_foo_foo, 0777);
9315 if (!NT_STATUS_IS_OK(status)) {
9316 printf("cli_posix_mkdir of %s failed\n", fname_foo_foo);
9317 goto out;
9318 }
9319
9320 status = cli_posix_mkdir(cli, fname_foo_Foo, 0777);
9321 if (!NT_STATUS_IS_OK(status)) {
9322 printf("cli_posix_mkdir of %s failed\n", fname_foo_Foo);
9323 goto out;
9324 }
9325
9326 status = cli_posix_mkdir(cli, fname_Foo_foo, 0777);
9327 if (!NT_STATUS_IS_OK(status)) {
9328 printf("cli_posix_mkdir of %s failed\n", fname_Foo_foo);
9329 goto out;
9330 }
9331
9332 status = cli_posix_mkdir(cli, fname_Foo_Foo, 0777);
9333 if (!NT_STATUS_IS_OK(status)) {
9334 printf("cli_posix_mkdir of %s failed\n", fname_Foo_Foo);
9335 goto out;
9336 }
9337
9338 printf("POSIX mkdir test passed\n");
9339 correct = true;
9340
9341 out:
9342
9343 if (fnum != (uint16_t)-1) {
9344 cli_close(cli, fnum);
9345 fnum = (uint16_t)-1;
9346 }
9347
9348 cli_posix_rmdir(cli, fname_foo_foo);
9349 cli_posix_rmdir(cli, fname_foo_Foo);
9350 cli_posix_rmdir(cli, fname_foo);
9351
9352 cli_posix_rmdir(cli, fname_Foo_foo);
9353 cli_posix_rmdir(cli, fname_Foo_Foo);
9354 cli_posix_rmdir(cli, fname_Foo);
9355
9356 if (!torture_close_connection(cli)) {
9357 correct = false;
9358 }
9359
9360 TALLOC_FREE(frame);
9361 return correct;
9362 }
9363
9364 struct posix_acl_oplock_state {
9365 struct tevent_context *ev;
9366 struct cli_state *cli;
9367 bool *got_break;
9368 bool *acl_ret;
9369 NTSTATUS status;
9370 };
9371
9372 static void posix_acl_oplock_got_break(struct tevent_req *req)
9373 {
9374 struct posix_acl_oplock_state *state = tevent_req_callback_data(
9375 req, struct posix_acl_oplock_state);
9376 uint16_t fnum;
9377 uint8_t level;
9378 NTSTATUS status;
9379
9380 status = cli_smb_oplock_break_waiter_recv(req, &fnum, &level);
9381 TALLOC_FREE(req);
9382 if (!NT_STATUS_IS_OK(status)) {
9383 printf("cli_smb_oplock_break_waiter_recv returned %s\n",
9384 nt_errstr(status));
9385 return;
9386 }
9387 *state->got_break = true;
9388
9389 req = cli_oplock_ack_send(state, state->ev, state->cli, fnum,
9390 NO_OPLOCK);
9391 if (req == NULL) {
9392 printf("cli_oplock_ack_send failed\n");
9393 return;
9394 }
9395 }
9396
9397 static void posix_acl_oplock_got_acl(struct tevent_req *req)
9398 {
9399 struct posix_acl_oplock_state *state = tevent_req_callback_data(
9400 req, struct posix_acl_oplock_state);
9401 size_t ret_size = 0;
9402 char *ret_data = NULL;
9403
9404 state->status = cli_posix_getacl_recv(req,
9405 state,
9406 &ret_size,
9407 &ret_data);
9408
9409 if (!NT_STATUS_IS_OK(state->status)) {
9410 printf("cli_posix_getacl_recv returned %s\n",
9411 nt_errstr(state->status));
9412 }
9413 *state->acl_ret = true;
9414 }
9415
9416 static bool run_posix_acl_oplock_test(int dummy)
9417 {
9418 struct tevent_context *ev;
9419 struct cli_state *cli1, *cli2;
9420 struct tevent_req *oplock_req, *getacl_req;
9421 const char *fname = "posix_acl_oplock";
9422 uint16_t fnum;
9423 int saved_use_oplocks = use_oplocks;
9424 NTSTATUS status;
9425 bool correct = true;
9426 bool got_break = false;
9427 bool acl_ret = false;
9428
9429 struct posix_acl_oplock_state *state;
9430
9431 printf("starting posix_acl_oplock test\n");
9432
9433 if (!torture_open_connection(&cli1, 0)) {
9434 use_level_II_oplocks = false;
9435 use_oplocks = saved_use_oplocks;
9436 return false;
9437 }
9438
9439 if (!torture_open_connection(&cli2, 1)) {
9440 use_level_II_oplocks = false;
9441 use_oplocks = saved_use_oplocks;
9442 return false;
9443 }
9444
9445 /* Setup posix on cli2 only. */
9446 status = torture_setup_unix_extensions(cli2);
9447 if (!NT_STATUS_IS_OK(status)) {
9448 return false;
9449 }
9450
9451 smbXcli_conn_set_sockopt(cli1->conn, sockops);
9452 smbXcli_conn_set_sockopt(cli2->conn, sockops);
9453
9454 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
9455
9456 /* Create the file on the Windows connection. */
9457 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
9458 &fnum);
9459 if (!NT_STATUS_IS_OK(status)) {
9460 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
9461 return false;
9462 }
9463
9464 status = cli_close(cli1, fnum);
9465 if (!NT_STATUS_IS_OK(status)) {
9466 printf("close1 failed (%s)\n", nt_errstr(status));
9467 return false;
9468 }
9469
9470 cli1->use_oplocks = true;
9471
9472 /* Open with oplock. */
9473 status = cli_ntcreate(cli1,
9474 fname,
9475 0,
9476 FILE_READ_DATA,
9477 FILE_ATTRIBUTE_NORMAL,
9478 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
9479 FILE_OPEN,
9480 0,
9481 0,
9482 &fnum,
9483 NULL);
9484
9485 if (!NT_STATUS_IS_OK(status)) {
9486 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
9487 return false;
9488 }
9489
9490 ev = samba_tevent_context_init(talloc_tos());
9491 if (ev == NULL) {
9492 printf("tevent_context_init failed\n");
9493 return false;
9494 }
9495
9496 state = talloc_zero(ev, struct posix_acl_oplock_state);
9497 if (state == NULL) {
9498 printf("talloc failed\n");
9499 return false;
9500 }
9501 state->ev = ev;
9502 state->cli = cli1;
9503 state->got_break = &got_break;
9504 state->acl_ret = &acl_ret;
9505
9506 oplock_req = cli_smb_oplock_break_waiter_send(
9507 talloc_tos(), ev, cli1);
9508 if (oplock_req == NULL) {
9509 printf("cli_smb_oplock_break_waiter_send failed\n");
9510 return false;
9511 }
9512 tevent_req_set_callback(oplock_req, posix_acl_oplock_got_break, state);
9513
9514 /* Get ACL on POSIX connection - should break oplock. */
9515 getacl_req = cli_posix_getacl_send(talloc_tos(),
9516 ev,
9517 cli2,
9518 fname);
9519 if (getacl_req == NULL) {
9520 printf("cli_posix_getacl_send failed\n");
9521 return false;
9522 }
9523 tevent_req_set_callback(getacl_req, posix_acl_oplock_got_acl, state);
9524
9525 while (!got_break || !acl_ret) {
9526 int ret;
9527 ret = tevent_loop_once(ev);
9528 if (ret == -1) {
9529 printf("tevent_loop_once failed: %s\n",
9530 strerror(errno));
9531 return false;
9532 }
9533 }
9534
9535 if (!NT_STATUS_IS_OK(state->status)) {
9536 printf("getacl failed (%s)\n", nt_errstr(state->status));
9537 correct = false;
9538 }
9539
9540 status = cli_close(cli1, fnum);
9541 if (!NT_STATUS_IS_OK(status)) {
9542 printf("close2 failed (%s)\n", nt_errstr(status));
9543 correct = false;
9544 }
9545
9546 status = cli_unlink(cli1,
9547 fname,
9548 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
9549 if (!NT_STATUS_IS_OK(status)) {
9550 printf("unlink failed (%s)\n", nt_errstr(status));
9551 correct = false;
9552 }
9553
9554 if (!torture_close_connection(cli1)) {
9555 correct = false;
9556 }
9557 if (!torture_close_connection(cli2)) {
9558 correct = false;
9559 }
9560
9561 if (!got_break) {
9562 correct = false;
9563 }
9564
9565 printf("finished posix acl oplock test\n");
9566
9567 return correct;
9568 }
9569
9570 static bool run_posix_acl_shareroot_test(int dummy)
9571 {
9572 struct cli_state *cli;
9573 NTSTATUS status;
9574 bool correct = false;
9575 char *posix_acl = NULL;
9576 size_t posix_acl_len = 0;
9577 uint16_t num_file_acls = 0;
9578 uint16_t num_dir_acls = 0;
9579 uint16_t i;
9580 uint32_t expected_size = 0;
9581 bool got_user = false;
9582 bool got_group = false;
9583 bool got_other = false;
9584 TALLOC_CTX *frame = NULL;
9585
9586 frame = talloc_stackframe();
9587
9588 printf("starting posix_acl_shareroot test\n");
9589
9590 if (!torture_open_connection(&cli, 0)) {
9591 TALLOC_FREE(frame);
9592 return false;
9593 }
9594
9595 smbXcli_conn_set_sockopt(cli->conn, sockops);
9596
9597 status = torture_setup_unix_extensions(cli);
9598 if (!NT_STATUS_IS_OK(status)) {
9599 printf("Failed to setup unix extensions\n");
9600 goto out;
9601 }
9602
9603 /* Get the POSIX ACL on the root of the share. */
9604 status = cli_posix_getacl(cli,
9605 ".",
9606 frame,
9607 &posix_acl_len,
9608 &posix_acl);
9609
9610 if (!NT_STATUS_IS_OK(status)) {
9611 printf("cli_posix_getacl of '.' failed (%s)\n",
9612 nt_errstr(status));
9613 goto out;
9614 }
9615
9616 if (posix_acl_len < 6 ||
9617 SVAL(posix_acl,0) != SMB_POSIX_ACL_VERSION) {
9618 printf("getfacl ., unknown POSIX acl version %u.\n",
9619 (unsigned int)CVAL(posix_acl,0) );
9620 goto out;
9621 }
9622
9623 num_file_acls = SVAL(posix_acl,2);
9624 num_dir_acls = SVAL(posix_acl,4);
9625 expected_size = SMB_POSIX_ACL_HEADER_SIZE +
9626 SMB_POSIX_ACL_ENTRY_SIZE*
9627 (num_file_acls+num_dir_acls);
9628
9629 if (posix_acl_len != expected_size) {
9630 printf("incorrect POSIX acl buffer size "
9631 "(should be %u, was %u).\n",
9632 (unsigned int)expected_size,
9633 (unsigned int)posix_acl_len);
9634 goto out;
9635 }
9636
9637 /*
9638 * We don't need to know what the ACL's are
9639 * we just need to know we have at least 3
9640 * file entries (u,g,o).
9641 */
9642
9643 for (i = 0; i < num_file_acls; i++) {
9644 unsigned char tagtype =
9645 CVAL(posix_acl,
9646 SMB_POSIX_ACL_HEADER_SIZE+
9647 (i*SMB_POSIX_ACL_ENTRY_SIZE));
9648
9649 switch(tagtype) {
9650 case SMB_POSIX_ACL_USER_OBJ:
9651 got_user = true;
9652 break;
9653 case SMB_POSIX_ACL_GROUP_OBJ:
9654 got_group = true;
9655 break;
9656 case SMB_POSIX_ACL_OTHER:
9657 got_other = true;
9658 break;
9659 default:
9660 break;
9661 }
9662 }
9663
9664 if (!got_user) {
9665 printf("Missing user entry\n");
9666 goto out;
9667 }
9668
9669 if (!got_group) {
9670 printf("Missing group entry\n");
9671 goto out;
9672 }
9673
9674 if (!got_other) {
9675 printf("Missing other entry\n");
9676 goto out;
9677 }
9678
9679 correct = true;
9680
9681 out:
9682
9683 if (!torture_close_connection(cli)) {
9684 correct = false;
9685 }
9686
9687 printf("finished posix acl shareroot test\n");
9688 TALLOC_FREE(frame);
9689
9690 return correct;
9691 }
9692
9693 static uint32_t open_attrs_table[] = {
9694 FILE_ATTRIBUTE_NORMAL,
9695 FILE_ATTRIBUTE_ARCHIVE,
9696 FILE_ATTRIBUTE_READONLY,
9697 FILE_ATTRIBUTE_HIDDEN,
9698 FILE_ATTRIBUTE_SYSTEM,
9699
9700 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY,
9701 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN,
9702 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,
9703 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
9704 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
9705 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
9706
9707 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
9708 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
9709 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
9710 FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM,
9711 };
9712
9713 struct trunc_open_results {
9714 unsigned int num;
9715 uint32_t init_attr;
9716 uint32_t trunc_attr;
9717 uint32_t result_attr;
9718 };
9719
9720 static struct trunc_open_results attr_results[] = {
9721 { 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
9722 { 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
9723 { 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
9724 { 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
9725 { 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
9726 { 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
9727 { 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
9728 { 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
9729 { 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
9730 { 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
9731 { 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
9732 { 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
9733 { 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
9734 { 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
9735 { 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 },
9736 { 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
9737 { 119, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
9738 { 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 },
9739 { 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 },
9740 { 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 },
9741 { 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
9742 { 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
9743 { 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
9744 { 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
9745 { 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
9746 { 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
9747 };
9748
9749 static bool run_openattrtest(int dummy)
9750 {
9751 static struct cli_state *cli1;
9752 const char *fname = "\\openattr.file";
9753 uint16_t fnum1;
9754 bool correct = True;
9755 uint32_t attr;
9756 unsigned int i, j, k, l;
9757 NTSTATUS status;
9758
9759 printf("starting open attr test\n");
9760
9761 if (!torture_open_connection(&cli1, 0)) {
9762 return False;
9763 }
9764
9765 smbXcli_conn_set_sockopt(cli1->conn, sockops);
9766
9767 for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32_t); i++) {
9768 cli_setatr(cli1, fname, 0, 0);
9769 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
9770
9771 status = cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA,
9772 open_attrs_table[i], FILE_SHARE_NONE,
9773 FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL);
9774 if (!NT_STATUS_IS_OK(status)) {
9775 printf("open %d (1) of %s failed (%s)\n", i, fname, nt_errstr(status));
9776 return False;
9777 }
9778
9779 status = cli_close(cli1, fnum1);
9780 if (!NT_STATUS_IS_OK(status)) {
9781 printf("close %d (1) of %s failed (%s)\n", i, fname, nt_errstr(status));
9782 return False;
9783 }
9784
9785 for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32_t); j++) {
9786 status = cli_ntcreate(cli1, fname, 0,
9787 FILE_READ_DATA|FILE_WRITE_DATA,
9788 open_attrs_table[j],
9789 FILE_SHARE_NONE, FILE_OVERWRITE,
9790 0, 0, &fnum1, NULL);
9791 if (!NT_STATUS_IS_OK(status)) {
9792 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
9793 if (attr_results[l].num == k) {
9794 printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
9795 k, open_attrs_table[i],
9796 open_attrs_table[j],
9797 fname, NT_STATUS_V(status), nt_errstr(status));
9798 correct = False;
9799 }
9800 }
9801
9802 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
9803 printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n",
9804 k, open_attrs_table[i], open_attrs_table[j],
9805 nt_errstr(status));
9806 correct = False;
9807 }
9808 #if 0
9809 printf("[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]);
9810 #endif
9811 k++;
9812 continue;
9813 }
9814
9815 status = cli_close(cli1, fnum1);
9816 if (!NT_STATUS_IS_OK(status)) {
9817 printf("close %d (2) of %s failed (%s)\n", j, fname, nt_errstr(status));
9818 return False;
9819 }
9820
9821 status = cli_getatr(cli1, fname, &attr, NULL, NULL);
9822 if (!NT_STATUS_IS_OK(status)) {
9823 printf("getatr(2) failed (%s)\n", nt_errstr(status));
9824 return False;
9825 }
9826
9827 #if 0
9828 printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
9829 k, open_attrs_table[i], open_attrs_table[j], attr );
9830 #endif
9831
9832 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
9833 if (attr_results[l].num == k) {
9834 if (attr != attr_results[l].result_attr ||
9835 open_attrs_table[i] != attr_results[l].init_attr ||
9836 open_attrs_table[j] != attr_results[l].trunc_attr) {
9837 printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
9838 open_attrs_table[i],
9839 open_attrs_table[j],
9840 (unsigned int)attr,
9841 attr_results[l].result_attr);
9842 correct = False;
9843 }
9844 break;
9845 }
9846 }
9847 k++;
9848 }
9849 }
9850
9851 cli_setatr(cli1, fname, 0, 0);
9852 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
9853
9854 printf("open attr test %s.\n", correct ? "passed" : "failed");
9855
9856 if (!torture_close_connection(cli1)) {
9857 correct = False;
9858 }
9859 return correct;
9860 }
9861
9862 static NTSTATUS list_fn(struct file_info *finfo,
9863 const char *name, void *state)
9864 {
9865 int *matched = (int *)state;
9866 if (matched != NULL) {
9867 *matched += 1;
9868 }
9869 return NT_STATUS_OK;
9870 }
9871
9872 /*
9873 test directory listing speed
9874 */
9875 static bool run_dirtest(int dummy)
9876 {
9877 int i;
9878 static struct cli_state *cli;
9879 uint16_t fnum;
9880 struct timeval core_start;
9881 bool correct = True;
9882 int matched;
9883
9884 printf("starting directory test\n");
9885
9886 if (!torture_open_connection(&cli, 0)) {
9887 return False;
9888 }
9889
9890 smbXcli_conn_set_sockopt(cli->conn, sockops);
9891
9892 srandom(0);
9893 for (i=0;i<torture_numops;i++) {
9894 fstring fname;
9895 slprintf(fname, sizeof(fname), "\\%x", (int)random());
9896 if (!NT_STATUS_IS_OK(cli_openx(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum))) {
9897 fprintf(stderr,"Failed to open %s\n", fname);
9898 return False;
9899 }
9900 cli_close(cli, fnum);
9901 }
9902
9903 core_start = timeval_current();
9904
9905 matched = 0;
9906 cli_list(cli, "a*.*", 0, list_fn, &matched);
9907 printf("Matched %d\n", matched);
9908
9909 matched = 0;
9910 cli_list(cli, "b*.*", 0, list_fn, &matched);
9911 printf("Matched %d\n", matched);
9912
9913 matched = 0;
9914 cli_list(cli, "xyzabc", 0, list_fn, &matched);
9915 printf("Matched %d\n", matched);
9916
9917 printf("dirtest core %g seconds\n", timeval_elapsed(&core_start));
9918
9919 srandom(0);
9920 for (i=0;i<torture_numops;i++) {
9921 fstring fname;
9922 slprintf(fname, sizeof(fname), "\\%x", (int)random());
9923 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
9924 }
9925
9926 if (!torture_close_connection(cli)) {
9927 correct = False;
9928 }
9929
9930 printf("finished dirtest\n");
9931
9932 return correct;
9933 }
9934
9935 static NTSTATUS del_fn(struct file_info *finfo, const char *mask,
9936 void *state)
9937 {
9938 struct cli_state *pcli = (struct cli_state *)state;
9939 fstring fname;
9940 slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name);
9941
9942 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
9943 return NT_STATUS_OK;
9944
9945 if (finfo->attr & FILE_ATTRIBUTE_DIRECTORY) {
9946 if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname)))
9947 printf("del_fn: failed to rmdir %s\n,", fname );
9948 } else {
9949 if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN)))
9950 printf("del_fn: failed to unlink %s\n,", fname );
9951 }
9952 return NT_STATUS_OK;
9953 }
9954
9955
9956 /*
9957 send a raw ioctl - used by the torture code
9958 */
9959 static NTSTATUS cli_raw_ioctl(struct cli_state *cli,
9960 uint16_t fnum,
9961 uint32_t code,
9962 DATA_BLOB *blob)
9963 {
9964 uint16_t vwv[3];
9965 NTSTATUS status;
9966
9967 PUSH_LE_U16(vwv + 0, 0, fnum);
9968 PUSH_LE_U16(vwv + 1, 0, code >> 16);
9969 PUSH_LE_U16(vwv + 2, 0, (code & 0xFFFF));
9970
9971 status = cli_smb(talloc_tos(),
9972 cli,
9973 SMBioctl,
9974 0,
9975 3,
9976 vwv,
9977 0,
9978 NULL,
9979 NULL,
9980 0,
9981 NULL,
9982 NULL,
9983 NULL,
9984 NULL);
9985 if (!NT_STATUS_IS_OK(status)) {
9986 return status;
9987 }
9988 *blob = data_blob_null;
9989 return NT_STATUS_OK;
9990 }
9991
9992 /*
9993 sees what IOCTLs are supported
9994 */
9995 bool torture_ioctl_test(int dummy)
9996 {
9997 static struct cli_state *cli;
9998 uint16_t device, function;
9999 uint16_t fnum;
10000 const char *fname = "\\ioctl.dat";
10001 DATA_BLOB blob;
10002 NTSTATUS status;
10003
10004 if (!torture_open_connection(&cli, 0)) {
10005 return False;
10006 }
10007
10008 printf("starting ioctl test\n");
10009
10010 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
10011
10012 status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
10013 if (!NT_STATUS_IS_OK(status)) {
10014 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
10015 return False;
10016 }
10017
10018 status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob);
10019 printf("ioctl device info: %s\n", nt_errstr(status));
10020
10021 status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob);
10022 printf("ioctl job info: %s\n", nt_errstr(status));
10023
10024 for (device=0;device<0x100;device++) {
10025 printf("ioctl test with device = 0x%x\n", device);
10026 for (function=0;function<0x100;function++) {
10027 uint32_t code = (device<<16) | function;
10028
10029 status = cli_raw_ioctl(cli, fnum, code, &blob);
10030
10031 if (NT_STATUS_IS_OK(status)) {
10032 printf("ioctl 0x%x OK : %d bytes\n", (int)code,
10033 (int)blob.length);
10034 data_blob_free(&blob);
10035 }
10036 }
10037 }
10038
10039 if (!torture_close_connection(cli)) {
10040 return False;
10041 }
10042
10043 return True;
10044 }
10045
10046
10047 /*
10048 tries variants of chkpath
10049 */
10050 bool torture_chkpath_test(int dummy)
10051 {
10052 static struct cli_state *cli;
10053 uint16_t fnum;
10054 bool ret;
10055 NTSTATUS status;
10056
10057 if (!torture_open_connection(&cli, 0)) {
10058 return False;
10059 }
10060
10061 printf("starting chkpath test\n");
10062
10063 /* cleanup from an old run */
10064 torture_deltree(cli, "\\chkpath.dir");
10065
10066 status = cli_mkdir(cli, "\\chkpath.dir");
10067 if (!NT_STATUS_IS_OK(status)) {
10068 printf("mkdir1 failed : %s\n", nt_errstr(status));
10069 return False;
10070 }
10071
10072 status = cli_mkdir(cli, "\\chkpath.dir\\dir2");
10073 if (!NT_STATUS_IS_OK(status)) {
10074 printf("mkdir2 failed : %s\n", nt_errstr(status));
10075 return False;
10076 }
10077
10078 status = cli_openx(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL,
10079 DENY_NONE, &fnum);
10080 if (!NT_STATUS_IS_OK(status)) {
10081 printf("open1 failed (%s)\n", nt_errstr(status));
10082 return False;
10083 }
10084 cli_close(cli, fnum);
10085
10086 status = cli_chkpath(cli, "\\chkpath.dir");
10087 if (!NT_STATUS_IS_OK(status)) {
10088 printf("chkpath1 failed: %s\n", nt_errstr(status));
10089 ret = False;
10090 }
10091
10092 status = cli_chkpath(cli, "\\chkpath.dir\\dir2");
10093 if (!NT_STATUS_IS_OK(status)) {
10094 printf("chkpath2 failed: %s\n", nt_errstr(status));
10095 ret = False;
10096 }
10097
10098 status = cli_chkpath(cli, "\\chkpath.dir\\foo.txt");
10099 if (!NT_STATUS_IS_OK(status)) {
10100 ret = check_error(__LINE__, status, ERRDOS, ERRbadpath,
10101 NT_STATUS_NOT_A_DIRECTORY);
10102 } else {
10103 printf("* chkpath on a file should fail\n");
10104 ret = False;
10105 }
10106
10107 status = cli_chkpath(cli, "\\chkpath.dir\\bar.txt");
10108 if (!NT_STATUS_IS_OK(status)) {
10109 ret = check_error(__LINE__, status, ERRDOS, ERRbadfile,
10110 NT_STATUS_OBJECT_NAME_NOT_FOUND);
10111 } else {
10112 printf("* chkpath on a non existent file should fail\n");
10113 ret = False;
10114 }
10115
10116 status = cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt");
10117 if (!NT_STATUS_IS_OK(status)) {
10118 ret = check_error(__LINE__, status, ERRDOS, ERRbadpath,
10119 NT_STATUS_OBJECT_PATH_NOT_FOUND);
10120 } else {
10121 printf("* chkpath on a non existent component should fail\n");
10122 ret = False;
10123 }
10124
10125 torture_deltree(cli, "\\chkpath.dir");
10126
10127 if (!torture_close_connection(cli)) {
10128 return False;
10129 }
10130
10131 return ret;
10132 }
10133
10134 static bool run_eatest(int dummy)
10135 {
10136 static struct cli_state *cli;
10137 const char *fname = "\\eatest.txt";
10138 bool correct = True;
10139 uint16_t fnum;
10140 size_t i, num_eas;
10141 struct ea_struct *ea_list = NULL;
10142 TALLOC_CTX *mem_ctx = talloc_init("eatest");
10143 NTSTATUS status;
10144
10145 printf("starting eatest\n");
10146
10147 if (!torture_open_connection(&cli, 0)) {
10148 talloc_destroy(mem_ctx);
10149 return False;
10150 }
10151
10152 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
10153
10154 status = cli_ntcreate(cli, fname, 0,
10155 FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
10156 FILE_SHARE_NONE, FILE_OVERWRITE_IF,
10157 0x4044, 0, &fnum, NULL);
10158 if (!NT_STATUS_IS_OK(status)) {
10159 printf("open failed - %s\n", nt_errstr(status));
10160 talloc_destroy(mem_ctx);
10161 return False;
10162 }
10163
10164 for (i = 0; i < 10; i++) {
10165 fstring ea_name, ea_val;
10166
10167 slprintf(ea_name, sizeof(ea_name), "EA_%zu", i);
10168 memset(ea_val, (char)i+1, i+1);
10169 status = cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1);
10170 if (!NT_STATUS_IS_OK(status)) {
10171 printf("ea_set of name %s failed - %s\n", ea_name,
10172 nt_errstr(status));
10173 talloc_destroy(mem_ctx);
10174 return False;
10175 }
10176 }
10177
10178 cli_close(cli, fnum);
10179 for (i = 0; i < 10; i++) {
10180 fstring ea_name, ea_val;
10181
10182 slprintf(ea_name, sizeof(ea_name), "EA_%zu", i+10);
10183 memset(ea_val, (char)i+1, i+1);
10184 status = cli_set_ea_path(cli, fname, ea_name, ea_val, i+1);
10185 if (!NT_STATUS_IS_OK(status)) {
10186 printf("ea_set of name %s failed - %s\n", ea_name,
10187 nt_errstr(status));
10188 talloc_destroy(mem_ctx);
10189 return False;
10190 }
10191 }
10192
10193 status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
10194 if (!NT_STATUS_IS_OK(status)) {
10195 printf("ea_get list failed - %s\n", nt_errstr(status));
10196 correct = False;
10197 }
10198
10199 printf("num_eas = %d\n", (int)num_eas);
10200
10201 if (num_eas != 20) {
10202 printf("Should be 20 EA's stored... failing.\n");
10203 correct = False;
10204 }
10205
10206 for (i = 0; i < num_eas; i++) {
10207 printf("%zu: ea_name = %s. Val = ", i, ea_list[i].name);
10208 dump_data(0, ea_list[i].value.data,
10209 ea_list[i].value.length);
10210 }
10211
10212 /* Setting EA's to zero length deletes them. Test this */
10213 printf("Now deleting all EA's - case independent....\n");
10214
10215 #if 1
10216 cli_set_ea_path(cli, fname, "", "", 0);
10217 #else
10218 for (i = 0; i < 20; i++) {
10219 fstring ea_name;
10220 slprintf(ea_name, sizeof(ea_name), "ea_%d", i);
10221 status = cli_set_ea_path(cli, fname, ea_name, "", 0);
10222 if (!NT_STATUS_IS_OK(status)) {
10223 printf("ea_set of name %s failed - %s\n", ea_name,
10224 nt_errstr(status));
10225 talloc_destroy(mem_ctx);
10226 return False;
10227 }
10228 }
10229 #endif
10230
10231 status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
10232 if (!NT_STATUS_IS_OK(status)) {
10233 printf("ea_get list failed - %s\n", nt_errstr(status));
10234 correct = False;
10235 }
10236
10237 printf("num_eas = %d\n", (int)num_eas);
10238 for (i = 0; i < num_eas; i++) {
10239 printf("%zu: ea_name = %s. Val = ", i, ea_list[i].name);
10240 dump_data(0, ea_list[i].value.data,
10241 ea_list[i].value.length);
10242 }
10243
10244 if (num_eas != 0) {
10245 printf("deleting EA's failed.\n");
10246 correct = False;
10247 }
10248
10249 /* Try and delete a non existent EA. */
10250 status = cli_set_ea_path(cli, fname, "foo", "", 0);
10251 if (!NT_STATUS_IS_OK(status)) {
10252 printf("deleting non-existent EA 'foo' should succeed. %s\n",
10253 nt_errstr(status));
10254 correct = False;
10255 }
10256
10257 talloc_destroy(mem_ctx);
10258 if (!torture_close_connection(cli)) {
10259 correct = False;
10260 }
10261
10262 return correct;
10263 }
10264
10265 static bool run_dirtest1(int dummy)
10266 {
10267 int i;
10268 static struct cli_state *cli;
10269 uint16_t fnum;
10270 int num_seen;
10271 bool correct = True;
10272
10273 printf("starting directory test\n");
10274
10275 if (!torture_open_connection(&cli, 0)) {
10276 return False;
10277 }
10278
10279 smbXcli_conn_set_sockopt(cli->conn, sockops);
10280
10281 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
10282 cli_list(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, del_fn, cli);
10283 cli_rmdir(cli, "\\LISTDIR");
10284 cli_mkdir(cli, "\\LISTDIR");
10285
10286 /* Create 1000 files and 1000 directories. */
10287 for (i=0;i<1000;i++) {
10288 fstring fname;
10289 slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i);
10290 if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
10291 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF,
10292 0, 0, &fnum, NULL))) {
10293 fprintf(stderr,"Failed to open %s\n", fname);
10294 return False;
10295 }
10296 cli_close(cli, fnum);
10297 }
10298 for (i=0;i<1000;i++) {
10299 fstring fname;
10300 slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i);
10301 if (!NT_STATUS_IS_OK(cli_mkdir(cli, fname))) {
10302 fprintf(stderr,"Failed to open %s\n", fname);
10303 return False;
10304 }
10305 }
10306
10307 /* Now ensure that doing an old list sees both files and directories. */
10308 num_seen = 0;
10309 cli_list_old(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
10310 printf("num_seen = %d\n", num_seen );
10311 /* We should see 100 files + 1000 directories + . and .. */
10312 if (num_seen != 2002)
10313 correct = False;
10314
10315 /* Ensure if we have the "must have" bits we only see the
10316 * relevant entries.
10317 */
10318 num_seen = 0;
10319 cli_list_old(cli, "\\LISTDIR\\*", (FILE_ATTRIBUTE_DIRECTORY<<8)|FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
10320 printf("num_seen = %d\n", num_seen );
10321 if (num_seen != 1002)
10322 correct = False;
10323
10324 num_seen = 0;
10325 cli_list_old(cli, "\\LISTDIR\\*", (FILE_ATTRIBUTE_ARCHIVE<<8)|FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
10326 printf("num_seen = %d\n", num_seen );
10327 if (num_seen != 1000)
10328 correct = False;
10329
10330 /* Delete everything. */
10331 cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
10332 cli_list(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, del_fn, cli);
10333 cli_rmdir(cli, "\\LISTDIR");
10334
10335 #if 0
10336 printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
10337 printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
10338 printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
10339 #endif
10340
10341 if (!torture_close_connection(cli)) {
10342 correct = False;
10343 }
10344
10345 printf("finished dirtest1\n");
10346
10347 return correct;
10348 }
10349
10350 static bool run_error_map_extract(int dummy) {
10351
10352 static struct cli_state *c_dos;
10353 static struct cli_state *c_nt;
10354 NTSTATUS status;
10355
10356 uint32_t error;
10357
10358 uint32_t errnum;
10359 uint8_t errclass;
10360
10361 NTSTATUS nt_status;
10362
10363 fstring user;
10364
10365 /* NT-Error connection */
10366
10367 disable_spnego = true;
10368 if (!(c_nt = open_nbt_connection())) {
10369 disable_spnego = false;
10370 return False;
10371 }
10372 disable_spnego = false;
10373
10374 status = smbXcli_negprot(c_nt->conn,
10375 c_nt->timeout,
10376 PROTOCOL_CORE,
10377 PROTOCOL_NT1,
10378 NULL,
10379 NULL,
10380 NULL);
10381
10382 if (!NT_STATUS_IS_OK(status)) {
10383 printf("%s rejected the NT-error negprot (%s)\n", host,
10384 nt_errstr(status));
10385 cli_shutdown(c_nt);
10386 return False;
10387 }
10388
10389 status = cli_session_setup_anon(c_nt);
10390 if (!NT_STATUS_IS_OK(status)) {
10391 printf("%s rejected the NT-error initial session setup (%s)\n",host, nt_errstr(status));
10392 return False;
10393 }
10394
10395 /* DOS-Error connection */
10396
10397 disable_spnego = true;
10398 force_dos_errors = true;
10399 if (!(c_dos = open_nbt_connection())) {
10400 disable_spnego = false;
10401 force_dos_errors = false;
10402 return False;
10403 }
10404 disable_spnego = false;
10405 force_dos_errors = false;
10406
10407 status = smbXcli_negprot(c_dos->conn,
10408 c_dos->timeout,
10409 PROTOCOL_CORE,
10410 PROTOCOL_NT1,
10411 NULL,
10412 NULL,
10413 NULL);
10414 if (!NT_STATUS_IS_OK(status)) {
10415 printf("%s rejected the DOS-error negprot (%s)\n", host,
10416 nt_errstr(status));
10417 cli_shutdown(c_dos);
10418 return False;
10419 }
10420
10421 status = cli_session_setup_anon(c_dos);
10422 if (!NT_STATUS_IS_OK(status)) {
10423 printf("%s rejected the DOS-error initial session setup (%s)\n",
10424 host, nt_errstr(status));
10425 return False;
10426 }
10427
10428 c_nt->map_dos_errors = false;
10429 c_dos->map_dos_errors = false;
10430
10431 for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) {
10432 struct cli_credentials *user_creds = NULL;
10433
10434 fstr_sprintf(user, "%X", error);
10435
10436 user_creds = cli_session_creds_init(talloc_tos(),
10437 user,
10438 workgroup,
10439 NULL, /* realm */
10440 password,
10441 false, /* use_kerberos */
10442 false, /* fallback_after_kerberos */
10443 false, /* use_ccache */
10444 false); /* password_is_nt_hash */
10445 if (user_creds == NULL) {
10446 printf("cli_session_creds_init(%s) failed\n", user);
10447 return false;
10448 }
10449
10450 status = cli_session_setup_creds(c_nt, user_creds);
10451 if (NT_STATUS_IS_OK(status)) {
10452 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
10453 }
10454
10455 /* Case #1: 32-bit NT errors */
10456 if (!NT_STATUS_IS_DOS(status)) {
10457 nt_status = status;
10458 } else {
10459 printf("/** Dos error on NT connection! (%s) */\n",
10460 nt_errstr(status));
10461 nt_status = NT_STATUS(0xc0000000);
10462 }
10463
10464 status = cli_session_setup_creds(c_dos, user_creds);
10465 if (NT_STATUS_IS_OK(status)) {
10466 printf("/** Session setup succeeded. This shouldn't happen...*/\n");
10467 }
10468
10469 /* Case #1: 32-bit NT errors */
10470 if (NT_STATUS_IS_DOS(status)) {
10471 printf("/** NT error on DOS connection! (%s) */\n",
10472 nt_errstr(status));
10473 errnum = errclass = 0;
10474 } else {
10475 errclass = NT_STATUS_DOS_CLASS(status);
10476 errnum = NT_STATUS_DOS_CODE(status);
10477 }
10478
10479 if (NT_STATUS_V(nt_status) != error) {
10480 printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n",
10481 get_nt_error_c_code(talloc_tos(), NT_STATUS(error)),
10482 get_nt_error_c_code(talloc_tos(), nt_status));
10483 }
10484
10485 printf("\t{%s,\t%s,\t%s},\n",
10486 smb_dos_err_class(errclass),
10487 smb_dos_err_name(errclass, errnum),
10488 get_nt_error_c_code(talloc_tos(), NT_STATUS(error)));
10489
10490 TALLOC_FREE(user_creds);
10491 }
10492 return True;
10493 }
10494
10495 static bool run_sesssetup_bench(int dummy)
10496 {
10497 static struct cli_state *c;
10498 const char *fname = "\\file.dat";
10499 uint16_t fnum;
10500 NTSTATUS status;
10501 int i;
10502
10503 if (!torture_open_connection(&c, 0)) {
10504 return false;
10505 }
10506
10507 status = cli_ntcreate(c, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
10508 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
10509 FILE_DELETE_ON_CLOSE, 0, &fnum, NULL);
10510 if (!NT_STATUS_IS_OK(status)) {
10511 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
10512 return false;
10513 }
10514
10515 for (i=0; i<torture_numops; i++) {
10516 status = cli_session_setup_creds(c, torture_creds);
10517 if (!NT_STATUS_IS_OK(status)) {
10518 d_printf("(%s) cli_session_setup_creds failed: %s\n",
10519 __location__, nt_errstr(status));
10520 return false;
10521 }
10522
10523 d_printf("\r%d ", (int)cli_state_get_uid(c));
10524
10525 status = cli_ulogoff(c);
10526 if (!NT_STATUS_IS_OK(status)) {
10527 d_printf("(%s) cli_ulogoff failed: %s\n",
10528 __location__, nt_errstr(status));
10529 return false;
10530 }
10531 }
10532
10533 return true;
10534 }
10535
10536 static bool subst_test(const char *str, const char *user, const char *domain,
10537 uid_t uid, gid_t gid, const char *expected)
10538 {
10539 char *subst;
10540 bool result = true;
10541
10542 subst = talloc_sub_specified(talloc_tos(), str, user, NULL, domain, uid, gid);
10543
10544 if (strcmp(subst, expected) != 0) {
10545 printf("sub_specified(%s, %s, %s, %d, %d) returned [%s], expected "
10546 "[%s]\n", str, user, domain, (int)uid, (int)gid, subst,
10547 expected);
10548 result = false;
10549 }
10550
10551 TALLOC_FREE(subst);
10552 return result;
10553 }
10554
10555 static void chain1_open_completion(struct tevent_req *req)
10556 {
10557 uint16_t fnum;
10558 NTSTATUS status;
10559 status = cli_openx_recv(req, &fnum);
10560 TALLOC_FREE(req);
10561
10562 d_printf("cli_openx_recv returned %s: %d\n",
10563 nt_errstr(status),
10564 NT_STATUS_IS_OK(status) ? fnum : -1);
10565 }
10566
10567 static void chain1_write_completion(struct tevent_req *req)
10568 {
10569 size_t written;
10570 NTSTATUS status;
10571 status = cli_write_andx_recv(req, &written);
10572 TALLOC_FREE(req);
10573
10574 d_printf("cli_write_andx_recv returned %s: %d\n",
10575 nt_errstr(status),
10576 NT_STATUS_IS_OK(status) ? (int)written : -1);
10577 }
10578
10579 static void chain1_close_completion(struct tevent_req *req)
10580 {
10581 NTSTATUS status;
10582 bool *done = (bool *)tevent_req_callback_data_void(req);
10583
10584 status = cli_close_recv(req);
10585 *done = true;
10586
10587 TALLOC_FREE(req);
10588
10589 d_printf("cli_close returned %s\n", nt_errstr(status));
10590 }
10591
10592 static bool run_chain1(int dummy)
10593 {
10594 struct cli_state *cli1;
10595 struct tevent_context *evt = samba_tevent_context_init(NULL);
10596 struct tevent_req *reqs[3], *smbreqs[3];
10597 bool done = false;
10598 const char *str = "foobar";
10599 const char *fname = "\\test_chain";
10600 NTSTATUS status;
10601
10602 printf("starting chain1 test\n");
10603 if (!torture_open_connection(&cli1, 0)) {
10604 return False;
10605 }
10606
10607 smbXcli_conn_set_sockopt(cli1->conn, sockops);
10608
10609 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
10610
10611 reqs[0] = cli_openx_create(talloc_tos(), evt, cli1, fname,
10612 O_CREAT|O_RDWR, 0, &smbreqs[0]);
10613 if (reqs[0] == NULL) return false;
10614 tevent_req_set_callback(reqs[0], chain1_open_completion, NULL);
10615
10616
10617 reqs[1] = cli_write_andx_create(talloc_tos(), evt, cli1, 0, 0,
10618 (const uint8_t *)str, 0, strlen(str)+1,
10619 smbreqs, 1, &smbreqs[1]);
10620 if (reqs[1] == NULL) return false;
10621 tevent_req_set_callback(reqs[1], chain1_write_completion, NULL);
10622
10623 reqs[2] = cli_smb1_close_create(talloc_tos(), evt, cli1, 0, &smbreqs[2]);
10624 if (reqs[2] == NULL) return false;
10625 tevent_req_set_callback(reqs[2], chain1_close_completion, &done);
10626
10627 status = smb1cli_req_chain_submit(smbreqs, ARRAY_SIZE(smbreqs));
10628 if (!NT_STATUS_IS_OK(status)) {
10629 return false;
10630 }
10631
10632 while (!done) {
10633 tevent_loop_once(evt);
10634 }
10635
10636 torture_close_connection(cli1);
10637 return True;
10638 }
10639
10640 static void chain2_sesssetup_completion(struct tevent_req *req)
10641 {
10642 NTSTATUS status;
10643 status = cli_session_setup_guest_recv(req);
10644 d_printf("sesssetup returned %s\n", nt_errstr(status));
10645 }
10646
10647 static void chain2_tcon_completion(struct tevent_req *req)
10648 {
10649 bool *done = (bool *)tevent_req_callback_data_void(req);
10650 NTSTATUS status;
10651 status = cli_tcon_andx_recv(req);
10652 d_printf("tcon_and_x returned %s\n", nt_errstr(status));
10653 *done = true;
10654 }
10655
10656 static bool run_chain2(int dummy)
10657 {
10658 struct cli_state *cli1;
10659 struct tevent_context *evt = samba_tevent_context_init(NULL);
10660 struct tevent_req *reqs[2], *smbreqs[2];
10661 bool done = false;
10662 NTSTATUS status;
10663 int flags = CLI_FULL_CONNECTION_FORCE_SMB1;
10664
10665 printf("starting chain2 test\n");
10666 status = cli_start_connection(talloc_tos(),
10667 &cli1,
10668 lp_netbios_name(),
10669 host,
10670 NULL,
10671 port_to_use,
10672 SMB_SIGNING_DEFAULT,
10673 flags);
10674 if (!NT_STATUS_IS_OK(status)) {
10675 return False;
10676 }
10677
10678 smbXcli_conn_set_sockopt(cli1->conn, sockops);
10679
10680 reqs[0] = cli_session_setup_guest_create(talloc_tos(), evt, cli1,
10681 &smbreqs[0]);
10682 if (reqs[0] == NULL) return false;
10683 tevent_req_set_callback(reqs[0], chain2_sesssetup_completion, NULL);
10684
10685 reqs[1] = cli_tcon_andx_create(talloc_tos(), evt, cli1, "IPC$",
10686 "?????", NULL, 0, &smbreqs[1]);
10687 if (reqs[1] == NULL) return false;
10688 tevent_req_set_callback(reqs[1], chain2_tcon_completion, &done);
10689
10690 status = smb1cli_req_chain_submit(smbreqs, ARRAY_SIZE(smbreqs));
10691 if (!NT_STATUS_IS_OK(status)) {
10692 return false;
10693 }
10694
10695 while (!done) {
10696 tevent_loop_once(evt);
10697 }
10698
10699 torture_close_connection(cli1);
10700 return True;
10701 }
10702
10703
10704 struct torture_createdel_state {
10705 struct tevent_context *ev;
10706 struct cli_state *cli;
10707 };
10708
10709 static void torture_createdel_created(struct tevent_req *subreq);
10710 static void torture_createdel_closed(struct tevent_req *subreq);
10711
10712 static struct tevent_req *torture_createdel_send(TALLOC_CTX *mem_ctx,
10713 struct tevent_context *ev,
10714 struct cli_state *cli,
10715 const char *name)
10716 {
10717 struct tevent_req *req, *subreq;
10718 struct torture_createdel_state *state;
10719
10720 req = tevent_req_create(mem_ctx, &state,
10721 struct torture_createdel_state);
10722 if (req == NULL) {
10723 return NULL;
10724 }
10725 state->ev = ev;
10726 state->cli = cli;
10727
10728 subreq = cli_ntcreate_send(
10729 state, ev, cli, name, 0,
10730 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
10731 FILE_ATTRIBUTE_NORMAL,
10732 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
10733 FILE_OPEN_IF, FILE_DELETE_ON_CLOSE,
10734 SMB2_IMPERSONATION_IMPERSONATION, 0);
10735
10736 if (tevent_req_nomem(subreq, req)) {
10737 return tevent_req_post(req, ev);
10738 }
10739 tevent_req_set_callback(subreq, torture_createdel_created, req);
10740 return req;
10741 }
10742
10743 static void torture_createdel_created(struct tevent_req *subreq)
10744 {
10745 struct tevent_req *req = tevent_req_callback_data(
10746 subreq, struct tevent_req);
10747 struct torture_createdel_state *state = tevent_req_data(
10748 req, struct torture_createdel_state);
10749 NTSTATUS status;
10750 uint16_t fnum;
10751
10752 status = cli_ntcreate_recv(subreq, &fnum, NULL);
10753 TALLOC_FREE(subreq);
10754 if (tevent_req_nterror(req, status)) {
10755 DEBUG(10, ("cli_ntcreate_recv returned %s\n",
10756 nt_errstr(status)));
10757 return;
10758 }
10759
10760 subreq = cli_close_send(state, state->ev, state->cli, fnum, 0);
10761 if (tevent_req_nomem(subreq, req)) {
10762 return;
10763 }
10764 tevent_req_set_callback(subreq, torture_createdel_closed, req);
10765 }
10766
10767 static void torture_createdel_closed(struct tevent_req *subreq)
10768 {
10769 struct tevent_req *req = tevent_req_callback_data(
10770 subreq, struct tevent_req);
10771 NTSTATUS status;
10772
10773 status = cli_close_recv(subreq);
10774 if (tevent_req_nterror(req, status)) {
10775 DEBUG(10, ("cli_close_recv returned %s\n", nt_errstr(status)));
10776 return;
10777 }
10778 tevent_req_done(req);
10779 }
10780
10781 static NTSTATUS torture_createdel_recv(struct tevent_req *req)
10782 {
10783 return tevent_req_simple_recv_ntstatus(req);
10784 }
10785
10786 struct torture_createdels_state {
10787 struct tevent_context *ev;
10788 struct cli_state *cli;
10789 const char *base_name;
10790 int sent;
10791 int received;
10792 int num_files;
10793 struct tevent_req **reqs;
10794 };
10795
10796 static void torture_createdels_done(struct tevent_req *subreq);
10797
10798 static struct tevent_req *torture_createdels_send(TALLOC_CTX *mem_ctx,
10799 struct tevent_context *ev,
10800 struct cli_state *cli,
10801 const char *base_name,
10802 int num_parallel,
10803 int num_files)
10804 {
10805 struct tevent_req *req;
10806 struct torture_createdels_state *state;
10807 int i;
10808
10809 req = tevent_req_create(mem_ctx, &state,
10810 struct torture_createdels_state);
10811 if (req == NULL) {
10812 return NULL;
10813 }
10814 state->ev = ev;
10815 state->cli = cli;
10816 state->base_name = talloc_strdup(state, base_name);
10817 if (tevent_req_nomem(state->base_name, req)) {
10818 return tevent_req_post(req, ev);
10819 }
10820 state->num_files = MAX(num_parallel, num_files);
10821 state->sent = 0;
10822 state->received = 0;
10823
10824 state->reqs = talloc_array(state, struct tevent_req *, num_parallel);
10825 if (tevent_req_nomem(state->reqs, req)) {
10826 return tevent_req_post(req, ev);
10827 }
10828
10829 for (i=0; i<num_parallel; i++) {
10830 char *name;
10831
10832 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
10833 state->sent);
10834 if (tevent_req_nomem(name, req)) {
10835 return tevent_req_post(req, ev);
10836 }
10837 state->reqs[i] = torture_createdel_send(
10838 state->reqs, state->ev, state->cli, name);
10839 if (tevent_req_nomem(state->reqs[i], req)) {
10840 return tevent_req_post(req, ev);
10841 }
10842 name = talloc_move(state->reqs[i], &name);
10843 tevent_req_set_callback(state->reqs[i],
10844 torture_createdels_done, req);
10845 state->sent += 1;
10846 }
10847 return req;
10848 }
10849
10850 static void torture_createdels_done(struct tevent_req *subreq)
10851 {
10852 struct tevent_req *req = tevent_req_callback_data(
10853 subreq, struct tevent_req);
10854 struct torture_createdels_state *state = tevent_req_data(
10855 req, struct torture_createdels_state);
10856 size_t i, num_parallel = talloc_array_length(state->reqs);
10857 NTSTATUS status;
10858 char *name;
10859
10860 status = torture_createdel_recv(subreq);
10861 if (!NT_STATUS_IS_OK(status)){
10862 DEBUG(10, ("torture_createdel_recv returned %s\n",
10863 nt_errstr(status)));
10864 TALLOC_FREE(subreq);
10865 tevent_req_nterror(req, status);
10866 return;
10867 }
10868
10869 for (i=0; i<num_parallel; i++) {
10870 if (subreq == state->reqs[i]) {
10871 break;
10872 }
10873 }
10874 if (i == num_parallel) {
10875 DEBUG(10, ("received something we did not send\n"));
10876 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
10877 return;
10878 }
10879 TALLOC_FREE(state->reqs[i]);
10880
10881 if (state->sent >= state->num_files) {
10882 tevent_req_done(req);
10883 return;
10884 }
10885
10886 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
10887 state->sent);
10888 if (tevent_req_nomem(name, req)) {
10889 return;
10890 }
10891 state->reqs[i] = torture_createdel_send(state->reqs, state->ev,
10892 state->cli, name);
10893 if (tevent_req_nomem(state->reqs[i], req)) {
10894 return;
10895 }
10896 name = talloc_move(state->reqs[i], &name);
10897 tevent_req_set_callback(state->reqs[i], torture_createdels_done, req);
10898 state->sent += 1;
10899 }
10900
10901 static NTSTATUS torture_createdels_recv(struct tevent_req *req)
10902 {
10903 return tevent_req_simple_recv_ntstatus(req);
10904 }
10905
10906 struct swallow_notify_state {
10907 struct tevent_context *ev;
10908 struct cli_state *cli;
10909 uint16_t fnum;
10910 uint32_t completion_filter;
10911 bool recursive;
10912 bool (*fn)(uint32_t action, const char *name, void *priv);
10913 void *priv;
10914 };
10915
10916 static void swallow_notify_done(struct tevent_req *subreq);
10917
10918 static struct tevent_req *swallow_notify_send(TALLOC_CTX *mem_ctx,
10919 struct tevent_context *ev,
10920 struct cli_state *cli,
10921 uint16_t fnum,
10922 uint32_t completion_filter,
10923 bool recursive,
10924 bool (*fn)(uint32_t action,
10925 const char *name,
10926 void *priv),
10927 void *priv)
10928 {
10929 struct tevent_req *req, *subreq;
10930 struct swallow_notify_state *state;
10931
10932 req = tevent_req_create(mem_ctx, &state,
10933 struct swallow_notify_state);
10934 if (req == NULL) {
10935 return NULL;
10936 }
10937 state->ev = ev;
10938 state->cli = cli;
10939 state->fnum = fnum;
10940 state->completion_filter = completion_filter;
10941 state->recursive = recursive;
10942 state->fn = fn;
10943 state->priv = priv;
10944
10945 subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
10946 0xffff, state->completion_filter,
10947 state->recursive);
10948 if (tevent_req_nomem(subreq, req)) {
10949 return tevent_req_post(req, ev);
10950 }
10951 tevent_req_set_callback(subreq, swallow_notify_done, req);
10952 return req;
10953 }
10954
10955 static void swallow_notify_done(struct tevent_req *subreq)
10956 {
10957 struct tevent_req *req = tevent_req_callback_data(
10958 subreq, struct tevent_req);
10959 struct swallow_notify_state *state = tevent_req_data(
10960 req, struct swallow_notify_state);
10961 NTSTATUS status;
10962 uint32_t i, num_changes;
10963 struct notify_change *changes;
10964
10965 status = cli_notify_recv(subreq, state, &num_changes, &changes);
10966 TALLOC_FREE(subreq);
10967 if (!NT_STATUS_IS_OK(status)) {
10968 DEBUG(10, ("cli_notify_recv returned %s\n",
10969 nt_errstr(status)));
10970 tevent_req_nterror(req, status);
10971 return;
10972 }
10973
10974 for (i=0; i<num_changes; i++) {
10975 state->fn(changes[i].action, changes[i].name, state->priv);
10976 }
10977 TALLOC_FREE(changes);
10978
10979 subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
10980 0xffff, state->completion_filter,
10981 state->recursive);
10982 if (tevent_req_nomem(subreq, req)) {
10983 return;
10984 }
10985 tevent_req_set_callback(subreq, swallow_notify_done, req);
10986 }
10987
10988 static bool print_notifies(uint32_t action, const char *name, void *priv)
10989 {
10990 if (DEBUGLEVEL > 5) {
10991 d_printf("%d %s\n", (int)action, name);
10992 }
10993 return true;
10994 }
10995
10996 static void notify_bench_done(struct tevent_req *req)
10997 {
10998 int *num_finished = (int *)tevent_req_callback_data_void(req);
10999 *num_finished += 1;
11000 }
11001
11002 static bool run_notify_bench(int dummy)
11003 {
11004 const char *dname = "\\notify-bench";
11005 struct tevent_context *ev;
11006 NTSTATUS status;
11007 uint16_t dnum;
11008 struct tevent_req *req1;
11009 struct tevent_req *req2 = NULL;
11010 int i, num_unc_names;
11011 int num_finished = 0;
11012
11013 printf("starting notify-bench test\n");
11014
11015 if (use_multishare_conn) {
11016 char **unc_list;
11017 unc_list = file_lines_load(multishare_conn_fname,
11018 &num_unc_names, 0, NULL);
11019 if (!unc_list || num_unc_names <= 0) {
11020 d_printf("Failed to load unc names list from '%s'\n",
11021 multishare_conn_fname);
11022 return false;
11023 }
11024 TALLOC_FREE(unc_list);
11025 } else {
11026 num_unc_names = 1;
11027 }
11028
11029 ev = samba_tevent_context_init(talloc_tos());
11030 if (ev == NULL) {
11031 d_printf("tevent_context_init failed\n");
11032 return false;
11033 }
11034
11035 for (i=0; i<num_unc_names; i++) {
11036 struct cli_state *cli;
11037 char *base_fname;
11038
11039 base_fname = talloc_asprintf(talloc_tos(), "%s\\file%3.3d.",
11040 dname, i);
11041 if (base_fname == NULL) {
11042 return false;
11043 }
11044
11045 if (!torture_open_connection(&cli, i)) {
11046 return false;
11047 }
11048
11049 status = cli_ntcreate(cli, dname, 0,
11050 MAXIMUM_ALLOWED_ACCESS,
11051 0, FILE_SHARE_READ|FILE_SHARE_WRITE|
11052 FILE_SHARE_DELETE,
11053 FILE_OPEN_IF, FILE_DIRECTORY_FILE, 0,
11054 &dnum, NULL);
11055
11056 if (!NT_STATUS_IS_OK(status)) {
11057 d_printf("Could not create %s: %s\n", dname,
11058 nt_errstr(status));
11059 return false;
11060 }
11061
11062 req1 = swallow_notify_send(talloc_tos(), ev, cli, dnum,
11063 FILE_NOTIFY_CHANGE_FILE_NAME |
11064 FILE_NOTIFY_CHANGE_DIR_NAME |
11065 FILE_NOTIFY_CHANGE_ATTRIBUTES |
11066 FILE_NOTIFY_CHANGE_LAST_WRITE,
11067 false, print_notifies, NULL);
11068 if (req1 == NULL) {
11069 d_printf("Could not create notify request\n");
11070 return false;
11071 }
11072
11073 req2 = torture_createdels_send(talloc_tos(), ev, cli,
11074 base_fname, 10, torture_numops);
11075 if (req2 == NULL) {
11076 d_printf("Could not create createdels request\n");
11077 return false;
11078 }
11079 TALLOC_FREE(base_fname);
11080
11081 tevent_req_set_callback(req2, notify_bench_done,
11082 &num_finished);
11083 }
11084
11085 while (num_finished < num_unc_names) {
11086 int ret;
11087 ret = tevent_loop_once(ev);
11088 if (ret != 0) {
11089 d_printf("tevent_loop_once failed\n");
11090 return false;
11091 }
11092 }
11093
11094 if (!tevent_req_poll(req2, ev)) {
11095 d_printf("tevent_req_poll failed\n");
11096 }
11097
11098 status = torture_createdels_recv(req2);
11099 d_printf("torture_createdels_recv returned %s\n", nt_errstr(status));
11100
11101 return true;
11102 }
11103
11104 static bool run_mangle1(int dummy)
11105 {
11106 struct cli_state *cli;
11107 const char *fname = "this_is_a_long_fname_to_be_mangled.txt";
11108 uint16_t fnum;
11109 fstring alt_name;
11110 NTSTATUS status;
11111
11112 printf("starting mangle1 test\n");
11113 if (!torture_open_connection(&cli, 0)) {
11114 return False;
11115 }
11116
11117 smbXcli_conn_set_sockopt(cli->conn, sockops);
11118
11119 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
11120 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
11121 0, 0, &fnum, NULL);
11122 if (!NT_STATUS_IS_OK(status)) {
11123 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
11124 return false;
11125 }
11126 cli_close(cli, fnum);
11127
11128 status = cli_qpathinfo_alt_name(cli, fname, alt_name);
11129 if (!NT_STATUS_IS_OK(status)) {
11130 d_printf("cli_qpathinfo_alt_name failed: %s\n",
11131 nt_errstr(status));
11132 return false;
11133 }
11134 d_printf("alt_name: %s\n", alt_name);
11135
11136 status = cli_openx(cli, alt_name, O_RDONLY, DENY_NONE, &fnum);
11137 if (!NT_STATUS_IS_OK(status)) {
11138 d_printf("cli_openx(%s) failed: %s\n", alt_name,
11139 nt_errstr(status));
11140 return false;
11141 }
11142 cli_close(cli, fnum);
11143
11144 status = cli_qpathinfo1(cli, alt_name, NULL, NULL, NULL, NULL, NULL);
11145 if (!NT_STATUS_IS_OK(status)) {
11146 d_printf("cli_qpathinfo1(%s) failed: %s\n", alt_name,
11147 nt_errstr(status));
11148 return false;
11149 }
11150
11151 return true;
11152 }
11153
11154 static NTSTATUS mangle_illegal_list_shortname_fn(struct file_info *f,
11155 const char *mask,
11156 void *state)
11157 {
11158 if (f->short_name == NULL) {
11159 return NT_STATUS_OK;
11160 }
11161
11162 if (strlen(f->short_name) == 0) {
11163 return NT_STATUS_OK;
11164 }
11165
11166 printf("unexpected shortname: %s\n", f->short_name);
11167
11168 return NT_STATUS_OBJECT_NAME_INVALID;
11169 }
11170
11171 static NTSTATUS mangle_illegal_list_name_fn(struct file_info *f,
11172 const char *mask,
11173 void *state)
11174 {
11175 char *name = state;
11176
11177 printf("name: %s\n", f->name);
11178 fstrcpy(name, f->name);
11179 return NT_STATUS_OK;
11180 }
11181
11182 static bool run_mangle_illegal(int dummy)
11183 {
11184 struct cli_state *cli = NULL;
11185 struct cli_state *cli_posix = NULL;
11186 const char *fname = "\\MANGLE_ILLEGAL\\this_is_a_long_fname_to_be_mangled.txt";
11187 const char *illegal_fname = "MANGLE_ILLEGAL/foo:bar";
11188 char *mangled_path = NULL;
11189 uint16_t fnum;
11190 fstring name;
11191 fstring alt_name;
11192 NTSTATUS status;
11193
11194 printf("starting mangle-illegal test\n");
11195
11196 if (!torture_open_connection(&cli, 0)) {
11197 return False;
11198 }
11199
11200 smbXcli_conn_set_sockopt(cli->conn, sockops);
11201
11202 if (!torture_open_connection(&cli_posix, 0)) {
11203 return false;
11204 }
11205
11206 smbXcli_conn_set_sockopt(cli_posix->conn, sockops);
11207
11208 status = torture_setup_unix_extensions(cli_posix);
11209 if (!NT_STATUS_IS_OK(status)) {
11210 return false;
11211 }
11212
11213 cli_rmdir(cli, "\\MANGLE_ILLEGAL");
11214 status = cli_mkdir(cli, "\\MANGLE_ILLEGAL");
11215 if (!NT_STATUS_IS_OK(status)) {
11216 printf("mkdir1 failed : %s\n", nt_errstr(status));
11217 return False;
11218 }
11219
11220 /*
11221 * Create a file with illegal NTFS characters and test that we
11222 * get a usable mangled name
11223 */
11224
11225 cli_setatr(cli_posix, illegal_fname, 0, 0);
11226 cli_posix_unlink(cli_posix, illegal_fname);
11227
11228 status = cli_posix_open(cli_posix, illegal_fname, O_RDWR|O_CREAT|O_EXCL,
11229 0600, &fnum);
11230 if (!NT_STATUS_IS_OK(status)) {
11231 printf("POSIX create of %s failed (%s)\n",
11232 illegal_fname, nt_errstr(status));
11233 return false;
11234 }
11235
11236 status = cli_close(cli_posix, fnum);
11237 if (!NT_STATUS_IS_OK(status)) {
11238 printf("close failed (%s)\n", nt_errstr(status));
11239 return false;
11240 }
11241
11242 status = cli_list(cli, "\\MANGLE_ILLEGAL\\*", 0, mangle_illegal_list_name_fn, &name);
11243 if (!NT_STATUS_IS_OK(status)) {
11244 d_printf("cli_list failed: %s\n", nt_errstr(status));
11245 return false;
11246 }
11247
11248 mangled_path = talloc_asprintf(talloc_tos(), "\\MANGLE_ILLEGAL\\%s", name);
11249 if (mangled_path == NULL) {
11250 return false;
11251 }
11252
11253 status = cli_openx(cli, mangled_path, O_RDONLY, DENY_NONE, &fnum);
11254 if (!NT_STATUS_IS_OK(status)) {
11255 d_printf("cli_openx(%s) failed: %s\n", mangled_path, nt_errstr(status));
11256 TALLOC_FREE(mangled_path);
11257 return false;
11258 }
11259 TALLOC_FREE(mangled_path);
11260 cli_close(cli, fnum);
11261
11262 cli_setatr(cli_posix, illegal_fname, 0, 0);
11263 cli_posix_unlink(cli_posix, illegal_fname);
11264
11265 /*
11266 * Create a file with a long name and check that we got *no* short name.
11267 */
11268
11269 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
11270 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
11271 0, 0, &fnum, NULL);
11272 if (!NT_STATUS_IS_OK(status)) {
11273 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
11274 return false;
11275 }
11276 cli_close(cli, fnum);
11277
11278 status = cli_list(cli, fname, 0, mangle_illegal_list_shortname_fn, &alt_name);
11279 if (!NT_STATUS_IS_OK(status)) {
11280 d_printf("cli_list failed\n");
11281 return false;
11282 }
11283
11284 cli_unlink(cli, fname, 0);
11285 cli_rmdir(cli, "\\MANGLE_ILLEGAL");
11286
11287 if (!torture_close_connection(cli_posix)) {
11288 return false;
11289 }
11290
11291 if (!torture_close_connection(cli)) {
11292 return false;
11293 }
11294
11295 return true;
11296 }
11297
11298 static size_t null_source(uint8_t *buf, size_t n, void *priv)
11299 {
11300 size_t *to_pull = (size_t *)priv;
11301 size_t thistime = *to_pull;
11302
11303 thistime = MIN(thistime, n);
11304 if (thistime == 0) {
11305 return 0;
11306 }
11307
11308 memset(buf, 0, thistime);
11309 *to_pull -= thistime;
11310 return thistime;
11311 }
11312
11313 static bool run_windows_write(int dummy)
11314 {
11315 struct cli_state *cli1;
11316 uint16_t fnum;
11317 int i;
11318 bool ret = false;
11319 const char *fname = "\\writetest.txt";
11320 struct timeval start_time;
11321 double seconds;
11322 double kbytes;
11323 NTSTATUS status;
11324
11325 printf("starting windows_write test\n");
11326 if (!torture_open_connection(&cli1, 0)) {
11327 return False;
11328 }
11329
11330 status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
11331 if (!NT_STATUS_IS_OK(status)) {
11332 printf("open failed (%s)\n", nt_errstr(status));
11333 return False;
11334 }
11335
11336 smbXcli_conn_set_sockopt(cli1->conn, sockops);
11337
11338 start_time = timeval_current();
11339
11340 for (i=0; i<torture_numops; i++) {
11341 uint8_t c = 0;
11342 off_t start = i * torture_blocksize;
11343 size_t to_pull = torture_blocksize - 1;
11344
11345 status = cli_writeall(cli1, fnum, 0, &c,
11346 start + torture_blocksize - 1, 1, NULL);
11347 if (!NT_STATUS_IS_OK(status)) {
11348 printf("cli_write failed: %s\n", nt_errstr(status));
11349 goto fail;
11350 }
11351
11352 status = cli_push(cli1, fnum, 0, i * torture_blocksize, torture_blocksize,
11353 null_source, &to_pull);
11354 if (!NT_STATUS_IS_OK(status)) {
11355 printf("cli_push returned: %s\n", nt_errstr(status));
11356 goto fail;
11357 }
11358 }
11359
11360 seconds = timeval_elapsed(&start_time);
11361 kbytes = (double)torture_blocksize * torture_numops;
11362 kbytes /= 1024;
11363
11364 printf("Wrote %d kbytes in %.2f seconds: %d kb/sec\n", (int)kbytes,
11365 (double)seconds, (int)(kbytes/seconds));
11366
11367 ret = true;
11368 fail:
11369 cli_close(cli1, fnum);
11370 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
11371 torture_close_connection(cli1);
11372 return ret;
11373 }
11374
11375 static size_t calc_expected_return(struct cli_state *cli, size_t len_requested)
11376 {
11377 size_t max_pdu = 0x1FFFF;
11378
11379 if (cli->server_posix_capabilities & CIFS_UNIX_LARGE_READ_CAP) {
11380 max_pdu = 0xFFFFFF;
11381 }
11382
11383 if (smb1cli_conn_signing_is_active(cli->conn)) {
11384 max_pdu = 0x1FFFF;
11385 }
11386
11387 if (smb1cli_conn_encryption_on(cli->conn)) {
11388 max_pdu = CLI_BUFFER_SIZE;
11389 }
11390
11391 if ((len_requested & 0xFFFF0000) == 0xFFFF0000) {
11392 len_requested &= 0xFFFF;
11393 }
11394
11395 return MIN(len_requested,
11396 max_pdu - (MIN_SMB_SIZE + VWV(12) + 1 /* padding byte */));
11397 }
11398
11399 static bool check_read_call(struct cli_state *cli,
11400 uint16_t fnum,
11401 uint8_t *buf,
11402 size_t len_requested)
11403 {
11404 NTSTATUS status;
11405 struct tevent_req *subreq = NULL;
11406 ssize_t len_read = 0;
11407 size_t len_expected = 0;
11408 struct tevent_context *ev = NULL;
11409
11410 ev = samba_tevent_context_init(talloc_tos());
11411 if (ev == NULL) {
11412 return false;
11413 }
11414
11415 subreq = cli_read_andx_send(talloc_tos(),
11416 ev,
11417 cli,
11418 fnum,
11419 0,
11420 len_requested);
11421
11422 if (!tevent_req_poll_ntstatus(subreq, ev, &status)) {
11423 return false;
11424 }
11425
11426 status = cli_read_andx_recv(subreq, &len_read, &buf);
11427 if (!NT_STATUS_IS_OK(status)) {
11428 d_printf("cli_read_andx_recv failed: %s\n", nt_errstr(status));
11429 return false;
11430 }
11431
11432 TALLOC_FREE(subreq);
11433 TALLOC_FREE(ev);
11434
11435 len_expected = calc_expected_return(cli, len_requested);
11436
11437 if (len_expected > 0x10000 && len_read == 0x10000) {
11438 /* Windows servers only return a max of 0x10000,
11439 doesn't matter if you set CAP_LARGE_READX in
11440 the client sessionsetupX call or not. */
11441 d_printf("Windows server - returned 0x10000 on a read of 0x%x\n",
11442 (unsigned int)len_requested);
11443 } else if (len_read != len_expected) {
11444 d_printf("read of 0x%x failed: got 0x%x, expected 0x%x\n",
11445 (unsigned int)len_requested,
11446 (unsigned int)len_read,
11447 (unsigned int)len_expected);
11448 return false;
11449 } else {
11450 d_printf("Correct read reply.\n");
11451 }
11452
11453 return true;
11454 }
11455
11456 /* Test large readX variants. */
11457 static bool large_readx_tests(struct cli_state *cli,
11458 uint16_t fnum,
11459 uint8_t *buf)
11460 {
11461 /* A read of 0xFFFF0001 should *always* return 1 byte. */
11462 if (check_read_call(cli, fnum, buf, 0xFFFF0001) == false) {
11463 return false;
11464 }
11465 /* A read of 0x10000 should return 0x10000 bytes. */
11466 if (check_read_call(cli, fnum, buf, 0x10000) == false) {
11467 return false;
11468 }
11469 /* A read of 0x10000 should return 0x10001 bytes. */
11470 if (check_read_call(cli, fnum, buf, 0x10001) == false) {
11471 return false;
11472 }
11473 /* A read of 0x1FFFF - (MIN_SMB_SIZE + VWV(12) should return
11474 the requested number of bytes. */
11475 if (check_read_call(cli, fnum, buf, 0x1FFFF - (MIN_SMB_SIZE + VWV(12))) == false) {
11476 return false;
11477 }
11478 /* A read of 1MB should return 1MB bytes (on Samba). */
11479 if (check_read_call(cli, fnum, buf, 0x100000) == false) {
11480 return false;
11481 }
11482
11483 if (check_read_call(cli, fnum, buf, 0x20001) == false) {
11484 return false;
11485 }
11486 if (check_read_call(cli, fnum, buf, 0x22000001) == false) {
11487 return false;
11488 }
11489 if (check_read_call(cli, fnum, buf, 0xFFFE0001) == false) {
11490 return false;
11491 }
11492 return true;
11493 }
11494
11495 static bool run_large_readx(int dummy)
11496 {
11497 uint8_t *buf = NULL;
11498 struct cli_state *cli1 = NULL;
11499 struct cli_state *cli2 = NULL;
11500 bool correct = false;
11501 const char *fname = "\\large_readx.dat";
11502 NTSTATUS status;
11503 uint16_t fnum1 = UINT16_MAX;
11504 uint32_t normal_caps = 0;
11505 size_t file_size = 20*1024*1024;
11506 TALLOC_CTX *frame = talloc_stackframe();
11507 size_t i;
11508 struct {
11509 const char *name;
11510 enum smb_signing_setting signing_setting;
11511 enum protocol_types protocol;
11512 } runs[] = {
11513 {
11514 .name = "NT1",
11515 .signing_setting = SMB_SIGNING_IF_REQUIRED,
11516 .protocol = PROTOCOL_NT1,
11517 },{
11518 .name = "NT1 - SIGNING_REQUIRED",
11519 .signing_setting = SMB_SIGNING_REQUIRED,
11520 .protocol = PROTOCOL_NT1,
11521 },
11522 };
11523
11524 printf("starting large_readx test\n");
11525
11526 if (!torture_open_connection(&cli1, 0)) {
11527 goto out;
11528 }
11529
11530 normal_caps = smb1cli_conn_capabilities(cli1->conn);
11531
11532 if (!(normal_caps & CAP_LARGE_READX)) {
11533 d_printf("Server doesn't have CAP_LARGE_READX 0x%x\n",
11534 (unsigned int)normal_caps);
11535 goto out;
11536 }
11537
11538 /* Create a file of size 4MB. */
11539 status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
11540 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
11541 0, 0, &fnum1, NULL);
11542
11543 if (!NT_STATUS_IS_OK(status)) {
11544 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
11545 goto out;
11546 }
11547
11548 /* Write file_size bytes. */
11549 buf = talloc_zero_array(frame, uint8_t, file_size);
11550 if (buf == NULL) {
11551 goto out;
11552 }
11553
11554 status = cli_writeall(cli1,
11555 fnum1,
11556 0,
11557 buf,
11558 0,
11559 file_size,
11560 NULL);
11561 if (!NT_STATUS_IS_OK(status)) {
11562 d_printf("cli_writeall failed: %s\n", nt_errstr(status));
11563 goto out;
11564 }
11565
11566 status = cli_close(cli1, fnum1);
11567 if (!NT_STATUS_IS_OK(status)) {
11568 d_printf("cli_close failed: %s\n", nt_errstr(status));
11569 goto out;
11570 }
11571
11572 fnum1 = UINT16_MAX;
11573
11574 for (i=0; i < ARRAY_SIZE(runs); i++) {
11575 enum smb_signing_setting saved_signing_setting = signing_state;
11576 uint16_t fnum2 = -1;
11577
11578 if (do_encrypt &&
11579 (runs[i].signing_setting == SMB_SIGNING_REQUIRED))
11580 {
11581 d_printf("skip[%u] - %s\n", (unsigned)i, runs[i].name);
11582 continue;
11583 }
11584
11585 d_printf("run[%u] - %s\n", (unsigned)i, runs[i].name);
11586
11587 signing_state = runs[i].signing_setting;
11588 cli2 = open_nbt_connection();
11589 signing_state = saved_signing_setting;
11590 if (cli2 == NULL) {
11591 goto out;
11592 }
11593
11594 status = smbXcli_negprot(cli2->conn,
11595 cli2->timeout,
11596 runs[i].protocol,
11597 runs[i].protocol,
11598 NULL,
11599 NULL,
11600 NULL);
11601 if (!NT_STATUS_IS_OK(status)) {
11602 goto out;
11603 }
11604
11605 status = cli_session_setup_creds(cli2, torture_creds);
11606 if (!NT_STATUS_IS_OK(status)) {
11607 goto out;
11608 }
11609
11610 status = cli_tree_connect(cli2,
11611 share,
11612 "?????",
11613 password);
11614 if (!NT_STATUS_IS_OK(status)) {
11615 goto out;
11616 }
11617
11618 cli_set_timeout(cli2, 120000); /* set a really long timeout (2 minutes) */
11619
11620 normal_caps = smb1cli_conn_capabilities(cli2->conn);
11621
11622 if (!(normal_caps & CAP_LARGE_READX)) {
11623 d_printf("Server doesn't have CAP_LARGE_READX 0x%x\n",
11624 (unsigned int)normal_caps);
11625 goto out;
11626 }
11627
11628 if (do_encrypt) {
11629 if (force_cli_encryption(cli2, share) == false) {
11630 goto out;
11631 }
11632 } else if (SERVER_HAS_UNIX_CIFS(cli2)) {
11633 uint16_t major, minor;
11634 uint32_t caplow, caphigh;
11635
11636 status = cli_unix_extensions_version(cli2,
11637 &major, &minor,
11638 &caplow, &caphigh);
11639 if (!NT_STATUS_IS_OK(status)) {
11640 goto out;
11641 }
11642 }
11643
11644 status = cli_ntcreate(cli2, fname, 0, FILE_READ_DATA,
11645 FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN,
11646 0, 0, &fnum2, NULL);
11647 if (!NT_STATUS_IS_OK(status)) {
11648 d_printf("Second open %s failed: %s\n", fname, nt_errstr(status));
11649 goto out;
11650 }
11651
11652 /* All reads must return less than file_size bytes. */
11653 if (!large_readx_tests(cli2, fnum2, buf)) {
11654 goto out;
11655 }
11656
11657 status = cli_close(cli2, fnum2);
11658 if (!NT_STATUS_IS_OK(status)) {
11659 d_printf("cli_close failed: %s\n", nt_errstr(status));
11660 goto out;
11661 }
11662 fnum2 = -1;
11663
11664 if (!torture_close_connection(cli2)) {
11665 goto out;
11666 }
11667 cli2 = NULL;
11668 }
11669
11670 correct = true;
11671 printf("Success on large_readx test\n");
11672
11673 out:
11674
11675 if (cli2) {
11676 if (!torture_close_connection(cli2)) {
11677 correct = false;
11678 }
11679 }
11680
11681 if (cli1) {
11682 if (fnum1 != UINT16_MAX) {
11683 status = cli_close(cli1, fnum1);
11684 if (!NT_STATUS_IS_OK(status)) {
11685 d_printf("cli_close failed: %s\n", nt_errstr(status));
11686 }
11687 fnum1 = UINT16_MAX;
11688 }
11689
11690 status = cli_unlink(cli1, fname,
11691 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
11692 if (!NT_STATUS_IS_OK(status)) {
11693 printf("unlink failed (%s)\n", nt_errstr(status));
11694 }
11695
11696 if (!torture_close_connection(cli1)) {
11697 correct = false;
11698 }
11699 }
11700
11701 TALLOC_FREE(frame);
11702
11703 printf("finished large_readx test\n");
11704 return correct;
11705 }
11706
11707 static NTSTATUS msdfs_attribute_list_fn(struct file_info *finfo,
11708 const char *mask,
11709 void *private_data)
11710 {
11711 uint32_t *p_attr = (uint32_t *)private_data;
11712
11713 if (strequal(finfo->name, test_filename)) {
11714 *p_attr = finfo->attr;
11715 }
11716
11717 return NT_STATUS_OK;
11718 }
11719
11720 static bool run_msdfs_attribute(int dummy)
11721 {
11722 static struct cli_state *cli;
11723 bool correct = false;
11724 uint32_t attr = 0;
11725 NTSTATUS status;
11726
11727 printf("Starting MSDFS-ATTRIBUTE test\n");
11728
11729 if (test_filename == NULL || test_filename[0] == '\0') {
11730 printf("MSDFS-ATTRIBUTE test "
11731 "needs -f filename-of-msdfs-link\n");
11732 return false;
11733 }
11734
11735 /*
11736 * NB. We use torture_open_connection_flags() not
11737 * torture_open_connection() as the latter forces
11738 * SMB1.
11739 */
11740 if (!torture_open_connection_flags(&cli, 0, 0)) {
11741 return false;
11742 }
11743
11744 smbXcli_conn_set_sockopt(cli->conn, sockops);
11745
11746 status = cli_list(cli,
11747 "*",
11748 FILE_ATTRIBUTE_DIRECTORY,
11749 msdfs_attribute_list_fn,
11750 &attr);
11751
11752 if (!NT_STATUS_IS_OK(status)) {
11753 printf("cli_list failed with %s\n",
11754 nt_errstr(status));
11755 goto out;
11756 }
11757 if ((attr & FILE_ATTRIBUTE_REPARSE_POINT) == 0) {
11758 printf("file %s should have "
11759 "FILE_ATTRIBUTE_REPARSE_POINT set. attr = 0x%x\n",
11760 test_filename,
11761 (unsigned int)attr);
11762 goto out;
11763 }
11764
11765 if ((attr & FILE_ATTRIBUTE_DIRECTORY) == 0) {
11766 printf("file %s should have "
11767 "FILE_ATTRIBUTE_DIRECTORY set. attr = 0x%x\n",
11768 test_filename,
11769 (unsigned int)attr);
11770 goto out;
11771 }
11772
11773 correct = true;
11774
11775 out:
11776
11777 torture_close_connection(cli);
11778 return correct;
11779 }
11780
11781 static bool run_cli_echo(int dummy)
11782 {
11783 struct cli_state *cli;
11784 NTSTATUS status;
11785
11786 printf("starting cli_echo test\n");
11787 if (!torture_open_connection(&cli, 0)) {
11788 return false;
11789 }
11790 smbXcli_conn_set_sockopt(cli->conn, sockops);
11791
11792 status = cli_echo(cli, 5, data_blob_const("hello", 5));
11793
11794 d_printf("cli_echo returned %s\n", nt_errstr(status));
11795
11796 torture_close_connection(cli);
11797 return NT_STATUS_IS_OK(status);
11798 }
11799
11800 static int splice_status(off_t written, void *priv)
11801 {
11802 return true;
11803 }
11804
11805 static bool run_cli_splice(int dummy)
11806 {
11807 uint8_t *buf = NULL;
11808 struct cli_state *cli1 = NULL;
11809 bool correct = false;
11810 const char *fname_src = "\\splice_src.dat";
11811 const char *fname_dst = "\\splice_dst.dat";
11812 NTSTATUS status;
11813 uint16_t fnum1 = UINT16_MAX;
11814 uint16_t fnum2 = UINT16_MAX;
11815 size_t file_size = 2*1024*1024;
11816 size_t splice_size = 1*1024*1024 + 713;
11817 uint8_t digest1[16], digest2[16];
11818 off_t written = 0;
11819 size_t nread = 0;
11820 TALLOC_CTX *frame = talloc_stackframe();
11821
11822 printf("starting cli_splice test\n");
11823
11824 if (!torture_open_connection(&cli1, 0)) {
11825 goto out;
11826 }
11827
11828 cli_unlink(cli1, fname_src,
11829 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
11830 cli_unlink(cli1, fname_dst,
11831 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
11832
11833 /* Create a file */
11834 status = cli_ntcreate(cli1, fname_src, 0, GENERIC_ALL_ACCESS,
11835 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
11836 0, 0, &fnum1, NULL);
11837
11838 if (!NT_STATUS_IS_OK(status)) {
11839 d_printf("open %s failed: %s\n", fname_src, nt_errstr(status));
11840 goto out;
11841 }
11842
11843 /* Write file_size bytes - must be bigger than splice_size. */
11844 buf = talloc_zero_array(frame, uint8_t, file_size);
11845 if (buf == NULL) {
11846 d_printf("talloc_fail\n");
11847 goto out;
11848 }
11849
11850 /* Fill it with random numbers. */
11851 generate_random_buffer(buf, file_size);
11852
11853 /* MD5 the first 1MB + 713 bytes. */
11854 gnutls_hash_fast(GNUTLS_DIG_MD5,
11855 buf,
11856 splice_size,
11857 digest1);
11858
11859 status = cli_writeall(cli1,
11860 fnum1,
11861 0,
11862 buf,
11863 0,
11864 file_size,
11865 NULL);
11866 if (!NT_STATUS_IS_OK(status)) {
11867 d_printf("cli_writeall failed: %s\n", nt_errstr(status));
11868 goto out;
11869 }
11870
11871 status = cli_ntcreate(cli1, fname_dst, 0, GENERIC_ALL_ACCESS,
11872 FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
11873 0, 0, &fnum2, NULL);
11874
11875 if (!NT_STATUS_IS_OK(status)) {
11876 d_printf("open %s failed: %s\n", fname_dst, nt_errstr(status));
11877 goto out;
11878 }
11879
11880 /* Now splice 1MB + 713 bytes. */
11881 status = cli_splice(cli1,
11882 cli1,
11883 fnum1,
11884 fnum2,
11885 splice_size,
11886 0,
11887 0,
11888 &written,
11889 splice_status,
11890 NULL);
11891
11892 if (!NT_STATUS_IS_OK(status)) {
11893 d_printf("cli_splice failed: %s\n", nt_errstr(status));
11894 goto out;
11895 }
11896
11897 /* Clear the old buffer. */
11898 memset(buf, '\0', file_size);
11899
11900 /* Read the new file. */
11901 status = cli_read(cli1, fnum2, (char *)buf, 0, splice_size, &nread);
11902 if (!NT_STATUS_IS_OK(status)) {
11903 d_printf("cli_read failed: %s\n", nt_errstr(status));
11904 goto out;
11905 }
11906 if (nread != splice_size) {
11907 d_printf("bad read of 0x%x, should be 0x%x\n",
11908 (unsigned int)nread,
11909 (unsigned int)splice_size);
11910 goto out;
11911 }
11912
11913 /* MD5 the first 1MB + 713 bytes. */
11914 gnutls_hash_fast(GNUTLS_DIG_MD5,
11915 buf,
11916 splice_size,
11917 digest2);
11918
11919 /* Must be the same. */
11920 if (memcmp(digest1, digest2, 16) != 0) {
11921 d_printf("bad MD5 compare\n");
11922 goto out;
11923 }
11924
11925 correct = true;
11926 printf("Success on cli_splice test\n");
11927
11928 out:
11929
11930 if (cli1) {
11931 if (fnum1 != UINT16_MAX) {
11932 cli_close(cli1, fnum1);
11933 }
11934 if (fnum2 != UINT16_MAX) {
11935 cli_close(cli1, fnum2);
11936 }
11937
11938 cli_unlink(cli1, fname_src,
11939 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
11940 cli_unlink(cli1, fname_dst,
11941 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
11942
11943 if (!torture_close_connection(cli1)) {
11944 correct = false;
11945 }
11946 }
11947
11948 TALLOC_FREE(frame);
11949 return correct;
11950 }
11951
11952 static bool run_uid_regression_test(int dummy)
11953 {
11954 static struct cli_state *cli;
11955 int16_t old_vuid;
11956 int32_t old_cnum;
11957 bool correct = True;
11958 struct smbXcli_tcon *tcon_copy = NULL;
11959 NTSTATUS status;
11960
11961 printf("starting uid regression test\n");
11962
11963 if (!torture_open_connection(&cli, 0)) {
11964 return False;
11965 }
11966
11967 smbXcli_conn_set_sockopt(cli->conn, sockops);
11968
11969 /* Ok - now save then logoff our current user. */
11970 old_vuid = cli_state_get_uid(cli);
11971
11972 status = cli_ulogoff(cli);
11973 if (!NT_STATUS_IS_OK(status)) {
11974 d_printf("(%s) cli_ulogoff failed: %s\n",
11975 __location__, nt_errstr(status));
11976 correct = false;
11977 goto out;
11978 }
11979
11980 cli_state_set_uid(cli, old_vuid);
11981
11982 /* Try an operation. */
11983 status = cli_mkdir(cli, "\\uid_reg_test");
11984 if (NT_STATUS_IS_OK(status)) {
11985 d_printf("(%s) cli_mkdir succeeded\n",
11986 __location__);
11987 correct = false;
11988 goto out;
11989 } else {
11990 /* Should be bad uid. */
11991 if (!check_error(__LINE__, status, ERRSRV, ERRbaduid,
11992 NT_STATUS_USER_SESSION_DELETED)) {
11993 correct = false;
11994 goto out;
11995 }
11996 }
11997
11998 old_cnum = cli_state_get_tid(cli);
11999 /*
12000 * This is an SMB1-only test.
12001 * Copy the tcon, not "save/restore".
12002 *
12003 * In SMB1 the cli_tdis() below frees
12004 * cli->smb1.tcon so we need a copy
12005 * of the struct to put back for the
12006 * second tdis call with invalid vuid.
12007 *
12008 * This is a test-only hack. Real client code
12009 * uses cli_state_save_tcon_share()/cli_state_restore_tcon_share().
12010 */
12011 tcon_copy = smbXcli_tcon_copy(cli, cli->smb1.tcon);
12012 if (tcon_copy == NULL) {
12013 correct = false;
12014 goto out;
12015 }
12016
12017 /* Now try a SMBtdis with the invalid vuid set to zero. */
12018 cli_state_set_uid(cli, 0);
12019
12020 /* This should succeed. */
12021 status = cli_tdis(cli);
12022
12023 if (NT_STATUS_IS_OK(status)) {
12024 d_printf("First tdis with invalid vuid should succeed.\n");
12025 } else {
12026 d_printf("First tdis failed (%s)\n", nt_errstr(status));
12027 correct = false;
12028 cli->smb1.tcon = tcon_copy;
12029 goto out;
12030 }
12031
12032 cli->smb1.tcon = tcon_copy;
12033 cli_state_set_uid(cli, old_vuid);
12034 cli_state_set_tid(cli, old_cnum);
12035
12036 /* This should fail. */
12037 status = cli_tdis(cli);
12038 if (NT_STATUS_IS_OK(status)) {
12039 d_printf("Second tdis with invalid vuid should fail - succeeded instead !.\n");
12040 correct = false;
12041 goto out;
12042 } else {
12043 /* Should be bad tid. */
12044 if (!check_error(__LINE__, status, ERRSRV, ERRinvnid,
12045 NT_STATUS_NETWORK_NAME_DELETED)) {
12046 correct = false;
12047 goto out;
12048 }
12049 }
12050
12051 cli_rmdir(cli, "\\uid_reg_test");
12052
12053 out:
12054
12055 cli_shutdown(cli);
12056 return correct;
12057 }
12058
12059
12060 static const char *illegal_chars = "*\\/?<>|\":";
12061 static char force_shortname_chars[] = " +,.[];=\177";
12062
12063 static NTSTATUS shortname_del_fn(struct file_info *finfo,
12064 const char *mask, void *state)
12065 {
12066 struct cli_state *pcli = (struct cli_state *)state;
12067 fstring fname;
12068 NTSTATUS status = NT_STATUS_OK;
12069
12070 slprintf(fname, sizeof(fname), "\\shortname\\%s", finfo->name);
12071
12072 if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
12073 return NT_STATUS_OK;
12074
12075 if (finfo->attr & FILE_ATTRIBUTE_DIRECTORY) {
12076 status = cli_rmdir(pcli, fname);
12077 if (!NT_STATUS_IS_OK(status)) {
12078 printf("del_fn: failed to rmdir %s\n,", fname );
12079 }
12080 } else {
12081 status = cli_unlink(pcli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
12082 if (!NT_STATUS_IS_OK(status)) {
12083 printf("del_fn: failed to unlink %s\n,", fname );
12084 }
12085 }
12086 return status;
12087 }
12088
12089 struct sn_state {
12090 int matched;
12091 int i;
12092 bool val;
12093 };
12094
12095 static NTSTATUS shortname_list_fn(struct file_info *finfo,
12096 const char *name, void *state)
12097 {
12098 struct sn_state *s = (struct sn_state *)state;
12099 int i = s->i;
12100
12101 #if 0
12102 printf("shortname list: i = %d, name = |%s|, shortname = |%s|\n",
12103 i, finfo->name, finfo->short_name);
12104 #endif
12105
12106 if (strchr(force_shortname_chars, i)) {
12107 if (!finfo->short_name) {
12108 /* Shortname not created when it should be. */
12109 d_printf("(%s) ERROR: Shortname was not created for file %s containing %d\n",
12110 __location__, finfo->name, i);
12111 s->val = true;
12112 }
12113 } else if (finfo->short_name){
12114 /* Shortname created when it should not be. */
12115 d_printf("(%s) ERROR: Shortname %s was created for file %s\n",
12116 __location__, finfo->short_name, finfo->name);
12117 s->val = true;
12118 }
12119 s->matched += 1;
12120 return NT_STATUS_OK;
12121 }
12122
12123 static bool run_shortname_test(int dummy)
12124 {
12125 static struct cli_state *cli;
12126 bool correct = True;
12127 int i;
12128 struct sn_state s;
12129 char fname[40];
12130 NTSTATUS status;
12131
12132 printf("starting shortname test\n");
12133
12134 if (!torture_open_connection(&cli, 0)) {
12135 return False;
12136 }
12137
12138 smbXcli_conn_set_sockopt(cli->conn, sockops);
12139
12140 cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
12141 cli_list(cli, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY, shortname_del_fn, cli);
12142 cli_rmdir(cli, "\\shortname");
12143
12144 status = cli_mkdir(cli, "\\shortname");
12145 if (!NT_STATUS_IS_OK(status)) {
12146 d_printf("(%s) cli_mkdir of \\shortname failed: %s\n",
12147 __location__, nt_errstr(status));
12148 correct = false;
12149 goto out;
12150 }
12151
12152 if (strlcpy(fname, "\\shortname\\", sizeof(fname)) >= sizeof(fname)) {
12153 correct = false;
12154 goto out;
12155 }
12156 if (strlcat(fname, "test .txt", sizeof(fname)) >= sizeof(fname)) {
12157 correct = false;
12158 goto out;
12159 }
12160
12161 s.val = false;
12162
12163 for (i = 32; i < 128; i++) {
12164 uint16_t fnum = (uint16_t)-1;
12165
12166 s.i = i;
12167
12168 if (strchr(illegal_chars, i)) {
12169 continue;
12170 }
12171 fname[15] = i;
12172
12173 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
12174 FILE_SHARE_READ|FILE_SHARE_WRITE,
12175 FILE_OVERWRITE_IF, 0, 0, &fnum, NULL);
12176 if (!NT_STATUS_IS_OK(status)) {
12177 d_printf("(%s) cli_nt_create of %s failed: %s\n",
12178 __location__, fname, nt_errstr(status));
12179 correct = false;
12180 goto out;
12181 }
12182 cli_close(cli, fnum);
12183
12184 s.matched = 0;
12185 status = cli_list(cli, "\\shortname\\test*.*", 0,
12186 shortname_list_fn, &s);
12187 if (s.matched != 1) {
12188 d_printf("(%s) failed to list %s: %s\n",
12189 __location__, fname, nt_errstr(status));
12190 correct = false;
12191 goto out;
12192 }
12193
12194 status = cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
12195 if (!NT_STATUS_IS_OK(status)) {
12196 d_printf("(%s) failed to delete %s: %s\n",
12197 __location__, fname, nt_errstr(status));
12198 correct = false;
12199 goto out;
12200 }
12201
12202 if (s.val) {
12203 correct = false;
12204 goto out;
12205 }
12206 }
12207
12208 out:
12209
12210 cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
12211 cli_list(cli, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY, shortname_del_fn, cli);
12212 cli_rmdir(cli, "\\shortname");
12213 torture_close_connection(cli);
12214 return correct;
12215 }
12216
12217 TLDAPRC callback_code;
12218
12219 static void pagedsearch_cb(struct tevent_req *req)
12220 {
12221 TLDAPRC rc;
12222 struct tldap_message *msg;
12223 char *dn;
12224
12225 rc = tldap_search_paged_recv(req, talloc_tos(), &msg);
12226 if (!TLDAP_RC_IS_SUCCESS(rc)) {
12227 d_printf("tldap_search_paged_recv failed: %s\n",
12228 tldap_rc2string(rc));
12229 callback_code = rc;
12230 return;
12231 }
12232 if (tldap_msg_type(msg) != TLDAP_RES_SEARCH_ENTRY) {
12233 TALLOC_FREE(msg);
12234 return;
12235 }
12236 if (!tldap_entry_dn(msg, &dn)) {
12237 d_printf("tldap_entry_dn failed\n");
12238 return;
12239 }
12240 d_printf("%s\n", dn);
12241 TALLOC_FREE(msg);
12242 }
12243
12244 enum tldap_extended_val {
12245 EXTENDED_ZERO = 0,
12246 EXTENDED_ONE = 1,
12247 EXTENDED_NONE = 2,
12248 };
12249
12250 /*
12251 * Construct an extended dn control with either no value, 0 or 1
12252 *
12253 * No value and 0 are equivalent (non-hyphenated GUID)
12254 * 1 has the hyphenated GUID
12255 */
12256 static struct tldap_control *
12257 tldap_build_extended_control(enum tldap_extended_val val)
12258 {
12259 struct tldap_control empty_control;
12260 struct asn1_data *data;
12261
12262 ZERO_STRUCT(empty_control);
12263
12264 if (val != EXTENDED_NONE) {
12265 data = asn1_init(talloc_tos(), ASN1_MAX_TREE_DEPTH);
12266
12267 if (!data) {
12268 return NULL;
12269 }
12270
12271 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
12272 return NULL;
12273 }
12274
12275 if (!asn1_write_Integer(data, (int)val)) {
12276 return NULL;
12277 }
12278
12279 if (!asn1_pop_tag(data)) {
12280 return NULL;
12281 }
12282
12283 if (!asn1_blob(data, &empty_control.value)) {
12284 return NULL;
12285 }
12286 }
12287
12288 empty_control.oid = "1.2.840.113556.1.4.529";
12289 empty_control.critical = true;
12290
12291 return tldap_add_control(talloc_tos(), NULL, 0, &empty_control);
12292
12293 }
12294
12295 static bool tldap_test_dn_guid_format(struct tldap_context *ld, const char *basedn,
12296 enum tldap_extended_val control_val)
12297 {
12298 struct tldap_control *control = tldap_build_extended_control(control_val);
12299 char *dn = NULL;
12300 struct tldap_message **msg;
12301 TLDAPRC rc;
12302
12303 rc = tldap_search(ld, basedn, TLDAP_SCOPE_BASE,
12304 "(objectClass=*)", NULL, 0, 0,
12305 control, 1, NULL,
12306 0, 0, 0, 0, talloc_tos(), &msg);
12307 if (!TLDAP_RC_IS_SUCCESS(rc)) {
12308 d_printf("tldap_search for domain DN failed: %s\n",
12309 tldap_errstr(talloc_tos(), ld, rc));
12310 return false;
12311 }
12312
12313 if (!tldap_entry_dn(msg[0], &dn)) {
12314 d_printf("tldap_search domain DN fetch failed: %s\n",
12315 tldap_errstr(talloc_tos(), ld, rc));
12316 return false;
12317 }
12318
12319 d_printf("%s\n", dn);
12320 {
12321 uint32_t time_low;
12322 uint32_t time_mid, time_hi_and_version;
12323 uint32_t clock_seq[2];
12324 uint32_t node[6];
12325 char next;
12326
12327 switch (control_val) {
12328 case EXTENDED_NONE:
12329 case EXTENDED_ZERO:
12330 /*
12331 * When reading GUIDs with hyphens, scanf will treat
12332 * hyphen as a hex character (and counts as part of the
12333 * width). This creates leftover GUID string which we
12334 * check will for with 'next' and closing '>'.
12335 */
12336 if (12 == sscanf(dn, "<GUID=%08x%04x%04x%02x%02x%02x%02x%02x%02x%02x%02x>%c",
12337 &time_low, &time_mid,
12338 &time_hi_and_version, &clock_seq[0],
12339 &clock_seq[1], &node[0], &node[1],
12340 &node[2], &node[3], &node[4],
12341 &node[5], &next)) {
12342 /* This GUID is good */
12343 } else {
12344 d_printf("GUID format in control (no hyphens) doesn't match output\n");
12345 return false;
12346 }
12347
12348 break;
12349 case EXTENDED_ONE:
12350 if (12 == sscanf(dn,
12351 "<GUID=%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x>%c",
12352 &time_low, &time_mid,
12353 &time_hi_and_version, &clock_seq[0],
12354 &clock_seq[1], &node[0], &node[1],
12355 &node[2], &node[3], &node[4],
12356 &node[5], &next)) {
12357 /* This GUID is good */
12358 } else {
12359 d_printf("GUID format in control (with hyphens) doesn't match output\n");
12360 return false;
12361 }
12362
12363 break;
12364 default:
12365 return false;
12366 }
12367 }
12368
12369 return true;
12370 }
12371
12372 static bool run_tldap(int dummy)
12373 {
12374 struct tldap_context *ld;
12375 int fd;
12376 TLDAPRC rc;
12377 NTSTATUS status;
12378 struct sockaddr_storage addr;
12379 struct tevent_context *ev;
12380 struct tevent_req *req;
12381 char *basedn;
12382 const char *filter;
12383 struct loadparm_context *lp_ctx = NULL;
12384 int tcp_port = 389;
12385 bool use_tls = false;
12386 bool use_starttls = false;
12387 int wrap_flags = -1;
12388 uint32_t gensec_features = 0;
12389
12390 lp_ctx = loadparm_init_s3(talloc_tos(), loadparm_s3_helpers());
12391
12392 wrap_flags = lpcfg_client_ldap_sasl_wrapping(lp_ctx);
12393
12394 if (wrap_flags & ADS_AUTH_SASL_LDAPS) {
12395 use_tls = true;
12396 tcp_port = 636;
12397 } else if (wrap_flags & ADS_AUTH_SASL_STARTTLS) {
12398 use_tls = true;
12399 use_starttls = true;
12400 }
12401 if (wrap_flags & ADS_AUTH_SASL_SEAL) {
12402 gensec_features |= GENSEC_FEATURE_SEAL;
12403 }
12404 if (wrap_flags & ADS_AUTH_SASL_SIGN) {
12405 gensec_features |= GENSEC_FEATURE_SIGN;
12406 }
12407
12408 if (gensec_features != 0) {
12409 gensec_features |= GENSEC_FEATURE_LDAP_STYLE;
12410 }
12411
12412 if (!resolve_name(host, &addr, 0, false)) {
12413 d_printf("could not find host %s\n", host);
12414 return false;
12415 }
12416 status = open_socket_out(&addr, tcp_port, 9999, &fd);
12417 if (!NT_STATUS_IS_OK(status)) {
12418 d_printf("open_socket_out failed: %s\n", nt_errstr(status));
12419 return false;
12420 }
12421
12422 ld = tldap_context_create(talloc_tos(), fd);
12423 if (ld == NULL) {
12424 close(fd);
12425 d_printf("tldap_context_create failed\n");
12426 return false;
12427 }
12428
12429 if (use_tls && !tldap_has_tls_tstream(ld)) {
12430 tldap_set_starttls_needed(ld, use_starttls);
12431
12432 rc = tldap_tls_connect(ld, lp_ctx, host);
12433 if (!TLDAP_RC_IS_SUCCESS(rc)) {
12434 DBG_ERR("tldap_tls_connect(%s) failed: %s\n",
12435 host, tldap_errstr(talloc_tos(), ld, rc));
12436 return false;
12437 }
12438 }
12439
12440 rc = tldap_fetch_rootdse(ld);
12441 if (!TLDAP_RC_IS_SUCCESS(rc)) {
12442 d_printf("tldap_fetch_rootdse failed: %s\n",
12443 tldap_errstr(talloc_tos(), ld, rc));
12444 return false;
12445 }
12446
12447 basedn = tldap_talloc_single_attribute(
12448 tldap_rootdse(ld), "defaultNamingContext", talloc_tos());
12449 if (basedn == NULL) {
12450 d_printf("no defaultNamingContext\n");
12451 return false;
12452 }
12453 d_printf("defaultNamingContext: %s\n", basedn);
12454
12455 ev = samba_tevent_context_init(talloc_tos());
12456 if (ev == NULL) {
12457 d_printf("tevent_context_init failed\n");
12458 return false;
12459 }
12460
12461 rc = tldap_gensec_bind(ld, torture_creds, "ldap", host, NULL,
12462 lp_ctx, gensec_features);
12463 if (!TLDAP_RC_IS_SUCCESS(rc)) {
12464 d_printf("tldap_gensec_bind failed\n");
12465 return false;
12466 }
12467
12468 callback_code = TLDAP_SUCCESS;
12469
12470 req = tldap_search_paged_send(talloc_tos(), ev, ld, basedn,
12471 TLDAP_SCOPE_SUB, "(objectclass=*)",
12472 NULL, 0, 0,
12473 NULL, 0, NULL, 0, 0, 0, 0, 5);
12474 if (req == NULL) {
12475 d_printf("tldap_search_paged_send failed\n");
12476 return false;
12477 }
12478 tevent_req_set_callback(req, pagedsearch_cb, NULL);
12479
12480 tevent_req_poll(req, ev);
12481
12482 TALLOC_FREE(req);
12483
12484 rc = callback_code;
12485
12486 if (!TLDAP_RC_IS_SUCCESS(rc)) {
12487 d_printf("tldap_search with paging failed: %s\n",
12488 tldap_errstr(talloc_tos(), ld, rc));
12489 return false;
12490 }
12491
12492 /* test search filters against rootDSE */
12493 filter = "(&(|(name=samba)(nextRid<=10000000)(usnChanged>=10)(samba~=ambas)(!(name=s*m*a)))"
12494 "(|(name:=samba)(name:dn:2.5.13.5:=samba)(:dn:2.5.13.5:=samba)(!(name=*samba))))";
12495
12496 rc = tldap_search(ld, "", TLDAP_SCOPE_BASE, filter,
12497 NULL, 0, 0, NULL, 0, NULL, 0, 0, 0, 0,
12498 talloc_tos(), NULL);
12499 if (!TLDAP_RC_IS_SUCCESS(rc)) {
12500 d_printf("tldap_search with complex filter failed: %s\n",
12501 tldap_errstr(talloc_tos(), ld, rc));
12502 return false;
12503 }
12504
12505 /*
12506 * Tests to check for regression of:
12507 *
12508 * https://bugzilla.samba.org/show_bug.cgi?id=14029
12509 *
12510 * TLDAP used here to pick apart the original string DN (with GUID)
12511 */
12512 if (!tldap_test_dn_guid_format(ld, basedn, EXTENDED_NONE)) {
12513 d_printf("tldap_search with extended dn (no val) failed: %s\n",
12514 tldap_errstr(talloc_tos(), ld, rc));
12515 return false;
12516 }
12517 if (!tldap_test_dn_guid_format(ld, basedn, EXTENDED_ZERO)) {
12518 d_printf("tldap_search with extended dn (0) failed: %s\n",
12519 tldap_errstr(talloc_tos(), ld, rc));
12520 return false;
12521 }
12522 if (!tldap_test_dn_guid_format(ld, basedn, EXTENDED_ONE)) {
12523 d_printf("tldap_search with extended dn (1) failed: %s\n",
12524 tldap_errstr(talloc_tos(), ld, rc));
12525 return false;
12526 }
12527
12528 TALLOC_FREE(ld);
12529 return true;
12530 }
12531
12532 /* Torture test to ensure no regression of :
12533 https://bugzilla.samba.org/show_bug.cgi?id=7084
12534 */
12535
12536 static bool run_dir_createtime(int dummy)
12537 {
12538 struct cli_state *cli;
12539 const char *dname = "\\testdir_createtime";
12540 const char *fname = "\\testdir_createtime\\testfile";
12541 NTSTATUS status;
12542 struct timespec create_time;
12543 struct timespec create_time1;
12544 uint16_t fnum;
12545 bool ret = false;
12546 uint64_t ino;
12547
12548 if (!torture_open_connection(&cli, 0)) {
12549 return false;
12550 }
12551
12552 if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
12553 /* Ensure ino is zero, SMB2 gets a real one. */
12554 ino = 0;
12555 } else {
12556 /* Ensure ino is -1, SMB1 never gets a real one. */
12557 ino = (uint64_t)-1;
12558 }
12559
12560 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
12561 cli_rmdir(cli, dname);
12562
12563 status = cli_mkdir(cli, dname);
12564 if (!NT_STATUS_IS_OK(status)) {
12565 printf("mkdir failed: %s\n", nt_errstr(status));
12566 goto out;
12567 }
12568
12569 status = cli_qpathinfo2(cli,
12570 dname,
12571 &create_time,
12572 NULL,
12573 NULL,
12574 NULL,
12575 NULL,
12576 NULL,
12577 &ino,
12578 NULL);
12579 if (!NT_STATUS_IS_OK(status)) {
12580 printf("cli_qpathinfo2 returned %s\n",
12581 nt_errstr(status));
12582 goto out;
12583 }
12584
12585 if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
12586 /* SMB2 should always return an inode. */
12587 if (ino == 0) {
12588 printf("SMB2 bad inode (0)\n");
12589 goto out;
12590 }
12591 } else {
12592 /* SMB1 must always return zero here. */
12593 if (ino != 0) {
12594 printf("SMB1 bad inode (!0)\n");
12595 goto out;
12596 }
12597 }
12598
12599 /* Sleep 3 seconds, then create a file. */
12600 sleep(3);
12601
12602 status = cli_openx(cli, fname, O_RDWR | O_CREAT | O_EXCL,
12603 DENY_NONE, &fnum);
12604 if (!NT_STATUS_IS_OK(status)) {
12605 printf("cli_openx failed: %s\n", nt_errstr(status));
12606 goto out;
12607 }
12608
12609 status = cli_qpathinfo2(cli,
12610 dname,
12611 &create_time1,
12612 NULL,
12613 NULL,
12614 NULL,
12615 NULL,
12616 NULL,
12617 NULL,
12618 NULL);
12619 if (!NT_STATUS_IS_OK(status)) {
12620 printf("cli_qpathinfo2 (2) returned %s\n",
12621 nt_errstr(status));
12622 goto out;
12623 }
12624
12625 if (timespec_compare(&create_time1, &create_time)) {
12626 printf("run_dir_createtime: create time was updated (error)\n");
12627 } else {
12628 printf("run_dir_createtime: create time was not updated (correct)\n");
12629 ret = true;
12630 }
12631
12632 out:
12633
12634 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
12635 cli_rmdir(cli, dname);
12636 if (!torture_close_connection(cli)) {
12637 ret = false;
12638 }
12639 return ret;
12640 }
12641
12642
12643 static bool run_streamerror(int dummy)
12644 {
12645 struct cli_state *cli;
12646 const char *dname = "\\testdir_streamerror";
12647 const char *streamname =
12648 "testdir_streamerror:{4c8cc155-6c1e-11d1-8e41-00c04fb9386d}:$DATA";
12649 NTSTATUS status;
12650 time_t change_time, access_time, write_time;
12651 off_t size;
12652 uint16_t fnum;
12653 uint32_t attr;
12654 bool ret = true;
12655
12656 if (!torture_open_connection(&cli, 0)) {
12657 return false;
12658 }
12659
12660 torture_deltree(cli, dname);
12661
12662 status = cli_mkdir(cli, dname);
12663 if (!NT_STATUS_IS_OK(status)) {
12664 printf("mkdir failed: %s\n", nt_errstr(status));
12665 return false;
12666 }
12667
12668 status = cli_qpathinfo1(cli, streamname, &change_time, &access_time,
12669 &write_time, &size, &attr);
12670 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
12671 printf("pathinfo returned %s, expected "
12672 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
12673 nt_errstr(status));
12674 ret = false;
12675 }
12676
12677 status = cli_ntcreate(cli, streamname, 0x16,
12678 FILE_READ_DATA|FILE_READ_EA|
12679 FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS,
12680 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
12681 FILE_OPEN, 0, 0, &fnum, NULL);
12682
12683 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
12684 printf("ntcreate returned %s, expected "
12685 "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
12686 nt_errstr(status));
12687 ret = false;
12688 }
12689
12690
12691 cli_rmdir(cli, dname);
12692 return ret;
12693 }
12694
12695 struct pidtest_state {
12696 bool success;
12697 uint16_t vwv[1];
12698 DATA_BLOB data;
12699 };
12700
12701 static void pid_echo_done(struct tevent_req *subreq);
12702
12703 static struct tevent_req *pid_echo_send(TALLOC_CTX *mem_ctx,
12704 struct tevent_context *ev,
12705 struct cli_state *cli)
12706 {
12707 struct tevent_req *req, *subreq;
12708 struct pidtest_state *state;
12709
12710 req = tevent_req_create(mem_ctx, &state, struct pidtest_state);
12711 if (req == NULL) {
12712 return NULL;
12713 }
12714
12715 SSVAL(state->vwv, 0, 1);
12716 state->data = data_blob_const("hello", 5);
12717
12718 subreq = smb1cli_req_send(state,
12719 ev,
12720 cli->conn,
12721 SMBecho,
12722 0, 0, /* *_flags */
12723 0, 0, /* *_flags2 */
12724 cli->timeout,
12725 0xDEADBEEF, /* pid */
12726 NULL, /* tcon */
12727 NULL, /* session */
12728 ARRAY_SIZE(state->vwv), state->vwv,
12729 state->data.length, state->data.data);
12730
12731 if (tevent_req_nomem(subreq, req)) {
12732 return tevent_req_post(req, ev);
12733 }
12734 tevent_req_set_callback(subreq, pid_echo_done, req);
12735 return req;
12736 }
12737
12738 static void pid_echo_done(struct tevent_req *subreq)
12739 {
12740 struct tevent_req *req = tevent_req_callback_data(
12741 subreq, struct tevent_req);
12742 struct pidtest_state *state = tevent_req_data(
12743 req, struct pidtest_state);
12744 NTSTATUS status;
12745 uint32_t num_bytes;
12746 uint8_t *bytes = NULL;
12747 struct iovec *recv_iov = NULL;
12748 uint8_t *phdr = NULL;
12749 uint16_t pidlow = 0;
12750 uint16_t pidhigh = 0;
12751 struct smb1cli_req_expected_response expected[] = {
12752 {
12753 .status = NT_STATUS_OK,
12754 .wct = 1,
12755 },
12756 };
12757
12758 status = smb1cli_req_recv(subreq, state,
12759 &recv_iov,
12760 &phdr,
12761 NULL, /* pwct */
12762 NULL, /* pvwv */
12763 NULL, /* pvwv_offset */
12764 &num_bytes,
12765 &bytes,
12766 NULL, /* pbytes_offset */
12767 NULL, /* pinbuf */
12768 expected, ARRAY_SIZE(expected));
12769
12770 TALLOC_FREE(subreq);
12771
12772 if (!NT_STATUS_IS_OK(status)) {
12773 tevent_req_nterror(req, status);
12774 return;
12775 }
12776
12777 if (num_bytes != state->data.length) {
12778 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
12779 return;
12780 }
12781
12782 if (memcmp(bytes, state->data.data, num_bytes) != 0) {
12783 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
12784 return;
12785 }
12786
12787 /* Check pid low/high == DEADBEEF */
12788 pidlow = SVAL(phdr, HDR_PID);
12789 if (pidlow != 0xBEEF){
12790 printf("Incorrect pidlow 0x%x, should be 0xBEEF\n",
12791 (unsigned int)pidlow);
12792 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
12793 return;
12794 }
12795 pidhigh = SVAL(phdr, HDR_PIDHIGH);
12796 if (pidhigh != 0xDEAD){
12797 printf("Incorrect pidhigh 0x%x, should be 0xDEAD\n",
12798 (unsigned int)pidhigh);
12799 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
12800 return;
12801 }
12802
12803 tevent_req_done(req);
12804 }
12805
12806 static NTSTATUS pid_echo_recv(struct tevent_req *req)
12807 {
12808 return tevent_req_simple_recv_ntstatus(req);
12809 }
12810
12811 static bool run_pidhigh(int dummy)
12812 {
12813 bool success = false;
12814 struct cli_state *cli = NULL;
12815 NTSTATUS status;
12816 struct tevent_context *ev = NULL;
12817 struct tevent_req *req = NULL;
12818 TALLOC_CTX *frame = talloc_stackframe();
12819
12820 printf("starting pid high test\n");
12821 if (!torture_open_connection(&cli, 0)) {
12822 return false;
12823 }
12824 smbXcli_conn_set_sockopt(cli->conn, sockops);
12825
12826 ev = samba_tevent_context_init(frame);
12827 if (ev == NULL) {
12828 goto fail;
12829 }
12830
12831 req = pid_echo_send(frame, ev, cli);
12832 if (req == NULL) {
12833 goto fail;
12834 }
12835
12836 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
12837 goto fail;
12838 }
12839
12840 status = pid_echo_recv(req);
12841 if (NT_STATUS_IS_OK(status)) {
12842 printf("pid high test ok\n");
12843 success = true;
12844 }
12845
12846 fail:
12847
12848 TALLOC_FREE(frame);
12849 torture_close_connection(cli);
12850 return success;
12851 }
12852
12853 /*
12854 Test Windows open on a bad POSIX symlink.
12855 */
12856 static bool run_symlink_open_test(int dummy)
12857 {
12858 static struct cli_state *cli;
12859 const char *fname = "non_existant_file";
12860 const char *sname = "dangling_symlink";
12861 uint16_t fnum = (uint16_t)-1;
12862 bool correct = false;
12863 NTSTATUS status;
12864 TALLOC_CTX *frame = NULL;
12865
12866 frame = talloc_stackframe();
12867
12868 printf("Starting Windows bad symlink open test\n");
12869
12870 if (!torture_open_connection(&cli, 0)) {
12871 TALLOC_FREE(frame);
12872 return false;
12873 }
12874
12875 smbXcli_conn_set_sockopt(cli->conn, sockops);
12876
12877 status = torture_setup_unix_extensions(cli);
12878 if (!NT_STATUS_IS_OK(status)) {
12879 TALLOC_FREE(frame);
12880 return false;
12881 }
12882
12883 /* Ensure nothing exists. */
12884 cli_setatr(cli, fname, 0, 0);
12885 cli_posix_unlink(cli, fname);
12886 cli_setatr(cli, sname, 0, 0);
12887 cli_posix_unlink(cli, sname);
12888
12889 /* Create a symlink pointing nowhere. */
12890 status = cli_posix_symlink(cli, fname, sname);
12891 if (!NT_STATUS_IS_OK(status)) {
12892 printf("cli_posix_symlink of %s -> %s failed (%s)\n",
12893 sname,
12894 fname,
12895 nt_errstr(status));
12896 goto out;
12897 }
12898
12899 /* Now ensure that a Windows open doesn't hang. */
12900 status = cli_ntcreate(cli,
12901 sname,
12902 0,
12903 FILE_READ_DATA|FILE_WRITE_DATA,
12904 0,
12905 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
12906 FILE_OPEN_IF,
12907 0x0,
12908 0x0,
12909 &fnum,
12910 NULL);
12911
12912 /*
12913 * We get either NT_STATUS_OBJECT_NAME_NOT_FOUND or
12914 * NT_STATUS_OBJECT_PATH_NOT_FOUND depending on if
12915 * we use O_NOFOLLOW on the server or not.
12916 */
12917 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND) ||
12918 NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND))
12919 {
12920 correct = true;
12921 } else {
12922 printf("cli_ntcreate of %s returned %s - should return"
12923 " either (%s) or (%s)\n",
12924 sname,
12925 nt_errstr(status),
12926 nt_errstr(NT_STATUS_OBJECT_NAME_NOT_FOUND),
12927 nt_errstr(NT_STATUS_OBJECT_PATH_NOT_FOUND));
12928 goto out;
12929 }
12930
12931 correct = true;
12932
12933 out:
12934
12935 if (fnum != (uint16_t)-1) {
12936 cli_close(cli, fnum);
12937 fnum = (uint16_t)-1;
12938 }
12939
12940 cli_setatr(cli, sname, 0, 0);
12941 cli_posix_unlink(cli, sname);
12942 cli_setatr(cli, fname, 0, 0);
12943 cli_posix_unlink(cli, fname);
12944
12945 if (!torture_close_connection(cli)) {
12946 correct = false;
12947 }
12948
12949 TALLOC_FREE(frame);
12950 return correct;
12951 }
12952
12953 static NTSTATUS smb1_wild_mangle_list_fn(struct file_info *finfo,
12954 const char *name,
12955 void *state)
12956 {
12957 char **mangled_name_return = (char **)state;
12958 bool is_mangled = strchr(finfo->name, '~');
12959
12960 if (is_mangled) {
12961 *mangled_name_return = talloc_strdup(NULL, finfo->name);
12962 if (*mangled_name_return == NULL) {
12963 return NT_STATUS_NO_MEMORY;
12964 }
12965 }
12966 return NT_STATUS_OK;
12967 }
12968
12969 static bool run_smb1_wild_mangle_unlink_test(int dummy)
12970 {
12971 static struct cli_state *cli_posix = NULL;
12972 static struct cli_state *cli = NULL;
12973 uint16_t fnum = (uint16_t)-1;
12974 bool correct = false;
12975 const char *dname = "smb1_wild_mangle_unlink";
12976 const char *aname = "smb1_wild_mangle_unlink/a";
12977 const char *star_name = "smb1_wild_mangle_unlink/*";
12978 char *windows_unlink_name = NULL;
12979 char *mangled_name = NULL;
12980 NTSTATUS status;
12981
12982 printf("Starting SMB1 wild mangle unlink test\n");
12983
12984 /* Open a Windows connection. */
12985 if (!torture_open_connection(&cli, 0)) {
12986 return false;
12987 }
12988
12989 smbXcli_conn_set_sockopt(cli->conn, sockops);
12990
12991 /* Open a POSIX connection. */
12992 if (!torture_open_connection(&cli_posix, 0)) {
12993 goto out;
12994 }
12995
12996 smbXcli_conn_set_sockopt(cli_posix->conn, sockops);
12997
12998 status = torture_setup_unix_extensions(cli_posix);
12999 if (!NT_STATUS_IS_OK(status)) {
13000 printf("server doesn't support POSIX\n");
13001 goto out;
13002 }
13003
13004 /* Start fresh. */
13005 torture_deltree(cli, dname);
13006
13007 /*
13008 * Create two files - 'a' and '*'.
13009 * We need POSIX extensions for this as '*'
13010 * is not a valid Windows name.
13011 */
13012
13013 status = cli_mkdir(cli, dname);
13014 if (!NT_STATUS_IS_OK(status)) {
13015 printf("cli_mkdir of %s returned %s\n",
13016 dname,
13017 nt_errstr(status));
13018 goto out;
13019 }
13020
13021 status = cli_posix_open(cli_posix,
13022 aname,
13023 O_RDWR|O_CREAT|O_EXCL,
13024 0660,
13025 &fnum);
13026 if (!NT_STATUS_IS_OK(status)) {
13027 printf("cli_posix_open (create) of %s returned %s\n",
13028 aname,
13029 nt_errstr(status));
13030 goto out;
13031 }
13032 status = cli_close(cli_posix, fnum);
13033 if (!NT_STATUS_IS_OK(status)) {
13034 goto out;
13035 }
13036 status = cli_posix_open(cli_posix,
13037 star_name,
13038 O_RDWR|O_CREAT|O_EXCL,
13039 0660,
13040 &fnum);
13041 if (!NT_STATUS_IS_OK(status)) {
13042 printf("cli_posix_open (create) of %s returned %s\n",
13043 star_name,
13044 nt_errstr(status));
13045 goto out;
13046 }
13047 status = cli_close(cli_posix, fnum);
13048 if (!NT_STATUS_IS_OK(status)) {
13049 goto out;
13050 }
13051
13052 status = cli_list(cli,
13053 star_name,
13054 0,
13055 smb1_wild_mangle_list_fn,
13056 &mangled_name);
13057 if (!NT_STATUS_IS_OK(status)) {
13058 printf("cli_list of %s returned %s\n",
13059 star_name,
13060 nt_errstr(status));
13061 goto out;
13062 }
13063
13064 if (mangled_name == NULL) {
13065 goto out;
13066 }
13067
13068 printf("mangled_name = %s\n",
13069 mangled_name);
13070
13071 /*
13072 * Try a Windows unlink with the mangled name.
13073 * This should *NOT* unlink the 'a' name.
13074 */
13075
13076 windows_unlink_name = talloc_asprintf(cli_posix,
13077 "%s\\%s",
13078 dname,
13079 mangled_name);
13080
13081 status = cli_unlink(cli, windows_unlink_name, 0);
13082 if (!NT_STATUS_IS_OK(status)) {
13083 printf("cli_unlink of %s returned %s\n",
13084 windows_unlink_name,
13085 nt_errstr(status));
13086 goto out;
13087 }
13088
13089 /* Does 'a' still exist ? */
13090 status = cli_posix_open(cli_posix,
13091 aname,
13092 O_RDONLY,
13093 0,
13094 &fnum);
13095 if (!NT_STATUS_IS_OK(status)) {
13096 printf("cli_posix_open O_RNONLY of %s returned %s\n",
13097 aname,
13098 nt_errstr(status));
13099 goto out;
13100 }
13101
13102 status = cli_close(cli_posix, fnum);
13103 if (!NT_STATUS_IS_OK(status)) {
13104 goto out;
13105 }
13106
13107 correct = true;
13108
13109 out:
13110
13111 TALLOC_FREE(windows_unlink_name);
13112 TALLOC_FREE(mangled_name);
13113
13114 if (cli != NULL) {
13115 torture_deltree(cli, dname);
13116 torture_close_connection(cli);
13117 }
13118
13119 if (cli_posix != NULL) {
13120 torture_close_connection(cli_posix);
13121 }
13122
13123 return correct;
13124 }
13125
13126 static bool run_smb1_wild_mangle_rename_test(int dummy)
13127 {
13128 static struct cli_state *cli_posix = NULL;
13129 static struct cli_state *cli = NULL;
13130 uint16_t fnum = (uint16_t)-1;
13131 bool correct = false;
13132 const char *dname = "smb1_wild_mangle_rename";
13133 const char *fooname = "smb1_wild_mangle_rename/foo";
13134 const char *foostar_name = "smb1_wild_mangle_rename/fo*";
13135 const char *wild_name = "smb1_wild_mangle_rename/*";
13136 char *windows_rename_src = NULL;
13137 const char *windows_rename_dst = "smb1_wild_mangle_rename\\bar";
13138 char *mangled_name = NULL;
13139 NTSTATUS status;
13140
13141 printf("Starting SMB1 wild mangle rename test\n");
13142
13143 if (!torture_open_connection(&cli_posix, 0)) {
13144 return false;
13145 }
13146
13147 smbXcli_conn_set_sockopt(cli_posix->conn, sockops);
13148
13149 status = torture_setup_unix_extensions(cli_posix);
13150 if (!NT_STATUS_IS_OK(status)) {
13151 printf("server doesn't support POSIX\n");
13152 return false;
13153 }
13154
13155 /* Open a Windows connection. */
13156 if (!torture_open_connection(&cli, 0)) {
13157 goto out;
13158 }
13159
13160 smbXcli_conn_set_sockopt(cli->conn, sockops);
13161
13162 /* Ensure we start from fresh. */
13163 torture_deltree(cli, dname);
13164
13165 /*
13166 * Create two files - 'foo' and 'fo*'.
13167 * We need POSIX extensions for this as 'fo*'
13168 * is not a valid Windows name.
13169 */
13170
13171 status = cli_posix_mkdir(cli_posix, dname, 0770);
13172 if (!NT_STATUS_IS_OK(status)) {
13173 printf("cli_posix_mkdir of %s returned %s\n",
13174 dname,
13175 nt_errstr(status));
13176 goto out;
13177 }
13178
13179 status = cli_posix_open(cli_posix,
13180 fooname,
13181 O_RDWR|O_CREAT|O_EXCL,
13182 0660,
13183 &fnum);
13184 if (!NT_STATUS_IS_OK(status)) {
13185 printf("cli_posix_open (create) of %s returned %s\n",
13186 fooname,
13187 nt_errstr(status));
13188 goto out;
13189 }
13190 status = cli_close(cli_posix, fnum);
13191 if (!NT_STATUS_IS_OK(status)) {
13192 goto out;
13193 }
13194 status = cli_posix_open(cli_posix,
13195 foostar_name,
13196 O_RDWR|O_CREAT|O_EXCL,
13197 0660,
13198 &fnum);
13199 if (!NT_STATUS_IS_OK(status)) {
13200 printf("cli_posix_open (create) of %s returned %s\n",
13201 foostar_name,
13202 nt_errstr(status));
13203 goto out;
13204 }
13205 status = cli_close(cli_posix, fnum);
13206 if (!NT_STATUS_IS_OK(status)) {
13207 goto out;
13208 }
13209
13210 /*
13211 * Get the mangled name. We can re-use the
13212 * previous smb1_wild_mangle_list_fn for this.
13213 */
13214
13215 status = cli_list(cli,
13216 wild_name,
13217 0,
13218 smb1_wild_mangle_list_fn,
13219 &mangled_name);
13220 if (!NT_STATUS_IS_OK(status)) {
13221 printf("cli_list of %s returned %s\n",
13222 wild_name,
13223 nt_errstr(status));
13224 goto out;
13225 }
13226
13227 if (mangled_name == NULL) {
13228 goto out;
13229 }
13230
13231 printf("mangled_name = %s\n",
13232 mangled_name);
13233
13234 /*
13235 * Try a Windows rename with the mangled name.
13236 * This should *NOT* rename the 'foo' name.
13237 */
13238
13239 windows_rename_src = talloc_asprintf(cli_posix,
13240 "%s\\%s",
13241 dname,
13242 mangled_name);
13243
13244 status = cli_rename(cli,
13245 windows_rename_src,
13246 windows_rename_dst,
13247 false);
13248 if (!NT_STATUS_IS_OK(status)) {
13249 printf("cli_rename of %s -> %s returned %s\n",
13250 windows_rename_src,
13251 windows_rename_dst,
13252 nt_errstr(status));
13253 goto out;
13254 }
13255
13256 /* Does 'foo' still exist ? */
13257 status = cli_posix_open(cli_posix,
13258 fooname,
13259 O_RDONLY,
13260 0,
13261 &fnum);
13262 if (!NT_STATUS_IS_OK(status)) {
13263 printf("cli_posix_open O_RNONLY of %s returned %s\n",
13264 fooname,
13265 nt_errstr(status));
13266 goto out;
13267 }
13268
13269 status = cli_close(cli_posix, fnum);
13270 if (!NT_STATUS_IS_OK(status)) {
13271 goto out;
13272 }
13273
13274 correct = true;
13275
13276 out:
13277
13278 TALLOC_FREE(mangled_name);
13279 TALLOC_FREE(windows_rename_src);
13280
13281 if (cli != NULL) {
13282 torture_deltree(cli, dname);
13283 torture_close_connection(cli);
13284 }
13285
13286 torture_close_connection(cli_posix);
13287
13288 return correct;
13289 }
13290
13291 /*
13292 * Only testing minimal time strings, as the others
13293 * need (locale-dependent) guessing at what strftime does and
13294 * even may differ in builds.
13295 */
13296 static bool timesubst_test(void)
13297 {
13298 TALLOC_CTX *ctx = NULL;
13299 /* Sa 23. Dez 04:33:20 CET 2017 */
13300 const struct timeval tv = { 1514000000, 123 };
13301 const char* expect_minimal = "20171223_033320";
13302 const char* expect_minus = "20171223_033320_000123";
13303 char *s;
13304 char *env_tz, *orig_tz = NULL;
13305 bool result = true;
13306
13307 ctx = talloc_new(NULL);
13308
13309 env_tz = getenv("TZ");
13310 if(env_tz) {
13311 orig_tz = talloc_strdup(ctx, env_tz);
13312 }
13313 setenv("TZ", "UTC", 1);
13314
13315 s = minimal_timeval_string(ctx, &tv, false);
13316
13317 if(!s || strcmp(s, expect_minimal)) {
13318 printf("minimal_timeval_string(ctx, tv, false) returned [%s], expected "
13319 "[%s]\n", s ? s : "<nil>", expect_minimal);
13320 result = false;
13321 }
13322 TALLOC_FREE(s);
13323 s = minimal_timeval_string(ctx, &tv, true);
13324 if(!s || strcmp(s, expect_minus)) {
13325 printf("minimal_timeval_string(ctx, tv, true) returned [%s], expected "
13326 "[%s]\n", s ? s : "<nil>", expect_minus);
13327 result = false;
13328 }
13329 TALLOC_FREE(s);
13330
13331 if(orig_tz) {
13332 setenv("TZ", orig_tz, 1);
13333 }
13334
13335 TALLOC_FREE(ctx);
13336 return result;
13337 }
13338
13339 static bool run_local_substitute(int dummy)
13340 {
13341 bool ok = true;
13342
13343 ok &= subst_test("%U", "bla", "", -1, -1, "bla");
13344 ok &= subst_test("%u%U", "bla", "", -1, -1, "blabla");
13345 ok &= subst_test("%g", "", "", -1, -1, "NO_GROUP");
13346 ok &= subst_test("%G", "", "", -1, -1, "NO_GROUP");
13347 ok &= subst_test("%g", "", "", -1, 0, gidtoname(0));
13348 ok &= subst_test("%G", "", "", -1, 0, gidtoname(0));
13349 ok &= subst_test("%D%u", "u", "dom", -1, 0, "domu");
13350 ok &= subst_test("%i %I", "", "", -1, -1, "0.0.0.0 0.0.0.0");
13351 ok &= subst_test("%j %J", "", "", -1, -1, "0_0_0_0 0_0_0_0");
13352 /* Substitution depends on current time, so better test the underlying
13353 formatting function. At least covers %t. */
13354 ok &= timesubst_test();
13355
13356 /* Different captialization rules in sub_basic... */
13357
13358 ok &= (strcmp(talloc_sub_basic(talloc_tos(), "BLA", "dom", "%U%D"),
13359 "blaDOM") == 0);
13360
13361 return ok;
13362 }
13363
13364 static bool run_local_base64(int dummy)
13365 {
13366 int i;
13367 bool ret = true;
13368
13369 for (i=1; i<2000; i++) {
13370 DATA_BLOB blob1, blob2;
13371 char *b64;
13372
13373 blob1.data = talloc_array(talloc_tos(), uint8_t, i);
13374 blob1.length = i;
13375 generate_random_buffer(blob1.data, blob1.length);
13376
13377 b64 = base64_encode_data_blob(talloc_tos(), blob1);
13378 if (b64 == NULL) {
13379 d_fprintf(stderr, "base64_encode_data_blob failed "
13380 "for %d bytes\n", i);
13381 ret = false;
13382 }
13383 blob2 = base64_decode_data_blob(b64);
13384 TALLOC_FREE(b64);
13385
13386 if (data_blob_cmp(&blob1, &blob2)) {
13387 d_fprintf(stderr, "data_blob_cmp failed for %d "
13388 "bytes\n", i);
13389 ret = false;
13390 }
13391 TALLOC_FREE(blob1.data);
13392 data_blob_free(&blob2);
13393 }
13394 return ret;
13395 }
13396
13397 static void parse_fn(const struct gencache_timeout *t,
13398 DATA_BLOB blob,
13399 void *private_data)
13400 {
13401 return;
13402 }
13403
13404 static bool run_local_gencache(int dummy)
13405 {
13406 char *val;
13407 time_t tm;
13408 DATA_BLOB blob;
13409 char v;
13410 struct memcache *mem;
13411 int i;
13412
13413 mem = memcache_init(NULL, 0);
13414 if (mem == NULL) {
13415 d_printf("%s: memcache_init failed\n", __location__);
13416 return false;
13417 }
13418 memcache_set_global(mem);
13419
13420 if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
13421 d_printf("%s: gencache_set() failed\n", __location__);
13422 return False;
13423 }
13424
13425 if (!gencache_get("foo", NULL, NULL, NULL)) {
13426 d_printf("%s: gencache_get() failed\n", __location__);
13427 return False;
13428 }
13429
13430 for (i=0; i<1000000; i++) {
13431 gencache_parse("foo", parse_fn, NULL);
13432 }
13433
13434 if (!gencache_get("foo", talloc_tos(), &val, &tm)) {
13435 d_printf("%s: gencache_get() failed\n", __location__);
13436 return False;
13437 }
13438 TALLOC_FREE(val);
13439
13440 if (!gencache_get("foo", talloc_tos(), &val, &tm)) {
13441 d_printf("%s: gencache_get() failed\n", __location__);
13442 return False;
13443 }
13444
13445 if (strcmp(val, "bar") != 0) {
13446 d_printf("%s: gencache_get() returned %s, expected %s\n",
13447 __location__, val, "bar");
13448 TALLOC_FREE(val);
13449 return False;
13450 }
13451
13452 TALLOC_FREE(val);
13453
13454 if (!gencache_del("foo")) {
13455 d_printf("%s: gencache_del() failed\n", __location__);
13456 return False;
13457 }
13458 if (gencache_del("foo")) {
13459 d_printf("%s: second gencache_del() succeeded\n",
13460 __location__);
13461 return False;
13462 }
13463
13464 if (gencache_get("foo", talloc_tos(), &val, &tm)) {
13465 d_printf("%s: gencache_get() on deleted entry "
13466 "succeeded\n", __location__);
13467 return False;
13468 }
13469
13470 blob = data_blob_string_const_null("bar");
13471 tm = time(NULL) + 60;
13472
13473 if (!gencache_set_data_blob("foo", blob, tm)) {
13474 d_printf("%s: gencache_set_data_blob() failed\n", __location__);
13475 return False;
13476 }
13477
13478 if (!gencache_get_data_blob("foo", talloc_tos(), &blob, NULL, NULL)) {
13479 d_printf("%s: gencache_get_data_blob() failed\n", __location__);
13480 return False;
13481 }
13482
13483 if (strcmp((const char *)blob.data, "bar") != 0) {
13484 d_printf("%s: gencache_get_data_blob() returned %s, expected %s\n",
13485 __location__, (const char *)blob.data, "bar");
13486 data_blob_free(&blob);
13487 return False;
13488 }
13489
13490 data_blob_free(&blob);
13491
13492 if (!gencache_del("foo")) {
13493 d_printf("%s: gencache_del() failed\n", __location__);
13494 return False;
13495 }
13496 if (gencache_del("foo")) {
13497 d_printf("%s: second gencache_del() succeeded\n",
13498 __location__);
13499 return False;
13500 }
13501
13502 if (gencache_get_data_blob("foo", talloc_tos(), &blob, NULL, NULL)) {
13503 d_printf("%s: gencache_get_data_blob() on deleted entry "
13504 "succeeded\n", __location__);
13505 return False;
13506 }
13507
13508 v = 1;
13509 blob.data = (uint8_t *)&v;
13510 blob.length = sizeof(v);
13511
13512 if (!gencache_set_data_blob("blob", blob, tm)) {
13513 d_printf("%s: gencache_set_data_blob() failed\n",
13514 __location__);
13515 return false;
13516 }
13517 if (gencache_get("blob", talloc_tos(), &val, &tm)) {
13518 d_printf("%s: gencache_get succeeded\n", __location__);
13519 return false;
13520 }
13521
13522 return True;
13523 }
13524
13525 static bool rbt_testflags(struct db_context *db, const char *key,
13526 const char *value)
13527 {
13528 bool ret = false;
13529 NTSTATUS status;
13530 struct db_record *rec;
13531
13532 rec = dbwrap_fetch_locked(db, db, string_tdb_data(key));
13533 if (rec == NULL) {
13534 d_fprintf(stderr, "fetch_locked failed\n");
13535 goto done;
13536 }
13537
13538 status = dbwrap_record_store(rec, string_tdb_data(value), TDB_MODIFY);
13539 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
13540 d_fprintf(stderr, "store TDB_MODIFY unexpected status: %s\n",
13541 nt_errstr(status));
13542 goto done;
13543 }
13544
13545 status = dbwrap_record_store(rec, string_tdb_data("overwriteme"),
13546 TDB_INSERT);
13547 if (!NT_STATUS_IS_OK(status)) {
13548 d_fprintf(stderr, "store TDB_INSERT failed: %s\n",
13549 nt_errstr(status));
13550 goto done;
13551 }
13552
13553 status = dbwrap_record_store(rec, string_tdb_data(value), TDB_INSERT);
13554 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_COLLISION)) {
13555 d_fprintf(stderr, "store TDB_INSERT unexpected status: %s\n",
13556 nt_errstr(status));
13557 goto done;
13558 }
13559
13560 status = dbwrap_record_store(rec, string_tdb_data(value), TDB_MODIFY);
13561 if (!NT_STATUS_IS_OK(status)) {
13562 d_fprintf(stderr, "store TDB_MODIFY failed: %s\n",
13563 nt_errstr(status));
13564 goto done;
13565 }
13566
13567 ret = true;
13568 done:
13569 TALLOC_FREE(rec);
13570 return ret;
13571 }
13572
13573 static bool rbt_testval(struct db_context *db, const char *key,
13574 const char *value)
13575 {
13576 struct db_record *rec;
13577 TDB_DATA data = string_tdb_data(value);
13578 bool ret = false;
13579 NTSTATUS status;
13580 TDB_DATA dbvalue;
13581
13582 rec = dbwrap_fetch_locked(db, db, string_tdb_data(key));
13583 if (rec == NULL) {
13584 d_fprintf(stderr, "fetch_locked failed\n");
13585 goto done;
13586 }
13587 status = dbwrap_record_store(rec, data, 0);
13588 if (!NT_STATUS_IS_OK(status)) {
13589 d_fprintf(stderr, "store failed: %s\n", nt_errstr(status));
13590 goto done;
13591 }
13592 TALLOC_FREE(rec);
13593
13594 rec = dbwrap_fetch_locked(db, db, string_tdb_data(key));
13595 if (rec == NULL) {
13596 d_fprintf(stderr, "second fetch_locked failed\n");
13597 goto done;
13598 }
13599
13600 dbvalue = dbwrap_record_get_value(rec);
13601 if ((dbvalue.dsize != data.dsize)
13602 || (memcmp(dbvalue.dptr, data.dptr, data.dsize) != 0)) {
13603 d_fprintf(stderr, "Got wrong data back\n");
13604 goto done;
13605 }
13606
13607 ret = true;
13608 done:
13609 TALLOC_FREE(rec);
13610 return ret;
13611 }
13612
13613 static int local_rbtree_traverse_read(struct db_record *rec, void *private_data)
13614 {
13615 int *count2 = (int *)private_data;
13616 (*count2)++;
13617 return 0;
13618 }
13619
13620 static int local_rbtree_traverse_delete(struct db_record *rec, void *private_data)
13621 {
13622 int *count2 = (int *)private_data;
13623 (*count2)++;
13624 dbwrap_record_delete(rec);
13625 return 0;
13626 }
13627
13628 static bool run_local_rbtree(int dummy)
13629 {
13630 struct db_context *db;
13631 bool ret = false;
13632 int i;
13633 NTSTATUS status;
13634 int count = 0;
13635 int count2 = 0;
13636
13637 db = db_open_rbt(NULL);
13638
13639 if (db == NULL) {
13640 d_fprintf(stderr, "db_open_rbt failed\n");
13641 return false;
13642 }
13643
13644 if (!rbt_testflags(db, "firstkey", "firstval")) {
13645 goto done;
13646 }
13647
13648 for (i = 0; i < 999; i++) {
13649 char key[sizeof("key-9223372036854775807-1234")];
13650 char value[sizeof("value-9223372036854775807-1234")];
13651
13652 snprintf(key, sizeof(key), "key%ld-%d", random(), i);
13653 snprintf(value, sizeof(value) ,"value%ld-%d", random(), i);
13654
13655 if (!rbt_testval(db, key, value)) {
13656 goto done;
13657 }
13658
13659 snprintf(value, sizeof(value) ,"value%ld-%d", random(), i + 1);
13660
13661 if (!rbt_testval(db, key, value)) {
13662 goto done;
13663 }
13664 }
13665
13666 ret = true;
13667 count = 0; count2 = 0;
13668 status = dbwrap_traverse_read(db, local_rbtree_traverse_read,
13669 &count2, &count);
13670 printf("%s: read1: %d %d, %s\n", __func__, count, count2, nt_errstr(status));
13671 if ((count != count2) || (count != 1000)) {
13672 ret = false;
13673 }
13674 count = 0; count2 = 0;
13675 status = dbwrap_traverse(db, local_rbtree_traverse_delete,
13676 &count2, &count);
13677 printf("%s: delete: %d %d, %s\n", __func__, count, count2, nt_errstr(status));
13678 if ((count != count2) || (count != 1000)) {
13679 ret = false;
13680 }
13681 count = 0; count2 = 0;
13682 status = dbwrap_traverse_read(db, local_rbtree_traverse_read,
13683 &count2, &count);
13684 printf("%s: read2: %d %d, %s\n", __func__, count, count2, nt_errstr(status));
13685 if ((count != count2) || (count != 0)) {
13686 ret = false;
13687 }
13688
13689 done:
13690 TALLOC_FREE(db);
13691 return ret;
13692 }
13693
13694
13695 /*
13696 local test for character set functions
13697
13698 This is a very simple test for the functionality in convert_string_error()
13699 */
13700 static bool run_local_convert_string(int dummy)
13701 {
13702 TALLOC_CTX *tmp_ctx = talloc_new(NULL);
13703 const char *test_strings[2] = { "March", "M\303\244rz" };
13704 char dst[7];
13705 int i;
13706
13707 for (i=0; i<2; i++) {
13708 const char *str = test_strings[i];
13709 int len = strlen(str);
13710 size_t converted_size;
13711 bool ret;
13712
13713 memset(dst, 'X', sizeof(dst));
13714
13715 /* first try with real source length */
13716 ret = convert_string_error(CH_UNIX, CH_UTF8,
13717 str, len,
13718 dst, sizeof(dst),
13719 &converted_size);
13720 if (ret != true) {
13721 d_fprintf(stderr, "Failed to convert '%s' to CH_DISPLAY\n", str);
13722 goto failed;
13723 }
13724
13725 if (converted_size != len) {
13726 d_fprintf(stderr, "Converted size of '%s' should be %d - got %d\n",
13727 str, len, (int)converted_size);
13728 goto failed;
13729 }
13730
13731 if (strncmp(str, dst, converted_size) != 0) {
13732 d_fprintf(stderr, "Expected '%s' to match '%s'\n", str, dst);
13733 goto failed;
13734 }
13735
13736 if (strlen(str) != converted_size) {
13737 d_fprintf(stderr, "Expected '%s' length %d - got %d\n", str,
13738 (int)strlen(str), (int)converted_size);
13739 goto failed;
13740 }
13741
13742 if (dst[converted_size] != 'X') {
13743 d_fprintf(stderr, "Expected no termination of '%s'\n", dst);
13744 goto failed;
13745 }
13746
13747 /* now with srclen==-1, this causes the nul to be
13748 * converted too */
13749 ret = convert_string_error(CH_UNIX, CH_UTF8,
13750 str, -1,
13751 dst, sizeof(dst),
13752 &converted_size);
13753 if (ret != true) {
13754 d_fprintf(stderr, "Failed to convert '%s' to CH_DISPLAY\n", str);
13755 goto failed;
13756 }
13757
13758 if (converted_size != len+1) {
13759 d_fprintf(stderr, "Converted size of '%s' should be %d - got %d\n",
13760 str, len, (int)converted_size);
13761 goto failed;
13762 }
13763
13764 if (strncmp(str, dst, converted_size) != 0) {
13765 d_fprintf(stderr, "Expected '%s' to match '%s'\n", str, dst);
13766 goto failed;
13767 }
13768
13769 if (len+1 != converted_size) {
13770 d_fprintf(stderr, "Expected '%s' length %d - got %d\n", str,
13771 len+1, (int)converted_size);
13772 goto failed;
13773 }
13774
13775 if (dst[converted_size] != 'X') {
13776 d_fprintf(stderr, "Expected no termination of '%s'\n", dst);
13777 goto failed;
13778 }
13779
13780 }
13781
13782
13783 TALLOC_FREE(tmp_ctx);
13784 return true;
13785 failed:
13786 TALLOC_FREE(tmp_ctx);
13787 return false;
13788 }
13789
13790 static bool run_local_string_to_sid(int dummy) {
13791 struct dom_sid sid;
13792
13793 if (string_to_sid(&sid, "S--1-5-32-545")) {
13794 printf("allowing S--1-5-32-545\n");
13795 return false;
13796 }
13797 if (string_to_sid(&sid, "S-1-5-32-+545")) {
13798 printf("allowing S-1-5-32-+545\n");
13799 return false;
13800 }
13801 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")) {
13802 printf("allowing S-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0\n");
13803 return false;
13804 }
13805 if (string_to_sid(&sid, "S-1-5-32-545-abc")) {
13806 printf("allowing S-1-5-32-545-abc\n");
13807 return false;
13808 }
13809 if (string_to_sid(&sid, "S-300-5-32-545")) {
13810 printf("allowing S-300-5-32-545\n");
13811 return false;
13812 }
13813 if (string_to_sid(&sid, "S-1-0xfffffffffffffe-32-545")) {
13814 printf("allowing S-1-0xfffffffffffffe-32-545\n");
13815 return false;
13816 }
13817 if (string_to_sid(&sid, "S-1-0xffffffffffff-5294967297-545")) {
13818 printf("allowing S-1-0xffffffffffff-5294967297-545\n");
13819 return false;
13820 }
13821 if (!string_to_sid(&sid, "S-1-0xfffffffffffe-32-545")) {
13822 printf("could not parse S-1-0xfffffffffffe-32-545\n");
13823 return false;
13824 }
13825 if (!string_to_sid(&sid, "S-1-5-32-545")) {
13826 printf("could not parse S-1-5-32-545\n");
13827 return false;
13828 }
13829 if (!dom_sid_equal(&sid, &global_sid_Builtin_Users)) {
13830 struct dom_sid_buf buf;
13831 printf("mis-parsed S-1-5-32-545 as %s\n",
13832 dom_sid_str_buf(&sid, &buf));
13833 return false;
13834 }
13835 return true;
13836 }
13837
13838 static bool sid_to_string_test(const char *expected) {
13839 char *str;
13840 bool res = true;
13841 struct dom_sid sid;
13842
13843 if (!string_to_sid(&sid, expected)) {
13844 printf("could not parse %s\n", expected);
13845 return false;
13846 }
13847
13848 str = dom_sid_string(NULL, &sid);
13849 if (strcmp(str, expected)) {
13850 printf("Comparison failed (%s != %s)\n", str, expected);
13851 res = false;
13852 }
13853 TALLOC_FREE(str);
13854 return res;
13855 }
13856
13857 static bool run_local_sid_to_string(int dummy) {
13858 if (!sid_to_string_test("S-1-0xffffffffffff-1-1-1-1-1-1-1-1-1-1-1-1"))
13859 return false;
13860 if (!sid_to_string_test("S-1-545"))
13861 return false;
13862 if (!sid_to_string_test("S-255-3840-1-1-1-1"))
13863 return false;
13864 return true;
13865 }
13866
13867 static bool run_local_binary_to_sid(int dummy) {
13868 ssize_t ret;
13869 struct dom_sid *sid = talloc(NULL, struct dom_sid);
13870 static const uint8_t good_binary_sid[] = {
13871 0x1, /* revision number */
13872 15, /* num auths */
13873 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
13874 0x1, 0x1, 0x1, 0x1, /* auth[0] */
13875 0x1, 0x1, 0x1, 0x1, /* auth[1] */
13876 0x1, 0x1, 0x1, 0x1, /* auth[2] */
13877 0x1, 0x1, 0x1, 0x1, /* auth[3] */
13878 0x1, 0x1, 0x1, 0x1, /* auth[4] */
13879 0x1, 0x1, 0x1, 0x1, /* auth[5] */
13880 0x1, 0x1, 0x1, 0x1, /* auth[6] */
13881 0x1, 0x1, 0x1, 0x1, /* auth[7] */
13882 0x1, 0x1, 0x1, 0x1, /* auth[8] */
13883 0x1, 0x1, 0x1, 0x1, /* auth[9] */
13884 0x1, 0x1, 0x1, 0x1, /* auth[10] */
13885 0x1, 0x1, 0x1, 0x1, /* auth[11] */
13886 0x1, 0x1, 0x1, 0x1, /* auth[12] */
13887 0x1, 0x1, 0x1, 0x1, /* auth[13] */
13888 0x1, 0x1, 0x1, 0x1, /* auth[14] */
13889 };
13890
13891 static const uint8_t long_binary_sid[] = {
13892 0x1, /* revision number */
13893 15, /* num auths */
13894 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
13895 0x1, 0x1, 0x1, 0x1, /* auth[0] */
13896 0x1, 0x1, 0x1, 0x1, /* auth[1] */
13897 0x1, 0x1, 0x1, 0x1, /* auth[2] */
13898 0x1, 0x1, 0x1, 0x1, /* auth[3] */
13899 0x1, 0x1, 0x1, 0x1, /* auth[4] */
13900 0x1, 0x1, 0x1, 0x1, /* auth[5] */
13901 0x1, 0x1, 0x1, 0x1, /* auth[6] */
13902 0x1, 0x1, 0x1, 0x1, /* auth[7] */
13903 0x1, 0x1, 0x1, 0x1, /* auth[8] */
13904 0x1, 0x1, 0x1, 0x1, /* auth[9] */
13905 0x1, 0x1, 0x1, 0x1, /* auth[10] */
13906 0x1, 0x1, 0x1, 0x1, /* auth[11] */
13907 0x1, 0x1, 0x1, 0x1, /* auth[12] */
13908 0x1, 0x1, 0x1, 0x1, /* auth[13] */
13909 0x1, 0x1, 0x1, 0x1, /* auth[14] */
13910 0x1, 0x1, 0x1, 0x1, /* auth[15] */
13911 0x1, 0x1, 0x1, 0x1, /* auth[16] */
13912 0x1, 0x1, 0x1, 0x1, /* auth[17] */
13913 };
13914
13915 static const uint8_t long_binary_sid2[] = {
13916 0x1, /* revision number */
13917 32, /* num auths */
13918 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
13919 0x1, 0x1, 0x1, 0x1, /* auth[0] */
13920 0x1, 0x1, 0x1, 0x1, /* auth[1] */
13921 0x1, 0x1, 0x1, 0x1, /* auth[2] */
13922 0x1, 0x1, 0x1, 0x1, /* auth[3] */
13923 0x1, 0x1, 0x1, 0x1, /* auth[4] */
13924 0x1, 0x1, 0x1, 0x1, /* auth[5] */
13925 0x1, 0x1, 0x1, 0x1, /* auth[6] */
13926 0x1, 0x1, 0x1, 0x1, /* auth[7] */
13927 0x1, 0x1, 0x1, 0x1, /* auth[8] */
13928 0x1, 0x1, 0x1, 0x1, /* auth[9] */
13929 0x1, 0x1, 0x1, 0x1, /* auth[10] */
13930 0x1, 0x1, 0x1, 0x1, /* auth[11] */
13931 0x1, 0x1, 0x1, 0x1, /* auth[12] */
13932 0x1, 0x1, 0x1, 0x1, /* auth[13] */
13933 0x1, 0x1, 0x1, 0x1, /* auth[14] */
13934 0x1, 0x1, 0x1, 0x1, /* auth[15] */
13935 0x1, 0x1, 0x1, 0x1, /* auth[16] */
13936 0x1, 0x1, 0x1, 0x1, /* auth[17] */
13937 0x1, 0x1, 0x1, 0x1, /* auth[18] */
13938 0x1, 0x1, 0x1, 0x1, /* auth[19] */
13939 0x1, 0x1, 0x1, 0x1, /* auth[20] */
13940 0x1, 0x1, 0x1, 0x1, /* auth[21] */
13941 0x1, 0x1, 0x1, 0x1, /* auth[22] */
13942 0x1, 0x1, 0x1, 0x1, /* auth[23] */
13943 0x1, 0x1, 0x1, 0x1, /* auth[24] */
13944 0x1, 0x1, 0x1, 0x1, /* auth[25] */
13945 0x1, 0x1, 0x1, 0x1, /* auth[26] */
13946 0x1, 0x1, 0x1, 0x1, /* auth[27] */
13947 0x1, 0x1, 0x1, 0x1, /* auth[28] */
13948 0x1, 0x1, 0x1, 0x1, /* auth[29] */
13949 0x1, 0x1, 0x1, 0x1, /* auth[30] */
13950 0x1, 0x1, 0x1, 0x1, /* auth[31] */
13951 };
13952
13953 ret = sid_parse(good_binary_sid, sizeof(good_binary_sid), sid);
13954 if (ret == -1) {
13955 return false;
13956 }
13957 ret = sid_parse(long_binary_sid2, sizeof(long_binary_sid2), sid);
13958 if (ret != -1) {
13959 return false;
13960 }
13961 ret = sid_parse(long_binary_sid, sizeof(long_binary_sid), sid);
13962 if (ret != -1) {
13963 return false;
13964 }
13965 return true;
13966 }
13967
13968 /* Split a path name into filename and stream name components. Canonicalise
13969 * such that an implicit $DATA token is always explicit.
13970 *
13971 * The "specification" of this function can be found in the
13972 * run_local_stream_name() function in torture.c, I've tried those
13973 * combinations against a W2k3 server.
13974 */
13975
13976 static NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
13977 char **pbase, char **pstream)
13978 {
13979 char *base = NULL;
13980 char *stream = NULL;
13981 char *sname; /* stream name */
13982 const char *stype; /* stream type */
13983
13984 DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
13985
13986 sname = strchr_m(fname, ':');
13987
13988 if (sname == NULL) {
13989 if (pbase != NULL) {
13990 base = talloc_strdup(mem_ctx, fname);
13991 NT_STATUS_HAVE_NO_MEMORY(base);
13992 }
13993 goto done;
13994 }
13995
13996 if (pbase != NULL) {
13997 base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
13998 NT_STATUS_HAVE_NO_MEMORY(base);
13999 }
14000
14001 sname += 1;
14002
14003 stype = strchr_m(sname, ':');
14004
14005 if (stype == NULL) {
14006 sname = talloc_strdup(mem_ctx, sname);
14007 stype = "$DATA";
14008 }
14009 else {
14010 if (strcasecmp_m(stype, ":$DATA") != 0) {
14011 /*
14012 * If there is an explicit stream type, so far we only
14013 * allow $DATA. Is there anything else allowed? -- vl
14014 */
14015 DEBUG(10, ("[%s] is an invalid stream type\n", stype));
14016 TALLOC_FREE(base);
14017 return NT_STATUS_OBJECT_NAME_INVALID;
14018 }
14019 sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
14020 stype += 1;
14021 }
14022
14023 if (sname == NULL) {
14024 TALLOC_FREE(base);
14025 return NT_STATUS_NO_MEMORY;
14026 }
14027
14028 if (sname[0] == '\0') {
14029 /*
14030 * no stream name, so no stream
14031 */
14032 goto done;
14033 }
14034
14035 if (pstream != NULL) {
14036 stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
14037 if (stream == NULL) {
14038 TALLOC_FREE(sname);
14039 TALLOC_FREE(base);
14040 return NT_STATUS_NO_MEMORY;
14041 }
14042 /*
14043 * upper-case the type field
14044 */
14045 (void)strupper_m(strchr_m(stream, ':')+1);
14046 }
14047
14048 done:
14049 if (pbase != NULL) {
14050 *pbase = base;
14051 }
14052 if (pstream != NULL) {
14053 *pstream = stream;
14054 }
14055 return NT_STATUS_OK;
14056 }
14057
14058 static bool test_stream_name(const char *fname, const char *expected_base,
14059 const char *expected_stream,
14060 NTSTATUS expected_status)
14061 {
14062 NTSTATUS status;
14063 char *base = NULL;
14064 char *stream = NULL;
14065
14066 status = split_ntfs_stream_name(talloc_tos(), fname, &base, &stream);
14067 if (!NT_STATUS_EQUAL(status, expected_status)) {
14068 goto error;
14069 }
14070
14071 if (!NT_STATUS_IS_OK(status)) {
14072 return true;
14073 }
14074
14075 if (base == NULL) goto error;
14076
14077 if (strcmp(expected_base, base) != 0) goto error;
14078
14079 if ((expected_stream != NULL) && (stream == NULL)) goto error;
14080 if ((expected_stream == NULL) && (stream != NULL)) goto error;
14081
14082 if ((stream != NULL) && (strcmp(expected_stream, stream) != 0))
14083 goto error;
14084
14085 TALLOC_FREE(base);
14086 TALLOC_FREE(stream);
14087 return true;
14088
14089 error:
14090 d_fprintf(stderr, "Do test_stream(%s, %s, %s, %s)\n",
14091 fname, expected_base ? expected_base : "<NULL>",
14092 expected_stream ? expected_stream : "<NULL>",
14093 nt_errstr(expected_status));
14094 d_fprintf(stderr, "-> base=%s, stream=%s, status=%s\n",
14095 base ? base : "<NULL>", stream ? stream : "<NULL>",
14096 nt_errstr(status));
14097 TALLOC_FREE(base);
14098 TALLOC_FREE(stream);
14099 return false;
14100 }
14101
14102 static bool run_local_stream_name(int dummy)
14103 {
14104 bool ret = true;
14105
14106 ret &= test_stream_name(
14107 "bla", "bla", NULL, NT_STATUS_OK);
14108 ret &= test_stream_name(
14109 "bla::$DATA", "bla", NULL, NT_STATUS_OK);
14110 ret &= test_stream_name(
14111 "bla:blub:", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
14112 ret &= test_stream_name(
14113 "bla::", NULL, NULL, NT_STATUS_OBJECT_NAME_INVALID);
14114 ret &= test_stream_name(
14115 "bla::123", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
14116 ret &= test_stream_name(
14117 "bla:$DATA", "bla", "$DATA:$DATA", NT_STATUS_OK);
14118 ret &= test_stream_name(
14119 "bla:x:$DATA", "bla", "x:$DATA", NT_STATUS_OK);
14120 ret &= test_stream_name(
14121 "bla:x", "bla", "x:$DATA", NT_STATUS_OK);
14122
14123 return ret;
14124 }
14125
14126 static bool data_blob_equal(DATA_BLOB a, DATA_BLOB b)
14127 {
14128 if (a.length != b.length) {
14129 printf("a.length=%d != b.length=%d\n",
14130 (int)a.length, (int)b.length);
14131 return false;
14132 }
14133 if (memcmp(a.data, b.data, a.length) != 0) {
14134 printf("a.data and b.data differ\n");
14135 return false;
14136 }
14137 return true;
14138 }
14139
14140 static bool run_local_memcache(int dummy)
14141 {
14142 struct memcache *cache;
14143 DATA_BLOB k1, k2, k3, k4, k5;
14144 DATA_BLOB d1, d3;
14145 DATA_BLOB v1, v3;
14146
14147 TALLOC_CTX *mem_ctx;
14148 char *ptr1 = NULL;
14149 char *ptr2 = NULL;
14150 char *ptr3 = NULL;
14151
14152 char *str1, *str2;
14153 size_t size1, size2;
14154 bool ret = false;
14155
14156 mem_ctx = talloc_init("foo");
14157 if (mem_ctx == NULL) {
14158 return false;
14159 }
14160
14161 /* STAT_CACHE TESTS */
14162
14163 cache = memcache_init(NULL, sizeof(void *) == 8 ? 200 : 100);
14164
14165 if (cache == NULL) {
14166 printf("memcache_init failed\n");
14167 return false;
14168 }
14169
14170 d1 = data_blob_const("d1", 2);
14171 d3 = data_blob_const("d3", 2);
14172
14173 k1 = data_blob_const("d1", 2);
14174 k2 = data_blob_const("d2", 2);
14175 k3 = data_blob_const("d3", 2);
14176 k4 = data_blob_const("d4", 2);
14177 k5 = data_blob_const("d5", 2);
14178
14179 memcache_add(cache, STAT_CACHE, k1, d1);
14180
14181 if (!memcache_lookup(cache, STAT_CACHE, k1, &v1)) {
14182 printf("could not find k1\n");
14183 return false;
14184 }
14185 if (!data_blob_equal(d1, v1)) {
14186 return false;
14187 }
14188
14189 memcache_add(cache, STAT_CACHE, k1, d3);
14190
14191 if (!memcache_lookup(cache, STAT_CACHE, k1, &v3)) {
14192 printf("could not find replaced k1\n");
14193 return false;
14194 }
14195 if (!data_blob_equal(d3, v3)) {
14196 return false;
14197 }
14198
14199 TALLOC_FREE(cache);
14200
14201 /* GETWD_CACHE TESTS */
14202 str1 = talloc_strdup(mem_ctx, "string1");
14203 if (str1 == NULL) {
14204 return false;
14205 }
14206 ptr2 = str1; /* Keep an alias for comparison. */
14207
14208 str2 = talloc_strdup(mem_ctx, "string2");
14209 if (str2 == NULL) {
14210 return false;
14211 }
14212
14213 cache = memcache_init(NULL, sizeof(void *) == 8 ? 200 : 100);
14214 if (cache == NULL) {
14215 printf("memcache_init failed\n");
14216 return false;
14217 }
14218
14219 memcache_add_talloc(cache, GETWD_CACHE, k2, &str1);
14220 /* str1 == NULL now. */
14221 ptr1 = memcache_lookup_talloc(cache, GETWD_CACHE, k2);
14222 if (ptr1 == NULL) {
14223 printf("could not find k2\n");
14224 return false;
14225 }
14226 if (ptr1 != ptr2) {
14227 printf("fetch of k2 got wrong string\n");
14228 return false;
14229 }
14230
14231 /* Add a blob to ensure k2 gets purged. */
14232 d3 = data_blob_talloc_zero(mem_ctx, 180);
14233 memcache_add(cache, STAT_CACHE, k3, d3);
14234
14235 ptr2 = memcache_lookup_talloc(cache, GETWD_CACHE, k2);
14236 if (ptr2 != NULL) {
14237 printf("Did find k2, should have been purged\n");
14238 return false;
14239 }
14240
14241 /*
14242 * Test that talloc size also is accounted in memcache and
14243 * causes purge of other object.
14244 */
14245
14246 str1 = talloc_zero_size(mem_ctx, 100);
14247 str2 = talloc_zero_size(mem_ctx, 100);
14248
14249 memcache_add_talloc(cache, GETWD_CACHE, k4, &str1);
14250 memcache_add_talloc(cache, GETWD_CACHE, k5, &str1);
14251
14252 ptr3 = memcache_lookup_talloc(cache, GETWD_CACHE, k4);
14253 if (ptr3 != NULL) {
14254 printf("Did find k4, should have been purged\n");
14255 return false;
14256 }
14257
14258 /*
14259 * Test that adding a duplicate non-talloced
14260 * key/value on top of a talloced key/value takes account
14261 * of the talloc_freed value size.
14262 */
14263 TALLOC_FREE(cache);
14264 TALLOC_FREE(mem_ctx);
14265
14266 mem_ctx = talloc_init("key_replace");
14267 if (mem_ctx == NULL) {
14268 return false;
14269 }
14270
14271 cache = memcache_init(NULL, sizeof(void *) == 8 ? 200 : 100);
14272 if (cache == NULL) {
14273 return false;
14274 }
14275
14276 /*
14277 * Add a 100 byte talloced string. This will
14278 * store a (4 or 8 byte) pointer and record the
14279 * total talloced size.
14280 */
14281 str1 = talloc_zero_size(mem_ctx, 100);
14282 memcache_add_talloc(cache, GETWD_CACHE, k4, &str1);
14283 /*
14284 * Now overwrite with a small talloced
14285 * value. This should fit in the existing size
14286 * and the total talloced size should be removed
14287 * from the cache size.
14288 */
14289 str1 = talloc_zero_size(mem_ctx, 2);
14290 memcache_add_talloc(cache, GETWD_CACHE, k4, &str1);
14291 /*
14292 * Now store a 20 byte string. If the
14293 * total talloced size wasn't accounted for
14294 * and removed in the overwrite, then this
14295 * will evict k4.
14296 */
14297 str2 = talloc_zero_size(mem_ctx, 20);
14298 memcache_add_talloc(cache, GETWD_CACHE, k5, &str2);
14299
14300 ptr3 = memcache_lookup_talloc(cache, GETWD_CACHE, k4);
14301 if (ptr3 == NULL) {
14302 printf("Did not find k4, should not have been purged\n");
14303 return false;
14304 }
14305
14306 TALLOC_FREE(cache);
14307 TALLOC_FREE(mem_ctx);
14308
14309 mem_ctx = talloc_init("foo");
14310 if (mem_ctx == NULL) {
14311 return false;
14312 }
14313
14314 cache = memcache_init(NULL, 0);
14315 if (cache == NULL) {
14316 return false;
14317 }
14318
14319 str1 = talloc_strdup(mem_ctx, "string1");
14320 if (str1 == NULL) {
14321 return false;
14322 }
14323 str2 = talloc_strdup(mem_ctx, "string2");
14324 if (str2 == NULL) {
14325 return false;
14326 }
14327 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
14328 data_blob_string_const("torture"), &str1);
14329 size1 = talloc_total_size(cache);
14330
14331 memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
14332 data_blob_string_const("torture"), &str2);
14333 size2 = talloc_total_size(cache);
14334
14335 printf("size1=%d, size2=%d\n", (int)size1, (int)size2);
14336
14337 if (size2 > size1) {
14338 printf("memcache leaks memory!\n");
14339 goto fail;
14340 }
14341
14342 ret = true;
14343 fail:
14344 TALLOC_FREE(cache);
14345 return ret;
14346 }
14347
14348 static void wbclient_done(struct tevent_req *req)
14349 {
14350 wbcErr wbc_err;
14351 struct winbindd_response *wb_resp;
14352 int *i = (int *)tevent_req_callback_data_void(req);
14353
14354 wbc_err = wb_trans_recv(req, req, &wb_resp);
14355 TALLOC_FREE(req);
14356 *i += 1;
14357 d_printf("wb_trans_recv %d returned %s\n", *i, wbcErrorString(wbc_err));
14358 }
14359
14360 static bool run_wbclient_multi_ping(int dummy)
14361 {
14362 struct tevent_context *ev;
14363 struct wb_context **wb_ctx;
14364 struct winbindd_request wb_req;
14365 bool result = false;
14366 int i, j;
14367
14368 BlockSignals(True, SIGPIPE);
14369
14370 ev = tevent_context_init(talloc_tos());
14371 if (ev == NULL) {
14372 goto fail;
14373 }
14374
14375 wb_ctx = talloc_array(ev, struct wb_context *, torture_nprocs);
14376 if (wb_ctx == NULL) {
14377 goto fail;
14378 }
14379
14380 ZERO_STRUCT(wb_req);
14381 wb_req.cmd = WINBINDD_PING;
14382
14383 d_printf("torture_nprocs=%d, numops=%d\n", (int)torture_nprocs, (int)torture_numops);
14384
14385 for (i=0; i<torture_nprocs; i++) {
14386 wb_ctx[i] = wb_context_init(ev, NULL);
14387 if (wb_ctx[i] == NULL) {
14388 goto fail;
14389 }
14390 for (j=0; j<torture_numops; j++) {
14391 struct tevent_req *req;
14392 req = wb_trans_send(ev, ev, wb_ctx[i],
14393 (j % 2) == 0, &wb_req);
14394 if (req == NULL) {
14395 goto fail;
14396 }
14397 tevent_req_set_callback(req, wbclient_done, &i);
14398 }
14399 }
14400
14401 i = 0;
14402
14403 while (i < torture_nprocs * torture_numops) {
14404 tevent_loop_once(ev);
14405 }
14406
14407 result = true;
14408 fail:
14409 TALLOC_FREE(ev);
14410 return result;
14411 }
14412
14413 static bool dbtrans_inc(struct db_context *db)
14414 {
14415 struct db_record *rec;
14416 uint32_t val;
14417 bool ret = false;
14418 NTSTATUS status;
14419 TDB_DATA value;
14420
14421 rec = dbwrap_fetch_locked(db, db, string_term_tdb_data("transtest"));
14422 if (rec == NULL) {
14423 printf(__location__ "fetch_lock failed\n");
14424 return false;
14425 }
14426
14427 value = dbwrap_record_get_value(rec);
14428
14429 if (value.dsize != sizeof(uint32_t)) {
14430 printf(__location__ "value.dsize = %d\n",
14431 (int)value.dsize);
14432 goto fail;
14433 }
14434
14435 memcpy(&val, value.dptr, sizeof(val));
14436 val += 1;
14437
14438 status = dbwrap_record_store(
14439 rec, make_tdb_data((uint8_t *)&val, sizeof(val)), 0);
14440 if (!NT_STATUS_IS_OK(status)) {
14441 printf(__location__ "store failed: %s\n",
14442 nt_errstr(status));
14443 goto fail;
14444 }
14445
14446 ret = true;
14447 fail:
14448 TALLOC_FREE(rec);
14449 return ret;
14450 }
14451
14452 static bool run_local_dbtrans(int dummy)
14453 {
14454 struct db_context *db;
14455 struct db_record *rec;
14456 NTSTATUS status;
14457 uint32_t initial;
14458 int res;
14459 TDB_DATA value;
14460
14461 db = db_open(talloc_tos(), "transtest.tdb", 0, TDB_DEFAULT,
14462 O_RDWR|O_CREAT, 0600, DBWRAP_LOCK_ORDER_1,
14463 DBWRAP_FLAG_NONE);
14464 if (db == NULL) {
14465 printf("Could not open transtest.db\n");
14466 return false;
14467 }
14468
14469 res = dbwrap_transaction_start(db);
14470 if (res != 0) {
14471 printf(__location__ "transaction_start failed\n");
14472 return false;
14473 }
14474
14475 rec = dbwrap_fetch_locked(db, db, string_term_tdb_data("transtest"));
14476 if (rec == NULL) {
14477 printf(__location__ "fetch_lock failed\n");
14478 return false;
14479 }
14480
14481 value = dbwrap_record_get_value(rec);
14482
14483 if (value.dptr == NULL) {
14484 initial = 0;
14485 status = dbwrap_record_store(
14486 rec, make_tdb_data((uint8_t *)&initial,
14487 sizeof(initial)),
14488 0);
14489 if (!NT_STATUS_IS_OK(status)) {
14490 printf(__location__ "store returned %s\n",
14491 nt_errstr(status));
14492 return false;
14493 }
14494 }
14495
14496 TALLOC_FREE(rec);
14497
14498 res = dbwrap_transaction_commit(db);
14499 if (res != 0) {
14500 printf(__location__ "transaction_commit failed\n");
14501 return false;
14502 }
14503
14504 while (true) {
14505 uint32_t val, val2;
14506 int i;
14507
14508 res = dbwrap_transaction_start(db);
14509 if (res != 0) {
14510 printf(__location__ "transaction_start failed\n");
14511 break;
14512 }
14513
14514 status = dbwrap_fetch_uint32_bystring(db, "transtest", &val);
14515 if (!NT_STATUS_IS_OK(status)) {
14516 printf(__location__ "dbwrap_fetch_uint32 failed: %s\n",
14517 nt_errstr(status));
14518 break;
14519 }
14520
14521 for (i=0; i<10; i++) {
14522 if (!dbtrans_inc(db)) {
14523 return false;
14524 }
14525 }
14526
14527 status = dbwrap_fetch_uint32_bystring(db, "transtest", &val2);
14528 if (!NT_STATUS_IS_OK(status)) {
14529 printf(__location__ "dbwrap_fetch_uint32 failed: %s\n",
14530 nt_errstr(status));
14531 break;
14532 }
14533
14534 if (val2 != val + 10) {
14535 printf(__location__ "val=%d, val2=%d\n",
14536 (int)val, (int)val2);
14537 break;
14538 }
14539
14540 printf("val2=%d\r", val2);
14541
14542 res = dbwrap_transaction_commit(db);
14543 if (res != 0) {
14544 printf(__location__ "transaction_commit failed\n");
14545 break;
14546 }
14547 }
14548
14549 TALLOC_FREE(db);
14550 return true;
14551 }
14552
14553 /*
14554 * Just a dummy test to be run under a debugger. There's no real way
14555 * to inspect the tevent_poll specific function from outside of
14556 * tevent_poll.c.
14557 */
14558
14559 static bool run_local_tevent_poll(int dummy)
14560 {
14561 struct tevent_context *ev;
14562 struct tevent_fd *fd1, *fd2;
14563 bool result = false;
14564
14565 ev = tevent_context_init_byname(NULL, "poll");
14566 if (ev == NULL) {
14567 d_fprintf(stderr, "tevent_context_init_byname failed\n");
14568 goto fail;
14569 }
14570
14571 fd1 = tevent_add_fd(ev, ev, 2, 0, NULL, NULL);
14572 if (fd1 == NULL) {
14573 d_fprintf(stderr, "tevent_add_fd failed\n");
14574 goto fail;
14575 }
14576 fd2 = tevent_add_fd(ev, ev, 3, 0, NULL, NULL);
14577 if (fd2 == NULL) {
14578 d_fprintf(stderr, "tevent_add_fd failed\n");
14579 goto fail;
14580 }
14581 TALLOC_FREE(fd2);
14582
14583 fd2 = tevent_add_fd(ev, ev, 1, 0, NULL, NULL);
14584 if (fd2 == NULL) {
14585 d_fprintf(stderr, "tevent_add_fd failed\n");
14586 goto fail;
14587 }
14588
14589 result = true;
14590 fail:
14591 TALLOC_FREE(ev);
14592 return result;
14593 }
14594
14595 static bool run_local_hex_encode_buf(int dummy)
14596 {
14597 char buf[17];
14598 uint8_t src[8];
14599 size_t i;
14600
14601 for (i=0; i<sizeof(src); i++) {
14602 src[i] = i;
14603 }
14604 hex_encode_buf(buf, src, sizeof(src));
14605 if (strcmp(buf, "0001020304050607") != 0) {
14606 return false;
14607 }
14608 hex_encode_buf(buf, NULL, 0);
14609 if (buf[0] != '\0') {
14610 return false;
14611 }
14612 return true;
14613 }
14614
14615 static const char *remove_duplicate_addrs2_test_strings_vector[] = {
14616 "0.0.0.0",
14617 "::0",
14618 "1.2.3.1",
14619 "0.0.0.0",
14620 "0.0.0.0",
14621 "1.2.3.2",
14622 "1.2.3.3",
14623 "1.2.3.4",
14624 "1.2.3.5",
14625 "::0",
14626 "1.2.3.6",
14627 "1.2.3.7",
14628 "::0",
14629 "::0",
14630 "::0",
14631 "1.2.3.8",
14632 "1.2.3.9",
14633 "1.2.3.10",
14634 "1.2.3.11",
14635 "1.2.3.12",
14636 "1.2.3.13",
14637 "1001:1111:1111:1000:0:1111:1111:1111",
14638 "1.2.3.1",
14639 "1.2.3.2",
14640 "1.2.3.3",
14641 "1.2.3.12",
14642 "::0",
14643 "::0"
14644 };
14645
14646 static const char *remove_duplicate_addrs2_test_strings_result[] = {
14647 "1.2.3.1",
14648 "1.2.3.2",
14649 "1.2.3.3",
14650 "1.2.3.4",
14651 "1.2.3.5",
14652 "1.2.3.6",
14653 "1.2.3.7",
14654 "1.2.3.8",
14655 "1.2.3.9",
14656 "1.2.3.10",
14657 "1.2.3.11",
14658 "1.2.3.12",
14659 "1.2.3.13",
14660 "1001:1111:1111:1000:0:1111:1111:1111"
14661 };
14662
14663 static bool run_local_remove_duplicate_addrs2(int dummy)
14664 {
14665 struct samba_sockaddr test_vector[28];
14666 size_t count, i;
14667
14668 /* Construct the sockaddr_storage test vector. */
14669 for (i = 0; i < 28; i++) {
14670 struct addrinfo hints;
14671 struct addrinfo *res = NULL;
14672 int ret;
14673
14674 memset(&hints, '\0', sizeof(hints));
14675 hints.ai_flags = AI_NUMERICHOST;
14676 ret = getaddrinfo(remove_duplicate_addrs2_test_strings_vector[i],
14677 NULL,
14678 &hints,
14679 &res);
14680 if (ret) {
14681 fprintf(stderr, "getaddrinfo failed on [%s]\n",
14682 remove_duplicate_addrs2_test_strings_vector[i]);
14683 return false;
14684 }
14685 memset(&test_vector[i], '\0', sizeof(test_vector[i]));
14686 memcpy(&test_vector[i].u.ss,
14687 res->ai_addr,
14688 res->ai_addrlen);
14689 freeaddrinfo(res);
14690 }
14691
14692 count = remove_duplicate_addrs2(test_vector, i);
14693
14694 if (count != 14) {
14695 fprintf(stderr, "count wrong (%zu) should be 14\n",
14696 count);
14697 return false;
14698 }
14699
14700 for (i = 0; i < count; i++) {
14701 char addr[INET6_ADDRSTRLEN];
14702
14703 print_sockaddr(addr, sizeof(addr), &test_vector[i].u.ss);
14704
14705 if (strcmp(addr, remove_duplicate_addrs2_test_strings_result[i]) != 0) {
14706 fprintf(stderr, "mismatch on [%zu] [%s] [%s]\n",
14707 i,
14708 addr,
14709 remove_duplicate_addrs2_test_strings_result[i]);
14710 return false;
14711 }
14712 }
14713
14714 printf("run_local_remove_duplicate_addrs2: success\n");
14715 return true;
14716 }
14717
14718 static bool run_local_tdb_opener(int dummy)
14719 {
14720 TDB_CONTEXT *t;
14721 unsigned v = 0;
14722
14723 while (1) {
14724 t = tdb_open("test.tdb", 1000, TDB_CLEAR_IF_FIRST,
14725 O_RDWR|O_CREAT, 0755);
14726 if (t == NULL) {
14727 perror("tdb_open failed");
14728 return false;
14729 }
14730 tdb_close(t);
14731
14732 v += 1;
14733 printf("\r%u", v);
14734 }
14735 return true;
14736 }
14737
14738 static bool run_local_tdb_writer(int dummy)
14739 {
14740 TDB_CONTEXT *t;
14741 unsigned v = 0;
14742 TDB_DATA val;
14743
14744 t = tdb_open("test.tdb", 1000, 0, O_RDWR|O_CREAT, 0755);
14745 if (t == 0) {
14746 perror("tdb_open failed");
14747 return 1;
14748 }
14749
14750 val.dptr = (uint8_t *)&v;
14751 val.dsize = sizeof(v);
14752
14753 while (1) {
14754 TDB_DATA data;
14755 int ret;
14756
14757 ret = tdb_store(t, val, val, 0);
14758 if (ret != 0) {
14759 printf("%s\n", tdb_errorstr(t));
14760 }
14761 v += 1;
14762 printf("\r%u", v);
14763
14764 data = tdb_fetch(t, val);
14765 if (data.dptr != NULL) {
14766 SAFE_FREE(data.dptr);
14767 }
14768 }
14769 return true;
14770 }
14771
14772 static bool run_local_canonicalize_path(int dummy)
14773 {
14774 const char *src[] = {
14775 "/foo/..",
14776 "/..",
14777 "/foo/bar/../baz",
14778 "/foo/././",
14779 "/../foo",
14780 ".././././",
14781 ".././././../../../boo",
14782 "./..",
14783 "/",
14784 "/../../",
14785 "/foo/../",
14786 "/./././",
14787 "/./././.",
14788 "/.../././.",
14789 "/./././.foo",
14790 "/./././.foo.",
14791 "/./././foo.",
14792 "/foo/bar/..",
14793 "/foo/bar/../baz/",
14794 "////////////////",
14795 "/////////./././././.",
14796 "/./.././../.boo/../baz",
14797 "/a/component/path",
14798 "/a/component/path/",
14799 "/a/component/path/..",
14800 "/a/component/../path/",
14801 "///a/./././///component/../////path/",
14802 NULL
14803 };
14804 const char *dst[] = {
14805 "/",
14806 "/",
14807 "/foo/baz",
14808 "/foo",
14809 "/foo",
14810 "/",
14811 "/boo",
14812 "/",
14813 "/",
14814 "/",
14815 "/",
14816 "/",
14817 "/",
14818 "/...",
14819 "/.foo",
14820 "/.foo.",
14821 "/foo.",
14822 "/foo",
14823 "/foo/baz",
14824 "/",
14825 "/",
14826 "/baz",
14827 "/a/component/path",
14828 "/a/component/path",
14829 "/a/component",
14830 "/a/path",
14831 "/a/path",
14832 NULL
14833 };
14834 unsigned int i;
14835
14836 for (i = 0; src[i] != NULL; i++) {
14837 char *d = canonicalize_absolute_path(talloc_tos(), src[i]);
14838 if (d == NULL) {
14839 perror("talloc fail\n");
14840 return false;
14841 }
14842 if (strcmp(d, dst[i]) != 0) {
14843 d_fprintf(stderr,
14844 "canonicalize mismatch %s -> %s != %s",
14845 src[i], d, dst[i]);
14846 return false;
14847 }
14848 talloc_free(d);
14849 }
14850 return true;
14851 }
14852 struct session_setup_nt1_truncated_state {
14853 uint16_t vwv[13];
14854 uint8_t bytes[20];
14855 };
14856
14857 static void smb1_session_setup_nt1_truncated_done(struct tevent_req *subreq);
14858
14859 static struct tevent_req *smb1_session_setup_nt1_truncated_send(
14860 TALLOC_CTX *mem_ctx,
14861 struct tevent_context *ev,
14862 struct smbXcli_conn *conn)
14863 {
14864 uint16_t *vwv = NULL;
14865 uint8_t *bytes = NULL;
14866 const char *pass = "12345678";
14867 const char *uname = "z";
14868 struct session_setup_nt1_truncated_state *state = NULL;
14869 struct tevent_req *req = NULL;
14870 struct tevent_req *subreq = NULL;
14871
14872 req = tevent_req_create(mem_ctx,
14873 &state,
14874 struct session_setup_nt1_truncated_state);
14875 if (req == NULL) {
14876 return NULL;
14877 }
14878 vwv = &state->vwv[0];
14879 bytes = &state->bytes[0];
14880
14881 SCVAL(vwv+0, 0, 0xff);
14882 SCVAL(vwv+0, 1, 0);
14883 SSVAL(vwv+1, 0, 0);
14884 SSVAL(vwv+2, 0, 8192);
14885 SSVAL(vwv+3, 0, 2);
14886 SSVAL(vwv+4, 0, 1);
14887 SIVAL(vwv+5, 0, 0);
14888 SSVAL(vwv+7, 0, strlen(pass)); /* OEMPasswordLen */
14889 SSVAL(vwv+8, 0, 0); /* UnicodePasswordLen */
14890 SSVAL(vwv+9, 0, 0); /* reserved */
14891 SSVAL(vwv+10, 0, 0); /* reserved */
14892 SIVAL(vwv+11, 0, CAP_STATUS32);
14893
14894 memcpy(bytes, pass, strlen(pass));
14895 bytes += strlen(pass);
14896 memcpy(bytes, uname, strlen(uname)+1);
14897
14898 subreq = smb1cli_req_send(state, ev, conn,
14899 SMBsesssetupX,
14900 0, /* additional_flags */
14901 0, /* clear_flags */
14902 0, /* additional_flags2 */
14903 0, /* clear_flags2 */
14904 10000, /* timeout_msec */
14905 getpid(),
14906 NULL, /* tcon */
14907 NULL, /* session */
14908 13, /* wct */
14909 state->vwv,
14910 strlen(pass), /* Truncate length at password. */
14911 state->bytes);
14912 if (tevent_req_nomem(subreq, req)) {
14913 return tevent_req_post(req, ev);
14914 }
14915 tevent_req_set_callback(subreq,
14916 smb1_session_setup_nt1_truncated_done,
14917 req);
14918 return req;
14919 }
14920
14921 static void smb1_session_setup_nt1_truncated_done(struct tevent_req *subreq)
14922 {
14923 struct tevent_req *req =
14924 tevent_req_callback_data(subreq,
14925 struct tevent_req);
14926 struct session_setup_nt1_truncated_state *state =
14927 tevent_req_data(req,
14928 struct session_setup_nt1_truncated_state);
14929 NTSTATUS status;
14930 struct smb1cli_req_expected_response expected[] = {
14931 {
14932 .status = NT_STATUS_OK,
14933 .wct = 3,
14934 },
14935 };
14936
14937 status = smb1cli_req_recv(subreq, state,
14938 NULL,
14939 NULL,
14940 NULL,
14941 NULL,
14942 NULL, /* pvwv_offset */
14943 NULL,
14944 NULL,
14945 NULL, /* pbytes_offset */
14946 NULL,
14947 expected, ARRAY_SIZE(expected));
14948 TALLOC_FREE(subreq);
14949 if (tevent_req_nterror(req, status)) {
14950 return;
14951 }
14952 tevent_req_done(req);
14953 }
14954
14955 static NTSTATUS smb1_session_setup_nt1_truncated_recv(struct tevent_req *req)
14956 {
14957 return tevent_req_simple_recv_ntstatus(req);
14958 }
14959
14960 static bool run_smb1_truncated_sesssetup(int dummy)
14961 {
14962 struct tevent_context *ev;
14963 struct tevent_req *req;
14964 struct smbXcli_conn *conn;
14965 struct sockaddr_storage ss;
14966 NTSTATUS status;
14967 int fd;
14968 bool ok;
14969
14970 printf("Starting send truncated SMB1 sesssetup.\n");
14971
14972 ok = resolve_name(host, &ss, 0x20, true);
14973 if (!ok) {
14974 d_fprintf(stderr, "Could not resolve name %s\n", host);
14975 return false;
14976 }
14977
14978 status = open_socket_out(&ss, 445, 10000, &fd);
14979 if (!NT_STATUS_IS_OK(status)) {
14980 d_fprintf(stderr, "open_socket_out failed: %s\n",
14981 nt_errstr(status));
14982 return false;
14983 }
14984
14985 conn = smbXcli_conn_create(talloc_tos(), fd, host, SMB_SIGNING_OFF, 0,
14986 NULL, 0, NULL);
14987 if (conn == NULL) {
14988 d_fprintf(stderr, "smbXcli_conn_create failed\n");
14989 return false;
14990 }
14991
14992 status = smbXcli_negprot(conn,
14993 0,
14994 PROTOCOL_NT1,
14995 PROTOCOL_NT1,
14996 NULL,
14997 NULL,
14998 NULL);
14999 if (!NT_STATUS_IS_OK(status)) {
15000 d_fprintf(stderr, "smbXcli_negprot failed!\n");
15001 return false;
15002 }
15003
15004 ev = samba_tevent_context_init(talloc_tos());
15005 if (ev == NULL) {
15006 d_fprintf(stderr, "samba_tevent_context_init failed\n");
15007 return false;
15008 }
15009
15010 req = smb1_session_setup_nt1_truncated_send(ev, ev, conn);
15011 if (req == NULL) {
15012 d_fprintf(stderr, "smb1_session_setup_nt1_truncated_send failed\n");
15013 return false;
15014 }
15015
15016 ok = tevent_req_poll_ntstatus(req, ev, &status);
15017 if (!ok) {
15018 d_fprintf(stderr, "tevent_req_poll failed with status %s\n",
15019 nt_errstr(status));
15020 return false;
15021 }
15022
15023 status = smb1_session_setup_nt1_truncated_recv(req);
15024 if (!NT_STATUS_IS_OK(status)) {
15025 d_fprintf(stderr, "smb1_session_setup_nt1_truncated_recv returned "
15026 "%s, expected NT_STATUS_OK\n",
15027 nt_errstr(status));
15028 return false;
15029 }
15030
15031 TALLOC_FREE(conn);
15032 return true;
15033 }
15034
15035 struct smb1_negotiate_exit_state {
15036 int dummy;
15037 };
15038
15039 static void smb1_negotiate_exit_done(struct tevent_req *subreq);
15040
15041 static struct tevent_req *smb1_negotiate_exit_send(
15042 TALLOC_CTX *mem_ctx,
15043 struct tevent_context *ev,
15044 struct smbXcli_conn *conn)
15045 {
15046 struct smb1_negotiate_exit_state *state = NULL;
15047 struct tevent_req *req = NULL;
15048 struct tevent_req *subreq = NULL;
15049
15050 req = tevent_req_create(mem_ctx,
15051 &state,
15052 struct smb1_negotiate_exit_state);
15053 if (req == NULL) {
15054 return NULL;
15055 }
15056 subreq = smb1cli_req_send(state, ev, conn,
15057 SMBexit,
15058 0, /* additional_flags */
15059 0, /* clear_flags */
15060 0, /* additional_flags2 */
15061 0, /* clear_flags2 */
15062 10000, /* timeout_msec */
15063 getpid(),
15064 NULL, /* tcon */
15065 NULL, /* session */
15066 0, /* wct */
15067 NULL,
15068 0,
15069 NULL);
15070 if (tevent_req_nomem(subreq, req)) {
15071 return tevent_req_post(req, ev);
15072 }
15073 tevent_req_set_callback(subreq,
15074 smb1_negotiate_exit_done,
15075 req);
15076 return req;
15077 }
15078
15079 static void smb1_negotiate_exit_done(struct tevent_req *subreq)
15080 {
15081 struct tevent_req *req =
15082 tevent_req_callback_data(subreq,
15083 struct tevent_req);
15084 struct smb1_negotiate_exit_state *state =
15085 tevent_req_data(req,
15086 struct smb1_negotiate_exit_state);
15087 NTSTATUS status;
15088 struct smb1cli_req_expected_response expected[] = {
15089 {
15090 .status = NT_STATUS_OK,
15091 .wct = 0,
15092 },
15093 };
15094
15095 status = smb1cli_req_recv(subreq, state,
15096 NULL,
15097 NULL,
15098 NULL,
15099 NULL,
15100 NULL, /* pvwv_offset */
15101 NULL,
15102 NULL,
15103 NULL, /* pbytes_offset */
15104 NULL,
15105 expected, ARRAY_SIZE(expected));
15106 TALLOC_FREE(subreq);
15107 if (tevent_req_nterror(req, status)) {
15108 return;
15109 }
15110 tevent_req_done(req);
15111 }
15112
15113 static NTSTATUS smb1_negotiate_exit_recv(struct tevent_req *req)
15114 {
15115 return tevent_req_simple_recv_ntstatus(req);
15116 }
15117
15118 static bool do_smb1_exit(TALLOC_CTX *mem_ctx,
15119 struct tevent_context *ev,
15120 struct smbXcli_conn *conn)
15121 {
15122 struct tevent_req *req;
15123 bool ok;
15124 NTSTATUS status;
15125 NTSTATUS expected_status = NT_STATUS_DOS(ERRSRV, ERRinvnid);;
15126
15127 req = smb1_negotiate_exit_send(ev, ev, conn);
15128 if (req == NULL) {
15129 d_fprintf(stderr, "smb1_negotiate_exit_send failed\n");
15130 return false;
15131 }
15132
15133 ok = tevent_req_poll_ntstatus(req, ev, &status);
15134 if (!ok) {
15135 d_fprintf(stderr, "tevent_req_poll failed with status %s\n",
15136 nt_errstr(status));
15137 return false;
15138 }
15139
15140 status = smb1_negotiate_exit_recv(req);
15141 if (!NT_STATUS_EQUAL(status, expected_status)) {
15142 d_fprintf(stderr, "smb1_negotiate_exit_recv returned "
15143 "%s, expected ERRSRV, ERRinvnid\n",
15144 nt_errstr(status));
15145 return false;
15146 }
15147 return true;
15148 }
15149
15150 static bool run_smb1_negotiate_exit(int dummy)
15151 {
15152 struct tevent_context *ev;
15153 struct smbXcli_conn *conn;
15154 struct sockaddr_storage ss;
15155 NTSTATUS status;
15156 int fd;
15157 bool ok;
15158
15159 printf("Starting send SMB1 negotiate+exit.\n");
15160
15161 ok = resolve_name(host, &ss, 0x20, true);
15162 if (!ok) {
15163 d_fprintf(stderr, "Could not resolve name %s\n", host);
15164 return false;
15165 }
15166
15167 status = open_socket_out(&ss, 445, 10000, &fd);
15168 if (!NT_STATUS_IS_OK(status)) {
15169 d_fprintf(stderr, "open_socket_out failed: %s\n",
15170 nt_errstr(status));
15171 return false;
15172 }
15173
15174 conn = smbXcli_conn_create(talloc_tos(), fd, host, SMB_SIGNING_OFF, 0,
15175 NULL, 0, NULL);
15176 if (conn == NULL) {
15177 d_fprintf(stderr, "smbXcli_conn_create failed\n");
15178 return false;
15179 }
15180
15181 status = smbXcli_negprot(conn,
15182 0,
15183 PROTOCOL_NT1,
15184 PROTOCOL_NT1,
15185 NULL,
15186 NULL,
15187 NULL);
15188 if (!NT_STATUS_IS_OK(status)) {
15189 d_fprintf(stderr, "smbXcli_negprot failed!\n");
15190 return false;
15191 }
15192
15193 ev = samba_tevent_context_init(talloc_tos());
15194 if (ev == NULL) {
15195 d_fprintf(stderr, "samba_tevent_context_init failed\n");
15196 return false;
15197 }
15198
15199 /*
15200 * Call do_smb1_exit twice to catch a server crash, the
15201 * server sends the first return code then crashes.
15202 */
15203 ok = do_smb1_exit(ev, ev, conn);
15204 if (!ok) {
15205 d_fprintf(stderr, "do_smb1_exit (1) failed\n");
15206 return false;
15207 }
15208 ok = do_smb1_exit(ev, ev, conn);
15209 if (!ok) {
15210 d_fprintf(stderr, "do_smb1_exit (2) failed\n");
15211 return false;
15212 }
15213
15214 TALLOC_FREE(conn);
15215 return true;
15216 }
15217
15218 static bool run_smb1_negotiate_tcon(int dummy)
15219 {
15220 struct cli_state *cli = NULL;
15221 uint16_t cnum = 0;
15222 uint16_t max_xmit = 0;
15223 NTSTATUS status;
15224
15225 printf("Starting send SMB1 negotiate+tcon.\n");
15226 cli = open_nbt_connection();
15227 if (cli == NULL) {
15228 d_fprintf(stderr, "open_nbt_connection failed!\n");
15229 return false;
15230 }
15231 smbXcli_conn_set_sockopt(cli->conn, sockops);
15232
15233 status = smbXcli_negprot(cli->conn,
15234 0,
15235 PROTOCOL_NT1,
15236 PROTOCOL_NT1,
15237 NULL,
15238 NULL,
15239 NULL);
15240 if (!NT_STATUS_IS_OK(status)) {
15241 d_fprintf(stderr, "smbXcli_negprot failed %s!\n",
15242 nt_errstr(status));
15243 return false;
15244 }
15245 status = cli_raw_tcon(cli,
15246 share,
15247 "",
15248 "?????",
15249 &max_xmit,
15250 &cnum);
15251 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
15252 d_fprintf(stderr, "cli_raw_tcon failed - got %s "
15253 "(should get NT_STATUS_ACCESS_DENIED)!\n",
15254 nt_errstr(status));
15255 return false;
15256 }
15257 return true;
15258 }
15259
15260 static bool run_ign_bad_negprot(int dummy)
15261 {
15262 struct tevent_context *ev;
15263 struct tevent_req *req;
15264 struct smbXcli_conn *conn;
15265 struct sockaddr_storage ss;
15266 NTSTATUS status;
15267 int fd;
15268 bool ok;
15269
15270 printf("starting ignore bad negprot\n");
15271
15272 ok = resolve_name(host, &ss, 0x20, true);
15273 if (!ok) {
15274 d_fprintf(stderr, "Could not resolve name %s\n", host);
15275 return false;
15276 }
15277
15278 status = open_socket_out(&ss, 445, 10000, &fd);
15279 if (!NT_STATUS_IS_OK(status)) {
15280 d_fprintf(stderr, "open_socket_out failed: %s\n",
15281 nt_errstr(status));
15282 return false;
15283 }
15284
15285 conn = smbXcli_conn_create(talloc_tos(), fd, host, SMB_SIGNING_OFF, 0,
15286 NULL, 0, NULL);
15287 if (conn == NULL) {
15288 d_fprintf(stderr, "smbXcli_conn_create failed\n");
15289 return false;
15290 }
15291
15292 status = smbXcli_negprot(conn,
15293 0,
15294 PROTOCOL_CORE,
15295 PROTOCOL_CORE,
15296 NULL,
15297 NULL,
15298 NULL);
15299 if (NT_STATUS_IS_OK(status)) {
15300 d_fprintf(stderr, "smbXcli_negprot succeeded!\n");
15301 return false;
15302 }
15303
15304 ev = samba_tevent_context_init(talloc_tos());
15305 if (ev == NULL) {
15306 d_fprintf(stderr, "samba_tevent_context_init failed\n");
15307 return false;
15308 }
15309
15310 req = smb1cli_session_setup_nt1_send(
15311 ev, ev, conn, 0, getpid(), NULL, 65503, 2, 1, 0, "", "",
15312 data_blob_null, data_blob_null, 0x40,
15313 "Windows 2000 2195", "Windows 2000 5.0");
15314 if (req == NULL) {
15315 d_fprintf(stderr, "smb1cli_session_setup_nt1_send failed\n");
15316 return false;
15317 }
15318
15319 ok = tevent_req_poll_ntstatus(req, ev, &status);
15320 if (!ok) {
15321 d_fprintf(stderr, "tevent_req_poll failed\n");
15322 return false;
15323 }
15324
15325 status = smb1cli_session_setup_nt1_recv(req, NULL, NULL, NULL, NULL,
15326 NULL, NULL);
15327 if (!NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_RESET)) {
15328 d_fprintf(stderr, "smb1cli_session_setup_nt1_recv returned "
15329 "%s, expected NT_STATUS_CONNECTION_RESET\n",
15330 nt_errstr(status));
15331 return false;
15332 }
15333
15334 TALLOC_FREE(conn);
15335
15336 printf("starting ignore bad negprot\n");
15337
15338 return true;
15339 }
15340
15341
15342 static double create_procs(bool (*fn)(int), bool *result)
15343 {
15344 int i, status;
15345 volatile pid_t *child_status;
15346 volatile bool *child_status_out;
15347 int synccount;
15348 int tries = 8;
15349 struct timeval start;
15350
15351 synccount = 0;
15352
15353 child_status = (volatile pid_t *)anonymous_shared_allocate(sizeof(pid_t)*torture_nprocs);
15354 if (!child_status) {
15355 printf("Failed to setup shared memory\n");
15356 return -1;
15357 }
15358
15359 child_status_out = (volatile bool *)anonymous_shared_allocate(sizeof(bool)*torture_nprocs);
15360 if (!child_status_out) {
15361 printf("Failed to setup result status shared memory\n");
15362 return -1;
15363 }
15364
15365 for (i = 0; i < torture_nprocs; i++) {
15366 child_status[i] = 0;
15367 child_status_out[i] = True;
15368 }
15369
15370 start = timeval_current();
15371
15372 for (i=0;i<torture_nprocs;i++) {
15373 procnum = i;
15374 if (fork() == 0) {
15375 pid_t mypid = getpid();
15376 sys_srandom(((int)mypid) ^ ((int)time(NULL)));
15377
15378 slprintf(myname,sizeof(myname),"CLIENT%d", i);
15379
15380 while (1) {
15381 if (torture_open_connection(&current_cli, i)) break;
15382 if (tries-- == 0) {
15383 printf("pid %d failed to start\n", (int)getpid());
15384 _exit(1);
15385 }
15386 smb_msleep(10);
15387 }
15388
15389 child_status[i] = getpid();
15390
15391 while (child_status[i] && timeval_elapsed(&start) < 5) smb_msleep(2);
15392
15393 child_status_out[i] = fn(i);
15394 _exit(0);
15395 }
15396 }
15397
15398 do {
15399 synccount = 0;
15400 for (i=0;i<torture_nprocs;i++) {
15401 if (child_status[i]) synccount++;
15402 }
15403 if (synccount == torture_nprocs) break;
15404 smb_msleep(10);
15405 } while (timeval_elapsed(&start) < 30);
15406
15407 if (synccount != torture_nprocs) {
15408 printf("FAILED TO START %d CLIENTS (started %d)\n", torture_nprocs, synccount);
15409 *result = False;
15410 return timeval_elapsed(&start);
15411 }
15412
15413 /* start the client load */
15414 start = timeval_current();
15415
15416 for (i=0;i<torture_nprocs;i++) {
15417 child_status[i] = 0;
15418 }
15419
15420 printf("%d clients started\n", torture_nprocs);
15421
15422 for (i=0;i<torture_nprocs;i++) {
15423 while (waitpid(0, &status, 0) == -1 && errno == EINTR) /* noop */ ;
15424 }
15425
15426 printf("\n");
15427
15428 for (i=0;i<torture_nprocs;i++) {
15429 if (!child_status_out[i]) {
15430 *result = False;
15431 }
15432 }
15433 return timeval_elapsed(&start);
15434 }
15435
15436 #define FLAG_MULTIPROC 1
15437
15438 static struct {
15439 const char *name;
15440 bool (*fn)(int);
15441 unsigned flags;
15442 } torture_ops[] = {
15443 {
15444 .name = "FDPASS",
15445 .fn = run_fdpasstest,
15446 },
15447 {
15448 .name = "LOCK1",
15449 .fn = run_locktest1,
15450 },
15451 {
15452 .name = "LOCK2",
15453 .fn = run_locktest2,
15454 },
15455 {
15456 .name = "LOCK3",
15457 .fn = run_locktest3,
15458 },
15459 {
15460 .name = "LOCK4",
15461 .fn = run_locktest4,
15462 },
15463 {
15464 .name = "LOCK5",
15465 .fn = run_locktest5,
15466 },
15467 {
15468 .name = "LOCK6",
15469 .fn = run_locktest6,
15470 },
15471 {
15472 .name = "LOCK7",
15473 .fn = run_locktest7,
15474 },
15475 {
15476 .name = "LOCK8",
15477 .fn = run_locktest8,
15478 },
15479 {
15480 .name = "LOCK9A",
15481 .fn = run_locktest9a,
15482 },
15483 {
15484 .name = "LOCK9B",
15485 .fn = run_locktest9b,
15486 },
15487 {
15488 .name = "LOCK10",
15489 .fn = run_locktest10,
15490 },
15491 {
15492 .name = "LOCK11",
15493 .fn = run_locktest11,
15494 },
15495 {
15496 .name = "LOCK12",
15497 .fn = run_locktest12,
15498 },
15499 {
15500 .name = "LOCK13",
15501 .fn = run_locktest13,
15502 },
15503 {
15504 .name = "UNLINK",
15505 .fn = run_unlinktest,
15506 },
15507 {
15508 .name = "BROWSE",
15509 .fn = run_browsetest,
15510 },
15511 {
15512 .name = "ATTR",
15513 .fn = run_attrtest,
15514 },
15515 {
15516 .name = "TRANS2",
15517 .fn = run_trans2test,
15518 },
15519 {
15520 .name = "MAXFID",
15521 .fn = run_maxfidtest,
15522 .flags = FLAG_MULTIPROC,
15523 },
15524 {
15525 .name = "TORTURE",
15526 .fn = run_torture,
15527 .flags = FLAG_MULTIPROC,
15528 },
15529 {
15530 .name = "RANDOMIPC",
15531 .fn = run_randomipc,
15532 },
15533 {
15534 .name = "NEGNOWAIT",
15535 .fn = run_negprot_nowait,
15536 },
15537 {
15538 .name = "NBENCH",
15539 .fn = run_nbench,
15540 },
15541 {
15542 .name = "NBENCH2",
15543 .fn = run_nbench2,
15544 },
15545 {
15546 .name = "OPLOCK1",
15547 .fn = run_oplock1,
15548 },
15549 {
15550 .name = "OPLOCK2",
15551 .fn = run_oplock2,
15552 },
15553 {
15554 .name = "OPLOCK4",
15555 .fn = run_oplock4,
15556 },
15557 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
15558 {
15559 .name = "OPLOCK5",
15560 .fn = run_oplock5,
15561 },
15562 #endif
15563 {
15564 .name = "DIR",
15565 .fn = run_dirtest,
15566 },
15567 {
15568 .name = "DIR1",
15569 .fn = run_dirtest1,
15570 },
15571 {
15572 .name = "DIR-CREATETIME",
15573 .fn = run_dir_createtime,
15574 },
15575 {
15576 .name = "DENY1",
15577 .fn = torture_denytest1,
15578 },
15579 {
15580 .name = "DENY2",
15581 .fn = torture_denytest2,
15582 },
15583 {
15584 .name = "TCON",
15585 .fn = run_tcon_test,
15586 },
15587 {
15588 .name = "TCONDEV",
15589 .fn = run_tcon_devtype_test,
15590 },
15591 {
15592 .name = "RW1",
15593 .fn = run_readwritetest,
15594 },
15595 {
15596 .name = "RW2",
15597 .fn = run_readwritemulti,
15598 .flags = FLAG_MULTIPROC
15599 },
15600 {
15601 .name = "RW3",
15602 .fn = run_readwritelarge,
15603 },
15604 {
15605 .name = "RW-SIGNING",
15606 .fn = run_readwritelarge_signtest,
15607 },
15608 {
15609 .name = "OPEN",
15610 .fn = run_opentest,
15611 },
15612 {
15613 .name = "POSIX",
15614 .fn = run_simple_posix_open_test,
15615 },
15616 {
15617 .name = "POSIX-APPEND",
15618 .fn = run_posix_append,
15619 },
15620 {
15621 .name = "POSIX-SYMLINK-ACL",
15622 .fn = run_acl_symlink_test,
15623 },
15624 {
15625 .name = "POSIX-SYMLINK-EA",
15626 .fn = run_ea_symlink_test,
15627 },
15628 {
15629 .name = "POSIX-STREAM-DELETE",
15630 .fn = run_posix_stream_delete,
15631 },
15632 {
15633 .name = "POSIX-OFD-LOCK",
15634 .fn = run_posix_ofd_lock_test,
15635 },
15636 {
15637 .name = "POSIX-BLOCKING-LOCK",
15638 .fn = run_posix_blocking_lock,
15639 },
15640 {
15641 .name = "POSIX-MKDIR",
15642 .fn = run_posix_mkdir_test,
15643 },
15644 {
15645 .name = "POSIX-ACL-OPLOCK",
15646 .fn = run_posix_acl_oplock_test,
15647 },
15648 {
15649 .name = "POSIX-ACL-SHAREROOT",
15650 .fn = run_posix_acl_shareroot_test,
15651 },
15652 {
15653 .name = "POSIX-LS-WILDCARD",
15654 .fn = run_posix_ls_wildcard_test,
15655 },
15656 {
15657 .name = "POSIX-LS-SINGLE",
15658 .fn = run_posix_ls_single_test,
15659 },
15660 {
15661 .name = "POSIX-READLINK",
15662 .fn = run_posix_readlink_test,
15663 },
15664 {
15665 .name = "POSIX-STAT",
15666 .fn = run_posix_stat_test,
15667 },
15668 {
15669 .name = "POSIX-SYMLINK-PARENT",
15670 .fn = run_posix_symlink_parent_test,
15671 },
15672 {
15673 .name = "POSIX-SYMLINK-CHMOD",
15674 .fn = run_posix_symlink_chmod_test,
15675 },
15676 {
15677 .name = "POSIX-SYMLINK-RENAME",
15678 .fn = run_posix_symlink_rename_test,
15679 },
15680 {
15681 .name = "POSIX-DIR-DEFAULT-ACL",
15682 .fn = run_posix_dir_default_acl_test,
15683 },
15684 {
15685 .name = "POSIX-SYMLINK-GETPATHINFO",
15686 .fn = run_posix_symlink_getpathinfo_test,
15687 },
15688 {
15689 .name = "POSIX-SYMLINK-SETPATHINFO",
15690 .fn = run_posix_symlink_setpathinfo_test,
15691 },
15692 {
15693 .name = "WINDOWS-BAD-SYMLINK",
15694 .fn = run_symlink_open_test,
15695 },
15696 {
15697 .name = "SMB1-WILD-MANGLE-UNLINK",
15698 .fn = run_smb1_wild_mangle_unlink_test,
15699 },
15700 {
15701 .name = "SMB1-WILD-MANGLE-RENAME",
15702 .fn = run_smb1_wild_mangle_rename_test,
15703 },
15704 {
15705 .name = "CASE-INSENSITIVE-CREATE",
15706 .fn = run_case_insensitive_create,
15707 },
15708 {
15709 .name = "ASYNC-ECHO",
15710 .fn = run_async_echo,
15711 },
15712 {
15713 .name = "UID-REGRESSION-TEST",
15714 .fn = run_uid_regression_test,
15715 },
15716 {
15717 .name = "SHORTNAME-TEST",
15718 .fn = run_shortname_test,
15719 },
15720 {
15721 .name = "ADDRCHANGE",
15722 .fn = run_addrchange,
15723 },
15724 #if 1
15725 {
15726 .name = "OPENATTR",
15727 .fn = run_openattrtest,
15728 },
15729 #endif
15730 {
15731 .name = "XCOPY",
15732 .fn = run_xcopy,
15733 },
15734 {
15735 .name = "RENAME",
15736 .fn = run_rename,
15737 },
15738 {
15739 .name = "RENAME-ACCESS",
15740 .fn = run_rename_access,
15741 },
15742 {
15743 .name = "OWNER-RIGHTS",
15744 .fn = run_owner_rights,
15745 },
15746 {
15747 .name = "DELETE",
15748 .fn = run_deletetest,
15749 },
15750 {
15751 .name = "DELETE-STREAM",
15752 .fn = run_delete_stream,
15753 },
15754 {
15755 .name = "DELETE-PRINT",
15756 .fn = run_delete_print_test,
15757 },
15758 {
15759 .name = "DELETE-LN",
15760 .fn = run_deletetest_ln,
15761 },
15762 {
15763 .name = "PROPERTIES",
15764 .fn = run_properties,
15765 },
15766 {
15767 .name = "MANGLE",
15768 .fn = torture_mangle,
15769 },
15770 {
15771 .name = "MANGLE1",
15772 .fn = run_mangle1,
15773 },
15774 {
15775 .name = "MANGLE-ILLEGAL",
15776 .fn = run_mangle_illegal,
15777 },
15778 {
15779 .name = "W2K",
15780 .fn = run_w2ktest,
15781 },
15782 {
15783 .name = "TRANS2SCAN",
15784 .fn = torture_trans2_scan,
15785 },
15786 {
15787 .name = "NTTRANSSCAN",
15788 .fn = torture_nttrans_scan,
15789 },
15790 {
15791 .name = "UTABLE",
15792 .fn = torture_utable,
15793 },
15794 {
15795 .name = "CASETABLE",
15796 .fn = torture_casetable,
15797 },
15798 {
15799 .name = "ERRMAPEXTRACT",
15800 .fn = run_error_map_extract,
15801 },
15802 {
15803 .name = "PIPE_NUMBER",
15804 .fn = run_pipe_number,
15805 },
15806 {
15807 .name = "TCON2",
15808 .fn = run_tcon2_test,
15809 },
15810 {
15811 .name = "IOCTL",
15812 .fn = torture_ioctl_test,
15813 },
15814 {
15815 .name = "CHKPATH",
15816 .fn = torture_chkpath_test,
15817 },
15818 {
15819 .name = "FDSESS",
15820 .fn = run_fdsesstest,
15821 },
15822 {
15823 .name = "EATEST",
15824 .fn = run_eatest,
15825 },
15826 {
15827 .name = "SESSSETUP_BENCH",
15828 .fn = run_sesssetup_bench,
15829 },
15830 {
15831 .name = "CHAIN1",
15832 .fn = run_chain1,
15833 },
15834 {
15835 .name = "CHAIN2",
15836 .fn = run_chain2,
15837 },
15838 {
15839 .name = "CHAIN3",
15840 .fn = run_chain3,
15841 },
15842 {
15843 .name = "WINDOWS-WRITE",
15844 .fn = run_windows_write,
15845 },
15846 {
15847 .name = "LARGE_READX",
15848 .fn = run_large_readx,
15849 },
15850 {
15851 .name = "MSDFS-ATTRIBUTE",
15852 .fn = run_msdfs_attribute,
15853 },
15854 {
15855 .name = "NTTRANS-CREATE",
15856 .fn = run_nttrans_create,
15857 },
15858 {
15859 .name = "NTTRANS-FSCTL",
15860 .fn = run_nttrans_fsctl,
15861 },
15862 {
15863 .name = "CLI_ECHO",
15864 .fn = run_cli_echo,
15865 },
15866 {
15867 .name = "CLI_SPLICE",
15868 .fn = run_cli_splice,
15869 },
15870 {
15871 .name = "TLDAP",
15872 .fn = run_tldap,
15873 },
15874 {
15875 .name = "STREAMERROR",
15876 .fn = run_streamerror,
15877 },
15878 {
15879 .name = "NOTIFY-BENCH",
15880 .fn = run_notify_bench,
15881 },
15882 {
15883 .name = "NOTIFY-BENCH2",
15884 .fn = run_notify_bench2,
15885 },
15886 {
15887 .name = "NOTIFY-BENCH3",
15888 .fn = run_notify_bench3,
15889 },
15890 {
15891 .name = "BAD-NBT-SESSION",
15892 .fn = run_bad_nbt_session,
15893 },
15894 {
15895 .name = "IGN-BAD-NEGPROT",
15896 .fn = run_ign_bad_negprot,
15897 },
15898 {
15899 .name = "SMB-ANY-CONNECT",
15900 .fn = run_smb_any_connect,
15901 },
15902 {
15903 .name = "NOTIFY-ONLINE",
15904 .fn = run_notify_online,
15905 },
15906 {
15907 .name = "SMB2-BASIC",
15908 .fn = run_smb2_basic,
15909 },
15910 {
15911 .name = "SMB2-NEGPROT",
15912 .fn = run_smb2_negprot,
15913 },
15914 {
15915 .name = "SMB2-ANONYMOUS",
15916 .fn = run_smb2_anonymous,
15917 },
15918 {
15919 .name = "SMB2-SESSION-RECONNECT",
15920 .fn = run_smb2_session_reconnect,
15921 },
15922 {
15923 .name = "SMB2-TCON-DEPENDENCE",
15924 .fn = run_smb2_tcon_dependence,
15925 },
15926 {
15927 .name = "SMB2-MULTI-CHANNEL",
15928 .fn = run_smb2_multi_channel,
15929 },
15930 {
15931 .name = "SMB2-SESSION-REAUTH",
15932 .fn = run_smb2_session_reauth,
15933 },
15934 {
15935 .name = "SMB2-FTRUNCATE",
15936 .fn = run_smb2_ftruncate,
15937 },
15938 {
15939 .name = "SMB2-DIR-FSYNC",
15940 .fn = run_smb2_dir_fsync,
15941 },
15942 {
15943 .name = "SMB2-PATH-SLASH",
15944 .fn = run_smb2_path_slash,
15945 },
15946 {
15947 .name = "SMB1-SYSTEM-SECURITY",
15948 .fn = run_smb1_system_security,
15949 },
15950 {
15951 .name = "SMB2-SACL",
15952 .fn = run_smb2_sacl,
15953 },
15954 {
15955 .name = "SMB2-QUOTA1",
15956 .fn = run_smb2_quota1,
15957 },
15958 {
15959 .name = "SMB2-INVALID-PIPENAME",
15960 .fn = run_smb2_invalid_pipename,
15961 },
15962 {
15963 .name = "SMB2-STREAM-ACL",
15964 .fn = run_smb2_stream_acl,
15965 },
15966 {
15967 .name = "SMB2-LIST-DIR-ASYNC",
15968 .fn = run_list_dir_async_test,
15969 },
15970 {
15971 .name = "SMB2-DEL-ON-CLOSE-NONEMPTY",
15972 .fn = run_delete_on_close_non_empty,
15973 },
15974 {
15975 .name = "SMB2-DEL-ON-CLOSE-NONWRITE-DELETE-YES",
15976 .fn = run_delete_on_close_nonwrite_delete_yes_test,
15977 },
15978 {
15979 .name = "SMB2-DEL-ON-CLOSE-NONWRITE-DELETE-NO",
15980 .fn = run_delete_on_close_nonwrite_delete_no_test,
15981 },
15982 {
15983 .name = "SMB2-DFS-PATHS",
15984 .fn = run_smb2_dfs_paths,
15985 },
15986 {
15987 .name = "SMB2-NON-DFS-SHARE",
15988 .fn = run_smb2_non_dfs_share,
15989 },
15990 {
15991 .name = "SMB2-DFS-SHARE-NON-DFS-PATH",
15992 .fn = run_smb2_dfs_share_non_dfs_path,
15993 },
15994 {
15995 .name = "SMB2-DFS-FILENAME-LEADING-BACKSLASH",
15996 .fn = run_smb2_dfs_filename_leading_backslash,
15997 },
15998 {
15999 .name = "SMB2-PIPE-READ-ASYNC-DISCONNECT",
16000 .fn = run_smb2_pipe_read_async_disconnect,
16001 },
16002 {
16003 .name = "SMB1-TRUNCATED-SESSSETUP",
16004 .fn = run_smb1_truncated_sesssetup,
16005 },
16006 {
16007 .name = "SMB1-NEGOTIATE-EXIT",
16008 .fn = run_smb1_negotiate_exit,
16009 },
16010 {
16011 .name = "SMB1-NEGOTIATE-TCON",
16012 .fn = run_smb1_negotiate_tcon,
16013 },
16014 {
16015 .name = "SMB1-DFS-PATHS",
16016 .fn = run_smb1_dfs_paths,
16017 },
16018 {
16019 .name = "SMB1-DFS-SEARCH-PATHS",
16020 .fn = run_smb1_dfs_search_paths,
16021 },
16022 {
16023 .name = "SMB1-DFS-OPERATIONS",
16024 .fn = run_smb1_dfs_operations,
16025 },
16026 {
16027 .name = "SMB1-DFS-BADPATH",
16028 .fn = run_smb1_dfs_check_badpath,
16029 },
16030 {
16031 .name = "CLEANUP1",
16032 .fn = run_cleanup1,
16033 },
16034 {
16035 .name = "CLEANUP2",
16036 .fn = run_cleanup2,
16037 },
16038 {
16039 .name = "CLEANUP4",
16040 .fn = run_cleanup4,
16041 },
16042 {
16043 .name = "OPLOCK-CANCEL",
16044 .fn = run_oplock_cancel,
16045 },
16046 {
16047 .name = "PIDHIGH",
16048 .fn = run_pidhigh,
16049 },
16050 {
16051 .name = "LOCAL-SUBSTITUTE",
16052 .fn = run_local_substitute,
16053 },
16054 {
16055 .name = "LOCAL-GENCACHE",
16056 .fn = run_local_gencache,
16057 },
16058 {
16059 .name = "LOCAL-DBWRAP-WATCH1",
16060 .fn = run_dbwrap_watch1,
16061 },
16062 {
16063 .name = "LOCAL-DBWRAP-WATCH2",
16064 .fn = run_dbwrap_watch2,
16065 },
16066 {
16067 .name = "LOCAL-DBWRAP-WATCH3",
16068 .fn = run_dbwrap_watch3,
16069 },
16070 {
16071 .name = "LOCAL-DBWRAP-WATCH4",
16072 .fn = run_dbwrap_watch4,
16073 },
16074 {
16075 .name = "LOCAL-DBWRAP-DO-LOCKED1",
16076 .fn = run_dbwrap_do_locked1,
16077 },
16078 {
16079 .name = "LOCAL-MESSAGING-READ1",
16080 .fn = run_messaging_read1,
16081 },
16082 {
16083 .name = "LOCAL-MESSAGING-READ2",
16084 .fn = run_messaging_read2,
16085 },
16086 {
16087 .name = "LOCAL-MESSAGING-READ3",
16088 .fn = run_messaging_read3,
16089 },
16090 {
16091 .name = "LOCAL-MESSAGING-READ4",
16092 .fn = run_messaging_read4,
16093 },
16094 {
16095 .name = "LOCAL-MESSAGING-FDPASS1",
16096 .fn = run_messaging_fdpass1,
16097 },
16098 {
16099 .name = "LOCAL-MESSAGING-FDPASS2",
16100 .fn = run_messaging_fdpass2,
16101 },
16102 {
16103 .name = "LOCAL-MESSAGING-FDPASS2a",
16104 .fn = run_messaging_fdpass2a,
16105 },
16106 {
16107 .name = "LOCAL-MESSAGING-FDPASS2b",
16108 .fn = run_messaging_fdpass2b,
16109 },
16110 {
16111 .name = "LOCAL-MESSAGING-SEND-ALL",
16112 .fn = run_messaging_send_all,
16113 },
16114 {
16115 .name = "LOCAL-BASE64",
16116 .fn = run_local_base64,
16117 },
16118 {
16119 .name = "LOCAL-RBTREE",
16120 .fn = run_local_rbtree,
16121 },
16122 {
16123 .name = "LOCAL-MEMCACHE",
16124 .fn = run_local_memcache,
16125 },
16126 {
16127 .name = "LOCAL-STREAM-NAME",
16128 .fn = run_local_stream_name,
16129 },
16130 {
16131 .name = "LOCAL-STR-MATCH-MSWILD",
16132 .fn = run_str_match_mswild,
16133 },
16134 {
16135 .name = "LOCAL-STR-MATCH-REGEX-SUB1",
16136 .fn = run_str_match_regex_sub1,
16137 },
16138 {
16139 .name = "WBCLIENT-MULTI-PING",
16140 .fn = run_wbclient_multi_ping,
16141 },
16142 {
16143 .name = "LOCAL-string_to_sid",
16144 .fn = run_local_string_to_sid,
16145 },
16146 {
16147 .name = "LOCAL-sid_to_string",
16148 .fn = run_local_sid_to_string,
16149 },
16150 {
16151 .name = "LOCAL-binary_to_sid",
16152 .fn = run_local_binary_to_sid,
16153 },
16154 {
16155 .name = "LOCAL-DBTRANS",
16156 .fn = run_local_dbtrans,
16157 },
16158 {
16159 .name = "LOCAL-TEVENT-POLL",
16160 .fn = run_local_tevent_poll,
16161 },
16162 {
16163 .name = "LOCAL-CONVERT-STRING",
16164 .fn = run_local_convert_string,
16165 },
16166 {
16167 .name = "LOCAL-CONV-AUTH-INFO",
16168 .fn = run_local_conv_auth_info,
16169 },
16170 {
16171 .name = "LOCAL-hex_encode_buf",
16172 .fn = run_local_hex_encode_buf,
16173 },
16174 {
16175 .name = "LOCAL-IDMAP-TDB-COMMON",
16176 .fn = run_idmap_tdb_common_test,
16177 },
16178 {
16179 .name = "LOCAL-remove_duplicate_addrs2",
16180 .fn = run_local_remove_duplicate_addrs2,
16181 },
16182 {
16183 .name = "local-tdb-opener",
16184 .fn = run_local_tdb_opener,
16185 },
16186 {
16187 .name = "local-tdb-writer",
16188 .fn = run_local_tdb_writer,
16189 },
16190 {
16191 .name = "LOCAL-DBWRAP-CTDB1",
16192 .fn = run_local_dbwrap_ctdb1,
16193 },
16194 {
16195 .name = "LOCAL-BENCH-PTHREADPOOL",
16196 .fn = run_bench_pthreadpool,
16197 },
16198 {
16199 .name = "LOCAL-PTHREADPOOL-TEVENT",
16200 .fn = run_pthreadpool_tevent,
16201 },
16202 {
16203 .name = "LOCAL-G-LOCK1",
16204 .fn = run_g_lock1,
16205 },
16206 {
16207 .name = "LOCAL-G-LOCK2",
16208 .fn = run_g_lock2,
16209 },
16210 {
16211 .name = "LOCAL-G-LOCK3",
16212 .fn = run_g_lock3,
16213 },
16214 {
16215 .name = "LOCAL-G-LOCK4",
16216 .fn = run_g_lock4,
16217 },
16218 {
16219 .name = "LOCAL-G-LOCK4A",
16220 .fn = run_g_lock4a,
16221 },
16222 {
16223 .name = "LOCAL-G-LOCK5",
16224 .fn = run_g_lock5,
16225 },
16226 {
16227 .name = "LOCAL-G-LOCK6",
16228 .fn = run_g_lock6,
16229 },
16230 {
16231 .name = "LOCAL-G-LOCK7",
16232 .fn = run_g_lock7,
16233 },
16234 {
16235 .name = "LOCAL-G-LOCK8",
16236 .fn = run_g_lock8,
16237 },
16238 {
16239 .name = "LOCAL-G-LOCK-PING-PONG",
16240 .fn = run_g_lock_ping_pong,
16241 },
16242 {
16243 .name = "LOCAL-CANONICALIZE-PATH",
16244 .fn = run_local_canonicalize_path,
16245 },
16246 {
16247 .name = "LOCAL-NAMEMAP-CACHE1",
16248 .fn = run_local_namemap_cache1,
16249 },
16250 {
16251 .name = "LOCAL-IDMAP-CACHE1",
16252 .fn = run_local_idmap_cache1,
16253 },
16254 {
16255 .name = "qpathinfo-bufsize",
16256 .fn = run_qpathinfo_bufsize,
16257 },
16258 {
16259 .name = "hide-new-files-timeout",
16260 .fn = run_hidenewfiles,
16261 },
16262 {
16263 .name = "hide-new-files-timeout-showdirs",
16264 .fn = run_hidenewfiles_showdirs,
16265 },
16266 #ifdef CLUSTER_SUPPORT
16267 {
16268 .name = "ctdbd-conn1",
16269 .fn = run_ctdbd_conn1,
16270 },
16271 #endif
16272 {
16273 .name = "readdir-timestamp",
16274 .fn = run_readdir_timestamp,
16275 },
16276 {
16277 .name = "rpc-scale",
16278 .fn = run_rpc_scale,
16279 },
16280 {
16281 .name = "LOCAL-TDB-VALIDATE",
16282 .fn = run_tdb_validate,
16283 },
16284 {
16285 .name = NULL,
16286 },
16287 };
16288
16289 /****************************************************************************
16290 run a specified test or "ALL"
16291 ****************************************************************************/
16292 static bool run_test(const char *name)
16293 {
16294 bool ret = True;
16295 bool result = True;
16296 bool found = False;
16297 int i;
16298 double t;
16299 if (strequal(name,"ALL")) {
16300 for (i=0;torture_ops[i].name;i++) {
16301 run_test(torture_ops[i].name);
16302 }
16303 found = True;
16304 }
16305
16306 for (i=0;torture_ops[i].name;i++) {
16307 fstr_sprintf(randomfname, "\\XX%x",
16308 (unsigned)random());
16309
16310 if (strequal(name, torture_ops[i].name)) {
16311 found = True;
16312 printf("Running %s\n", name);
16313 if (torture_ops[i].flags & FLAG_MULTIPROC) {
16314 t = create_procs(torture_ops[i].fn, &result);
16315 if (!result) {
16316 ret = False;
16317 printf("TEST %s FAILED!\n", name);
16318 }
16319 } else {
16320 struct timeval start;
16321 start = timeval_current();
16322 if (!torture_ops[i].fn(0)) {
16323 ret = False;
16324 printf("TEST %s FAILED!\n", name);
16325 }
16326 t = timeval_elapsed(&start);
16327 }
16328 printf("%s took %g secs\n\n", name, t);
16329 }
16330 }
16331
16332 if (!found) {
16333 printf("Did not find a test named %s\n", name);
16334 ret = False;
16335 }
16336
16337 return ret;
16338 }
16339
16340
16341 static void usage(void)
16342 {
16343 int i;
16344
16345 printf("WARNING samba4 test suite is much more complete nowadays.\n");
16346 printf("Please use samba4 torture.\n\n");
16347
16348 printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
16349
16350 printf("\t-d debuglevel\n");
16351 printf("\t-U user%%pass\n");
16352 printf("\t-k use kerberos\n");
16353 printf("\t-N numprocs\n");
16354 printf("\t-n my_netbios_name\n");
16355 printf("\t-W workgroup\n");
16356 printf("\t-o num_operations\n");
16357 printf("\t-O socket_options\n");
16358 printf("\t-m maximum protocol\n");
16359 printf("\t-L use oplocks\n");
16360 printf("\t-c CLIENT.TXT specify client load file for NBENCH\n");
16361 printf("\t-A showall\n");
16362 printf("\t-p port\n");
16363 printf("\t-s seed\n");
16364 printf("\t-b unclist_filename specify multiple shares for multiple connections\n");
16365 printf("\t-f filename filename to test\n");
16366 printf("\t-e encrypt\n");
16367 printf("\t-T 'OPTION=VALUE' smb.conf option line\n");
16368 printf("\n\n");
16369
16370 printf("tests are:");
16371 for (i=0;torture_ops[i].name;i++) {
16372 printf(" %s", torture_ops[i].name);
16373 }
16374 printf("\n");
16375
16376 printf("default test is ALL\n");
16377
16378 exit(1);
16379 }
16380
16381 /****************************************************************************
16382 main program
16383 ****************************************************************************/
16384 int main(int argc,char *argv[])
16385 {
16386 int opt, i;
16387 char *p;
16388 int gotuser = 0;
16389 int gotpass = 0;
16390 bool correct = True;
16391 TALLOC_CTX *frame = talloc_stackframe();
16392 int seed = time(NULL);
16393 struct loadparm_context *lp_ctx = NULL;
16394
16395 #ifdef HAVE_SETBUFFER
16396 setbuffer(stdout, NULL, 0);
16397 #endif
16398
16399 setup_logging("smbtorture", DEBUG_STDOUT);
16400
16401 smb_init_locale();
16402 fault_setup();
16403
16404 lp_ctx = loadparm_init_s3(frame, loadparm_s3_helpers());
16405 if (lp_ctx == NULL) {
16406 fprintf(stderr,
16407 "Failed to initialise the global parameter structure.\n");
16408 return 1;
16409 }
16410
16411 if (is_default_dyn_CONFIGFILE()) {
16412 if(getenv("SMB_CONF_PATH")) {
16413 set_dyn_CONFIGFILE(getenv("SMB_CONF_PATH"));
16414 }
16415 }
16416 lp_load_global(get_dyn_CONFIGFILE());
16417 load_interfaces();
16418
16419 if (argc < 2) {
16420 usage();
16421 }
16422
16423 for(p = argv[1]; *p; p++)
16424 if(*p == '\\')
16425 *p = '/';
16426
16427 if (strncmp(argv[1], "//", 2)) {
16428 usage();
16429 }
16430
16431 fstrcpy(host, &argv[1][2]);
16432 p = strchr_m(&host[2],'/');
16433 if (!p) {
16434 usage();
16435 }
16436 *p = 0;
16437 fstrcpy(share, p+1);
16438
16439 fstrcpy(myname, get_myname(talloc_tos()));
16440 if (!*myname) {
16441 fprintf(stderr, "Failed to get my hostname.\n");
16442 return 1;
16443 }
16444
16445 if (*username == 0 && getenv("LOGNAME")) {
16446 fstrcpy(username,getenv("LOGNAME"));
16447 }
16448
16449 argc--;
16450 argv++;
16451
16452 fstrcpy(workgroup, lp_workgroup());
16453
16454 while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ll:d:Aec:ks:b:B:f:T:"))
16455 != EOF) {
16456 switch (opt) {
16457 case 'p':
16458 port_to_use = atoi(optarg);
16459 break;
16460 case 's':
16461 seed = atoi(optarg);
16462 break;
16463 case 'W':
16464 fstrcpy(workgroup,optarg);
16465 break;
16466 case 'm':
16467 lpcfg_set_cmdline(lp_ctx, "client max protocol", optarg);
16468 break;
16469 case 'N':
16470 torture_nprocs = atoi(optarg);
16471 break;
16472 case 'o':
16473 torture_numops = atoi(optarg);
16474 break;
16475 case 'd':
16476 lpcfg_set_cmdline(lp_ctx, "log level", optarg);
16477 break;
16478 case 'O':
16479 sockops = optarg;
16480 break;
16481 case 'L':
16482 use_oplocks = True;
16483 break;
16484 case 'l':
16485 local_path = optarg;
16486 break;
16487 case 'A':
16488 torture_showall = True;
16489 break;
16490 case 'n':
16491 fstrcpy(myname, optarg);
16492 break;
16493 case 'c':
16494 client_txt = optarg;
16495 break;
16496 case 'e':
16497 do_encrypt = true;
16498 break;
16499 case 'k':
16500 #ifdef HAVE_KRB5
16501 use_kerberos = True;
16502 #else
16503 d_printf("No kerberos support compiled in\n");
16504 exit(1);
16505 #endif
16506 break;
16507 case 'U':
16508 gotuser = 1;
16509 fstrcpy(username,optarg);
16510 p = strchr_m(username,'%');
16511 if (p) {
16512 *p = 0;
16513 fstrcpy(password, p+1);
16514 gotpass = 1;
16515 }
16516 break;
16517 case 'b':
16518 fstrcpy(multishare_conn_fname, optarg);
16519 use_multishare_conn = True;
16520 break;
16521 case 'B':
16522 torture_blocksize = atoi(optarg);
16523 break;
16524 case 'f':
16525 test_filename = SMB_STRDUP(optarg);
16526 break;
16527 case 'T':
16528 lpcfg_set_option(lp_ctx, optarg);
16529 break;
16530 default:
16531 printf("Unknown option %c (%d)\n", (char)opt, opt);
16532 usage();
16533 }
16534 }
16535
16536 d_printf("using seed %d\n", seed);
16537
16538 srandom(seed);
16539
16540 if(use_kerberos && !gotuser) gotpass = True;
16541
16542 while (!gotpass) {
16543 char pwd[256] = {0};
16544 int rc;
16545
16546 rc = samba_getpass("Password:", pwd, sizeof(pwd), false, false);
16547 if (rc == 0) {
16548 fstrcpy(password, pwd);
16549 gotpass = 1;
16550 }
16551 }
16552
16553 reopen_logs();
16554
16555 printf("host=%s share=%s user=%s myname=%s\n",
16556 host, share, username, myname);
16557
16558 torture_creds = cli_session_creds_init(frame,
16559 username,
16560 workgroup,
16561 NULL, /* realm */
16562 password,
16563 use_kerberos,
16564 false, /* fallback_after_kerberos */
16565 false, /* use_ccache */
16566 false); /* password_is_nt_hash */
16567 if (torture_creds == NULL) {
16568 d_printf("cli_session_creds_init() failed.\n");
16569 exit(1);
16570 }
16571
16572 if (argc == optind) {
16573 correct = run_test("ALL");
16574 } else {
16575 for (i=optind;i<argc;i++) {
16576 if (!run_test(argv[i])) {
16577 correct = False;
16578 }
16579 }
16580 }
16581
16582 TALLOC_FREE(frame);
16583
16584 if (correct) {
16585 return(0);
16586 } else {
16587 return(1);
16588 }
16589 }
GSS-enabled samba4