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