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