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