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