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