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